From 64636a0f55d1b2e62764aa3a50d8929765bdbda0 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Wed, 13 May 2026 17:01:08 -0600
Subject: [PATCH 001/136] Regenerate doc tests and prune stale generated files

---
 python/quantum-pecos/tests/docs/conftest.py   |  2 +-
 .../user_guide_circuit_representation.rs      |  2 +-
 scripts/docs/generate_doc_tests.py            | 19 +++++++++++++++++--
 3 files changed, 19 insertions(+), 4 deletions(-)

diff --git a/python/quantum-pecos/tests/docs/conftest.py b/python/quantum-pecos/tests/docs/conftest.py
index 7a5ed3ca1..9e59c51aa 100644
--- a/python/quantum-pecos/tests/docs/conftest.py
+++ b/python/quantum-pecos/tests/docs/conftest.py
@@ -21,7 +21,7 @@ def _check_cuda_available() -> bool:
     # Check for CUDA toolkit using pecos CLI (same as Justfile pattern)
     try:
         result = subprocess.run(
-            ["cargo", "run", "-p", "pecos", "--features", "cli", "--", "cuda", "check", "-q"],
+            ["cargo", "run", "-p", "pecos-cli", "--quiet", "--", "cuda", "check", "-q"],
             capture_output=True,
             timeout=30,
             check=False,
diff --git a/python/quantum-pecos/tests/docs/rust_crate/tests/user_guide_circuit_representation.rs b/python/quantum-pecos/tests/docs/rust_crate/tests/user_guide_circuit_representation.rs
index 4862d6ab2..142bf145d 100644
--- a/python/quantum-pecos/tests/docs/rust_crate/tests/user_guide_circuit_representation.rs
+++ b/python/quantum-pecos/tests/docs/rust_crate/tests/user_guide_circuit_representation.rs
@@ -8,7 +8,7 @@ fn test_user_guide_circuit_representation_rust_1() {
     use pecos::core::{Gate, QubitId};
     use pecos::dag::DAG;
     use pecos::digraph::DiGraph;
-    use pecos::quantum::{Attribute, DagCircuit, TickCircuit, TickGateError};
+    use pecos::quantum::{Attribute, DagCircuit, TickCircuit};
 
 // Fluent builder API
 let mut circuit = DagCircuit::new();
diff --git a/scripts/docs/generate_doc_tests.py b/scripts/docs/generate_doc_tests.py
index d716c37af..d593e9d22 100755
--- a/scripts/docs/generate_doc_tests.py
+++ b/scripts/docs/generate_doc_tests.py
@@ -864,7 +864,7 @@ def generate_test_file(file_path: Path, blocks: list[CodeBlock]) -> str:
                 "",
                 "    try:",
                 "        result = subprocess.run(",
-                '            ["cargo", "run", "-p", "pecos", "--features", "cli",',
+                '            ["cargo", "run", "-p", "pecos-cli", "--quiet",',
                 '             "--", "cuda", "check", "-q"],',
                 "            capture_output=True, timeout=30, check=False,",
                 "        )",
@@ -957,7 +957,7 @@ def _check_cuda_available() -> bool:
     # Check for CUDA toolkit using pecos CLI (same as Justfile pattern)
     try:
         result = subprocess.run(
-            ["cargo", "run", "-p", "pecos", "--features", "cli", "--", "cuda", "check", "-q"],
+            ["cargo", "run", "-p", "pecos-cli", "--quiet", "--", "cuda", "check", "-q"],
             capture_output=True,
             timeout=30,
             check=False,
@@ -1316,6 +1316,7 @@ def main() -> None:
     total_rust_blocks = 0
     total_skipped = 0
     files_generated = 0
+    generated_paths: set[Path] = set()
 
     for md_file in markdown_files:
         # Extract Python and Rust blocks
@@ -1373,10 +1374,22 @@ def main() -> None:
                 init_file.write_text('"""Auto-generated doc test package."""\n')
             output_path.write_text(test_content)
             files_generated += 1
+            generated_paths.add(output_path.resolve())
             print(
                 f"Generated: {output_path} ({len(python_blocks)} Python, {len(rust_blocks)} Rust blocks)",
             )
 
+    # Prune stale auto-generated test files whose source markdown was deleted
+    # or now skips every block. Only touch files matching `test_*.py` under the
+    # output dir so __init__.py, conftest.py, and __pycache__ are left alone.
+    stale_removed = 0
+    if not args.dry_run and args.output_dir.exists():
+        for stale in args.output_dir.rglob("test_*.py"):
+            if stale.resolve() not in generated_paths:
+                stale.unlink()
+                stale_removed += 1
+                print(f"Removed stale: {stale}")
+
     # Generate unified Rust test crate
     if not args.dry_run:
         rust_crate_dir = args.output_dir.parent / "rust_crate"
@@ -1389,6 +1402,8 @@ def main() -> None:
     print(f"  Total code blocks: {total_python_blocks + total_rust_blocks}")
     print(f"  Blocks with skip markers: {total_skipped}")
     print(f"  Test files generated: {files_generated}")
+    if stale_removed:
+        print(f"  Stale test files removed: {stale_removed}")
     print(f"\nRun tests with: pytest {args.output_dir} -v")
     print(f"Run Rust doc tests: cargo test --manifest-path {rust_crate_dir}/Cargo.toml")
 

From 0f58884e66b0f16d6e18ba30817d59f414a100e9 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Wed, 13 May 2026 17:01:12 -0600
Subject: [PATCH 002/136] Auto-include CUDA Python packages when toolkit and
 NVIDIA GPU detected

---
 Justfile                               | 10 ++++-
 crates/pecos-cli/src/cli.rs            |  8 +++-
 crates/pecos-cli/src/cli/cuda_cmd.rs   | 52 ++++++++++++++++++++++----
 crates/pecos-cli/src/cli/python_cmd.rs | 30 ++++++++++++++-
 crates/pecos-cli/src/cli/setup_cmd.rs  | 37 ++++++++++++++++++
 5 files changed, 125 insertions(+), 12 deletions(-)

diff --git a/Justfile b/Justfile
index 8f1977165..868d444c8 100644
--- a/Justfile
+++ b/Justfile
@@ -519,7 +519,15 @@ sync-deps:
         exit 0
     fi
     echo "Python deps incomplete, running uv sync..."
-    uv sync --project . --all-packages
+    SYNC_ARGS=(--project . --all-packages)
+    # Include CUDA Python packages (cupy, cuquantum, pytket-cutensornet) when
+    # the toolkit is installed AND an NVIDIA GPU is present. Pure Rust users
+    # and machines without a GPU skip this -- mirrors `pecos python build`.
+    if {{pecos}} cuda check -q 2>/dev/null && nvidia-smi -L 2>/dev/null | grep -q "^GPU "; then
+        echo "CUDA toolkit + NVIDIA GPU detected -- including CUDA Python packages"
+        SYNC_ARGS+=(--group cuda)
+    fi
+    uv sync "${SYNC_ARGS[@]}"
 
 [private]
 build-selene:
diff --git a/crates/pecos-cli/src/cli.rs b/crates/pecos-cli/src/cli.rs
index b7154f28a..46a0c64e1 100644
--- a/crates/pecos-cli/src/cli.rs
+++ b/crates/pecos-cli/src/cli.rs
@@ -72,9 +72,13 @@ pub enum PythonCommands {
         #[arg(long)]
         rustflags: Option<String>,
 
-        /// Build with CUDA support
-        #[arg(long)]
+        /// Force CUDA support on (overrides auto-detection)
+        #[arg(long, conflicts_with = "no_cuda")]
         cuda: bool,
+
+        /// Force CUDA support off (overrides auto-detection)
+        #[arg(long = "no-cuda")]
+        no_cuda: bool,
     },
 }
 
diff --git a/crates/pecos-cli/src/cli/cuda_cmd.rs b/crates/pecos-cli/src/cli/cuda_cmd.rs
index 0124be08f..f713fdb56 100644
--- a/crates/pecos-cli/src/cli/cuda_cmd.rs
+++ b/crates/pecos-cli/src/cli/cuda_cmd.rs
@@ -1,11 +1,40 @@
 //! Implementation of the `cuda` subcommand
 
+use std::process::Command;
+
 use pecos_build::Result;
 use pecos_build::cuda::{
     find_cuda, get_cuda_version, get_pecos_cuda_dir, is_valid_cuda_installation,
 };
 use pecos_build::errors::Error;
 
+/// Check whether an NVIDIA GPU is present and accessible via the driver.
+///
+/// Used to decide whether to install Python CUDA packages (cupy, cuquantum,
+/// pytket-cutensornet) alongside the toolkit. We only auto-include them when
+/// both the toolkit and a usable GPU are present, so build/CI machines with
+/// just the toolkit don't pull large GPU-only wheels they can't use.
+///
+/// Note: distinct from `probe_gpu_availability()` in `rust_cmd.rs`, which
+/// uses wgpu and matches any adapter (NVIDIA, AMD, Intel, Apple). cupy needs
+/// NVIDIA specifically.
+pub(super) fn has_nvidia_gpu() -> bool {
+    let Ok(output) = Command::new("nvidia-smi").arg("-L").output() else {
+        return false;
+    };
+    output.status.success()
+        && String::from_utf8_lossy(&output.stdout)
+            .lines()
+            .any(|line| line.starts_with("GPU "))
+}
+
+/// Whether Python CUDA packages should be auto-included for this machine.
+///
+/// True iff the CUDA toolkit is installed and an NVIDIA GPU is detected.
+pub(super) fn should_install_cuda_python() -> bool {
+    find_cuda().is_some() && has_nvidia_gpu()
+}
+
 /// Run the cuda subcommand
 pub fn run(command: super::CudaCommands) -> Result<()> {
     match command {
@@ -169,11 +198,9 @@ fn run_validate(path: Option<String>) -> Result<()> {
     }
 }
 
-/// Install CUDA Python packages
+/// CLI entry point for `pecos cuda setup-python`. Validates the toolkit is
+/// present, then runs `uv sync --group cuda` and prints next-step hints.
 fn run_setup_python() -> Result<()> {
-    use std::process::Command;
-
-    // First check if CUDA toolkit is available
     if find_cuda().is_none() {
         eprintln!("Error: CUDA toolkit not found.");
         eprintln!();
@@ -186,10 +213,22 @@ fn run_setup_python() -> Result<()> {
         ));
     }
 
+    install_cuda_python_packages()?;
+    println!();
+    println!("Verify with:");
+    println!("  python -c \"import cupy; print('cupy:', cupy.cuda.is_available())\"");
+    Ok(())
+}
+
+/// Run `uv sync --group cuda` to install Python CUDA packages.
+///
+/// Reusable from other CLI commands (e.g. `pecos setup`) once they've already
+/// confirmed the user wants this. Does NOT validate toolkit presence -- caller
+/// is responsible for that check.
+pub(super) fn install_cuda_python_packages() -> Result<()> {
     println!("Installing CUDA Python packages (cupy, cuquantum, pytket-cutensornet)...");
     println!();
 
-    // Run uv sync --group cuda to install CUDA packages via dependency group
     let status = Command::new("uv")
         .args(["sync", "--group", "cuda"])
         .status();
@@ -198,9 +237,6 @@ fn run_setup_python() -> Result<()> {
         Ok(s) if s.success() => {
             println!();
             println!("CUDA Python packages installed successfully.");
-            println!();
-            println!("Verify with:");
-            println!("  python -c \"import cupy; print('cupy:', cupy.cuda.is_available())\"");
             Ok(())
         }
         Ok(_) => {
diff --git a/crates/pecos-cli/src/cli/python_cmd.rs b/crates/pecos-cli/src/cli/python_cmd.rs
index c37cac0ad..277a84fda 100644
--- a/crates/pecos-cli/src/cli/python_cmd.rs
+++ b/crates/pecos-cli/src/cli/python_cmd.rs
@@ -13,8 +13,36 @@ pub fn run(command: &super::PythonCommands) -> Result<()> {
             profile,
             rustflags,
             cuda,
-        } => run_build(profile, rustflags.as_deref(), *cuda),
+            no_cuda,
+        } => {
+            let cuda_resolved = resolve_cuda_choice(*cuda, *no_cuda);
+            run_build(profile, rustflags.as_deref(), cuda_resolved)
+        }
+    }
+}
+
+/// Decide whether to install CUDA Python packages for this build.
+///
+/// Resolution order:
+/// - `--cuda`     -> always on (caller knows what they want)
+/// - `--no-cuda`  -> always off (caller opts out)
+/// - neither      -> auto-detect: include CUDA Python packages when both the
+///   toolkit and an NVIDIA GPU are present, otherwise skip
+fn resolve_cuda_choice(cuda: bool, no_cuda: bool) -> bool {
+    if cuda {
+        return true;
+    }
+    if no_cuda {
+        return false;
+    }
+    let detected = super::cuda_cmd::should_install_cuda_python();
+    if detected {
+        println!(
+            "CUDA toolkit + NVIDIA GPU detected -- including CUDA Python packages \
+             (cupy, cuquantum, pytket-cutensornet). Pass --no-cuda to skip."
+        );
     }
+    detected
 }
 
 /// Get the repository root
diff --git a/crates/pecos-cli/src/cli/setup_cmd.rs b/crates/pecos-cli/src/cli/setup_cmd.rs
index e6048d45a..b1e579012 100644
--- a/crates/pecos-cli/src/cli/setup_cmd.rs
+++ b/crates/pecos-cli/src/cli/setup_cmd.rs
@@ -35,6 +35,14 @@ pub fn run(mode: PromptMode, skip_llvm: bool, skip_cuda: bool, quiet: bool) -> R
         setup_cuquantum(mode)?;
     }
 
+    // Python CUDA packages: only relevant when toolkit + NVIDIA GPU are present.
+    // The Justfile/`pecos python build` flow auto-detects this too; offering it
+    // here means an interactive `pecos setup` puts the user in a fully-ready
+    // state without a follow-up command.
+    if !skip_cuda && super::cuda_cmd::should_install_cuda_python() {
+        setup_cuda_python(mode)?;
+    }
+
     if !quiet || anything_missing {
         println!();
         println!("Setup complete. Run `just build` to build PECOS.");
@@ -190,6 +198,35 @@ fn setup_cuquantum(mode: PromptMode) -> Result<()> {
     Ok(())
 }
 
+// ── Python CUDA packages ────────────────────────────────────────────────────
+
+fn setup_cuda_python(mode: PromptMode) -> Result<()> {
+    if cupy_already_installed() {
+        return Ok(());
+    }
+
+    if confirm(
+        "Install CUDA Python packages? (cupy, cuquantum, pytket-cutensornet via `uv sync --group cuda`)",
+        true, // default yes when CUDA toolkit + NVIDIA GPU are present
+        mode,
+    ) {
+        super::cuda_cmd::install_cuda_python_packages()?;
+    } else {
+        println!("  Skipping CUDA Python packages. Install later with `pecos cuda setup-python`.");
+    }
+
+    Ok(())
+}
+
+/// Cheap check: is cupy already importable in the active uv environment?
+/// Used to avoid re-prompting users who already have the CUDA group synced.
+fn cupy_already_installed() -> bool {
+    std::process::Command::new("uv")
+        .args(["run", "--frozen", "python", "-c", "import cupy"])
+        .output()
+        .is_ok_and(|o| o.status.success())
+}
+
 // ── Helpers ─────────────────────────────────────────────────────────────────
 
 fn ensure_llvm_configured() {

From 6a55986741a9fa668f952fb395972355ab306f45 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Wed, 13 May 2026 18:43:08 -0600
Subject: [PATCH 003/136] Surface CUDA Python packages in pecos setup summary

---
 crates/pecos-cli/src/cli/cuda_cmd.rs  | 19 ++++++++++++++++++
 crates/pecos-cli/src/cli/setup_cmd.rs | 28 +++++++++++++++++----------
 2 files changed, 37 insertions(+), 10 deletions(-)

diff --git a/crates/pecos-cli/src/cli/cuda_cmd.rs b/crates/pecos-cli/src/cli/cuda_cmd.rs
index f713fdb56..64e7807df 100644
--- a/crates/pecos-cli/src/cli/cuda_cmd.rs
+++ b/crates/pecos-cli/src/cli/cuda_cmd.rs
@@ -1,6 +1,7 @@
 //! Implementation of the `cuda` subcommand
 
 use std::process::Command;
+use std::sync::OnceLock;
 
 use pecos_build::Result;
 use pecos_build::cuda::{
@@ -35,6 +36,24 @@ pub(super) fn should_install_cuda_python() -> bool {
     find_cuda().is_some() && has_nvidia_gpu()
 }
 
+/// Cheap proxy for "are the CUDA Python packages synced into the active
+/// environment?". Spawns `uv run --frozen python -c "import cupy"`, so the
+/// result is cached for the lifetime of this process — `pecos setup` calls it
+/// from `has_missing_deps`, `print_status_summary`, and the install step itself,
+/// and the cache keeps that to one subprocess instead of three.
+///
+/// We probe `cupy` specifically because it's the package most likely to fail
+/// at runtime when missing (others in the group degrade more silently).
+pub(super) fn cuda_python_packages_installed() -> bool {
+    static CACHED: OnceLock<bool> = OnceLock::new();
+    *CACHED.get_or_init(|| {
+        Command::new("uv")
+            .args(["run", "--frozen", "python", "-c", "import cupy"])
+            .output()
+            .is_ok_and(|o| o.status.success())
+    })
+}
+
 /// Run the cuda subcommand
 pub fn run(command: super::CudaCommands) -> Result<()> {
     match command {
diff --git a/crates/pecos-cli/src/cli/setup_cmd.rs b/crates/pecos-cli/src/cli/setup_cmd.rs
index 70317300c..4e2cf26cd 100644
--- a/crates/pecos-cli/src/cli/setup_cmd.rs
+++ b/crates/pecos-cli/src/cli/setup_cmd.rs
@@ -79,6 +79,12 @@ fn has_missing_deps(skip_llvm: bool, skip_cuda: bool, skip_cmake: bool) -> bool
     {
         return true;
     }
+    if !skip_cuda
+        && super::cuda_cmd::should_install_cuda_python()
+        && !super::cuda_cmd::cuda_python_packages_installed()
+    {
+        return true;
+    }
     if !skip_cmake && pecos_build::cmake::find_cmake().is_none() {
         return true;
     }
@@ -118,6 +124,17 @@ fn print_status_summary(skip_llvm: bool, skip_cuda: bool, skip_cmake: bool) {
         }
     }
 
+    // CUDA Python packages (only show when toolkit + NVIDIA GPU are present;
+    // mirrors the gate used by setup_cuda_python so the summary matches what
+    // the orchestrator will actually do).
+    if !skip_cuda && super::cuda_cmd::should_install_cuda_python() {
+        if super::cuda_cmd::cuda_python_packages_installed() {
+            println!("  cupy:       installed (CUDA Python packages synced)");
+        } else {
+            println!("  cupy:       not installed (~500 MB via `uv sync --group cuda`)");
+        }
+    }
+
     // cmake (optional, used for the MWPF decoder)
     if skip_cmake {
         println!("  cmake:      skipped (--skip-cmake)");
@@ -331,7 +348,7 @@ fn setup_cuquantum(mode: PromptMode) -> Result<()> {
 // ── Python CUDA packages ────────────────────────────────────────────────────
 
 fn setup_cuda_python(mode: PromptMode) -> Result<()> {
-    if cupy_already_installed() {
+    if super::cuda_cmd::cuda_python_packages_installed() {
         return Ok(());
     }
 
@@ -348,15 +365,6 @@ fn setup_cuda_python(mode: PromptMode) -> Result<()> {
     Ok(())
 }
 
-/// Cheap check: is cupy already importable in the active uv environment?
-/// Used to avoid re-prompting users who already have the CUDA group synced.
-fn cupy_already_installed() -> bool {
-    std::process::Command::new("uv")
-        .args(["run", "--frozen", "python", "-c", "import cupy"])
-        .output()
-        .is_ok_and(|o| o.status.success())
-}
-
 // ── cmake (optional, MWPF decoder) ──────────────────────────────────────────
 
 // cmake is optional, so install failures degrade gracefully (mwpf disabled)

From 1f525cc28b3affdff0c91cca647974a51fca1858 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Thu, 14 May 2026 10:23:16 -0600
Subject: [PATCH 004/136] Stop pytest from shelling out to cargo, fix shadowed
 slr_tests module collision

---
 .../pecos/slr/gen_codes/guppy/ir_builder.py   |  2 +-
 .../tests/guppy/test_hugr_compilation.py      | 95 ++-----------------
 .../quantum-pecos/tests/slr_tests/__init__.py |  7 ++
 .../guppy/__init__.py                         |  0
 .../guppy/demo_improvements.py                |  0
 .../guppy/demo_unpacking_rules.py             |  0
 .../guppy/test_allocation_optimization.py     |  0
 .../guppy/test_array_patterns.py              |  0
 .../guppy/test_complex_permutations.py        |  0
 .../guppy/test_conditional_refinement.py      |  0
 .../guppy/test_conditional_resources.py       |  0
 .../guppy/test_data_flow.py                   |  0
 .../guppy/test_hugr_compilation.py            |  0
 .../guppy/test_hugr_error_messages.py         |  0
 .../guppy/test_ir_basic.py                    |  0
 .../guppy/test_ir_for_loops.py                |  0
 .../guppy/test_ir_generator.py                |  0
 .../guppy/test_ir_hugr_compatibility.py       |  0
 .../guppy/test_ir_permute.py                  |  0
 .../guppy/test_ir_scope_management.py         |  0
 .../guppy/test_ir_while_loops.py              |  0
 .../guppy/test_linearity_patterns.py          |  0
 .../guppy/test_loop_generation.py             |  0
 .../guppy/test_measurement_optimization.py    |  0
 .../guppy/test_multi_qubit_measurements.py    |  0
 .../guppy/test_partial_array_returns.py       |  0
 .../guppy/test_partial_consumption.py         |  0
 .../guppy/test_register_wide_ops.py           |  0
 .../guppy/test_simple_slr_to_guppy.py         |  0
 .../guppy/test_steane_integration.py          |  0
 .../guppy/test_unified_resource_planner.py    |  0
 .../guppy/test_unpacking_rules.py             |  0
 .../regression/random_cases/test_slr_phys.py  |  0
 .../pecos/unit/slr/conftest.py                |  0
 .../pecos/unit/slr/test_basic_permutation.py  |  0
 .../unit/slr/test_complex_permutation.py      |  0
 .../unit/slr/test_conversion_with_qasm.py     |  0
 .../pecos/unit/slr/test_creg_permutation.py   |  0
 .../pecos/unit/slr/test_guppy_generation.py   |  0
 .../test_guppy_generation_comprehensive.py    |  0
 .../unit/slr/test_measurement_permutation.py  |  0
 .../unit/slr/test_measurement_unrolling.py    |  0
 .../unit/slr/test_pythonic_syntax_example.py  |  0
 .../slr/test_quantum_circuit_conversion.py    |  0
 .../unit/slr/test_quantum_permutation.py      |  0
 .../unit/slr/test_register_permutation.py     |  0
 .../unit/slr/test_repeat_to_guppy_pipeline.py |  0
 .../pecos/unit/slr/test_return_validation.py  |  0
 .../pecos/unit/slr/test_stim_conversion.py    |  0
 .../tests/{slr-tests => slr_tests}/pytest.ini |  0
 .../{slr-tests => slr_tests}/test_partial.py  |  0
 51 files changed, 16 insertions(+), 88 deletions(-)
 create mode 100644 python/quantum-pecos/tests/slr_tests/__init__.py
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/guppy/__init__.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/guppy/demo_improvements.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/guppy/demo_unpacking_rules.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/guppy/test_allocation_optimization.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/guppy/test_array_patterns.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/guppy/test_complex_permutations.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/guppy/test_conditional_refinement.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/guppy/test_conditional_resources.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/guppy/test_data_flow.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/guppy/test_hugr_compilation.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/guppy/test_hugr_error_messages.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/guppy/test_ir_basic.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/guppy/test_ir_for_loops.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/guppy/test_ir_generator.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/guppy/test_ir_hugr_compatibility.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/guppy/test_ir_permute.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/guppy/test_ir_scope_management.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/guppy/test_ir_while_loops.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/guppy/test_linearity_patterns.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/guppy/test_loop_generation.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/guppy/test_measurement_optimization.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/guppy/test_multi_qubit_measurements.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/guppy/test_partial_array_returns.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/guppy/test_partial_consumption.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/guppy/test_register_wide_ops.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/guppy/test_simple_slr_to_guppy.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/guppy/test_steane_integration.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/guppy/test_unified_resource_planner.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/guppy/test_unpacking_rules.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/pecos/regression/random_cases/test_slr_phys.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/pecos/unit/slr/conftest.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/pecos/unit/slr/test_basic_permutation.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/pecos/unit/slr/test_complex_permutation.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/pecos/unit/slr/test_conversion_with_qasm.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/pecos/unit/slr/test_creg_permutation.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/pecos/unit/slr/test_guppy_generation.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/pecos/unit/slr/test_guppy_generation_comprehensive.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/pecos/unit/slr/test_measurement_permutation.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/pecos/unit/slr/test_measurement_unrolling.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/pecos/unit/slr/test_pythonic_syntax_example.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/pecos/unit/slr/test_quantum_circuit_conversion.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/pecos/unit/slr/test_quantum_permutation.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/pecos/unit/slr/test_register_permutation.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/pecos/unit/slr/test_repeat_to_guppy_pipeline.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/pecos/unit/slr/test_return_validation.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/pecos/unit/slr/test_stim_conversion.py (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/pytest.ini (100%)
 rename python/quantum-pecos/tests/{slr-tests => slr_tests}/test_partial.py (100%)

diff --git a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/ir_builder.py b/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/ir_builder.py
index 22580b5b9..c6cd5c076 100644
--- a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/ir_builder.py
+++ b/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/ir_builder.py
@@ -36,7 +36,7 @@ def verify(ancilla: array[qubit, 3] @owned) -> tuple[array[qubit, 2], ...]:
 - Use separate ancilla qubits instead of array elements for verification
 - Or restructure the verification pattern to avoid the loop issue
 
-See tests/slr-tests/guppy/test_partial_array_returns.py for correct usage patterns.
+See tests/slr_tests/guppy/test_partial_array_returns.py for correct usage patterns.
 """
 
 from __future__ import annotations
diff --git a/python/quantum-pecos/tests/guppy/test_hugr_compilation.py b/python/quantum-pecos/tests/guppy/test_hugr_compilation.py
index e0033fb75..89afb372a 100644
--- a/python/quantum-pecos/tests/guppy/test_hugr_compilation.py
+++ b/python/quantum-pecos/tests/guppy/test_hugr_compilation.py
@@ -1,7 +1,13 @@
-"""Test HUGR compilation and LLVM IR generation."""
+"""Test HUGR compilation and LLVM IR generation.
+
+Rust-side coverage (compilation, unit tests) lives in `cargo test
+-p pecos-hugr-qis` and is run by `just rstest` / `pecos rust test
+--workspace --features=runtime,hugr`. Don't re-invoke cargo from pytest --
+duplicates work, hides Rust build errors as Python test failures, and
+runs under a different env than the canonical Rust test path.
+"""
 
 import os
-import shutil
 import subprocess
 import tempfile
 from pathlib import Path
@@ -38,91 +44,6 @@ def _find_llvm_as() -> str | None:
 class TestHUGRCompilation:
     """Test suite for HUGR compilation and related functionality."""
 
-    def test_rust_hugr_crate_compilation(self) -> None:
-        """Test that the Rust HUGR support compiles."""
-        # Check if cargo is available
-        cargo_path = shutil.which("cargo")
-        if not cargo_path:
-            pytest.skip("Cargo not available")
-
-        try:
-            result = subprocess.run(
-                [cargo_path, "--version"],
-                capture_output=True,
-                text=True,
-                check=False,
-            )
-            if result.returncode != 0:
-                pytest.skip("Cargo not available")
-        except FileNotFoundError:
-            pytest.skip("Cargo not found in PATH")
-
-        # Check if pecos-hugr-qis crate exists
-        project_root = Path(__file__).resolve().parent.parent.parent.parent.parent
-        hugr_crate = project_root / "crates" / "pecos-hugr-qis"
-
-        if not hugr_crate.exists():
-            pytest.skip("pecos-hugr-qis crate not found")
-
-        # Test compilation of pecos-hugr-qis crate
-        result = subprocess.run(
-            [cargo_path, "check", "-p", "pecos-hugr-qis", "--features", "llvm"],
-            capture_output=True,
-            text=True,
-            cwd=project_root,
-            check=False,
-        )
-
-        # returncode == 0 means SUCCESS, not failure!
-        assert result.returncode == 0, f"HUGR crate compilation failed: {result.stderr[:500]}"
-
-    def test_rust_hugr_unit_tests(self) -> None:
-        """Test that HUGR unit tests pass."""
-        # Check cargo availability
-        cargo_path = shutil.which("cargo")
-        if not cargo_path:
-            pytest.skip("Cargo not available")
-
-        try:
-            subprocess.run(
-                [cargo_path, "--version"],
-                capture_output=True,
-                check=False,
-            )
-        except FileNotFoundError:
-            pytest.skip("Cargo not available")
-
-        project_root = Path(__file__).resolve().parent.parent.parent.parent.parent
-        hugr_crate = project_root / "crates" / "pecos-hugr-qis"
-
-        if not hugr_crate.exists():
-            pytest.skip("pecos-hugr-qis crate not found")
-
-        # Run HUGR-specific unit tests
-        result = subprocess.run(
-            [
-                cargo_path,
-                "test",
-                "-p",
-                "pecos-hugr-qis",
-                "--features",
-                "llvm",
-                "--",
-                "--nocapture",
-            ],
-            capture_output=True,
-            text=True,
-            cwd=project_root,
-            check=False,
-        )
-
-        assert result.returncode == 0, f"HUGR unit tests failed: {result.stderr[:500]}"
-
-        # Count successful tests if output is available
-        if "test result: ok" in result.stdout:
-            test_count = result.stdout.count("test result: ok")
-            assert test_count > 0, "Should have at least one passing test"
-
     def test_llvm_ir_format_validation(self) -> None:
         """Test that generated LLVM IR follows HUGR conventions."""
         # Create a test LLVM IR file following HUGR conventions
diff --git a/python/quantum-pecos/tests/slr_tests/__init__.py b/python/quantum-pecos/tests/slr_tests/__init__.py
new file mode 100644
index 000000000..579b19fbf
--- /dev/null
+++ b/python/quantum-pecos/tests/slr_tests/__init__.py
@@ -0,0 +1,7 @@
+"""SLR test package.
+
+The `__init__.py` here is load-bearing: without it, pytest's importlib
+mode resolves `slr_tests/guppy/test_hugr_compilation.py` and `guppy/
+test_hugr_compilation.py` to the same module name (`guppy.test_hugr_
+compilation`), and the second-loaded file silently aliases to the first.
+"""
diff --git a/python/quantum-pecos/tests/slr-tests/guppy/__init__.py b/python/quantum-pecos/tests/slr_tests/guppy/__init__.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/guppy/__init__.py
rename to python/quantum-pecos/tests/slr_tests/guppy/__init__.py
diff --git a/python/quantum-pecos/tests/slr-tests/guppy/demo_improvements.py b/python/quantum-pecos/tests/slr_tests/guppy/demo_improvements.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/guppy/demo_improvements.py
rename to python/quantum-pecos/tests/slr_tests/guppy/demo_improvements.py
diff --git a/python/quantum-pecos/tests/slr-tests/guppy/demo_unpacking_rules.py b/python/quantum-pecos/tests/slr_tests/guppy/demo_unpacking_rules.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/guppy/demo_unpacking_rules.py
rename to python/quantum-pecos/tests/slr_tests/guppy/demo_unpacking_rules.py
diff --git a/python/quantum-pecos/tests/slr-tests/guppy/test_allocation_optimization.py b/python/quantum-pecos/tests/slr_tests/guppy/test_allocation_optimization.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/guppy/test_allocation_optimization.py
rename to python/quantum-pecos/tests/slr_tests/guppy/test_allocation_optimization.py
diff --git a/python/quantum-pecos/tests/slr-tests/guppy/test_array_patterns.py b/python/quantum-pecos/tests/slr_tests/guppy/test_array_patterns.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/guppy/test_array_patterns.py
rename to python/quantum-pecos/tests/slr_tests/guppy/test_array_patterns.py
diff --git a/python/quantum-pecos/tests/slr-tests/guppy/test_complex_permutations.py b/python/quantum-pecos/tests/slr_tests/guppy/test_complex_permutations.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/guppy/test_complex_permutations.py
rename to python/quantum-pecos/tests/slr_tests/guppy/test_complex_permutations.py
diff --git a/python/quantum-pecos/tests/slr-tests/guppy/test_conditional_refinement.py b/python/quantum-pecos/tests/slr_tests/guppy/test_conditional_refinement.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/guppy/test_conditional_refinement.py
rename to python/quantum-pecos/tests/slr_tests/guppy/test_conditional_refinement.py
diff --git a/python/quantum-pecos/tests/slr-tests/guppy/test_conditional_resources.py b/python/quantum-pecos/tests/slr_tests/guppy/test_conditional_resources.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/guppy/test_conditional_resources.py
rename to python/quantum-pecos/tests/slr_tests/guppy/test_conditional_resources.py
diff --git a/python/quantum-pecos/tests/slr-tests/guppy/test_data_flow.py b/python/quantum-pecos/tests/slr_tests/guppy/test_data_flow.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/guppy/test_data_flow.py
rename to python/quantum-pecos/tests/slr_tests/guppy/test_data_flow.py
diff --git a/python/quantum-pecos/tests/slr-tests/guppy/test_hugr_compilation.py b/python/quantum-pecos/tests/slr_tests/guppy/test_hugr_compilation.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/guppy/test_hugr_compilation.py
rename to python/quantum-pecos/tests/slr_tests/guppy/test_hugr_compilation.py
diff --git a/python/quantum-pecos/tests/slr-tests/guppy/test_hugr_error_messages.py b/python/quantum-pecos/tests/slr_tests/guppy/test_hugr_error_messages.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/guppy/test_hugr_error_messages.py
rename to python/quantum-pecos/tests/slr_tests/guppy/test_hugr_error_messages.py
diff --git a/python/quantum-pecos/tests/slr-tests/guppy/test_ir_basic.py b/python/quantum-pecos/tests/slr_tests/guppy/test_ir_basic.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/guppy/test_ir_basic.py
rename to python/quantum-pecos/tests/slr_tests/guppy/test_ir_basic.py
diff --git a/python/quantum-pecos/tests/slr-tests/guppy/test_ir_for_loops.py b/python/quantum-pecos/tests/slr_tests/guppy/test_ir_for_loops.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/guppy/test_ir_for_loops.py
rename to python/quantum-pecos/tests/slr_tests/guppy/test_ir_for_loops.py
diff --git a/python/quantum-pecos/tests/slr-tests/guppy/test_ir_generator.py b/python/quantum-pecos/tests/slr_tests/guppy/test_ir_generator.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/guppy/test_ir_generator.py
rename to python/quantum-pecos/tests/slr_tests/guppy/test_ir_generator.py
diff --git a/python/quantum-pecos/tests/slr-tests/guppy/test_ir_hugr_compatibility.py b/python/quantum-pecos/tests/slr_tests/guppy/test_ir_hugr_compatibility.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/guppy/test_ir_hugr_compatibility.py
rename to python/quantum-pecos/tests/slr_tests/guppy/test_ir_hugr_compatibility.py
diff --git a/python/quantum-pecos/tests/slr-tests/guppy/test_ir_permute.py b/python/quantum-pecos/tests/slr_tests/guppy/test_ir_permute.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/guppy/test_ir_permute.py
rename to python/quantum-pecos/tests/slr_tests/guppy/test_ir_permute.py
diff --git a/python/quantum-pecos/tests/slr-tests/guppy/test_ir_scope_management.py b/python/quantum-pecos/tests/slr_tests/guppy/test_ir_scope_management.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/guppy/test_ir_scope_management.py
rename to python/quantum-pecos/tests/slr_tests/guppy/test_ir_scope_management.py
diff --git a/python/quantum-pecos/tests/slr-tests/guppy/test_ir_while_loops.py b/python/quantum-pecos/tests/slr_tests/guppy/test_ir_while_loops.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/guppy/test_ir_while_loops.py
rename to python/quantum-pecos/tests/slr_tests/guppy/test_ir_while_loops.py
diff --git a/python/quantum-pecos/tests/slr-tests/guppy/test_linearity_patterns.py b/python/quantum-pecos/tests/slr_tests/guppy/test_linearity_patterns.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/guppy/test_linearity_patterns.py
rename to python/quantum-pecos/tests/slr_tests/guppy/test_linearity_patterns.py
diff --git a/python/quantum-pecos/tests/slr-tests/guppy/test_loop_generation.py b/python/quantum-pecos/tests/slr_tests/guppy/test_loop_generation.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/guppy/test_loop_generation.py
rename to python/quantum-pecos/tests/slr_tests/guppy/test_loop_generation.py
diff --git a/python/quantum-pecos/tests/slr-tests/guppy/test_measurement_optimization.py b/python/quantum-pecos/tests/slr_tests/guppy/test_measurement_optimization.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/guppy/test_measurement_optimization.py
rename to python/quantum-pecos/tests/slr_tests/guppy/test_measurement_optimization.py
diff --git a/python/quantum-pecos/tests/slr-tests/guppy/test_multi_qubit_measurements.py b/python/quantum-pecos/tests/slr_tests/guppy/test_multi_qubit_measurements.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/guppy/test_multi_qubit_measurements.py
rename to python/quantum-pecos/tests/slr_tests/guppy/test_multi_qubit_measurements.py
diff --git a/python/quantum-pecos/tests/slr-tests/guppy/test_partial_array_returns.py b/python/quantum-pecos/tests/slr_tests/guppy/test_partial_array_returns.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/guppy/test_partial_array_returns.py
rename to python/quantum-pecos/tests/slr_tests/guppy/test_partial_array_returns.py
diff --git a/python/quantum-pecos/tests/slr-tests/guppy/test_partial_consumption.py b/python/quantum-pecos/tests/slr_tests/guppy/test_partial_consumption.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/guppy/test_partial_consumption.py
rename to python/quantum-pecos/tests/slr_tests/guppy/test_partial_consumption.py
diff --git a/python/quantum-pecos/tests/slr-tests/guppy/test_register_wide_ops.py b/python/quantum-pecos/tests/slr_tests/guppy/test_register_wide_ops.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/guppy/test_register_wide_ops.py
rename to python/quantum-pecos/tests/slr_tests/guppy/test_register_wide_ops.py
diff --git a/python/quantum-pecos/tests/slr-tests/guppy/test_simple_slr_to_guppy.py b/python/quantum-pecos/tests/slr_tests/guppy/test_simple_slr_to_guppy.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/guppy/test_simple_slr_to_guppy.py
rename to python/quantum-pecos/tests/slr_tests/guppy/test_simple_slr_to_guppy.py
diff --git a/python/quantum-pecos/tests/slr-tests/guppy/test_steane_integration.py b/python/quantum-pecos/tests/slr_tests/guppy/test_steane_integration.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/guppy/test_steane_integration.py
rename to python/quantum-pecos/tests/slr_tests/guppy/test_steane_integration.py
diff --git a/python/quantum-pecos/tests/slr-tests/guppy/test_unified_resource_planner.py b/python/quantum-pecos/tests/slr_tests/guppy/test_unified_resource_planner.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/guppy/test_unified_resource_planner.py
rename to python/quantum-pecos/tests/slr_tests/guppy/test_unified_resource_planner.py
diff --git a/python/quantum-pecos/tests/slr-tests/guppy/test_unpacking_rules.py b/python/quantum-pecos/tests/slr_tests/guppy/test_unpacking_rules.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/guppy/test_unpacking_rules.py
rename to python/quantum-pecos/tests/slr_tests/guppy/test_unpacking_rules.py
diff --git a/python/quantum-pecos/tests/slr-tests/pecos/regression/random_cases/test_slr_phys.py b/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/pecos/regression/random_cases/test_slr_phys.py
rename to python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py
diff --git a/python/quantum-pecos/tests/slr-tests/pecos/unit/slr/conftest.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/conftest.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/pecos/unit/slr/conftest.py
rename to python/quantum-pecos/tests/slr_tests/pecos/unit/slr/conftest.py
diff --git a/python/quantum-pecos/tests/slr-tests/pecos/unit/slr/test_basic_permutation.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_basic_permutation.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/pecos/unit/slr/test_basic_permutation.py
rename to python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_basic_permutation.py
diff --git a/python/quantum-pecos/tests/slr-tests/pecos/unit/slr/test_complex_permutation.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_complex_permutation.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/pecos/unit/slr/test_complex_permutation.py
rename to python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_complex_permutation.py
diff --git a/python/quantum-pecos/tests/slr-tests/pecos/unit/slr/test_conversion_with_qasm.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_conversion_with_qasm.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/pecos/unit/slr/test_conversion_with_qasm.py
rename to python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_conversion_with_qasm.py
diff --git a/python/quantum-pecos/tests/slr-tests/pecos/unit/slr/test_creg_permutation.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_creg_permutation.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/pecos/unit/slr/test_creg_permutation.py
rename to python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_creg_permutation.py
diff --git a/python/quantum-pecos/tests/slr-tests/pecos/unit/slr/test_guppy_generation.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_guppy_generation.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/pecos/unit/slr/test_guppy_generation.py
rename to python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_guppy_generation.py
diff --git a/python/quantum-pecos/tests/slr-tests/pecos/unit/slr/test_guppy_generation_comprehensive.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_guppy_generation_comprehensive.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/pecos/unit/slr/test_guppy_generation_comprehensive.py
rename to python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_guppy_generation_comprehensive.py
diff --git a/python/quantum-pecos/tests/slr-tests/pecos/unit/slr/test_measurement_permutation.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_measurement_permutation.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/pecos/unit/slr/test_measurement_permutation.py
rename to python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_measurement_permutation.py
diff --git a/python/quantum-pecos/tests/slr-tests/pecos/unit/slr/test_measurement_unrolling.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_measurement_unrolling.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/pecos/unit/slr/test_measurement_unrolling.py
rename to python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_measurement_unrolling.py
diff --git a/python/quantum-pecos/tests/slr-tests/pecos/unit/slr/test_pythonic_syntax_example.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_pythonic_syntax_example.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/pecos/unit/slr/test_pythonic_syntax_example.py
rename to python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_pythonic_syntax_example.py
diff --git a/python/quantum-pecos/tests/slr-tests/pecos/unit/slr/test_quantum_circuit_conversion.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_circuit_conversion.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/pecos/unit/slr/test_quantum_circuit_conversion.py
rename to python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_circuit_conversion.py
diff --git a/python/quantum-pecos/tests/slr-tests/pecos/unit/slr/test_quantum_permutation.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_permutation.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/pecos/unit/slr/test_quantum_permutation.py
rename to python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_permutation.py
diff --git a/python/quantum-pecos/tests/slr-tests/pecos/unit/slr/test_register_permutation.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_register_permutation.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/pecos/unit/slr/test_register_permutation.py
rename to python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_register_permutation.py
diff --git a/python/quantum-pecos/tests/slr-tests/pecos/unit/slr/test_repeat_to_guppy_pipeline.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_repeat_to_guppy_pipeline.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/pecos/unit/slr/test_repeat_to_guppy_pipeline.py
rename to python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_repeat_to_guppy_pipeline.py
diff --git a/python/quantum-pecos/tests/slr-tests/pecos/unit/slr/test_return_validation.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_return_validation.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/pecos/unit/slr/test_return_validation.py
rename to python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_return_validation.py
diff --git a/python/quantum-pecos/tests/slr-tests/pecos/unit/slr/test_stim_conversion.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_stim_conversion.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/pecos/unit/slr/test_stim_conversion.py
rename to python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_stim_conversion.py
diff --git a/python/quantum-pecos/tests/slr-tests/pytest.ini b/python/quantum-pecos/tests/slr_tests/pytest.ini
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/pytest.ini
rename to python/quantum-pecos/tests/slr_tests/pytest.ini
diff --git a/python/quantum-pecos/tests/slr-tests/test_partial.py b/python/quantum-pecos/tests/slr_tests/test_partial.py
similarity index 100%
rename from python/quantum-pecos/tests/slr-tests/test_partial.py
rename to python/quantum-pecos/tests/slr_tests/test_partial.py

From 7cbcb5ce2b697826bd5ce131d9e0e5e586d362f8 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Thu, 14 May 2026 12:49:42 -0600
Subject: [PATCH 005/136] Sanitize generated doc test paths and fix cmake-setup
 example

---
 docs/user-guide/cmake-setup.md     |  5 +++--
 scripts/docs/generate_doc_tests.py | 10 ++++++++--
 2 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/docs/user-guide/cmake-setup.md b/docs/user-guide/cmake-setup.md
index 4c7fb564a..bbd1c5061 100644
--- a/docs/user-guide/cmake-setup.md
+++ b/docs/user-guide/cmake-setup.md
@@ -94,9 +94,10 @@ Optional decoders:
 `pecos python build` will detect cmake automatically and pass `--features mwpf` to maturin. To check the decoder from Python:
 
 ```python
-import pecos_rslib
+from pecos_rslib.qec import ObservableSubgraphDecoder  # MWPF-capable decoder
 
-pecos_rslib.qec.create_observable_decoder(dem_str, "mwpf")  # should not raise
+# Construct with a real DEM + stabilizer coords:
+#   decoder = ObservableSubgraphDecoder(dem_str, stab_coords, inner_decoder="mwpf")
 ```
 
 Set `PECOS_BUILD_MWPF=0` to force MWPF off even when cmake is present (useful for reproducing the lean build locally). `PECOS_BUILD_MWPF=1` forces it on, which is what CI sets.
diff --git a/scripts/docs/generate_doc_tests.py b/scripts/docs/generate_doc_tests.py
index 743030d78..d69774775 100755
--- a/scripts/docs/generate_doc_tests.py
+++ b/scripts/docs/generate_doc_tests.py
@@ -1364,10 +1364,16 @@ def main() -> None:
         # Generate test file
         test_content = generate_test_file(md_file, pytest_blocks)
 
-        # Create output path preserving directory structure
+        # Create output path preserving directory structure. Sanitize each
+        # directory component so the output tree is a valid Python package
+        # (no dashes, etc.); otherwise pytest's importlib mode resolves
+        # `tests/docs/generated/foo-bar/test_x.py` to a module name with a
+        # dash, and any duplicate basename elsewhere in the tree silently
+        # aliases via sys.modules. See also: tests/slr_tests/__init__.py.
         relative_path = md_file.relative_to(args.docs_dir)
         test_file_name = f"test_{_sanitize_name(relative_path.stem)}.py"
-        output_subdir = args.output_dir / relative_path.parent
+        sanitized_parent = Path(*[_sanitize_name(p) for p in relative_path.parent.parts])
+        output_subdir = args.output_dir / sanitized_parent
         output_path = output_subdir / test_file_name
 
         if args.dry_run:

From 8796251b60d31c87907d00b00641c409aaa9abfb Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Thu, 14 May 2026 12:49:47 -0600
Subject: [PATCH 006/136] Introduce VariableState; fix SLR linearity bugs at
 use-after-unpack sites

---
 .../pecos/slr/gen_codes/guppy/ir_builder.py   |  83 +++++++++-
 .../slr/gen_codes/guppy/variable_state.py     | 154 ++++++++++++++++++
 2 files changed, 232 insertions(+), 5 deletions(-)
 create mode 100644 python/quantum-pecos/src/pecos/slr/gen_codes/guppy/variable_state.py

diff --git a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/ir_builder.py b/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/ir_builder.py
index c6cd5c076..83d7e31f5 100644
--- a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/ir_builder.py
+++ b/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/ir_builder.py
@@ -152,6 +152,15 @@ def __init__(
         # Track version numbers for generating unique variable names
         self.variable_version_counter: dict[str, int] = {}
 
+        # Unified variable-state tracking: replaces ad-hoc dicts like
+        # `unpacked_vars`, `refreshed_arrays`, etc. (See variable_state.py
+        # for rationale.) Migration is incremental -- legacy dicts still
+        # populated, this object is consulted at sites that need a coherent
+        # view of "what Guppy form is this SLR variable in right now?".
+        from pecos.slr.gen_codes.guppy.variable_state import VariableState
+
+        self.var_state = VariableState()
+
     def _get_unique_var_name(self, base_name: str, index: int | None = None) -> str:
         """Generate a unique variable name that doesn't conflict with existing names.
 
@@ -1967,6 +1976,22 @@ def render(self, _context):
                     if not was_consumed and hasattr(self, "consumed_resources"):
                         was_consumed = fresh_name in self.consumed_resources
 
+                    # If the fresh array was unpacked into element vars, the
+                    # array itself was moved by the unpack -- discard_array
+                    # would error. Element-level cleanup is handled separately
+                    # (or the elements were consumed by gates/measurements).
+                    # The unpacked-state tracker keys by the *original* SLR
+                    # symbol, so we look up via the original; the fresh name
+                    # itself doesn't appear in unpacked_vars.
+                    original_name = info.get("original")
+                    if (
+                        original_name
+                        and self.var_state.is_unpacked(original_name)
+                        and hasattr(self, "refreshed_arrays")
+                        and self.refreshed_arrays.get(original_name) == fresh_name
+                    ):
+                        was_consumed = True
+
                     if not was_consumed and info.get("is_quantum_array"):
                         # Add discard statement
                         discard_stmt = FunctionCall(
@@ -3019,6 +3044,36 @@ def render(self, context):
                 # Regular pre-allocated array - use measure_array
                 qreg_ref = self._convert_qubit_ref(qreg)
 
+                # If the array was previously unpacked (e.g., to access an
+                # individual element after a function call returned it),
+                # Guppy considers the original variable name consumed by
+                # the unpack. Repack from the element vars so measure_array
+                # can take the whole array as input. We emit the repack
+                # statement *prepended* to whatever statement(s) the rest
+                # of this branch produces (see `_prepend_to_result`).
+                #
+                # var_state and the legacy `unpacked_vars` dict are both
+                # updated so other code paths agree the array is whole again.
+                repack_stmt = None
+                if hasattr(qreg, "sym") and self.var_state.is_unpacked(qreg.sym):
+                    binding = self.var_state.get(qreg.sym)
+                    repack_stmt = Assignment(
+                        target=VariableRef(qreg.sym),
+                        value=self._create_array_reconstruction(list(binding.element_names)),
+                    )
+                    self.var_state.bind_whole(qreg.sym, qreg.sym)
+                    if hasattr(self, "unpacked_vars") and qreg.sym in self.unpacked_vars:
+                        del self.unpacked_vars[qreg.sym]
+                    if hasattr(self, "context"):
+                        var = self.context.lookup_variable(qreg.sym)
+                        if var:
+                            var.is_unpacked = False
+                            var.unpacked_names = []
+                    # qreg_ref was computed *before* the repack -- recompute
+                    # so it points at the now-whole array, not stale unpacked
+                    # element variables.
+                    qreg_ref = self._convert_qubit_ref(qreg)
+
                 # Mark fresh variable as used if this is measuring a fresh variable
                 if hasattr(self, "fresh_variables_to_track") and hasattr(
                     self,
@@ -3120,7 +3175,10 @@ def render(self, context):
                             func_name="quantum.measure_array",
                             args=[qreg_ref],
                         )
-                        return Assignment(target=creg_ref, value=call)
+                        result = Assignment(target=creg_ref, value=call)
+                        if repack_stmt is not None:
+                            return Block(statements=[repack_stmt, result])
+                        return result
 
                 # No target - just measure
                 call = FunctionCall(
@@ -3139,7 +3197,10 @@ def analyze(self, context):
                     def render(self, context):
                         return self.expr.render(context)
 
-                return ExpressionStatement(call)
+                result = ExpressionStatement(call)
+                if repack_stmt is not None:
+                    return Block(statements=[repack_stmt, result])
+                return result
 
         # Handle single qubit measurement
         if len(meas.qargs) == 1:
@@ -6656,12 +6717,19 @@ def render(self, context):
                         )
                         element_names = [f"{name}_{i}{unpack_suffix}" for i in range(return_array_size)]
 
-                        # Add unpacking statement using ArrayUnpack IR class
+                        # Add unpacking statement using ArrayUnpack IR class.
+                        # When the array was refreshed by a function call (e.g.,
+                        # q → q_fresh), unpack from the refreshed name -- the
+                        # original is moved/consumed at this point. Without
+                        # this, generated Guppy looks like `q_0_ret, = q` and
+                        # Guppy rejects with WrongNumberOfUnpacksError or
+                        # AlreadyUsedError.
                         from pecos.slr.gen_codes.guppy.ir import ArrayUnpack
 
+                        unpack_source = self.refreshed_arrays.get(name, name)
                         unpack_stmt = ArrayUnpack(
                             targets=element_names,
-                            source=name,
+                            source=unpack_source,
                         )
                         statements.append(unpack_stmt)
 
@@ -6673,14 +6741,19 @@ def render(self, context):
                         # CRITICAL: Track index mapping for partial consumption
                         # If live_qubits tells us which original indices are in the returned array,
                         # create a mapping from original index → unpacked variable index
+                        index_map: dict[int, int] | None = None
                         if name in live_qubits:
                             original_indices = sorted(live_qubits[name])
                             if not hasattr(self, "index_mapping"):
                                 self.index_mapping = {}
                             # Map original index to position in returned/unpacked array
-                            self.index_mapping[name] = {
+                            index_map = {
                                 orig_idx: new_idx for new_idx, orig_idx in enumerate(original_indices)
                             }
+                            self.index_mapping[name] = index_map
+
+                        # Mirror to unified variable state (see variable_state.py)
+                        self.var_state.bind_unpacked(name, list(element_names), index_map)
 
                         # Update context
                         if hasattr(self, "context"):
diff --git a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/variable_state.py b/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/variable_state.py
new file mode 100644
index 000000000..f5805f6ce
--- /dev/null
+++ b/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/variable_state.py
@@ -0,0 +1,154 @@
+"""Unified variable-state tracking for the Guppy IR generator.
+
+The Guppy generator translates SLR programs (high-level quantum DSL) to
+Guppy source. Guppy uses linear types: every qubit must be used exactly
+once, and arrays-of-qubits get "moved" into and out of operations rather
+than mutated in place.
+
+Translating SLR to Guppy means tracking, for each SLR variable, *what
+Guppy variable currently holds it*. The form changes over the lifetime
+of the SLR variable -- it might be a whole array, get unpacked into
+element variables for individual access, get refreshed by a function
+return, get partially consumed, etc.
+
+Historically the IRGuppyGenerator did this with ~6+ separate dicts
+(`unpacked_vars`, `refreshed_arrays`, `array_remapping`, `index_mapping`,
+`variable_remapping`, `function_var_remapping`, `replaced_qubits`,
+`fresh_variables_to_track`, ...). Different code generation sites
+consult different subsets of these dicts; sites that miss a state
+transition emit Guppy that violates linearity ("AlreadyUsedError",
+"WrongNumberOfUnpacksError", etc.).
+
+This module replaces that with one model: each SLR variable has a
+*current binding* describing its Guppy form right now. Operations on the
+variable consult the binding; transitions update it. Code-generation
+sites that need the variable in a particular form call helpers like
+`ensure_whole()` which emit reconstruction statements transparently.
+
+The migration is incremental. While the legacy dicts still exist, this
+module shadows them: writes go to both, reads prefer this module. Once
+all read sites are migrated, the legacy dicts can be removed.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass(frozen=True)
+class WholeArray:
+    """SLR variable is currently bound to a single Guppy array variable.
+
+    `guppy_name` is the live identifier; subsequent ops can reference
+    `guppy_name` directly or index into it via `guppy_name[i]`.
+    """
+
+    guppy_name: str
+
+
+@dataclass(frozen=True)
+class UnpackedArray:
+    """SLR variable was unpacked into per-element Guppy variables.
+
+    `element_names[i]` is the Guppy variable for original SLR index
+    `i` -- unless `index_mapping` is set, in which case mapping
+    `original_index -> position_in_element_names` is used (this happens
+    when a function call returned a partially-consumed array).
+    """
+
+    element_names: tuple[str, ...]
+    index_mapping: tuple[tuple[int, int], ...] = ()  # (orig_idx, position)
+
+    def position_for(self, original_index: int) -> int | None:
+        """Return the position in `element_names` for an SLR index.
+
+        With no `index_mapping`, returns `original_index` directly when in
+        bounds. With a mapping, looks up the position; returns None for
+        SLR indices that aren't present in the partial array.
+        """
+        if not self.index_mapping:
+            return original_index if original_index < len(self.element_names) else None
+        for orig, pos in self.index_mapping:
+            if orig == original_index:
+                return pos
+        return None
+
+
+@dataclass(frozen=True)
+class Consumed:
+    """SLR variable is fully consumed; subsequent references are bugs.
+
+    `reason` is a short human-readable note for diagnostics ("measured",
+    "passed to function as @owned", etc.).
+    """
+
+    reason: str = ""
+
+
+Binding = WholeArray | UnpackedArray | Consumed
+
+
+@dataclass
+class VariableState:
+    """Current Guppy bindings for SLR variables in one generation context.
+
+    A "context" is typically one Guppy function being generated -- the
+    main function or one of the extracted sub-block functions. Bindings
+    are local to a context; the same SLR variable name in different
+    contexts can have different bindings.
+    """
+
+    bindings: dict[str, Binding] = field(default_factory=dict)
+
+    def bind_whole(self, slr_name: str, guppy_name: str) -> None:
+        """Record that `slr_name` is currently held by Guppy var `guppy_name`."""
+        self.bindings[slr_name] = WholeArray(guppy_name)
+
+    def bind_unpacked(
+        self,
+        slr_name: str,
+        element_names: list[str],
+        index_mapping: dict[int, int] | None = None,
+    ) -> None:
+        """Record that `slr_name` was unpacked into per-element Guppy vars."""
+        mapping_tuple = tuple(sorted(index_mapping.items())) if index_mapping else ()
+        self.bindings[slr_name] = UnpackedArray(tuple(element_names), mapping_tuple)
+
+    def bind_consumed(self, slr_name: str, reason: str = "") -> None:
+        """Record that `slr_name` is no longer accessible."""
+        self.bindings[slr_name] = Consumed(reason)
+
+    def get(self, slr_name: str) -> Binding | None:
+        """Return current binding, or None if `slr_name` is unknown here."""
+        return self.bindings.get(slr_name)
+
+    def is_unpacked(self, slr_name: str) -> bool:
+        """True iff `slr_name` is currently in unpacked form."""
+        return isinstance(self.bindings.get(slr_name), UnpackedArray)
+
+    def is_consumed(self, slr_name: str) -> bool:
+        """True iff `slr_name` has been consumed."""
+        return isinstance(self.bindings.get(slr_name), Consumed)
+
+    def ensure_whole(self, slr_name: str) -> tuple[list[str], str | None]:
+        """Ensure `slr_name` is bound as a whole array; emit prep code if not.
+
+        Returns (preparation_lines, guppy_name). The caller emits the
+        preparation_lines (Guppy source as `array(elem_0, elem_1, ...)`
+        repacking) before whatever it does with `guppy_name`. Returns
+        ([], guppy_name) when already whole. Returns ([], None) when
+        `slr_name` is consumed or unknown -- caller should treat as a
+        programming error.
+
+        After repack, the binding is updated to WholeArray so subsequent
+        callers don't repack again.
+        """
+        binding = self.bindings.get(slr_name)
+        if isinstance(binding, WholeArray):
+            return [], binding.guppy_name
+        if isinstance(binding, UnpackedArray):
+            elements = ", ".join(binding.element_names)
+            line = f"{slr_name} = array({elements})"
+            self.bindings[slr_name] = WholeArray(slr_name)
+            return [line], slr_name
+        return [], None

From 0c4b0c068c1eed0358531add99cf55628c690ab2 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Thu, 14 May 2026 14:57:02 -0600
Subject: [PATCH 007/136] Add AST -> Guppy v1 acceptance tests as xfail spec

---
 .../tests/slr_tests/ast_guppy/__init__.py     |  20 ++
 .../tests/slr_tests/ast_guppy/_harness.py     |  98 +++++++
 .../slr_tests/ast_guppy/test_v1_acceptance.py | 251 ++++++++++++++++++
 3 files changed, 369 insertions(+)
 create mode 100644 python/quantum-pecos/tests/slr_tests/ast_guppy/__init__.py
 create mode 100644 python/quantum-pecos/tests/slr_tests/ast_guppy/_harness.py
 create mode 100644 python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_acceptance.py

diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/__init__.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/__init__.py
new file mode 100644
index 000000000..d405f6835
--- /dev/null
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/__init__.py
@@ -0,0 +1,20 @@
+"""AST -> Guppy v1 acceptance tests.
+
+These tests exercise the SLR -> AST -> Guppy lowering path
+(`SlrConverter.guppy()` and downstream codegens at
+`pecos/slr/ast/codegen/guppy.py`). They are the v1 acceptance
+contract: each test is the spec for one feature in the v1 supported
+set documented at:
+
+    ~/Repos/pecos-docs/design/slr/v1-feature-matrix.md
+    ~/Repos/pecos-docs/design/slr/stage3-synthesis.md
+    ~/Repos/pecos-docs/design/slr/stage5-integrity-review.md
+
+Tests start as xfail because the AST Guppy emitter is being rewritten
+on this branch (`feat/ast-guppy-v1`). As features land, the xfail
+mark comes off the corresponding test.
+
+Do not route acceptance through `SlrConverter.hugr()` until cutover
+(Step 4 in the forward path); `hugr()` still falls back to the
+legacy IR generator and would mask AST-path failures.
+"""
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/_harness.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/_harness.py
new file mode 100644
index 000000000..5bc1e730a
--- /dev/null
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/_harness.py
@@ -0,0 +1,98 @@
+"""Compile harness for AST -> Guppy v1 acceptance tests.
+
+Provides a single primitive: `assert_ast_guppy_compiles(prog)`. Takes an
+SLR `Main`/`Block`, runs it through `SlrConverter.guppy()` (which is the
+AST path: `slr_to_ast` -> `AstToGuppy`), writes the source to a temp
+file, imports it as a fresh module, and calls `main.compile_function()`
+on the resulting Guppy function.
+
+This is intentionally NOT routed through `SlrConverter.hugr()`. That
+path still falls back to the legacy IR generator and would mask
+AST-path failures.
+
+Reference for the compile machinery:
+`pecos/slr/gen_codes/guppy/hugr_compiler.py::HugrCompiler.compile_to_hugr`
+does the same dance for the legacy IR path; we lift the technique.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import sys
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+
+from pecos.slr import Block, SlrConverter
+
+
+@dataclass(frozen=True)
+class CompileFailure(AssertionError):
+    """Raised when generated Guppy source fails to compile.
+
+    Carries the generated source for diagnostics. The exception type
+    inherits from AssertionError so pytest renders it as a normal
+    test failure instead of an internal error.
+    """
+
+    source: str
+    cause: BaseException
+
+    def __str__(self) -> str:
+        cause_msg = f"{type(self.cause).__name__}: {self.cause}"
+        # Truncate the source in repr; full source is on .source for inspection.
+        max_lines = 80
+        lines = self.source.splitlines()
+        shown = "\n".join(lines[:max_lines])
+        suffix = (
+            f"\n... ({len(lines) - max_lines} more lines truncated)"
+            if len(lines) > max_lines
+            else ""
+        )
+        return f"{cause_msg}\n--- generated Guppy source ---\n{shown}{suffix}"
+
+
+def ast_guppy_source(slr_program: Block) -> str:
+    """Return the Guppy source the AST path would emit, without compiling."""
+    return SlrConverter(slr_program).guppy()
+
+
+def assert_ast_guppy_compiles(slr_program: Block) -> None:
+    """Run SLR -> AST -> Guppy source -> compile_function. Raise on failure.
+
+    The "main" function in the generated source is compiled via Guppy's
+    `compile_function()` (works for parameterized functions, unlike
+    `compile()` which expects a no-arg entrypoint).
+    """
+    source = ast_guppy_source(slr_program)
+
+    # Import as a fresh module from a temp file so Guppy can attribute
+    # source spans correctly in any error messages.
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+        path = Path(f.name)
+        f.write(source)
+
+    spec = importlib.util.spec_from_file_location(f"_ast_guppy_test_{path.stem}", path)
+    if spec is None or spec.loader is None:
+        msg = f"Failed to create import spec for generated source at {path}"
+        raise RuntimeError(msg)
+
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    try:
+        spec.loader.exec_module(module)
+    except BaseException as exc:
+        raise CompileFailure(source=source, cause=exc) from exc
+
+    main = getattr(module, "main", None)
+    if main is None:
+        msg = "Generated Guppy source has no `main` function"
+        raise CompileFailure(
+            source=source,
+            cause=AttributeError(msg),
+        )
+
+    try:
+        main.compile_function()
+    except BaseException as exc:
+        raise CompileFailure(source=source, cause=exc) from exc
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_acceptance.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_acceptance.py
new file mode 100644
index 000000000..f24beab4b
--- /dev/null
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_acceptance.py
@@ -0,0 +1,251 @@
+"""v1 acceptance tests for the AST -> Guppy emitter.
+
+Each test is the spec for one feature in the v1 supported set. All
+marked `xfail(strict=True)` until the emitter rewrite lands the
+corresponding feature; xfail comes off as features ship.
+
+Source matrix:
+    ~/Repos/pecos-docs/design/slr/v1-feature-matrix.md
+    ~/Repos/pecos-docs/design/slr/stage5-integrity-review.md (findings 5, 6)
+
+Test layout follows Codex's "practical v1 acceptance set" plus the
+coverage gaps surfaced in stage 5 (final-root-return, static For,
+Parallel, Prep-after-measure, mixed Permute, gates beyond CX,
+SZ/SZdg mapping, measurement-without-output, targeted unsupported
+errors).
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from pecos.slr import Block, CReg, If, Main, QReg, Repeat
+from pecos.slr.qeclib import qubit as qb
+from pecos.slr.qeclib.qubit.measures import Measure
+
+from ._harness import assert_ast_guppy_compiles
+
+
+pytestmark = pytest.mark.xfail(
+    strict=False,
+    reason="awaiting feat/ast-guppy-v1 emitter rewrite (Codex PR sequence)",
+)
+
+
+class TestStraightLine:
+    """Bell, GHZ, simple-reset, multi-register; the basics."""
+
+    def test_bell(self) -> None:
+        prog = Main(
+            q := QReg("q", 2),
+            c := CReg("c", 2),
+            qb.H(q[0]),
+            qb.CX(q[0], q[1]),
+            Measure(q) > c,
+        )
+        assert_ast_guppy_compiles(prog)
+
+    def test_ghz_three(self) -> None:
+        prog = Main(
+            q := QReg("q", 3),
+            c := CReg("c", 3),
+            qb.H(q[0]),
+            qb.CX(q[0], q[1]),
+            qb.CX(q[1], q[2]),
+            Measure(q) > c,
+        )
+        assert_ast_guppy_compiles(prog)
+
+    def test_multi_register(self) -> None:
+        prog = Main(
+            a := QReg("a", 2),
+            b := QReg("b", 2),
+            ca := CReg("ca", 2),
+            cb := CReg("cb", 2),
+            qb.H(a[0]),
+            qb.CX(a[0], a[1]),
+            qb.X(b[0]),
+            qb.CX(b[0], b[1]),
+            Measure(a) > ca,
+            Measure(b) > cb,
+        )
+        assert_ast_guppy_compiles(prog)
+
+
+class TestMeasurement:
+    """Partial / full / no-output / individual measurement patterns."""
+
+    def test_partial_measurement_lives_discarded(self) -> None:
+        """q[0] measured; q[1], q[2] live -> codegen discards them at exit."""
+        prog = Main(
+            q := QReg("q", 3),
+            c := CReg("c", 1),
+            qb.H(q[0]),
+            Measure(q[0]) > c[0],
+        )
+        assert_ast_guppy_compiles(prog)
+
+    def test_full_register_measurement(self) -> None:
+        prog = Main(
+            q := QReg("q", 4),
+            c := CReg("c", 4),
+            qb.H(q[0]),
+            qb.H(q[1]),
+            qb.H(q[2]),
+            qb.H(q[3]),
+            Measure(q) > c,
+        )
+        assert_ast_guppy_compiles(prog)
+
+    def test_individual_measurements(self) -> None:
+        prog = Main(
+            q := QReg("q", 3),
+            c := CReg("c", 3),
+            qb.X(q[0]),
+            Measure(q[0]) > c[0],
+            qb.X(q[1]),
+            Measure(q[1]) > c[1],
+            Measure(q[2]) > c[2],
+        )
+        assert_ast_guppy_compiles(prog)
+
+    def test_measurement_without_output(self) -> None:
+        """Measure with no `> creg` consumes the qubit, discards the result."""
+        prog = Main(
+            q := QReg("q", 2),
+            qb.H(q[0]),
+            qb.CX(q[0], q[1]),
+            Measure(q),
+        )
+        assert_ast_guppy_compiles(prog)
+
+
+class TestPrep:
+    """Prep as reset (live slot) or fresh allocation (consumed slot)."""
+
+    def test_prep_resets_live_slot(self) -> None:
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 2),
+            qb.H(q[0]),
+            Measure(q[0]) > c[0],
+            qb.Prep(q[0]),  # consumed -> fresh qubit()
+            Measure(q[0]) > c[1],
+        )
+        assert_ast_guppy_compiles(prog)
+
+
+class TestControlFlow:
+    """Conditional + loop patterns within v1 supported semantics."""
+
+    def test_conditional_x_state_preserving(self) -> None:
+        """If-then where then preserves slot state; identity else is implicit."""
+        prog = Main(
+            q := QReg("q", 2),
+            c := CReg("c", 2),
+            Measure(q[0]) > c[0],
+            If(c[0]).Then(qb.X(q[1])),
+            Measure(q[1]) > c[1],
+        )
+        assert_ast_guppy_compiles(prog)
+
+    def test_repeat_state_preserving_body(self) -> None:
+        """Repeat whose body leaves slot state unchanged."""
+        prog = Main(
+            q := QReg("q", 1),
+            Repeat(3).block(qb.H(q[0]), qb.H(q[0])),
+            Measure(q[0]),
+        )
+        assert_ast_guppy_compiles(prog)
+
+
+class TestGatesBeyondCX:
+    """Core gates per matrix: H, X, Y, Z, S/Sdg, T/Tdg, CX, CY, CZ, CH."""
+
+    def test_pauli_set(self) -> None:
+        prog = Main(
+            q := QReg("q", 4),
+            c := CReg("c", 4),
+            qb.X(q[0]),
+            qb.Y(q[1]),
+            qb.Z(q[2]),
+            qb.H(q[3]),
+            Measure(q) > c,
+        )
+        assert_ast_guppy_compiles(prog)
+
+    def test_szdg_t_tdg(self) -> None:
+        """SZ/SZdg map to s/sdg in Guppy; T/Tdg are direct."""
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            qb.H(q[0]),
+            qb.SZ(q[0]),
+            qb.T(q[0]),
+            qb.Tdg(q[0]),
+            qb.SZdg(q[0]),
+            qb.H(q[0]),
+            Measure(q[0]) > c[0],
+        )
+        assert_ast_guppy_compiles(prog)
+
+    def test_cy_cz(self) -> None:
+        prog = Main(
+            q := QReg("q", 2),
+            c := CReg("c", 2),
+            qb.H(q[0]),
+            qb.CY(q[0], q[1]),
+            qb.CZ(q[0], q[1]),
+            Measure(q) > c,
+        )
+        assert_ast_guppy_compiles(prog)
+
+
+class TestReturn:
+    """Final root-level Return (stage 5 finding 5)."""
+
+    def test_final_root_return_qubit_array(self) -> None:
+        """Explicit Return -> generated function returns the live array."""
+        from pecos.slr.misc import Return
+
+        prog = Main(
+            q := QReg("q", 1),
+            qb.H(q[0]),
+            Return(q),
+        )
+        assert_ast_guppy_compiles(prog)
+
+
+class TestRejection:
+    """v1 must REJECT these with clear errors (not silently miscompile)."""
+
+    @pytest.mark.xfail(
+        strict=False,
+        reason="awaiting emitter rejection logic; will assert specific exception once landed",
+    )
+    def test_divergent_branch_post_state_rejected(self) -> None:
+        """Then-branch consumes q[1], else (implicit) does not -> rejected."""
+        prog = Main(
+            q := QReg("q", 2),
+            c := CReg("c", 2),
+            Measure(q[0]) > c[0],
+            If(c[0]).Then(Measure(q[1]) > c[1]),
+            # q[1] state diverges between branches -> codegen must reject
+        )
+        with pytest.raises(Exception):  # noqa: BLE001 -- placeholder until specific type lands
+            assert_ast_guppy_compiles(prog)
+
+    @pytest.mark.xfail(
+        strict=False,
+        reason="awaiting emitter rejection logic for unsupported gates",
+    )
+    def test_unsupported_sx_rejected(self) -> None:
+        """SX/SY have no direct Guppy mapping in v1; emitter rejects."""
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            qb.SX(q[0]),
+            Measure(q[0]) > c[0],
+        )
+        with pytest.raises(Exception):  # noqa: BLE001
+            assert_ast_guppy_compiles(prog)

From d1eea61e1292e5a6509ceea1b95adc86edd4b06c Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Thu, 14 May 2026 14:59:36 -0600
Subject: [PATCH 008/136] Tighten v1 acceptance tests: strict xfail; defer
 rejection tests

---
 .../slr_tests/ast_guppy/test_v1_acceptance.py | 43 ++++---------------
 1 file changed, 9 insertions(+), 34 deletions(-)

diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_acceptance.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_acceptance.py
index f24beab4b..52298c09a 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_acceptance.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_acceptance.py
@@ -27,7 +27,7 @@
 
 
 pytestmark = pytest.mark.xfail(
-    strict=False,
+    strict=True,
     reason="awaiting feat/ast-guppy-v1 emitter rewrite (Codex PR sequence)",
 )
 
@@ -216,36 +216,11 @@ def test_final_root_return_qubit_array(self) -> None:
         assert_ast_guppy_compiles(prog)
 
 
-class TestRejection:
-    """v1 must REJECT these with clear errors (not silently miscompile)."""
-
-    @pytest.mark.xfail(
-        strict=False,
-        reason="awaiting emitter rejection logic; will assert specific exception once landed",
-    )
-    def test_divergent_branch_post_state_rejected(self) -> None:
-        """Then-branch consumes q[1], else (implicit) does not -> rejected."""
-        prog = Main(
-            q := QReg("q", 2),
-            c := CReg("c", 2),
-            Measure(q[0]) > c[0],
-            If(c[0]).Then(Measure(q[1]) > c[1]),
-            # q[1] state diverges between branches -> codegen must reject
-        )
-        with pytest.raises(Exception):  # noqa: BLE001 -- placeholder until specific type lands
-            assert_ast_guppy_compiles(prog)
-
-    @pytest.mark.xfail(
-        strict=False,
-        reason="awaiting emitter rejection logic for unsupported gates",
-    )
-    def test_unsupported_sx_rejected(self) -> None:
-        """SX/SY have no direct Guppy mapping in v1; emitter rejects."""
-        prog = Main(
-            q := QReg("q", 1),
-            c := CReg("c", 1),
-            qb.SX(q[0]),
-            Measure(q[0]) > c[0],
-        )
-        with pytest.raises(Exception):  # noqa: BLE001
-            assert_ast_guppy_compiles(prog)
+# Rejection tests for divergent control flow + unsupported gates land
+# in a follow-up PR once Codex's emitter has a specific `LinearityError`
+# (or analogous typed error) to assert against. Asserting `Exception`
+# today would silently pass on the AST path's pre-existing breakage --
+# a fallback the design philosophy explicitly disallows. See:
+#   ~/Repos/pecos-docs/design/slr/stage5-integrity-review.md (finding 6)
+#   ~/Repos/pecos-docs/design/slr/v1-feature-matrix.md ("Explicitly
+#       unsupported in v1" table)

From 626dbf03b91a2d62f32e9d719d638c4666514f68 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Thu, 14 May 2026 15:13:12 -0600
Subject: [PATCH 009/136] Add Guppy-only linearity helper for AST -> Guppy
 lowering

---
 .../pecos/slr/ast/codegen/guppy_linearity.py  | 223 ++++++++++++++++++
 .../ast_guppy/test_linearity_helper.py        | 219 +++++++++++++++++
 2 files changed, 442 insertions(+)
 create mode 100644 python/quantum-pecos/src/pecos/slr/ast/codegen/guppy_linearity.py
 create mode 100644 python/quantum-pecos/tests/slr_tests/ast_guppy/test_linearity_helper.py

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy_linearity.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy_linearity.py
new file mode 100644
index 000000000..4c7c06093
--- /dev/null
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy_linearity.py
@@ -0,0 +1,223 @@
+# Copyright 2026 The PECOS Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations under the License.
+
+"""Guppy-only slot ownership tracking for AST code generation.
+
+This module is deliberately target-scoped. It tracks the Guppy local that
+currently owns each logical SLR qubit slot while `ast/codegen/guppy.py`
+emits source. It does not annotate AST nodes and does not model non-Guppy
+codegens.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum, auto
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Mapping
+
+
+@dataclass(frozen=True, slots=True)
+class Slot:
+    """Logical qubit slot from an SLR allocator, such as `q[0]`."""
+
+    allocator: str
+    index: int
+
+    def __str__(self) -> str:
+        """Return a compact user-facing slot name."""
+        return f"{self.allocator}[{self.index}]"
+
+
+class SlotState(Enum):
+    """Guppy ownership state for a logical qubit slot."""
+
+    LIVE = auto()
+    CONSUMED = auto()
+
+
+@dataclass(frozen=True, slots=True)
+class Binding:
+    """Current Guppy local name and ownership state for one slot."""
+
+    local: str
+    state: SlotState
+
+
+LinearitySnapshot = dict[Slot, Binding]
+
+
+class LinearityError(Exception):
+    """Raised when AST emission would produce unsound Guppy ownership."""
+
+
+class GuppyLinearityState:
+    """Track logical qubit slots while the Guppy emitter writes locals."""
+
+    def __init__(self, bindings: Mapping[Slot, Binding]) -> None:
+        """Create state from an explicit binding table in stable order."""
+        self._order = tuple(bindings)
+        self._bindings = dict(bindings)
+
+    @classmethod
+    def from_allocators(cls, allocators: Mapping[str, int]) -> GuppyLinearityState:
+        """Create live slot bindings for root QReg/QAlloc declarations."""
+        bindings: dict[Slot, Binding] = {}
+        for allocator, size in allocators.items():
+            if size < 0:
+                msg = f"Allocator {allocator!r} has negative size {size}"
+                raise LinearityError(msg)
+            for index in range(size):
+                slot = Slot(allocator, index)
+                bindings[slot] = Binding(local=f"{allocator}_{index}", state=SlotState.LIVE)
+        return cls(bindings)
+
+    def bindings(self) -> Iterable[tuple[Slot, Binding]]:
+        """Iterate bindings in stable allocator/index order."""
+        return ((slot, self._bindings[slot]) for slot in self._order)
+
+    def binding(self, slot: Slot) -> Binding:
+        """Return the current binding for a slot, including consumed slots."""
+        self._require_known(slot)
+        return self._bindings[slot]
+
+    def status(self, slot: Slot) -> SlotState:
+        """Return whether a slot is live or consumed."""
+        return self.binding(slot).state
+
+    def live(self, slot: Slot) -> str:
+        """Return the live Guppy local for a slot, or raise if consumed."""
+        binding = self.binding(slot)
+        if binding.state is not SlotState.LIVE:
+            msg = f"Slot {slot} is consumed and has no live Guppy local"
+            raise LinearityError(msg)
+        return binding.local
+
+    def set_live(self, slot: Slot, local: str) -> None:
+        """Record the current live owner for a slot; the name may be unchanged."""
+        self._require_known(slot)
+        self._bindings[slot] = Binding(local=local, state=SlotState.LIVE)
+
+    def consume(self, slot: Slot) -> str:
+        """Return the live local and mark the slot consumed; raise if unavailable."""
+        local = self.live(slot)
+        self._bindings[slot] = Binding(local=local, state=SlotState.CONSUMED)
+        return local
+
+    def discard_live(self) -> list[tuple[Slot, str]]:
+        """Consume all remaining live slots for end-of-function cleanup."""
+        discarded: list[tuple[Slot, str]] = []
+        for slot in self._order:
+            binding = self._bindings[slot]
+            if binding.state is SlotState.LIVE:
+                discarded.append((slot, binding.local))
+                self._bindings[slot] = Binding(local=binding.local, state=SlotState.CONSUMED)
+        return discarded
+
+    def snapshot(self) -> LinearitySnapshot:
+        """Return an opaque copy for speculative branch or loop emission."""
+        return dict(self._bindings)
+
+    def restore(self, snapshot: LinearitySnapshot) -> None:
+        """Restore a previous snapshot before emitting another region."""
+        self._require_valid_snapshot(snapshot, label="restore")
+        self._bindings = dict(snapshot)
+
+    def merge_if(
+        self,
+        before: LinearitySnapshot,
+        then_state: LinearitySnapshot,
+        else_state: LinearitySnapshot | None = None,
+        *,
+        label: str,
+    ) -> None:
+        """Accept an if only when both exits leave identical slot bindings."""
+        self._require_valid_snapshot(before, label=f"{label} before")
+        self._require_valid_snapshot(then_state, label=f"{label} then")
+        merged_else = before if else_state is None else else_state
+        self._require_valid_snapshot(merged_else, label=f"{label} else")
+
+        if then_state != merged_else:
+            msg = (
+                f"{label} leaves divergent Guppy slot states; "
+                f"then={self._snapshot_summary(then_state)}, else={self._snapshot_summary(merged_else)}"
+            )
+            raise LinearityError(msg)
+        self._bindings = dict(then_state)
+
+    def assert_same(
+        self,
+        before: LinearitySnapshot,
+        after: LinearitySnapshot,
+        *,
+        label: str,
+    ) -> None:
+        """Require a loop/region body to preserve exact slot bindings."""
+        self._require_valid_snapshot(before, label=f"{label} before")
+        self._require_valid_snapshot(after, label=f"{label} after")
+        if before != after:
+            msg = (
+                f"{label} changes Guppy slot state across a required invariant; "
+                f"before={self._snapshot_summary(before)}, after={self._snapshot_summary(after)}"
+            )
+            raise LinearityError(msg)
+        self._bindings = dict(after)
+
+    def permute(self, mapping: Mapping[Slot, Slot], *, label: str) -> None:
+        """Apply a static logical-slot permutation to the binding table.
+
+        `mapping` is interpreted as `logical_source -> old_logical_target`:
+        after `permute({a[0]: a[1], a[1]: a[0]})`, references to `a[0]`
+        use the binding that previously belonged to `a[1]`.
+        """
+        keys = set(mapping)
+        values = set(mapping.values())
+        if keys != values:
+            msg = f"{label} must be bijective over the same slot set"
+            raise LinearityError(msg)
+
+        for slot in keys:
+            self._require_known(slot)
+        for slot in values:
+            self._require_known(slot)
+
+        old_bindings = dict(self._bindings)
+        for source, target in mapping.items():
+            self._bindings[source] = old_bindings[target]
+
+    def _require_known(self, slot: Slot) -> None:
+        if slot not in self._bindings:
+            msg = f"Unknown Guppy slot {slot}"
+            raise LinearityError(msg)
+
+    def _require_valid_snapshot(self, snapshot: LinearitySnapshot, *, label: str) -> None:
+        if set(snapshot) != set(self._bindings):
+            msg = f"{label} snapshot has different slot set"
+            raise LinearityError(msg)
+
+    def _snapshot_summary(self, snapshot: LinearitySnapshot) -> str:
+        parts = []
+        for slot in self._order:
+            binding = snapshot[slot]
+            parts.append(f"{slot}:{binding.local}/{binding.state.name}")
+        return "{" + ", ".join(parts) + "}"
+
+
+__all__ = [
+    "Binding",
+    "GuppyLinearityState",
+    "LinearityError",
+    "LinearitySnapshot",
+    "Slot",
+    "SlotState",
+]
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_linearity_helper.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_linearity_helper.py
new file mode 100644
index 000000000..cf5c1ee24
--- /dev/null
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_linearity_helper.py
@@ -0,0 +1,219 @@
+"""Unit tests for the Guppy-only linearity helper."""
+
+from __future__ import annotations
+
+import pytest
+from pecos.slr.ast.codegen.guppy_linearity import (
+    Binding,
+    GuppyLinearityState,
+    LinearityError,
+    Slot,
+    SlotState,
+)
+
+
+def test_slot_and_binding_are_stable_values() -> None:
+    slot = Slot("q", 0)
+    binding = Binding("q_0", SlotState.LIVE)
+
+    assert str(slot) == "q[0]"
+    assert slot == Slot("q", 0)
+    assert hash(slot) == hash(Slot("q", 0))
+    assert binding == Binding("q_0", SlotState.LIVE)
+
+
+def test_from_allocators_creates_live_bindings_in_stable_order() -> None:
+    state = GuppyLinearityState.from_allocators({"q": 2, "anc": 1})
+
+    assert list(state.bindings()) == [
+        (Slot("q", 0), Binding("q_0", SlotState.LIVE)),
+        (Slot("q", 1), Binding("q_1", SlotState.LIVE)),
+        (Slot("anc", 0), Binding("anc_0", SlotState.LIVE)),
+    ]
+
+
+def test_from_allocators_rejects_negative_sizes() -> None:
+    with pytest.raises(LinearityError, match="negative size"):
+        GuppyLinearityState.from_allocators({"q": -1})
+
+
+def test_set_live_consume_and_error_paths() -> None:
+    state = GuppyLinearityState.from_allocators({"q": 1})
+    slot = Slot("q", 0)
+
+    assert state.status(slot) is SlotState.LIVE
+    assert state.live(slot) == "q_0"
+
+    assert state.consume(slot) == "q_0"
+    assert state.status(slot) is SlotState.CONSUMED
+
+    with pytest.raises(LinearityError, match="consumed"):
+        state.live(slot)
+    with pytest.raises(LinearityError, match="consumed"):
+        state.consume(slot)
+
+    state.set_live(slot, "q_0")
+    assert state.binding(slot) == Binding("q_0", SlotState.LIVE)
+
+    unknown = Slot("q", 1)
+    with pytest.raises(LinearityError, match="Unknown"):
+        state.binding(unknown)
+    with pytest.raises(LinearityError, match="Unknown"):
+        state.set_live(unknown, "q_1")
+    with pytest.raises(LinearityError, match="Unknown"):
+        state.consume(unknown)
+
+
+def test_discard_live_consumes_only_live_slots() -> None:
+    state = GuppyLinearityState.from_allocators({"q": 3})
+
+    state.consume(Slot("q", 1))
+
+    assert state.discard_live() == [
+        (Slot("q", 0), "q_0"),
+        (Slot("q", 2), "q_2"),
+    ]
+    assert state.status(Slot("q", 0)) is SlotState.CONSUMED
+    assert state.status(Slot("q", 1)) is SlotState.CONSUMED
+    assert state.status(Slot("q", 2)) is SlotState.CONSUMED
+    assert state.discard_live() == []
+
+
+def test_snapshot_and_restore_round_trip() -> None:
+    state = GuppyLinearityState.from_allocators({"q": 2})
+    before = state.snapshot()
+
+    state.consume(Slot("q", 0))
+    state.set_live(Slot("q", 1), "custom_q_1")
+
+    assert state.status(Slot("q", 0)) is SlotState.CONSUMED
+    assert state.live(Slot("q", 1)) == "custom_q_1"
+
+    state.restore(before)
+    assert list(state.bindings()) == [
+        (Slot("q", 0), Binding("q_0", SlotState.LIVE)),
+        (Slot("q", 1), Binding("q_1", SlotState.LIVE)),
+    ]
+
+
+def test_restore_rejects_snapshot_for_different_slot_set() -> None:
+    state = GuppyLinearityState.from_allocators({"q": 1})
+
+    with pytest.raises(LinearityError, match="different slot set"):
+        state.restore({})
+
+
+def test_merge_if_accepts_matching_explicit_branches() -> None:
+    state = GuppyLinearityState.from_allocators({"q": 1})
+    before = state.snapshot()
+
+    state.set_live(Slot("q", 0), "q_0")
+    then_state = state.snapshot()
+    state.restore(before)
+    state.set_live(Slot("q", 0), "q_0")
+    else_state = state.snapshot()
+
+    state.merge_if(before, then_state, else_state, label="If(c[0])")
+    assert state.live(Slot("q", 0)) == "q_0"
+
+
+def test_merge_if_accepts_identity_else_when_none() -> None:
+    state = GuppyLinearityState.from_allocators({"q": 1})
+    before = state.snapshot()
+
+    state.set_live(Slot("q", 0), "q_0")
+    then_state = state.snapshot()
+
+    state.merge_if(before, then_state, else_state=None, label="If(c[0])")
+    assert state.live(Slot("q", 0)) == "q_0"
+
+
+def test_merge_if_rejects_divergent_branch_states() -> None:
+    state = GuppyLinearityState.from_allocators({"q": 1})
+    before = state.snapshot()
+
+    state.consume(Slot("q", 0))
+    then_state = state.snapshot()
+
+    with pytest.raises(LinearityError, match="divergent"):
+        state.merge_if(before, then_state, else_state=None, label="If(c[0])")
+
+
+def test_assert_same_accepts_preserved_loop_body() -> None:
+    state = GuppyLinearityState.from_allocators({"q": 1})
+    before = state.snapshot()
+
+    state.set_live(Slot("q", 0), "q_0")
+    after = state.snapshot()
+
+    state.assert_same(before, after, label="Repeat(3)")
+    assert state.live(Slot("q", 0)) == "q_0"
+
+
+def test_assert_same_rejects_loop_body_that_changes_state() -> None:
+    state = GuppyLinearityState.from_allocators({"q": 1})
+    before = state.snapshot()
+
+    state.consume(Slot("q", 0))
+    after = state.snapshot()
+
+    with pytest.raises(LinearityError, match="changes Guppy slot state"):
+        state.assert_same(before, after, label="Repeat(3)")
+
+
+def test_permute_clean_swap() -> None:
+    state = GuppyLinearityState.from_allocators({"q": 2})
+
+    state.permute(
+        {
+            Slot("q", 0): Slot("q", 1),
+            Slot("q", 1): Slot("q", 0),
+        },
+        label="Permute(q[0], q[1])",
+    )
+
+    assert state.live(Slot("q", 0)) == "q_1"
+    assert state.live(Slot("q", 1)) == "q_0"
+
+
+def test_permute_cross_allocator_cycle() -> None:
+    state = GuppyLinearityState.from_allocators({"a": 1, "b": 1, "c": 1})
+
+    state.permute(
+        {
+            Slot("a", 0): Slot("b", 0),
+            Slot("b", 0): Slot("c", 0),
+            Slot("c", 0): Slot("a", 0),
+        },
+        label="Permute(a[0], b[0], c[0])",
+    )
+
+    assert state.live(Slot("a", 0)) == "b_0"
+    assert state.live(Slot("b", 0)) == "c_0"
+    assert state.live(Slot("c", 0)) == "a_0"
+
+
+def test_permute_rejects_non_bijective_mapping() -> None:
+    state = GuppyLinearityState.from_allocators({"q": 2})
+
+    with pytest.raises(LinearityError, match="bijective"):
+        state.permute(
+            {
+                Slot("q", 0): Slot("q", 1),
+                Slot("q", 1): Slot("q", 1),
+            },
+            label="bad Permute",
+        )
+
+
+def test_permute_rejects_unknown_slots() -> None:
+    state = GuppyLinearityState.from_allocators({"q": 1})
+
+    with pytest.raises(LinearityError, match="Unknown"):
+        state.permute(
+            {
+                Slot("q", 0): Slot("missing", 0),
+                Slot("missing", 0): Slot("q", 0),
+            },
+            label="bad Permute",
+        )

From 08f94a4d5bdc2ef34eb0739f022bf1dad64d991a Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Thu, 14 May 2026 15:25:17 -0600
Subject: [PATCH 010/136] Rewrite AST Guppy emitter for v1 linearity

---
 .../src/pecos/slr/ast/codegen/guppy.py        | 1134 ++++++++---------
 .../slr/ast_tests/test_ast_codegen_guppy.py   |   55 +-
 .../pecos/slr/ast_tests/test_ast_permute.py   |   22 +-
 .../pecos/slr/ast_tests/test_ast_roundtrip.py |   19 +-
 .../slr/ast_tests/test_codegen_equivalence.py |    4 +-
 .../slr_tests/ast_guppy/test_v1_acceptance.py |   10 +-
 6 files changed, 564 insertions(+), 680 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
index a9013e44a..192f4cbc7 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
@@ -11,46 +11,48 @@
 
 """AST to Guppy Python code generator.
 
-This module provides a visitor that transforms AST nodes into Guppy Python code.
-Guppy is a quantum programming language that compiles to HUGR.
-
-Example:
-    from pecos.slr.ast import slr_to_ast, Program
-    from pecos.slr.ast.codegen import AstToGuppy
-
-    # Convert SLR to AST
-    ast = slr_to_ast(slr_program)
-
-    # Generate Guppy code
-    generator = AstToGuppy()
-    guppy_code = generator.generate(ast)
+This emitter lowers SLR's allocator-style AST to Guppy source. Guppy has
+linear qubit ownership, so quantum arrays are unpacked to stable local qubit
+variables at function entry and the Guppy-only `GuppyLinearityState` tracks
+which local owns each logical slot while recursive descent emits statements.
 """
 
 from __future__ import annotations
 
+import re
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING
 
+from pecos.slr.ast.codegen.guppy_linearity import (
+    GuppyLinearityState,
+    LinearityError,
+    Slot,
+    SlotState,
+)
 from pecos.slr.ast.nodes import (
     AllocatorDecl,
     BinaryExpr,
     BinaryOp,
     BitExpr,
     BitRef,
+    BitTypeExpr,
     ForStmt,
     GateKind,
+    GateOp,
     IfStmt,
     LiteralExpr,
     MeasureOp,
     ParallelBlock,
+    PrepareOp,
+    QubitTypeExpr,
     RegisterDecl,
     RepeatStmt,
+    ReturnOp,
     UnaryExpr,
     UnaryOp,
     VarExpr,
     WhileStmt,
 )
-from pecos.slr.ast.visitor import BaseVisitor
 
 if TYPE_CHECKING:
     from pecos.slr.ast.nodes import (
@@ -58,64 +60,32 @@
         BarrierOp,
         CommentOp,
         Expression,
-        GateOp,
         PermuteOp,
-        PrepareOp,
         Program,
-        ReturnOp,
         SlotRef,
+        Statement,
     )
 
 
-# Mapping from AST GateKind to Guppy function names
-GATE_TO_GUPPY: dict[GateKind, str] = {
-    # Single-qubit Paulis
-    GateKind.X: "quantum.x",
-    GateKind.Y: "quantum.y",
-    GateKind.Z: "quantum.z",
-    # Hadamard
-    GateKind.H: "quantum.h",
-    # Phase gates
-    GateKind.S: "quantum.s",
-    GateKind.Sdg: "quantum.sdg",
-    GateKind.T: "quantum.t",
-    GateKind.Tdg: "quantum.tdg",
-    # Square root gates
-    GateKind.SX: "quantum.sx",
-    GateKind.SY: "quantum.sy",
-    GateKind.SZ: "quantum.sz",
-    GateKind.SXdg: "quantum.sxdg",
-    GateKind.SYdg: "quantum.sydg",
-    GateKind.SZdg: "quantum.szdg",
-    # Rotation gates
-    GateKind.RX: "quantum.rx",
-    GateKind.RY: "quantum.ry",
-    GateKind.RZ: "quantum.rz",
-    # Two-qubit gates
-    GateKind.CX: "quantum.cx",
-    GateKind.CY: "quantum.cy",
-    GateKind.CZ: "quantum.cz",
-    GateKind.CH: "quantum.ch",
-    # Two-qubit rotation gates
-    GateKind.SXX: "quantum.sxx",
-    GateKind.SYY: "quantum.syy",
-    GateKind.SZZ: "quantum.szz",
-    GateKind.SXXdg: "quantum.sxxdg",
-    GateKind.SYYdg: "quantum.syydg",
-    GateKind.SZZdg: "quantum.szzdg",
-    GateKind.RZZ: "quantum.rzz",
-    # Controlled rotation gates
-    GateKind.CRX: "quantum.crx",
-    GateKind.CRY: "quantum.cry",
-    GateKind.CRZ: "quantum.crz",
-    # Face rotations
-    GateKind.F: "quantum.f",
-    GateKind.Fdg: "quantum.fdg",
-    GateKind.F4: "quantum.f4",
-    GateKind.F4dg: "quantum.f4dg",
+FUNCTIONAL_GATES: dict[GateKind, str] = {
+    GateKind.X: "x",
+    GateKind.Y: "y",
+    GateKind.Z: "z",
+    GateKind.H: "h",
+    GateKind.S: "s",
+    GateKind.Sdg: "sdg",
+    GateKind.T: "t",
+    GateKind.Tdg: "tdg",
+    GateKind.SZ: "s",
+    GateKind.SZdg: "sdg",
+    GateKind.CX: "cx",
+    GateKind.CY: "cy",
+    GateKind.CZ: "cz",
+    GateKind.CH: "ch",
 }
 
-# Mapping from AST BinaryOp to Python operators
+FUNCTIONAL_GATE_IMPORTS = ", ".join(sorted(set(FUNCTIONAL_GATES.values()) | {"reset"}))
+
 BINARY_OP_TO_PYTHON: dict[BinaryOp, str] = {
     BinaryOp.ADD: "+",
     BinaryOp.SUB: "-",
@@ -134,32 +104,21 @@
     BinaryOp.RSHIFT: ">>",
 }
 
-# Mapping from AST UnaryOp to Python operators
-UNARY_OP_TO_PYTHON: dict[UnaryOp, str] = {
-    UnaryOp.NOT: "not",
-    UnaryOp.NEG: "-",
-}
+
+class GuppyCodegenError(LinearityError):
+    """Raised when the v1 AST -> Guppy emitter rejects an unsupported construct."""
 
 
 @dataclass
-class CodeGenContext:
-    """Context for code generation."""
+class GuppyContext:
+    """Mutable state for one Guppy emission run."""
 
     indent_level: int = 0
-    allocators: dict[str, int] = field(default_factory=dict)  # name -> capacity
-    allocator_parents: dict[str, str | None] = field(
-        default_factory=dict,
-    )  # name -> parent
-    allocator_offsets: dict[str, int] = field(
-        default_factory=dict,
-    )  # name -> offset in parent
-    registers: dict[str, int] = field(default_factory=dict)  # name -> size
-    measured_slots: set[tuple[str, int]] = field(
-        default_factory=set,
-    )  # (allocator, index)
-    measurement_vars: list[str] = field(
-        default_factory=list,
-    )  # variable names for results
+    root_allocators: dict[str, int] = field(default_factory=dict)
+    child_allocators: set[str] = field(default_factory=set)
+    registers: dict[str, RegisterDecl] = field(default_factory=dict)
+    linearity: GuppyLinearityState | None = None
+    temp_counter: int = 0
 
     def indent(self) -> str:
         """Return current indentation string."""
@@ -173,117 +132,51 @@ def pop_indent(self) -> None:
         """Decrease indentation level."""
         self.indent_level = max(0, self.indent_level - 1)
 
-    def mark_measured(self, allocator: str, index: int) -> None:
-        """Mark a qubit slot as consumed by measurement."""
-        self.measured_slots.add((allocator, index))
-
-    def is_allocator_fully_consumed(self, name: str) -> bool:
-        """Check if all slots of an allocator have been measured."""
-        if name not in self.allocators:
-            return False
-        capacity = self.allocators[name]
-        return all((name, i) in self.measured_slots for i in range(capacity))
+    def temp(self, prefix: str) -> str:
+        """Return a unique temporary local name."""
+        name = f"_{prefix}_{self.temp_counter}"
+        self.temp_counter += 1
+        return name
 
-    def get_root_allocator(self, name: str) -> str:
-        """Get the root allocator for a given allocator name."""
-        current = name
-        while self.allocator_parents.get(current) is not None:
-            current = self.allocator_parents[current]
-        return current
 
-    def get_absolute_index(self, allocator: str, index: int) -> int:
-        """Get the absolute index in the root allocator."""
-        offset = self.allocator_offsets.get(allocator, 0)
-        return offset + index
-
-
-class AstToGuppy(BaseVisitor[list[str]]):
-    """Visitor that generates Guppy Python code from AST.
-
-    Generates clean Guppy code that can be compiled to HUGR.
-
-    Usage:
-        generator = AstToGuppy()
-        lines = generator.generate(ast_program)
-        code = "\\n".join(lines)
-    """
+class AstToGuppy:
+    """Recursive-descent Guppy code generator for AST programs."""
 
     def __init__(self) -> None:
         """Initialize the generator."""
-        self.context = CodeGenContext()
+        self.context = GuppyContext()
 
     def generate(self, program: Program) -> list[str]:
-        """Generate Guppy code for a program.
-
-        Args:
-            program: The AST Program to generate code for.
-
-        Returns:
-            List of code lines.
-        """
-        self.context = CodeGenContext()
-        return self.visit(program)
-
-    def default_result(self) -> list[str]:
-        """Return empty list as default."""
-        return []
-
-    def combine_results(self, results: list[list[str]]) -> list[str]:
-        """Combine multiple results into a single list."""
-        combined = []
-        for r in results:
-            combined.extend(r)
-        return combined
-
-    # === Program ===
-
-    def visit_program(self, node: Program) -> list[str]:
-        """Generate code for a complete program."""
-        lines = []
-
-        # Standard imports
-        lines.append("from guppylang import guppy")
-        lines.append("from guppylang.std import quantum")
-        lines.append("from guppylang.std.quantum import qubit")
-        lines.append("")
-
-        # Process declarations to build context
-        for decl in node.declarations:
-            if isinstance(decl, AllocatorDecl):
-                self.context.allocators[decl.name] = decl.capacity
-                self.context.allocator_parents[decl.name] = decl.parent
-            elif isinstance(decl, RegisterDecl):
-                self.context.registers[decl.name] = decl.size
+        """Generate Guppy code for a program."""
+        self.context = GuppyContext()
+        self._collect_declarations(program)
+        self.context.linearity = GuppyLinearityState.from_allocators(self.context.root_allocators)
+        self._reject_child_allocators()
 
-        if node.allocator:
-            self.context.allocators[node.allocator.name] = node.allocator.capacity
-            self.context.allocator_parents[node.allocator.name] = node.allocator.parent
-
-        # Calculate offsets for child allocators (sequential allocation within parent)
-        self._calculate_allocator_offsets(node)
-
-        # First pass: scan body to find measurements (to determine return type)
-        self._scan_for_measurements(node.body)
-
-        # Generate function signature
-        func_name = node.name.lower()
-        params = self._generate_params(node)
-        return_type = self._generate_return_type(node)
+        body = list(program.body)
+        explicit_return = self._validate_return_position(body)
+        emitted_body = body[:-1] if explicit_return else body
 
+        lines = self._imports()
+        lines.append("")
         lines.append("@guppy")
-        lines.append(f"def {func_name}({params}) -> {return_type}:")
+        lines.append(f"def {program.name.lower()}({self._render_params()}) -> {self._return_type(explicit_return)}:")
 
-        # Generate body
         self.context.push_indent()
+        body_lines: list[str] = []
+        body_lines.extend(self._emit_entry_unpacks())
+        body_lines.extend(self._emit_register_initializers())
 
-        body_lines = []
-        for stmt in node.body:
-            body_lines.extend(self.visit(stmt))
+        for stmt in emitted_body:
+            body_lines.extend(self._emit_stmt(stmt))
 
-        # Add return statement
-        return_lines = self._generate_return_statement(node)
-        if return_lines:
-            body_lines.extend(return_lines)
+        if explicit_return is not None:
+            body_lines.extend(self._emit_explicit_return(explicit_return))
+        else:
+            body_lines.extend(self._emit_end_cleanup())
+            auto_return = self._auto_return_expr()
+            if auto_return is not None:
+                body_lines.append(f"{self.context.indent()}return {auto_return}")
 
         if body_lines:
             lines.extend(body_lines)
@@ -291,539 +184,520 @@ def visit_program(self, node: Program) -> list[str]:
             lines.append(f"{self.context.indent()}pass")
 
         self.context.pop_indent()
-
         return lines
 
-    def _scan_for_measurements(self, stmts: tuple) -> None:
-        """Scan statements to find all measurements and mark consumed qubits.
-
-        Also pre-registers measurement variable names for return type generation.
-        """
-        for stmt in stmts:
-            if isinstance(stmt, MeasureOp):
-                for i, target in enumerate(stmt.targets):
-                    self.context.mark_measured(target.allocator, target.index)
-                    # Pre-register measurement variable name
-                    if i < len(stmt.results):
-                        result = stmt.results[i]
-                        var_name = f"{result.register}_{result.index}"
-                    else:
-                        var_name = f"_m{len(self.context.measurement_vars)}"
-                    self.context.measurement_vars.append(var_name)
-            elif isinstance(stmt, IfStmt):
-                self._scan_for_measurements(stmt.then_body)
-                if stmt.else_body:
-                    self._scan_for_measurements(stmt.else_body)
-            elif isinstance(stmt, (ForStmt, WhileStmt, RepeatStmt, ParallelBlock)):
-                self._scan_for_measurements(stmt.body)
-
-    def _calculate_allocator_offsets(self, node: Program) -> None:
-        """Calculate the offset of each child allocator within its parent.
-
-        Children are allocated sequentially within their parent's capacity.
-        This allows translating child[i] to parent[offset + i].
-        """
-        # Track allocated space per parent
-        parent_next_offset: dict[str, int] = {}
-
-        # Root allocators have offset 0
-        for decl in node.declarations:
-            if isinstance(decl, AllocatorDecl) and decl.parent is None:
-                self.context.allocator_offsets[decl.name] = 0
-
-        if node.allocator and node.allocator.parent is None:
-            self.context.allocator_offsets[node.allocator.name] = 0
-
-        # Process child allocators in declaration order
-        for decl in node.declarations:
-            if isinstance(decl, AllocatorDecl) and decl.parent is not None:
-                parent = decl.parent
-                if parent not in parent_next_offset:
-                    parent_next_offset[parent] = 0
-
-                # Get parent's offset (for nested hierarchies)
-                parent_offset = self.context.allocator_offsets.get(parent, 0)
-
-                # This child's offset is parent's offset + next available slot
-                self.context.allocator_offsets[decl.name] = parent_offset + parent_next_offset[parent]
-
-                # Reserve space in parent
-                parent_next_offset[parent] += decl.capacity
-
-    def _generate_params(self, node: Program) -> str:
-        """Generate function parameters from declarations.
-
-        Only includes root allocators (those without parents) as function parameters.
-        Child allocators are derived from parent allocators within the function.
-        """
-        params = []
-
-        # Add allocator parameters (only root allocators without parents)
-        for decl in node.declarations:
-            if isinstance(decl, AllocatorDecl):
-                # Skip child allocators - they're derived from parents
-                if decl.parent is not None:
-                    continue
-                params.append(f"{decl.name}: array[qubit, {decl.capacity}] @owned")
-
-        if node.allocator and node.allocator.parent is None:
-            params.append(
-                f"{node.allocator.name}: array[qubit, {node.allocator.capacity}] @owned",
-            )
-
-        return ", ".join(params)
-
-    def _generate_return_type(self, node: Program) -> str:
-        """Generate return type annotation based on consumed/unconsumed qubits."""
-        return_types = []
-
-        # Only include qubit arrays that are NOT fully consumed by measurement
-        for decl in node.declarations:
-            if isinstance(decl, AllocatorDecl):
-                # Skip child allocators - only include root allocators in params/returns
-                if decl.parent is not None:
-                    continue
-                if not self.context.is_allocator_fully_consumed(decl.name):
-                    return_types.append(f"array[qubit, {decl.capacity}]")
-
-        if node.allocator and not self.context.is_allocator_fully_consumed(
-            node.allocator.name,
-        ):
-            return_types.append(f"array[qubit, {node.allocator.capacity}]")
-
-        # Add measurement results (bools)
-        if self.context.measurement_vars:
-            return_types.extend("bool" for _ in self.context.measurement_vars)
-
-        if not return_types:
-            return "None"
-        if len(return_types) == 1:
-            return return_types[0]
-        return f"tuple[{', '.join(return_types)}]"
-
-    def _generate_return_statement(self, node: Program) -> list[str]:
-        """Generate return statement with unconsumed qubits and measurement results."""
-        return_values = []
-
-        # Return unconsumed qubit arrays
-        for decl in node.declarations:
+    def _collect_declarations(self, program: Program) -> None:
+        for decl in program.declarations:
             if isinstance(decl, AllocatorDecl):
-                # Skip child allocators
-                if decl.parent is not None:
-                    continue
-                if not self.context.is_allocator_fully_consumed(decl.name):
-                    return_values.append(decl.name)
-
-        if node.allocator and not self.context.is_allocator_fully_consumed(
-            node.allocator.name,
-        ):
-            return_values.append(node.allocator.name)
-
-        # Return measurement results
-        return_values.extend(self.context.measurement_vars)
-
-        if not return_values:
-            return []
-
-        return [f"{self.context.indent()}return {', '.join(return_values)}"]
-
-    # === Declarations ===
-
-    def visit_allocator_decl(self, _node: AllocatorDecl) -> list[str]:
-        """Allocator declarations are handled at program level."""
-        return []
-
-    def visit_register_decl(self, _node: RegisterDecl) -> list[str]:
-        """Register declarations are handled at program level."""
-        return []
-
-    # === Gates ===
+                self._add_allocator_decl(decl)
+            elif isinstance(decl, RegisterDecl):
+                self.context.registers[decl.name] = decl
 
-    def visit_gate(self, node: GateOp) -> list[str]:
-        """Generate gate operation."""
-        gate_func = GATE_TO_GUPPY.get(node.gate, f"quantum.{node.gate.name.lower()}")
+        if program.allocator is not None:
+            self._add_allocator_decl(program.allocator)
 
-        # Generate target references
-        targets = [self._render_slot_ref(t) for t in node.targets]
+    def _add_allocator_decl(self, decl: AllocatorDecl) -> None:
+        if decl.parent is not None:
+            self.context.child_allocators.add(decl.name)
+            return
+        self.context.root_allocators.setdefault(decl.name, decl.capacity)
 
-        # Handle parameterized gates
-        if node.params:
-            params = [self._render_expression(p) for p in node.params]
-            args = ", ".join(params + targets)
-        else:
-            args = ", ".join(targets)
+    def _reject_child_allocators(self) -> None:
+        if self.context.child_allocators:
+            names = ", ".join(sorted(self.context.child_allocators))
+            msg = f"AST -> Guppy v1 does not support child allocators: {names}"
+            raise GuppyCodegenError(msg)
 
-        # Single qubit gates need reassignment for linearity
-        if node.gate.arity == 1:
-            target = targets[0]
-            return [f"{self.context.indent()}{target} = {gate_func}({target})"]
-        # Two-qubit gates return a tuple
+    def _imports(self) -> list[str]:
         return [
-            f"{self.context.indent()}{targets[0]}, {targets[1]} = {gate_func}({args})",
+            "from guppylang import guppy",
+            "from guppylang.std.builtins import array, owned",
+            "from guppylang.std.mem import mem_swap",
+            "from guppylang.std.quantum import discard, measure, qubit",
+            f"from guppylang.std.quantum.functional import {FUNCTIONAL_GATE_IMPORTS}",
         ]
 
-    def visit_prepare(self, node: PrepareOp) -> list[str]:
-        """Generate prepare/reset operation."""
-        lines = []
+    def _render_params(self) -> str:
+        return ", ".join(
+            f"{name}: array[qubit, {size}] @ owned" for name, size in self.context.root_allocators.items()
+        )
 
-        if node.slots is None:
-            # Prepare all - would need array iteration
-            lines.append(
-                f"{self.context.indent()}# Prepare all slots in {node.allocator}",
-            )
-        else:
-            for slot in node.slots:
-                ref = f"{node.allocator}[{slot}]"
-                # In Guppy, qubits start in |0⟩ state from allocation
-                # For re-preparation after measurement, we'd use reset
-                lines.append(
-                    f"{self.context.indent()}{ref} = quantum.reset({ref})",
-                )
+    def _return_type(self, explicit_return: ReturnOp | None) -> str:
+        if explicit_return is not None:
+            types = [self._return_value_type(value) for value in explicit_return.values]
+            return self._tuple_type(types)
 
+        types = [
+            f"array[bool, {decl.size}]"
+            for decl in self.context.registers.values()
+            if decl.is_result
+        ]
+        return self._tuple_type(types)
+
+    def _return_value_type(self, value: Expression | str) -> str:
+        if isinstance(value, str):
+            if value in self.context.root_allocators:
+                return f"array[qubit, {self.context.root_allocators[value]}]"
+            if value in self.context.registers:
+                return f"array[bool, {self.context.registers[value].size}]"
+            msg = f"Unsupported Guppy return value {value!r}"
+            raise GuppyCodegenError(msg)
+
+        if isinstance(value, BitExpr):
+            return "bool"
+        if isinstance(value, LiteralExpr) and isinstance(value.value, bool):
+            return "bool"
+        if isinstance(value, LiteralExpr) and isinstance(value.value, int):
+            return "int"
+        msg = f"Unsupported Guppy return expression {value!r}"
+        raise GuppyCodegenError(msg)
+
+    def _tuple_type(self, types: list[str]) -> str:
+        if not types:
+            return "None"
+        if len(types) == 1:
+            return types[0]
+        return f"tuple[{', '.join(types)}]"
+
+    def _emit_entry_unpacks(self) -> list[str]:
+        lines: list[str] = []
+        linearity = self._linearity()
+        for allocator, size in self.context.root_allocators.items():
+            if size == 0:
+                continue
+            locals_for_allocator = [
+                binding.local
+                for slot, binding in linearity.bindings()
+                if slot.allocator == allocator
+            ]
+            lhs = ", ".join(locals_for_allocator)
+            if size == 1:
+                lhs += ","
+            lines.append(f"{self.context.indent()}{lhs} = {allocator}")
         return lines
 
-    def visit_measure(self, node: MeasureOp) -> list[str]:
-        """Generate measurement operation.
+    def _emit_register_initializers(self) -> list[str]:
+        lines: list[str] = []
+        for decl in self.context.registers.values():
+            values = ", ".join("False" for _ in range(decl.size))
+            lines.append(f"{self.context.indent()}{decl.name} = array({values})")
+        return lines
 
-        In Guppy, quantum.measure() consumes the qubit and returns a bool.
-        We use local variable names for measurement results.
-        Variable names are pre-registered during scan phase for return type generation.
-        """
-        lines = []
+    def _validate_return_position(self, body: list[Statement]) -> ReturnOp | None:
+        return_count = self._count_returns(body)
+        if return_count == 0:
+            return None
+        if return_count == 1 and body and isinstance(body[-1], ReturnOp):
+            return body[-1]
+        msg = "AST -> Guppy v1 supports only one final root-level Return"
+        raise GuppyCodegenError(msg)
+
+    def _count_returns(self, body: list[Statement] | tuple[Statement, ...]) -> int:
+        count = 0
+        for stmt in body:
+            if isinstance(stmt, ReturnOp):
+                count += 1
+            elif isinstance(stmt, IfStmt):
+                count += self._count_returns(stmt.then_body)
+                count += self._count_returns(stmt.else_body)
+            elif isinstance(stmt, WhileStmt | ForStmt | RepeatStmt | ParallelBlock):
+                count += self._count_returns(stmt.body)
+        return count
+
+    def _emit_stmt(self, stmt: Statement) -> list[str]:
+        if isinstance(stmt, GateOp):
+            return self._emit_gate(stmt)
+        if isinstance(stmt, PrepareOp):
+            return self._emit_prepare(stmt)
+        if isinstance(stmt, MeasureOp):
+            return self._emit_measure(stmt)
+        if isinstance(stmt, IfStmt):
+            return self._emit_if(stmt)
+        if isinstance(stmt, RepeatStmt):
+            return self._emit_repeat(stmt)
+        if isinstance(stmt, ForStmt):
+            return self._emit_for(stmt)
+        if isinstance(stmt, WhileStmt):
+            msg = "AST -> Guppy v1 does not support While loops"
+            raise GuppyCodegenError(msg)
+        if isinstance(stmt, ParallelBlock):
+            return self._emit_parallel(stmt)
+        if isinstance(stmt, ReturnOp):
+            msg = "AST -> Guppy v1 supports Return only as the final root-level statement"
+            raise GuppyCodegenError(msg)
+
+        from pecos.slr.ast.nodes import AssignOp, BarrierOp, CommentOp, PermuteOp  # noqa: PLC0415
+
+        if isinstance(stmt, AssignOp):
+            return self._emit_assign(stmt)
+        if isinstance(stmt, BarrierOp):
+            return self._emit_barrier(stmt)
+        if isinstance(stmt, CommentOp):
+            return self._emit_comment(stmt)
+        if isinstance(stmt, PermuteOp):
+            return self._emit_permute(stmt)
+
+        msg = f"Unsupported AST statement for Guppy codegen: {type(stmt).__name__}"
+        raise GuppyCodegenError(msg)
+
+    def _emit_gate(self, node: GateOp) -> list[str]:
+        gate = FUNCTIONAL_GATES.get(node.gate)
+        if gate is None:
+            self._raise_unsupported_gate(node.gate)
 
-        for i, target in enumerate(node.targets):
-            target_ref = self._render_slot_ref(target)
+        if node.params:
+            msg = f"AST -> Guppy v1 does not support parameterized gate {node.gate.name}"
+            raise GuppyCodegenError(msg)
 
-            if i < len(node.results):
-                result = node.results[i]
-                # Use a proper local variable name instead of array indexing
-                var_name = f"{result.register}_{result.index}"
-            else:
-                # No result specified - use indexed name
-                var_name = f"_m{i}"
+        slots = [self._slot_from_ref(target) for target in node.targets]
+        if len(slots) != len(set(slots)):
+            msg = f"Gate {node.gate.name} uses the same qubit slot more than once"
+            raise GuppyCodegenError(msg)
 
-            lines.append(
-                f"{self.context.indent()}{var_name} = quantum.measure({target_ref})",
-            )
+        linearity = self._linearity()
+        locals_ = [linearity.live(slot) for slot in slots]
 
+        if node.gate.arity == 1:
+            local = locals_[0]
+            linearity.set_live(slots[0], local)
+            return [f"{self.context.indent()}{local} = {gate}({local})"]
+
+        if node.gate.arity == 2:
+            left, right = locals_
+            linearity.set_live(slots[0], left)
+            linearity.set_live(slots[1], right)
+            return [f"{self.context.indent()}{left}, {right} = {gate}({left}, {right})"]
+
+        msg = f"AST -> Guppy v1 does not support {node.gate.arity}-qubit gate {node.gate.name}"
+        raise GuppyCodegenError(msg)
+
+    def _raise_unsupported_gate(self, gate: GateKind) -> None:
+        if gate in {GateKind.SX, GateKind.SXdg, GateKind.SY, GateKind.SYdg}:
+            msg = f"AST -> Guppy v1 rejects {gate.name}; decompose it before Guppy emission"
+            raise GuppyCodegenError(msg)
+        if gate.is_parameterized:
+            msg = f"AST -> Guppy v1 does not support parameterized gate {gate.name}"
+            raise GuppyCodegenError(msg)
+        msg = f"AST -> Guppy v1 does not support gate {gate.name}"
+        raise GuppyCodegenError(msg)
+
+    def _emit_prepare(self, node: PrepareOp) -> list[str]:
+        lines: list[str] = []
+        slots = range(self.context.root_allocators[node.allocator]) if node.slots is None else node.slots
+        linearity = self._linearity()
+        for index in slots:
+            slot = Slot(node.allocator, index)
+            local = self._local_name(slot)
+            if linearity.status(slot) is SlotState.LIVE:
+                old_local = linearity.live(slot)
+                lines.append(f"{self.context.indent()}{old_local} = reset({old_local})")
+                linearity.set_live(slot, old_local)
+            else:
+                lines.append(f"{self.context.indent()}{local} = qubit()")
+                linearity.set_live(slot, local)
         return lines
 
-    # === Statements ===
-
-    def visit_assign(self, node: AssignOp) -> list[str]:
-        """Generate assignment operation."""
-        target = f"{node.target.register}[{node.target.index}]" if isinstance(node.target, BitRef) else str(node.target)
+    def _emit_measure(self, node: MeasureOp) -> list[str]:
+        lines: list[str] = []
+        linearity = self._linearity()
+        for index, target in enumerate(node.targets):
+            slot = self._slot_from_ref(target)
+            local = linearity.consume(slot)
+            if index < len(node.results):
+                result = self._render_bit_ref(node.results[index])
+                lines.append(f"{self.context.indent()}{result} = measure({local})")
+            else:
+                temp = self.context.temp("measurement")
+                lines.append(f"{self.context.indent()}{temp} = measure({local})")
+        return lines
 
+    def _emit_assign(self, node: AssignOp) -> list[str]:
+        target = self._render_bit_ref(node.target) if isinstance(node.target, BitRef) else str(node.target)
         value = self._render_expression(node.value)
         return [f"{self.context.indent()}{target} = {value}"]
 
-    def visit_barrier(self, node: BarrierOp) -> list[str]:
-        """Generate barrier (as comment - no direct Guppy equivalent)."""
-        if node.allocators:
-            allocs = ", ".join(node.allocators)
-            return [f"{self.context.indent()}# barrier({allocs})"]
+    def _emit_barrier(self, _node: BarrierOp) -> list[str]:
         return [f"{self.context.indent()}# barrier"]
 
-    def visit_comment(self, node: CommentOp) -> list[str]:
-        """Generate comment."""
-        if node.text:
-            return [f"{self.context.indent()}# {node.text}"]
-        return []
-
-    def visit_return(self, node: ReturnOp) -> list[str]:
-        """Generate return statement."""
-        if not node.values:
-            return [f"{self.context.indent()}return"]
-
-        values = []
-        for v in node.values:
-            if isinstance(v, str):
-                values.append(v)
-            else:
-                values.append(self._render_expression(v))
-
-        return [f"{self.context.indent()}return {', '.join(values)}"]
-
-    def visit_permute(self, node: PermuteOp) -> list[str]:
-        """Generate permutation (register swap) code.
-
-        Generates temp variable assignments to swap register references.
-        For Permute(a, b), generates:
-            # Swap a and b
-            _temp_a = a
-            a = b
-            b = _temp_a
-        """
-        lines = []
-
-        if len(node.sources) != len(node.targets):
-            lines.append(
-                f"{self.context.indent()}# ERROR: Permute sources/targets length mismatch",
-            )
-            return lines
-
-        if len(node.sources) == 0:
-            return lines
-
-        # Add comment if requested
-        if node.add_comment:
-            names = " and ".join(node.sources)
-            lines.append(f"{self.context.indent()}# Swap {names}")
-
-        # For a simple two-way swap: a, b = b, a
-        if len(node.sources) == 1 and node.sources[0] != node.targets[0]:
-            src = node.sources[0]
-            tgt = node.targets[0]
-            temp = f"_temp_{src}"
-            lines.append(f"{self.context.indent()}{temp} = {src}")
-            lines.append(f"{self.context.indent()}{src} = {tgt}")
-            lines.append(f"{self.context.indent()}{tgt} = {temp}")
-        elif len(node.sources) == 2 and set(node.sources) == set(node.targets):
-            # Simple swap: Permute([a, b], [b, a])
-            # Can use Python tuple swap
-            a, b = node.sources
-            lines.append(f"{self.context.indent()}{a}, {b} = {b}, {a}")
-        else:
-            # General case: use temp variables
-            temps = []
-            for src in node.sources:
-                temp = f"_temp_{src}"
-                temps.append(temp)
-                lines.append(f"{self.context.indent()}{temp} = {src}")
-
-            for i, src in enumerate(node.sources):
-                tgt = node.targets[i]
-                lines.append(f"{self.context.indent()}{src} = {tgt}")
-
-            for i, tgt in enumerate(node.targets):
-                lines.append(f"{self.context.indent()}{tgt} = {temps[i]}")
-
-        return lines
-
-    # === Control Flow ===
+    def _emit_comment(self, node: CommentOp) -> list[str]:
+        if not node.text:
+            return []
+        return [f"{self.context.indent()}# {line.strip()}" for line in node.text.splitlines()]
 
-    def visit_if(self, node: IfStmt) -> list[str]:
-        """Generate if statement."""
-        lines = []
+    def _emit_if(self, node: IfStmt) -> list[str]:
+        linearity = self._linearity()
+        before = linearity.snapshot()
 
         cond = self._render_expression(node.condition)
-        lines.append(f"{self.context.indent()}if {cond}:")
+        lines = [f"{self.context.indent()}if {cond}:"]
 
-        # Then block
         self.context.push_indent()
-        then_lines = []
-        for stmt in node.then_body:
-            then_lines.extend(self.visit(stmt))
-
-        if then_lines:
-            lines.extend(then_lines)
-        else:
-            lines.append(f"{self.context.indent()}pass")
+        then_lines = self._emit_block(node.then_body)
+        lines.extend(then_lines or [f"{self.context.indent()}pass"])
         self.context.pop_indent()
+        then_state = linearity.snapshot()
 
-        # Else block
+        linearity.restore(before)
+        else_state = None
         if node.else_body:
             lines.append(f"{self.context.indent()}else:")
             self.context.push_indent()
-            else_lines = []
-            for stmt in node.else_body:
-                else_lines.extend(self.visit(stmt))
-
-            if else_lines:
-                lines.extend(else_lines)
-            else:
-                lines.append(f"{self.context.indent()}pass")
+            else_lines = self._emit_block(node.else_body)
+            lines.extend(else_lines or [f"{self.context.indent()}pass"])
             self.context.pop_indent()
+            else_state = linearity.snapshot()
 
+        linearity.merge_if(before, then_state, else_state, label="If")
         return lines
 
-    def visit_while(self, node: WhileStmt) -> list[str]:
-        """Generate while loop."""
-        lines = []
-
-        cond = self._render_expression(node.condition)
-        lines.append(f"{self.context.indent()}while {cond}:")
+    def _emit_repeat(self, node: RepeatStmt) -> list[str]:
+        linearity = self._linearity()
+        before = linearity.snapshot()
+        lines = [f"{self.context.indent()}for _ in range({node.count}):"]
 
         self.context.push_indent()
-        body_lines = []
-        for stmt in node.body:
-            body_lines.extend(self.visit(stmt))
-
-        if body_lines:
-            lines.extend(body_lines)
-        else:
-            lines.append(f"{self.context.indent()}pass")
+        body_lines = self._emit_block(node.body)
+        lines.extend(body_lines or [f"{self.context.indent()}pass"])
         self.context.pop_indent()
 
+        after = linearity.snapshot()
+        linearity.assert_same(before, after, label=f"Repeat({node.count})")
         return lines
 
-    def visit_for(self, node: ForStmt) -> list[str]:
-        """Generate for loop."""
-        lines = []
-
+    def _emit_for(self, node: ForStmt) -> list[str]:
+        linearity = self._linearity()
         start = self._render_expression(node.start)
         stop = self._render_expression(node.stop)
-
-        if node.step:
+        if node.step is not None:
             step = self._render_expression(node.step)
-            lines.append(
-                f"{self.context.indent()}for {node.variable} in range({start}, {stop}, {step}):",
-            )
+            header = f"for {node.variable} in range({start}, {stop}, {step}):"
         else:
-            lines.append(
-                f"{self.context.indent()}for {node.variable} in range({start}, {stop}):",
-            )
+            header = f"for {node.variable} in range({start}, {stop}):"
 
+        before = linearity.snapshot()
+        lines = [f"{self.context.indent()}{header}"]
         self.context.push_indent()
-        body_lines = []
-        for stmt in node.body:
-            body_lines.extend(self.visit(stmt))
-
-        if body_lines:
-            lines.extend(body_lines)
-        else:
-            lines.append(f"{self.context.indent()}pass")
+        body_lines = self._emit_block(node.body)
+        lines.extend(body_lines or [f"{self.context.indent()}pass"])
         self.context.pop_indent()
 
+        after = linearity.snapshot()
+        linearity.assert_same(before, after, label=f"For({node.variable})")
         return lines
 
-    def visit_repeat(self, node: RepeatStmt) -> list[str]:
-        """Generate repeat loop (as for _ in range(n))."""
-        lines = []
-
-        lines.append(f"{self.context.indent()}for _ in range({node.count}):")
-
-        self.context.push_indent()
-        body_lines = []
-        for stmt in node.body:
-            body_lines.extend(self.visit(stmt))
-
-        if body_lines:
-            lines.extend(body_lines)
-        else:
-            lines.append(f"{self.context.indent()}pass")
-        self.context.pop_indent()
+    def _emit_parallel(self, node: ParallelBlock) -> list[str]:
+        return self._emit_block(node.body)
 
+    def _emit_block(self, body: tuple[Statement, ...]) -> list[str]:
+        lines: list[str] = []
+        for stmt in body:
+            lines.extend(self._emit_stmt(stmt))
         return lines
 
-    def visit_parallel(self, node: ParallelBlock) -> list[str]:
-        """Generate parallel block (as comment + sequential for now)."""
-        lines = []
-        lines.append(f"{self.context.indent()}# parallel begin")
-
-        for stmt in node.body:
-            lines.extend(self.visit(stmt))
-
-        lines.append(f"{self.context.indent()}# parallel end")
+    def _emit_permute(self, node: PermuteOp) -> list[str]:
+        if len(node.sources) != len(node.targets):
+            msg = "Permute source/target length mismatch"
+            raise GuppyCodegenError(msg)
+
+        quantum_mapping: dict[Slot, Slot] = {}
+        classical_mapping: dict[BitRef, BitRef] = {}
+        for source, target in zip(node.sources, node.targets, strict=True):
+            source_refs = self._expand_permute_ref(source)
+            target_refs = self._expand_permute_ref(target)
+            if len(source_refs) != len(target_refs):
+                msg = f"Permute element count mismatch for {source!r} -> {target!r}"
+                raise GuppyCodegenError(msg)
+            for source_ref, target_ref in zip(source_refs, target_refs, strict=True):
+                if isinstance(source_ref, Slot) and isinstance(target_ref, Slot):
+                    quantum_mapping[source_ref] = target_ref
+                elif isinstance(source_ref, BitRef) and isinstance(target_ref, BitRef):
+                    classical_mapping[source_ref] = target_ref
+                else:
+                    msg = f"Permute cannot map quantum and classical refs together: {source!r} -> {target!r}"
+                    raise GuppyCodegenError(msg)
+
+        lines: list[str] = []
+        if quantum_mapping:
+            self._linearity().permute(quantum_mapping, label="Permute")
+
+        if classical_mapping:
+            lines.extend(self._emit_classical_permute(classical_mapping))
+
+        if node.add_comment and (quantum_mapping or classical_mapping):
+            pairs = ", ".join(
+                f"{source} -> {target}" for source, target in zip(node.sources, node.targets, strict=True)
+            )
+            lines.insert(0, f"{self.context.indent()}# Permute: {pairs}")
         return lines
 
-    # === References ===
-
-    def visit_slot_ref(self, node: SlotRef) -> list[str]:
-        """Slot refs are rendered inline."""
-        return [self._render_slot_ref(node)]
-
-    def visit_bit_ref(self, node: BitRef) -> list[str]:
-        """Bit refs are rendered inline."""
-        return [f"{node.register}[{node.index}]"]
-
-    # === Expressions ===
-
-    def visit_literal(self, node: LiteralExpr) -> list[str]:
-        """Literals are rendered inline."""
-        return [self._render_literal(node)]
-
-    def visit_var(self, node: VarExpr) -> list[str]:
-        """Variables are rendered inline."""
-        return [node.name]
-
-    def visit_bit_expr(self, node: BitExpr) -> list[str]:
-        """Bit expressions are rendered inline."""
-        return [f"{node.ref.register}[{node.ref.index}]"]
-
-    def visit_binary(self, node: BinaryExpr) -> list[str]:
-        """Binary expressions are rendered inline."""
-        return [self._render_binary(node)]
-
-    def visit_unary(self, node: UnaryExpr) -> list[str]:
-        """Unary expressions are rendered inline."""
-        return [self._render_unary(node)]
-
-    # === Type expressions ===
+    def _expand_permute_ref(self, ref: str) -> list[Slot | BitRef]:
+        parsed = self._parse_indexed_ref(ref)
+        if parsed is not None:
+            name, index = parsed
+            if name in self.context.root_allocators:
+                return [Slot(name, index)]
+            if name in self.context.registers:
+                return [BitRef(register=name, index=index)]
+            msg = f"Unknown Permute ref {ref!r}"
+            raise GuppyCodegenError(msg)
+
+        if ref in self.context.root_allocators:
+            return [Slot(ref, index) for index in range(self.context.root_allocators[ref])]
+        if ref in self.context.registers:
+            return [BitRef(register=ref, index=index) for index in range(self.context.registers[ref].size)]
+
+        msg = f"Unknown Permute ref {ref!r}"
+        raise GuppyCodegenError(msg)
+
+    def _emit_classical_permute(self, mapping: dict[BitRef, BitRef]) -> list[str]:
+        if set(mapping) != set(mapping.values()):
+            msg = "Classical Permute must be bijective over the same bit set"
+            raise GuppyCodegenError(msg)
+
+        lines: list[str] = []
+        visited: set[BitRef] = set()
+        for start, target in mapping.items():
+            if start in visited or target == start:
+                visited.add(start)
+                continue
+            cycle = [start]
+            visited.add(start)
+            current = target
+            while current != start:
+                if current in visited:
+                    msg = "Classical Permute contains a malformed cycle"
+                    raise GuppyCodegenError(msg)
+                cycle.append(current)
+                visited.add(current)
+                current = mapping[current]
+
+            lines.extend(
+                f"{self.context.indent()}mem_swap({self._render_bit_ref(cycle[index])}, "
+                f"{self._render_bit_ref(cycle[index + 1])})"
+                for index in range(len(cycle) - 1)
+            )
+        return lines
 
-    def visit_qubit_type(self, _node: object) -> list[str]:
-        return ["qubit"]
+    def _emit_end_cleanup(self) -> list[str]:
+        return [f"{self.context.indent()}discard({local})" for _slot, local in self._linearity().discard_live()]
 
-    def visit_bit_type(self, _node: object) -> list[str]:
-        return ["bool"]
+    def _auto_return_expr(self) -> str | None:
+        values = [decl.name for decl in self.context.registers.values() if decl.is_result]
+        if not values:
+            return None
+        return ", ".join(values)
 
-    def visit_array_type(self, node) -> list[str]:
-        elem = self.visit(node.element)[0] if self.visit(node.element) else "qubit"
-        return [f"array[{elem}, {node.size}]"]
+    def _emit_explicit_return(self, node: ReturnOp) -> list[str]:
+        values = [self._return_value_expr(value) for value in node.values]
+        lines = self._emit_end_cleanup()
+        if values:
+            lines.append(f"{self.context.indent()}return {', '.join(values)}")
+        else:
+            lines.append(f"{self.context.indent()}return")
+        return lines
 
-    def visit_allocator_type(self, node) -> list[str]:
-        return [f"array[qubit, {node.capacity}]"]
+    def _return_value_expr(self, value: Expression | str) -> str:
+        if isinstance(value, str):
+            if value in self.context.root_allocators:
+                return self._consume_allocator_for_return(value)
+            if value in self.context.registers:
+                return value
+            msg = f"Unsupported Guppy return value {value!r}"
+            raise GuppyCodegenError(msg)
+        return self._render_expression(value)
+
+    def _consume_allocator_for_return(self, allocator: str) -> str:
+        linearity = self._linearity()
+        locals_ = [
+            linearity.consume(Slot(allocator, index))
+            for index in range(self.context.root_allocators[allocator])
+        ]
+        return f"array({', '.join(locals_)})"
 
-    # === Helper methods ===
+    def _linearity(self) -> GuppyLinearityState:
+        if self.context.linearity is None:
+            msg = "Guppy linearity state was not initialized"
+            raise GuppyCodegenError(msg)
+        return self.context.linearity
 
-    def _render_slot_ref(self, node: SlotRef) -> str:
-        """Render a slot reference as array access.
+    def _slot_from_ref(self, ref: SlotRef) -> Slot:
+        if ref.allocator not in self.context.root_allocators:
+            msg = f"AST -> Guppy v1 does not support allocator {ref.allocator!r}"
+            raise GuppyCodegenError(msg)
+        return Slot(ref.allocator, ref.index)
 
-        For child allocators, translates to root allocator with computed offset.
-        E.g., data[0] -> base[0], ancilla[0] -> base[4]
-        """
-        # Get the root allocator and absolute index
-        root = self.context.get_root_allocator(node.allocator)
-        abs_index = self.context.get_absolute_index(node.allocator, node.index)
+    def _local_name(self, slot: Slot) -> str:
+        return f"{slot.allocator}_{slot.index}"
 
-        return f"{root}[{abs_index}]"
+    def _render_bit_ref(self, ref: BitRef) -> str:
+        if ref.register not in self.context.registers:
+            msg = f"Unknown classical register {ref.register!r}"
+            raise GuppyCodegenError(msg)
+        return f"{ref.register}[{ref.index}]"
 
     def _render_expression(self, expr: Expression) -> str:
-        """Render an expression to a string."""
         if isinstance(expr, LiteralExpr):
             return self._render_literal(expr)
         if isinstance(expr, VarExpr):
             return expr.name
         if isinstance(expr, BitExpr):
-            # Use underscore naming to match measurement variable names
-            return f"{expr.ref.register}_{expr.ref.index}"
+            return self._render_bit_ref(expr.ref)
         if isinstance(expr, BinaryExpr):
             return self._render_binary(expr)
         if isinstance(expr, UnaryExpr):
             return self._render_unary(expr)
-        return str(expr)
-
-    def _render_literal(self, node: LiteralExpr) -> str:
-        """Render a literal value."""
-        if isinstance(node.value, bool):
-            return "True" if node.value else "False"
-        return str(node.value)
-
-    def _render_binary(self, node: BinaryExpr) -> str:
-        """Render a binary expression."""
-        left = self._render_expression(node.left)
-        right = self._render_expression(node.right)
-        op = BINARY_OP_TO_PYTHON.get(node.op, str(node.op))
+        msg = f"Unsupported Guppy expression {expr!r}"
+        raise GuppyCodegenError(msg)
+
+    def _render_literal(self, expr: LiteralExpr) -> str:
+        if isinstance(expr.value, bool):
+            return "True" if expr.value else "False"
+        return str(expr.value)
+
+    def _render_binary(self, expr: BinaryExpr) -> str:
+        left = self._render_expression(expr.left)
+        right = self._render_expression(expr.right)
+        op = BINARY_OP_TO_PYTHON.get(expr.op)
+        if op is None:
+            msg = f"Unsupported Guppy binary op {expr.op.name}"
+            raise GuppyCodegenError(msg)
         return f"({left} {op} {right})"
 
-    def _render_unary(self, node: UnaryExpr) -> str:
-        """Render a unary expression."""
-        operand = self._render_expression(node.operand)
-        op = UNARY_OP_TO_PYTHON.get(node.op, str(node.op))
-        return f"({op} {operand})"
-
+    def _render_unary(self, expr: UnaryExpr) -> str:
+        operand = self._render_expression(expr.operand)
+        if expr.op == UnaryOp.NOT:
+            return f"(not {operand})"
+        if expr.op == UnaryOp.NEG:
+            return f"(-{operand})"
+        msg = f"Unsupported Guppy unary op {expr.op.name}"
+        raise GuppyCodegenError(msg)
+
+    def _parse_indexed_ref(self, ref: str) -> tuple[str, int] | None:
+        match = re.fullmatch(r"([A-Za-z_]\w*)\[(\d+)\]", ref)
+        if match is None:
+            return None
+        return match.group(1), int(match.group(2))
+
+    def visit_qubit_type(self, _node: QubitTypeExpr) -> list[str]:
+        """Render a qubit type expression."""
+        return ["qubit"]
 
-def ast_to_guppy(program: Program) -> str:
-    """Convert an AST Program to Guppy Python code.
+    def visit_bit_type(self, _node: BitTypeExpr) -> list[str]:
+        """Render a bit type expression."""
+        return ["bool"]
 
-    Convenience function for simple code generation.
+    def visit_array_type(self, node: object) -> list[str]:
+        """Render an array type expression."""
+        if isinstance(node.element, QubitTypeExpr):
+            elem = "qubit"
+        elif isinstance(node.element, BitTypeExpr):
+            elem = "bool"
+        else:
+            elem = "qubit"
+        return [f"array[{elem}, {node.size}]"]
 
-    Args:
-        program: The AST Program to convert.
 
-    Returns:
-        Generated Guppy Python code as a string.
-    """
+def ast_to_guppy(program: Program) -> str:
+    """Convert an AST Program to Guppy Python code."""
     generator = AstToGuppy()
-    lines = generator.generate(program)
-    return "\n".join(lines)
+    return "\n".join(generator.generate(program))
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_codegen_guppy.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_codegen_guppy.py
index 4c9df090d..97ae82f89 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_codegen_guppy.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_codegen_guppy.py
@@ -28,7 +28,8 @@ def test_empty_program(self) -> None:
         code = ast_to_guppy(ast)
 
         assert "from guppylang import guppy" in code
-        assert "from guppylang.std import quantum" in code
+        assert "from guppylang.std.builtins import array, owned" in code
+        assert "from guppylang.std.quantum import discard, measure, qubit" in code
         assert "@guppy" in code
         assert "def main" in code
 
@@ -71,9 +72,9 @@ def test_single_qubit_gate(self) -> None:
 
         code = ast_to_guppy(ast)
 
-        # Should generate gate with reassignment for linearity
-        assert "quantum.h" in code
-        assert "q[0] = quantum.h(q[0])" in code
+        assert "q_0, = q" in code
+        assert "q_0 = h(q_0)" in code
+        assert "discard(q_0)" in code
 
     def test_two_qubit_gate(self) -> None:
         """Two-qubit gate generates tuple assignment."""
@@ -85,9 +86,8 @@ def test_two_qubit_gate(self) -> None:
 
         code = ast_to_guppy(ast)
 
-        # Two-qubit gates return tuple
-        assert "quantum.cx" in code
-        assert "q[0], q[1] = quantum.cx" in code
+        assert "q_0, q_1 = q" in code
+        assert "q_0, q_1 = cx(q_0, q_1)" in code
 
     def test_multiple_gates(self) -> None:
         """Multiple gates generate correct sequence."""
@@ -101,9 +101,9 @@ def test_multiple_gates(self) -> None:
 
         code = ast_to_guppy(ast)
 
-        assert "quantum.h" in code
-        assert "quantum.x" in code
-        assert "quantum.cz" in code
+        assert "q_0 = h(q_0)" in code
+        assert "q_1 = x(q_1)" in code
+        assert "q_0, q_1 = cz(q_0, q_1)" in code
 
 
 class TestAstToGuppyPrepMeasure:
@@ -120,12 +120,10 @@ def test_measure_with_result(self) -> None:
 
         code = ast_to_guppy(ast)
 
-        assert "quantum.measure" in code
-        # Measurement results use local variable names (c_0 instead of c[0])
-        assert "c_0 = quantum.measure(q[0])" in code
-        # Return type should be bool since all qubits are measured
-        assert "-> bool:" in code
-        assert "return c_0" in code
+        assert "c = array(False)" in code
+        assert "c[0] = measure(q_0)" in code
+        assert "-> array[bool, 1]:" in code
+        assert "return c" in code
 
 
 class TestAstToGuppyControlFlow:
@@ -145,7 +143,7 @@ def test_if_statement(self) -> None:
         code = ast_to_guppy(ast)
 
         assert "if" in code
-        assert "quantum.h" in code
+        assert "q_0 = h(q_0)" in code
 
     def test_if_else_statement(self) -> None:
         """If-else statement generates both branches."""
@@ -166,8 +164,8 @@ def test_if_else_statement(self) -> None:
 
         assert "if" in code
         assert "else:" in code
-        assert "quantum.h" in code
-        assert "quantum.x" in code
+        assert "q_0 = h(q_0)" in code
+        assert "q_0 = x(q_0)" in code
 
     def test_repeat_statement(self) -> None:
         """Repeat statement generates for-range loop."""
@@ -183,7 +181,7 @@ def test_repeat_statement(self) -> None:
 
         # Repeat becomes for _ in range(n)
         assert "for _ in range(3):" in code
-        assert "quantum.h" in code
+        assert "q_0 = h(q_0)" in code
 
 
 class TestAstToGuppyQEC:
@@ -208,8 +206,9 @@ def test_syndrome_extraction(self) -> None:
         assert "ancilla: array[qubit, 1]" in code
 
         # Check operations
-        assert "quantum.cx" in code
-        assert "quantum.measure" in code
+        assert "data_0, ancilla_0 = cx(data_0, ancilla_0)" in code
+        assert "data_1, ancilla_0 = cx(data_1, ancilla_0)" in code
+        assert "c[0] = measure(ancilla_0)" in code
 
 
 class TestAstToGuppyGenerator:
@@ -235,8 +234,8 @@ def test_generator_reusable(self) -> None:
         code1 = "\n".join(generator.generate(ast1))
         code2 = "\n".join(generator.generate(ast2))
 
-        assert "q[0]" in code1
-        assert "r[0]" in code2
+        assert "q_0 = h(q_0)" in code1
+        assert "r_0 = x(r_0)" in code2
 
     def test_indentation(self) -> None:
         """Generated code has proper indentation for nested blocks."""
@@ -291,10 +290,10 @@ def test_full_pipeline(self) -> None:
         assert "from guppylang import guppy" in code
         assert "@guppy" in code
         assert "def main" in code
-        assert "quantum.h" in code
-        assert "quantum.cx" in code
+        assert "q_0 = h(q_0)" in code
+        assert "q_0, q_1 = cx(q_0, q_1)" in code
         assert "if" in code
-        assert "quantum.x" in code
+        assert "q_2 = x(q_2)" in code
 
     def test_bell_state_circuit(self) -> None:
         """Test a simple Bell state circuit."""
@@ -318,5 +317,5 @@ def test_bell_state_circuit(self) -> None:
         assert any("def main" in line for line in lines)
 
         # Check gates are in function body (indented)
-        gate_lines = [line for line in lines if "quantum." in line]
+        gate_lines = [line for line in lines if " = h(" in line or " = cx(" in line]
         assert all(line.startswith("    ") for line in gate_lines)
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_permute.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_permute.py
index e48e86d4b..ecf21f25f 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_permute.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_permute.py
@@ -105,8 +105,26 @@ def test_permute_guppy_codegen(self) -> None:
         ast = slr_to_ast(prog)
 
         guppy = generate(ast, "guppy")
-        # Should contain swap code
-        assert "Swap" in guppy or "_temp_" in guppy or "a, b = b, a" in guppy
+        # Qubits are remapped logically in the Guppy slot state.
+        assert "# Permute: a -> b, b -> a" in guppy
+        assert "b_0 = x(b_0)" in guppy
+
+    def test_creg_permute_guppy_uses_mem_swap(self) -> None:
+        """Test CReg Permute uses Guppy's in-place swap helper."""
+        prog = Main(
+            c := CReg("c", 2),
+            d := CReg("d", 2),
+            c[0].set(1),
+            d[1].set(1),
+            Permute(c, d),
+        )
+        ast = slr_to_ast(prog)
+
+        guppy = generate(ast, "guppy")
+
+        assert "from guppylang.std.mem import mem_swap" in guppy
+        assert "mem_swap(c[0], d[0])" in guppy
+        assert "mem_swap(c[1], d[1])" in guppy
 
     def test_permute_qasm_codegen(self) -> None:
         """Test Permute generates QASM comment."""
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_roundtrip.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_roundtrip.py
index d4faf033a..df9eb3e33 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_roundtrip.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_roundtrip.py
@@ -202,11 +202,11 @@ def test_bell_state_guppy_structure(self) -> None:
 
         # Verify Guppy imports and structure
         assert "from guppylang import guppy" in guppy
-        assert "from guppylang.std import quantum" in guppy
+        assert "from guppylang.std.builtins import array, owned" in guppy
         assert "@guppy" in guppy
         assert "def main" in guppy.lower()
-        assert "quantum.h" in guppy
-        assert "quantum.cx" in guppy
+        assert "q_0 = h(q_0)" in guppy
+        assert "q_0, q_1 = cx(q_0, q_1)" in guppy
 
     def test_measurement_guppy_structure(self) -> None:
         """Test measurement generates correct Guppy structure."""
@@ -219,7 +219,7 @@ def test_measurement_guppy_structure(self) -> None:
         ast = slr_to_ast(prog)
         guppy = ast_to_guppy(ast)
 
-        assert "quantum.measure" in guppy
+        assert "c[0] = measure(q_0)" in guppy
 
 
 class TestRoundTripStim:
@@ -439,8 +439,9 @@ def test_same_qubit_order_all_generators(self) -> None:
 
         # Guppy
         guppy = ast_to_guppy(ast)
-        assert "a[0]" in guppy
-        assert "b[0]" in guppy
+        assert "a_0 = h(a_0)" in guppy
+        assert "b_0 = h(b_0)" in guppy
+        assert "a_0, b_0 = cx(a_0, b_0)" in guppy
 
     def test_gate_sequence_preserved_all_generators(self) -> None:
         """Test that gate sequence is preserved in all generators."""
@@ -462,9 +463,9 @@ def test_gate_sequence_preserved_all_generators(self) -> None:
 
         # Guppy - check order
         guppy = ast_to_guppy(ast)
-        h_pos = guppy.find("quantum.h")
-        x_pos = guppy.find("quantum.x")
-        z_pos = guppy.find("quantum.z")
+        h_pos = guppy.find("q_0 = h(q_0)")
+        x_pos = guppy.find("q_0 = x(q_0)")
+        z_pos = guppy.find("q_0 = z(q_0)")
         assert h_pos < x_pos < z_pos, "Gate order not preserved in Guppy"
 
 
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_codegen_equivalence.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_codegen_equivalence.py
index 03e32b2be..b9e7cf86d 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_codegen_equivalence.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_codegen_equivalence.py
@@ -200,10 +200,10 @@ def test_bell_state_guppy_structure(self) -> None:
 
         # Both should have H and CX gates
         assert "quantum.h" in direct_guppy.lower() or ".h(" in direct_guppy.lower()
-        assert "quantum.h" in ast_guppy.lower() or ".h(" in ast_guppy.lower()
+        assert " = h(" in ast_guppy.lower()
 
         assert "quantum.cx" in direct_guppy.lower() or ".cx(" in direct_guppy.lower()
-        assert "quantum.cx" in ast_guppy.lower() or ".cx(" in ast_guppy.lower()
+        assert " = cx(" in ast_guppy.lower()
 
 
 class TestQIREquivalence:
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_acceptance.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_acceptance.py
index 52298c09a..29bb76168 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_acceptance.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_acceptance.py
@@ -17,19 +17,11 @@
 
 from __future__ import annotations
 
-import pytest
-
 from pecos.slr import Block, CReg, If, Main, QReg, Repeat
 from pecos.slr.qeclib import qubit as qb
 from pecos.slr.qeclib.qubit.measures import Measure
 
-from ._harness import assert_ast_guppy_compiles
-
-
-pytestmark = pytest.mark.xfail(
-    strict=True,
-    reason="awaiting feat/ast-guppy-v1 emitter rewrite (Codex PR sequence)",
-)
+from ._harness import assert_ast_guppy_compiles  # noqa: TID252
 
 
 class TestStraightLine:

From 6905ae6ee2f235e25fbc845e444e483127a48ee9 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Thu, 14 May 2026 16:19:32 -0600
Subject: [PATCH 011/136] Clean up legacy AST Guppy tests after v1 emitter
 rewrite

---
 .../pecos/unit/test_slr_converter_guppy.py    | 136 +------
 .../slr_tests/guppy/test_array_patterns.py    | 197 +---------
 .../guppy/test_conditional_resources.py       | 158 +-------
 .../guppy/test_linearity_patterns.py          | 145 +-------
 .../slr_tests/guppy/test_loop_generation.py   | 118 ++----
 .../guppy/test_measurement_optimization.py    | 241 +-----------
 .../guppy/test_multi_qubit_measurements.py    | 292 +++------------
 .../guppy/test_partial_array_returns.py       | 155 ++------
 .../guppy/test_partial_consumption.py         | 183 ++-------
 .../slr_tests/guppy/test_register_wide_ops.py |  88 -----
 .../guppy/test_simple_slr_to_guppy.py         | 350 ++----------------
 .../guppy/test_steane_integration.py          | 109 ------
 .../pecos/unit/slr/test_guppy_generation.py   | 268 +++-----------
 .../test_guppy_generation_comprehensive.py    | 285 +++-----------
 .../unit/slr/test_repeat_to_guppy_pipeline.py | 116 ++----
 15 files changed, 333 insertions(+), 2508 deletions(-)
 delete mode 100644 python/quantum-pecos/tests/slr_tests/guppy/test_register_wide_ops.py
 delete mode 100644 python/quantum-pecos/tests/slr_tests/guppy/test_steane_integration.py

diff --git a/python/quantum-pecos/tests/pecos/unit/test_slr_converter_guppy.py b/python/quantum-pecos/tests/pecos/unit/test_slr_converter_guppy.py
index 3da0e0ed3..9c0b60d0a 100644
--- a/python/quantum-pecos/tests/pecos/unit/test_slr_converter_guppy.py
+++ b/python/quantum-pecos/tests/pecos/unit/test_slr_converter_guppy.py
@@ -9,33 +9,15 @@
 # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 # specific language governing permissions and limitations under the License.
 
-"""Tests for SlrConverter Guppy functionality."""
-
-from pecos.slr import CReg, Main, Parallel, QReg, SlrConverter
-from pecos.slr.qeclib import qubit as qb
-from pecos.slr.qeclib.steane.steane_class import Steane
+"""Tests for SlrConverter Guppy functionality.
 
+The v1 AST -> Guppy emitter is exercised via compile-and-run acceptance tests
+under ``tests/slr_tests/ast_guppy/``. Tests here cover surviving non-string
+checks (`SlrConverter.hugr()` legacy IR path, basic structural sanity) only.
+"""
 
-def test_slr_converter_guppy_simple() -> None:
-    """Test SlrConverter.guppy() with a simple program."""
-    prog = Main(
-        q := QReg("q", 2),
-        c := CReg("c", 2),
-        qb.H(q[0]),
-        qb.CX(q[0], q[1]),
-        qb.Measure(q) > c,
-    )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # Check that the generated code is valid Python
-    # AST codegen uses simplified imports
-    assert "from guppylang import guppy" in guppy_code
-    assert "@guppy" in guppy_code
-    # AST codegen uses array parameters
-    assert "def main(q:" in guppy_code
-    assert "quantum.h(" in guppy_code
-    assert "quantum.cx(" in guppy_code
+from pecos.slr import CReg, Main, QReg, SlrConverter
+from pecos.slr.qeclib import qubit as qb
 
 
 def test_slr_converter_guppy_does_not_have_undefined_variables() -> None:
@@ -99,88 +81,6 @@ def test_slr_converter_hugr_simple() -> None:
     assert hasattr(hugr, "modules")
 
 
-def test_slr_converter_steane_guppy_generation() -> None:
-    """Test that Steane code can generate Guppy code without undefined variables."""
-    prog = Main(
-        c := Steane("c"),
-        c.px(),  # Simple Pauli-X operation
-    )
-
-    # This should generate valid Guppy code without undefined variables
-    guppy_code = SlrConverter(prog).guppy()
-
-    # AST codegen uses array parameters instead of local declarations
-    # Check that c_a is declared as parameter or that c_a[i] is properly accessed
-    # Either c_a: array[...] @owned in params, or c_a = array(...) in body
-    c_a_in_params = "c_a: array[qubit" in guppy_code
-    c_a_declared = "c_a =" in guppy_code or "c_a=" in guppy_code
-
-    # If c_a appears in the code, it should be in params or declared
-    assert ("c_a" not in guppy_code) or c_a_in_params or c_a_declared
-
-    # Code should have quantum operations
-    assert "quantum." in guppy_code
-
-
-def test_slr_converter_steane_hugr_compilation() -> None:
-    """Test that Steane code can compile to HUGR.
-
-    This test verifies that the Steane code implementation can be successfully
-    compiled to HUGR format through guppylang. The test ensures that:
-
-    1. Ancilla arrays (like c_a) are properly detected and excluded from structs
-    2. These arrays are passed to functions with @owned annotation
-    3. Arrays are unpacked to individual variables to avoid MoveOutOfSubscriptError
-    4. The unpacked variables are used instead of array indexing in function bodies
-
-    The solution works by:
-    - Detecting ancilla qubits based on usage patterns (frequent measurement/reset)
-    - Excluding them from struct packing to keep them as separate arrays
-    - Unpacking @owned ancilla arrays at the start of functions
-    - Using the unpacked variables (e.g., c_a_0) instead of array access (c_a[0])
-
-    Note: The guppy code generation itself works correctly, but the final
-    compilation to HUGR fails due to API mismatch between guppylang-internals
-    (expecting hugr.build module) and hugr 0.13.0 (which doesn't have it).
-    """
-    prog = Main(
-        c := Steane("c"),
-        c.px(),
-    )
-
-    # This should work once guppylang supports the required patterns
-    hugr = SlrConverter(prog).hugr()
-    assert hugr is not None
-    assert hasattr(hugr, "modules")
-
-
-def test_slr_converter_parallel_blocks_guppy() -> None:
-    """Test Guppy generation with parallel blocks."""
-    prog = Main(
-        q := QReg("q", 4),
-        c := CReg("c", 4),
-        Parallel(
-            qb.H(q[0]),
-            qb.X(q[1]),
-            qb.H(q[2]),
-            qb.X(q[3]),
-        ),
-        qb.Measure(q) > c,
-    )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # Should contain the gates
-    assert "quantum.h(" in guppy_code
-    assert "quantum.x(" in guppy_code
-    assert "quantum.measure" in guppy_code
-
-    # Should not have undefined variables
-    undefined_vars = ["c_a", "c_a_0"]
-    for var in undefined_vars:
-        assert var not in guppy_code, f"Generated code contains undefined variable: {var}"
-
-
 def test_slr_converter_guppy_has_main_function() -> None:
     """Test that generated Guppy code has a proper main function."""
     prog = Main(
@@ -195,25 +95,3 @@ def test_slr_converter_guppy_has_main_function() -> None:
     # Should have main function with array parameters
     assert "def main(" in guppy_code
     assert "@guppy" in guppy_code
-
-
-def test_slr_converter_guppy_imports() -> None:
-    """Test that generated Guppy code has correct imports."""
-    prog = Main(
-        q := QReg("q", 1),
-        c := CReg("c", 1),
-        qb.H(q[0]),
-        qb.Measure(q) > c,
-    )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # AST codegen uses simplified imports
-    required_imports = [
-        "from guppylang import guppy",
-        "from guppylang.std import quantum",
-        "from guppylang.std.quantum import qubit",
-    ]
-
-    for imp in required_imports:
-        assert imp in guppy_code, f"Missing import: {imp}"
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_array_patterns.py b/python/quantum-pecos/tests/slr_tests/guppy/test_array_patterns.py
index 714b98c2f..542765a00 100644
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_array_patterns.py
+++ b/python/quantum-pecos/tests/slr_tests/guppy/test_array_patterns.py
@@ -1,10 +1,11 @@
 """Tests for array handling patterns in Guppy code generation.
 
-These tests verify various array patterns including:
-- Array unpacking for measurements
-- Swapping and permutation patterns
-- Option[qubit] patterns (future enhancement)
-- Array indexing vs unpacking trade-offs
+After the AST -> Guppy v1 emitter rewrite, the canonical acceptance corpus
+lives in ``tests/slr_tests/ast_guppy/test_v1_acceptance.py``. The legacy
+string-shape tests in this file are mostly duplicate coverage of that
+corpus and have been deleted; the surviving cases either exercise a
+v1 pattern not yet in the acceptance set (e.g. ``Permute``) or test
+non-Guppy fallthrough behavior on the legacy IR path.
 """
 
 import pytest
@@ -12,80 +13,12 @@
 from pecos.slr.qeclib import qubit
 from pecos.slr.qeclib.qubit.measures import Measure
 
+from ..ast_guppy._harness import assert_ast_guppy_compiles  # noqa: TID252
+
 
 class TestArrayUnpacking:
     """Test array unpacking patterns for measurements."""
 
-    def test_unpack_for_selective_measurement(self) -> None:
-        """Test selective measurements of individual qubits."""
-        prog = Main(
-            q := QReg("q", 4),
-            c := CReg("c", 4),
-            # Selective measurements
-            Measure(q[0]) > c[0],
-            qubit.H(q[1]),  # Operation between measurements
-            Measure(q[1]) > c[1],
-            Measure(q[2]) > c[2],
-            Measure(q[3]) > c[3],
-        )
-
-        guppy_code = SlrConverter(prog).guppy()
-
-        # AST codegen uses array indexing
-        # Check that measurements use array indexing
-        assert "quantum.measure(q[0])" in guppy_code
-        assert "quantum.measure(q[1])" in guppy_code
-
-        # Check that gate uses array indexing
-        assert "quantum.h(q[1])" in guppy_code
-
-    def test_no_unpack_for_full_measurement(self) -> None:
-        """Test full array measurements."""
-        prog = Main(
-            q := QReg("q", 4),
-            c := CReg("c", 4),
-            qubit.H(q[0]),
-            qubit.CX(q[0], q[1]),
-            # Full array measurement
-            Measure(q) > c,
-        )
-
-        guppy_code = SlrConverter(prog).guppy()
-
-        # AST codegen measures each qubit individually
-        assert "quantum.measure(q[0])" in guppy_code
-        assert "quantum.measure(q[1])" in guppy_code
-        assert "quantum.measure(q[2])" in guppy_code
-        assert "quantum.measure(q[3])" in guppy_code
-
-    def test_unpack_timing_for_first_measurement(self) -> None:
-        """Test measurement order is preserved."""
-        prog = Main(
-            q := QReg("q", 3),
-            c := CReg("c", 3),
-            # Operations before measurement
-            qubit.H(q[0]),
-            qubit.CX(q[0], q[1]),
-            qubit.CX(q[1], q[2]),
-            # First measurement triggers unpacking
-            Measure(q[1]) > c[1],  # Not measuring in order
-            Measure(q[0]) > c[0],
-            Measure(q[2]) > c[2],
-        )
-
-        guppy_code = SlrConverter(prog).guppy()
-
-        # AST codegen uses array parameters and indexing
-        assert "q: array[qubit, 3]" in guppy_code
-        assert "quantum.h(q[0])" in guppy_code
-        assert "quantum.cx(q[0], q[1])" in guppy_code
-        assert "quantum.cx(q[1], q[2])" in guppy_code
-
-        # Measurements use array indexing
-        assert "c_1 = quantum.measure(q[1])" in guppy_code
-        assert "c_0 = quantum.measure(q[0])" in guppy_code
-        assert "c_2 = quantum.measure(q[2])" in guppy_code
-
     @pytest.mark.optional_dependency
     def test_unique_unpacked_names(self) -> None:
         """Test that unpacked names avoid conflicts."""
@@ -113,129 +46,21 @@ def test_unique_unpacked_names(self) -> None:
 
 
 class TestArraySwapPatterns:
-    """Test patterns for swapping array elements."""
+    """Test patterns for swapping array elements via Permute."""
 
     def test_permute_operation(self) -> None:
-        """Test Permute operation for register swapping."""
+        """Permute on whole quantum registers compiles via the AST emitter."""
         prog = Main(
             q1 := QReg("q1", 2),
             q2 := QReg("q2", 2),
             c := CReg("c", 4),
-            # Prepare states
             qubit.H(q1[0]),
             qubit.X(q2[0]),
-            # Swap registers
             Permute(q1, q2),
-            # Measure (q1 and q2 are swapped)
             Measure(q1) > c[0:2],
             Measure(q2) > c[2:4],
         )
-
-        guppy_code = SlrConverter(prog).guppy()
-
-        # Permute operation generates a swap comment
-        assert "# Swap" in guppy_code
-        # AST codegen uses Python tuple swap syntax
-        assert "q1, q2 = q2, q1" in guppy_code
-
-    def test_manual_element_swap(self) -> None:
-        """Test measuring in different order than indices."""
-        # This pattern might be used to reorder qubits
-        prog = Main(
-            q := QReg("q", 3),
-            c := CReg("c", 3),
-            # Prepare different states
-            qubit.H(q[0]),
-            qubit.X(q[1]),
-            qubit.Y(q[2]),
-            # Measure in different order
-            Measure(q[2]) > c[0],
-            Measure(q[0]) > c[1],
-            Measure(q[1]) > c[2],
-        )
-
-        guppy_code = SlrConverter(prog).guppy()
-
-        # AST codegen uses array indexing
-        assert "quantum.h(q[0])" in guppy_code
-        assert "quantum.x(q[1])" in guppy_code
-        assert "quantum.y(q[2])" in guppy_code
-        # Measurements in the specified order
-        assert "c_0 = quantum.measure(q[2])" in guppy_code
-        assert "c_1 = quantum.measure(q[0])" in guppy_code
-        assert "c_2 = quantum.measure(q[1])" in guppy_code
-
-
-class TestMeasurementIntoArrays:
-    """Test patterns for measuring into classical arrays."""
-
-    def test_measure_into_preallocated_array(self) -> None:
-        """Test measuring qubits into classical variables."""
-        prog = Main(
-            q := QReg("q", 4),
-            c := CReg("c", 4),
-            # Initialize qubits
-            qubit.H(q[0]),
-            qubit.CX(q[0], q[1]),
-            # Measure into specific indices
-            Measure(q[0]) > c[0],
-            Measure(q[1]) > c[1],
-            Measure(q[2]) > c[2],
-            Measure(q[3]) > c[3],
-        )
-
-        guppy_code = SlrConverter(prog).guppy()
-
-        # AST codegen uses array indexing for qubits
-        assert "quantum.h(q[0])" in guppy_code
-        assert "quantum.cx(q[0], q[1])" in guppy_code
-        assert "c_0 = quantum.measure(q[0])" in guppy_code
-        assert "c_1 = quantum.measure(q[1])" in guppy_code
-
-    def test_measure_into_multiple_arrays(self) -> None:
-        """Test measuring into different classical variables."""
-        prog = Main(
-            q := QReg("q", 4),
-            even := CReg("even", 2),
-            odd := CReg("odd", 2),
-            # Measure even indices to one array, odd to another
-            Measure(q[0]) > even[0],
-            Measure(q[2]) > even[1],
-            Measure(q[1]) > odd[0],
-            Measure(q[3]) > odd[1],
-        )
-
-        guppy_code = SlrConverter(prog).guppy()
-
-        # AST codegen uses array indexing
-        # Results distributed to correctly named variables
-        assert "even_0 = quantum.measure(q[0])" in guppy_code
-        assert "even_1 = quantum.measure(q[2])" in guppy_code
-        assert "odd_0 = quantum.measure(q[1])" in guppy_code
-        assert "odd_1 = quantum.measure(q[3])" in guppy_code
-
-    def test_partial_array_measurement(self) -> None:
-        """Test measuring only part of a quantum array."""
-        prog = Main(
-            q := QReg("q", 5),
-            c := CReg("c", 3),
-            # Only measure first 3 qubits
-            Measure(q[0]) > c[0],
-            Measure(q[1]) > c[1],
-            Measure(q[2]) > c[2],
-            # q[3] and q[4] remain unmeasured
-        )
-
-        guppy_code = SlrConverter(prog).guppy()
-
-        # AST codegen uses array indexing
-        assert "c_0 = quantum.measure(q[0])" in guppy_code
-        assert "c_1 = quantum.measure(q[1])" in guppy_code
-        assert "c_2 = quantum.measure(q[2])" in guppy_code
-
-        # Unmeasured qubits are returned in the function signature
-        # since not all qubits are consumed
-        assert "array[qubit, 5]" in guppy_code
+        assert_ast_guppy_compiles(prog)
 
 
 class TestComplexArrayPatterns:
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_conditional_resources.py b/python/quantum-pecos/tests/slr_tests/guppy/test_conditional_resources.py
index 7f23054ac..362f373bc 100644
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_conditional_resources.py
+++ b/python/quantum-pecos/tests/slr_tests/guppy/test_conditional_resources.py
@@ -1,154 +1,22 @@
-"""Tests for conditional resource consumption handling."""
+"""Tests for conditional resource consumption handling.
+
+Most legacy tests in this file exercised divergent post-state branches
+(e.g. ``If(c).Then(Measure(q[1]))`` with no else, or ``Then`` and
+``Else`` measuring different qubits). The AST -> Guppy v1 emitter
+explicitly rejects those patterns -- the v1 acceptance corpus covers
+the supported state-preserving conditional in
+``tests/slr_tests/ast_guppy/test_v1_acceptance.py::TestControlFlow``.
+
+The remaining test below targets the legacy ``SlrConverter.hugr()``
+path, which still routes through the legacy IR generator and is
+unaffected by the AST emitter rewrite.
+"""
 
 import pytest
 from pecos.slr import CReg, If, Main, QReg, SlrConverter
-from pecos.slr.qeclib import qubit
 from pecos.slr.qeclib.qubit.measures import Measure
 
 
-def test_conditional_measurement_without_else() -> None:
-    """Test that conditional measurements without else properly consume resources."""
-    prog = Main(
-        q := QReg("q", 2),
-        flag := CReg("flag", 1),
-        result := CReg("result", 1),
-        # Get flag
-        Measure(q[0]) > flag[0],
-        # Conditionally measure second qubit
-        If(flag[0]).Then(
-            Measure(q[1]) > result[0],
-        ),
-    )
-
-    guppy = SlrConverter(prog).guppy()
-
-    # AST codegen generates conditionals with array indexing
-    assert "if flag_0:" in guppy
-    # Check measurements
-    assert "quantum.measure(q[0])" in guppy
-    assert "quantum.measure(q[1])" in guppy
-
-
-def test_if_else_different_measurements() -> None:
-    """Test that if-else blocks with different measurements balance resources."""
-    prog = Main(
-        q := QReg("q", 3),
-        flag := CReg("flag", 1),
-        result := CReg("result", 2),
-        # Get flag
-        Measure(q[0]) > flag[0],
-        # Different measurements in each branch
-        If(flag[0])
-        .Then(
-            Measure(q[1]) > result[0],
-        )
-        .Else(
-            Measure(q[2]) > result[1],
-        ),
-    )
-
-    guppy = SlrConverter(prog).guppy()
-
-    # AST codegen uses variable names for conditions
-    assert "if flag_0:" in guppy
-    assert "else:" in guppy
-
-    # Check that measurements are present
-    assert "quantum.measure(q[0])" in guppy
-    assert "quantum.measure(q[1])" in guppy
-    assert "quantum.measure(q[2])" in guppy
-
-
-def test_complex_conditional_with_gates() -> None:
-    """Test complex conditional with quantum gates and partial consumption."""
-    prog = Main(
-        q := QReg("q", 4),
-        flag := CReg("flag", 1),
-        result := CReg("result", 4),
-        qubit.H(q[0]),
-        Measure(q[0]) > flag[0],
-        If(flag[0])
-        .Then(
-            qubit.CX(q[1], q[2]),
-            Measure(q[1]) > result[1],
-            Measure(q[2]) > result[2],
-            # q[3] not measured in this branch
-        )
-        .Else(
-            qubit.X(q[3]),
-            Measure(q[3]) > result[3],
-            # q[1], q[2] not measured in this branch
-        ),
-    )
-
-    guppy = SlrConverter(prog).guppy()
-
-    # AST codegen uses array indexing
-    assert "quantum.h(q[0])" in guppy
-    assert "quantum.cx(q[1], q[2])" in guppy
-    assert "quantum.x(q[3])" in guppy
-
-    # Check that measurements happen in conditional branches
-    assert "quantum.measure(q[0])" in guppy
-
-
-def test_nested_conditionals() -> None:
-    """Test nested conditionals properly handle resource consumption."""
-    prog = Main(
-        q := QReg("q", 3),
-        flags := CReg("flags", 2),
-        result := CReg("result", 3),
-        Measure(q[0]) > flags[0],
-        If(flags[0]).Then(
-            Measure(q[1]) > flags[1],
-            If(flags[1]).Then(
-                Measure(q[2]) > result[2],
-            ),
-        ),
-    )
-
-    guppy = SlrConverter(prog).guppy()
-
-    # AST codegen uses array indexing
-    assert "quantum.measure(q[0])" in guppy
-    assert "quantum.measure(q[1])" in guppy
-    assert "quantum.measure(q[2])" in guppy
-
-    # Check nested if structure
-    assert "if flags_0:" in guppy
-    assert "if flags_1:" in guppy
-
-    # Should compile to HUGR without errors
-    hugr = SlrConverter(prog).hugr()
-    assert hugr is not None
-
-
-def test_no_else_with_unconsumed_resources() -> None:
-    """Test that missing else blocks are generated when needed for linearity."""
-    prog = Main(
-        q := QReg("q", 2),
-        flag := CReg("flag", 2),  # Need size 2 for flag[1]
-        Measure(q[0]) > flag[0],
-        If(flag[0]).Then(
-            # Only measure q[1] in then branch
-            Measure(q[1])
-            > flag[1],
-        ),
-        # No explicit else - should be generated
-    )
-
-    guppy = SlrConverter(prog).guppy()
-
-    # Should have if block with condition
-    assert "if flag_0:" in guppy
-    assert "quantum.measure(q[0])" in guppy
-    assert "quantum.measure(q[1])" in guppy
-
-    # Should compile to HUGR without errors
-    hugr = SlrConverter(prog).hugr()
-    assert hugr is not None
-
-
 @pytest.mark.optional_dependency
 def test_hugr_compilation_simple() -> None:
     """Test that simple conditional programs can compile to HUGR."""
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_linearity_patterns.py b/python/quantum-pecos/tests/slr_tests/guppy/test_linearity_patterns.py
index 03c0835f9..5023bf7cc 100644
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_linearity_patterns.py
+++ b/python/quantum-pecos/tests/slr_tests/guppy/test_linearity_patterns.py
@@ -1,23 +1,26 @@
 """Tests for SLR patterns that challenge Guppy's linearity requirements.
 
-These tests verify that the Guppy generator correctly handles:
-- Functions that modify but don't consume qubits
-- Partial measurements in main function
-- Conditional consumption patterns
-- Resource cleanup for linearity
+The v1 emitter rejects divergent post-states at control-flow joins, so the
+legacy ``conditional_consumption`` / ``all_paths_consume_resources``
+tests have been deleted (they exercised behavior the v1 design
+explicitly disallows). The remaining cases cover Block-flattening
+patterns that are in v1 scope but not part of the v1 acceptance set in
+``tests/slr_tests/ast_guppy/test_v1_acceptance.py``.
 """
 
 import pytest
-from pecos.slr import Block, CReg, If, Main, QReg, SlrConverter
+from pecos.slr import Block, CReg, Main, QReg, SlrConverter
 from pecos.slr.qeclib import qubit
 from pecos.slr.qeclib.qubit.measures import Measure
 
+from ..ast_guppy._harness import assert_ast_guppy_compiles  # noqa: TID252
+
 
 class TestLinearityPatterns:
     """Test patterns that challenge Guppy's linear type system."""
 
     def test_function_modifies_but_returns_qubits(self) -> None:
-        """Test function that modifies qubits and returns them."""
+        """Block subclass that modifies (but does not consume) qubits."""
 
         class PrepareGHZ(Block):
             """Prepare a GHZ state - modifies qubits but doesn't measure them."""
@@ -35,65 +38,12 @@ def __init__(self, q: QReg) -> None:
             q := QReg("q", 3),
             c := CReg("c", 3),
             PrepareGHZ(q),
-            # Use q after function call
             Measure(q) > c,
         )
-
-        guppy_code = SlrConverter(prog).guppy()
-
-        # AST codegen flattens blocks into main
-        # Check that GHZ operations are present
-        assert "quantum.h(q[0])" in guppy_code
-        assert "quantum.cx(q[0], q[1])" in guppy_code
-        assert "quantum.cx(q[1], q[2])" in guppy_code
-
-        # Measurements should follow
-        assert "quantum.measure(q[0])" in guppy_code
-
-    def test_main_with_unmeasured_qubits(self) -> None:
-        """Test main function that doesn't measure all qubits."""
-        prog = Main(
-            q := QReg("q", 5),
-            c := CReg("c", 2),
-            qubit.H(q[0]),
-            qubit.CX(q[0], q[1]),
-            # Only measure first two qubits
-            Measure(q[0]) > c[0],
-            Measure(q[1]) > c[1],
-            # q[2], q[3], q[4] are not measured
-        )
-
-        guppy_code = SlrConverter(prog).guppy()
-
-        # AST codegen returns unconsumed qubits
-        # Function should return the array since not all consumed
-        assert "array[qubit, 5]" in guppy_code
-        # Measurements are present
-        assert "quantum.measure(q[0])" in guppy_code
-        assert "quantum.measure(q[1])" in guppy_code
-
-    def test_conditional_consumption(self) -> None:
-        """Test conditional consumption of quantum resources."""
-        prog = Main(
-            q := QReg("q", 2),
-            flag := CReg("flag", 1),
-            result := CReg("result", 1),
-            # Set flag based on some condition
-            Measure(q[0]) > flag[0],
-            # Conditionally measure second qubit
-            If(flag[0]).Then(
-                Measure(q[1]) > result[0],
-            ),
-            # Note: q[1] might not be consumed if flag[0] is False
-        )
-
-        guppy_code = SlrConverter(prog).guppy()
-
-        # Should handle conditional consumption
-        assert "if flag_0:" in guppy_code
+        assert_ast_guppy_compiles(prog)
 
     def test_multiple_functions_passing_qubits(self) -> None:
-        """Test passing qubits through multiple functions."""
+        """Multiple Block subclasses sharing the same QReg."""
 
         class ApplyH(Block):
             def __init__(self, q: QReg) -> None:
@@ -114,17 +64,10 @@ def __init__(self, q: QReg) -> None:
             ApplyCNOT(q),
             Measure(q) > c,
         )
-
-        guppy_code = SlrConverter(prog).guppy()
-
-        # AST codegen flattens blocks into main
-        assert "quantum.h(q[0])" in guppy_code
-        assert "quantum.cx(q[0], q[1])" in guppy_code
-        assert "quantum.measure(q[0])" in guppy_code
-        assert "quantum.measure(q[1])" in guppy_code
+        assert_ast_guppy_compiles(prog)
 
     def test_partial_array_in_function(self) -> None:
-        """Test function that consumes part of an array."""
+        """Block consumes part of a QReg; the remainder is consumed at root."""
 
         class MeasureHalf(Block):
             def __init__(self, q: QReg, c: CReg) -> None:
@@ -134,7 +77,6 @@ def __init__(self, q: QReg, c: CReg) -> None:
                 self.ops = [
                     Measure(q[0]) > c[0],
                     Measure(q[1]) > c[1],
-                    # q[2] and q[3] remain unmeasured
                 ]
 
         prog = Main(
@@ -142,18 +84,10 @@ def __init__(self, q: QReg, c: CReg) -> None:
             partial := CReg("partial", 2),
             rest := CReg("rest", 2),
             MeasureHalf(q, partial),
-            # Measure remaining qubits
             Measure(q[2]) > rest[0],
             Measure(q[3]) > rest[1],
         )
-
-        guppy_code = SlrConverter(prog).guppy()
-
-        # AST codegen flattens blocks - verify all measurements present
-        assert "partial_0 = quantum.measure(q[0])" in guppy_code
-        assert "partial_1 = quantum.measure(q[1])" in guppy_code
-        assert "rest_0 = quantum.measure(q[2])" in guppy_code
-        assert "rest_1 = quantum.measure(q[3])" in guppy_code
+        assert_ast_guppy_compiles(prog)
 
     @pytest.mark.optional_dependency
     def test_empty_main_linearity(self) -> None:
@@ -173,7 +107,7 @@ def test_empty_main_linearity(self) -> None:
             pytest.fail(f"Empty main should compile: {e}")
 
     def test_nested_blocks_linearity(self) -> None:
-        """Test nested blocks handle linearity correctly."""
+        """Nested Block subclasses are flattened into main and compile."""
 
         class Inner(Block):
             def __init__(self, q: QReg, c: CReg) -> None:
@@ -192,7 +126,6 @@ def __init__(self, q: QReg, c: CReg) -> None:
                 self.ops = [
                     qubit.H(q[0]),
                     Inner(q, c),
-                    # q[1] still needs to be handled
                 ]
 
         prog = Main(
@@ -201,20 +134,14 @@ def __init__(self, q: QReg, c: CReg) -> None:
             Outer(q, c),
             Measure(q[1]) > c[1],
         )
-
-        guppy_code = SlrConverter(prog).guppy()
-
-        # AST codegen flattens nested blocks
-        assert "quantum.h(q[0])" in guppy_code
-        assert "c_0 = quantum.measure(q[0])" in guppy_code
-        assert "c_1 = quantum.measure(q[1])" in guppy_code
+        assert_ast_guppy_compiles(prog)
 
 
 class TestResourceManagement:
     """Test quantum resource allocation and deallocation patterns."""
 
     def test_function_with_local_qubits(self) -> None:
-        """Test function that allocates and consumes local qubits."""
+        """Block uses an ancilla register that is consumed inside the block."""
 
         class UseAncilla(Block):
             def __init__(self, data: QReg, ancilla: QReg, result: CReg) -> None:
@@ -225,7 +152,6 @@ def __init__(self, data: QReg, ancilla: QReg, result: CReg) -> None:
                 self.ops = [
                     qubit.CX(data[0], ancilla[0]),
                     Measure(ancilla[0]) > result[0],
-                    # ancilla consumed, data returned
                 ]
 
         prog = Main(
@@ -236,37 +162,4 @@ def __init__(self, data: QReg, ancilla: QReg, result: CReg) -> None:
             UseAncilla(data, ancilla, result),
             Measure(data[0]) > final[0],
         )
-
-        guppy_code = SlrConverter(prog).guppy()
-
-        # AST codegen flattens blocks
-        assert "quantum.cx(data[0], ancilla[0])" in guppy_code
-        assert "result_0 = quantum.measure(ancilla[0])" in guppy_code
-        assert "final_0 = quantum.measure(data[0])" in guppy_code
-
-    def test_all_paths_consume_resources(self) -> None:
-        """Test that all execution paths consume quantum resources."""
-        prog = Main(
-            q := QReg("q", 2),
-            flag := CReg("flag", 1),
-            result := CReg("result", 2),
-            # Get a flag
-            Measure(q[0]) > flag[0],
-            If(flag[0])
-            .Then(
-                qubit.X(q[1]),
-                Measure(q[1]) > result[1],
-            )
-            .Else(
-                qubit.Z(q[1]),
-                Measure(q[1]) > result[0],  # Different index
-            ),
-        )
-
-        guppy_code = SlrConverter(prog).guppy()
-
-        # Both branches should consume q[1]
-        assert "if flag_0:" in guppy_code
-        assert "else:" in guppy_code
-        assert "quantum.x(q[1])" in guppy_code
-        assert "quantum.z(q[1])" in guppy_code
+        assert_ast_guppy_compiles(prog)
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_loop_generation.py b/python/quantum-pecos/tests/slr_tests/guppy/test_loop_generation.py
index f86e23f2c..c4ce31b92 100644
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_loop_generation.py
+++ b/python/quantum-pecos/tests/slr_tests/guppy/test_loop_generation.py
@@ -1,16 +1,24 @@
-"""Test loop generation for register-wide operations."""
+"""Tests for register-wide gate expansion.
 
-from pecos.slr import Block, CReg, Main, QReg, SlrConverter
+The v1 emitter expands register-wide single-qubit gates (e.g. ``H(q)``)
+to one functional call per slot. The v1 acceptance corpus does not yet
+exercise this expansion, so the cases below verify the expanded form
+compiles. The legacy string assertions on ``quantum.h(q[i])`` were the
+buggy form and have been deleted.
+"""
+
+from pecos.slr import Block, CReg, Main, QReg
 from pecos.slr.qeclib import qubit
 from pecos.slr.qeclib.qubit.measures import Measure
 
+from ..ast_guppy._harness import assert_ast_guppy_compiles  # noqa: TID252
+
 
 def test_consecutive_gate_applications() -> None:
-    """Test that gates applied individually remain individual."""
+    """Apply the same single-qubit gate to each element individually."""
     prog = Main(
         q := QReg("q", 5),
         c := CReg("c", 5),
-        # Apply gates to consecutive elements individually
         qubit.H(q[0]),
         qubit.H(q[1]),
         qubit.H(q[2]),
@@ -18,74 +26,43 @@ def test_consecutive_gate_applications() -> None:
         qubit.H(q[4]),
         Measure(q) > c,
     )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # Individual applications remain individual (not merged into loops)
-    assert "quantum.h(q[0])" in guppy_code
-    assert "quantum.h(q[1])" in guppy_code
-    assert "quantum.h(q[2])" in guppy_code
-    assert "quantum.h(q[3])" in guppy_code
-    assert "quantum.h(q[4])" in guppy_code
+    assert_ast_guppy_compiles(prog)
 
 
 def test_register_wide_generates_loop() -> None:
-    """Test that register-wide operations are handled (loop or expanded)."""
+    """Register-wide H(q) expands to one call per slot."""
     prog = Main(
         q := QReg("q", 5),
         c := CReg("c", 5),
-        # Apply gate to entire register
-        qubit.H(q),  # May generate loop or expand to individual
+        qubit.H(q),
         Measure(q) > c,
     )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # AST codegen expands register-wide ops to individual operations
-    # Check that all qubits have H applied
-    h_count = guppy_code.count("quantum.h")
-    assert h_count >= 5, f"Expected at least 5 H gates, got {h_count}"
+    assert_ast_guppy_compiles(prog)
 
 
 def test_mixed_individual_and_register_wide() -> None:
-    """Test mixing individual and register-wide operations."""
+    """Mixing register-wide and element-specific operations on one QReg."""
     prog = Main(
         q := QReg("q", 4),
         c := CReg("c", 4),
-        # Mix register-wide and individual operations
-        qubit.H(q),  # Register-wide
-        qubit.X(q[0]),  # Individual
-        qubit.X(q[2]),  # Individual
-        qubit.Z(q),  # Register-wide
+        qubit.H(q),
+        qubit.X(q[0]),
+        qubit.X(q[2]),
+        qubit.Z(q),
         Measure(q) > c,
     )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # Should have H and Z applied to all qubits
-    h_count = guppy_code.count("quantum.h")
-    z_count = guppy_code.count("quantum.z")
-    assert h_count >= 4, f"Expected at least 4 H gates, got {h_count}"
-    assert z_count >= 4, f"Expected at least 4 Z gates, got {z_count}"
-
-    # Should have individual X operations
-    assert "quantum.x(q[0])" in guppy_code
-    assert "quantum.x(q[2])" in guppy_code
+    assert_ast_guppy_compiles(prog)
 
 
 def test_loop_in_function() -> None:
-    """Test register-wide operations in a function block.
-
-    Note: AST codegen flattens blocks into main and expands register-wide
-    operations to individual operations.
-    """
+    """Register-wide operations inside a Block subclass flatten and expand."""
 
     class ApplyHadamards(Block):
         def __init__(self, q: QReg) -> None:
             super().__init__()
             self.q = q
             self.ops = [
-                qubit.H(q),  # Apply to entire register
+                qubit.H(q),
             ]
 
     prog = Main(
@@ -94,69 +71,32 @@ def __init__(self, q: QReg) -> None:
         ApplyHadamards(q),
         Measure(q) > c,
     )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # AST codegen flattens blocks and expands register-wide ops
-    # Verify H is applied to all elements
-    h_count = guppy_code.count("quantum.h")
-    assert h_count >= 4, f"Expected at least 4 H gates, got {h_count}"
-
-    # Verify measurements
-    assert "quantum.measure(q[0])" in guppy_code
-    assert "quantum.measure(q[1])" in guppy_code
-
-    # Verify it compiles to HUGR (the real test of correctness)
-    hugr = SlrConverter(prog).hugr()
-    assert hugr is not None
+    assert_ast_guppy_compiles(prog)
 
 
 def test_different_gates_separate_loops() -> None:
-    """Test that different gates are applied to all qubits."""
+    """Several different register-wide gates on the same register."""
     prog = Main(
         q := QReg("q", 3),
         c := CReg("c", 3),
-        # Different gates on same register
         qubit.H(q),
         qubit.X(q),
         qubit.Y(q),
         qubit.Z(q),
         Measure(q) > c,
     )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # Each gate type should be applied 3 times (once per qubit)
-    h_count = guppy_code.count("quantum.h")
-    x_count = guppy_code.count("quantum.x")
-    y_count = guppy_code.count("quantum.y")
-    z_count = guppy_code.count("quantum.z")
-
-    assert h_count >= 3, f"Expected at least 3 H gates, got {h_count}"
-    assert x_count >= 3, f"Expected at least 3 X gates, got {x_count}"
-    assert y_count >= 3, f"Expected at least 3 Y gates, got {y_count}"
-    assert z_count >= 3, f"Expected at least 3 Z gates, got {z_count}"
+    assert_ast_guppy_compiles(prog)
 
 
 def test_multiple_registers() -> None:
-    """Test operations on multiple registers."""
+    """Register-wide operations across multiple QRegs."""
     prog = Main(
         q1 := QReg("q1", 3),
         q2 := QReg("q2", 3),
         c := CReg("c", 6),
-        # Apply gates to both registers
         qubit.H(q1),
         qubit.X(q2),
         Measure(q1) > c[0:3],
         Measure(q2) > c[3:6],
     )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # Should have H applied to q1 and X applied to q2
-    assert "quantum.h(q1[0])" in guppy_code
-    assert "quantum.h(q1[1])" in guppy_code
-    assert "quantum.h(q1[2])" in guppy_code
-    assert "quantum.x(q2[0])" in guppy_code
-    assert "quantum.x(q2[1])" in guppy_code
-    assert "quantum.x(q2[2])" in guppy_code
+    assert_ast_guppy_compiles(prog)
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_measurement_optimization.py b/python/quantum-pecos/tests/slr_tests/guppy/test_measurement_optimization.py
index f2f9cb535..a3aa1d061 100644
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_measurement_optimization.py
+++ b/python/quantum-pecos/tests/slr_tests/guppy/test_measurement_optimization.py
@@ -1,226 +1,25 @@
-"""Tests for measurement optimization in Guppy code generation.
-
-These tests verify that the Guppy generator handles measurement patterns:
-- Full array measurements
-- Selective measurements
-- Mixed measurement patterns
+"""Realistic measurement patterns built from v1 supported features.
+
+The straightforward measurement coverage (full-register, partial,
+selective, conditionals on measurement results) is in
+``tests/slr_tests/ast_guppy/test_v1_acceptance.py``. Surviving here is
+the QEC syndrome-extraction pattern, which combines Block flattening,
+register-wide measurement, and If-driven Pauli corrections in one
+realistic shape.
 """
 
-from pecos.slr import Block, CReg, If, Main, QReg, SlrConverter
+from pecos.slr import Block, CReg, If, Main, QReg
 from pecos.slr.qeclib import qubit
 from pecos.slr.qeclib.qubit.measures import Measure
 
-
-class TestMeasurementOptimization:
-    """Test measurement pattern handling."""
-
-    def test_full_array_measurement(self) -> None:
-        """Test that full array measurements are handled."""
-        prog = Main(
-            q := QReg("q", 5),
-            c := CReg("c", 5),
-            # Full array measurement
-            Measure(q) > c,
-        )
-
-        guppy_code = SlrConverter(prog).guppy()
-
-        # AST codegen measures each qubit individually
-        assert "quantum.measure(q[0])" in guppy_code
-        assert "quantum.measure(q[1])" in guppy_code
-        assert "quantum.measure(q[4])" in guppy_code
-
-    def test_selective_measurements_force_unpacking(self) -> None:
-        """Test that selective measurements are handled correctly."""
-        prog = Main(
-            q := QReg("q", 5),
-            c := CReg("c", 5),
-            qubit.H(q[0]),
-            # Selective measurements with operations between
-            Measure(q[0]) > c[0],
-            qubit.CX(q[1], q[2]),
-            Measure(q[1]) > c[1],
-            Measure(q[2]) > c[2],
-            Measure(q[3]) > c[3],
-            Measure(q[4]) > c[4],
-        )
-
-        guppy_code = SlrConverter(prog).guppy()
-
-        # AST codegen uses array indexing
-        assert "quantum.h(q[0])" in guppy_code
-        assert "c_0 = quantum.measure(q[0])" in guppy_code
-        assert "quantum.cx(q[1], q[2])" in guppy_code
-
-    def test_block_all_measurements_together(self) -> None:
-        """Test optimization when all measurements are consecutive in a block."""
-
-        class MeasureAll(Block):
-            def __init__(self, q: QReg, c: CReg) -> None:
-                super().__init__()
-                self.q = q
-                self.c = c
-                self.ops = [
-                    Measure(q[0]) > c[0],
-                    Measure(q[1]) > c[1],
-                    Measure(q[2]) > c[2],
-                    Measure(q[3]) > c[3],
-                ]
-
-        prog = Main(
-            q := QReg("q", 4),
-            c := CReg("c", 4),
-            qubit.H(q[0]),
-            MeasureAll(q, c),
-        )
-
-        guppy_code = SlrConverter(prog).guppy()
-
-        # AST codegen flattens blocks and uses array indexing
-        assert "quantum.h(q[0])" in guppy_code
-        assert "c_0 = quantum.measure(q[0])" in guppy_code
-        assert "c_3 = quantum.measure(q[3])" in guppy_code
-
-    def test_non_contiguous_measurements(self) -> None:
-        """Test handling of non-contiguous index measurements."""
-        prog = Main(
-            q := QReg("q", 6),
-            c := CReg("c", 3),
-            # Measure non-contiguous indices
-            Measure(q[0]) > c[0],
-            Measure(q[2]) > c[1],
-            Measure(q[4]) > c[2],
-        )
-
-        guppy_code = SlrConverter(prog).guppy()
-
-        # AST codegen uses array indexing
-        assert "c_0 = quantum.measure(q[0])" in guppy_code
-        assert "c_1 = quantum.measure(q[2])" in guppy_code
-        assert "c_2 = quantum.measure(q[4])" in guppy_code
-
-    def test_measurement_with_conditionals(self) -> None:
-        """Test measurements interleaved with conditionals."""
-        prog = Main(
-            q := QReg("q", 3),
-            c := CReg("c", 3),
-            Measure(q[0]) > c[0],
-            If(c[0]).Then(
-                qubit.X(q[1]),
-            ),
-            Measure(q[1]) > c[1],
-            Measure(q[2]) > c[2],
-        )
-
-        guppy_code = SlrConverter(prog).guppy()
-
-        # AST codegen uses array indexing for qubits, underscore naming for bits
-        assert "c_0 = quantum.measure(q[0])" in guppy_code
-        assert "if c_0:" in guppy_code
-        assert "quantum.x(q[1])" in guppy_code
-        assert "c_1 = quantum.measure(q[1])" in guppy_code
-        assert "c_2 = quantum.measure(q[2])" in guppy_code
-
-    def test_multiple_qreg_measurements(self) -> None:
-        """Test measurements across multiple quantum registers."""
-        prog = Main(
-            q1 := QReg("q1", 2),
-            q2 := QReg("q2", 2),
-            c1 := CReg("c1", 2),
-            c2 := CReg("c2", 2),
-            # Measure both registers fully
-            Measure(q1) > c1,
-            Measure(q2) > c2,
-        )
-
-        guppy_code = SlrConverter(prog).guppy()
-
-        # AST codegen measures each qubit individually
-        assert "c1_0 = quantum.measure(q1[0])" in guppy_code
-        assert "c1_1 = quantum.measure(q1[1])" in guppy_code
-        assert "c2_0 = quantum.measure(q2[0])" in guppy_code
-        assert "c2_1 = quantum.measure(q2[1])" in guppy_code
-
-    def test_partial_then_full_measurement(self) -> None:
-        """Test partial measurements followed by full measurement."""
-
-        class MeasureFirst(Block):
-            def __init__(self, q: QReg, c: CReg) -> None:
-                super().__init__()
-                self.q = q
-                self.c = c
-                self.ops = [
-                    Measure(q[0]) > c[0],
-                    Measure(q[1]) > c[1],
-                ]
-
-        prog = Main(
-            q := QReg("q", 4),
-            partial := CReg("partial", 2),
-            rest := CReg("rest", 2),
-            MeasureFirst(q, partial),
-            # Measure remaining qubits
-            Measure(q[2]) > rest[0],
-            Measure(q[3]) > rest[1],
-        )
-
-        guppy_code = SlrConverter(prog).guppy()
-
-        # AST codegen flattens blocks and measures all
-        assert "partial_0 = quantum.measure(q[0])" in guppy_code
-        assert "partial_1 = quantum.measure(q[1])" in guppy_code
-        assert "rest_0 = quantum.measure(q[2])" in guppy_code
-        assert "rest_1 = quantum.measure(q[3])" in guppy_code
-
-
-class TestMeasurementResultPacking:
-    """Test handling of measurement results."""
-
-    def test_pack_individual_results(self) -> None:
-        """Test individual measurement results are handled."""
-        prog = Main(
-            q := QReg("q", 3),
-            c := CReg("c", 3),
-            # Force individual measurements with operations between
-            Measure(q[0]) > c[0],
-            qubit.H(q[1]),
-            Measure(q[1]) > c[1],
-            qubit.H(q[2]),
-            Measure(q[2]) > c[2],
-        )
-
-        guppy_code = SlrConverter(prog).guppy()
-
-        # AST codegen uses array indexing
-        assert "c_0 = quantum.measure(q[0])" in guppy_code
-        assert "quantum.h(q[1])" in guppy_code
-        assert "c_1 = quantum.measure(q[1])" in guppy_code
-        assert "quantum.h(q[2])" in guppy_code
-        assert "c_2 = quantum.measure(q[2])" in guppy_code
-
-    def test_no_packing_for_partial_measurements(self) -> None:
-        """Test that partial measurements are handled correctly."""
-        prog = Main(
-            q := QReg("q", 4),
-            c := CReg("c", 4),
-            # Only measure some qubits
-            Measure(q[0]) > c[0],
-            Measure(q[1]) > c[1],
-            # c[2] and c[3] remain unset
-        )
-
-        guppy_code = SlrConverter(prog).guppy()
-
-        # AST codegen uses array indexing
-        assert "c_0 = quantum.measure(q[0])" in guppy_code
-        assert "c_1 = quantum.measure(q[1])" in guppy_code
+from ..ast_guppy._harness import assert_ast_guppy_compiles  # noqa: TID252
 
 
 class TestComplexPatterns:
     """Test complex measurement patterns from real QEC code."""
 
     def test_syndrome_extraction_pattern(self) -> None:
-        """Test typical syndrome extraction pattern."""
+        """Syndrome extraction Block + per-bit If corrections."""
 
         class ExtractSyndrome(Block):
             def __init__(self, data: QReg, ancilla: QReg, syndrome: CReg) -> None:
@@ -229,7 +28,6 @@ def __init__(self, data: QReg, ancilla: QReg, syndrome: CReg) -> None:
                 self.ancilla = ancilla
                 self.syndrome = syndrome
                 self.ops = [
-                    # Syndrome extraction circuit
                     qubit.H(ancilla[0]),
                     qubit.CX(data[0], ancilla[0]),
                     qubit.CX(data[1], ancilla[0]),
@@ -240,7 +38,6 @@ def __init__(self, data: QReg, ancilla: QReg, syndrome: CReg) -> None:
                     qubit.CX(data[4], ancilla[1]),
                     qubit.CX(data[5], ancilla[1]),
                     qubit.H(ancilla[1]),
-                    # Measure ancillas
                     Measure(ancilla) > syndrome,
                 ]
 
@@ -249,7 +46,6 @@ def __init__(self, data: QReg, ancilla: QReg, syndrome: CReg) -> None:
             ancilla := QReg("ancilla", 2),
             syndrome := CReg("syndrome", 2),
             ExtractSyndrome(data, ancilla, syndrome),
-            # Apply correction based on syndrome
             If(syndrome[0]).Then(
                 qubit.X(data[0]),
             ),
@@ -257,17 +53,4 @@ def __init__(self, data: QReg, ancilla: QReg, syndrome: CReg) -> None:
                 qubit.X(data[3]),
             ),
         )
-
-        guppy_code = SlrConverter(prog).guppy()
-
-        # AST codegen flattens blocks
-        assert "quantum.h(ancilla[0])" in guppy_code
-        assert "quantum.cx(data[0], ancilla[0])" in guppy_code
-        assert "syndrome_0 = quantum.measure(ancilla[0])" in guppy_code
-        assert "syndrome_1 = quantum.measure(ancilla[1])" in guppy_code
-
-        # Should have conditionals for corrections
-        assert "if syndrome_0:" in guppy_code
-        assert "if syndrome_1:" in guppy_code
-        assert "quantum.x(data[0])" in guppy_code
-        assert "quantum.x(data[3])" in guppy_code
+        assert_ast_guppy_compiles(prog)
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_multi_qubit_measurements.py b/python/quantum-pecos/tests/slr_tests/guppy/test_multi_qubit_measurements.py
index 3e8eb2fcb..414982768 100644
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_multi_qubit_measurements.py
+++ b/python/quantum-pecos/tests/slr_tests/guppy/test_multi_qubit_measurements.py
@@ -1,268 +1,82 @@
-"""Test multi-qubit measurement support in Guppy IR builder."""
+"""Multi-qubit ``Measure(...) > (c[0], c[1], ...)`` patterns.
 
-from pecos.slr import Block, CReg, QReg
+The legacy tests instantiated a bare ``Block`` and called
+``SlrConverter(block).guppy()`` directly, which the v1 AST -> Guppy
+emitter does not accept (root allocators must be declared at the
+Program level). These rewrites wrap each pattern in a ``Main`` and
+verify the generated Guppy compiles via the v1 harness.
+"""
+
+from pecos.slr import CReg, Main, QReg
 from pecos.slr.qeclib import qubit
-from pecos.slr.slr_converter import SlrConverter
 
+from ..ast_guppy._harness import assert_ast_guppy_compiles  # noqa: TID252
 
-class MultiQubitMeasureWithOutputs(Block):
-    """Test block with multi-qubit measurement and classical outputs."""
 
-    def __init__(self, q: QReg, c: CReg) -> None:
-        """Measure multiple qubits into classical bits.
+class TestMultiQubitMeasurements:
+    """Multi-qubit ``Measure`` with classical outputs."""
 
-        Args:
-            q: Quantum register with 3 qubits
-            c: Classical register with 3 bits
-        """
-        super().__init__()
-        self.extend(
-            # Multi-qubit measurement with classical outputs
-            qubit.Measure(q[0], q[1], q[2])
-            > (c[0], c[1], c[2]),
+    def test_multi_qubit_with_outputs(self) -> None:
+        prog = Main(
+            q := QReg("q", 3),
+            c := CReg("c", 3),
+            qubit.Measure(q[0], q[1], q[2]) > (c[0], c[1], c[2]),
         )
+        assert_ast_guppy_compiles(prog)
 
-
-class MultiQubitMeasureWithoutOutputs(Block):
-    """Test block with multi-qubit measurement but no classical outputs."""
-
-    def __init__(self, q: QReg) -> None:
-        """Measure multiple qubits without storing results.
-
-        Args:
-            q: Quantum register with 3 qubits
-        """
-        super().__init__()
-        self.extend(
-            # Multi-qubit measurement without classical outputs
+    def test_multi_qubit_without_outputs(self) -> None:
+        prog = Main(
+            q := QReg("q", 3),
             qubit.Measure(q[0], q[1], q[2]),
         )
+        assert_ast_guppy_compiles(prog)
 
-
-class MixedMeasurements(Block):
-    """Test block with both single and multi-qubit measurements."""
-
-    def __init__(self, q: QReg, c: CReg) -> None:
-        """Mix of single and multi-qubit measurements.
-
-        Args:
-            q: Quantum register with 5 qubits
-            c: Classical register with 5 bits
-        """
-        super().__init__()
-        self.extend(
-            # Single qubit measurement
+    def test_mixed_measurements(self) -> None:
+        prog = Main(
+            q := QReg("q", 5),
+            c := CReg("c", 5),
             qubit.Measure(q[0]) > c[0],
-            # Multi-qubit measurement
             qubit.Measure(q[1], q[2], q[3]) > (c[1], c[2], c[3]),
-            # Another single measurement
             qubit.Measure(q[4]) > c[4],
         )
-
-
-class MismatchedMeasurement(Block):
-    """Test block with mismatched qubit/output counts (should generate error comment)."""
-
-    def __init__(self, q: QReg, c: CReg) -> None:
-        """Intentionally mismatched measurement.
-
-        Args:
-            q: Quantum register with 3 qubits
-            c: Classical register with 2 bits (intentional mismatch)
-        """
-        super().__init__()
-        # This creates a measurement with 3 qubits but only 2 outputs
-        # In practice, this might not be possible due to PECOS validation,
-        # but we test the IR builder's handling
-        meas = qubit.Measure(q[0], q[1], q[2])
-        meas.cout = (c[0], c[1])  # Manually set mismatched outputs
-        self.extend(meas)
-
-
-class TestMultiQubitMeasurements:
-    """Test multi-qubit measurement IR generation."""
-
-    def test_multi_qubit_with_outputs(self) -> None:
-        """Test that multi-qubit measurements with outputs generate multiple IR measurement nodes."""
-        q = QReg("q", 3)
-        c = CReg("c", 3)
-        block = MultiQubitMeasureWithOutputs(q, c)
-
-        # Convert to Guppy
-        guppy_code = SlrConverter(block).guppy()
-
-        # Should generate three separate measurement statements
-        assert "quantum.measure(" in guppy_code or "measure(" in guppy_code
-
-        # Should have three measurements total
-        assert guppy_code.count("measure(") >= 3
-
-        # Should have array subscript references for qubits
-        assert "q[0]" in guppy_code
-        assert "q[1]" in guppy_code
-        assert "q[2]" in guppy_code
-
-        # Should reference classical bits (AST codegen uses underscore naming)
-        assert "c_0" in guppy_code
-        assert "c_1" in guppy_code
-        assert "c_2" in guppy_code
-
-        # Should not have TODO or error comments
-        assert "TODO" not in guppy_code
-        assert "ERROR" not in guppy_code
-
-    def test_multi_qubit_without_outputs(self) -> None:
-        """Test that multi-qubit measurements without outputs are handled."""
-        q = QReg("q", 3)
-        block = MultiQubitMeasureWithoutOutputs(q)
-
-        # Convert to Guppy
-        guppy_code = SlrConverter(block).guppy()
-
-        # Should generate measurement statements
-        assert "measure(" in guppy_code
-
-        # Should have three measurements
-        assert guppy_code.count("measure(") >= 3
-
-        # Should reference qubits
-        assert "q[0]" in guppy_code
-        assert "q[1]" in guppy_code
-        assert "q[2]" in guppy_code
-
-        # Should not have TODO or error comments
-        assert "TODO" not in guppy_code
-        assert "ERROR" not in guppy_code
-
-    def test_mixed_measurements(self) -> None:
-        """Test that single and multi-qubit measurements can coexist."""
-        q = QReg("q", 5)
-        c = CReg("c", 5)
-        block = MixedMeasurements(q, c)
-
-        # Convert to Guppy
-        guppy_code = SlrConverter(block).guppy()
-
-        # Should generate measurement statements
-        assert "measure(" in guppy_code
-
-        # Should have 5 measurements (1 single + 3 multi + 1 single)
-        assert guppy_code.count("measure(") >= 5
-
-        # Should reference all qubits
-        for i in range(5):
-            assert f"q[{i}]" in guppy_code
-
-        # Should reference all classical bits (AST codegen uses underscore naming)
-        for i in range(5):
-            assert f"c_{i}" in guppy_code
-
-        # Should not have TODO or error comments
-        assert "TODO" not in guppy_code
-        assert "ERROR" not in guppy_code
-
-    def test_resource_consumption(self) -> None:
-        """Test that multi-qubit measurements properly track consumed qubits."""
-        q = QReg("q", 3)
-        c = CReg("c", 3)
-        block = MultiQubitMeasureWithOutputs(q, c)
-
-        # Convert to Guppy - should succeed without linearity errors
-        guppy_code = SlrConverter(block).guppy()
-
-        # Should not have error messages about unconsumed resources
-        assert "ERROR" not in guppy_code
-        assert "not all variables consumed" not in guppy_code.lower()
+        assert_ast_guppy_compiles(prog)
 
 
 class TestMultiQubitMeasurementEdgeCases:
-    """Test edge cases in multi-qubit measurement handling."""
+    """Edge cases in multi-qubit measurement handling."""
 
     def test_two_qubit_measurement(self) -> None:
-        """Test measurement with exactly two qubits."""
-
-        class TwoQubitMeasure(Block):
-            def __init__(self, q: QReg, c: CReg) -> None:
-                super().__init__()
-                self.extend(qubit.Measure(q[0], q[1]) > (c[0], c[1]))
-
-        q = QReg("q", 2)
-        c = CReg("c", 2)
-        block = TwoQubitMeasure(q, c)
-
-        guppy_code = SlrConverter(block).guppy()
-
-        # Should handle 2-qubit case correctly
-        assert "measure(" in guppy_code
-        assert guppy_code.count("measure(") >= 2
-        assert "TODO" not in guppy_code
-        assert "ERROR" not in guppy_code
+        prog = Main(
+            q := QReg("q", 2),
+            c := CReg("c", 2),
+            qubit.Measure(q[0], q[1]) > (c[0], c[1]),
+        )
+        assert_ast_guppy_compiles(prog)
 
     def test_many_qubit_measurement(self) -> None:
-        """Test measurement with many qubits (stress test)."""
-
-        class ManyQubitMeasure(Block):
-            def __init__(self, q: QReg, c: CReg) -> None:
-                super().__init__()
-                # Measure 7 qubits
-                self.extend(
-                    qubit.Measure(q[0], q[1], q[2], q[3], q[4], q[5], q[6])
-                    > (c[0], c[1], c[2], c[3], c[4], c[5], c[6]),
-                )
-
-        q = QReg("q", 7)
-        c = CReg("c", 7)
-        block = ManyQubitMeasure(q, c)
-
-        guppy_code = SlrConverter(block).guppy()
-
-        # Should handle many qubits correctly
-        assert "measure(" in guppy_code
-        assert guppy_code.count("measure(") >= 7
-        assert "TODO" not in guppy_code
-        assert "ERROR" not in guppy_code
-
-        # Should reference all 7 qubits
-        for i in range(7):
-            assert f"q[{i}]" in guppy_code
+        prog = Main(
+            q := QReg("q", 7),
+            c := CReg("c", 7),
+            qubit.Measure(q[0], q[1], q[2], q[3], q[4], q[5], q[6])
+            > (c[0], c[1], c[2], c[3], c[4], c[5], c[6]),
+        )
+        assert_ast_guppy_compiles(prog)
 
 
 class TestSingleQubitMeasurementRegression:
-    """Ensure single-qubit measurements still work correctly."""
+    """Single-qubit ``Measure`` regression coverage at the Main level."""
 
     def test_single_qubit_with_output(self) -> None:
-        """Test that single-qubit measurement with output still works."""
-
-        class SingleMeasure(Block):
-            def __init__(self, q: QReg, c: CReg) -> None:
-                super().__init__()
-                self.extend(qubit.Measure(q[0]) > c[0])
-
-        q = QReg("q", 1)
-        c = CReg("c", 1)
-        block = SingleMeasure(q, c)
-
-        guppy_code = SlrConverter(block).guppy()
-
-        # Should generate measurement
-        assert "measure(" in guppy_code
-        assert "TODO" not in guppy_code
-        assert "ERROR" not in guppy_code
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            qubit.Measure(q[0]) > c[0],
+        )
+        assert_ast_guppy_compiles(prog)
 
     def test_single_qubit_without_output(self) -> None:
-        """Test that single-qubit measurement without output still works."""
-
-        class SingleMeasureNoOutput(Block):
-            def __init__(self, q: QReg) -> None:
-                super().__init__()
-                self.extend(qubit.Measure(q[0]))
-
-        q = QReg("q", 1)
-        block = SingleMeasureNoOutput(q)
-
-        guppy_code = SlrConverter(block).guppy()
-
-        # Should generate measurement
-        assert "measure(" in guppy_code
-        assert "TODO" not in guppy_code
-        assert "ERROR" not in guppy_code
+        prog = Main(
+            q := QReg("q", 1),
+            qubit.Measure(q[0]),
+        )
+        assert_ast_guppy_compiles(prog)
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_partial_array_returns.py b/python/quantum-pecos/tests/slr_tests/guppy/test_partial_array_returns.py
index 024072ab7..f2c51a869 100644
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_partial_array_returns.py
+++ b/python/quantum-pecos/tests/slr_tests/guppy/test_partial_array_returns.py
@@ -1,34 +1,34 @@
-"""Tests for partial array patterns in Guppy code generation.
-
-Note: The AST codegen flattens Block subclasses into the main function
-rather than generating nested functions. These tests verify that blocks
-are correctly flattened and all operations are included.
+"""Tests for partial array patterns through Block flattening.
+
+The two-round-stabilizer pattern from the legacy file used the same
+ancilla register across two rounds without an intervening ``Prep``.
+The v1 AST emitter rejects use-after-measurement, so that case is
+deleted; the remaining tests cover Block-flattening + partial-
+measurement patterns that v1 supports but that are not part of the v1
+acceptance set in ``tests/slr_tests/ast_guppy/test_v1_acceptance.py``.
 """
 
-from pecos.slr import Block, CReg, Main, QReg, SlrConverter
+from pecos.slr import Block, CReg, Main, QReg
 from pecos.slr.qeclib import qubit
 from pecos.slr.qeclib.qubit.measures import Measure
 
+from ..ast_guppy._harness import assert_ast_guppy_compiles  # noqa: TID252
+
 
 def test_block_with_partial_measurements() -> None:
-    """Test that blocks with partial measurements are flattened correctly."""
+    """Block measures ancillas; data qubits are consumed at the root level."""
 
     class MeasureAncillas(Block):
-        """Measure ancilla qubits, return data qubits."""
-
         def __init__(self, data: QReg, ancilla: QReg, syndrome: CReg) -> None:
             super().__init__()
             self.data = data
             self.ancilla = ancilla
             self.syndrome = syndrome
             self.ops = [
-                # Entangle for syndrome extraction
                 qubit.CX(data[0], ancilla[0]),
                 qubit.CX(data[1], ancilla[1]),
-                # Measure only ancillas
                 Measure(ancilla[0]) > syndrome[0],
                 Measure(ancilla[1]) > syndrome[1],
-                # data qubits remain unmeasured
             ]
 
     prog = Main(
@@ -37,43 +37,25 @@ def __init__(self, data: QReg, ancilla: QReg, syndrome: CReg) -> None:
         syndrome := CReg("syndrome", 2),
         final := CReg("final", 2),
         MeasureAncillas(data, ancilla, syndrome),
-        # Continue using data qubits
         Measure(data) > final,
     )
-
-    guppy = SlrConverter(prog).guppy()
-
-    # AST codegen flattens blocks into main
-    # Check that all operations from the block are present
-    assert "quantum.cx(data[0], ancilla[0])" in guppy
-    assert "quantum.cx(data[1], ancilla[1])" in guppy
-    assert "syndrome_0 = quantum.measure(ancilla[0])" in guppy
-    assert "syndrome_1 = quantum.measure(ancilla[1])" in guppy
-
-    # Final measurements should also be present
-    assert "final_0 = quantum.measure(data[0])" in guppy
-    assert "final_1 = quantum.measure(data[1])" in guppy
+    assert_ast_guppy_compiles(prog)
 
 
 def test_partial_array_operations() -> None:
-    """Test operations on subsets of arrays."""
+    """Block measures odd indices for discard, root consumes the even ones."""
 
     class SelectEvenQubits(Block):
-        """Process array, measure odd indices."""
-
         def __init__(self, q: QReg) -> None:
             super().__init__()
             self.q = q
             self.ops = [
-                # Apply gates to all
                 qubit.H(q[0]),
                 qubit.H(q[1]),
                 qubit.H(q[2]),
                 qubit.H(q[3]),
-                # Measure odd indices
-                Measure(q[1]),  # Discard
-                Measure(q[3]),  # Discard
-                # q[0] and q[2] remain
+                Measure(q[1]),
+                Measure(q[3]),
             ]
 
     prog = Main(
@@ -83,39 +65,21 @@ def __init__(self, q: QReg) -> None:
         Measure(q[0]) > result[0],
         Measure(q[2]) > result[1],
     )
-
-    guppy = SlrConverter(prog).guppy()
-
-    # AST codegen flattens blocks
-    # Check that H gates are applied to all qubits
-    assert "quantum.h(q[0])" in guppy
-    assert "quantum.h(q[1])" in guppy
-    assert "quantum.h(q[2])" in guppy
-    assert "quantum.h(q[3])" in guppy
-
-    # Check measurements
-    assert "quantum.measure(q[1])" in guppy
-    assert "quantum.measure(q[3])" in guppy
-    assert "result_0 = quantum.measure(q[0])" in guppy
-    assert "result_1 = quantum.measure(q[2])" in guppy
+    assert_ast_guppy_compiles(prog)
 
 
 def test_multiple_blocks_with_measurements() -> None:
-    """Test multiple blocks with different measurement patterns."""
+    """Block consumes one slot per QReg; root consumes the rest."""
 
     class SplitAndMeasure(Block):
-        """Split two arrays, measure half of each."""
-
         def __init__(self, a: QReg, b: QReg, results: CReg) -> None:
             super().__init__()
             self.a = a
             self.b = b
             self.results = results
             self.ops = [
-                # Measure first half of each array
                 Measure(a[0]) > results[0],
                 Measure(b[0]) > results[1],
-                # a[1] and b[1] remain
             ]
 
     prog = Main(
@@ -123,29 +87,16 @@ def __init__(self, a: QReg, b: QReg, results: CReg) -> None:
         b := QReg("b", 2),
         results := CReg("results", 4),
         SplitAndMeasure(a, b, results[0:2]),
-        # Use remaining qubits
         Measure(a[1]) > results[2],
         Measure(b[1]) > results[3],
     )
-
-    guppy = SlrConverter(prog).guppy()
-
-    # AST codegen flattens blocks
-    # Check measurements from block
-    assert "results_0 = quantum.measure(a[0])" in guppy
-    assert "results_1 = quantum.measure(b[0])" in guppy
-
-    # Check remaining measurements
-    assert "results_2 = quantum.measure(a[1])" in guppy
-    assert "results_3 = quantum.measure(b[1])" in guppy
+    assert_ast_guppy_compiles(prog)
 
 
 def test_all_qubits_consumed() -> None:
-    """Test that blocks consuming all qubits work correctly."""
+    """Block consumes every qubit in the QReg; root has no remainder."""
 
     class MeasureAll(Block):
-        """Measure all input qubits."""
-
         def __init__(self, q: QReg, c: CReg) -> None:
             super().__init__()
             self.q = q
@@ -160,68 +111,4 @@ def __init__(self, q: QReg, c: CReg) -> None:
         c := CReg("c", 2),
         MeasureAll(q, c),
     )
-
-    guppy = SlrConverter(prog).guppy()
-
-    # AST codegen flattens blocks
-    assert "c_0 = quantum.measure(q[0])" in guppy
-    assert "c_1 = quantum.measure(q[1])" in guppy
-
-
-def test_qec_pattern_flattened() -> None:
-    """Test realistic QEC pattern is correctly flattened."""
-
-    class StabilizerRound(Block):
-        """Perform one round of stabilizer measurements."""
-
-        def __init__(self, data: QReg, ancilla: QReg, syndrome: CReg) -> None:
-            super().__init__()
-            self.data = data
-            self.ancilla = ancilla
-            self.syndrome = syndrome
-            self.ops = [
-                # Syndrome extraction
-                qubit.H(ancilla[0]),
-                qubit.CX(data[0], ancilla[0]),
-                qubit.CX(data[1], ancilla[0]),
-                qubit.H(ancilla[0]),
-                qubit.H(ancilla[1]),
-                qubit.CX(data[1], ancilla[1]),
-                qubit.CX(data[2], ancilla[1]),
-                qubit.H(ancilla[1]),
-                # Measure ancillas only
-                Measure(ancilla) > syndrome,
-                # Data qubits preserved
-            ]
-
-    prog = Main(
-        data := QReg("data", 3),
-        ancilla := QReg("ancilla", 2),
-        syndrome1 := CReg("syndrome1", 2),
-        syndrome2 := CReg("syndrome2", 2),
-        final := CReg("final", 3),
-        # First round
-        StabilizerRound(data, ancilla, syndrome1),
-        # Second round (same block used twice)
-        StabilizerRound(data, ancilla, syndrome2),
-        # Final measurement
-        Measure(data) > final,
-    )
-
-    guppy = SlrConverter(prog).guppy()
-
-    # AST codegen flattens blocks (operations appear twice for two rounds)
-    assert "quantum.h(ancilla[0])" in guppy
-    assert "quantum.cx(data[0], ancilla[0])" in guppy
-    assert "quantum.cx(data[1], ancilla[0])" in guppy
-
-    # Syndrome measurements for both rounds
-    assert "syndrome1_0 = quantum.measure(ancilla[0])" in guppy
-    assert "syndrome1_1 = quantum.measure(ancilla[1])" in guppy
-    assert "syndrome2_0 = quantum.measure(ancilla[0])" in guppy
-    assert "syndrome2_1 = quantum.measure(ancilla[1])" in guppy
-
-    # Final measurements
-    assert "final_0 = quantum.measure(data[0])" in guppy
-    assert "final_1 = quantum.measure(data[1])" in guppy
-    assert "final_2 = quantum.measure(data[2])" in guppy
+    assert_ast_guppy_compiles(prog)
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_partial_consumption.py b/python/quantum-pecos/tests/slr_tests/guppy/test_partial_consumption.py
index 4ba87fb56..ccad3ddda 100644
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_partial_consumption.py
+++ b/python/quantum-pecos/tests/slr_tests/guppy/test_partial_consumption.py
@@ -1,8 +1,10 @@
-"""Tests for partial array consumption patterns in Guppy code generation.
+"""Tests for partial array consumption patterns.
 
-Note: The AST codegen flattens Block subclasses into the main function
-rather than generating nested functions. These tests verify that blocks
-are correctly flattened and operations are properly sequenced.
+The straight-line measurement variants are covered by the v1 acceptance
+corpus (``tests/slr_tests/ast_guppy/test_v1_acceptance.py``). The cases
+here exercise Block flattening + measurement patterns and the empty-
+Main / no-measurement edge cases that the acceptance corpus does not
+cover.
 """
 
 import pytest
@@ -10,28 +12,26 @@
 from pecos.slr.qeclib import qubit
 from pecos.slr.qeclib.qubit.measures import Measure
 
+from ..ast_guppy._harness import assert_ast_guppy_compiles  # noqa: TID252
+
 
 class TestPartialConsumption:
     """Test cases for partial quantum array consumption."""
 
     def test_measure_ancillas_preserve_data(self) -> None:
-        """Test measuring ancilla qubits while preserving data qubits."""
+        """Block measures every ancilla; data is consumed at root after a gate."""
 
         class MeasureAncillas(Block):
-            """Measure ancilla qubits but keep data qubits."""
-
             def __init__(self, data: QReg, ancilla: QReg, syndrome: CReg) -> None:
                 super().__init__()
                 self.data = data
                 self.ancilla = ancilla
                 self.syndrome = syndrome
                 self.ops = [
-                    # Measure all ancillas
                     Measure(ancilla[0]) > syndrome[0],
                     Measure(ancilla[1]) > syndrome[1],
                     Measure(ancilla[2]) > syndrome[2],
                     Measure(ancilla[3]) > syndrome[3],
-                    # Data qubits remain unmeasured
                 ]
 
         prog = Main(
@@ -39,38 +39,18 @@ def __init__(self, data: QReg, ancilla: QReg, syndrome: CReg) -> None:
             ancilla := QReg("ancilla", 4),
             syndrome := CReg("syndrome", 4),
             data_result := CReg("data_result", 7),
-            # Prepare some state
             qubit.H(data[0]),
             qubit.CX(data[0], ancilla[0]),
-            # Measure ancillas but keep data
             MeasureAncillas(data, ancilla, syndrome),
-            # Continue using data
             qubit.X(data[0]),
-            # Eventually measure data
             Measure(data) > data_result,
         )
-
-        guppy_code = SlrConverter(prog).guppy()
-
-        # AST codegen flattens blocks
-        # Check ancilla measurements
-        assert "syndrome_0 = quantum.measure(ancilla[0])" in guppy_code
-        assert "syndrome_1 = quantum.measure(ancilla[1])" in guppy_code
-        assert "syndrome_2 = quantum.measure(ancilla[2])" in guppy_code
-        assert "syndrome_3 = quantum.measure(ancilla[3])" in guppy_code
-
-        # Check that data operations are present
-        assert "quantum.x(data[0])" in guppy_code
-
-        # Check data measurements
-        assert "data_result_0 = quantum.measure(data[0])" in guppy_code
+        assert_ast_guppy_compiles(prog)
 
     def test_consume_subset_of_qubits(self) -> None:
-        """Test consuming only part of a qubit array."""
+        """Block consumes a subset of slots; root consumes the rest."""
 
         class MeasureFirstHalf(Block):
-            """Measure first half of a qubit array."""
-
             def __init__(self, qubits: QReg, results: CReg) -> None:
                 super().__init__()
                 self.qubits = qubits
@@ -79,57 +59,36 @@ def __init__(self, qubits: QReg, results: CReg) -> None:
                     Measure(qubits[0]) > results[0],
                     Measure(qubits[1]) > results[1],
                     Measure(qubits[2]) > results[2],
-                    # qubits[3], [4], [5] remain unmeasured
                 ]
 
         prog = Main(
             q := QReg("q", 6),
             c_first := CReg("c_first", 3),
             c_second := CReg("c_second", 3),
-            # Prepare
             qubit.H(q[0]),
             qubit.CX(q[0], q[1]),
-            # Measure first half
             MeasureFirstHalf(q, c_first),
-            # Continue with second half
             qubit.H(q[3]),
             Measure(q[3]) > c_second[0],
             Measure(q[4]) > c_second[1],
             Measure(q[5]) > c_second[2],
         )
-
-        guppy_code = SlrConverter(prog).guppy()
-
-        # AST codegen flattens blocks
-        # Check first half measurements
-        assert "c_first_0 = quantum.measure(q[0])" in guppy_code
-        assert "c_first_1 = quantum.measure(q[1])" in guppy_code
-        assert "c_first_2 = quantum.measure(q[2])" in guppy_code
-
-        # Check operations on second half
-        assert "quantum.h(q[3])" in guppy_code
-        assert "c_second_0 = quantum.measure(q[3])" in guppy_code
-        assert "c_second_1 = quantum.measure(q[4])" in guppy_code
-        assert "c_second_2 = quantum.measure(q[5])" in guppy_code
+        assert_ast_guppy_compiles(prog)
 
     def test_block_operations_flattened(self) -> None:
-        """Test that block operations are flattened into main."""
+        """Stabilizer-style Block + post-block gate on data qubits."""
 
         class StabilizerMeasurement(Block):
-            """Measure stabilizer, return data qubits."""
-
             def __init__(self, data: QReg, ancilla: QReg, syndrome: CReg) -> None:
                 super().__init__()
                 self.data = data
                 self.ancilla = ancilla
                 self.syndrome = syndrome
                 self.ops = [
-                    # Stabilizer circuit
                     qubit.H(ancilla[0]),
                     qubit.CX(data[0], ancilla[0]),
                     qubit.CX(data[1], ancilla[0]),
                     qubit.H(ancilla[0]),
-                    # Measure ancilla to get syndrome
                     Measure(ancilla[0]) > syndrome[0],
                 ]
 
@@ -138,96 +97,14 @@ def __init__(self, data: QReg, ancilla: QReg, syndrome: CReg) -> None:
             ancilla := QReg("ancilla", 1),
             syndrome := CReg("syndrome", 1),
             final := CReg("final", 2),
-            # Run stabilizer measurement
             StabilizerMeasurement(data, ancilla, syndrome),
-            # Continue with data
             qubit.Z(data[0]),
-            # Final measurements
             Measure(data) > final,
         )
-
-        guppy_code = SlrConverter(prog).guppy()
-
-        # AST codegen flattens blocks
-        # Check stabilizer operations
-        assert "quantum.h(ancilla[0])" in guppy_code
-        assert "quantum.cx(data[0], ancilla[0])" in guppy_code
-        assert "quantum.cx(data[1], ancilla[0])" in guppy_code
-        assert "syndrome_0 = quantum.measure(ancilla[0])" in guppy_code
-
-        # Check operations after block
-        assert "quantum.z(data[0])" in guppy_code
-        assert "final_0 = quantum.measure(data[0])" in guppy_code
-        assert "final_1 = quantum.measure(data[1])" in guppy_code
-
-    def test_consecutive_measurements(self) -> None:
-        """Test that consecutive measurements use array indexing."""
-        prog = Main(
-            q := QReg("q", 4),
-            c := CReg("c", 4),
-            # Consecutive measurements
-            Measure(q[0]) > c[0],
-            Measure(q[1]) > c[1],
-            Measure(q[2]) > c[2],
-            Measure(q[3]) > c[3],
-        )
-
-        guppy_code = SlrConverter(prog).guppy()
-
-        # AST codegen uses array indexing
-        assert "c_0 = quantum.measure(q[0])" in guppy_code
-        assert "c_1 = quantum.measure(q[1])" in guppy_code
-        assert "c_2 = quantum.measure(q[2])" in guppy_code
-        assert "c_3 = quantum.measure(q[3])" in guppy_code
-
-    def test_mixed_destination_measurements(self) -> None:
-        """Test measurements to different classical registers."""
-        prog = Main(
-            q := QReg("q", 4),
-            c1 := CReg("c1", 2),
-            c2 := CReg("c2", 2),
-            # Measurements to different registers
-            Measure(q[0]) > c1[0],
-            Measure(q[1]) > c1[1],
-            Measure(q[2]) > c2[0],
-            Measure(q[3]) > c2[1],
-        )
-
-        guppy_code = SlrConverter(prog).guppy()
-
-        # Results distributed to correct destinations
-        assert "c1_0 = quantum.measure(q[0])" in guppy_code
-        assert "c1_1 = quantum.measure(q[1])" in guppy_code
-        assert "c2_0 = quantum.measure(q[2])" in guppy_code
-        assert "c2_1 = quantum.measure(q[3])" in guppy_code
-
-    def test_gates_with_array_indexing(self) -> None:
-        """Test that gates work correctly with array indexing."""
-        prog = Main(
-            q := QReg("q", 3),
-            c := CReg("c", 3),
-            # Apply gates
-            qubit.H(q[0]),
-            qubit.CX(q[0], q[1]),
-            # Then measure
-            Measure(q[0]) > c[0],
-            qubit.X(q[1]),  # Gate between measurements
-            Measure(q[1]) > c[1],
-            Measure(q[2]) > c[2],
-        )
-
-        guppy_code = SlrConverter(prog).guppy()
-
-        # AST codegen uses array indexing
-        assert "quantum.h(q[0])" in guppy_code
-        assert "quantum.cx(q[0], q[1])" in guppy_code
-        assert "c_0 = quantum.measure(q[0])" in guppy_code
-        assert "quantum.x(q[1])" in guppy_code
-        assert "c_1 = quantum.measure(q[1])" in guppy_code
-        assert "c_2 = quantum.measure(q[2])" in guppy_code
+        assert_ast_guppy_compiles(prog)
 
     def test_single_element_block(self) -> None:
-        """Test block with single operation."""
+        """Block with a single statement still compiles after flattening."""
 
         class MeasureSingle(Block):
             def __init__(self, q: QReg, c: CReg) -> None:
@@ -243,11 +120,7 @@ def __init__(self, q: QReg, c: CReg) -> None:
             result := CReg("result", 1),
             MeasureSingle(single, result),
         )
-
-        guppy_code = SlrConverter(prog).guppy()
-
-        # AST codegen flattens blocks
-        assert "result_0 = quantum.measure(single[0])" in guppy_code
+        assert_ast_guppy_compiles(prog)
 
     @pytest.mark.optional_dependency
     def test_hugr_compilation(self) -> None:
@@ -270,10 +143,10 @@ def test_hugr_compilation(self) -> None:
 
 
 class TestEdgeCases:
-    """Test edge cases and error conditions."""
+    """Test edge cases and corner cases for the v1 emitter."""
 
     def test_empty_block(self) -> None:
-        """Test block with no operations."""
+        """A Block with an empty op list flattens to nothing."""
 
         class DoNothing(Block):
             def __init__(self, q: QReg) -> None:
@@ -287,27 +160,13 @@ def __init__(self, q: QReg) -> None:
             DoNothing(q),
             Measure(q) > c,
         )
-
-        guppy_code = SlrConverter(prog).guppy()
-
-        # Empty blocks are just skipped, measurements should work
-        assert "c_0 = quantum.measure(q[0])" in guppy_code
-        assert "c_1 = quantum.measure(q[1])" in guppy_code
+        assert_ast_guppy_compiles(prog)
 
     def test_unmeasured_qubits_returned(self) -> None:
-        """Test handling of unconsumed qubits in main return type."""
+        """Main with no measurements: live qubits are discarded at exit."""
         prog = Main(
             q := QReg("q", 2),
-            # Apply gates but don't measure
             qubit.H(q[0]),
             qubit.CX(q[0], q[1]),
         )
-
-        guppy_code = SlrConverter(prog).guppy()
-
-        # Main should have qubit operations
-        assert "quantum.h(q[0])" in guppy_code
-        assert "quantum.cx(q[0], q[1])" in guppy_code
-
-        # Return type should include qubit array since they're not consumed
-        assert "array[qubit, 2]" in guppy_code
+        assert_ast_guppy_compiles(prog)
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_register_wide_ops.py b/python/quantum-pecos/tests/slr_tests/guppy/test_register_wide_ops.py
deleted file mode 100644
index 20da744f6..000000000
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_register_wide_ops.py
+++ /dev/null
@@ -1,88 +0,0 @@
-"""Test register-wide operations that should generate loops."""
-
-from pecos.slr import CReg, Main, QReg, SlrConverter
-from pecos.slr.qeclib import qubit
-from pecos.slr.qeclib.qubit.measures import Measure
-
-
-def test_hadamard_on_register() -> None:
-    """Test that H(q) generates a loop when q is a register."""
-    prog = Main(
-        q := QReg("q", 4),
-        # Apply Hadamard to entire register
-        qubit.H(q),
-        # Measure all qubits
-        Measure(q) > CReg("c", 4),
-    )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # Should generate a loop to apply H to each qubit
-    assert "for" in guppy_code or "quantum.h(q[0])" in guppy_code
-
-    # Check that H is applied (either in a loop or expanded)
-    if "for" in guppy_code:
-        # Loop form
-        assert "quantum.h(q[i])" in guppy_code
-    else:
-        # Expanded form
-        h_count = guppy_code.count("quantum.h")
-        assert h_count >= 4, f"Expected at least 4 H gates, got {h_count}"
-
-
-def test_multiple_gates_on_register() -> None:
-    """Test multiple single-qubit gates on registers."""
-    prog = Main(
-        q := QReg("q", 3),
-        # Apply multiple gates to entire register
-        qubit.H(q),
-        qubit.X(q),
-        qubit.Z(q),
-        # Measure all
-        Measure(q) > CReg("c", 3),
-    )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # Check that all gates are applied (either in loops or expanded)
-    if "for" in guppy_code:
-        # Loop form
-        assert "quantum.h(q[i])" in guppy_code
-        assert "quantum.x(q[i])" in guppy_code
-        assert "quantum.z(q[i])" in guppy_code
-    else:
-        # Expanded form
-        assert guppy_code.count("quantum.h") >= 3
-        assert guppy_code.count("quantum.x") >= 3
-        assert guppy_code.count("quantum.z") >= 3
-
-
-def test_mixed_register_and_element_ops() -> None:
-    """Test mixing register-wide and element-specific operations."""
-    prog = Main(
-        q := QReg("q", 4),
-        # Apply H to entire register
-        qubit.H(q),
-        # Apply X to specific elements
-        qubit.X(q[0]),
-        qubit.X(q[2]),
-        # Apply Z to entire register again
-        qubit.Z(q),
-        Measure(q) > CReg("c", 4),
-    )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # Should have H and Z applied to all qubits (either in loops or expanded)
-    if "for" in guppy_code:
-        # Loop form - count loops
-        assert "quantum.h(q[i])" in guppy_code
-        assert "quantum.z(q[i])" in guppy_code
-    else:
-        # Expanded form
-        assert guppy_code.count("quantum.h") >= 4
-        assert guppy_code.count("quantum.z") >= 4
-
-    # Should have X applied to specific qubits (always individual)
-    assert "quantum.x(q[0])" in guppy_code
-    assert "quantum.x(q[2])" in guppy_code
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_simple_slr_to_guppy.py b/python/quantum-pecos/tests/slr_tests/guppy/test_simple_slr_to_guppy.py
index 0b6355368..af78b1bfb 100644
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_simple_slr_to_guppy.py
+++ b/python/quantum-pecos/tests/slr_tests/guppy/test_simple_slr_to_guppy.py
@@ -1,363 +1,61 @@
 """Simple SLR-to-Guppy translation tests.
 
-These tests verify that basic SLR patterns translate cleanly to Guppy
-and compile to HUGR without errors. They serve as both documentation
-of expected translations and regression tests.
+The straightforward Bell / GHZ / two-qubit-gate / multi-op tests in the
+legacy file are covered by the v1 acceptance corpus
+(``tests/slr_tests/ast_guppy/test_v1_acceptance.py``). What survives
+here is the measure-then-Prep cycle invoked multiple times via a
+Block subclass, which is in v1 scope but not part of the acceptance
+set.
 """
 
-from pecos.slr import Block, CReg, Main, QReg, SlrConverter
+from pecos.slr import Block, CReg, Main, QReg
 from pecos.slr.qeclib import qubit as qb
 from pecos.slr.qeclib.qubit.measures import Measure
 from pecos.slr.qeclib.qubit.preps import Prep
 
+from ..ast_guppy._harness import assert_ast_guppy_compiles  # noqa: TID252
 
-def test_simple_bell_state() -> None:
-    """Test simple Bell state preparation translates cleanly."""
-    prog = Main(
-        q := QReg("q", 2),
-        c := CReg("c", 2),
-        # Bell state: H on q[0], then CNOT
-        qb.H(q[0]),
-        qb.CX(q[0], q[1]),
-        # Measure both qubits
-        Measure(q) > c,
-    )
-
-    # Generate Guppy code
-    guppy_code = SlrConverter(prog).guppy()
-
-    # Verify clean translation with AST codegen
-    assert "quantum.h(q[0])" in guppy_code
-    assert "quantum.cx(q[0], q[1])" in guppy_code
-    # AST codegen measures individually
-    assert "quantum.measure(q[0])" in guppy_code
-    assert "quantum.measure(q[1])" in guppy_code
-
-    # Verify it compiles to HUGR
-    hugr = SlrConverter(prog).hugr()
-    assert hugr is not None
-    assert hasattr(hugr, "modules")
-
-    print("Bell state: Clean translation and HUGR compilation")
-
-
-def test_simple_reset() -> None:
-    """Test that reset operations translate cleanly to functional reset."""
-    prog = Main(
-        q := QReg("q", 1),
-        c := CReg("c", 1),
-        # Prepare |+>
-        qb.H(q[0]),
-        # Measure
-        Measure(q[0]) > c[0],
-        # Reset (should use functional reset)
-        Prep(q[0]),
-        # Apply X
-        qb.X(q[0]),
-    )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # AST codegen uses array parameter and reset operation
-    assert "q: array[qubit, 1]" in guppy_code
-    assert "quantum.h(q[0])" in guppy_code
-    assert "quantum.measure(q[0])" in guppy_code
-    # Reset operation
-    assert "quantum.reset(q[0])" in guppy_code
-    # X gate after reset
-    assert "quantum.x(q[0])" in guppy_code
-
-    # Should compile to HUGR
-    hugr = SlrConverter(prog).hugr()
-    assert hugr is not None
-
-    print("Reset: Functional reset with correct assignment")
-
-
-def test_simple_function_with_return() -> None:
-    """Test that functions with quantum returns translate cleanly."""
-
-    class ApplyH(Block):
-        """Simple block that applies H to a qubit."""
-
-        def __init__(self, q: QReg) -> None:
-            super().__init__()
-            self.q = q
-            self.ops = [qb.H(q[0])]
-
-    prog = Main(
-        q := QReg("q", 1),
-        c := CReg("c", 1),
-        # Apply H (function should return q)
-        ApplyH(q),
-        # Measure
-        Measure(q[0]) > c[0],
-    )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # AST codegen generates main with array parameter
-    assert "def main" in guppy_code
-    assert "array[qubit, 1]" in guppy_code
-    assert "quantum.h(q[0])" in guppy_code
-    assert "quantum.measure(q[0])" in guppy_code
 
-    # Should compile
-    hugr = SlrConverter(prog).hugr()
-    assert hugr is not None
-
-    print("Function return: Proper signature and capture")
-
-
-def test_simple_measurement_then_reset() -> None:
-    """Test measure-reset pattern common in QEC."""
-
-    class MeasureAndReset(Block):
-        """Measure a qubit and reset it."""
+def test_simple_explicit_reset_in_loop() -> None:
+    """A Block performing measure + Prep is invoked three times in a row."""
 
+    class ResetQubit(Block):
         def __init__(self, q: QReg, c: CReg) -> None:
             super().__init__()
             self.q = q
             self.c = c
             self.ops = [
                 Measure(q[0]) > c[0],
-                Prep(q[0]),  # Explicit reset
+                Prep(q[0]),
             ]
 
     prog = Main(
         q := QReg("q", 1),
-        c := CReg("c", 1),
-        # Measure and reset
-        MeasureAndReset(q, c),
-        # Apply gate to reset qubit
-        qb.X(q[0]),
-    )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # Function should have array parameter
-    assert "array[qubit, 1]" in guppy_code
-    # Should have reset operation
-    assert "quantum.reset" in guppy_code or "quantum.qubit()" in guppy_code
-
-    # Should compile to HUGR
-    hugr = SlrConverter(prog).hugr()
-    assert hugr is not None
-
-    print("Measure-reset: Explicit reset returned correctly")
-
-
-def test_simple_two_qubit_gate() -> None:
-    """Test two-qubit gate translation."""
-    prog = Main(
-        q := QReg("q", 3),
         c := CReg("c", 3),
-        # Apply CNOT gates
-        qb.CX(q[0], q[1]),
-        qb.CX(q[1], q[2]),
-        # Measure
-        Measure(q) > c,
-    )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # Check gates are in order
-    assert "quantum.cx(q[0], q[1])" in guppy_code
-    assert "quantum.cx(q[1], q[2])" in guppy_code
-    # Check order (q[0],q[1]) should come before (q[1],q[2])
-    idx1 = guppy_code.index("quantum.cx(q[0], q[1])")
-    idx2 = guppy_code.index("quantum.cx(q[1], q[2])")
-    assert idx1 < idx2
-
-    # Should compile
-    hugr = SlrConverter(prog).hugr()
-    assert hugr is not None
-
-    print("Two-qubit gates: Correct order preserved")
-
-
-def test_simple_loop_pattern() -> None:
-    """Test that register-wide operations are handled."""
-    prog = Main(
-        q := QReg("q", 5),
-        c := CReg("c", 5),
-        # Apply H to all qubits
-        qb.H(q),
-        # Measure all
-        Measure(q) > c,
-    )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # AST codegen applies H to each qubit
-    # Either generates a loop or individual operations
-    assert "quantum.h" in guppy_code
-    # Measurements for all qubits
-    assert "quantum.measure" in guppy_code
-
-    # Should compile
-    hugr = SlrConverter(prog).hugr()
-    assert hugr is not None
-
-    print("Loop generation: Clean pattern")
-
-
-def test_simple_partial_consumption() -> None:
-    """Test partial array consumption pattern."""
-
-    class MeasureFirst(Block):
-        """Measure only first qubit."""
-
-        def __init__(self, q: QReg, c: CReg) -> None:
-            super().__init__()
-            self.q = q
-            self.c = c
-            self.ops = [
-                Measure(q[0]) > c[0],
-                # q[1] and q[2] remain
-            ]
-
-    prog = Main(
-        q := QReg("q", 3),
-        c := CReg("c", 3),
-        # Measure first qubit only
-        MeasureFirst(q, c[0:1]),
-        # Use remaining qubits
-        qb.H(q[1]),
-        qb.H(q[2]),
-        Measure(q[1]) > c[1],
-        Measure(q[2]) > c[2],
+        ResetQubit(q, c[0:1]),
+        ResetQubit(q, c[1:2]),
+        ResetQubit(q, c[2:3]),
     )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # AST codegen generates main with array parameter
-    assert "array[qubit, 3]" in guppy_code
-    assert "quantum.measure(q[0])" in guppy_code
-    assert "quantum.h(q[1])" in guppy_code
-    assert "quantum.h(q[2])" in guppy_code
-
-    # Should compile
-    hugr = SlrConverter(prog).hugr()
-    assert hugr is not None
-
-    print("Partial consumption: Returns only unconsumed qubits")
+    assert_ast_guppy_compiles(prog)
 
 
-def test_simple_explicit_reset_in_loop() -> None:
-    """Test that explicit resets work in loop patterns."""
-
-    class ResetQubit(Block):
-        """Measure and reset a qubit."""
+def test_simple_measurement_then_reset() -> None:
+    """Measure-then-reset followed by a root-level X on the freshly-prepped slot."""
 
+    class MeasureAndReset(Block):
         def __init__(self, q: QReg, c: CReg) -> None:
             super().__init__()
             self.q = q
             self.c = c
             self.ops = [
                 Measure(q[0]) > c[0],
-                Prep(q[0]),  # Explicit reset - should be returned!
+                Prep(q[0]),
             ]
 
     prog = Main(
         q := QReg("q", 1),
-        c := CReg("c", 3),
-        # Call three times - requires consistent return size
-        ResetQubit(q, c[0:1]),
-        ResetQubit(q, c[1:2]),
-        ResetQubit(q, c[2:3]),
-    )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # AST codegen generates main with array parameter
-    assert "array[qubit, 1]" in guppy_code
-    # Should have measure and reset operations
-    assert "quantum.measure" in guppy_code
-    assert "quantum.reset" in guppy_code or "def main" in guppy_code
-
-    # Should compile to HUGR (this is the critical test!)
-    hugr = SlrConverter(prog).hugr()
-    assert hugr is not None
-
-    print("Explicit reset in loop: Maintains array size correctly")
-
-
-def test_simple_multi_qubit_operations() -> None:
-    """Test multiple operations on same qubits."""
-    prog = Main(
-        q := QReg("q", 2),
-        c := CReg("c", 2),
-        # Multiple operations
-        qb.H(q[0]),
-        qb.X(q[1]),
-        qb.CX(q[0], q[1]),
-        qb.H(q[0]),
-        qb.H(q[1]),
-        # Measure
-        Measure(q) > c,
-    )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # All operations should be present in order
-    operations = [
-        "quantum.h(q[0])",
-        "quantum.x(q[1])",
-        "quantum.cx(q[0], q[1])",
-    ]
-
-    for op in operations:
-        assert op in guppy_code
-
-    # Should compile
-    hugr = SlrConverter(prog).hugr()
-    assert hugr is not None
-
-    print("Multiple operations: All present and ordered")
-
-
-def test_simple_ghz_state() -> None:
-    """Test GHZ state preparation (3-qubit entangled state)."""
-    prog = Main(
-        q := QReg("q", 3),
-        c := CReg("c", 3),
-        # GHZ state: H on first qubit, then CNOTs
-        qb.H(q[0]),
-        qb.CX(q[0], q[1]),
-        qb.CX(q[0], q[2]),
-        # Measure all
-        Measure(q) > c,
+        c := CReg("c", 1),
+        MeasureAndReset(q, c),
+        qb.X(q[0]),
     )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # Check structure
-    assert "quantum.h(q[0])" in guppy_code
-    assert "quantum.cx(q[0], q[1])" in guppy_code
-    assert "quantum.cx(q[0], q[2])" in guppy_code
-    # AST codegen measures individually
-    assert "quantum.measure(q[0])" in guppy_code
-    assert "quantum.measure(q[1])" in guppy_code
-    assert "quantum.measure(q[2])" in guppy_code
-
-    # Should compile
-    hugr = SlrConverter(prog).hugr()
-    assert hugr is not None
-
-    print("GHZ state: Clean 3-qubit entanglement")
-
-
-if __name__ == "__main__":
-    """Run all tests and print results."""
-    test_simple_bell_state()
-    test_simple_reset()
-    test_simple_function_with_return()
-    test_simple_measurement_then_reset()
-    test_simple_two_qubit_gate()
-    test_simple_loop_pattern()
-    test_simple_partial_consumption()
-    test_simple_explicit_reset_in_loop()
-    test_simple_multi_qubit_operations()
-    test_simple_ghz_state()
-    print("\nAll simple SLR-to-Guppy tests passed!")
+    assert_ast_guppy_compiles(prog)
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_steane_integration.py b/python/quantum-pecos/tests/slr_tests/guppy/test_steane_integration.py
deleted file mode 100644
index a71fa0332..000000000
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_steane_integration.py
+++ /dev/null
@@ -1,109 +0,0 @@
-"""Test SLR-to-Guppy compilation with Steane code integration.
-
-This test demonstrates the complete pipeline from natural SLR code
-through Guppy generation with real quantum error correction code.
-
-Note: AST codegen flattens Block subclasses into the main function
-and uses array parameters with indexing.
-"""
-
-from pecos.slr import Main, SlrConverter
-from pecos.slr.qeclib.steane.steane_class import Steane
-
-
-def test_steane_guppy_generation() -> None:
-    """Test that Steane SLR code generates valid Guppy code."""
-    # Create natural SLR program with Steane code
-    prog = Main(
-        c := Steane("c"),
-        c.px(),
-    )
-
-    # Generate Guppy code
-    guppy_code = SlrConverter(prog).guppy()
-
-    # Verify code generation succeeded
-    assert guppy_code is not None
-    assert len(guppy_code) > 0
-
-    # Verify basic structure
-    assert "from guppylang" in guppy_code
-    assert "@guppy" in guppy_code
-    assert "def main(" in guppy_code
-
-    # Verify array parameters (AST codegen uses array inputs)
-    assert "c_d: array[qubit, 7]" in guppy_code
-    assert "c_a: array[qubit, 3]" in guppy_code
-
-
-def test_steane_array_operations() -> None:
-    """Test that Steane array operations are correctly generated."""
-    prog = Main(
-        c := Steane("c"),
-        c.px(),
-    )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # Check that qubit operations use array indexing
-    assert "c_d[0]" in guppy_code
-    assert "c_a[0]" in guppy_code
-
-    # Check for H gates (used in encoding)
-    assert "quantum.h(" in guppy_code
-
-    # Check for CX gates (used in syndrome extraction and encoding)
-    assert "quantum.cx(" in guppy_code
-
-    # Check for measurements
-    assert "quantum.measure(" in guppy_code
-
-
-def test_steane_hugr_compilation() -> None:
-    """Test HUGR compilation of Steane code."""
-    prog = Main(
-        c := Steane("c"),
-        c.px(),
-    )
-
-    try:
-        hugr = SlrConverter(prog).hugr()
-        assert hugr is not None
-
-    except (ImportError, Exception) as e:
-        # HUGR compilation may fail due to:
-        # - ImportError: missing guppylang library
-        # - GuppyError: linearity violations or other compilation issues
-        print(f"WARNING: HUGR compilation issue: {type(e).__name__}: {e}")
-
-        # Even if HUGR compilation fails, verify the Guppy code is generated
-        guppy_code = SlrConverter(prog).guppy()
-
-        # Check that we're using array parameters
-        assert "array[qubit," in guppy_code, "Should use array parameters"
-
-        # The test passes if code generation succeeds
-        # HUGR compilation issues are acceptable for complex codes
-
-
-def test_steane_quantum_operations() -> None:
-    """Test that Steane operations produce valid quantum gates."""
-    prog = Main(
-        c := Steane("c"),
-        c.px(),
-    )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # Verify quantum operations are present
-    # H gates for encoding
-    h_count = guppy_code.count("quantum.h(")
-    assert h_count > 0, "Should have H gates"
-
-    # CX gates for entanglement
-    cx_count = guppy_code.count("quantum.cx(")
-    assert cx_count > 0, "Should have CX gates"
-
-    # Measurements for verification
-    measure_count = guppy_code.count("quantum.measure(")
-    assert measure_count > 0, "Should have measurements"
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_guppy_generation.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_guppy_generation.py
index 9b19273b7..feeb9928a 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_guppy_generation.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_guppy_generation.py
@@ -1,146 +1,40 @@
-"""Tests for Guppy code generation from SLR programs."""
-
-from pecos.slr import CReg, If, Main, QReg, Repeat, SlrConverter
-from pecos.slr.qeclib import qubit as qb
-
-
-def test_simple_circuit() -> None:
-    """Test simple quantum circuit generation."""
-    prog = Main(
-        q := QReg("q", 2),
-        c := CReg("c", 2),
-        # Prepare Bell state
-        qb.H(q[0]),
-        qb.CX(q[0], q[1]),
-        # Measure
-        qb.Measure(q) > c,
-    )
-
-    # Generate Guppy code
-    guppy_code = SlrConverter(prog).guppy()
-
-    # Basic assertions - AST codegen uses array parameters
-    assert "@guppy" in guppy_code
-    assert "def main(" in guppy_code
-    assert "array[qubit," in guppy_code  # Array parameter type
-    assert "quantum.h(" in guppy_code
-    assert "quantum.cx(" in guppy_code
-
-
-def test_conditional_logic() -> None:
-    """Test conditional logic generation."""
-    prog = Main(
-        q := QReg("q", 1),
-        c := CReg("c", 1),
-        qb.H(q[0]),
-        qb.Measure(q[0]) > c[0],
-        If(c[0] == 1).Then(
-            qb.X(q[0]),
-        ),
-    )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # Check conditional structure - AST codegen preserves comparison expression
-    assert "if (c_0 == 1):" in guppy_code
-    assert "quantum.x(q[0])" in guppy_code
-
-
-def test_repeat_loop() -> None:
-    """Test repeat loop generation."""
-    prog = Main(
-        q := QReg("q", 1),
-        # Apply H gate 3 times
-        Repeat(3).block(
-            qb.H(q[0]),
-        ),
-    )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # Check loop structure
-    assert "for _ in range(3):" in guppy_code
-    assert "quantum.h(q[0])" in guppy_code
-
-
-def test_steane_snippet() -> None:
-    """Test a simple Steane code snippet."""
-    from pecos.slr.qeclib.steane.steane_class import Steane
-
-    prog = Main(
-        # Create two logical qubits
-        s1 := Steane("s1"),
-        s2 := Steane("s2"),
-        # Prepare logical |0>
-        s1.pz(),
-        # Apply logical Hadamard
-        s1.h(),
-        # Logical CNOT
-        s1.cx(s2),
-        # QEC cycle
-        s1.qec(),
-        s2.qec(),
-    )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # Check that Steane registers are declared as array parameters
-    assert "s1_d: array[qubit, 7] @owned" in guppy_code
-    assert "s2_d: array[qubit, 7] @owned" in guppy_code
-    # Check that some quantum operations are present
-    assert "quantum.h(" in guppy_code
-    assert "quantum.cx(" in guppy_code
-
-
-def test_measurement_handling() -> None:
-    """Test different measurement patterns."""
-    prog = Main(
-        q := QReg("q", 3),
-        c := CReg("c", 3),
-        # Individual qubit measurement
-        qb.Measure(q[0]) > c[0],
-        # Full register measurement
-        qb.Measure(q) > c,
-    )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # Check measurement generation - AST codegen unpacks registers
-    assert "c_0 = quantum.measure(" in guppy_code
-    # Full register measurement is expanded to individual measurements
-    assert "c_1 = quantum.measure(" in guppy_code
-    assert "c_2 = quantum.measure(" in guppy_code
-
-
-def test_various_gates() -> None:
-    """Test generation of various quantum gates."""
-    prog = Main(
-        q := QReg("q", 2),
-        # Single-qubit gates
-        qb.H(q[0]),
-        qb.X(q[0]),
-        qb.Y(q[0]),
-        qb.Z(q[0]),
-        qb.SZ(q[0]),  # S gate
-        qb.SZdg(q[0]),  # Sdg gate
-        qb.T(q[0]),
-        qb.Tdg(q[0]),
-        # Two-qubit gates
-        qb.CX(q[0], q[1]),
-        qb.CY(q[0], q[1]),
-        qb.CZ(q[0], q[1]),
-    )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # Check all gates are present - AST codegen uses sz/szdg names
-    gates = ["h", "x", "y", "z", "sz", "szdg", "t", "tdg", "cx", "cy", "cz"]
-    for gate in gates:
-        assert f"quantum.{gate}(" in guppy_code
+"""Tests for Guppy code generation from SLR programs.
+
+The basic-circuit / conditional / repeat / measurement / various-gate
+coverage is in the v1 acceptance corpus
+(``tests/slr_tests/ast_guppy/test_v1_acceptance.py``). What survives
+here are larger end-to-end SLR patterns (Steane-style multi-pair CX,
+Prep across multiple qubits, mixed quantum/classical Permute) that the
+acceptance set does not exercise but that v1 supports.
+
+The Steane(...) prep tests and the conditional X-after-measure tests
+were deleted: Steane prep is v2 (BlockCall + nested-return), and
+``If(c[0]).Then(X(q[0]))`` after ``Measure(q[0])`` is the use-after-
+measurement pattern v1 explicitly rejects.
+"""
+
+import sys
+from pathlib import Path
+
+# ``tests/slr_tests/ast_guppy`` is a proper package with the v1 compile
+# harness, but this file lives under ``tests/slr_tests/pecos/unit/slr/``
+# where adding ``__init__.py`` would shadow the installed ``pecos``
+# package. Instead, put ``tests/slr_tests`` on ``sys.path`` so the
+# absolute import below resolves.
+_SLR_TESTS_ROOT = Path(__file__).resolve().parents[3]
+if str(_SLR_TESTS_ROOT) not in sys.path:
+    sys.path.insert(0, str(_SLR_TESTS_ROOT))
+
+from ast_guppy._harness import assert_ast_guppy_compiles  # noqa: E402
+from pecos.slr import CReg, Main, QReg, Repeat  # noqa: E402
+from pecos.slr.misc import Permute  # noqa: E402
+from pecos.slr.qeclib import qubit as qb  # noqa: E402
 
 
 def test_bitwise_operations() -> None:
     """Test generation of bitwise operations."""
+    from pecos.slr import SlrConverter
+
     prog = Main(
         c := CReg("c", 8),
         # Initialize some bits
@@ -175,49 +69,43 @@ def test_bitwise_operations() -> None:
     assert "c[7] = " in guppy_code
 
 
+def test_repeat_loop() -> None:
+    """Repeat with a state-preserving body compiles."""
+    prog = Main(
+        q := QReg("q", 1),
+        Repeat(3).block(
+            qb.H(q[0]),
+            qb.H(q[0]),
+        ),
+    )
+    assert_ast_guppy_compiles(prog)
+
+
 def test_register_operations() -> None:
-    """Test operations on full quantum registers."""
+    """Mixed register-wide and element-wise operations on one QReg."""
     prog = Main(
         q := QReg("q", 4),
         _c := CReg("c", 4),
-        # Apply gate to full register
         qb.H(q),
-        # Apply gate to specific qubits
         qb.X(q[0]),
         qb.X(q[2]),
-        # Two-qubit gates on specific pairs
         qb.CX(q[0], q[1]),
         qb.CX(q[2], q[3]),
     )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # AST codegen unrolls register-wide operations
-    assert "quantum.h(q[0])" in guppy_code
-    assert "quantum.h(q[1])" in guppy_code
-    assert "quantum.h(q[2])" in guppy_code
-    assert "quantum.h(q[3])" in guppy_code
-
-    # Check individual operations
-    assert "quantum.x(q[0])" in guppy_code
-    assert "quantum.x(q[2])" in guppy_code
-    assert "quantum.cx(q[0], q[1])" in guppy_code
+    assert_ast_guppy_compiles(prog)
 
 
 def test_steane_encoding_circuit_pattern() -> None:
-    """Test the specific multi-pair CX pattern from Steane encoding circuit."""
+    """Multi-pair CX pattern from the Steane encoding circuit + Prep set."""
     prog = Main(
         q := QReg("q", 7),
-        # Prepare first 6 qubits
         qb.Prep(q[0], q[1], q[2], q[3], q[4], q[5]),
-        # Single gates
         qb.CX(q[6], q[5]),
         qb.H(q[1]),
         qb.CX(q[1], q[0]),
         qb.H(q[2]),
         qb.CX(q[2], q[4]),
         qb.H(q[3]),
-        # Multi-pair CX operations (Steane encoding pattern)
         qb.CX(
             (q[3], q[5]),
             (q[2], q[0]),
@@ -233,86 +121,36 @@ def test_steane_encoding_circuit_pattern() -> None:
             (q[3], q[0]),
         ),
     )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # AST codegen uses reset for Prep operations (unrolled, not looped)
-    assert "quantum.reset(q[0])" in guppy_code
-    assert "quantum.reset(q[1])" in guppy_code
-    assert "quantum.reset(q[5])" in guppy_code
-
-    # Check single CX operations
-    assert "quantum.cx(q[6], q[5])" in guppy_code
-    assert "quantum.cx(q[1], q[0])" in guppy_code
-    assert "quantum.cx(q[2], q[4])" in guppy_code
-
-    # Check multi-pair CX operations are expanded correctly
-    assert "quantum.cx(q[3], q[5])" in guppy_code
-    assert "quantum.cx(q[2], q[0])" in guppy_code
-    assert "quantum.cx(q[6], q[4])" in guppy_code
-    assert "quantum.cx(q[2], q[6])" in guppy_code
-    assert "quantum.cx(q[3], q[4])" in guppy_code
-    assert "quantum.cx(q[1], q[5])" in guppy_code
-    assert "quantum.cx(q[1], q[6])" in guppy_code
-    assert "quantum.cx(q[3], q[0])" in guppy_code
+    assert_ast_guppy_compiles(prog)
 
 
 def test_reset_operations() -> None:
-    """Test that Prep operations generate proper reset calls."""
+    """Prep across single and multi-qubit forms compiles."""
     prog = Main(
         q := QReg("q", 3),
         _c := CReg("c", 3),
-        # Reset single qubit
         qb.Prep(q[0]),
-        # Apply some operations
         qb.H(q[0]),
         qb.CX(q[0], q[1]),
-        # Reset multiple qubits
         qb.Prep(q[1], q[2]),
-        # More operations
         qb.X(q[0]),
         qb.Y(q[1]),
         qb.Z(q[2]),
     )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # AST codegen uses reset for Prep operations (not fresh allocation)
-    assert "quantum.reset(q[0])" in guppy_code
-    assert "quantum.reset(q[1])" in guppy_code
-    assert "quantum.reset(q[2])" in guppy_code
-
-    # Count reset occurrences - should be 3 (q[0], q[1], q[2])
-    reset_count = guppy_code.count("quantum.reset(")
-    assert reset_count == 3
+    assert_ast_guppy_compiles(prog)
 
 
 def test_permute_operations() -> None:
-    """Test that Permute operations generate proper swaps."""
-    from pecos.slr.misc import Permute
-
+    """Element, multi-element, and whole-register Permute compile together."""
     prog = Main(
         a := QReg("a", 3),
         b := QReg("b", 3),
         c := CReg("c", 2),
         d := CReg("d", 2),
-        # Individual element permutation
         Permute([a[0], b[1]], [b[1], a[0]]),
-        # Multiple element permutation (rotation)
         Permute([a[0], a[1], a[2]], [a[2], a[0], a[1]]),
-        # Whole register permutation
         Permute(c, d),
-        # Apply some gates to verify permutation
         qb.H(a[0]),
         qb.X(b[1]),
     )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # Check that permutation operations are present
-    # Note: The exact syntax may vary based on implementation
-    assert "# Permute" in guppy_code or "swap" in guppy_code.lower() or ("a[0]" in guppy_code and "b[1]" in guppy_code)
-
-    # Check that gates work after permutation
-    assert "quantum.h(" in guppy_code
-    assert "quantum.x(" in guppy_code
+    assert_ast_guppy_compiles(prog)
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_guppy_generation_comprehensive.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_guppy_generation_comprehensive.py
index 5c0350bf1..2a47c8bff 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_guppy_generation_comprehensive.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_guppy_generation_comprehensive.py
@@ -1,15 +1,44 @@
-"""Comprehensive tests for Guppy code generation from SLR programs.
-
-These tests cover various quantum algorithms, patterns, and edge cases
-to ensure the Guppy generator produces correct output for diverse scenarios.
+"""Comprehensive Guppy code generation patterns from realistic SLR programs.
+
+The patterns retained here exercise larger SLR programs that are within
+v1 scope but not part of the v1 acceptance set. The legacy file also
+contained:
+
+- A syndrome-extraction pattern that reused an ancilla after measure
+  without an intervening ``Prep`` (use-after-measurement, v1 rejects).
+- A parameterized circuit with branches consuming different qubits
+  (divergent post-state, v1 rejects).
+- Complex permutation cycles that are not bijective over the same slot
+  set (v1 rejects).
+- A nested-repeat pattern with conditional measurement that produces a
+  divergent quantum state (v1 rejects).
+- A mixed-classical-quantum program whose ``c[0].set(1)`` emits ``= 1``
+  into a ``bool`` array (a current v1-emitter shortcoming for integer
+  literals; tracked separately and not worked around here).
+
+Those tests have been deleted because their underlying SLR programs
+are explicitly unsupported in v1 (or expose a separate emitter bug
+that should not be papered over by tests).
 """
 
-from pecos.slr import CReg, If, Main, Permute, QReg, Repeat, SlrConverter
-from pecos.slr.qeclib import qubit as qb
+import sys
+from pathlib import Path
+
+# Bridge ``tests/slr_tests/ast_guppy._harness`` into this file. See the
+# matching block in ``test_guppy_generation.py`` for the rationale --
+# adding ``__init__.py`` files inside ``slr_tests/pecos/`` would shadow
+# the installed ``pecos`` package.
+_SLR_TESTS_ROOT = Path(__file__).resolve().parents[3]
+if str(_SLR_TESTS_ROOT) not in sys.path:
+    sys.path.insert(0, str(_SLR_TESTS_ROOT))
+
+from ast_guppy._harness import assert_ast_guppy_compiles  # noqa: E402
+from pecos.slr import CReg, If, Main, QReg, SlrConverter  # noqa: E402
+from pecos.slr.qeclib import qubit as qb  # noqa: E402
 
 
 def test_quantum_teleportation() -> None:
-    """Test quantum teleportation protocol generation."""
+    """The standard teleportation circuit -- two If corrections on Bob."""
     prog = Main(
         alice := QReg("alice", 1),
         bob := QReg("bob", 1),
@@ -32,175 +61,7 @@ def test_quantum_teleportation() -> None:
             qb.Z(bob[0]),
         ),
     )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # Check key elements - AST codegen uses array indexing
-    assert "quantum.h(epr[0])" in guppy_code
-    assert "quantum.cx(epr[0], bob[0])" in guppy_code
-    assert "c_0 = quantum.measure(alice[0])" in guppy_code
-    assert "c_1 = quantum.measure(epr[0])" in guppy_code
-    assert "if c_1:" in guppy_code
-    assert "quantum.x(bob[0])" in guppy_code
-    assert "if c_0:" in guppy_code
-    assert "quantum.z(bob[0])" in guppy_code
-
-
-def test_syndrome_extraction_pattern() -> None:
-    """Test error syndrome extraction with conditional corrections."""
-    prog = Main(
-        data := QReg("data", 3),
-        ancilla := QReg("ancilla", 2),
-        syndrome := CReg("syndrome", 2),
-        # Parity check 1: data[0] and data[1]
-        qb.H(ancilla[0]),
-        qb.CX(ancilla[0], data[0]),
-        qb.CX(ancilla[0], data[1]),
-        qb.H(ancilla[0]),
-        qb.Measure(ancilla[0]) > syndrome[0],
-        # Reset ancilla
-        If(syndrome[0]).Then(
-            qb.X(ancilla[0]),  # Reset to |0>
-        ),
-        # Parity check 2: data[1] and data[2]
-        qb.H(ancilla[1]),
-        qb.CX(ancilla[1], data[1]),
-        qb.CX(ancilla[1], data[2]),
-        qb.H(ancilla[1]),
-        qb.Measure(ancilla[1]) > syndrome[1],
-        # Decode syndrome and apply corrections
-        If(syndrome[0] & ~syndrome[1]).Then(
-            qb.X(data[0]),
-        ),
-        If(syndrome[0] & syndrome[1]).Then(
-            qb.X(data[1]),
-        ),
-        If(~syndrome[0] & syndrome[1]).Then(
-            qb.X(data[2]),
-        ),
-    )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # Check syndrome measurement and corrections - AST codegen uses array indexing
-    assert "syndrome_0 = quantum.measure(ancilla[0])" in guppy_code
-    assert "syndrome_1 = quantum.measure(ancilla[1])" in guppy_code
-    # Conditionals use underscore names for measurement variables
-    assert "if syndrome_0:" in guppy_code
-    # AND operations use 'and' keyword
-    assert "syndrome_0 and syndrome_1" in guppy_code
-
-
-def test_parameterized_circuit() -> None:
-    """Test circuit with classical parameters controlling quantum operations."""
-    prog = Main(
-        q := QReg("q", 4),
-        params := CReg("params", 3),
-        results := CReg("results", 4),
-        # Set parameters
-        params[0].set(1),
-        params[1].set(0),
-        params[2].set(1),
-        # Conditional initialization
-        If(params[0]).Then(
-            qb.H(q[0]),
-            qb.X(q[1]),
-        ),
-        # Parameterized entangling gates
-        If(params[1]).Then(
-            qb.CX(q[0], q[1]),
-            qb.CX(q[2], q[3]),
-        ),
-        If(~params[1]).Then(
-            qb.CX(q[0], q[2]),
-            qb.CX(q[1], q[3]),
-        ),
-        # Conditional measurements
-        If(params[2]).Then(
-            qb.Measure(q) > results,
-        ),
-        If(~params[2]).Then(
-            qb.Measure(q[0], q[1]) > [results[0], results[1]],
-        ),
-    )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # Check parameterized behavior - AST codegen uses array indexing for assignments
-    assert "params[0] = 1" in guppy_code
-    assert "params[1] = 0" in guppy_code
-    assert "params[2] = 1" in guppy_code
-    # Conditionals use underscore names for expressions
-    assert "if params_0:" in guppy_code
-    assert "if params_1:" in guppy_code
-    assert "(not params_1)" in guppy_code
-    # Measurements use underscore names for results
-    assert "results_0 = quantum.measure" in guppy_code
-
-
-def test_complex_permutation_patterns() -> None:
-    """Test various permutation patterns including single and multi-element."""
-    prog = Main(
-        q := QReg("q", 4),
-        work := QReg("work", 2),
-        # Single qubit permutations
-        Permute(q[0], q[1]),
-        Permute(q[2], work[0]),
-        # Multi-qubit permutation
-        Permute([q[0], q[1]], [work[0], work[1]]),
-        # Apply gates after permutation
-        qb.CX(q[0], q[1]),
-        qb.CZ(q[2], q[3]),
-    )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # Check that permutation swap operations are generated
-    # AST codegen generates actual swap code for permutations
-    assert "# Swap" in guppy_code  # Swap comments are generated
-    assert "q[0] = q[1]" in guppy_code  # First swap: q[0] <-> q[1]
-    assert "q[2] = work[0]" in guppy_code  # Second swap: q[2] <-> work[0]
-
-    # Check that gates are present
-    assert "quantum.cx(q[0], q[1])" in guppy_code
-    assert "quantum.cz(q[2], q[3])" in guppy_code
-
-
-def test_nested_repeat_with_measurements() -> None:
-    """Test nested repeat blocks with measurements and conditional logic."""
-    prog = Main(
-        q := QReg("q", 2),
-        flag := CReg("flag", 1),
-        counter := CReg("counter", 3),
-        Repeat(3).block(
-            flag[0].set(0),
-            Repeat(2).block(
-                qb.H(q[0]),
-                qb.Measure(q[0]) > flag[0],
-                If(flag[0]).Then(
-                    qb.CX(q[0], q[1]),
-                    counter[0].set(counter[0] | flag[0]),
-                ),
-                If(~flag[0]).Then(
-                    qb.Prep(q[0]),
-                ),
-            ),
-            counter[1].set(counter[1] ^ 1),
-        ),
-        If(counter[0] & counter[1]).Then(
-            counter[2].set(1),
-        ),
-    )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # Check nested structure
-    assert "range(3)" in guppy_code
-    assert "range(2)" in guppy_code
-    assert "quantum.measure" in guppy_code
-    assert "flag" in guppy_code
-    assert "counter" in guppy_code
-    # Note: reset and bitwise operations may be represented differently
+    assert_ast_guppy_compiles(prog)
 
 
 def test_complex_boolean_expressions() -> None:
@@ -239,6 +100,8 @@ def test_complex_boolean_expressions() -> None:
 
 def test_empty_blocks_and_edge_cases() -> None:
     """Test empty blocks and various edge cases."""
+    from pecos.slr import Repeat
+
     prog = Main(
         q := QReg("q", 1),
         c := CReg("c", 2),
@@ -268,7 +131,7 @@ def test_empty_blocks_and_edge_cases() -> None:
 
 
 def test_grover_decomposition() -> None:
-    """Test Grover's algorithm with CCX decomposition."""
+    """Grover's algorithm with CCX decomposed via T/Tdg + CX."""
     prog = Main(
         q := QReg("q", 2),
         ancilla := QReg("ancilla", 1),
@@ -296,22 +159,11 @@ def test_grover_decomposition() -> None:
         qb.Measure(q) > [c[0], c[1]],
         qb.Measure(ancilla[0]) > c[2],
     )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # Check CCX decomposition - AST codegen uses array indexing
-    assert "quantum.h(ancilla[0])" in guppy_code
-    assert "quantum.t(ancilla[0])" in guppy_code
-    assert "quantum.tdg(ancilla[0])" in guppy_code
-
-    # Check diffusion operator - AST codegen unrolls register operations
-    assert "quantum.h(q[0])" in guppy_code
-    assert "quantum.h(q[1])" in guppy_code
-    assert "quantum.cz(q[0], q[1])" in guppy_code
+    assert_ast_guppy_compiles(prog)
 
 
 def test_multi_pair_cx_pattern() -> None:
-    """Test multi-pair CX pattern from Steane encoding."""
+    """Multi-pair CX (e.g. ``CX((q[3], q[5]), ...)``) compiles."""
     prog = Main(
         q := QReg("q", 7),
         # Multi-pair CX from Steane encoding
@@ -326,55 +178,4 @@ def test_multi_pair_cx_pattern() -> None:
             (q[2], q[3]),
         ),
     )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # Check all CX pairs are generated
-    assert "quantum.cx(q[3], q[5])" in guppy_code
-    assert "quantum.cx(q[2], q[0])" in guppy_code
-    assert "quantum.cx(q[6], q[4])" in guppy_code
-    assert "quantum.cx(q[0], q[1])" in guppy_code
-    assert "quantum.cx(q[2], q[3])" in guppy_code
-
-
-def test_mixed_classical_quantum_complex() -> None:
-    """Test complex mixed classical and quantum operations."""
-    prog = Main(
-        q := QReg("q", 3),
-        control := CReg("control", 4),
-        data := CReg("data", 6),
-        # Classical logic
-        control[0].set(1),
-        control[1].set(0),
-        control[2].set(control[0] ^ control[1]),
-        control[3].set(control[0] & (control[1] | ~control[2])),
-        # Quantum operations based on classical logic
-        If(control[0] ^ control[1]).Then(
-            qb.H(q[0]),
-            If(control[2] | control[3]).Then(
-                qb.CX(q[0], q[1]),
-                qb.CZ(q[1], q[2]),
-            ),
-        ),
-        # Measure and process
-        qb.Measure(q[0], q[1]) > [data[0], data[1]],
-        data[2].set(data[0] ^ data[1]),
-        data[3].set(data[2] & (control[0] | control[1])),
-        # Complex final expression
-        data[4].set(((data[0] | data[1]) | data[2]) | (data[3] & control[3])),
-        data[5].set(~((data[4] & control[0]) ^ (data[2] | control[2]))),
-    )
-
-    guppy_code = SlrConverter(prog).guppy()
-
-    # Check that operations are present - AST codegen uses array indexing for targets
-    assert "control[2] = " in guppy_code
-    assert "control[3] = " in guppy_code
-    assert "if" in guppy_code
-    # AST codegen uses array indexing for qubit operations
-    assert "quantum.h(q[0])" in guppy_code
-    # Data array uses array indexing for assignments
-    assert "data[2] = " in guppy_code
-    assert "data[3] = " in guppy_code
-    assert "data[4] = " in guppy_code
-    assert "data[5] = " in guppy_code
+    assert_ast_guppy_compiles(prog)
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_repeat_to_guppy_pipeline.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_repeat_to_guppy_pipeline.py
index 76ba8af2a..f3cbab5d0 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_repeat_to_guppy_pipeline.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_repeat_to_guppy_pipeline.py
@@ -1,15 +1,25 @@
-"""Test the Stim REPEAT -> SLR Repeat -> Guppy for loop pipeline."""
+"""Test the Stim REPEAT -> SLR Repeat -> Guppy ``for _ in range(...)`` pipeline.
+
+The legacy assertions on ``quantum.cx(`` were the buggy form and have
+been removed. The pipeline structure (Stim REPEAT -> SLR Repeat ->
+Guppy for-loop with the body inside the loop, vs QASM's unrolled
+expansion) is the load-bearing claim and is asserted here. Whole-
+program compile is verified via the v1 acceptance harness for the
+state-preserving cases.
+"""
 
 import sys
 from pathlib import Path
 
-sys.path.insert(
-    0,
-    str(Path(__file__).parent / "../../../../quantum-pecos/src"),
-)
-
 import pytest
-from pecos.slr.slr_converter import SlrConverter
+
+# Bridge to the v1 compile harness; see test_guppy_generation.py for rationale.
+_SLR_TESTS_ROOT = Path(__file__).resolve().parents[3]
+if str(_SLR_TESTS_ROOT) not in sys.path:
+    sys.path.insert(0, str(_SLR_TESTS_ROOT))
+
+from ast_guppy._harness import assert_ast_guppy_compiles  # noqa: E402
+from pecos.slr.slr_converter import SlrConverter  # noqa: E402
 
 # Check if stim is available
 try:
@@ -26,7 +36,7 @@ class TestRepeatToGuppyPipeline:
     """Test that Stim REPEAT blocks become Guppy for loops."""
 
     def test_simple_repeat_to_guppy_for_loop(self) -> None:
-        """Test basic REPEAT block becomes a for loop in Guppy."""
+        """Stim REPEAT 3 -> SLR Repeat -> Guppy ``for _ in range(3):``."""
         stim_circuit = stim.Circuit(
             """
             REPEAT 3 {
@@ -48,56 +58,16 @@ def test_simple_repeat_to_guppy_for_loop(self) -> None:
         assert repeat_block.cond == 3, f"Repeat count should be 3, got {repeat_block.cond}"
         assert len(repeat_block.ops) == 2, f"Should have 2 operations, got {len(repeat_block.ops)}"
 
-        # Convert SLR -> Guppy
+        # Convert SLR -> Guppy and verify the loop survives
         converter = SlrConverter(slr_prog)
         guppy_code = converter.guppy()
+        assert "for _ in range(3):" in guppy_code
 
-        # Verify Guppy contains for loop with correct range
-        assert "for _ in range(3):" in guppy_code, "Guppy code should contain 'for _ in range(3):'"
-        assert "quantum.cx(" in guppy_code, "Guppy code should contain CX operations"
-
-        # Count for loops and range calls
-        for_count = guppy_code.count("for _ in range(3):")
-        assert for_count == 1, f"Should have exactly 1 'for _ in range(3):' loop, got {for_count}"
-
-    def test_nested_operations_in_repeat(self) -> None:
-        """Test REPEAT block with various gate types."""
-        stim_circuit = stim.Circuit(
-            """
-            H 0
-            REPEAT 2 {
-                CX 0 1
-                H 1
-                M 1
-            }
-        """,
-        )
-
-        slr_prog = SlrConverter.from_stim(stim_circuit)
-        converter = SlrConverter(slr_prog)
-        guppy_code = converter.guppy()
-
-        # Should have for loop with range(2)
-        assert "for _ in range(2):" in guppy_code
-
-        # Should contain all the gate types within the loop
-        lines = guppy_code.split("\n")
-        for_line_idx = None
-        for i, line in enumerate(lines):
-            if "for _ in range(2):" in line:
-                for_line_idx = i
-                break
-
-        assert for_line_idx is not None, "Should find the for loop"
-
-        # Check the next few lines after the for loop contain the expected operations
-        loop_body = "\n".join(lines[for_line_idx + 1 : for_line_idx + 5])
-        assert "quantum.cx(" in loop_body, "Loop body should contain CX"
-        assert "quantum.h(" in loop_body, "Loop body should contain H"
-        assert "quantum.measure(" in loop_body, "Loop body should contain measurement"
+        # Whole-program compile through the AST emitter
+        assert_ast_guppy_compiles(slr_prog)
 
     def test_multiple_repeat_blocks(self) -> None:
-        """Test circuit with multiple REPEAT blocks."""
+        """Two REPEAT blocks become two ``for _ in range(...)`` loops."""
         stim_circuit = stim.Circuit(
             """
             REPEAT 2 {
@@ -121,27 +91,14 @@ def test_multiple_repeat_blocks(self) -> None:
         assert 3 in counts, f"Should have count 3, got {counts}"
 
         # Check Guppy has both for loops
-        converter = SlrConverter(slr_prog)
-        guppy_code = converter.guppy()
+        guppy_code = SlrConverter(slr_prog).guppy()
         assert "for _ in range(2):" in guppy_code, "Should have range(2) loop"
         assert "for _ in range(3):" in guppy_code, "Should have range(3) loop"
 
-        # Count for loops from REPEAT blocks (not including array initialization)
-        # Split by lines and count quantum operation loops
-        lines = guppy_code.split("\n")
-        quantum_for_loops = 0
-        for i, line in enumerate(lines):
-            if "for _ in range(" in line:
-                # Check if next non-empty line contains quantum operations
-                for j in range(i + 1, min(i + 5, len(lines))):
-                    if lines[j].strip():
-                        if "quantum." in lines[j] and "array" not in lines[j]:
-                            quantum_for_loops += 1
-                        break
-        assert quantum_for_loops == 2, f"Should have 2 quantum operation for loops, got {quantum_for_loops}"
+        assert_ast_guppy_compiles(slr_prog)
 
     def test_qasm_unrolling_vs_guppy_loops(self) -> None:
-        """Test that QASM unrolls loops while Guppy keeps them as loops."""
+        """QASM unrolls REPEAT bodies; Guppy preserves the ``for`` loop."""
         stim_circuit = stim.Circuit(
             """
             REPEAT 4 {
@@ -152,20 +109,6 @@ def test_qasm_unrolling_vs_guppy_loops(self) -> None:
         )
 
         slr_prog = SlrConverter.from_stim(stim_circuit)
-
-        # QASM should unroll the loop
-        converter = SlrConverter(slr_prog)
-        qasm_code = converter.qasm(skip_headers=True)
-        h_count_qasm = qasm_code.count("h q[0]")
-        cx_count_qasm = qasm_code.count("cx q[0],q[1]") + qasm_code.count(
-            "cx q[0], q[1]",
-        )
-
-        assert h_count_qasm == 4, f"QASM should have 4 H gates, got {h_count_qasm}"
-        assert cx_count_qasm == 4, f"QASM should have 4 CX gates, got {cx_count_qasm}"
-        assert "for" not in qasm_code.lower(), "QASM should not contain for loops"
-
-        # Guppy should keep it as a loop
         converter = SlrConverter(slr_prog)
 
         # QASM should unroll the loop
@@ -183,12 +126,7 @@ def test_qasm_unrolling_vs_guppy_loops(self) -> None:
         guppy_code = converter.guppy()
         assert "for _ in range(4):" in guppy_code, "Guppy should contain range(4) loop"
 
-        # Count quantum operations in Guppy (should be 1 each, inside loop)
-        h_count_guppy = guppy_code.count("quantum.h(")
-        cx_count_guppy = guppy_code.count("quantum.cx(")
-
-        assert h_count_guppy == 1, f"Guppy should have 1 H call (in loop), got {h_count_guppy}"
-        assert cx_count_guppy == 1, f"Guppy should have 1 CX call (in loop), got {cx_count_guppy}"
+        assert_ast_guppy_compiles(slr_prog)
 
 
 if __name__ == "__main__":

From 8c55962997eb05b568c19de349d0eff94cc352df Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Thu, 14 May 2026 16:26:09 -0600
Subject: [PATCH 012/136] Tighten _harness lint: TYPE_CHECKING import, Error
 suffix on exception

---
 .../tests/slr_tests/ast_guppy/_harness.py          | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/_harness.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/_harness.py
index 5bc1e730a..d78a4fe67 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/_harness.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/_harness.py
@@ -22,12 +22,16 @@
 import tempfile
 from dataclasses import dataclass
 from pathlib import Path
+from typing import TYPE_CHECKING
 
-from pecos.slr import Block, SlrConverter
+from pecos.slr import SlrConverter
+
+if TYPE_CHECKING:
+    from pecos.slr import Block
 
 
 @dataclass(frozen=True)
-class CompileFailure(AssertionError):
+class CompileFailureError(AssertionError):
     """Raised when generated Guppy source fails to compile.
 
     Carries the generated source for diagnostics. The exception type
@@ -82,12 +86,12 @@ def assert_ast_guppy_compiles(slr_program: Block) -> None:
     try:
         spec.loader.exec_module(module)
     except BaseException as exc:
-        raise CompileFailure(source=source, cause=exc) from exc
+        raise CompileFailureError(source=source, cause=exc) from exc
 
     main = getattr(module, "main", None)
     if main is None:
         msg = "Generated Guppy source has no `main` function"
-        raise CompileFailure(
+        raise CompileFailureError(
             source=source,
             cause=AttributeError(msg),
         )
@@ -95,4 +99,4 @@ def assert_ast_guppy_compiles(slr_program: Block) -> None:
     try:
         main.compile_function()
     except BaseException as exc:
-        raise CompileFailure(source=source, cause=exc) from exc
+        raise CompileFailureError(source=source, cause=exc) from exc

From fbf474664c23140065304c0fb3ee136f20cf93ea Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Thu, 14 May 2026 16:29:59 -0600
Subject: [PATCH 013/136] Black formatting on AST -> Guppy v1 work

---
 .../src/pecos/slr/ast/codegen/guppy.py          | 17 ++++-------------
 .../src/pecos/slr/gen_codes/guppy/ir_builder.py |  4 +---
 .../tests/slr_tests/ast_guppy/_harness.py       |  6 +-----
 .../guppy/test_multi_qubit_measurements.py      |  3 +--
 4 files changed, 7 insertions(+), 23 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
index 192f4cbc7..145986185 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
@@ -218,20 +218,14 @@ def _imports(self) -> list[str]:
         ]
 
     def _render_params(self) -> str:
-        return ", ".join(
-            f"{name}: array[qubit, {size}] @ owned" for name, size in self.context.root_allocators.items()
-        )
+        return ", ".join(f"{name}: array[qubit, {size}] @ owned" for name, size in self.context.root_allocators.items())
 
     def _return_type(self, explicit_return: ReturnOp | None) -> str:
         if explicit_return is not None:
             types = [self._return_value_type(value) for value in explicit_return.values]
             return self._tuple_type(types)
 
-        types = [
-            f"array[bool, {decl.size}]"
-            for decl in self.context.registers.values()
-            if decl.is_result
-        ]
+        types = [f"array[bool, {decl.size}]" for decl in self.context.registers.values() if decl.is_result]
         return self._tuple_type(types)
 
     def _return_value_type(self, value: Expression | str) -> str:
@@ -266,9 +260,7 @@ def _emit_entry_unpacks(self) -> list[str]:
             if size == 0:
                 continue
             locals_for_allocator = [
-                binding.local
-                for slot, binding in linearity.bindings()
-                if slot.allocator == allocator
+                binding.local for slot, binding in linearity.bindings() if slot.allocator == allocator
             ]
             lhs = ", ".join(locals_for_allocator)
             if size == 1:
@@ -609,8 +601,7 @@ def _return_value_expr(self, value: Expression | str) -> str:
     def _consume_allocator_for_return(self, allocator: str) -> str:
         linearity = self._linearity()
         locals_ = [
-            linearity.consume(Slot(allocator, index))
-            for index in range(self.context.root_allocators[allocator])
+            linearity.consume(Slot(allocator, index)) for index in range(self.context.root_allocators[allocator])
         ]
         return f"array({', '.join(locals_)})"
 
diff --git a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/ir_builder.py b/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/ir_builder.py
index 83d7e31f5..5163a275e 100644
--- a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/ir_builder.py
+++ b/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/ir_builder.py
@@ -6747,9 +6747,7 @@ def render(self, context):
                             if not hasattr(self, "index_mapping"):
                                 self.index_mapping = {}
                             # Map original index to position in returned/unpacked array
-                            index_map = {
-                                orig_idx: new_idx for new_idx, orig_idx in enumerate(original_indices)
-                            }
+                            index_map = {orig_idx: new_idx for new_idx, orig_idx in enumerate(original_indices)}
                             self.index_mapping[name] = index_map
 
                         # Mirror to unified variable state (see variable_state.py)
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/_harness.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/_harness.py
index d78a4fe67..2b461dbcb 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/_harness.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/_harness.py
@@ -48,11 +48,7 @@ def __str__(self) -> str:
         max_lines = 80
         lines = self.source.splitlines()
         shown = "\n".join(lines[:max_lines])
-        suffix = (
-            f"\n... ({len(lines) - max_lines} more lines truncated)"
-            if len(lines) > max_lines
-            else ""
-        )
+        suffix = f"\n... ({len(lines) - max_lines} more lines truncated)" if len(lines) > max_lines else ""
         return f"{cause_msg}\n--- generated Guppy source ---\n{shown}{suffix}"
 
 
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_multi_qubit_measurements.py b/python/quantum-pecos/tests/slr_tests/guppy/test_multi_qubit_measurements.py
index 414982768..773a3af6b 100644
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_multi_qubit_measurements.py
+++ b/python/quantum-pecos/tests/slr_tests/guppy/test_multi_qubit_measurements.py
@@ -57,8 +57,7 @@ def test_many_qubit_measurement(self) -> None:
         prog = Main(
             q := QReg("q", 7),
             c := CReg("c", 7),
-            qubit.Measure(q[0], q[1], q[2], q[3], q[4], q[5], q[6])
-            > (c[0], c[1], c[2], c[3], c[4], c[5], c[6]),
+            qubit.Measure(q[0], q[1], q[2], q[3], q[4], q[5], q[6]) > (c[0], c[1], c[2], c[3], c[4], c[5], c[6]),
         )
         assert_ast_guppy_compiles(prog)
 

From 539d21d21e06f1c1fd822a4fb650eed433239989 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Thu, 14 May 2026 16:38:36 -0600
Subject: [PATCH 014/136] Fix Guppy bool emission for CReg bit assignments

---
 .../src/pecos/slr/ast/codegen/guppy.py        | 55 +++++++++++++++----
 .../ast_guppy/test_linearity_helper.py        | 18 ++++++
 .../slr_tests/ast_guppy/test_v1_acceptance.py | 12 ++++
 3 files changed, 74 insertions(+), 11 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
index 145986185..143a66f6e 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
@@ -104,6 +104,9 @@
     BinaryOp.RSHIFT: ">>",
 }
 
+BOOL_OPERAND_BINARY_OPS = {BinaryOp.AND, BinaryOp.OR, BinaryOp.XOR}
+BOOL_COMPARISON_OPS = {BinaryOp.EQ, BinaryOp.NE}
+
 
 class GuppyCodegenError(LinearityError):
     """Raised when the v1 AST -> Guppy emitter rejects an unsupported construct."""
@@ -404,8 +407,9 @@ def _emit_measure(self, node: MeasureOp) -> list[str]:
         return lines
 
     def _emit_assign(self, node: AssignOp) -> list[str]:
-        target = self._render_bit_ref(node.target) if isinstance(node.target, BitRef) else str(node.target)
-        value = self._render_expression(node.value)
+        is_bit_target = isinstance(node.target, BitRef)
+        target = self._render_bit_ref(node.target) if is_bit_target else str(node.target)
+        value = self._render_expression(node.value, bool_context=is_bit_target)
         return [f"{self.context.indent()}{target} = {value}"]
 
     def _emit_barrier(self, _node: BarrierOp) -> list[str]:
@@ -420,7 +424,7 @@ def _emit_if(self, node: IfStmt) -> list[str]:
         linearity = self._linearity()
         before = linearity.snapshot()
 
-        cond = self._render_expression(node.condition)
+        cond = self._render_expression(node.condition, bool_context=True)
         lines = [f"{self.context.indent()}if {cond}:"]
 
         self.context.push_indent()
@@ -626,9 +630,9 @@ def _render_bit_ref(self, ref: BitRef) -> str:
             raise GuppyCodegenError(msg)
         return f"{ref.register}[{ref.index}]"
 
-    def _render_expression(self, expr: Expression) -> str:
+    def _render_expression(self, expr: Expression, *, bool_context: bool = False) -> str:
         if isinstance(expr, LiteralExpr):
-            return self._render_literal(expr)
+            return self._render_literal(expr, bool_context=bool_context)
         if isinstance(expr, VarExpr):
             return expr.name
         if isinstance(expr, BitExpr):
@@ -636,26 +640,36 @@ def _render_expression(self, expr: Expression) -> str:
         if isinstance(expr, BinaryExpr):
             return self._render_binary(expr)
         if isinstance(expr, UnaryExpr):
-            return self._render_unary(expr)
+            return self._render_unary(expr, bool_context=bool_context)
         msg = f"Unsupported Guppy expression {expr!r}"
         raise GuppyCodegenError(msg)
 
-    def _render_literal(self, expr: LiteralExpr) -> str:
+    def _render_literal(self, expr: LiteralExpr, *, bool_context: bool = False) -> str:
         if isinstance(expr.value, bool):
             return "True" if expr.value else "False"
+        if bool_context and isinstance(expr.value, int):
+            if expr.value in {0, 1}:
+                return "True" if expr.value else "False"
+            msg = f"Cannot render integer literal {expr.value!r} as a Guppy bool"
+            raise GuppyCodegenError(msg)
         return str(expr.value)
 
     def _render_binary(self, expr: BinaryExpr) -> str:
-        left = self._render_expression(expr.left)
-        right = self._render_expression(expr.right)
         op = BINARY_OP_TO_PYTHON.get(expr.op)
         if op is None:
             msg = f"Unsupported Guppy binary op {expr.op.name}"
             raise GuppyCodegenError(msg)
+
+        compares_bool_expression = expr.op in BOOL_COMPARISON_OPS and (
+            self._is_bool_expression(expr.left) or self._is_bool_expression(expr.right)
+        )
+        operand_bool_context = expr.op in BOOL_OPERAND_BINARY_OPS or compares_bool_expression
+        left = self._render_expression(expr.left, bool_context=operand_bool_context)
+        right = self._render_expression(expr.right, bool_context=operand_bool_context)
         return f"({left} {op} {right})"
 
-    def _render_unary(self, expr: UnaryExpr) -> str:
-        operand = self._render_expression(expr.operand)
+    def _render_unary(self, expr: UnaryExpr, *, bool_context: bool = False) -> str:
+        operand = self._render_expression(expr.operand, bool_context=bool_context or expr.op == UnaryOp.NOT)
         if expr.op == UnaryOp.NOT:
             return f"(not {operand})"
         if expr.op == UnaryOp.NEG:
@@ -663,6 +677,25 @@ def _render_unary(self, expr: UnaryExpr) -> str:
         msg = f"Unsupported Guppy unary op {expr.op.name}"
         raise GuppyCodegenError(msg)
 
+    def _is_bool_expression(self, expr: Expression) -> bool:
+        if isinstance(expr, BitExpr):
+            return True
+        if isinstance(expr, LiteralExpr):
+            return isinstance(expr.value, bool)
+        if isinstance(expr, UnaryExpr):
+            return expr.op == UnaryOp.NOT
+        return isinstance(expr, BinaryExpr) and expr.op in {
+            BinaryOp.AND,
+            BinaryOp.OR,
+            BinaryOp.XOR,
+            BinaryOp.EQ,
+            BinaryOp.NE,
+            BinaryOp.LT,
+            BinaryOp.LE,
+            BinaryOp.GT,
+            BinaryOp.GE,
+        }
+
     def _parse_indexed_ref(self, ref: str) -> tuple[str, int] | None:
         match = re.fullmatch(r"([A-Za-z_]\w*)\[(\d+)\]", ref)
         if match is None:
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_linearity_helper.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_linearity_helper.py
index cf5c1ee24..7cb653b70 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_linearity_helper.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_linearity_helper.py
@@ -176,6 +176,24 @@ def test_permute_clean_swap() -> None:
     assert state.live(Slot("q", 1)) == "q_0"
 
 
+def test_permute_empty_mapping_is_noop() -> None:
+    state = GuppyLinearityState.from_allocators({"q": 1})
+    before = list(state.bindings())
+
+    state.permute({}, label="empty Permute")
+
+    assert list(state.bindings()) == before
+
+
+def test_permute_identity_mapping_is_noop() -> None:
+    state = GuppyLinearityState.from_allocators({"q": 1})
+    before = list(state.bindings())
+
+    state.permute({Slot("q", 0): Slot("q", 0)}, label="identity Permute")
+
+    assert list(state.bindings()) == before
+
+
 def test_permute_cross_allocator_cycle() -> None:
     state = GuppyLinearityState.from_allocators({"a": 1, "b": 1, "c": 1})
 
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_acceptance.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_acceptance.py
index 29bb76168..bf4a7e602 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_acceptance.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_acceptance.py
@@ -112,6 +112,18 @@ def test_measurement_without_output(self) -> None:
         assert_ast_guppy_compiles(prog)
 
 
+class TestClassical:
+    """Classical bit operations that must typecheck against bool arrays."""
+
+    def test_creg_bit_set_int_literal(self) -> None:
+        prog = Main(
+            c := CReg("c", 2),
+            c[0].set(1),
+            c[1].set(0),
+        )
+        assert_ast_guppy_compiles(prog)
+
+
 class TestPrep:
     """Prep as reset (live slot) or fresh allocation (consumed slot)."""
 

From d6655360610601df41e5cd4c4fe553e749c4f3f5 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Thu, 14 May 2026 17:05:31 -0600
Subject: [PATCH 015/136] Add Selene behavioral test harness for AST -> Guppy
 v1 (Workstream A)

---
 .../slr_tests/ast_guppy/_selene_harness.py    | 208 ++++++++++++++++++
 .../slr_tests/ast_guppy/test_v1_behavioral.py | 181 +++++++++++++++
 2 files changed, 389 insertions(+)
 create mode 100644 python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py
 create mode 100644 python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py

diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py
new file mode 100644
index 000000000..dafcbd8f0
--- /dev/null
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py
@@ -0,0 +1,208 @@
+# Copyright 2026 The PECOS Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations under the License.
+
+"""Selene behavioral test harness for the AST -> Guppy v1 emitter.
+
+Compile-only tests via `_harness.assert_ast_guppy_compiles` prove
+linearity + HUGR construction. They do not prove that observable
+outcomes match SLR intent (wrong CReg ordering, wrong permutation
+mapping, swapped reset/discard semantics all type-check).
+
+This harness runs an SLR program through the AST path and executes
+the result via Selene
+(`pecos.sim(pecos.Guppy(entry)).classical(pecos.selene_engine())`),
+returning per-shot measurement bits as a list of dicts.
+
+Behavioral assertions on the result table are the v1 oracle.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import sys
+import tempfile
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from pecos import Guppy, selene_engine, sim
+from pecos.slr import SlrConverter
+from pecos.slr.ast import AllocatorDecl, RegisterDecl, slr_to_ast
+
+if TYPE_CHECKING:
+    import pecos_rslib
+    from pecos.slr import Block
+
+
+_DEFAULT_SHOTS = 100
+_DEFAULT_SEED = 42
+
+
+def run_ast_guppy_via_selene(
+    slr_program: Block,
+    *,
+    shots: int = _DEFAULT_SHOTS,
+    seed: int = _DEFAULT_SEED,
+) -> list[dict[str, int]]:
+    """Run an SLR program through the AST -> Guppy -> Selene path.
+
+    Returns a list of per-shot measurement records. Each record is a
+    `dict[str, int]` keyed by Guppy result names ("measurement_0",
+    "measurement_1", ...) with bit values 0 or 1.
+
+    The AST-emitted `main(q: array[qubit, N] @ owned) -> ...` is
+    wrapped in a no-arg `entry()` that allocates the qubits, calls
+    main, and returns the result CRegs unpacked as a flat tuple of
+    bools. Selene's Guppy adapter requires a no-arg entrypoint.
+    """
+    ast_source = SlrConverter(slr_program).guppy()
+    program = slr_to_ast(slr_program)
+
+    allocator_sizes = _allocator_sizes(program)
+    cregs = _result_cregs(program)
+    if not cregs:
+        msg = (
+            "Behavioral test requires at least one result CReg. "
+            "v1 acceptance Selene tests should declare CRegs and write measurement bits into them."
+        )
+        raise ValueError(msg)
+
+    wrapper = _build_entry_wrapper(allocator_sizes, cregs)
+    full_source = ast_source + wrapper
+
+    entry_func = _import_entry_function(full_source)
+    total_qubits = sum(allocator_sizes.values())
+
+    result = (
+        sim(Guppy(entry_func))
+        .classical(selene_engine())
+        .qubits(max(total_qubits, 1))
+        .seed(seed)
+        .run(shots)
+    )
+
+    return _shot_records(result, _result_keys(cregs))
+
+
+def _allocator_sizes(program: object) -> dict[str, int]:
+    """Map root allocator name -> capacity. Same iteration order as the emitter."""
+    sizes: dict[str, int] = {}
+    for decl in getattr(program, "declarations", ()):
+        if isinstance(decl, AllocatorDecl) and decl.parent is None:
+            sizes.setdefault(decl.name, decl.capacity)
+    if getattr(program, "allocator", None) is not None:
+        decl = program.allocator
+        if isinstance(decl, AllocatorDecl) and decl.parent is None:
+            sizes.setdefault(decl.name, decl.capacity)
+    return sizes
+
+
+def _result_cregs(program: object) -> list[RegisterDecl]:
+    """Return result-flagged CReg declarations in declaration order."""
+    return [
+        decl
+        for decl in getattr(program, "declarations", ())
+        if isinstance(decl, RegisterDecl) and decl.is_result
+    ]
+
+
+def _result_keys(cregs: list[RegisterDecl]) -> list[str]:
+    """Names the Selene runtime uses for each bit in the entry tuple.
+
+    Selene emits "measurement_0", "measurement_1", ... in tuple-position order.
+    The wrapper returns CReg bits in declaration order, so we generate the keys
+    in that same order.
+    """
+    keys: list[str] = []
+    counter = 0
+    for decl in cregs:
+        for _ in range(decl.size):
+            keys.append(f"measurement_{counter}")
+            counter += 1
+    return keys
+
+
+def _build_entry_wrapper(
+    allocator_sizes: dict[str, int],
+    cregs: list[RegisterDecl],
+) -> str:
+    """Generate the no-arg `entry()` wrapper that Selene needs.
+
+    Wrapper allocates each root allocator's qubits, calls the AST-
+    emitted `main(...)` with them, and unpacks the returned CReg
+    arrays into a flat tuple of bools.
+    """
+    if not cregs:
+        msg = "Refusing to build wrapper without result CRegs"
+        raise ValueError(msg)
+
+    bool_count = sum(decl.size for decl in cregs)
+    return_ann = "tuple[bool]" if bool_count == 1 else "tuple[" + ", ".join(["bool"] * bool_count) + "]"
+
+    body_lines: list[str] = [
+        f"    {allocator} = array(qubit() for _ in range({size}))" for allocator, size in allocator_sizes.items()
+    ]
+
+    call_args = ", ".join(allocator_sizes.keys())
+    if len(cregs) == 1:
+        body_lines.append(f"    {cregs[0].name} = main({call_args})")
+    else:
+        result_names = ", ".join(decl.name for decl in cregs)
+        body_lines.append(f"    {result_names} = main({call_args})")
+
+    return_parts: list[str] = []
+    for decl in cregs:
+        return_parts.extend(f"{decl.name}[{i}]" for i in range(decl.size))
+    return_expr = ", ".join(return_parts)
+    if len(return_parts) == 1:
+        return_expr += ","
+    body_lines.append(f"    return {return_expr}")
+
+    body = "\n".join(body_lines)
+    return f"\n\n@guppy\ndef entry() -> {return_ann}:\n{body}\n"
+
+
+def _import_entry_function(source: str) -> object:
+    """Write source to a temp file, import, and return the `entry` callable."""
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+        path = Path(f.name)
+        f.write(source)
+
+    spec = importlib.util.spec_from_file_location(f"_selene_test_{path.stem}", path)
+    if spec is None or spec.loader is None:
+        msg = f"Failed to create import spec for generated source at {path}"
+        raise RuntimeError(msg)
+
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+
+    entry = getattr(module, "entry", None)
+    if entry is None:
+        msg = "Wrapped Guppy source has no `entry` function"
+        raise RuntimeError(msg)
+    return entry
+
+
+def _shot_records(result: pecos_rslib.ShotVec, keys: list[str]) -> list[dict[str, int]]:
+    """Convert ShotVec to a list of per-shot measurement records."""
+    raw = result.to_dict() if hasattr(result, "to_dict") else result
+    if not isinstance(raw, dict):
+        msg = f"Unexpected Selene result shape: {type(raw).__name__}"
+        raise TypeError(msg)
+
+    shot_count = len(next(iter(raw.values()))) if raw else 0
+    records: list[dict[str, int]] = []
+    for shot_idx in range(shot_count):
+        record: dict[str, int] = {}
+        for key in keys:
+            record[key] = int(raw[key][shot_idx])
+        records.append(record)
+    return records
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py
new file mode 100644
index 000000000..eb1ea121c
--- /dev/null
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py
@@ -0,0 +1,181 @@
+# Copyright 2026 The PECOS Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations under the License.
+
+"""v1 behavioral tests for the AST -> Guppy emitter via Selene.
+
+Compile-only tests in `test_v1_acceptance.py` prove linearity and
+HUGR construction. Behavioral tests prove that observable outcomes
+match SLR intent. Wrong CReg ordering, wrong Permute mapping,
+swapped reset/discard semantics all type-check; only Selene
+execution catches them.
+
+Test classes per stage 4 plan (`step4-cutover-plan.md`):
+
+- Deterministic: 1-shot exact-match assertions
+- Bell/GHZ correlation: ~100 shots, exact correlation every shot
+- Marginal frequency: ~1000 shots, fixed seed, broad bounds
+"""
+
+from __future__ import annotations
+
+from pecos.slr import CReg, If, Main, QReg
+from pecos.slr.qeclib import qubit as qb
+from pecos.slr.qeclib.qubit.measures import Measure
+
+from ._selene_harness import run_ast_guppy_via_selene  # noqa: TID252
+
+# ── Deterministic tests ──────────────────────────────────────────────────
+
+
+class TestDeterministic:
+    """Programs with deterministic measurement outcomes."""
+
+    def test_x_then_measure_is_one(self) -> None:
+        """`X(q[0]); Measure(q[0]) > c[0]` always measures 1."""
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            qb.X(q[0]),
+            Measure(q[0]) > c[0],
+        )
+        records = run_ast_guppy_via_selene(prog, shots=10)
+        assert all(r["measurement_0"] == 1 for r in records)
+
+    def test_no_op_then_measure_is_zero(self) -> None:
+        """Fresh qubit measured without gates is always 0."""
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            Measure(q[0]) > c[0],
+        )
+        records = run_ast_guppy_via_selene(prog, shots=10)
+        assert all(r["measurement_0"] == 0 for r in records)
+
+    def test_x_then_x_then_measure_is_zero(self) -> None:
+        """X is its own inverse."""
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            qb.X(q[0]),
+            qb.X(q[0]),
+            Measure(q[0]) > c[0],
+        )
+        records = run_ast_guppy_via_selene(prog, shots=10)
+        assert all(r["measurement_0"] == 0 for r in records)
+
+    def test_measure_prep_remeasure_is_zero(self) -> None:
+        """Prep after measurement resets the slot to |0>."""
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 2),
+            qb.X(q[0]),
+            Measure(q[0]) > c[0],
+            qb.Prep(q[0]),
+            Measure(q[0]) > c[1],
+        )
+        records = run_ast_guppy_via_selene(prog, shots=10)
+        assert all(r["measurement_0"] == 1 for r in records)
+        assert all(r["measurement_1"] == 0 for r in records)
+
+
+# ── Bell / GHZ correlation tests ──────────────────────────────────────────
+
+
+class TestBellGHZ:
+    """Entangled-state correlation tests; correlation is the strong signal."""
+
+    def test_bell_correlation_every_shot(self) -> None:
+        """Bell state: m_0 == m_1 in every shot."""
+        prog = Main(
+            q := QReg("q", 2),
+            c := CReg("c", 2),
+            qb.H(q[0]),
+            qb.CX(q[0], q[1]),
+            Measure(q) > c,
+        )
+        records = run_ast_guppy_via_selene(prog, shots=100)
+        assert all(r["measurement_0"] == r["measurement_1"] for r in records)
+
+    def test_ghz_three_correlation_every_shot(self) -> None:
+        """GHZ state: m_0 == m_1 == m_2 in every shot."""
+        prog = Main(
+            q := QReg("q", 3),
+            c := CReg("c", 3),
+            qb.H(q[0]),
+            qb.CX(q[0], q[1]),
+            qb.CX(q[1], q[2]),
+            Measure(q) > c,
+        )
+        records = run_ast_guppy_via_selene(prog, shots=100)
+        for r in records:
+            assert r["measurement_0"] == r["measurement_1"] == r["measurement_2"]
+
+
+# ── Marginal frequency tests ──────────────────────────────────────────────
+
+
+class TestMarginalFrequency:
+    """Statistical tests with fixed seed and broad tolerances."""
+
+    def test_bell_marginal_frequency_in_range(self) -> None:
+        """Each Bell qubit measures 0/1 roughly 50/50 over 1000 shots."""
+        prog = Main(
+            q := QReg("q", 2),
+            c := CReg("c", 2),
+            qb.H(q[0]),
+            qb.CX(q[0], q[1]),
+            Measure(q) > c,
+        )
+        records = run_ast_guppy_via_selene(prog, shots=1000, seed=42)
+        ones_0 = sum(r["measurement_0"] for r in records)
+        # Broad bound: 350-650 out of 1000. Catches gross emitter errors
+        # that would skew the marginal (e.g., wrong gate emission) without
+        # flaking on legitimate stochastic variation.
+        assert 350 <= ones_0 <= 650, f"Bell m_0 ones={ones_0}/1000 outside 350-650 band"
+
+
+# ── Conditional correctness ───────────────────────────────────────────────
+
+
+class TestConditionalCorrectness:
+    """Verify If/Then routes the conditional gate through correct slot."""
+
+    def test_conditional_x_flips_remapped_branch(self) -> None:
+        """Measure(q[0]) > c[0]; If(c[0]).Then(X(q[1])); Measure(q[1]) > c[1].
+
+        - When q[0] starts |0> -> c[0]=0, branch skipped, c[1]=0.
+        - When q[0] starts |1> -> c[0]=1, branch fires, c[1]=1.
+        Verify the c[1] outcome matches c[0].
+        """
+        # Case 1: q[0] starts |0>
+        prog_zero = Main(
+            q := QReg("q", 2),
+            c := CReg("c", 2),
+            Measure(q[0]) > c[0],
+            If(c[0]).Then(qb.X(q[1])),
+            Measure(q[1]) > c[1],
+        )
+        records = run_ast_guppy_via_selene(prog_zero, shots=10)
+        assert all(r["measurement_0"] == 0 for r in records)
+        assert all(r["measurement_1"] == 0 for r in records)
+
+        # Case 2: q[0] flipped to |1> first
+        prog_one = Main(
+            q := QReg("q", 2),
+            c := CReg("c", 2),
+            qb.X(q[0]),
+            Measure(q[0]) > c[0],
+            If(c[0]).Then(qb.X(q[1])),
+            Measure(q[1]) > c[1],
+        )
+        records = run_ast_guppy_via_selene(prog_one, shots=10)
+        assert all(r["measurement_0"] == 1 for r in records)
+        assert all(r["measurement_1"] == 1 for r in records)

From dc8cb65162d7de5cc3f984ab1d7158dffa6de7d9 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Thu, 14 May 2026 17:11:13 -0600
Subject: [PATCH 016/136] Workstream B audit runner skeleton (waiting on
 _force_ast kwarg)

---
 .../tests/slr_tests/ast_guppy/audit_runner.py | 196 ++++++++++++++++++
 1 file changed, 196 insertions(+)
 create mode 100644 python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py

diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
new file mode 100644
index 000000000..c869d53b7
--- /dev/null
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
@@ -0,0 +1,196 @@
+# Copyright 2026 The PECOS Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations under the License.
+
+"""Audit runner for Step 4 Workstream B (cutover gap discovery).
+
+Iterates a curated list of `(source_label, slr_program_factory)`
+pairs from PECOS examples, qeclib, and existing test fixtures.
+Runs each through the AST -> Guppy path via
+`SlrConverter.hugr(_force_ast=True)` (private kwarg added by
+Codex; see step4-cutover-plan.md) and captures any failures.
+
+This is NOT a pytest test file. It's an audit tool grug runs
+during Workstream B and at cutover. Output is the seed for new
+rows in `~/Repos/pecos-docs/design/slr/v1-audit-manifest.md`.
+
+Invocation:
+    cd /home/ciaranra/Repos/PECOS
+    uv run python python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
+
+For each program: emits one of
+- OK   <label>
+- FAIL <label> <ExceptionType>: <truncated message>
+
+The curated list is intentionally small at first and grows as we
+identify canonical examples worth exercising. The list is the audit
+surface; growing it is part of Workstream B.
+"""
+
+from __future__ import annotations
+
+import sys
+import traceback
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from pecos.slr import CReg, If, Main, QReg, Repeat, SlrConverter
+from pecos.slr.qeclib import qubit as qb
+from pecos.slr.qeclib.qubit.measures import Measure
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from pecos.slr import Block
+
+
+@dataclass(frozen=True)
+class AuditCase:
+    """One audit entry: a label and a factory that builds the SLR program."""
+
+    label: str
+    factory: Callable[[], Block]
+
+
+@dataclass(frozen=True)
+class AuditResult:
+    """Audit outcome for one program."""
+
+    label: str
+    passed: bool
+    exception_type: str | None = None
+    exception_message: str | None = None
+
+
+def _bell() -> Block:
+    return Main(
+        q := QReg("q", 2),
+        c := CReg("c", 2),
+        qb.H(q[0]),
+        qb.CX(q[0], q[1]),
+        Measure(q) > c,
+    )
+
+
+def _ghz_three() -> Block:
+    return Main(
+        q := QReg("q", 3),
+        c := CReg("c", 3),
+        qb.H(q[0]),
+        qb.CX(q[0], q[1]),
+        qb.CX(q[1], q[2]),
+        Measure(q) > c,
+    )
+
+
+def _conditional_correction() -> Block:
+    return Main(
+        q := QReg("q", 2),
+        c := CReg("c", 2),
+        Measure(q[0]) > c[0],
+        If(c[0]).Then(qb.X(q[1])),
+        Measure(q[1]) > c[1],
+    )
+
+
+def _repeat_idle() -> Block:
+    return Main(
+        q := QReg("q", 1),
+        Repeat(3).block(qb.H(q[0]), qb.H(q[0])),
+        Measure(q[0]),
+    )
+
+
+def _curated_cases() -> list[AuditCase]:
+    """v1 acceptance baseline; grows during Workstream B as gaps surface.
+
+    Initial list mirrors the v1 acceptance corpus. As the audit
+    runner is exercised against examples/ and qeclib, additional
+    cases are added here. Each new case is a candidate manifest row.
+    """
+    return [
+        AuditCase("v1.bell", _bell),
+        AuditCase("v1.ghz_three", _ghz_three),
+        AuditCase("v1.conditional_correction", _conditional_correction),
+        AuditCase("v1.repeat_idle", _repeat_idle),
+    ]
+
+
+def _run_case(case: AuditCase) -> AuditResult:
+    """Run one program through the AST path and capture pass/fail."""
+    try:
+        prog = case.factory()
+    except BaseException as exc:
+        return AuditResult(
+            label=case.label,
+            passed=False,
+            exception_type=type(exc).__name__,
+            exception_message=f"factory raised: {exc}",
+        )
+
+    try:
+        # _force_ast is a private kwarg that routes SlrConverter.hugr()
+        # through the AST path even before cutover. Audit-only.
+        SlrConverter(prog).hugr(_force_ast=True)
+    except TypeError as exc:
+        # _force_ast not yet plumbed -- emit a clear marker so the runner
+        # output points at the missing kwarg instead of looking like a
+        # real audit failure.
+        if "_force_ast" in str(exc):
+            return AuditResult(
+                label=case.label,
+                passed=False,
+                exception_type="MissingKwarg",
+                exception_message="SlrConverter.hugr() does not accept _force_ast yet (Codex emitter PR pending)",
+            )
+        return AuditResult(
+            label=case.label,
+            passed=False,
+            exception_type=type(exc).__name__,
+            exception_message=str(exc).splitlines()[0][:200],
+        )
+    except BaseException as exc:
+        return AuditResult(
+            label=case.label,
+            passed=False,
+            exception_type=type(exc).__name__,
+            exception_message=str(exc).splitlines()[0][:200],
+        )
+
+    return AuditResult(label=case.label, passed=True)
+
+
+def run_audit() -> list[AuditResult]:
+    """Run the full curated list and return all results."""
+    return [_run_case(case) for case in _curated_cases()]
+
+
+def main() -> int:
+    """CLI entrypoint. Returns 0 if all pass; non-zero if any fail."""
+    results = run_audit()
+    for r in results:
+        if r.passed:
+            print(f"OK   {r.label}")
+        else:
+            print(f"FAIL {r.label} {r.exception_type}: {r.exception_message}")
+
+    failures = sum(1 for r in results if not r.passed)
+    total = len(results)
+    print()
+    print(f"Audit summary: {total - failures}/{total} passed; {failures} failed")
+    return 0 if failures == 0 else 1
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main())
+    except Exception:
+        traceback.print_exc()
+        sys.exit(2)

From d730c52804e1e9747e427ba64529e571005c4b70 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Thu, 14 May 2026 17:20:03 -0600
Subject: [PATCH 017/136] Add audit-only AST HUGR route

---
 .../src/pecos/slr/slr_converter.py            | 51 ++++++++++++++++++-
 .../ast_guppy/test_force_ast_hugr.py          | 21 ++++++++
 2 files changed, 71 insertions(+), 1 deletion(-)
 create mode 100644 python/quantum-pecos/tests/slr_tests/ast_guppy/test_force_ast_hugr.py

diff --git a/python/quantum-pecos/src/pecos/slr/slr_converter.py b/python/quantum-pecos/src/pecos/slr/slr_converter.py
index 34090386d..1a021511d 100644
--- a/python/quantum-pecos/src/pecos/slr/slr_converter.py
+++ b/python/quantum-pecos/src/pecos/slr/slr_converter.py
@@ -170,7 +170,7 @@ def guppy(self) -> str:
         """
         return self._generate_guppy()
 
-    def hugr(self):
+    def hugr(self, *, _force_ast: bool = False):
         """Compile the SLR block to HUGR via Guppy.
 
         Returns:
@@ -180,6 +180,9 @@ def hugr(self):
             ImportError: If guppylang is not available
             RuntimeError: If compilation fails
         """
+        if _force_ast:
+            return self._compile_ast_guppy_to_hugr()
+
         # Generate Guppy code
         self._generate_guppy()
 
@@ -200,6 +203,52 @@ def hugr(self):
         compiler = HugrCompiler(generator)
         return compiler.compile_to_hugr()
 
+    def _compile_ast_guppy_to_hugr(self):
+        # Audit-only AST -> Guppy -> HUGR route used before cutover.
+        guppy_code = self._generate_guppy()
+
+        import importlib.util
+        import linecache
+        import sys
+        import tempfile
+        from contextlib import suppress
+        from pathlib import Path
+
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+            temp_file = Path(f.name)
+            f.write(guppy_code)
+
+        module_name = f"_ast_guppy_generated_{temp_file.stem}"
+        linecache.cache[str(temp_file)] = (
+            len(guppy_code),
+            None,
+            guppy_code.splitlines(keepends=True),
+            str(temp_file),
+        )
+
+        try:
+            spec = importlib.util.spec_from_file_location(module_name, temp_file)
+            if spec is None or spec.loader is None:
+                msg = "Failed to create module spec for AST-generated Guppy source"
+                raise RuntimeError(msg)
+
+            module = importlib.util.module_from_spec(spec)
+            module.__file__ = str(temp_file)
+            sys.modules[module_name] = module
+            spec.loader.exec_module(module)
+
+            main_func = getattr(module, "main", None)
+            if main_func is None:
+                msg = "No main function found in AST-generated Guppy source"
+                raise RuntimeError(msg)
+
+            return main_func.compile_function()
+        finally:
+            sys.modules.pop(module_name, None)
+            linecache.cache.pop(str(temp_file), None)
+            with suppress(OSError, FileNotFoundError):
+                temp_file.unlink()
+
     def stim(self) -> stim.Circuit:
         """Generate a Stim circuit from the SLR block.
 
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_force_ast_hugr.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_force_ast_hugr.py
new file mode 100644
index 000000000..c8c6cb49e
--- /dev/null
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_force_ast_hugr.py
@@ -0,0 +1,21 @@
+"""Audit-only `SlrConverter.hugr(_force_ast=True)` hook tests."""
+
+from __future__ import annotations
+
+from pecos.slr import CReg, Main, QReg, SlrConverter
+from pecos.slr.qeclib import qubit as qb
+from pecos.slr.qeclib.qubit.measures import Measure
+
+
+def test_force_ast_hugr_compiles_via_ast_guppy_path() -> None:
+    prog = Main(
+        q := QReg("q", 2),
+        c := CReg("c", 2),
+        qb.H(q[0]),
+        qb.CX(q[0], q[1]),
+        Measure(q) > c,
+    )
+
+    hugr = SlrConverter(prog).hugr(_force_ast=True)
+
+    assert hugr is not None

From 7ed21f3b69e31af1dab27af25df8906b77149dbf Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Thu, 14 May 2026 17:28:06 -0600
Subject: [PATCH 018/136] Expand audit runner with legacy HUGR test corpus (9
 cases all pass)

---
 .../tests/slr_tests/ast_guppy/audit_runner.py | 159 +++++++++++++++++-
 1 file changed, 152 insertions(+), 7 deletions(-)

diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
index c869d53b7..84515deaa 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
@@ -41,15 +41,13 @@
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
-from pecos.slr import CReg, If, Main, QReg, Repeat, SlrConverter
+from pecos.slr import Block, CReg, If, Main, QReg, Repeat, SlrConverter
 from pecos.slr.qeclib import qubit as qb
 from pecos.slr.qeclib.qubit.measures import Measure
 
 if TYPE_CHECKING:
     from collections.abc import Callable
 
-    from pecos.slr import Block
-
 
 @dataclass(frozen=True)
 class AuditCase:
@@ -108,18 +106,165 @@ def _repeat_idle() -> Block:
     )
 
 
+def _legacy_individual_measurements() -> Block:
+    """tests/slr_tests/guppy/test_hugr_compilation.py::test_individual_measurements_compile."""
+    return Main(
+        q := QReg("q", 4),
+        c := CReg("c", 4),
+        Measure(q[0]) > c[0],
+        Measure(q[1]) > c[1],
+        Measure(q[2]) > c[2],
+        Measure(q[3]) > c[3],
+    )
+
+
+def _legacy_multiple_qregs() -> Block:
+    """tests/slr_tests/guppy/test_hugr_compilation.py::test_multiple_qregs_compile."""
+    return Main(
+        q1 := QReg("q1", 2),
+        q2 := QReg("q2", 2),
+        c1 := CReg("c1", 2),
+        c2 := CReg("c2", 2),
+        qb.H(q1[0]),
+        qb.H(q2[0]),
+        qb.CX(q1[0], q2[0]),
+        Measure(q1) > c1,
+        Measure(q2) > c2,
+    )
+
+
+def _legacy_empty_main() -> Block:
+    """tests/slr_tests/guppy/test_hugr_compilation.py::test_empty_main_compiles."""
+    return Main()
+
+
+def _legacy_gates_only_no_measurement() -> Block:
+    """tests/slr_tests/guppy/test_hugr_compilation.py::test_gates_only_with_cleanup_compiles."""
+    return Main(
+        q := QReg("q", 3),
+        qb.H(q[0]),
+        qb.CX(q[0], q[1]),
+        qb.CX(q[1], q[2]),
+    )
+
+
+def _legacy_partial_consumption_with_block() -> Block:
+    """tests/slr_tests/guppy/test_hugr_compilation.py::test_partial_consumption_compiles.
+
+    Uses a `Block` subclass `MeasureAncillas` that takes data + ancilla and
+    measures the ancilla. v1 flattens nested blocks (BlockCall is v2), so
+    this is the cleanest test of "did flattening preserve linearity correctly?"
+    """
+
+    class MeasureAncillas(Block):
+        def __init__(self, data: QReg, ancilla: QReg, syndrome: CReg) -> None:
+            super().__init__()
+            self.data = data
+            self.ancilla = ancilla
+            self.syndrome = syndrome
+            self.ops = [
+                qb.CX(data[0], ancilla[0]),
+                Measure(ancilla) > syndrome,
+            ]
+
+    return Main(
+        data := QReg("data", 2),
+        ancilla := QReg("ancilla", 1),
+        syndrome := CReg("syndrome", 1),
+        result := CReg("result", 2),
+        MeasureAncillas(data, ancilla, syndrome),
+        qb.H(data[0]),
+        Measure(data) > result,
+    )
+
+
+def _legacy_function_with_returns() -> Block:
+    """tests/slr_tests/guppy/test_hugr_compilation.py::test_function_with_returns_compiles.
+
+    ProcessQubits Block uses qubits without measuring them; the outer scope
+    measures. Tests that nested-block flattening preserves "live qubits flow
+    out" semantics.
+    """
+
+    class ProcessQubits(Block):
+        def __init__(self, q: QReg) -> None:
+            super().__init__()
+            self.q = q
+            self.ops = [
+                qb.H(q[0]),
+                qb.CX(q[0], q[1]),
+            ]
+
+    return Main(
+        q := QReg("q", 2),
+        c := CReg("c", 2),
+        ProcessQubits(q),
+        Measure(q) > c,
+    )
+
+
+def _legacy_nested_blocks() -> Block:
+    """tests/slr_tests/guppy/test_hugr_compilation.py::test_nested_blocks_compile.
+
+    Two-level nesting: OuterBlock contains InnerBlock. v1 flattening must
+    preserve the InnerBlock's measurement consuming q[0] for the outer
+    sequence to remain linearity-valid.
+    """
+
+    class InnerBlock(Block):
+        def __init__(self, q: QReg, c: CReg) -> None:
+            super().__init__()
+            self.q = q
+            self.c = c
+            self.ops = [
+                Measure(q[0]) > c[0],
+            ]
+
+    class OuterBlock(Block):
+        def __init__(self, q: QReg, c: CReg) -> None:
+            super().__init__()
+            self.q = q
+            self.c = c
+            self.ops = [
+                qb.H(q[0]),
+                InnerBlock(q, c),
+                qb.H(q[1]),
+                Measure(q[1]) > c[1],
+            ]
+
+    return Main(
+        q := QReg("q", 2),
+        c := CReg("c", 2),
+        OuterBlock(q, c),
+    )
+
+
 def _curated_cases() -> list[AuditCase]:
-    """v1 acceptance baseline; grows during Workstream B as gaps surface.
+    """v1 acceptance baseline + legacy HUGR-test corpus.
+
+    The v1.* prefix is the curated acceptance baseline (mirrors
+    test_v1_acceptance.py). The legacy.* prefix is the corpus from
+    `tests/slr_tests/guppy/test_hugr_compilation.py` -- programs
+    that currently pass via the legacy IR generator. Any failure on
+    the AST path is a real gap candidate (manifest row).
 
-    Initial list mirrors the v1 acceptance corpus. As the audit
-    runner is exercised against examples/ and qeclib, additional
-    cases are added here. Each new case is a candidate manifest row.
+    As the audit progresses, additional cases come from `examples/`
+    and `qeclib/`.
     """
     return [
+        # v1 acceptance baseline (all should pass; sanity checks)
         AuditCase("v1.bell", _bell),
         AuditCase("v1.ghz_three", _ghz_three),
         AuditCase("v1.conditional_correction", _conditional_correction),
         AuditCase("v1.repeat_idle", _repeat_idle),
+        # Legacy HUGR corpus (passes on legacy IR; failures = real gaps)
+        AuditCase("legacy.individual_measurements", _legacy_individual_measurements),
+        AuditCase("legacy.multiple_qregs", _legacy_multiple_qregs),
+        AuditCase("legacy.empty_main", _legacy_empty_main),
+        AuditCase("legacy.gates_only_no_measurement", _legacy_gates_only_no_measurement),
+        AuditCase("legacy.partial_consumption_with_block", _legacy_partial_consumption_with_block),
+        AuditCase("legacy.function_with_returns", _legacy_function_with_returns),
+        AuditCase("legacy.nested_blocks", _legacy_nested_blocks),
     ]
 
 

From ac61737e075ac785563d2db0520a033e5ead3498 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Thu, 14 May 2026 17:44:21 -0600
Subject: [PATCH 019/136] Harden AST Guppy behavioral coverage

---
 .../slr_tests/ast_guppy/test_v1_behavioral.py | 71 ++++++++++++++++++-
 1 file changed, 70 insertions(+), 1 deletion(-)

diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py
index eb1ea121c..e50194f10 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py
@@ -26,7 +26,7 @@
 
 from __future__ import annotations
 
-from pecos.slr import CReg, If, Main, QReg
+from pecos.slr import CReg, If, Main, Permute, QReg
 from pecos.slr.qeclib import qubit as qb
 from pecos.slr.qeclib.qubit.measures import Measure
 
@@ -85,6 +85,48 @@ def test_measure_prep_remeasure_is_zero(self) -> None:
         assert all(r["measurement_0"] == 1 for r in records)
         assert all(r["measurement_1"] == 0 for r in records)
 
+    def test_measure_prep_x_remeasure_is_one(self) -> None:
+        """Prep after measurement produces a fresh |0> that can be inverted."""
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 2),
+            qb.X(q[0]),
+            Measure(q[0]) > c[0],
+            qb.Prep(q[0]),
+            qb.X(q[0]),
+            Measure(q[0]) > c[1],
+        )
+        records = run_ast_guppy_via_selene(prog, shots=10)
+        assert all(r["measurement_0"] == 1 for r in records)
+        assert all(r["measurement_1"] == 1 for r in records)
+
+    def test_h_z_h_then_measure_is_one(self) -> None:
+        """HZH is equivalent to X, covering deterministic Z-basis behavior."""
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            qb.H(q[0]),
+            qb.Z(q[0]),
+            qb.H(q[0]),
+            Measure(q[0]) > c[0],
+        )
+        records = run_ast_guppy_via_selene(prog, shots=10)
+        assert all(r["measurement_0"] == 1 for r in records)
+
+    def test_quantum_permute_is_observed_by_later_measurements(self) -> None:
+        """Qubit slot permutation must remap the owned local, not just typecheck."""
+        prog = Main(
+            q := QReg("q", 2),
+            c := CReg("c", 2),
+            qb.X(q[0]),
+            Permute([q[0], q[1]], [q[1], q[0]]),
+            Measure(q[0]) > c[0],
+            Measure(q[1]) > c[1],
+        )
+        records = run_ast_guppy_via_selene(prog, shots=10)
+        assert all(r["measurement_0"] == 0 for r in records)
+        assert all(r["measurement_1"] == 1 for r in records)
+
 
 # ── Bell / GHZ correlation tests ──────────────────────────────────────────
 
@@ -179,3 +221,30 @@ def test_conditional_x_flips_remapped_branch(self) -> None:
         records = run_ast_guppy_via_selene(prog_one, shots=10)
         assert all(r["measurement_0"] == 1 for r in records)
         assert all(r["measurement_1"] == 1 for r in records)
+
+    def test_creg_permute_remaps_condition_bit(self) -> None:
+        """CReg Permute must affect a later If condition."""
+        prog_without_permute = Main(
+            q := QReg("q", 1),
+            flag := CReg("flag", 2, result=False),
+            out := CReg("out", 1),
+            flag[0].set(1),
+            flag[1].set(0),
+            If(flag[1]).Then(qb.X(q[0])),
+            Measure(q[0]) > out[0],
+        )
+        records = run_ast_guppy_via_selene(prog_without_permute, shots=10)
+        assert all(r["measurement_0"] == 0 for r in records)
+
+        prog_with_permute = Main(
+            q := QReg("q", 1),
+            flag := CReg("flag", 2, result=False),
+            out := CReg("out", 1),
+            flag[0].set(1),
+            flag[1].set(0),
+            Permute([flag[0], flag[1]], [flag[1], flag[0]]),
+            If(flag[1]).Then(qb.X(q[0])),
+            Measure(q[0]) > out[0],
+        )
+        records = run_ast_guppy_via_selene(prog_with_permute, shots=10)
+        assert all(r["measurement_0"] == 1 for r in records)

From 3e7b5a14c7bda1131439b8acd39f24d671787be9 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Thu, 14 May 2026 18:49:35 -0600
Subject: [PATCH 020/136] Add examples/ corpus to audit runner (pass 2)

---
 .../tests/slr_tests/ast_guppy/audit_runner.py | 166 +++++++++++++++++-
 1 file changed, 160 insertions(+), 6 deletions(-)

diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
index 84515deaa..cdc4a24a6 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
@@ -41,7 +41,9 @@
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
-from pecos.slr import Block, CReg, If, Main, QReg, Repeat, SlrConverter
+from pecos.qec.surface import SurfacePatch
+from pecos.qec.surface.schedule import compute_cnot_schedule
+from pecos.slr import Barrier, Block, CReg, If, Main, Parallel, QReg, Repeat, SlrConverter
 from pecos.slr.qeclib import qubit as qb
 from pecos.slr.qeclib.qubit.measures import Measure
 
@@ -239,17 +241,164 @@ def __init__(self, q: QReg, c: CReg) -> None:
     )
 
 
+def _examples_surface_d3_z_1round() -> Block:
+    """Surface-code memory experiment from
+    examples/surface_code_slr_exploration.ipynb::build_surface_code_slr.
+
+    distance=3, num_rounds=1, basis="Z". Pure-v1 gate surface
+    (Prep, H, CX, Measure, Barrier) over multi-QReg. Real-shaped
+    program: 9 data + 4 X-anc + 4 Z-anc, 4 CNOT rounds.
+    """
+    patch = SurfacePatch.create(distance=3)
+    geom = patch.geometry
+    cnot_rounds = compute_cnot_schedule(patch)
+    num_x = len(geom.x_stabilizers)
+    num_z = len(geom.z_stabilizers)
+
+    data = QReg("data", geom.num_data)
+    x_anc = QReg("ax", num_x)
+    z_anc = QReg("az", num_z)
+
+    ops: list = []
+    ops.extend(qb.Prep(data[i]) for i in range(geom.num_data))
+    ops.append(Barrier())
+
+    ops.extend(qb.Prep(x_anc[i]) for i in range(num_x))
+    ops.extend(qb.Prep(z_anc[i]) for i in range(num_z))
+    ops.append(Barrier())
+
+    ops.extend(qb.H(x_anc[i]) for i in range(num_x))
+    ops.append(Barrier())
+
+    for cx_round in cnot_rounds:
+        for stab_type, stab_idx, data_q in cx_round:
+            if stab_type == "X":
+                ops.append(qb.CX(x_anc[stab_idx], data[data_q]))
+            else:
+                ops.append(qb.CX(data[data_q], z_anc[stab_idx]))
+        ops.append(Barrier())
+
+    ops.extend(qb.H(x_anc[i]) for i in range(num_x))
+    ops.append(Barrier())
+
+    ops.extend(Measure(x_anc[i]) for i in range(num_x))
+    ops.extend(Measure(z_anc[i]) for i in range(num_z))
+    ops.append(Barrier())
+
+    ops.extend(Measure(data[i]) for i in range(geom.num_data))
+
+    return Main(data, x_anc, z_anc, *ops)
+
+
+def _examples_surface_d3_x_1round() -> Block:
+    """X-basis variant of the surface-code memory experiment.
+
+    Same as Z variant plus H wrapping on data qubits at the start and
+    before final measurement. Tiny diff but covers the X-basis path
+    distinctly in case wrap-around H scheduling surfaces anything.
+    """
+    patch = SurfacePatch.create(distance=3)
+    geom = patch.geometry
+    cnot_rounds = compute_cnot_schedule(patch)
+    num_x = len(geom.x_stabilizers)
+    num_z = len(geom.z_stabilizers)
+
+    data = QReg("data", geom.num_data)
+    x_anc = QReg("ax", num_x)
+    z_anc = QReg("az", num_z)
+
+    ops: list = []
+    ops.extend(qb.Prep(data[i]) for i in range(geom.num_data))
+    ops.extend(qb.H(data[i]) for i in range(geom.num_data))
+    ops.append(Barrier())
+
+    ops.extend(qb.Prep(x_anc[i]) for i in range(num_x))
+    ops.extend(qb.Prep(z_anc[i]) for i in range(num_z))
+    ops.append(Barrier())
+
+    ops.extend(qb.H(x_anc[i]) for i in range(num_x))
+    ops.append(Barrier())
+
+    for cx_round in cnot_rounds:
+        for stab_type, stab_idx, data_q in cx_round:
+            if stab_type == "X":
+                ops.append(qb.CX(x_anc[stab_idx], data[data_q]))
+            else:
+                ops.append(qb.CX(data[data_q], z_anc[stab_idx]))
+        ops.append(Barrier())
+
+    ops.extend(qb.H(x_anc[i]) for i in range(num_x))
+    ops.append(Barrier())
+
+    ops.extend(Measure(x_anc[i]) for i in range(num_x))
+    ops.extend(Measure(z_anc[i]) for i in range(num_z))
+    ops.append(Barrier())
+
+    ops.extend(qb.H(data[i]) for i in range(geom.num_data))
+    ops.append(Barrier())
+    ops.extend(Measure(data[i]) for i in range(geom.num_data))
+
+    return Main(data, x_anc, z_anc, *ops)
+
+
+def _examples_parallel_bell_pairs() -> Block:
+    """Parallel/Block bell pairs lifted from
+    examples/Dusting off color code code.ipynb.
+
+    Tests v1 emitter handling of Parallel + nested Block constructs
+    over a 6-qubit register with register-broadcast measurement.
+    """
+    return Main(
+        q := QReg("q", 6),
+        c := CReg("m", 6),
+        Parallel(
+            Block(
+                qb.H(q[0]),
+                qb.CX(q[0], q[1]),
+            ),
+            Block(
+                qb.H(q[2]),
+                qb.CX(q[2], q[3]),
+            ),
+            Block(
+                qb.H(q[4]),
+                qb.CX(q[4], q[5]),
+            ),
+        ),
+        Measure(q) > c,
+    )
+
+
+def _examples_measure_register_to_creg() -> Block:
+    """Register-broadcast measure-to-creg at 4q scale.
+
+    Distinct from v1.bell (2q->2c) in size; same shape. Confirms v1
+    emitter handles per-element fanout from QReg to CReg at >2-bit
+    width without relying on Parallel/Block scaffolding.
+    """
+    return Main(
+        q := QReg("q", 4),
+        c := CReg("c", 4),
+        qb.H(q[0]),
+        qb.CX(q[0], q[1]),
+        qb.H(q[2]),
+        qb.CX(q[2], q[3]),
+        Measure(q) > c,
+    )
+
+
 def _curated_cases() -> list[AuditCase]:
-    """v1 acceptance baseline + legacy HUGR-test corpus.
+    """v1 acceptance baseline + legacy HUGR-test corpus + examples/.
 
     The v1.* prefix is the curated acceptance baseline (mirrors
     test_v1_acceptance.py). The legacy.* prefix is the corpus from
     `tests/slr_tests/guppy/test_hugr_compilation.py` -- programs
-    that currently pass via the legacy IR generator. Any failure on
-    the AST path is a real gap candidate (manifest row).
+    that currently pass via the legacy IR generator. The examples.*
+    prefix is curated SLR programs lifted from
+    `/home/ciaranra/Repos/PECOS/examples/`. Any failure on the AST
+    path is a real gap candidate (manifest row).
 
-    As the audit progresses, additional cases come from `examples/`
-    and `qeclib/`.
+    As the audit progresses, additional cases come from `qeclib/`.
     """
     return [
         # v1 acceptance baseline (all should pass; sanity checks)
@@ -265,6 +414,11 @@ def _curated_cases() -> list[AuditCase]:
         AuditCase("legacy.partial_consumption_with_block", _legacy_partial_consumption_with_block),
         AuditCase("legacy.function_with_returns", _legacy_function_with_returns),
         AuditCase("legacy.nested_blocks", _legacy_nested_blocks),
+        # examples/ corpus (pass 2)
+        AuditCase("examples.surface_d3_z_1round", _examples_surface_d3_z_1round),
+        AuditCase("examples.surface_d3_x_1round", _examples_surface_d3_x_1round),
+        AuditCase("examples.parallel_bell_pairs", _examples_parallel_bell_pairs),
+        AuditCase("examples.measure_register_to_creg", _examples_measure_register_to_creg),
     ]
 
 

From 21b80b678e10bc29fa506905689298b782793ce5 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Thu, 14 May 2026 18:49:49 -0600
Subject: [PATCH 021/136] Add qeclib corpus + ExpectedFailure XFAIL mechanism
 to audit runner (pass 3)

---
 .../tests/slr_tests/ast_guppy/audit_runner.py | 202 +++++++++++++++++-
 1 file changed, 196 insertions(+), 6 deletions(-)

diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
index cdc4a24a6..880d3da89 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
@@ -45,7 +45,18 @@
 from pecos.qec.surface.schedule import compute_cnot_schedule
 from pecos.slr import Barrier, Block, CReg, If, Main, Parallel, QReg, Repeat, SlrConverter
 from pecos.slr.qeclib import qubit as qb
+from pecos.slr.qeclib.color488 import Color488Patch
+from pecos.slr.qeclib.generic.check import Check
+from pecos.slr.qeclib.generic.check_1flag import Check1Flag
+from pecos.slr.qeclib.generic.transversal import transversal_tq
 from pecos.slr.qeclib.qubit.measures import Measure
+from pecos.slr.qeclib.steane.steane_class import Steane
+from pecos.slr.qeclib.surface import (
+    LatticeType,
+    SurfacePatchBuilder,
+    SurfacePatchOrientation,
+    SurfaceStdGates,
+)
 
 if TYPE_CHECKING:
     from collections.abc import Callable
@@ -57,6 +68,17 @@ class AuditCase:
 
     label: str
     factory: Callable[[], Block]
+    expected_failure: ExpectedFailure | None = None
+
+
+@dataclass(frozen=True)
+class ExpectedFailure:
+    """One accepted red-light audit outcome."""
+
+    exception_type: str
+    message_contains: str
+    classification: str
+    reason: str
 
 
 @dataclass(frozen=True)
@@ -65,6 +87,8 @@ class AuditResult:
 
     label: str
     passed: bool
+    expected: bool = False
+    classification: str | None = None
     exception_type: str | None = None
     exception_message: str | None = None
 
@@ -387,18 +411,101 @@ def _examples_measure_register_to_creg() -> Block:
     )
 
 
+def _qeclib_generic_check_xyz() -> Block:
+    """Generic Check over X/Y/Z Paulis with barriers."""
+    return Main(
+        q := QReg("q", 4),
+        c := CReg("c", 1),
+        Check([q[0], q[1], q[2]], "XYZ", q[3], c[0], with_barriers=True),
+    )
+
+
+def _qeclib_generic_check_1flag_ch() -> Block:
+    """Flagged generic Check using the CH branch in Check1Flag."""
+    return Main(
+        q := QReg("q", 5),
+        c := CReg("c", 2),
+        Check1Flag([q[0], q[1], q[2]], "XYZ", q[3], q[4], c[0], c[1], with_barriers=True),
+    )
+
+
+def _qeclib_generic_transversal_cx() -> Block:
+    """Generic transversal CX helper across two registers."""
+    return Main(
+        a := QReg("a", 3),
+        b := QReg("b", 3),
+        c := CReg("c", 6),
+        transversal_tq(qb.CX, a, b),
+        Measure(a) > c[0:3],
+        Measure(b) > c[3:6],
+    )
+
+
+def _qeclib_surface_patch_builder_empty() -> Block:
+    """SLR qeclib SurfacePatchBuilder construct from examples/Surface SLR.ipynb.
+
+    The current surface gate methods are mostly TODOs, so this green
+    case only verifies that a built RotatedSurfacePatch contributes its
+    underlying QReg cleanly to AST -> Guppy -> HUGR.
+    """
+    return Main(
+        SurfacePatchBuilder()
+        .set_name("s")
+        .with_distances(3, 5)
+        .with_lattice(LatticeType.SQUARE)
+        .with_orientation(SurfacePatchOrientation.Z_TOP_BOTTOM)
+        .build(),
+    )
+
+
+def _qeclib_steane_pz_v2_defer() -> Block:
+    """Deliberate red-light: Steane pz() is v2 per stage3-synthesis Q B."""
+    return Main(
+        c := Steane("c"),
+        c.pz(),
+    )
+
+
+def _qeclib_surface_std_pz_preexisting() -> Block:
+    """Deliberate red-light: surface std pz() currently fails during construction."""
+    patch = (
+        SurfacePatchBuilder()
+        .set_name("s")
+        .with_distances(3, 5)
+        .with_lattice(LatticeType.SQUARE)
+        .with_orientation(SurfacePatchOrientation.Z_TOP_BOTTOM)
+        .build()
+    )
+    return Main(
+        patch,
+        *SurfaceStdGates.pz(patch),
+    )
+
+
+def _qeclib_color488_syn_extract_bare_preexisting() -> Block:
+    """Deliberate red-light: color488 bare extraction currently fails during construction."""
+    patch = Color488Patch("c", 5, num_ancillas=4)
+    return Main(
+        patch,
+        syn := CReg("syn", patch.num_data - 1),
+        patch.syn_extract_bare(syn),
+    )
+
+
 def _curated_cases() -> list[AuditCase]:
-    """v1 acceptance baseline + legacy HUGR-test corpus + examples/.
+    """v1 acceptance baseline + legacy HUGR-test corpus + examples/ + qeclib.
 
     The v1.* prefix is the curated acceptance baseline (mirrors
     test_v1_acceptance.py). The legacy.* prefix is the corpus from
     `tests/slr_tests/guppy/test_hugr_compilation.py` -- programs
     that currently pass via the legacy IR generator. The examples.*
     prefix is curated SLR programs lifted from
-    `/home/ciaranra/Repos/PECOS/examples/`. Any failure on the AST
-    path is a real gap candidate (manifest row).
+    `/home/ciaranra/Repos/PECOS/examples/`. The qeclib.* prefix
+    audits programmatic qeclib constructs. Any unexpected failure on
+    the AST path is a real gap candidate (manifest row). Accepted
+    red-light cases are explicit XFAIL rows with classifications.
 
-    As the audit progresses, additional cases come from `qeclib/`.
+    As the audit progresses, additional cases come from docs.
     """
     return [
         # v1 acceptance baseline (all should pass; sanity checks)
@@ -419,14 +526,80 @@ def _curated_cases() -> list[AuditCase]:
         AuditCase("examples.surface_d3_x_1round", _examples_surface_d3_x_1round),
         AuditCase("examples.parallel_bell_pairs", _examples_parallel_bell_pairs),
         AuditCase("examples.measure_register_to_creg", _examples_measure_register_to_creg),
+        # qeclib/ corpus (pass 3)
+        AuditCase("qeclib.generic_check_xyz", _qeclib_generic_check_xyz),
+        AuditCase("qeclib.generic_check_1flag_ch", _qeclib_generic_check_1flag_ch),
+        AuditCase("qeclib.generic_transversal_cx", _qeclib_generic_transversal_cx),
+        AuditCase("qeclib.surface_patch_builder_empty", _qeclib_surface_patch_builder_empty),
+        AuditCase(
+            "qeclib.steane_pz",
+            _qeclib_steane_pz_v2_defer,
+            expected_failure=ExpectedFailure(
+                exception_type="GuppyCodegenError",
+                message_contains="supports only one final root-level Return",
+                classification="v2-defer",
+                reason="Steane pz() requires nested Return / BlockCall semantics",
+            ),
+        ),
+        AuditCase(
+            "qeclib.surface_std_pz",
+            _qeclib_surface_std_pz_preexisting,
+            expected_failure=ExpectedFailure(
+                exception_type="TypeError",
+                message_contains="PrepZ.__init__()",
+                classification="pre-existing",
+                reason="SurfaceStdGates.pz() fails while building the SLR program",
+            ),
+        ),
+        AuditCase(
+            "qeclib.color488_syn_extract_bare",
+            _qeclib_color488_syn_extract_bare_preexisting,
+            expected_failure=ExpectedFailure(
+                exception_type="TypeError",
+                message_contains="'float' object cannot be interpreted as an integer",
+                classification="pre-existing",
+                reason="Color488 bare extraction fails while building the SLR program",
+            ),
+        ),
     ]
 
 
+def _expected_result(case: AuditCase, exc: BaseException) -> AuditResult | None:
+    expected = case.expected_failure
+    if expected is None:
+        return None
+
+    exception_type = type(exc).__name__
+    exception_message = str(exc).splitlines()[0][:200]
+    if exception_type == expected.exception_type and expected.message_contains in str(exc):
+        return AuditResult(
+            label=case.label,
+            passed=True,
+            expected=True,
+            classification=expected.classification,
+            exception_type=exception_type,
+            exception_message=exception_message,
+        )
+
+    return AuditResult(
+        label=case.label,
+        passed=False,
+        exception_type="UnexpectedFailure",
+        exception_message=(
+            f"expected {expected.exception_type} containing {expected.message_contains!r}; "
+            f"got {exception_type}: {exception_message}"
+        ),
+    )
+
+
 def _run_case(case: AuditCase) -> AuditResult:
     """Run one program through the AST path and capture pass/fail."""
     try:
         prog = case.factory()
     except BaseException as exc:
+        expected = _expected_result(case, exc)
+        if expected is not None:
+            return expected
         return AuditResult(
             label=case.label,
             passed=False,
@@ -439,6 +612,9 @@ def _run_case(case: AuditCase) -> AuditResult:
         # through the AST path even before cutover. Audit-only.
         SlrConverter(prog).hugr(_force_ast=True)
     except TypeError as exc:
+        expected = _expected_result(case, exc)
+        if expected is not None:
+            return expected
         # _force_ast not yet plumbed -- emit a clear marker so the runner
         # output points at the missing kwarg instead of looking like a
         # real audit failure.
@@ -456,6 +632,9 @@ def _run_case(case: AuditCase) -> AuditResult:
             exception_message=str(exc).splitlines()[0][:200],
         )
     except BaseException as exc:
+        expected = _expected_result(case, exc)
+        if expected is not None:
+            return expected
         return AuditResult(
             label=case.label,
             passed=False,
@@ -463,6 +642,14 @@ def _run_case(case: AuditCase) -> AuditResult:
             exception_message=str(exc).splitlines()[0][:200],
         )
 
+    if case.expected_failure is not None:
+        return AuditResult(
+            label=case.label,
+            passed=False,
+            exception_type="UnexpectedPass",
+            exception_message=f"expected {case.expected_failure.classification} failure, but AST path compiled",
+        )
+
     return AuditResult(label=case.label, passed=True)
 
 
@@ -475,15 +662,18 @@ def main() -> int:
     """CLI entrypoint. Returns 0 if all pass; non-zero if any fail."""
     results = run_audit()
     for r in results:
-        if r.passed:
+        if r.expected:
+            print(f"XFAIL {r.label} {r.classification}: {r.exception_type}: {r.exception_message}")
+        elif r.passed:
             print(f"OK   {r.label}")
         else:
             print(f"FAIL {r.label} {r.exception_type}: {r.exception_message}")
 
     failures = sum(1 for r in results if not r.passed)
+    expected = sum(1 for r in results if r.expected)
     total = len(results)
     print()
-    print(f"Audit summary: {total - failures}/{total} passed; {failures} failed")
+    print(f"Audit summary: {total - failures}/{total} accepted; {expected} expected failures; {failures} failed")
     return 0 if failures == 0 else 1
 
 

From 6a340bd312236c5fb5f81f06e861dff310c8a4d8 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Thu, 14 May 2026 19:11:04 -0600
Subject: [PATCH 022/136] Harden Guppy v1 preflight + inline-CReg inference;
 lock down pass 4 audit (4 green, 5 XFAIL)

---
 .../src/pecos/slr/ast/codegen/guppy.py        |  99 ++++++++
 .../src/pecos/slr/slr_converter.py            |   4 +-
 .../tests/slr_tests/ast_guppy/audit_runner.py | 220 +++++++++++++++++-
 .../ast_guppy/test_force_ast_hugr.py          |  50 +++-
 4 files changed, 370 insertions(+), 3 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
index 143a66f6e..a28bf4dab 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
@@ -55,6 +55,8 @@
 )
 
 if TYPE_CHECKING:
+    from collections.abc import Iterator
+
     from pecos.slr.ast.nodes import (
         AssignOp,
         BarrierOp,
@@ -153,6 +155,7 @@ def generate(self, program: Program) -> list[str]:
         """Generate Guppy code for a program."""
         self.context = GuppyContext()
         self._collect_declarations(program)
+        self._collect_implicit_measure_registers(program.body)
         self.context.linearity = GuppyLinearityState.from_allocators(self.context.root_allocators)
         self._reject_child_allocators()
 
@@ -205,6 +208,39 @@ def _add_allocator_decl(self, decl: AllocatorDecl) -> None:
             return
         self.context.root_allocators.setdefault(decl.name, decl.capacity)
 
+    def _collect_implicit_measure_registers(self, body: tuple[Statement, ...]) -> None:
+        """Add result registers introduced only as measurement outputs."""
+        max_indices: dict[str, int] = {}
+        for stmt in body:
+            self._collect_implicit_measure_register_refs(stmt, max_indices)
+
+        for register, max_index in max_indices.items():
+            if register not in self.context.registers:
+                self.context.registers[register] = RegisterDecl(name=register, size=max_index + 1, is_result=True)
+
+    def _collect_implicit_measure_register_refs(self, stmt: Statement, max_indices: dict[str, int]) -> None:
+        if isinstance(stmt, MeasureOp):
+            for ref in stmt.results:
+                if ref.register not in self.context.registers:
+                    max_indices[ref.register] = max(max_indices.get(ref.register, -1), ref.index)
+            return
+
+        if isinstance(stmt, IfStmt):
+            self._collect_implicit_measure_registers_in_body(stmt.then_body, max_indices)
+            self._collect_implicit_measure_registers_in_body(stmt.else_body, max_indices)
+            return
+
+        if isinstance(stmt, RepeatStmt | ForStmt | WhileStmt | ParallelBlock):
+            self._collect_implicit_measure_registers_in_body(stmt.body, max_indices)
+
+    def _collect_implicit_measure_registers_in_body(
+        self,
+        body: tuple[Statement, ...],
+        max_indices: dict[str, int],
+    ) -> None:
+        for stmt in body:
+            self._collect_implicit_measure_register_refs(stmt, max_indices)
+
     def _reject_child_allocators(self) -> None:
         if self.context.child_allocators:
             names = ", ".join(sorted(self.context.child_allocators))
@@ -725,3 +761,66 @@ def ast_to_guppy(program: Program) -> str:
     """Convert an AST Program to Guppy Python code."""
     generator = AstToGuppy()
     return "\n".join(generator.generate(program))
+
+
+def validate_slr_for_guppy_v1(block: object | None) -> None:
+    """Reject SLR constructs that the v1 AST -> Guppy path cannot represent soundly."""
+    if block is None:
+        return
+    _validate_slr_node_for_guppy_v1(block)
+
+
+def _validate_slr_node_for_guppy_v1(node: object) -> None:
+    node_type = type(node).__name__
+    if node_type == "While":
+        msg = "AST -> Guppy v1 does not support While loops"
+        raise GuppyCodegenError(msg)
+
+    if getattr(node, "is_qgate", False):
+        _validate_slr_gate_for_guppy_v1(node)
+
+    for child in getattr(node, "ops", ()) or ():
+        _validate_slr_node_for_guppy_v1(child)
+
+    else_block = getattr(node, "else_block", None)
+    if else_block is not None:
+        _validate_slr_node_for_guppy_v1(else_block)
+
+
+def _validate_slr_gate_for_guppy_v1(gate: object) -> None:
+    qargs = getattr(gate, "qargs", ()) or ()
+    cout = getattr(gate, "cout", ()) or ()
+
+    if _contains_symbolic_index(qargs) or _contains_symbolic_index(cout):
+        msg = "AST -> Guppy v1 does not support symbolic LoopVar indexing"
+        raise GuppyCodegenError(msg)
+
+    if getattr(gate, "sym", None) != "Prep":
+        return
+
+    for basis in _string_args(qargs):
+        if basis.strip().upper() not in {"Z", "+Z"}:
+            msg = "AST -> Guppy v1 supports only Z-basis Prep; use Prep(q); H(q) for X-basis prep"
+            raise GuppyCodegenError(msg)
+
+
+def _contains_symbolic_index(value: object) -> bool:
+    for item in _nested_items(value):
+        if hasattr(item, "index_var") or type(item).__name__.startswith("Symbolic"):
+            return True
+    return False
+
+
+def _string_args(value: object) -> list[str]:
+    return [item for item in _nested_items(value) if isinstance(item, str)]
+
+
+def _nested_items(value: object) -> Iterator[object]:
+    if isinstance(value, str):
+        yield value
+        return
+    if isinstance(value, list | tuple):
+        for item in value:
+            yield from _nested_items(item)
+        return
+    yield value
diff --git a/python/quantum-pecos/src/pecos/slr/slr_converter.py b/python/quantum-pecos/src/pecos/slr/slr_converter.py
index 1a021511d..cacf80ff3 100644
--- a/python/quantum-pecos/src/pecos/slr/slr_converter.py
+++ b/python/quantum-pecos/src/pecos/slr/slr_converter.py
@@ -43,6 +43,7 @@ def __init__(self, block: Main | None = None, *, optimize_parallel: bool = True)
             optimize_parallel: Whether to apply ParallelOptimizer transformation (default: True).
                              Only affects blocks containing Parallel() statements.
         """
+        self._original_block = block
         self._block = block
         self._optimize_parallel = optimize_parallel
 
@@ -106,8 +107,9 @@ def _generate_qasm(self, *, include_header: bool = True) -> str:
 
     def _generate_guppy(self) -> str:
         """Generate Guppy code using AST-based codegen."""
-        from pecos.slr.ast.codegen.guppy import ast_to_guppy
+        from pecos.slr.ast.codegen.guppy import ast_to_guppy, validate_slr_for_guppy_v1
 
+        validate_slr_for_guppy_v1(self._original_block)
         ast = self._to_ast()
         return ast_to_guppy(ast)
 
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
index 880d3da89..cb775f2de 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
@@ -43,7 +43,20 @@
 
 from pecos.qec.surface import SurfacePatch
 from pecos.qec.surface.schedule import compute_cnot_schedule
-from pecos.slr import Barrier, Block, CReg, If, Main, Parallel, QReg, Repeat, SlrConverter
+from pecos.slr import (
+    Barrier,
+    Block,
+    CReg,
+    For,
+    If,
+    LoopVar,
+    Main,
+    Parallel,
+    QReg,
+    Repeat,
+    SlrConverter,
+    While,
+)
 from pecos.slr.qeclib import qubit as qb
 from pecos.slr.qeclib.color488 import Color488Patch
 from pecos.slr.qeclib.generic.check import Check
@@ -492,6 +505,156 @@ def _qeclib_color488_syn_extract_bare_preexisting() -> Block:
     )
 
 
+def _docs_for_static_indexing() -> Block:
+    """v1-shaped For loop: string iteration variable, integer bounds, fixed-slot body.
+
+    From `test_unified_resource_planner.py` shape per v1-feature-matrix:
+    v1 supports For("i", 0, 3) over fixed slots, no symbolic indexing.
+    """
+    return Main(
+        q := QReg("q", 3),
+        c := CReg("c", 3),
+        For("i", 0, 3).Do(
+            qb.H(q[0]),
+        ),
+        Measure(q) > c,
+    )
+
+
+def _docs_flat_parallel_h_gates() -> Block:
+    """Parallel of flat gates (no Block scaffolding), from
+    docs/development/slr-qeclib.md::test_slr_qeclib_block_4."""
+    return Main(
+        q := QReg("q", 4),
+        c := CReg("c", 4),
+        Parallel(
+            qb.H(q[0]),
+            qb.H(q[1]),
+            qb.H(q[2]),
+            qb.H(q[3]),
+        ),
+        Measure(q) > c,
+    )
+
+
+def _docs_repeat_state_preserving() -> Block:
+    """Repeat block lifted from docs/development/slr-qeclib.md::test_slr_qeclib_block_6.
+
+    Single-H body iterates 3 times. Slot stays live across iterations.
+    """
+    return Main(
+        q := QReg("q", 1),
+        c := CReg("c", 1),
+        Repeat(3).block(
+            qb.H(q[0]),
+        ),
+        Measure(q) > c,
+    )
+
+
+def _docs_while_loop_v2_defer() -> Block:
+    """Deliberate red-light: While loop is v2-defer per v1-feature-matrix.
+
+    Body consumes-and-replaces the qubit slot inside an unbounded loop;
+    "Fixed-point linear state through unknown iteration count is too large
+    for first sound emitter."
+    """
+    return Main(
+        q := QReg("q", 1),
+        c := CReg("c", 1),
+        While(c[0] == 0).Do(
+            qb.H(q[0]),
+            Measure(q[0]) > c[0],
+        ),
+    )
+
+
+def _docs_for_loopvar_symbolic_v2_defer() -> Block:
+    """Deliberate red-light: For with LoopVar + symbolic q[i] is v2-defer.
+
+    Per v1-feature-matrix: "Current AST converter cannot represent symbolic
+    SlotRef.index; supporting it would touch shared conversion semantics."
+    """
+    i = LoopVar("i")
+    return Main(
+        q := QReg("q", 4),
+        c := CReg("c", 4),
+        For(i, range(4)).Do(
+            qb.H(q[i]),
+        ),
+        Measure(q) > c,
+    )
+
+
+def _docs_prep_basis_x_v2_defer() -> Block:
+    """Deliberate red-light: Prep with explicit "X" basis is v2-defer.
+
+    Per v1-feature-matrix: "Current Prep gate is reset-to-zero in the AST.
+    V1 supports Z reset only. Use Prep(q); H(q) for X-basis prep."
+    """
+    return Main(
+        q := QReg("q", 1),
+        c := CReg("c", 1),
+        qb.Prep(q[0], "X"),
+        Measure(q) > c,
+    )
+
+
+def _docs_rotation_rx_probe() -> Block:
+    """Probe: RX rotation gate from docs/development/slr-qeclib.md.
+
+    Per v1-feature-matrix: rotations need design; doc-test form
+    `RX(q[0], 0.5)` "currently looks like extra qargs." Probe to record.
+    """
+    return Main(
+        q := QReg("q", 1),
+        c := CReg("c", 1),
+        qb.RX(q[0], 0.5),
+        Measure(q) > c,
+    )
+
+
+def _docs_inline_measure_creg() -> Block:
+    """Inline measurement result CReg without a root declaration."""
+    return Main(
+        q := QReg("q", 2),
+        Measure(q) > CReg("final", 2),
+    )
+
+
+def _docs_surface_syndrome_block18_probe() -> Block:
+    """Probe: surface_code_syndrome doc-test shape from test_slr_qeclib_block_18.
+
+    Uses basis-arg Prep("Z") and Prep("X") plus Block-grouped operations.
+    Likely XFAIL on the Prep basis arg (v2-defer); probe to record exact
+    failure or surface a real gap.
+    """
+    d = 2
+    num_data = d * d
+    num_ancilla = 2
+    return Main(
+        data := QReg("data", num_data),
+        ancilla := QReg("anc", num_ancilla),
+        syn := CReg("syn", num_ancilla),
+        Block(*[qb.Prep(data[i], "Z") for i in range(num_data)]),
+        Block(
+            qb.Prep(ancilla[0], "X"),
+            qb.H(ancilla[0]),
+            qb.CX(ancilla[0], data[0]),
+            qb.CX(ancilla[0], data[1]),
+            qb.H(ancilla[0]),
+            Measure(ancilla[0]) > syn[0],
+        ),
+        Block(
+            qb.Prep(ancilla[1], "Z"),
+            qb.CX(data[0], ancilla[1]),
+            qb.CX(data[3], ancilla[1]),
+            Measure(ancilla[1]) > syn[1],
+        ),
+        Measure(data) > CReg("final", num_data),
+    )
+
+
 def _curated_cases() -> list[AuditCase]:
     """v1 acceptance baseline + legacy HUGR-test corpus + examples/ + qeclib.
 
@@ -561,6 +724,61 @@ def _curated_cases() -> list[AuditCase]:
                 reason="Color488 bare extraction fails while building the SLR program",
             ),
         ),
+        # docs/ corpus (pass 4)
+        AuditCase("docs.for_static_indexing", _docs_for_static_indexing),
+        AuditCase("docs.flat_parallel_h_gates", _docs_flat_parallel_h_gates),
+        AuditCase("docs.repeat_state_preserving", _docs_repeat_state_preserving),
+        AuditCase("docs.inline_measure_creg", _docs_inline_measure_creg),
+        AuditCase(
+            "docs.while_loop",
+            _docs_while_loop_v2_defer,
+            expected_failure=ExpectedFailure(
+                exception_type="GuppyCodegenError",
+                message_contains="does not support While loops",
+                classification="v2-defer",
+                reason="While loop linearity fixed-points are outside v1 scope",
+            ),
+        ),
+        AuditCase(
+            "docs.for_loopvar_symbolic",
+            _docs_for_loopvar_symbolic_v2_defer,
+            expected_failure=ExpectedFailure(
+                exception_type="GuppyCodegenError",
+                message_contains="symbolic LoopVar indexing",
+                classification="v2-defer",
+                reason="Symbolic SlotRef indices require shared AST/converter design",
+            ),
+        ),
+        AuditCase(
+            "docs.prep_basis_x",
+            _docs_prep_basis_x_v2_defer,
+            expected_failure=ExpectedFailure(
+                exception_type="GuppyCodegenError",
+                message_contains="supports only Z-basis Prep",
+                classification="v2-defer",
+                reason="Non-Z Prep basis semantics are not represented in the v1 AST",
+            ),
+        ),
+        AuditCase(
+            "docs.rotation_rx",
+            _docs_rotation_rx_probe,
+            expected_failure=ExpectedFailure(
+                exception_type="GuppyCodegenError",
+                message_contains="does not support parameterized gate RX",
+                classification="v2-defer",
+                reason="Parameterized rotations need design beyond v1 fixed Clifford emission",
+            ),
+        ),
+        AuditCase(
+            "docs.surface_syndrome_block18",
+            _docs_surface_syndrome_block18_probe,
+            expected_failure=ExpectedFailure(
+                exception_type="GuppyCodegenError",
+                message_contains="supports only Z-basis Prep",
+                classification="v2-defer",
+                reason="Doc-test includes Prep('X'); inline result CReg shape is covered separately",
+            ),
+        ),
     ]
 
 
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_force_ast_hugr.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_force_ast_hugr.py
index c8c6cb49e..610493545 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_force_ast_hugr.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_force_ast_hugr.py
@@ -2,7 +2,9 @@
 
 from __future__ import annotations
 
-from pecos.slr import CReg, Main, QReg, SlrConverter
+import pytest
+from pecos.slr import CReg, For, LoopVar, Main, QReg, SlrConverter, While
+from pecos.slr.ast.codegen.guppy import GuppyCodegenError
 from pecos.slr.qeclib import qubit as qb
 from pecos.slr.qeclib.qubit.measures import Measure
 
@@ -19,3 +21,49 @@ def test_force_ast_hugr_compiles_via_ast_guppy_path() -> None:
     hugr = SlrConverter(prog).hugr(_force_ast=True)
 
     assert hugr is not None
+
+
+def test_force_ast_rejects_while_before_parallel_optimizer_erases_it() -> None:
+    prog = Main(
+        q := QReg("q", 1),
+        c := CReg("c", 1),
+        While(c[0] == 0).Do(
+            qb.H(q[0]),
+            Measure(q[0]) > c[0],
+        ),
+    )
+
+    with pytest.raises(GuppyCodegenError, match="does not support While loops"):
+        SlrConverter(prog).hugr(_force_ast=True)
+
+
+def test_force_ast_rejects_non_z_prep_basis_before_ast_drops_it() -> None:
+    prog = Main(
+        q := QReg("q", 1),
+        qb.Prep(q[0], "X"),
+    )
+
+    with pytest.raises(GuppyCodegenError, match="supports only Z-basis Prep"):
+        SlrConverter(prog).hugr(_force_ast=True)
+
+
+def test_force_ast_rejects_symbolic_loopvar_indexing_cleanly() -> None:
+    i = LoopVar("i")
+    prog = Main(
+        q := QReg("q", 4),
+        For(i, range(4)).Do(qb.H(q[i])),
+    )
+
+    with pytest.raises(GuppyCodegenError, match="symbolic LoopVar indexing"):
+        SlrConverter(prog).hugr(_force_ast=True)
+
+
+def test_force_ast_accepts_inline_measure_creg_result() -> None:
+    prog = Main(
+        q := QReg("q", 2),
+        Measure(q) > CReg("final", 2),
+    )
+
+    hugr = SlrConverter(prog).hugr(_force_ast=True)
+
+    assert hugr is not None

From 48ce554d4ba99ecf1048dec589b5757b8ce1774d Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Thu, 14 May 2026 19:17:47 -0600
Subject: [PATCH 023/136] Cutover: route SlrConverter.hugr() through AST by
 default; remove _force_ast kwarg

---
 .../src/pecos/slr/slr_converter.py            | 28 ++----------------
 .../tests/slr_tests/ast_guppy/audit_runner.py | 29 ++-----------------
 ...est_force_ast_hugr.py => test_ast_hugr.py} | 22 +++++++-------
 3 files changed, 17 insertions(+), 62 deletions(-)
 rename python/quantum-pecos/tests/slr_tests/ast_guppy/{test_force_ast_hugr.py => test_ast_hugr.py} (64%)

diff --git a/python/quantum-pecos/src/pecos/slr/slr_converter.py b/python/quantum-pecos/src/pecos/slr/slr_converter.py
index cacf80ff3..23248a04d 100644
--- a/python/quantum-pecos/src/pecos/slr/slr_converter.py
+++ b/python/quantum-pecos/src/pecos/slr/slr_converter.py
@@ -172,7 +172,7 @@ def guppy(self) -> str:
         """
         return self._generate_guppy()
 
-    def hugr(self, *, _force_ast: bool = False):
+    def hugr(self):
         """Compile the SLR block to HUGR via Guppy.
 
         Returns:
@@ -182,31 +182,9 @@ def hugr(self, *, _force_ast: bool = False):
             ImportError: If guppylang is not available
             RuntimeError: If compilation fails
         """
-        if _force_ast:
-            return self._compile_ast_guppy_to_hugr()
+        return self._compile_hugr()
 
-        # Generate Guppy code
-        self._generate_guppy()
-
-        # Compile to HUGR
-        try:
-            from pecos.slr.gen_codes.guppy.hugr_compiler import HugrCompiler
-        except ImportError as e:
-            msg = "Failed to import HugrCompiler. Make sure guppylang is installed."
-            raise ImportError(msg) from e
-
-        # HugrCompiler needs the generator object for its internal state
-        # For now, fall back to the old path
-        from pecos.slr.gen_codes.guppy import IRGuppyGenerator
-
-        generator = IRGuppyGenerator(_internal=True)
-        generator.generate_block(self._block)
-
-        compiler = HugrCompiler(generator)
-        return compiler.compile_to_hugr()
-
-    def _compile_ast_guppy_to_hugr(self):
-        # Audit-only AST -> Guppy -> HUGR route used before cutover.
+    def _compile_hugr(self):
         guppy_code = self._generate_guppy()
 
         import importlib.util
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
index cb775f2de..162b79925 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
@@ -13,9 +13,8 @@
 
 Iterates a curated list of `(source_label, slr_program_factory)`
 pairs from PECOS examples, qeclib, and existing test fixtures.
-Runs each through the AST -> Guppy path via
-`SlrConverter.hugr(_force_ast=True)` (private kwarg added by
-Codex; see step4-cutover-plan.md) and captures any failures.
+Runs each through `SlrConverter.hugr()` (now AST-routed by default
+post-cutover) and captures any failures.
 
 This is NOT a pytest test file. It's an audit tool grug runs
 during Workstream B and at cutover. Output is the seed for new
@@ -826,29 +825,7 @@ def _run_case(case: AuditCase) -> AuditResult:
         )
 
     try:
-        # _force_ast is a private kwarg that routes SlrConverter.hugr()
-        # through the AST path even before cutover. Audit-only.
-        SlrConverter(prog).hugr(_force_ast=True)
-    except TypeError as exc:
-        expected = _expected_result(case, exc)
-        if expected is not None:
-            return expected
-        # _force_ast not yet plumbed -- emit a clear marker so the runner
-        # output points at the missing kwarg instead of looking like a
-        # real audit failure.
-        if "_force_ast" in str(exc):
-            return AuditResult(
-                label=case.label,
-                passed=False,
-                exception_type="MissingKwarg",
-                exception_message="SlrConverter.hugr() does not accept _force_ast yet (Codex emitter PR pending)",
-            )
-        return AuditResult(
-            label=case.label,
-            passed=False,
-            exception_type=type(exc).__name__,
-            exception_message=str(exc).splitlines()[0][:200],
-        )
+        SlrConverter(prog).hugr()
     except BaseException as exc:
         expected = _expected_result(case, exc)
         if expected is not None:
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_force_ast_hugr.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
similarity index 64%
rename from python/quantum-pecos/tests/slr_tests/ast_guppy/test_force_ast_hugr.py
rename to python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
index 610493545..e7100095e 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_force_ast_hugr.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
@@ -1,4 +1,4 @@
-"""Audit-only `SlrConverter.hugr(_force_ast=True)` hook tests."""
+"""Lock-in tests for `SlrConverter.hugr()` AST-routed path (post-cutover)."""
 
 from __future__ import annotations
 
@@ -9,7 +9,7 @@
 from pecos.slr.qeclib.qubit.measures import Measure
 
 
-def test_force_ast_hugr_compiles_via_ast_guppy_path() -> None:
+def test_hugr_compiles_via_ast_guppy_path() -> None:
     prog = Main(
         q := QReg("q", 2),
         c := CReg("c", 2),
@@ -18,12 +18,12 @@ def test_force_ast_hugr_compiles_via_ast_guppy_path() -> None:
         Measure(q) > c,
     )
 
-    hugr = SlrConverter(prog).hugr(_force_ast=True)
+    hugr = SlrConverter(prog).hugr()
 
     assert hugr is not None
 
 
-def test_force_ast_rejects_while_before_parallel_optimizer_erases_it() -> None:
+def test_hugr_rejects_while_before_parallel_optimizer_erases_it() -> None:
     prog = Main(
         q := QReg("q", 1),
         c := CReg("c", 1),
@@ -34,20 +34,20 @@ def test_force_ast_rejects_while_before_parallel_optimizer_erases_it() -> None:
     )
 
     with pytest.raises(GuppyCodegenError, match="does not support While loops"):
-        SlrConverter(prog).hugr(_force_ast=True)
+        SlrConverter(prog).hugr()
 
 
-def test_force_ast_rejects_non_z_prep_basis_before_ast_drops_it() -> None:
+def test_hugr_rejects_non_z_prep_basis_before_ast_drops_it() -> None:
     prog = Main(
         q := QReg("q", 1),
         qb.Prep(q[0], "X"),
     )
 
     with pytest.raises(GuppyCodegenError, match="supports only Z-basis Prep"):
-        SlrConverter(prog).hugr(_force_ast=True)
+        SlrConverter(prog).hugr()
 
 
-def test_force_ast_rejects_symbolic_loopvar_indexing_cleanly() -> None:
+def test_hugr_rejects_symbolic_loopvar_indexing_cleanly() -> None:
     i = LoopVar("i")
     prog = Main(
         q := QReg("q", 4),
@@ -55,15 +55,15 @@ def test_force_ast_rejects_symbolic_loopvar_indexing_cleanly() -> None:
     )
 
     with pytest.raises(GuppyCodegenError, match="symbolic LoopVar indexing"):
-        SlrConverter(prog).hugr(_force_ast=True)
+        SlrConverter(prog).hugr()
 
 
-def test_force_ast_accepts_inline_measure_creg_result() -> None:
+def test_hugr_accepts_inline_measure_creg_result() -> None:
     prog = Main(
         q := QReg("q", 2),
         Measure(q) > CReg("final", 2),
     )
 
-    hugr = SlrConverter(prog).hugr(_force_ast=True)
+    hugr = SlrConverter(prog).hugr()
 
     assert hugr is not None

From 78e3af13f9ae038037eccce6f26bb65428c4762b Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Thu, 14 May 2026 19:26:13 -0600
Subject: [PATCH 024/136] Cutover: delete legacy gen_codes/guppy/ and dependent
 tests

---
 .../quantum-pecos/src/pecos/slr/__init__.py   |    9 -
 .../src/pecos/slr/gen_codes/__init__.py       |    2 -
 .../src/pecos/slr/gen_codes/gen_guppy.py      |   12 -
 .../src/pecos/slr/gen_codes/guppy/__init__.py |    5 -
 .../pecos/slr/gen_codes/guppy/data_flow.py    |  379 -
 .../gen_codes/guppy/dependency_analyzer.py    |  210 -
 .../slr/gen_codes/guppy/hugr_compiler.py      |  107 -
 .../slr/gen_codes/guppy/hugr_error_handler.py |  207 -
 .../src/pecos/slr/gen_codes/guppy/ir.py       |  680 --
 .../pecos/slr/gen_codes/guppy/ir_analyzer.py  |  362 -
 .../pecos/slr/gen_codes/guppy/ir_builder.py   | 9360 -----------------
 .../pecos/slr/gen_codes/guppy/ir_generator.py |   79 -
 .../slr/gen_codes/guppy/ir_postprocessor.py   |  253 -
 .../src/pecos/slr/gen_codes/guppy/naming.py   |  138 -
 .../gen_codes/guppy/qubit_state_validator.py  |  329 -
 .../gen_codes/guppy/qubit_usage_analyzer.py   |  259 -
 .../slr/gen_codes/guppy/scope_manager.py      |  236 -
 .../guppy/unified_resource_planner.py         |  547 -
 .../slr/gen_codes/guppy/unpacking_rules.py    |  237 -
 .../slr/gen_codes/guppy/variable_state.py     |  154 -
 .../slr/ast_tests/test_codegen_equivalence.py |   33 -
 .../pecos/slr/test_qubit_state_validator.py   |  309 -
 .../slr_tests/guppy/demo_improvements.py      |  168 -
 .../slr_tests/guppy/demo_unpacking_rules.py   |  103 -
 .../guppy/test_allocation_optimization.py     |  188 -
 .../guppy/test_complex_permutations.py        |  172 -
 .../guppy/test_conditional_refinement.py      |  297 -
 .../tests/slr_tests/guppy/test_data_flow.py   |  296 -
 .../guppy/test_hugr_error_messages.py         |  116 -
 .../tests/slr_tests/guppy/test_ir_basic.py    |   83 -
 .../slr_tests/guppy/test_ir_for_loops.py      |  172 -
 .../slr_tests/guppy/test_ir_generator.py      |  114 -
 .../guppy/test_ir_hugr_compatibility.py       |  128 -
 .../tests/slr_tests/guppy/test_ir_permute.py  |  112 -
 .../guppy/test_ir_scope_management.py         |  127 -
 .../slr_tests/guppy/test_ir_while_loops.py    |  167 -
 .../guppy/test_unified_resource_planner.py    |  489 -
 .../slr_tests/guppy/test_unpacking_rules.py   |  406 -
 38 files changed, 17045 deletions(-)
 delete mode 100644 python/quantum-pecos/src/pecos/slr/gen_codes/gen_guppy.py
 delete mode 100644 python/quantum-pecos/src/pecos/slr/gen_codes/guppy/__init__.py
 delete mode 100644 python/quantum-pecos/src/pecos/slr/gen_codes/guppy/data_flow.py
 delete mode 100644 python/quantum-pecos/src/pecos/slr/gen_codes/guppy/dependency_analyzer.py
 delete mode 100644 python/quantum-pecos/src/pecos/slr/gen_codes/guppy/hugr_compiler.py
 delete mode 100644 python/quantum-pecos/src/pecos/slr/gen_codes/guppy/hugr_error_handler.py
 delete mode 100644 python/quantum-pecos/src/pecos/slr/gen_codes/guppy/ir.py
 delete mode 100644 python/quantum-pecos/src/pecos/slr/gen_codes/guppy/ir_analyzer.py
 delete mode 100644 python/quantum-pecos/src/pecos/slr/gen_codes/guppy/ir_builder.py
 delete mode 100644 python/quantum-pecos/src/pecos/slr/gen_codes/guppy/ir_generator.py
 delete mode 100644 python/quantum-pecos/src/pecos/slr/gen_codes/guppy/ir_postprocessor.py
 delete mode 100644 python/quantum-pecos/src/pecos/slr/gen_codes/guppy/naming.py
 delete mode 100644 python/quantum-pecos/src/pecos/slr/gen_codes/guppy/qubit_state_validator.py
 delete mode 100644 python/quantum-pecos/src/pecos/slr/gen_codes/guppy/qubit_usage_analyzer.py
 delete mode 100644 python/quantum-pecos/src/pecos/slr/gen_codes/guppy/scope_manager.py
 delete mode 100644 python/quantum-pecos/src/pecos/slr/gen_codes/guppy/unified_resource_planner.py
 delete mode 100644 python/quantum-pecos/src/pecos/slr/gen_codes/guppy/unpacking_rules.py
 delete mode 100644 python/quantum-pecos/src/pecos/slr/gen_codes/guppy/variable_state.py
 delete mode 100644 python/quantum-pecos/tests/pecos/slr/test_qubit_state_validator.py
 delete mode 100644 python/quantum-pecos/tests/slr_tests/guppy/demo_improvements.py
 delete mode 100644 python/quantum-pecos/tests/slr_tests/guppy/demo_unpacking_rules.py
 delete mode 100644 python/quantum-pecos/tests/slr_tests/guppy/test_allocation_optimization.py
 delete mode 100644 python/quantum-pecos/tests/slr_tests/guppy/test_complex_permutations.py
 delete mode 100644 python/quantum-pecos/tests/slr_tests/guppy/test_conditional_refinement.py
 delete mode 100644 python/quantum-pecos/tests/slr_tests/guppy/test_data_flow.py
 delete mode 100644 python/quantum-pecos/tests/slr_tests/guppy/test_hugr_error_messages.py
 delete mode 100644 python/quantum-pecos/tests/slr_tests/guppy/test_ir_basic.py
 delete mode 100644 python/quantum-pecos/tests/slr_tests/guppy/test_ir_for_loops.py
 delete mode 100644 python/quantum-pecos/tests/slr_tests/guppy/test_ir_generator.py
 delete mode 100644 python/quantum-pecos/tests/slr_tests/guppy/test_ir_hugr_compatibility.py
 delete mode 100644 python/quantum-pecos/tests/slr_tests/guppy/test_ir_permute.py
 delete mode 100644 python/quantum-pecos/tests/slr_tests/guppy/test_ir_scope_management.py
 delete mode 100644 python/quantum-pecos/tests/slr_tests/guppy/test_ir_while_loops.py
 delete mode 100644 python/quantum-pecos/tests/slr_tests/guppy/test_unified_resource_planner.py
 delete mode 100644 python/quantum-pecos/tests/slr_tests/guppy/test_unpacking_rules.py

diff --git a/python/quantum-pecos/src/pecos/slr/__init__.py b/python/quantum-pecos/src/pecos/slr/__init__.py
index 38e8e38b0..a08a5deea 100644
--- a/python/quantum-pecos/src/pecos/slr/__init__.py
+++ b/python/quantum-pecos/src/pecos/slr/__init__.py
@@ -85,11 +85,6 @@
 from pecos.slr import ast, qeclib
 from pecos.slr.block import Block
 from pecos.slr.cond_block import If, Repeat
-from pecos.slr.gen_codes.guppy.qubit_state_validator import (
-    QubitStateValidator,
-    StateViolation,
-    validate_qubit_states,
-)
 from pecos.slr.loop_block import For, While
 from pecos.slr.main import Main
 from pecos.slr.main import (
@@ -188,14 +183,11 @@ def generate(
     "QReg",
     "Qubit",
     "QubitRef",
-    # State validation
-    "QubitStateValidator",
     "QubitType",
     "Repeat",
     "Return",
     "SlotState",
     "SlrConverter",
-    "StateViolation",
     "Vars",
     "While",
     # AST module
@@ -204,5 +196,4 @@ def generate(
     "generate",
     # QEC library
     "qeclib",
-    "validate_qubit_states",
 ]
diff --git a/python/quantum-pecos/src/pecos/slr/gen_codes/__init__.py b/python/quantum-pecos/src/pecos/slr/gen_codes/__init__.py
index d2c013507..faa19035d 100644
--- a/python/quantum-pecos/src/pecos/slr/gen_codes/__init__.py
+++ b/python/quantum-pecos/src/pecos/slr/gen_codes/__init__.py
@@ -34,14 +34,12 @@
 For AST-based code generation, see :mod:`pecos.slr.ast.codegen`.
 """
 
-from pecos.slr.gen_codes.gen_guppy import GuppyGenerator
 from pecos.slr.gen_codes.gen_qasm import QASMGenerator
 from pecos.slr.gen_codes.gen_qir import QIRGenerator
 from pecos.slr.gen_codes.gen_quantum_circuit import QuantumCircuitGenerator
 from pecos.slr.gen_codes.gen_stim import StimGenerator
 
 __all__ = [
-    "GuppyGenerator",
     "QASMGenerator",
     "QIRGenerator",
     "QuantumCircuitGenerator",
diff --git a/python/quantum-pecos/src/pecos/slr/gen_codes/gen_guppy.py b/python/quantum-pecos/src/pecos/slr/gen_codes/gen_guppy.py
deleted file mode 100644
index 1d7721d71..000000000
--- a/python/quantum-pecos/src/pecos/slr/gen_codes/gen_guppy.py
+++ /dev/null
@@ -1,12 +0,0 @@
-"""Guppy code generation for SLR programs.
-
-This module provides the entry point for Guppy code generation.
-The actual implementation is in the guppy/ subdirectory.
-"""
-
-from pecos.slr.gen_codes.guppy import IRGuppyGenerator
-
-# Alias for convenience
-GuppyGenerator = IRGuppyGenerator
-
-__all__ = ["GuppyGenerator", "IRGuppyGenerator"]
diff --git a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/__init__.py b/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/__init__.py
deleted file mode 100644
index d2668b286..000000000
--- a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/__init__.py
+++ /dev/null
@@ -1,5 +0,0 @@
-"""Guppy code generation package for SLR programs."""
-
-from pecos.slr.gen_codes.guppy.ir_generator import IRGuppyGenerator
-
-__all__ = ["IRGuppyGenerator"]
diff --git a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/data_flow.py b/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/data_flow.py
deleted file mode 100644
index 8673d750f..000000000
--- a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/data_flow.py
+++ /dev/null
@@ -1,379 +0,0 @@
-"""Data flow analysis for SLR to Guppy code generation.
-
-This module provides data flow analysis to track how quantum and classical values
-flow through a program, particularly tracking measurement results and their usage.
-
-The key insight is that we need to distinguish between:
-1. Operations BEFORE measurement (don't require unpacking)
-2. Operations AFTER measurement that use the SAME qubit (require unpacking for replacement)
-3. Operations AFTER measurement that use DIFFERENT qubits (don't require unpacking)
-
-Current heuristics over-approximate by treating ANY operation after ANY measurement
-as requiring unpacking, leading to unnecessary array unpacking.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any
-
-if TYPE_CHECKING:
-    from pecos.slr import Block as SLRBlock
-
-
-@dataclass
-class ValueUse:
-    """Represents a use of a value (qubit or classical bit)."""
-
-    array_name: str
-    index: int
-    position: int  # Position in operation sequence
-    operation_type: str  # e.g., "gate", "measurement", "condition"
-    is_consuming: bool = False  # True if this use consumes the value (e.g., measurement)
-
-
-@dataclass
-class DataFlowInfo:
-    """Information about data flow for a single array element."""
-
-    array_name: str
-    index: int
-    is_classical: bool
-
-    # Track all uses of this element
-    uses: list[ValueUse] = field(default_factory=list)
-
-    # Track consumption points (measurements)
-    consumed_at: list[int] = field(default_factory=list)
-
-    # Track replacements (e.g., Prep after measurement)
-    replaced_at: list[int] = field(default_factory=list)
-
-    def add_use(
-        self,
-        position: int,
-        operation_type: str,
-        *,
-        is_consuming: bool = False,
-    ) -> None:
-        """Add a use of this value."""
-        use = ValueUse(
-            array_name=self.array_name,
-            index=self.index,
-            position=position,
-            operation_type=operation_type,
-            is_consuming=is_consuming,
-        )
-        self.uses.append(use)
-
-        if is_consuming:
-            self.consumed_at.append(position)
-
-    def add_replacement(self, position: int) -> None:
-        """Mark that this value is replaced at a position (e.g., Prep)."""
-        self.replaced_at.append(position)
-
-    def has_use_after_consumption(self) -> bool:
-        """Check if this element is used after being consumed.
-
-        This is the key analysis for determining if unpacking is needed.
-        If a qubit is measured and then used again (not just replaced),
-        we need unpacking to handle the replacement properly.
-        """
-        if not self.consumed_at:
-            return False
-
-        # Find the first consumption point
-        first_consumption = min(self.consumed_at)
-
-        # Check if there are any non-replacement uses after consumption
-        for use in self.uses:
-            if use.position > first_consumption and use.position not in self.replaced_at:
-                # This is a real use after consumption, not just replacement
-                # However, we need to check if it's AFTER replacement
-                # Find if there's a replacement between consumption and this use
-                replacements_between = [r for r in self.replaced_at if first_consumption < r < use.position]
-
-                if not replacements_between:
-                    # Use after consumption with no replacement in between
-                    # This requires unpacking
-                    return True
-
-        return False
-
-    def requires_unpacking_for_flow(self) -> bool:
-        """Determine if this element requires unpacking based on data flow.
-
-        This is more precise than the heuristic approach:
-        - Classical values can be used multiple times without issue
-        - Quantum values can be used multiple times if not measured
-        - Quantum values that are measured and then used require unpacking
-        """
-        if self.is_classical:
-            # Classical values can be read multiple times
-            return False
-
-        # Quantum values: check if used after consumption
-        return self.has_use_after_consumption()
-
-
-@dataclass
-class DataFlowAnalysis:
-    """Complete data flow analysis for a block."""
-
-    # Map from (array_name, index) to DataFlowInfo
-    element_flows: dict[tuple[str, int], DataFlowInfo] = field(default_factory=dict)
-
-    # Track conditionally accessed elements
-    conditional_accesses: set[tuple[str, int]] = field(default_factory=set)
-
-    def get_or_create_flow(
-        self,
-        array_name: str,
-        index: int,
-        is_classical: bool,
-    ) -> DataFlowInfo:
-        """Get or create data flow info for an array element."""
-        key = (array_name, index)
-        if key not in self.element_flows:
-            self.element_flows[key] = DataFlowInfo(
-                array_name=array_name,
-                index=index,
-                is_classical=is_classical,
-            )
-        return self.element_flows[key]
-
-    def add_gate_use(self, array_name: str, index: int, position: int) -> None:
-        """Record a gate operation on an array element."""
-        flow = self.get_or_create_flow(array_name, index, is_classical=False)
-        flow.add_use(position, "gate", is_consuming=False)
-
-    def add_measurement(
-        self,
-        quantum_array: str,
-        quantum_index: int,
-        position: int,
-        classical_array: str | None = None,
-        classical_index: int | None = None,
-    ) -> None:
-        """Record a measurement operation."""
-        # Quantum side: consumption
-        q_flow = self.get_or_create_flow(
-            quantum_array,
-            quantum_index,
-            is_classical=False,
-        )
-        q_flow.add_use(position, "measurement", is_consuming=True)
-
-        # Classical side: creation (if specified)
-        if classical_array is not None and classical_index is not None:
-            c_flow = self.get_or_create_flow(
-                classical_array,
-                classical_index,
-                is_classical=True,
-            )
-            c_flow.add_use(position, "measurement_result", is_consuming=False)
-
-    def add_preparation(self, array_name: str, index: int, position: int) -> None:
-        """Record a preparation/reset operation (replaces a qubit)."""
-        flow = self.get_or_create_flow(array_name, index, is_classical=False)
-        flow.add_use(position, "preparation", is_consuming=False)
-        flow.add_replacement(position)
-
-    def add_conditional_use(
-        self,
-        array_name: str,
-        index: int,
-        position: int,
-        is_classical: bool,
-    ) -> None:
-        """Record a conditional use of an array element."""
-        flow = self.get_or_create_flow(array_name, index, is_classical)
-        flow.add_use(position, "condition", is_consuming=False)
-        self.conditional_accesses.add((array_name, index))
-
-    def elements_requiring_unpacking(self) -> set[tuple[str, int]]:
-        """Get the set of array elements that require unpacking based on data flow."""
-        requiring_unpacking = set()
-
-        for key, flow in self.element_flows.items():
-            if flow.requires_unpacking_for_flow():
-                requiring_unpacking.add(key)
-
-        return requiring_unpacking
-
-    def array_requires_unpacking(self, array_name: str) -> bool:
-        """Check if an entire array requires unpacking based on data flow."""
-        for key, flow in self.element_flows.items():
-            if key[0] == array_name and flow.requires_unpacking_for_flow():
-                return True
-        return False
-
-
-class DataFlowAnalyzer:
-    """Analyzes data flow in SLR blocks."""
-
-    def __init__(self):
-        self.position_counter = 0
-        self.in_conditional = False
-
-    def analyze(
-        self,
-        block: SLRBlock,
-        variable_context: dict[str, Any],
-    ) -> DataFlowAnalysis:
-        """Analyze data flow in a block.
-
-        Args:
-            block: The SLR block to analyze
-            variable_context: Context of variables (QReg, CReg, etc.)
-
-        Returns:
-            DataFlowAnalysis containing all data flow information
-        """
-        analysis = DataFlowAnalysis()
-        self.position_counter = 0
-        self.in_conditional = False
-
-        # Analyze all operations
-        if hasattr(block, "ops"):
-            for op in block.ops:
-                self._analyze_operation(op, analysis, variable_context)
-                self.position_counter += 1
-
-        return analysis
-
-    def _analyze_operation(
-        self,
-        op: Any,
-        analysis: DataFlowAnalysis,
-        variable_context: dict[str, Any],
-    ) -> None:
-        """Analyze a single operation."""
-        op_type = type(op).__name__
-
-        if op_type == "Measure":
-            self._analyze_measurement(op, analysis)
-        elif op_type == "If":
-            self._analyze_if_block(op, analysis, variable_context)
-        elif hasattr(op, "qargs"):
-            # Check if this is a preparation operation
-            if self._is_preparation(op):
-                self._analyze_preparation(op, analysis)
-            else:
-                self._analyze_quantum_operation(op, analysis)
-        elif hasattr(op, "ops"):
-            # Nested block - recurse
-            for nested_op in op.ops:
-                self._analyze_operation(nested_op, analysis, variable_context)
-
-    def _is_preparation(self, op: Any) -> bool:
-        """Check if an operation is a preparation/reset."""
-        op_name = type(op).__name__
-        return op_name in ["Prep", "Init", "Reset"]
-
-    def _analyze_measurement(self, meas: Any, analysis: DataFlowAnalysis) -> None:
-        """Analyze a measurement operation."""
-        # Get classical targets
-        classical_targets = []
-        if hasattr(meas, "cout") and meas.cout:
-            classical_targets.extend(
-                (cout.reg.sym, cout.index)
-                for cout in meas.cout
-                if hasattr(cout, "reg") and hasattr(cout.reg, "sym") and hasattr(cout, "index")
-            )
-
-        # Analyze quantum sources
-        if hasattr(meas, "qargs") and meas.qargs:
-            for i, qarg in enumerate(meas.qargs):
-                # Individual element measurement
-                if hasattr(qarg, "reg") and hasattr(qarg.reg, "sym") and hasattr(qarg, "index"):
-                    array_name = qarg.reg.sym
-                    index = qarg.index
-
-                    # Get corresponding classical target if exists
-                    classical_array = None
-                    classical_index = None
-                    if i < len(classical_targets):
-                        classical_array, classical_index = classical_targets[i]
-
-                    analysis.add_measurement(
-                        quantum_array=array_name,
-                        quantum_index=index,
-                        position=self.position_counter,
-                        classical_array=classical_array,
-                        classical_index=classical_index,
-                    )
-
-    def _analyze_preparation(self, op: Any, analysis: DataFlowAnalysis) -> None:
-        """Analyze a preparation/reset operation."""
-        if hasattr(op, "qargs") and op.qargs:
-            for qarg in op.qargs:
-                if hasattr(qarg, "reg") and hasattr(qarg.reg, "sym") and hasattr(qarg, "index"):
-                    array_name = qarg.reg.sym
-                    index = qarg.index
-                    analysis.add_preparation(array_name, index, self.position_counter)
-
-    def _analyze_quantum_operation(self, op: Any, analysis: DataFlowAnalysis) -> None:
-        """Analyze a quantum gate operation."""
-        if hasattr(op, "qargs") and op.qargs:
-            for qarg in op.qargs:
-                if hasattr(qarg, "reg") and hasattr(qarg.reg, "sym") and hasattr(qarg, "index"):
-                    array_name = qarg.reg.sym
-                    index = qarg.index
-
-                    if self.in_conditional:
-                        analysis.add_conditional_use(
-                            array_name,
-                            index,
-                            self.position_counter,
-                            is_classical=False,
-                        )
-                    else:
-                        analysis.add_gate_use(array_name, index, self.position_counter)
-
-    def _analyze_if_block(
-        self,
-        if_block: Any,
-        analysis: DataFlowAnalysis,
-        variable_context: dict[str, Any],
-    ) -> None:
-        """Analyze an if block."""
-        prev_conditional = self.in_conditional
-        self.in_conditional = True
-
-        # Analyze condition
-        if hasattr(if_block, "cond"):
-            self._analyze_condition(if_block.cond, analysis)
-
-        # Analyze then block
-        if hasattr(if_block, "ops"):
-            for op in if_block.ops:
-                self._analyze_operation(op, analysis, variable_context)
-
-        # Analyze else block
-        if hasattr(if_block, "else_block") and if_block.else_block and hasattr(if_block.else_block, "ops"):
-            for op in if_block.else_block.ops:
-                self._analyze_operation(op, analysis, variable_context)
-
-        self.in_conditional = prev_conditional
-
-    def _analyze_condition(self, cond: Any, analysis: DataFlowAnalysis) -> None:
-        """Analyze a condition expression."""
-        cond_type = type(cond).__name__
-
-        if cond_type == "Bit" and hasattr(cond, "reg") and hasattr(cond.reg, "sym") and hasattr(cond, "index"):
-            array_name = cond.reg.sym
-            index = cond.index
-            analysis.add_conditional_use(
-                array_name,
-                index,
-                self.position_counter,
-                is_classical=True,
-            )
-
-        # Handle compound conditions
-        if hasattr(cond, "left"):
-            self._analyze_condition(cond.left, analysis)
-        if hasattr(cond, "right"):
-            self._analyze_condition(cond.right, analysis)
diff --git a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/dependency_analyzer.py b/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/dependency_analyzer.py
deleted file mode 100644
index bbd77521a..000000000
--- a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/dependency_analyzer.py
+++ /dev/null
@@ -1,210 +0,0 @@
-"""Dependency analyzer for SLR blocks."""
-
-from __future__ import annotations
-
-import inspect
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any
-
-if TYPE_CHECKING:
-    from pecos.slr import Block
-
-
-@dataclass
-class BlockDependency:
-    """Represents dependencies for a block."""
-
-    block_type: str
-    constructor_params: dict[str, Any]  # parameter name -> value/type
-    used_variables: set[str]  # Set of variable names used in operations
-    nested_blocks: list[BlockDependency]  # Dependencies of nested blocks
-
-
-class DependencyAnalyzer:
-    """Analyzes SLR blocks to determine parameter dependencies."""
-
-    def __init__(self):
-        self.analyzed_blocks = {}  # Cache of analyzed block types
-
-    def analyze_block(self, block: Block) -> BlockDependency:
-        """Analyze a block to determine its dependencies."""
-        block_type = type(block).__name__
-
-        # Get constructor parameters
-        constructor_params = self._get_constructor_params(block)
-
-        # Find used variables in operations
-        used_variables = set()
-        nested_blocks = []
-
-        if hasattr(block, "ops"):
-            for op in block.ops:
-                # Collect variables from operations
-                self._collect_variables_from_op(op, used_variables)
-
-                # If it's a nested block, analyze it too
-                if hasattr(op, "ops") and hasattr(op, "vars"):
-                    nested_dep = self.analyze_block(op)
-                    nested_blocks.append(nested_dep)
-                    # Add nested block's used variables
-                    used_variables.update(nested_dep.used_variables)
-
-        return BlockDependency(
-            block_type=block_type,
-            constructor_params=constructor_params,
-            used_variables=used_variables,
-            nested_blocks=nested_blocks,
-        )
-
-    def _get_constructor_params(self, block: Block) -> dict[str, Any]:
-        """Extract constructor parameters from a block instance."""
-        params = {}
-
-        # Get the constructor signature
-        sig = inspect.signature(type(block).__init__)
-
-        # Try to match parameters with instance attributes
-        for param_name in sig.parameters:
-            if param_name == "self":
-                continue
-
-            # Common patterns for how parameters are stored
-            if hasattr(block, param_name):
-                params[param_name] = getattr(block, param_name)
-            elif hasattr(block, f"_{param_name}"):
-                params[param_name] = getattr(block, f"_{param_name}")
-            # Try to infer from operations
-            elif param_name in ["data", "qubits", "q"]:
-                # Look for quantum registers
-                params[param_name] = self._find_qreg_in_ops(block)
-            elif param_name in ["ancilla", "a"]:
-                # Look for ancilla qubits
-                params[param_name] = self._find_ancilla_in_ops(block)
-            elif param_name in ["init_bit", "init", "bit", "c"]:
-                # Look for classical bits
-                params[param_name] = self._find_bit_in_ops(block)
-
-        return params
-
-    def _collect_variables_from_op(self, op, used_vars: set[str]):
-        """Collect variable names used in an operation."""
-        # Check quantum arguments
-        if hasattr(op, "qargs"):
-            for qarg in op.qargs:
-                if hasattr(qarg, "reg") and hasattr(qarg.reg, "sym"):
-                    used_vars.add(qarg.reg.sym)
-                elif hasattr(qarg, "sym"):
-                    # Direct QReg object
-                    used_vars.add(qarg.sym)
-                elif isinstance(qarg, tuple):
-                    # Handle tuples of qubits
-                    for q in qarg:
-                        if hasattr(q, "reg") and hasattr(q.reg, "sym"):
-                            used_vars.add(q.reg.sym)
-
-        # Check classical arguments
-        if hasattr(op, "cargs"):
-            for carg in op.cargs:
-                if hasattr(carg, "reg") and hasattr(carg.reg, "sym"):
-                    used_vars.add(carg.reg.sym)
-
-        # Check output bits (for measurements)
-        if hasattr(op, "cout") and op.cout:
-            for cout in op.cout:
-                if hasattr(cout, "reg") and hasattr(cout.reg, "sym"):
-                    used_vars.add(cout.reg.sym)
-                elif hasattr(cout, "sym"):
-                    # Direct CReg reference
-                    used_vars.add(cout.sym)
-
-        # Check condition (for If blocks)
-        if hasattr(op, "cond"):
-            self._collect_variables_from_expr(op.cond, used_vars)
-
-        # Check expressions (for classical operations)
-        if hasattr(op, "left"):
-            self._collect_variables_from_expr(op.left, used_vars)
-        if hasattr(op, "right"):
-            self._collect_variables_from_expr(op.right, used_vars)
-
-    def _collect_variables_from_expr(self, expr, used_vars: set[str]):
-        """Collect variable names from expressions."""
-        if hasattr(expr, "reg") and hasattr(expr.reg, "sym"):
-            used_vars.add(expr.reg.sym)
-        elif hasattr(expr, "left") and hasattr(expr, "right"):
-            # Binary operation
-            self._collect_variables_from_expr(expr.left, used_vars)
-            self._collect_variables_from_expr(expr.right, used_vars)
-        elif hasattr(expr, "args"):
-            # Function call or similar
-            for arg in expr.args:
-                self._collect_variables_from_expr(arg, used_vars)
-
-    def _find_qreg_in_ops(self, block):
-        """Try to find quantum register used in operations."""
-        if hasattr(block, "ops"):
-            for op in block.ops:
-                if hasattr(op, "qargs") and op.qargs:
-                    qarg = op.qargs[0]
-                    if hasattr(qarg, "reg"):
-                        return qarg.reg
-        return None
-
-    def _find_ancilla_in_ops(self, block):
-        """Try to find ancilla qubit used in operations."""
-        # Look for single qubit operations that might be ancilla
-        if hasattr(block, "ops"):
-            for op in block.ops:
-                if type(op).__name__ == "Prep" and hasattr(op, "qargs"):
-                    # Prep operations often reset ancillas
-                    for qarg in op.qargs:
-                        if hasattr(qarg, "index") and not hasattr(qarg, "size"):
-                            # Single qubit
-                            return qarg
-        return None
-
-    def _find_bit_in_ops(self, block):
-        """Try to find classical bit used in operations."""
-        if hasattr(block, "ops"):
-            for op in block.ops:
-                if hasattr(op, "cout") and op.cout:
-                    # Measurement output
-                    return op.cout[0]
-        return None
-
-    def get_required_parameters(
-        self,
-        block: Block,
-        parent_context: dict[str, Any],
-    ) -> list[tuple[str, str]]:
-        """Get the parameters required for a block function.
-
-        Args:
-            block: The block to analyze
-            parent_context: Dictionary mapping variable names to their types/values
-
-        Returns:
-            List of (param_name, param_type) tuples
-        """
-        dep = self.analyze_block(block)
-
-        # Collect all used variables
-        all_used = dep.used_variables.copy()
-
-        # Map to parameter types
-        params = []
-        for var_name in sorted(all_used):
-            if var_name in parent_context:
-                var_info = parent_context[var_name]
-                if hasattr(var_info, "__class__"):
-                    var_type = var_info.__class__.__name__
-                    if var_type == "QReg":
-                        size = var_info.size if hasattr(var_info, "size") else 1
-                        params.append((var_name, f"array[quantum.qubit, {size}]"))
-                    elif var_type == "CReg":
-                        size = var_info.size if hasattr(var_info, "size") else 1
-                        params.append((var_name, f"array[bool, {size}]"))
-                    else:
-                        params.append((var_name, var_type))
-
-        return params
diff --git a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/hugr_compiler.py b/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/hugr_compiler.py
deleted file mode 100644
index 8fb6f29dd..000000000
--- a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/hugr_compiler.py
+++ /dev/null
@@ -1,107 +0,0 @@
-"""HUGR compiler for Guppy code generation."""
-
-from __future__ import annotations
-
-import tempfile
-from typing import Any
-
-from pecos.slr.gen_codes.guppy.hugr_error_handler import HugrErrorHandler
-
-
-class HugrCompiler:
-    """Compiles generated Guppy code to HUGR."""
-
-    def __init__(self, generator):
-        """Initialize the HUGR compiler.
-
-        Args:
-            generator: A generator instance with generated code (must have get_output() method)
-        """
-        self.generator = generator
-
-    def compile_to_hugr(self) -> Any:
-        """Compile the generated Guppy code to HUGR.
-
-        Returns:
-            The compiled HUGR module
-
-        Raises:
-            RuntimeError: If compilation fails
-        """
-        # Get the generated Guppy code
-        guppy_code = self.generator.get_output()
-
-        # Create a temporary file to hold the generated code
-        # This is necessary because guppy.compile() needs to be able to inspect the source
-        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
-            temp_file = f.name
-            f.write(guppy_code)
-
-        try:
-            # Import the module from the temporary file
-            import importlib.util
-            import linecache
-            import sys
-
-            # Add the source to linecache for better error tracking
-            lines = guppy_code.splitlines(keepends=True)
-            linecache.cache[temp_file] = (
-                len(guppy_code),
-                None,
-                lines,
-                temp_file,
-            )
-
-            spec = importlib.util.spec_from_file_location("_guppy_generated", temp_file)
-            if spec is None or spec.loader is None:
-                msg = "Failed to create module spec"
-                raise RuntimeError(msg)
-
-            module = importlib.util.module_from_spec(spec)
-
-            # Ensure the module has proper file tracking
-            module.__file__ = temp_file
-
-            # Add to sys.modules temporarily to help with source tracking
-            sys.modules["_guppy_generated"] = module
-
-            spec.loader.exec_module(module)
-
-            # Get the main function
-            if not hasattr(module, "main"):
-                msg = "No main function found in generated code"
-                raise RuntimeError(msg)
-
-            main_func = module.main
-
-            # Compile to HUGR
-            try:
-                # Debug: print the generated code
-                # print("DEBUG: Generated Guppy code:")
-                # print(guppy_code)
-                # print("="*50)
-
-                # Use the new API: func.compile() instead of guppy.compile(func)
-                return main_func.compile()
-            except (AttributeError, TypeError, ValueError, RuntimeError) as e:
-                # Use the enhanced error handler
-                error_handler = HugrErrorHandler(guppy_code)
-                detailed_error = error_handler.analyze_error(e)
-                raise RuntimeError(detailed_error)
-
-        finally:
-            # Clean up
-            try:
-                # Remove from sys.modules
-                import sys
-
-                if "_guppy_generated" in sys.modules:
-                    del sys.modules["_guppy_generated"]
-
-                # Clean up the temporary file
-                from pathlib import Path
-
-                Path(temp_file).unlink()
-            except (OSError, FileNotFoundError):
-                # Ignore cleanup errors
-                pass
diff --git a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/hugr_error_handler.py b/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/hugr_error_handler.py
deleted file mode 100644
index ba8d265fb..000000000
--- a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/hugr_error_handler.py
+++ /dev/null
@@ -1,207 +0,0 @@
-"""Enhanced error handling for HUGR compilation failures."""
-
-from __future__ import annotations
-
-import re
-from dataclasses import dataclass
-from typing import ClassVar
-
-
-@dataclass
-class ErrorContext:
-    """Context information for an error."""
-
-    line_number: int
-    line_content: str
-    variable_name: str | None = None
-    error_type: str | None = None
-    suggestion: str | None = None
-
-
-class HugrErrorHandler:
-    """Provides detailed error messages and suggestions for HUGR compilation failures."""
-
-    # Common error patterns and their explanations
-    ERROR_PATTERNS: ClassVar[dict[str, dict[str, str]]] = {
-        r"PlaceNotUsedError.*Variable\(name='(\w+)'": {
-            "type": "PlaceNotUsedError",
-            "message": "Quantum register '{var}' was not consumed",
-            "suggestion": "Add a measurement for this quantum register or ensure it's consumed in all execution paths",
-        },
-        r"NotOwnedError.*Variable\(name='(\w+)'": {
-            "type": "NotOwnedError",
-            "message": "Variable '{var}' is not owned in this context",
-            "suggestion": "Ensure the variable is passed with @owned annotation or is properly borrowed",
-        },
-        r"AlreadyUsedError.*Variable\(name='(\w+)'": {
-            "type": "AlreadyUsedError",
-            "message": "Variable '{var}' has already been consumed",
-            "suggestion": "Quantum resources can only be used once. Check for duplicate measurements or operations",
-        },
-        r"MoveOutOfSubscriptError": {
-            "type": "MoveOutOfSubscriptError",
-            "message": "Cannot move out of array subscript",
-            "suggestion": (
-                "Use array unpacking or measure_array() instead of individual element access after consumption"
-            ),
-        },
-        r"NotCallableError.*'(\w+)'": {
-            "type": "NotCallableError",
-            "message": "'{var}' is not callable",
-            "suggestion": "Check if a variable name conflicts with a function name (e.g., 'result')",
-        },
-        r"NameError.*name\s+'(\w+)'\s+is\s+not\s+defined": {
-            "type": "NameError",
-            "message": "Variable '{var}' is not defined",
-            "suggestion": "Check variable scoping or if the variable was renamed to avoid conflicts",
-        },
-        r"TypeError.*missing.*positional argument.*'(\w+)'": {
-            "type": "TypeError",
-            "message": "Missing required argument '{var}'",
-            "suggestion": "Check function signatures and ensure all required parameters are provided",
-        },
-        r"UnknownSourceError.*obj=<class.*\.(\w+)'>": {
-            "type": "UnknownSourceError",
-            "message": "Cannot find source location for dynamically generated class '{var}'",
-            "suggestion": "This is a known limitation with dynamically generated structs. "
-            "The struct definition is correct but lacks source tracking metadata.",
-        },
-    }
-
-    def __init__(self, guppy_code: str):
-        """Initialize with the generated Guppy code."""
-        self.code_lines = guppy_code.split("\n")
-
-    def analyze_error(self, error: Exception) -> str:
-        """Analyze an error and provide detailed diagnostics."""
-        error_str = str(error)
-        error_type = type(error).__name__
-
-        # Try to match against known patterns
-        for pattern, info in self.ERROR_PATTERNS.items():
-            match = re.search(pattern, error_str)
-            if match:
-                return self._format_known_error(match, info, error_str)
-
-        # Handle specific error types with custom logic
-        if "MoveOutOfSubscriptError" in error_str:
-            return self._analyze_subscript_error(error_str)
-
-        # Generic error handling
-        return self._format_generic_error(error_type, error_str)
-
-    def _format_known_error(self, match: re.Match, info: dict, error_str: str) -> str:
-        """Format a known error pattern."""
-        var_name = match.group(1) if match.groups() else None
-
-        lines = [
-            f"\n{'='*60}",
-            f"HUGR Compilation Error: {info['type']}",
-            f"{'='*60}\n",
-        ]
-
-        if var_name:
-            lines.append(f"Problem: {info['message'].format(var=var_name)}")
-        else:
-            lines.append(f"Problem: {info['message']}")
-
-        lines.append(f"\nSuggestion: {info['suggestion']}")
-
-        # Find relevant code context
-        context = self._find_code_context(var_name)
-        if context:
-            lines.append("\nRelevant code:")
-            lines.extend(f"  Line {ctx.line_number}: {ctx.line_content.strip()}" for ctx in context)
-
-        # Add specific examples for common fixes
-        if info["type"] == "PlaceNotUsedError" and var_name:
-            lines.append("\nExample fix:")
-            lines.append("  # Add before the end of the function:")
-            lines.append(f"  _ = quantum.measure_array({var_name})")
-
-        elif info["type"] == "MoveOutOfSubscriptError":
-            lines.append("\nExample fix:")
-            lines.append("  # Instead of accessing elements after measurement:")
-            lines.append("  # BAD:  c = measure_array(q); x = q[0]")
-            lines.append("  # GOOD: q_0, q_1 = q; c_0 = measure(q_0)")
-
-        lines.append(f"\nOriginal error: {error_str}")
-        lines.append(f"{'='*60}\n")
-
-        return "\n".join(lines)
-
-    def _analyze_subscript_error(self, error_str: str) -> str:
-        """Analyze MoveOutOfSubscriptError in detail."""
-        lines = [
-            f"\n{'='*60}",
-            "HUGR Compilation Error: MoveOutOfSubscriptError",
-            f"{'='*60}\n",
-            "Problem: Attempting to access array elements after the array has been consumed",
-            "\nThis typically happens when:",
-            "  1. You measure an entire array with measure_array()",
-            "  2. Then try to access individual elements like array[0]",
-            "\nSolution approaches:",
-            "  1. Unpack the array before measurements:",
-            "     q_0, q_1, q_2 = q  # Unpack at the start",
-            "     c_0 = quantum.measure(q_0)  # Use unpacked names",
-            "\n  2. Use measure_array() for the entire array:",
-            "     c = quantum.measure_array(q)  # Measure all at once",
-            "\n  3. Measure individual elements without unpacking:",
-            "     c[0] = quantum.measure(q[0])  # Before array is consumed",
-        ]
-
-        # Look for array access patterns in the code
-        for i, line in enumerate(self.code_lines):
-            if (
-                "measure_array" in line
-                and "["
-                in self.code_lines[
-                    min(i + 1, len(self.code_lines) - 1) : min(
-                        i + 5,
-                        len(self.code_lines),
-                    )
-                ]
-            ):
-                lines.append(f"\nPotential issue found around line {i+1}:")
-                lines.append(f"  {line.strip()}")
-
-        lines.append(f"\nOriginal error: {error_str}")
-        lines.append(f"{'='*60}\n")
-
-        return "\n".join(lines)
-
-    def _format_generic_error(self, error_type: str, error_str: str) -> str:
-        """Format a generic error with basic diagnostics."""
-        lines = [
-            f"\n{'='*60}",
-            f"HUGR Compilation Error: {error_type}",
-            f"{'='*60}\n",
-            f"Error details: {error_str}",
-            "\nGeneral troubleshooting tips:",
-            "  1. Check that all quantum registers are consumed (measured)",
-            "  2. Ensure variables don't conflict with reserved names (result, array, quantum)",
-            "  3. Verify array operations happen before the array is consumed",
-            "  4. Check function parameter types and ownership annotations",
-            "\nFor more specific help, please check the error message above.",
-            f"{'='*60}\n",
-        ]
-
-        return "\n".join(lines)
-
-    def _find_code_context(self, var_name: str | None) -> list[ErrorContext]:
-        """Find relevant code lines for a variable."""
-        if not var_name:
-            return []
-
-        contexts = []
-        for i, line in enumerate(self.code_lines):
-            if var_name in line:
-                contexts.append(
-                    ErrorContext(
-                        line_number=i + 1,
-                        line_content=line,
-                        variable_name=var_name,
-                    ),
-                )
-
-        return contexts
diff --git a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/ir.py b/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/ir.py
deleted file mode 100644
index db700a003..000000000
--- a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/ir.py
+++ /dev/null
@@ -1,680 +0,0 @@
-"""Intermediate Representation for Guppy code generation.
-
-This module provides an IR that allows us to analyze and transform code
-before generating the final Guppy output.
-"""
-
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from dataclasses import dataclass, field
-from enum import Enum
-from typing import Any, ClassVar
-
-
-class ResourceState(Enum):
-    """State of a quantum resource."""
-
-    AVAILABLE = "available"
-    CONSUMED = "consumed"
-    BORROWED = "borrowed"
-
-
-@dataclass
-class VariableInfo:
-    """Information about a variable."""
-
-    name: str
-    original_name: str  # Before renaming
-    var_type: str  # "quantum", "classical", etc.
-    size: int | None = None
-    is_array: bool = False
-    is_unpacked: bool = False
-    unpacked_names: list[str] = field(default_factory=list)
-    state: ResourceState = ResourceState.AVAILABLE
-    is_struct: bool = False
-    struct_info: dict | None = None
-    is_struct_field: bool = False
-    struct_name: str | None = None
-    field_name: str | None = None
-
-
-@dataclass
-class ScopeContext:
-    """Context for a scope (function, block, etc.)."""
-
-    parent: ScopeContext | None = None
-    variables: dict[str, VariableInfo] = field(default_factory=dict)
-    unpacked_arrays: dict[str, list[str]] = field(default_factory=dict)
-    consumed_resources: set[str] = field(default_factory=set)
-    refreshed_arrays: dict[str, str] = field(
-        default_factory=dict,
-    )  # original_name -> fresh_name
-
-    def lookup_variable(self, name: str) -> VariableInfo | None:
-        """Look up a variable in this scope or parent scopes."""
-        if name in self.variables:
-            return self.variables[name]
-
-        # Check if this variable was refreshed by a function call
-        if name in self.refreshed_arrays:
-            fresh_name = self.refreshed_arrays[name]
-            if fresh_name in self.variables:
-                return self.variables[fresh_name]
-
-        if self.parent:
-            return self.parent.lookup_variable(name)
-        return None
-
-    def add_variable(self, var_info: VariableInfo) -> None:
-        """Add a variable to this scope."""
-        self.variables[var_info.name] = var_info
-
-    def mark_consumed(self, name: str) -> None:
-        """Mark a resource as consumed."""
-        self.consumed_resources.add(name)
-        var = self.lookup_variable(name)
-        if var:
-            var.state = ResourceState.CONSUMED
-
-
-class IRNode(ABC):
-    """Base class for all IR nodes."""
-
-    @abstractmethod
-    def analyze(self, context: ScopeContext) -> None:
-        """Analyze this node for resource usage, unpacking needs, etc."""
-
-    @abstractmethod
-    def render(self, context: ScopeContext) -> list[str]:
-        """Render this node to Guppy code lines."""
-
-
-@dataclass
-class ArrayAccess(IRNode):
-    """Represents array[index] access."""
-
-    array_name: str = None  # Optional for backwards compatibility
-    array: IRNode = None  # Can be a FieldAccess for struct.field[index]
-    index: int | str | IRNode = None
-    force_array_syntax: bool = False  # If True, never use unpacked names
-
-    def __post_init__(self):
-        """Initialize ArrayAccess, supporting both old and new API."""
-        # Support both old and new API
-        if self.array_name and not self.array:
-            self.array = VariableRef(self.array_name)
-
-    def analyze(self, context: ScopeContext) -> None:
-        """Mark that this array needs element access."""
-        if self.array:
-            self.array.analyze(context)
-
-    def render(self, context: ScopeContext) -> list[str]:
-        """Render array access, using unpacked name if available."""
-        # Handle old API
-        if self.array_name and not self.force_array_syntax:
-            var = context.lookup_variable(self.array_name)
-            if var and var.is_unpacked and isinstance(self.index, int) and self.index < len(var.unpacked_names):
-                return [var.unpacked_names[self.index]]
-
-        # Render array if it's an IRNode (e.g., FieldAccess)
-        if self.array:
-            array_code = self.array.render(context)
-            array_str = array_code[0] if len(array_code) == 1 else "???"
-        else:
-            array_str = self.array_name
-
-        # Render index if it's an IRNode
-        if isinstance(self.index, IRNode):
-            index_code = self.index.render(context)
-            if len(index_code) == 1:
-                return [f"{array_str}[{index_code[0]}]"]
-            # Complex index expression - shouldn't happen usually
-            return [f"{array_str}[{' '.join(index_code)}]"]
-
-        return [f"{array_str}[{self.index}]"]
-
-
-@dataclass
-class FieldAccess(IRNode):
-    """Access to a struct field: obj.field"""
-
-    obj: IRNode
-    field: str
-
-    def analyze(self, context: ScopeContext) -> None:
-        """Analyze the object being accessed."""
-        self.obj.analyze(context)
-
-    def render(self, context: ScopeContext) -> list[str]:
-        """Render field access as obj.field."""
-        obj_code = self.obj.render(context)
-        obj_str = obj_code[0] if len(obj_code) == 1 else "???"
-        return [f"{obj_str}.{self.field}"]
-
-
-@dataclass
-class VariableRef(IRNode):
-    """Reference to a variable."""
-
-    name: str
-
-    def analyze(self, context: ScopeContext) -> None:
-        """Check variable exists."""
-        # Nothing to analyze for a simple variable reference
-
-    def render(self, context: ScopeContext) -> list[str]:
-        """Render variable reference."""
-        var = context.lookup_variable(self.name)
-
-        if var:
-            return [var.name]  # Use potentially renamed name
-        return [self.name]
-
-
-@dataclass
-class Literal(IRNode):
-    """Literal value."""
-
-    value: Any
-
-    def analyze(self, context: ScopeContext) -> None:
-        """Analyze literal - no-op as literals don't need analysis."""
-        # Nothing to analyze for literals
-
-    def render(self, context: ScopeContext) -> list[str]:
-        _ = context  # Context not needed for literal rendering
-        if isinstance(self.value, bool):
-            return ["True" if self.value else "False"]
-        if isinstance(self.value, str):
-            return [f'"{self.value}"']
-        return [str(self.value)]
-
-
-@dataclass
-class Statement(IRNode):
-    """Base class for statements."""
-
-
-@dataclass
-class Expression(IRNode):
-    """Base class for expressions."""
-
-
-@dataclass
-class BinaryOp(Expression):
-    """Binary operation: left op right."""
-
-    left: IRNode
-    op: str
-    right: IRNode
-    needs_parens: bool = False  # Track if this expression needs parentheses
-
-    # Operator precedence (higher number = higher precedence)
-    PRECEDENCE: ClassVar[dict[str, int]] = {
-        "or": 1,
-        "|": 1,
-        "and": 2,
-        "&": 2,
-        "^": 3,
-        "==": 4,
-        "!=": 4,
-        "<": 4,
-        ">": 4,
-        "<=": 4,
-        ">=": 4,
-        "+": 5,
-        "-": 5,
-        "*": 6,
-        "/": 6,
-        "//": 6,
-        "%": 6,
-        "**": 7,
-    }
-
-    def analyze(self, context: ScopeContext) -> None:
-        """Analyze both operands."""
-        self.left.analyze(context)
-        self.right.analyze(context)
-
-    def _needs_parens(self, child: IRNode, *, is_right: bool = False) -> bool:
-        """Check if child expression needs parentheses."""
-        if not isinstance(child, BinaryOp):
-            return False
-
-        child_prec = self.PRECEDENCE.get(child.op, 10)
-        self_prec = self.PRECEDENCE.get(self.op, 10)
-
-        # Lower precedence needs parens
-        if child_prec < self_prec:
-            return True
-        # Same precedence: check associativity (left-to-right)
-        # For operators like -, /, we need parens on the right
-        return child_prec == self_prec and is_right and self.op in ["-", "/", "//", "%"]
-
-    def render(self, context: ScopeContext) -> list[str]:
-        """Render binary operation with proper precedence handling."""
-        # Render children
-        left_code = self.left.render(context)
-        right_code = self.right.render(context)
-
-        # Add parentheses if needed for children
-        left_str = left_code[0] if len(left_code) == 1 else " ".join(left_code)
-        right_str = right_code[0] if len(right_code) == 1 else " ".join(right_code)
-
-        if self._needs_parens(self.left):
-            left_str = f"({left_str})"
-        if self._needs_parens(self.right, is_right=True):
-            right_str = f"({right_str})"
-
-        result = f"{left_str} {self.op} {right_str}"
-
-        # Add parentheses if this expression was marked as needing them
-        if self.needs_parens:
-            result = f"({result})"
-
-        return [result]
-
-
-@dataclass
-class UnaryOp(Expression):
-    """Unary operation: op operand."""
-
-    op: str
-    operand: IRNode
-
-    def analyze(self, context: ScopeContext) -> None:
-        """Analyze the operand."""
-        self.operand.analyze(context)
-
-    def render(self, context: ScopeContext) -> list[str]:
-        """Render unary operation."""
-        operand_code = self.operand.render(context)
-        if len(operand_code) == 1:
-            return [f"{self.op} {operand_code[0]}"]
-        # For complex expressions, use parentheses
-        return [f"{self.op} ({' '.join(operand_code)})"]
-
-
-@dataclass
-class Assignment(Statement):
-    """Assignment statement: target = value."""
-
-    target: IRNode
-    value: IRNode
-
-    def analyze(self, context: ScopeContext) -> None:
-        """Analyze both target and value."""
-        self.target.analyze(context)
-        self.value.analyze(context)
-
-    def render(self, context: ScopeContext) -> list[str]:
-        target_code = self.target.render(context)
-        value_code = self.value.render(context)
-        if len(target_code) == 1 and len(value_code) == 1:
-            return [f"{target_code[0]} = {value_code[0]}"]
-        # Handle multi-line expressions
-        result = value_code[:-1]  # All but last line
-        result.append(f"{target_code[0]} = {value_code[-1]}")
-        return result
-
-
-@dataclass
-class FunctionCall(Expression):
-    """Function call expression."""
-
-    func_name: str
-    args: list[IRNode]
-
-    def analyze(self, context: ScopeContext) -> None:
-        for arg in self.args:
-            arg.analyze(context)
-
-    def render(self, context: ScopeContext) -> list[str]:
-        arg_strs = []
-        for arg in self.args:
-            arg_code = arg.render(context)
-            arg_strs.append(arg_code[0] if len(arg_code) == 1 else "???")
-        return [f"{self.func_name}({', '.join(arg_strs)})"]
-
-
-@dataclass
-class MethodCall(Expression):
-    """Method call: obj.method(args)."""
-
-    obj: IRNode
-    method: str
-    args: list[IRNode]
-
-    def analyze(self, context: ScopeContext) -> None:
-        self.obj.analyze(context)
-        for arg in self.args:
-            arg.analyze(context)
-
-    def render(self, context: ScopeContext) -> list[str]:
-        obj_code = self.obj.render(context)
-        arg_strs = []
-        for arg in self.args:
-            arg_code = arg.render(context)
-            arg_strs.append(arg_code[0] if len(arg_code) == 1 else "???")
-
-        obj_str = obj_code[0] if len(obj_code) == 1 else "???"
-        return [f"{obj_str}.{self.method}({', '.join(arg_strs)})"]
-
-
-@dataclass
-class Measurement(Statement):
-    """Measurement operation."""
-
-    qubit: IRNode
-    target: IRNode | None = None
-
-    def analyze(self, context: ScopeContext) -> None:
-        self.qubit.analyze(context)
-        if self.target:
-            self.target.analyze(context)
-
-        # Mark qubit as consumed if it's a simple reference
-        if isinstance(self.qubit, VariableRef):
-            context.mark_consumed(self.qubit.name)
-        elif isinstance(self.qubit, ArrayAccess):
-            # Track that this array element is consumed
-            pass
-
-    def render(self, context: ScopeContext) -> list[str]:
-        qubit_code = self.qubit.render(context)
-        qubit_str = qubit_code[0] if len(qubit_code) == 1 else "???"
-
-        if self.target:
-            target_code = self.target.render(context)
-            target_str = target_code[0] if len(target_code) == 1 else "???"
-            return [f"{target_str} = quantum.measure({qubit_str})"]
-        return [f"quantum.measure({qubit_str})"]
-
-
-@dataclass
-class ArrayUnpack(Statement):
-    """Array unpacking: a, b, c = array."""
-
-    targets: list[str]
-    source: str
-
-    def analyze(self, context: ScopeContext) -> None:
-        # Mark the array as unpacked
-        var = context.lookup_variable(self.source)
-        if var:
-            var.is_unpacked = True
-            var.unpacked_names = self.targets
-
-    def render(self, context: ScopeContext) -> list[str]:
-        _ = context  # Context not needed for unpacking
-        if len(self.targets) == 1:
-            # Special syntax for single element
-            return [f"{self.targets[0]}, = {self.source}"]
-        return [f"{', '.join(self.targets)} = {self.source}"]
-
-
-@dataclass
-class Comment(Statement):
-    """Comment line."""
-
-    text: str
-
-    def analyze(self, context: ScopeContext) -> None:
-        """Analyze comment - no-op."""
-        # Nothing to analyze for comments
-
-    def render(self, context: ScopeContext) -> list[str]:
-        """Render comment line."""
-        _ = context  # Context not needed for comments
-        if self.text:
-            return [f"# {self.text}"]
-        return []  # Don't render empty comments
-
-
-@dataclass
-class ReturnStatement(Statement):
-    """Return statement."""
-
-    value: IRNode | None = None
-
-    def analyze(self, context: ScopeContext) -> None:
-        """Analyze return value if present."""
-        if self.value:
-            self.value.analyze(context)
-
-    def render(self, context: ScopeContext) -> list[str]:
-        """Render return statement."""
-        if self.value:
-            value_code = self.value.render(context)
-            return [f"return {value_code[0]}"]
-        return ["return"]
-
-
-@dataclass
-class TupleExpression(Expression):
-    """Tuple expression for multiple returns."""
-
-    elements: list[IRNode]
-
-    def analyze(self, context: ScopeContext) -> None:
-        """Analyze all elements."""
-        for elem in self.elements:
-            elem.analyze(context)
-
-    def render(self, context: ScopeContext) -> list[str]:
-        """Render tuple expression."""
-        elem_codes = [elem.render(context)[0] for elem in self.elements]
-        return [", ".join(elem_codes)]  # No parentheses needed for tuple returns
-
-
-@dataclass
-class Block(IRNode):
-    """Block of statements."""
-
-    statements: list[Statement] = field(default_factory=list)
-
-    def analyze(self, context: ScopeContext) -> None:
-        for stmt in self.statements:
-            stmt.analyze(context)
-
-    def render(self, context: ScopeContext) -> list[str]:
-        lines = []
-        for stmt in self.statements:
-            lines.extend(stmt.render(context))
-        return lines
-
-
-@dataclass
-class IfStatement(Statement):
-    """If statement with optional else."""
-
-    condition: IRNode
-    then_block: Block
-    else_block: Block | None = None
-
-    def analyze(self, context: ScopeContext) -> None:
-        self.condition.analyze(context)
-
-        # Create new scope for then block
-        then_context = ScopeContext(parent=context)
-        self.then_block.analyze(then_context)
-
-        if self.else_block:
-            # Create new scope for else block
-            else_context = ScopeContext(parent=context)
-            self.else_block.analyze(else_context)
-
-    def render(self, context: ScopeContext) -> list[str]:
-        lines = []
-
-        # Render condition
-        cond_code = self.condition.render(context)
-        cond_str = cond_code[0] if len(cond_code) == 1 else "???"
-        lines.append(f"if {cond_str}:")
-
-        # Render then block (indented)
-        then_lines = self.then_block.render(context)
-        if then_lines:
-            lines.extend(f"    {line}" for line in then_lines)
-        else:
-            lines.append("    pass")
-
-        # Render else block if present
-        if self.else_block:
-            lines.append("else:")
-            else_lines = self.else_block.render(context)
-            if else_lines:
-                lines.extend(f"    {line}" for line in else_lines)
-            else:
-                lines.append("    pass")
-
-        return lines
-
-
-@dataclass
-class WhileStatement(Statement):
-    """While loop statement."""
-
-    condition: IRNode
-    body: Block
-
-    def analyze(self, context: ScopeContext) -> None:
-        self.condition.analyze(context)
-        # Create new scope for loop body
-        loop_context = ScopeContext(parent=context)
-        self.body.analyze(loop_context)
-
-    def render(self, context: ScopeContext) -> list[str]:
-        lines = []
-
-        # Render condition
-        cond_code = self.condition.render(context)
-        cond_str = cond_code[0] if len(cond_code) == 1 else "???"
-        lines.append(f"while {cond_str}:")
-
-        # Render body (indented)
-        body_lines = self.body.render(context)
-        if body_lines:
-            lines.extend(f"    {line}" for line in body_lines)
-        else:
-            lines.append("    pass")
-
-        return lines
-
-
-@dataclass
-class ForStatement(Statement):
-    """For loop statement."""
-
-    loop_var: str
-    iterable: IRNode
-    body: Block
-
-    def analyze(self, context: ScopeContext) -> None:
-        # Analyze iterable
-        self.iterable.analyze(context)
-
-        # Create new scope for loop body with loop variable
-        loop_context = ScopeContext(parent=context)
-        # Add loop variable to context (simplified - would need type info)
-        self.body.analyze(loop_context)
-
-    def render(self, context: ScopeContext) -> list[str]:
-        lines = []
-
-        # Render iterable
-        iter_code = self.iterable.render(context)
-        iter_str = iter_code[0] if len(iter_code) == 1 else "???"
-        lines.append(f"for {self.loop_var} in {iter_str}:")
-
-        # Render body (indented)
-        body_lines = self.body.render(context)
-        if body_lines:
-            lines.extend(f"    {line}" for line in body_lines)
-        else:
-            lines.append("    pass")
-
-        return lines
-
-
-@dataclass
-class Function(IRNode):
-    """Function definition."""
-
-    name: str
-    params: list[tuple[str, str]]  # [(name, type), ...]
-    return_type: str
-    body: Block
-    decorators: list[str] = field(default_factory=list)
-
-    def analyze(self, context: ScopeContext) -> None:
-        # Create new scope for function
-        func_context = ScopeContext(parent=context)
-
-        # Add parameters to scope
-        for param_name, param_type in self.params:
-            var_info = VariableInfo(
-                name=param_name,
-                original_name=param_name,
-                var_type=param_type,
-            )
-            func_context.add_variable(var_info)
-
-        # Analyze body
-        self.body.analyze(func_context)
-
-    def render(self, context: ScopeContext) -> list[str]:
-        lines = []
-
-        # Decorators
-        lines.extend(f"@{decorator}" for decorator in self.decorators)
-
-        # Function signature
-        param_strs = []
-        for name, ptype in self.params:
-            param_strs.append(f"{name}: {ptype}")
-
-        lines.append(f"def {self.name}({', '.join(param_strs)}) -> {self.return_type}:")
-
-        # Body
-        body_lines = self.body.render(context)
-        if body_lines:
-            lines.extend(f"    {line}" for line in body_lines)
-        else:
-            lines.append("    pass")
-
-        return lines
-
-
-@dataclass
-class Module(IRNode):
-    """Module containing imports and definitions."""
-
-    imports: list[str] = field(default_factory=list)
-    functions: list[Function] = field(default_factory=list)
-    refreshed_arrays: dict[str, set[str]] = field(
-        default_factory=dict,
-    )  # function_name -> set of refreshed array names
-
-    def analyze(self, context: ScopeContext) -> None:
-        for func in self.functions:
-            func.analyze(context)
-
-    def render(self, context: ScopeContext) -> list[str]:
-        lines = []
-
-        # Imports
-        lines.extend(self.imports)
-
-        if self.imports and self.functions:
-            lines.append("")  # Blank line between imports and code
-
-        # Functions
-        for i, func in enumerate(self.functions):
-            if i > 0:
-                lines.append("")  # Blank line between functions
-            lines.extend(func.render(context))
-
-        return lines
diff --git a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/ir_analyzer.py b/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/ir_analyzer.py
deleted file mode 100644
index 954ddf13e..000000000
--- a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/ir_analyzer.py
+++ /dev/null
@@ -1,362 +0,0 @@
-"""Analyzer for determining array unpacking and other transformations needed."""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any
-
-if TYPE_CHECKING:
-    from pecos.slr import Block as SLRBlock
-
-
-@dataclass
-class ArrayAccessInfo:
-    """Information about how an array is accessed."""
-
-    array_name: str
-    size: int
-    is_classical: bool = False  # Track if this is a CReg
-
-    # Track individual element accesses
-    element_accesses: set[int] = field(default_factory=set)
-    element_access_positions: dict[int, list[int]] = field(default_factory=dict)
-
-    # Track full array accesses
-    full_array_accesses: list[int] = field(default_factory=list)
-
-    # Track if passed to blocks
-    passed_to_blocks: bool = False
-
-    # Track operations between accesses
-    has_operations_between: bool = False
-    has_conditionals_between: bool = False
-
-    # NEW: Track which specific elements are conditionally accessed
-    # This is more precise than the boolean flag above
-    conditionally_accessed_elements: set[int] = field(default_factory=set)
-
-    # Consumption info
-    elements_consumed: set[int] = field(default_factory=set)
-    fully_consumed: bool = False
-    consumed_at_position: int | None = None
-
-    @property
-    def has_individual_access(self) -> bool:
-        """Check if array has individual element access."""
-        return len(self.element_accesses) > 0
-
-    @property
-    def all_elements_accessed(self) -> bool:
-        """Check if all elements are accessed."""
-        return len(self.element_accesses) == self.size
-
-    @property
-    def needs_unpacking(self) -> bool:
-        """Determine if this array needs unpacking.
-
-        This uses a rule-based decision tree for clearer, more maintainable logic.
-        See unpacking_rules.py for the detailed decision tree implementation.
-        """
-        from pecos.slr.gen_codes.guppy.unpacking_rules import should_unpack_array
-
-        return should_unpack_array(self)
-
-
-@dataclass
-class UnpackingPlan:
-    """Plan for unpacking arrays in a scope."""
-
-    arrays_to_unpack: dict[str, ArrayAccessInfo] = field(default_factory=dict)
-    unpack_at_start: set[str] = field(default_factory=set)
-    renamed_variables: dict[str, str] = field(default_factory=dict)
-    # Store all analyzed arrays, including those that don't need unpacking
-    all_analyzed_arrays: dict[str, ArrayAccessInfo] = field(default_factory=dict)
-
-
-class IRAnalyzer:
-    """Analyzes SLR blocks to determine IR transformations needed."""
-
-    def __init__(self):
-        self.array_info: dict[str, ArrayAccessInfo] = {}
-        self.position_counter = 0
-        self.in_conditional = False
-        self.reserved_names = {"result", "array", "quantum", "guppy", "owned"}
-        self.has_nested_blocks = False
-
-    def analyze_block(
-        self,
-        block: SLRBlock,
-        variable_context: dict[str, Any],
-    ) -> UnpackingPlan:
-        """Analyze a block and return unpacking plan."""
-        plan = UnpackingPlan()
-
-        # Reset state
-        self.array_info.clear()
-        self.position_counter = 0
-
-        # First, collect array information from variables
-        self._collect_array_info(block, variable_context)
-
-        # Perform data flow analysis to get precise information
-        from pecos.slr.gen_codes.guppy.data_flow import DataFlowAnalyzer
-
-        data_flow_analyzer = DataFlowAnalyzer()
-        data_flow = data_flow_analyzer.analyze(block, variable_context)
-
-        # Analyze operations to determine access patterns
-        if hasattr(block, "ops"):
-            for op in block.ops:
-                self._analyze_operation(op)
-                self.position_counter += 1
-
-        # Update array info with data flow analysis results
-        self._integrate_data_flow(data_flow)
-
-        # Determine which arrays need unpacking
-        # Special case: if we have nested blocks but @owned parameters, we must unpack
-        # because @owned parameters require unpacking to access elements
-        must_unpack_for_owned = hasattr(self, "has_nested_blocks_with_owned") and self.has_nested_blocks_with_owned
-
-        # Store all analyzed arrays in the plan
-        plan.all_analyzed_arrays = self.array_info.copy()
-
-        if not self.has_nested_blocks or must_unpack_for_owned:
-            for array_name, info in self.array_info.items():
-                should_unpack = info.needs_unpacking
-
-                # Force unpacking for @owned parameters even with nested blocks
-                if (
-                    must_unpack_for_owned
-                    and hasattr(self, "expected_owned_params")
-                    and array_name in self.expected_owned_params
-                ):
-                    should_unpack = True
-
-                if should_unpack:
-                    plan.arrays_to_unpack[array_name] = info
-                    plan.unpack_at_start.add(array_name)
-
-        # Check for variable name conflicts
-        self._check_name_conflicts(block, plan)
-
-        return plan
-
-    def _collect_array_info(
-        self,
-        block: SLRBlock,
-        variable_context: dict[str, Any],
-    ) -> None:
-        """Collect information about arrays in the block."""
-        # From block variables
-        if hasattr(block, "vars"):
-            for var in block.vars:
-                var_type = type(var).__name__
-                if var_type in ["QReg", "CReg"] and hasattr(var, "sym") and hasattr(var, "size"):
-                    self.array_info[var.sym] = ArrayAccessInfo(
-                        array_name=var.sym,
-                        size=var.size,
-                        is_classical=(var_type == "CReg"),
-                    )
-
-        # From variable context
-        if variable_context:
-            for var_name, var in variable_context.items():
-                var_type = type(var).__name__
-                if var_type in ["QReg", "CReg"] and hasattr(var, "size") and var_name not in self.array_info:
-                    self.array_info[var_name] = ArrayAccessInfo(
-                        array_name=var_name,
-                        size=var.size,
-                        is_classical=(var_type == "CReg"),
-                    )
-
-    def _analyze_operation(self, op: Any) -> None:
-        """Analyze a single operation."""
-        op_type = type(op).__name__
-
-        if op_type == "Measure":
-            self._analyze_measurement(op)
-        elif op_type == "If":
-            self._analyze_if_block(op)
-        elif hasattr(op, "qargs"):
-            self._analyze_quantum_operation(op)
-        elif hasattr(op, "ops"):
-            # Check if this is a nested Block
-            if hasattr(op, "__class__"):
-                from pecos.slr import Block as SlrBlock
-
-                try:
-                    if issubclass(op.__class__, SlrBlock):
-                        # Mark that we have nested blocks
-                        self.has_nested_blocks = True
-                except (TypeError, AttributeError):
-                    # Not a class or doesn't have expected attributes
-                    pass
-
-            # Nested block - recurse into its operations
-            for nested_op in op.ops:
-                self._analyze_operation(nested_op)
-
-    def _analyze_measurement(self, meas: Any) -> None:
-        """Analyze a measurement operation."""
-        # Analyze classical targets if present
-        if hasattr(meas, "cout") and meas.cout:
-            for cout in meas.cout:
-                if hasattr(cout, "reg") and hasattr(cout.reg, "sym"):
-                    array_name = cout.reg.sym
-                    if array_name in self.array_info and hasattr(cout, "index"):
-                        info = self.array_info[array_name]
-                        # Track individual classical element access
-                        info.element_accesses.add(cout.index)
-
-        # Analyze quantum sources
-        if hasattr(meas, "qargs") and meas.qargs:
-            for qarg in meas.qargs:
-                # Handle full array measurement (QReg directly)
-                if hasattr(qarg, "sym") and hasattr(qarg, "size"):
-                    array_name = qarg.sym
-                    if array_name in self.array_info:
-                        info = self.array_info[array_name]
-                        # Full array measurement
-                        info.full_array_accesses.append(self.position_counter)
-                        info.fully_consumed = True
-                        info.consumed_at_position = self.position_counter
-
-                        # Mark all elements as consumed
-                        for i in range(info.size):
-                            info.elements_consumed.add(i)
-
-                # Handle individual element measurement (Qubit with reg)
-                elif hasattr(qarg, "reg") and hasattr(qarg.reg, "sym"):
-                    array_name = qarg.reg.sym
-                    if array_name in self.array_info:
-                        info = self.array_info[array_name]
-
-                        if hasattr(qarg, "index"):
-                            # Individual element measurement
-                            index = qarg.index
-                            info.element_accesses.add(index)
-                            info.elements_consumed.add(index)
-
-                            if index not in info.element_access_positions:
-                                info.element_access_positions[index] = []
-                            info.element_access_positions[index].append(
-                                self.position_counter,
-                            )
-
-    def _analyze_quantum_operation(self, op: Any) -> None:
-        """Analyze a quantum operation (gate, etc.)."""
-        if hasattr(op, "qargs") and op.qargs:
-            for qarg in op.qargs:
-                if hasattr(qarg, "reg") and hasattr(qarg.reg, "sym"):
-                    array_name = qarg.reg.sym
-                    if array_name in self.array_info:
-                        info = self.array_info[array_name]
-
-                        if hasattr(qarg, "index"):
-                            # Individual element access
-                            index = qarg.index
-                            info.element_accesses.add(index)
-
-                            if index not in info.element_access_positions:
-                                info.element_access_positions[index] = []
-                            info.element_access_positions[index].append(
-                                self.position_counter,
-                            )
-
-                            # Check if there are measurements before this
-                            if info.elements_consumed:
-                                info.has_operations_between = True
-
-    def _analyze_if_block(self, if_block: Any) -> None:
-        """Analyze an if block."""
-        prev_conditional = self.in_conditional
-        self.in_conditional = True
-
-        # Check condition for array accesses
-        if hasattr(if_block, "cond"):
-            self._analyze_condition(if_block.cond)
-
-        # Analyze then block
-        if hasattr(if_block, "ops"):
-            for op in if_block.ops:
-                self._analyze_operation(op)
-
-        # Analyze else block
-        if hasattr(if_block, "else_block") and if_block.else_block and hasattr(if_block.else_block, "ops"):
-            for op in if_block.else_block.ops:
-                self._analyze_operation(op)
-
-        self.in_conditional = prev_conditional
-
-        # Mark arrays used in conditionals
-        if self.in_conditional:
-            for info in self.array_info.values():
-                if info.element_accesses:
-                    info.has_conditionals_between = True
-
-    def _analyze_condition(self, cond: Any) -> None:
-        """Analyze a condition expression."""
-        # Look for array accesses in conditions
-        cond_type = type(cond).__name__
-
-        if cond_type == "Bit":
-            if hasattr(cond, "reg") and hasattr(cond.reg, "sym"):
-                array_name = cond.reg.sym
-                if array_name in self.array_info and hasattr(cond, "index"):
-                    info = self.array_info[array_name]
-                    info.element_accesses.add(cond.index)
-                    info.has_conditionals_between = True
-
-        # Handle compound conditions
-        elif hasattr(cond, "left"):
-            self._analyze_condition(cond.left)
-        if hasattr(cond, "right"):
-            self._analyze_condition(cond.right)
-
-    def _check_name_conflicts(self, block: SLRBlock, plan: UnpackingPlan) -> None:
-        """Check for variable names that conflict with reserved words."""
-        if hasattr(block, "vars"):
-            for var in block.vars:
-                if hasattr(var, "sym") and var.sym in self.reserved_names:
-                    # Need to rename this variable
-                    new_name = f"{var.sym}_reg"
-                    plan.renamed_variables[var.sym] = new_name
-
-    def _integrate_data_flow(self, data_flow) -> None:
-        """Integrate data flow analysis results into array access info.
-
-        This provides more precise information about operations between accesses,
-        reducing false positives from the heuristic analysis.
-
-        Args:
-            data_flow: DataFlowAnalysis from the data flow analyzer
-        """
-        from pecos.slr.gen_codes.guppy.data_flow import DataFlowAnalysis
-
-        if not isinstance(data_flow, DataFlowAnalysis):
-            return
-
-        # For each array element in the data flow analysis
-        for (array_name, index), flow_info in data_flow.element_flows.items():
-            if array_name in self.array_info:
-                info = self.array_info[array_name]
-
-                # Update has_operations_between with precise data flow information
-                # Only set to True if THIS SPECIFIC element is used after its own measurement
-                if flow_info.has_use_after_consumption():
-                    # Mark that THIS array has operations between for THIS element
-                    # This is more precise than the heuristic which marks the whole array
-                    info.has_operations_between = True
-
-        # Also check conditional accesses from data flow
-        for array_name, index in data_flow.conditional_accesses:
-            if array_name in self.array_info:
-                info = self.array_info[array_name]
-                # NEW: Track the specific element that is conditionally accessed
-                info.conditionally_accessed_elements.add(index)
-
-                # Keep the old flag for backward compatibility
-                # But now we have more precise information in conditionally_accessed_elements
-                if index in info.element_accesses:
-                    info.has_conditionals_between = True
diff --git a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/ir_builder.py b/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/ir_builder.py
deleted file mode 100644
index 5163a275e..000000000
--- a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/ir_builder.py
+++ /dev/null
@@ -1,9360 +0,0 @@
-"""Builder for converting SLR operations to IR.
-
-IMPORTANT LIMITATION - Partial Consumption in Loops:
-====================================================
-
-The current implementation returns ONLY unconsumed array elements from functions.
-This works correctly for most patterns, but has a known limitation with certain
-verification loop patterns (e.g., Steane code).
-
-WORKING PATTERN (Partial Consumption):
---------------------------------------
-def process_qubits(q: array[quantum.qubit, 4] @owned) -> array[quantum.qubit, 2]:
-    # Measures q[0] and q[2], returns q[1] and q[3]
-    # Return type correctly reflects only unconsumed elements
-
-PROBLEMATIC PATTERN (Verification Ancillas in Loops):
------------------------------------------------------
-def verify(ancilla: array[qubit, 3] @owned) -> tuple[array[qubit, 2], ...]:
-    # Measures ancilla[0], creates fresh qubit at ancilla[0]
-    # Returns ONLY ancilla[1] and ancilla[2] (unconsumed elements)
-    # Fresh qubit is NOT returned (it's an automatic replacement for linearity)
-
-# In calling function:
-for _ in range(2):
-    ancilla_returned = verify(ancilla)  # ERROR: Returns size 2, needs size 3
-
-WHY THIS HAPPENS:
-- Automatic qubit replacements (lines 2966-2977) are created for Guppy's linear
-  type system, not for meaningful quantum operations
-- The replacement qubit is not semantically part of the verification result
-- Only unconsumed elements (ancilla[1], ancilla[2]) are returned
-- This creates a size mismatch in subsequent loop iterations
-
-ARCHITECTURAL SOLUTIONS:
-- Don't use partial consumption for verification ancillas that need reuse
-- Use separate ancilla qubits instead of array elements for verification
-- Or restructure the verification pattern to avoid the loop issue
-
-See tests/slr_tests/guppy/test_partial_array_returns.py for correct usage patterns.
-"""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any, ClassVar
-
-if TYPE_CHECKING:
-    from pecos.slr import Block as SLRBlock
-    from pecos.slr.gen_codes.guppy.ir import IRNode
-    from pecos.slr.gen_codes.guppy.ir_analyzer import UnpackingPlan
-    from pecos.slr.gen_codes.guppy.unified_resource_planner import (
-        UnifiedResourceAnalysis,
-    )
-
-# AllocationOptimizer removed - now using UnifiedResourceAnalysis directly
-from pecos.slr.gen_codes.guppy.ir import (
-    ArrayAccess,
-    ArrayUnpack,
-    Assignment,
-    BinaryOp,
-    Block,
-    Comment,
-    Expression,
-    FieldAccess,
-    ForStatement,
-    Function,
-    FunctionCall,
-    IfStatement,
-    Literal,
-    Measurement,
-    Module,
-    ResourceState,
-    ReturnStatement,
-    ScopeContext,
-    Statement,
-    TupleExpression,
-    UnaryOp,
-    VariableInfo,
-    VariableRef,
-    WhileStatement,
-)
-from pecos.slr.gen_codes.guppy.qubit_usage_analyzer import QubitRole, QubitUsageAnalyzer
-from pecos.slr.gen_codes.guppy.scope_manager import (
-    ResourceUsage,
-    ScopeManager,
-    ScopeType,
-)
-
-
-class IRBuilder:
-    """Builds IR from SLR operations."""
-
-    # Core blocks that should remain as control flow (not converted to functions)
-    CORE_BLOCKS: ClassVar[set[str]] = {
-        "If",
-        "Repeat",
-        "While",
-        "For",
-        "Main",
-        "Block",
-        "Comment",
-        "Barrier",
-    }
-
-    def __init__(
-        self,
-        unpacking_plan: UnpackingPlan,
-        *,
-        unified_analysis: UnifiedResourceAnalysis | None = None,
-        include_optimization_report: bool = False,
-    ):
-        self.plan = unpacking_plan
-        self.unified_analysis = unified_analysis
-        self.context = ScopeContext()
-        self.scope_manager = ScopeManager()
-        self.current_block: Block | None = None
-        # AllocationOptimizer removed - using UnifiedResourceAnalysis directly
-        self.include_optimization_report = include_optimization_report
-
-        # Track arrays that have been refreshed by function calls
-        # Maps original array name -> fresh returned name
-        self.refreshed_arrays = {}
-        # Track which function refreshed each array
-        # Maps original array name -> function name that refreshed it
-        self.refreshed_by_function = {}
-
-        # Track conditionally consumed variables (e.g., in if blocks)
-        # Maps original variable -> conditionally consumed version
-        self.conditional_fresh_vars = {}
-
-        # Track blocks for function generation
-        self.block_registry = {}  # Maps block signature to function name
-        self.pending_functions = []  # Functions to be generated
-        self.generated_functions = set()  # Functions already generated (actually built)
-        self.discovered_functions = set()  # Functions discovered but maybe not built yet
-        self.function_counter = 0  # For generating unique function names
-        self.function_info = {}  # Track metadata about functions
-        self.function_return_types = {}  # Maps function name to return type
-
-        # Struct generation tracking
-        self.struct_info = {}  # Maps prefix -> {fields: [(suffix, type, size)], struct_name: str}
-
-        # Track all used variable names to avoid conflicts
-        self.used_var_names = set()
-
-        # Track explicit Prep (reset) operations for return type calculation
-        # Maps array_name -> set of indices that were explicitly reset
-        self.explicitly_reset_qubits = {}
-
-        # Variable remapping for handling measurement+Prep pattern
-        # Maps old_name -> new_name for variables that need fresh names
-        self.variable_remapping: dict[str, str] = {}
-        # Track version numbers for generating unique variable names
-        self.variable_version_counter: dict[str, int] = {}
-
-        # Unified variable-state tracking: replaces ad-hoc dicts like
-        # `unpacked_vars`, `refreshed_arrays`, etc. (See variable_state.py
-        # for rationale.) Migration is incremental -- legacy dicts still
-        # populated, this object is consulted at sites that need a coherent
-        # view of "what Guppy form is this SLR variable in right now?".
-        from pecos.slr.gen_codes.guppy.variable_state import VariableState
-
-        self.var_state = VariableState()
-
-    def _get_unique_var_name(self, base_name: str, index: int | None = None) -> str:
-        """Generate a unique variable name that doesn't conflict with existing names.
-
-        Args:
-            base_name: The base name for the variable
-            index: Optional index to append to the base name
-
-        Returns:
-            A unique variable name
-        """
-        candidate = f"{base_name}_{index}" if index is not None else base_name
-
-        # If the name doesn't conflict, use it
-        if candidate not in self.used_var_names:
-            self.used_var_names.add(candidate)
-            return candidate
-
-        # Add underscores until we find a unique name
-        while candidate in self.used_var_names:
-            candidate = f"_{candidate}"
-
-        self.used_var_names.add(candidate)
-        return candidate
-
-    def _collect_var_names(self, block) -> None:
-        """Collect all variable names from a block to avoid conflicts."""
-        if hasattr(block, "vars"):
-            for var in block.vars:
-                if hasattr(var, "sym"):
-                    self.used_var_names.add(var.sym)
-        # Also check ops recursively
-        if hasattr(block, "ops"):
-            for op in block.ops:
-                if hasattr(op, "__class__") and op.__class__.__name__ in [
-                    "Main",
-                    "Block",
-                ]:
-                    self._collect_var_names(op)
-
-    def build_module(self, main_block: SLRBlock, pending_functions: list) -> Module:
-        """Build a complete module from SLR."""
-        module = Module()
-
-        # Collect all existing variable names to avoid conflicts
-        self._collect_var_names(main_block)
-
-        # Allocation analysis now comes from UnifiedResourceAnalysis
-        # (passed via unified_analysis parameter)
-
-        # Analyze qubit usage to identify ancillas
-        qubit_analyzer = QubitUsageAnalyzer()
-        self.qubit_usage_stats = qubit_analyzer.analyze_block(main_block)
-
-        # Detect and analyze struct patterns (will use qubit usage stats)
-        self._detect_struct_patterns(main_block)
-
-        # Add imports (including functional quantum operations for Array Unpacking Pattern)
-        module.imports = [
-            "from __future__ import annotations",
-            "",
-            "from typing import no_type_check",
-            "",
-            "from guppylang.decorator import guppy",
-            "from guppylang.std import quantum",
-            "from guppylang.std.quantum import qubit",
-            "from guppylang.std.quantum.functional import (reset, h, x, y, z, s, t, sdg, tdg, cx, cy, cz)",
-            "from guppylang.std.builtins import array, owned, result, py",
-        ]
-
-        # Generate struct definitions after imports
-        if self.struct_info:
-            module.imports.append("")
-            struct_defs = self._generate_struct_definitions()
-            module.imports.extend(struct_defs)
-
-        # Add optimization report as comments (only if requested)
-        if self.include_optimization_report and self.unified_analysis:
-            # Use unified resource planning report (comprehensive)
-            report = self.unified_analysis.get_report()
-            module.imports.extend(
-                [
-                    "",
-                    *["# " + line for line in report.split("\n") if line.strip()],
-                ],
-            )
-
-        # Build main function
-        main_func = self.build_main_function(main_block)
-        module.functions.append(main_func)
-        # Store refreshed arrays for main function
-        module.refreshed_arrays["main"] = self.refreshed_arrays.copy()
-        # Also store which functions refreshed each array in main
-        if not hasattr(module, "refreshed_by_function_map"):
-            module.refreshed_by_function_map = {}
-        module.refreshed_by_function_map["main"] = self.refreshed_by_function.copy()
-
-        # Generate helper functions for structs
-        for prefix, info in self.struct_info.items():
-            # Generate decompose function (always needed for cleanup)
-            decompose_func = self._generate_struct_decompose_function(prefix, info)
-            if decompose_func:
-                module.functions.append(decompose_func)
-
-            # Also generate discard function (useful for other contexts)
-            discard_func = self._generate_struct_discard_function(prefix, info)
-            if discard_func:
-                module.functions.append(discard_func)
-
-        # Build any pending functions (from both parameter and internal tracking)
-        all_pending = list(pending_functions) + self.pending_functions
-        while all_pending:
-            func_info = all_pending.pop(0)
-            func = self.build_function(func_info)
-            if func:
-                module.functions.append(func)
-                # Mark this function as generated
-                if len(func_info) >= 2:
-                    self.generated_functions.add(func_info[1])
-                    # Store refreshed arrays for this function
-                    module.refreshed_arrays[func_info[1]] = self.refreshed_arrays.copy()
-                    # Also store which functions refreshed each array
-                    if not hasattr(module, "refreshed_by_function_map"):
-                        module.refreshed_by_function_map = {}
-                    module.refreshed_by_function_map[func_info[1]] = self.refreshed_by_function.copy()
-                # Check if building this function added more pending functions
-                # Add any new pending functions, avoiding duplicates
-                for new_func in self.pending_functions:
-                    _new_block, new_name, _new_sig = new_func
-                    # Check if this function is already built or pending
-                    already_pending = any(f[1] == new_name for f in all_pending if len(f) >= 2)
-                    if new_name not in self.generated_functions and not already_pending:
-                        all_pending.append(new_func)
-                self.pending_functions = []
-
-        # SECOND PASS: Correct return types for functions that return values from other functions
-        # This is needed because nested functions are built after their parents
-        self._correct_return_types_from_called_functions(module)
-
-        return module
-
-    def _correct_return_types_from_called_functions(self, module):
-        """Correct return types for functions that return values from other functions.
-
-        This is a second pass needed because nested functions are built after their parents,
-        so when calculating the parent's return type, the nested function's return type
-        isn't available yet.
-        """
-
-        # For each function, check if it needs return type correction
-        for func in module.functions:
-            if func.name == "main":
-                continue  # Skip main function
-
-            # Check if this function has refreshed_by_function mappings
-            if func.name not in module.refreshed_arrays:
-                continue
-
-            func_refreshed_arrays = module.refreshed_arrays[func.name]
-            if not func_refreshed_arrays:
-                continue
-
-            # We need to check if this function's return type should be corrected
-            # by looking at which functions refreshed its arrays
-            # For now, we'll use a simpler approach: check if the return type
-            # involves arrays that were refreshed by other functions
-
-            # Parse the current return type
-            current_return_type = func.return_type
-            if current_return_type == "None":
-                continue  # Procedural function, no correction needed
-
-            # Get the refreshed_by_function mapping for this function
-            if not hasattr(module, "refreshed_by_function_map"):
-                continue
-            if func.name not in module.refreshed_by_function_map:
-                continue
-
-            func_refreshed_by_function = module.refreshed_by_function_map[func.name]
-            if not func_refreshed_by_function:
-                continue
-
-            # For functions returning tuples, we need to check each element
-            if current_return_type.startswith("tuple["):
-                import re
-
-                tuple_match = re.match(r"tuple\[(.*)\]", current_return_type)
-                if tuple_match:
-                    # Get parameter names from function params (quantum arrays only)
-                    param_names = [p[0] for p in func.params if "array[quantum.qubit," in p[1]]
-
-                    # For each quantum parameter, check if it was refreshed by a function
-                    corrected_types = []
-                    for param_name in param_names:
-                        if param_name in func_refreshed_by_function:
-                            func_info = func_refreshed_by_function[param_name]
-                            # Extract function name from the dict (or handle legacy string format)
-                            called_func_name = (
-                                func_info["function"]
-                                if isinstance(func_info, dict)
-                                else func_info  # Legacy string format
-                            )
-
-                            # Look up the called function's return type
-                            if called_func_name in self.function_return_types:
-                                called_return_type = self.function_return_types[called_func_name]
-
-                                # If the called function returns a tuple, extract the type for this param
-                                if called_return_type.startswith("tuple["):
-                                    tuple_match2 = re.match(
-                                        r"tuple\[(.*)\]",
-                                        called_return_type,
-                                    )
-                                    if tuple_match2:
-                                        called_types_str = tuple_match2.group(1)
-                                        # Parse the types (handling nested brackets)
-                                        types_list = []
-                                        bracket_depth = 0
-                                        current_type = ""
-                                        for char in called_types_str:
-                                            if char == "[":
-                                                bracket_depth += 1
-                                                current_type += char
-                                            elif char == "]":
-                                                bracket_depth -= 1
-                                                current_type += char
-                                            elif char == "," and bracket_depth == 0:
-                                                types_list.append(current_type.strip())
-                                                current_type = ""
-                                            else:
-                                                current_type += char
-                                        if current_type:
-                                            types_list.append(current_type.strip())
-
-                                        # Find which position this param is in
-                                        param_idx = param_names.index(param_name)
-                                        if param_idx < len(types_list):
-                                            corrected_types.append(
-                                                types_list[param_idx],
-                                            )
-                                        else:
-                                            # Fallback: use current type
-                                            corrected_types.append(None)
-                                    else:
-                                        corrected_types.append(None)
-                                else:
-                                    # Single return - use it directly if this is the only param
-                                    if len(param_names) == 1:
-                                        corrected_types.append(called_return_type)
-                                    else:
-                                        corrected_types.append(None)
-                            else:
-                                corrected_types.append(None)
-                        else:
-                            corrected_types.append(None)
-
-                    # If we have corrections, update the function's return type
-                    if any(ct is not None for ct in corrected_types):
-                        # Parse current types
-                        current_types_str = tuple_match.group(1)
-                        current_types_list = []
-                        bracket_depth = 0
-                        current_type = ""
-                        for char in current_types_str:
-                            if char == "[":
-                                bracket_depth += 1
-                                current_type += char
-                            elif char == "]":
-                                bracket_depth -= 1
-                                current_type += char
-                            elif char == "," and bracket_depth == 0:
-                                current_types_list.append(current_type.strip())
-                                current_type = ""
-                            else:
-                                current_type += char
-                        if current_type:
-                            current_types_list.append(current_type.strip())
-
-                        # Apply corrections
-                        new_types = []
-                        for i, corrected in enumerate(corrected_types):
-                            if corrected is not None:
-                                new_types.append(corrected)
-                            elif i < len(current_types_list):
-                                new_types.append(current_types_list[i])
-                            else:
-                                # Something went wrong, skip correction
-                                new_types = None
-                                break
-
-                        if new_types:
-                            new_return_type = f"tuple[{', '.join(new_types)}]"
-                            func.return_type = new_return_type
-                            # Also update the registry
-                            self.function_return_types[func.name] = new_return_type
-
-    def build_main_function(self, block: SLRBlock) -> Function:
-        """Build the main function."""
-        # Set current function name
-        self.current_function_name = "main"
-
-        # Reset function-local state
-        self.refreshed_arrays = {}
-        self.refreshed_by_function = {}
-        self.conditional_fresh_vars = {}
-        self.array_remapping = {}  # Reset array remapping for main function
-
-        # Analyze qubit usage patterns
-        usage_analyzer = QubitUsageAnalyzer()
-        usage_analyzer.analyze_block(block, self.struct_info)
-        self.allocation_recommendations = usage_analyzer.get_allocation_recommendations()
-
-        # Pre-analyze explicit reset operations (Prep) to distinguish them from automatic replacements
-        consumed_in_main = {}
-        self._track_consumed_qubits(block, consumed_in_main)
-
-        # Override allocation recommendations for struct fields to ensure they're pre-allocated
-        # (struct constructors need all fields to be available)
-        if self.struct_info:
-            for prefix, info in self.struct_info.items():
-                for suffix, _, _ in info["fields"]:
-                    var_name = info["var_names"][suffix]
-                    # Override the allocation recommendations system
-                    if var_name in self.allocation_recommendations:
-                        recommendation = self.allocation_recommendations[var_name]
-                        if recommendation.get("allocation") == "dynamic":
-                            # Override dynamic allocation for struct fields
-                            self.allocation_recommendations[var_name] = {
-                                "allocation": "pre_allocate",
-                                "reason": "Struct field requires pre-allocation",
-                                "keep_packed": recommendation.get("keep_packed", True),
-                                "pre_allocate": True,
-                            }
-
-        body = Block()
-        self.current_block = body
-
-        # Track arrays consumed by @owned function calls
-        self.consumed_arrays = set()
-
-        # Add variable declarations
-        if hasattr(block, "vars"):
-            # First, add non-struct variables
-            struct_vars = set()
-            for prefix, info in self.struct_info.items():
-                struct_vars.update(info["var_names"].values())
-
-            # Get ancilla variables that were excluded from structs
-            ancilla_vars = getattr(self, "ancilla_qubits", set())
-
-            for var in block.vars:
-                if hasattr(var, "sym"):
-                    # Add if not in struct OR if it's an ancilla (which was excluded from struct)
-                    if var.sym not in struct_vars or var.sym in ancilla_vars:
-                        self._add_variable_declaration(var, block)
-
-                    # Add to scope context for resource tracking
-                    var_type = type(var).__name__
-                    if var_type in ["QReg", "CReg"]:
-                        is_quantum = var_type == "QReg"
-                        size = getattr(var, "size", None)
-
-                        var_info = VariableInfo(
-                            name=var.sym,
-                            original_name=var.sym,
-                            var_type="quantum" if is_quantum else "classical",
-                            size=size,
-                            is_array=True,
-                        )
-                        self.context.add_variable(var_info)
-
-            # Then, create struct instances
-            for prefix, info in self.struct_info.items():
-                self._add_struct_initialization(prefix, info, block)
-
-        # Main function maintains natural SLR array semantics
-        # Arrays are only unpacked internally when needed for selective measurements
-
-        # Track unpacked vars for main
-        self.unpacked_vars = {}
-
-        # First pass: determine which quantum arrays will be unpacked
-        will_unpack_quantum = set()
-        for array_name in self.plan.unpack_at_start:
-            if array_name in self.plan.arrays_to_unpack:
-                info = self.plan.arrays_to_unpack[array_name]
-
-                # Skip struct fields
-                is_struct_field = False
-                if self.struct_info:
-                    for prefix, struct_info in self.struct_info.items():
-                        if array_name in struct_info.get("var_names", {}).values():
-                            is_struct_field = True
-                            break
-
-                if is_struct_field:
-                    continue
-
-                # Skip dynamically allocated arrays
-                if hasattr(self, "dynamic_allocations") and array_name in self.dynamic_allocations:
-                    continue
-
-                # Mark quantum arrays that will be unpacked
-                if not info.is_classical:
-                    will_unpack_quantum.add(array_name)
-
-        # Second pass: actually unpack arrays
-        for array_name in self.plan.unpack_at_start:
-            if array_name in self.plan.arrays_to_unpack:
-                info = self.plan.arrays_to_unpack[array_name]
-
-                # Skip unpacking for arrays that are struct fields
-                # (already consumed by struct constructor)
-                is_struct_field = False
-                if self.struct_info:
-                    for prefix, struct_info in self.struct_info.items():
-                        if array_name in struct_info.get("var_names", {}).values():
-                            is_struct_field = True
-                            break
-
-                if is_struct_field:
-                    # Skip unpacking - array is consumed by struct constructor
-                    # Individual elements can be accessed via struct decomposition
-                    self.current_block.statements.append(
-                        Comment(
-                            f"Skip unpacking {array_name} - consumed by struct constructor",
-                        ),
-                    )
-                    continue
-
-                # For dynamically allocated arrays, skip unpacking - qubits are allocated on first use
-                if hasattr(self, "dynamic_allocations") and array_name in self.dynamic_allocations:
-                    # Don't unpack - the array doesn't exist, qubits are allocated individually
-                    continue
-                if not info.is_classical:
-                    # Regular unpacking for quantum arrays
-                    self.current_block.statements.append(
-                        Comment(f"Unpack {array_name} for individual access"),
-                    )
-                    self._add_array_unpacking(array_name, info.size)
-                else:
-                    # For classical arrays, unpack if any quantum array is unpacked
-                    # This ensures consistent variable naming patterns
-                    should_unpack_classical = len(will_unpack_quantum) > 0 or (
-                        hasattr(self, "dynamic_allocations") and len(self.dynamic_allocations) > 0
-                    )
-                    if should_unpack_classical:
-                        # Unpack classical array to support quantum unpacking pattern
-                        self.current_block.statements.append(
-                            Comment(
-                                f"Unpack {array_name} for individual measurement results",
-                            ),
-                        )
-                        self._add_array_unpacking(array_name, info.size)
-                    else:
-                        # Skip unpacking classical arrays in main to avoid linearity violations
-                        # Classical arrays can be accessed directly and passed to functions
-                        self.current_block.statements.append(
-                            Comment(
-                                f"Skip unpacking classical array {array_name} - not needed for linearity",
-                            ),
-                        )
-
-        # Add operations
-        if hasattr(block, "ops"):
-            # Store block reference for look-ahead in operation conversion
-            self.current_block_ops = block.ops
-            for op_index, op in enumerate(block.ops):
-                # Store current operation index for look-ahead
-                self.current_op_index = op_index
-                stmt = self._convert_operation(op)
-                if stmt:
-                    body.statements.append(stmt)
-            # Clear after processing
-            self.current_block_ops = None
-            self.current_op_index = None
-
-        # Handle struct decomposition, results, and cleanup
-        self._add_final_handling(block)
-
-        return Function(
-            name="main",
-            params=[],
-            return_type="None",
-            body=body,
-            decorators=["guppy", "no_type_check"],
-        )
-
-    def build_function(self, func_info) -> Function | None:
-        """Build a function from pending function info."""
-
-        # Reset function-local state
-        self.refreshed_arrays = {}
-        self.refreshed_by_function = {}
-        self.conditional_fresh_vars = {}
-        self.array_remapping = {}  # Reset array remapping for each function
-        # Reset parameter_unpacked_arrays for each function
-        self.parameter_unpacked_arrays = set()
-        # Reset explicitly_reset_qubits for each function to prevent cross-contamination
-        self.explicitly_reset_qubits = {}
-
-        # Handle different formats of func_info
-        if len(func_info) == 3:
-            # New format from IR builder: (block, func_name, signature)
-            sample_block, func_name, _block_signature = func_info
-        elif len(func_info) == 4:
-            # Old format: (block_key, func_name, sample_block, block_name)
-            _block_key, func_name, sample_block, _block_name = func_info
-        else:
-            return None
-
-        # Analyze dependencies to determine parameters
-        deps = self._analyze_block_dependencies(sample_block)
-
-        # Build parameter list
-        params = []
-        param_mapping = {}  # Maps parameter names to original variable names
-
-        # Check if we should use structs instead of individual arrays
-        struct_params = set()  # Structs we've already added
-        vars_in_structs = set()  # Variables that are part of structs
-
-        # First pass: identify which variables are part of structs
-        for prefix, info in self.struct_info.items():
-            vars_in_this_struct = []
-            for var in info["var_names"].values():
-                if var in deps["quantum"] or var in deps["classical"]:
-                    vars_in_structs.add(var)
-                    vars_in_this_struct.append(var)
-
-            # If any variable from this struct is used, add the struct as a parameter
-            if vars_in_this_struct and prefix not in struct_params:
-                # Add struct parameter
-                struct_name = info["struct_name"]
-                param_type = struct_name
-
-                # Check if this struct contains quantum resources
-                has_quantum = any(v in deps["quantum"] for v in vars_in_this_struct)
-                if has_quantum and self._block_consumes_quantum(sample_block):
-                    param_type = f"{param_type} @owned"
-
-                params.append((prefix, param_type))
-                param_mapping[prefix] = prefix
-                struct_params.add(prefix)
-
-        # Black Box Pattern: All functions that handle quantum arrays should use
-        # functional pattern. This maintains SLR's global array semantics at
-        # boundaries while using functional internals
-        # BUT: Only unpack if the IR analyzer determined it's necessary
-        # First, run the IR analyzer on this block to get unpacking plan
-        from pecos.slr.gen_codes.guppy.ir_analyzer import IRAnalyzer
-
-        # Pre-analyze consumption to inform the IR analyzer about @owned parameters
-        consumed_params = set()
-        if hasattr(sample_block, "ops"):
-            # Check if this function has nested blocks
-            has_nested_blocks = False
-            for op in sample_block.ops:
-                if hasattr(op, "__class__"):
-                    from pecos.slr import Block as SlrBlock
-
-                    try:
-                        if issubclass(op.__class__, SlrBlock):
-                            has_nested_blocks = True
-                            break
-                    except (TypeError, AttributeError):
-                        # Not a class or doesn't have required attributes
-                        pass
-
-            # Analyze consumption - this will help determine @owned parameters
-            consumed_params = self._analyze_consumed_parameters(sample_block)
-            # Also analyze which arrays have subscript access - they also need @owned
-            subscripted_params = self._analyze_subscript_access(sample_block)
-            # Store for later use in @owned determination
-            self.subscripted_params = subscripted_params
-        else:
-            # No ops - initialize empty set
-            self.subscripted_params = set()
-
-        analyzer = IRAnalyzer()
-
-        # Pass information about expected @owned parameters to the analyzer
-        analyzer.expected_owned_params = consumed_params
-        analyzer.has_nested_blocks_with_owned = has_nested_blocks and bool(
-            consumed_params,
-        )
-
-        block_plan = analyzer.analyze_block(sample_block, self.context.variables)
-
-        # Only unpack if there are arrays that need unpacking according to the analyzer
-        needs_unpacking = len(block_plan.arrays_to_unpack) > 0
-
-        # Check if this function consumes its quantum arrays
-        # For the functional pattern in Guppy, all functions that take quantum arrays
-        # and will return them need @owned annotation
-        self._block_consumes_quantum(sample_block)
-
-        # If the function has quantum parameters, it should use @owned
-        # This is required for Guppy's linearity system when arrays are returned
-        bool(deps["quantum"] & deps["reads"])
-
-        # Add quantum parameters (skip those in structs UNLESS they're ancillas)
-        for var in sorted(deps["quantum"] & deps["reads"]):
-            # Check if this is an ancilla that was excluded from structs
-            is_excluded_ancilla = hasattr(self, "ancilla_qubits") and var in self.ancilla_qubits
-
-            if var in vars_in_structs and not is_excluded_ancilla:
-                continue
-            param_name = var  # Use the same name, no need for _param suffix
-            param_mapping[param_name] = var
-            # Determine type from context or default to qubit array
-            var_info = self.context.lookup_variable(var)
-            if var_info:
-                if var_info.is_unpacked:
-                    # This is an unpacked array - need the original array type
-                    param_type = f"array[quantum.qubit, {var_info.size}]"
-                else:
-                    # Always use array type to maintain consistency with SLR semantics
-                    param_type = f"array[quantum.qubit, {var_info.size}]"
-            else:
-                # Default assumption for quantum variables
-                param_type = "array[quantum.qubit, 7]"
-
-            params.append((param_name, param_type))
-
-        # Add classical parameters (no ownership, but include written vars
-        # since arrays are mutable)
-        for var in sorted(deps["classical"] & (deps["reads"] | deps["writes"])):
-            if var in vars_in_structs:
-                continue
-            param_name = var  # Use the same name, no need for _param suffix
-            param_mapping[param_name] = var
-            # Determine type from context
-            var_info = self.context.lookup_variable(var)
-            # Always use array type for consistency
-            param_type = f"array[bool, {var_info.size}]" if var_info else "array[bool, 32]"
-            params.append((param_name, param_type))
-
-        # Create function body
-        body = Block()
-        prev_block = self.current_block
-        prev_mapping = self.param_mapping if hasattr(self, "param_mapping") else {}
-        self.current_block = body
-        self.param_mapping = param_mapping
-
-        # Create a variable remapping context for this function
-        # This maps original variable names to their parameter names
-        var_remapping = {}
-        for param_name, original_name in param_mapping.items():
-            var_remapping[original_name] = param_name
-
-            # Also handle unpacked variables
-            var_info = self.context.lookup_variable(original_name)
-            if var_info and var_info.is_unpacked:
-                # Map each unpacked element
-                for i, unpacked_name in enumerate(var_info.unpacked_names):
-                    var_remapping[unpacked_name] = f"{param_name}[{i}]"
-
-        # Store current function context
-        self.current_function_name = func_name
-        self.current_function_params = params
-        self.current_function_return_type = None  # Will be set after we determine it
-
-        # Clear fresh_return_vars tracking for this new function
-        # (to avoid bleeding from previous function builds)
-        self.fresh_return_vars = {}
-
-        # Track if this function has @owned struct parameters
-        has_owned_struct_params = any(
-            "@owned" in param_type and param_name in self.struct_info for param_name, param_type in params
-        )
-        self.function_info[func_name] = {
-            "has_owned_struct_params": has_owned_struct_params,
-            "params": params,
-        }
-
-        # Store the remapping for use during conversion
-        prev_var_remapping = getattr(self, "var_remapping", {})
-        self.var_remapping = var_remapping
-
-        # Track unpacked variables (only if needed)
-        self.unpacked_vars = {}  # Maps array_name -> [element_names]
-        self.replaced_qubits = {}  # Maps array_name -> set of replaced indices
-
-        # Initially add array unpacking for arrays that the analyzer determined need it
-        if needs_unpacking:
-            for param_name, param_type in params:
-                if "array[quantum.qubit," in param_type and param_name in block_plan.arrays_to_unpack:
-                    # Extract array size
-                    import re
-
-                    match = re.search(r"array\[quantum\.qubit, (\d+)\]", param_type)
-                    if match:
-                        size = int(match.group(1))
-                        # Generate unpacked variable names
-                        element_names = [self._get_unique_var_name(param_name, i) for i in range(size)]
-                        self.unpacked_vars[param_name] = element_names
-
-                        # Add unpacking statement to function body
-                        unpacking_stmt = self._create_array_unpack_statement(
-                            param_name,
-                            element_names,
-                        )
-                        body.statements.append(unpacking_stmt)
-
-        # Additionally, check for ALL @owned arrays that need unpacking
-        # With the functional pattern, @owned arrays must be unpacked to avoid MoveOutOfSubscriptError
-        # UNLESS they're passed to nested blocks
-        for param_name, param_type in params:
-            if "@owned" in param_type and "array[quantum.qubit," in param_type and param_name not in self.unpacked_vars:
-                # Check if this function has any nested block calls
-                # If so, we can't unpack @owned arrays as we may need to pass them
-                # But this will cause MoveOutOfSubscriptError, so we need a different approach
-                has_nested_blocks = False
-                if hasattr(sample_block, "ops"):
-                    for op in sample_block.ops:
-                        # Check if this is a Block subclass
-                        if hasattr(op, "__class__"):
-                            from pecos.slr import Block as SlrBlock
-
-                            try:
-                                if issubclass(op.__class__, SlrBlock):
-                                    has_nested_blocks = True
-                                    break
-                            except (TypeError, AttributeError):
-                                # Not a class or doesn't have required attributes
-                                pass
-
-                # @owned parameters MUST be unpacked regardless of analyzer decision
-                # This is required by Guppy's type system to avoid MoveOutOfSubscriptError
-                force_unpack = "@owned" in param_type
-
-                # Check if the analyzer decided this array should be unpacked
-                # Even with nested blocks, @owned arrays need unpacking to access elements
-                if not force_unpack and param_name not in block_plan.arrays_to_unpack:
-                    if has_nested_blocks:
-                        body.statements.append(
-                            Comment(
-                                f"Skip unpacking {param_name} - function has nested blocks",
-                            ),
-                        )
-                    continue
-
-                # This @owned array needs unpacking to avoid MoveOutOfSubscriptError
-                import re
-
-                match = re.search(r"array\[quantum\.qubit, (\d+)\]", param_type)
-                if match:
-                    size = int(match.group(1))
-                    # Generate unpacked variable names
-                    element_names = [self._get_unique_var_name(param_name, i) for i in range(size)]
-                    self.unpacked_vars[param_name] = element_names
-
-                    # Track that this was unpacked from a parameter (not a return value)
-                    # Parameter-unpacked arrays should NOT be reconstructed for function calls
-                    if not hasattr(self, "parameter_unpacked_arrays"):
-                        self.parameter_unpacked_arrays = set()
-                    self.parameter_unpacked_arrays.add(param_name)
-
-                    # Add comment explaining why we're unpacking
-                    body.statements.append(
-                        Comment(
-                            f"Unpack @owned array {param_name} to avoid MoveOutOfSubscriptError",
-                        ),
-                    )
-
-                    # Add unpacking statement to function body
-                    unpacking_stmt = ArrayUnpack(
-                        source=param_name,
-                        targets=element_names,
-                    )
-                    body.statements.append(unpacking_stmt)
-
-        # Add struct unpacking for struct parameters
-        struct_field_vars = {}  # Maps original var name to struct field path for @owned structs
-        struct_reconstruction = {}  # Maps struct param name to list of field vars for reconstruction
-
-        for param_name, param_type in params:
-            if "@owned" in param_type and param_name in self.struct_info:
-                # This is an @owned struct parameter
-                # For @owned structs, we must decompose them immediately to avoid AlreadyUsedError
-                # when accessing multiple fields
-                struct_info = self.struct_info[param_name]
-
-                # Track that we have an owned struct
-                if not hasattr(self, "owned_structs"):
-                    self.owned_structs = set()
-                self.owned_structs.add(param_name)
-
-                # Decompose the @owned struct using the decompose function
-                # Use the struct name, not the parameter name (e.g., steane_decompose not c_decompose)
-                struct_name = struct_info["struct_name"].replace("_struct", "")
-                decompose_func_name = f"{struct_name}_decompose"
-
-                # Create decomposition call
-                field_vars = []
-                for suffix, field_type, field_size in sorted(struct_info["fields"]):
-                    field_var = f"{param_name}_{suffix}"
-                    field_vars.append(field_var)
-
-                # Add comment explaining decomposition
-                body.statements.append(
-                    Comment(
-                        f"Decompose @owned struct {param_name} to avoid AlreadyUsedError",
-                    ),
-                )
-
-                # Add decomposition statement: c_c, c_d, ... = steane_decompose(c)
-                class TupleAssignment(Statement):
-                    def __init__(self, targets, value):
-                        self.targets = targets
-                        self.value = value
-
-                    def analyze(self, context):
-                        self.value.analyze(context)
-
-                    def render(self, context):
-                        target_str = ", ".join(self.targets)
-                        value_str = self.value.render(context)[0]
-                        return [f"{target_str} = {value_str}"]
-
-                decompose_call = FunctionCall(
-                    func_name=decompose_func_name,
-                    args=[VariableRef(param_name)],
-                )
-
-                decomposition_stmt = TupleAssignment(
-                    targets=field_vars,
-                    value=decompose_call,
-                )
-                body.statements.append(decomposition_stmt)
-
-                # Map original variables to the decomposed field variables
-                for suffix, field_type, field_size in sorted(struct_info["fields"]):
-                    original_var = struct_info["var_names"].get(suffix)
-                    if original_var:
-                        field_var = f"{param_name}_{suffix}"
-                        # Map the original variable name to the decomposed variable
-                        if not hasattr(self, "var_remapping"):
-                            self.var_remapping = {}
-                        self.var_remapping[original_var] = field_var
-
-                # Track the field variables for reconstruction in return statements
-                struct_reconstruction[param_name] = field_vars
-
-                # Track decomposed variables for field access
-                if not hasattr(self, "decomposed_vars"):
-                    self.decomposed_vars = {}
-                field_mapping = {}
-                for suffix, field_type, field_size in sorted(struct_info["fields"]):
-                    field_var = f"{param_name}_{suffix}"
-                    field_mapping[suffix] = field_var
-                self.decomposed_vars[param_name] = field_mapping
-
-                # Skip normal unpacking for @owned structs
-                continue
-            if param_name in self.struct_info:
-                # Non-owned struct parameter - can unpack normally
-                struct_info = self.struct_info[param_name]
-                field_vars = []
-
-                # Generate unpacking statement - use same order as struct
-                # definition (sorted by suffix)
-                unpack_targets = []
-                for suffix, field_type, field_size in sorted(struct_info["fields"]):
-                    field_var = f"{param_name}_{suffix}"
-                    unpack_targets.append(field_var)
-                    field_vars.append(field_var)
-
-                    # Map the original variable name to this unpacked field variable
-                    original_var = struct_info["var_names"].get(suffix)
-                    if original_var:
-                        struct_field_vars[original_var] = field_var
-                        # Also update var_remapping to use field access directly
-                        self.var_remapping[original_var] = field_var
-
-                # Create the unpacking statement:
-                # field1, field2, ... = struct.field1, struct.field2, ...
-                # In Guppy, we need to unpack the entire struct at once -
-                # use same order as struct definition
-                unpack_stmt = Assignment(
-                    target=TupleExpression(
-                        [VariableRef(var) for var in unpack_targets],
-                    ),
-                    value=TupleExpression(
-                        [FieldAccess(VariableRef(param_name), field) for field, _, _ in sorted(struct_info["fields"])],
-                    ),
-                )
-                body.statements.append(unpack_stmt)
-
-                # Store for reconstruction
-                struct_reconstruction[param_name] = field_vars
-
-        # Store struct field mappings for use in variable references
-        self.struct_field_mapping = struct_field_vars
-
-        # Pre-analyze what qubits will be consumed to determine return type
-        consumed_in_function = {}
-        self._track_consumed_qubits(sample_block, consumed_in_function)
-
-        # Pre-determine if this function will return quantum arrays
-        # (needed for measurement replacement logic)
-        will_return_quantum = False
-        has_quantum_arrays = any("array[quantum.qubit," in ptype for name, ptype in params)
-        has_structs = any(name in self.struct_info for name, ptype in params)
-
-        if has_quantum_arrays or has_structs:
-            # Check if any quantum arrays will be returned
-            for name, ptype in params:
-                if "array[quantum.qubit," in ptype:
-                    # Check if this array is part of a struct
-                    in_struct = False
-                    for prefix, info in self.struct_info.items():
-                        if name in info["var_names"].values():
-                            in_struct = True
-                            break
-
-                    # Check if this is an ancilla that was excluded from structs
-                    is_excluded_ancilla = hasattr(self, "ancilla_qubits") and name in self.ancilla_qubits
-
-                    # Check if this array has any live qubits
-                    if name in consumed_in_function:
-                        # Some elements were consumed - check if any are still live
-                        consumed_indices = consumed_in_function[name]
-                        import re
-
-                        size_match = re.search(
-                            r"array\[quantum\.qubit,\s*(\d+)\]",
-                            ptype,
-                        )
-                        array_size = int(size_match.group(1)) if size_match else 2
-                        total_indices = set(range(array_size))
-                        live_indices = total_indices - consumed_indices
-                        include_array = bool(
-                            live_indices,
-                        )  # Only include if has live qubits
-                    else:
-                        # No consumption tracked for this array - assume it's live
-                        include_array = not in_struct or is_excluded_ancilla
-
-                    if include_array:
-                        will_return_quantum = True
-                        break
-
-        # Check if this is a procedural block based on resource flow
-        # If the block has live qubits that should be returned, it's not procedural
-        _consumed_qubits, live_qubits = self._analyze_quantum_resource_flow(
-            sample_block,
-        )
-        has_live_qubits = bool(live_qubits)
-        is_procedural_block = not has_live_qubits
-
-        # SMART DETECTION: Determine if this function should be procedural based on usage patterns
-        # Functions should be procedural if:
-        # 1. They don't need their quantum returns to be used afterward in the calling scope
-        # 2. They primarily do terminal operations (measurements, cleanup)
-        # 3. Making them procedural would avoid PlaceNotUsedError issues
-
-        # HYBRID APPROACH: Use smart detection to determine optimal strategy
-        should_be_procedural = self._should_function_be_procedural(
-            func_name,
-            sample_block,
-            params,
-            has_live_qubits,
-        )
-
-        if should_be_procedural:
-            is_procedural_block = True
-        # Function determined to be procedural
-
-        # If it appears to be procedural based on live qubits, double-check with signature
-        if is_procedural_block and hasattr(sample_block, "__init__"):
-            import inspect
-
-            try:
-                sig = inspect.signature(sample_block.__class__.__init__)
-                return_annotation = sig.return_annotation
-                if return_annotation is None or return_annotation is type(None) or str(return_annotation) == "None":
-                    is_procedural_block = True
-                else:
-                    is_procedural_block = False  # Has return annotation, not procedural
-            except (ValueError, TypeError, AttributeError):
-                # Default to procedural if can't inspect signature
-                # ValueError: signature cannot be determined
-                # TypeError: object is not callable
-                # AttributeError: missing expected attributes
-                is_procedural_block = True
-
-        # Store whether this is a procedural block for measurement logic
-        self.current_function_is_procedural = is_procedural_block
-
-        # Process params and add @owned annotations (now that we know if it's procedural)
-        # HYBRID OWNERSHIP: Smart @owned annotation based on function type and consumption
-        processed_params = []
-        for param_name, param_type in params:
-            if "array[quantum.qubit," in param_type:
-                # Determine if this parameter should be @owned based on consumption analysis
-                should_be_owned = False
-
-                if is_procedural_block:
-                    # For procedural blocks, be selective with @owned
-                    # Only use @owned if the parameter is truly consumed (measured) and not reused
-                    # BUT also check if this parameter is passed to other functions that might expect @owned
-                    # This is necessary for functions like prep_rus that pass parameters to prep_encoding_ft_zero
-                    # For simplicity, if the block has nested blocks, make quantum params @owned
-                    # If a procedural block calls other blocks, those blocks might need @owned params
-                    should_be_owned = True if has_nested_blocks else param_name in consumed_params
-                else:
-                    # For functional blocks that return quantum arrays, check if parameter is actually consumed
-                    # In Guppy's linear type system:
-                    # - @owned: parameter is consumed by the function
-                    # - non-@owned: parameter is borrowed and must be returned
-                    # IMPORTANT: In Guppy, subscripting an array (c_a[0]) marks it as used
-                    # So ANY element access requires @owned annotation to avoid MoveOutOfSubscriptError
-                    if param_name in consumed_in_function:
-                        # ANY consumption requires @owned (not just full consumption)
-                        # This is because subscripting marks the array as used
-                        consumed_indices = consumed_in_function[param_name]
-                        should_be_owned = len(consumed_indices) > 0
-                    elif hasattr(self, "subscripted_params") and param_name in self.subscripted_params:
-                        # Array has subscript access (c_d[0]) which requires @owned
-                        should_be_owned = True
-                    else:
-                        # Check if there's element access even without consumption
-                        # (e.g., gates applied to elements)
-                        # Arrays in arrays_to_unpack need @owned
-                        should_be_owned = param_name in block_plan.arrays_to_unpack
-                        if should_be_owned:
-                            pass
-                        else:
-                            # Last resort: if parameter is used in the function at all, it likely needs @owned
-                            # In Guppy, any use of an array parameter in a functional block requires @owned
-                            # because the generated IR will likely subscript it
-                            # Check if the parameter appears in deps (it's used in the function)
-                            if param_name in deps["quantum"]:
-                                should_be_owned = True
-
-                if should_be_owned:
-                    param_type = f"{param_type} @owned"
-
-            processed_params.append((param_name, param_type))
-        params = processed_params
-
-        # HYBRID UNPACKING: After parameter processing, check for @owned arrays that need unpacking
-        # @owned arrays must be unpacked to avoid MoveOutOfSubscriptError when accessing elements
-        for param_name, param_type in params:
-            # Don't double-unpack
-            is_owned_qubit_array = "array[quantum.qubit," in param_type and "@owned" in param_type
-            if is_owned_qubit_array and param_name not in self.unpacked_vars:
-                # Adding @owned array unpacking
-                # Extract array size
-                import re
-
-                match = re.search(r"array\[quantum\.qubit, (\d+)\]", param_type)
-                if match:
-                    size = int(match.group(1))
-                    # Generate unpacked variable names
-                    element_names = [self._get_unique_var_name(param_name, i) for i in range(size)]
-                    self.unpacked_vars[param_name] = element_names
-
-                    # Track that this was unpacked from a parameter (not a return value)
-                    # Parameter-unpacked arrays should NOT be reconstructed for function calls
-                    self.parameter_unpacked_arrays.add(param_name)
-
-                    # Add unpacking statement to function body
-                    unpacking_stmt = self._create_array_unpack_statement(
-                        param_name,
-                        element_names,
-                    )
-                    body.statements.append(unpacking_stmt)
-
-        # Store whether this function returns quantum arrays
-        self.current_function_returns_quantum = will_return_quantum
-
-        # Pre-extract conditions that might be needed in loops with @owned structs
-        # This must happen BEFORE any operations that might consume the structs
-        if hasattr(sample_block, "ops") and self._function_has_owned_struct_params(
-            params,
-        ):
-            extracted_conditions = self._pre_extract_loop_conditions(sample_block, body)
-
-            # Track extracted conditions for later use
-            if extracted_conditions:
-                if not hasattr(self, "pre_extracted_conditions"):
-                    self.pre_extracted_conditions = {}
-                self.pre_extracted_conditions.update(extracted_conditions)
-
-        # Now convert operations (can use will_return_quantum flag)
-        if hasattr(sample_block, "ops"):
-            # Store block reference for look-ahead in operation conversion
-            # This enables measurement+Prep pattern detection in _convert_operation
-            self.current_block_ops = sample_block.ops
-            for op_index, op in enumerate(sample_block.ops):
-                # Store current operation index for look-ahead
-                self.current_op_index = op_index
-                stmt = self._convert_operation(op)
-                if stmt:
-                    body.statements.append(stmt)
-            # Clear after processing
-            self.current_block_ops = None
-            self.current_op_index = None
-
-        # Fix linearity issues: add fresh qubit allocations after consuming operations
-        self._fix_post_consuming_linearity_issues(body)
-
-        # Fix unused fresh variables in conditional execution paths
-        self._fix_unused_fresh_variables(body)
-
-        # Save the current variable remapping (includes changes from Prep operations)
-        # BEFORE restoring previous mapping, as we need it for return statement generation
-        self.function_var_remapping = self.variable_remapping.copy() if hasattr(self, "variable_remapping") else {}
-
-        # Restore previous remapping
-        self.var_remapping = prev_var_remapping
-        self.current_block = prev_block
-        self.param_mapping = prev_mapping
-
-        # Now calculate the actual detailed return type and generate return statements
-        return_type = "None"
-
-        # Black Box Pattern: functions that handle quantum arrays return modified arrays
-        # BUT: if function consumes arrays (@owned), don't return them
-        # Check if we have quantum arrays or structs to return (regardless of unpacking)
-        has_quantum_arrays = any("array[quantum.qubit," in ptype for name, ptype in params)
-        has_structs = any(name in self.struct_info for name, ptype in params)
-
-        # For procedural blocks, don't generate return statements
-        if not is_procedural_block and (has_quantum_arrays or has_structs):
-            # Array/struct return pattern: functions return reconstructed arrays or structs
-            quantum_returns = []
-
-            # Add structs first - even @owned structs can be returned if they're reconstructed
-            for name, ptype in params:
-                if name in self.struct_info:
-                    # Remove @owned annotation from type for return type
-                    return_type = ptype.replace(" @owned", "")
-                    quantum_returns.append((name, return_type))
-
-            # Then add individual arrays not in structs (including ancillas)
-            for name, ptype in params:
-                if "array[quantum.qubit," in ptype:
-                    # Check if this array is part of a struct
-                    in_struct = False
-                    is_excluded_ancilla = False
-
-                    for prefix, info in self.struct_info.items():
-                        if name in info["var_names"].values():
-                            in_struct = True
-                            break
-
-                    # Check if this is an ancilla that was excluded from structs
-                    if hasattr(self, "ancilla_qubits") and name in self.ancilla_qubits:
-                        is_excluded_ancilla = True
-
-                    # Only include arrays that have live (unconsumed) qubits
-                    # Check if this array has any unconsumed elements
-                    if name in consumed_in_function:
-                        # Some elements were consumed - check if any are still live
-                        consumed_indices = consumed_in_function[name]
-                        # Extract size from parameter type
-                        import re
-
-                        size_match = re.search(
-                            r"array\[quantum\.qubit,\s*(\d+)\]",
-                            ptype,
-                        )
-                        array_size = int(size_match.group(1)) if size_match else 2
-                        total_indices = set(range(array_size))
-
-                        # Live indices = unconsumed OR explicitly reset
-                        # Explicitly reset qubits are consumed by measurement but recreated by Prep
-                        explicitly_reset_indices = set()
-                        if hasattr(self, "explicitly_reset_qubits") and name in self.explicitly_reset_qubits:
-                            explicitly_reset_indices = self.explicitly_reset_qubits[name]
-
-                        live_indices = (total_indices - consumed_indices) | explicitly_reset_indices
-                        include_array = bool(
-                            live_indices,
-                        )  # Only include if has live qubits (unconsumed OR explicitly reset)
-                    else:
-                        # No consumption tracked for this array - assume it's live
-                        include_array = not in_struct or is_excluded_ancilla
-
-                    if include_array:
-                        # PRIORITY 1: Check if this array was refreshed by a function call
-                        # If so, use the called function's return type instead of consumption analysis
-                        if hasattr(self, "refreshed_arrays") and name in self.refreshed_arrays:
-                            self.refreshed_arrays[name]
-                            # Find which function call produced this fresh variable
-                            # by looking at the refreshed_by_function mapping
-                            if hasattr(self, "refreshed_by_function") and name in self.refreshed_by_function:
-                                func_info = self.refreshed_by_function[name]
-                                # Extract function name from the dict (or handle legacy string format)
-                                called_func_name = (
-                                    func_info["function"]
-                                    if isinstance(func_info, dict)
-                                    else func_info  # Legacy string format
-                                )
-                                # Look up that function's return type
-                                if called_func_name in self.function_return_types:
-                                    called_func_return = self.function_return_types[called_func_name]
-                                    # If it returns a tuple, extract the type for this array
-                                    if called_func_return.startswith("tuple["):
-                                        # Parse tuple to find the type for this array
-                                        import re
-
-                                        tuple_match = re.match(
-                                            r"tuple\[(.*)\]",
-                                            called_func_return,
-                                        )
-                                        if tuple_match:
-                                            return_types_str = tuple_match.group(1)
-                                            # Split by comma but handle nested brackets
-                                            types_list = []
-                                            bracket_depth = 0
-                                            current_type = ""
-                                            for char in return_types_str:
-                                                if char == "[":
-                                                    bracket_depth += 1
-                                                    current_type += char
-                                                elif char == "]":
-                                                    bracket_depth -= 1
-                                                    current_type += char
-                                                elif char == "," and bracket_depth == 0:
-                                                    types_list.append(
-                                                        current_type.strip(),
-                                                    )
-                                                    current_type = ""
-                                                else:
-                                                    current_type += char
-                                            if current_type:
-                                                types_list.append(current_type.strip())
-
-                                            # Find which position this array is in the function's parameters
-                                            quantum_param_names = [
-                                                n for n, pt in params if "array[quantum.qubit," in pt
-                                            ]
-                                            if name in quantum_param_names:
-                                                param_idx = quantum_param_names.index(
-                                                    name,
-                                                )
-                                                if param_idx < len(types_list):
-                                                    # Use the return type from the called function
-                                                    new_type = types_list[param_idx]
-                                                    quantum_returns.append(
-                                                        (name, new_type),
-                                                    )
-                                                    continue  # Skip consumption analysis
-                                    else:
-                                        # Single return - use it directly
-                                        quantum_returns.append(
-                                            (name, called_func_return),
-                                        )
-                                        continue  # Skip consumption analysis
-
-                        # PRIORITY 2: Use consumption analysis if array wasn't refreshed by a function
-                        # Check if any elements remain unconsumed for ALL arrays
-                        if name in consumed_in_function:
-                            # Extract array size from type
-                            import re
-
-                            match = re.search(r"array\[quantum\.qubit, (\d+)\]", ptype)
-                            if match:
-                                original_size = int(match.group(1))
-                                consumed_indices = consumed_in_function[name]
-
-                                # Check if any consumed qubits were replaced
-                                if hasattr(self, "replaced_qubits") and name in self.replaced_qubits:
-                                    self.replaced_qubits[name]
-
-                                # Check if this parameter was fully consumed (all elements measured)
-                                # BUT: if consumed qubits were explicitly reset, they should be returned
-                                fully_consumed = len(consumed_indices) == original_size
-
-                                # Check if any consumed qubits were explicitly reset
-                                explicitly_reset_indices = set()
-                                if hasattr(self, "explicitly_reset_qubits") and name in self.explicitly_reset_qubits:
-                                    explicitly_reset_indices = self.explicitly_reset_qubits[name]
-
-                                # If fully consumed BUT some were explicitly reset, we should return those
-                                if fully_consumed and not explicitly_reset_indices:
-                                    # All qubits were measured and none were explicitly reset - don't return
-                                    pass  # Don't add to quantum_returns
-                                else:
-                                    # Not fully consumed - return the array
-                                    # Determine how many qubits will actually be returned
-                                    # This depends on:
-                                    # 1. Whether this will be a single or multiple return
-                                    # 2. Whether consumed qubits were replaced
-
-                                    # Count how many quantum arrays will likely be returned
-                                    # (This is a heuristic - we're building quantum_returns as we go)
-                                    num_quantum_params = 0
-                                    for n, pt in params:
-                                        if "array[quantum.qubit," in pt:
-                                            # Check if this array is part of a struct
-                                            in_struct = False
-                                            if isinstance(self.struct_info, dict) and n in self.struct_info.values():
-                                                in_struct = True
-                                            if not in_struct:
-                                                num_quantum_params += 1
-
-                                    # For both single and multiple returns with partial consumption:
-                                    # Return unconsumed + explicitly reset elements
-                                    # Automatic replacements (for linearity) are not returned
-                                    # Matches return statement generation at lines 1424-1465
-
-                                    # Calculate how many elements to return
-                                    explicitly_reset_indices = set()
-                                    if (
-                                        hasattr(self, "explicitly_reset_qubits")
-                                        and name in self.explicitly_reset_qubits
-                                    ):
-                                        explicitly_reset_indices = self.explicitly_reset_qubits[name]
-
-                                    # Count elements that are either unconsumed OR explicitly reset
-                                    elements_to_return_count = 0
-                                    for i in range(original_size):
-                                        if i not in consumed_indices or i in explicitly_reset_indices:
-                                            elements_to_return_count += 1
-
-                                    remaining_count = elements_to_return_count
-
-                                    if remaining_count > 0:
-                                        # Some qubits remain - return array with correct size
-                                        if remaining_count < original_size:
-                                            # Partial consumption - return array with reduced size
-                                            new_type = f"array[quantum.qubit, {remaining_count}]"
-                                        else:
-                                            # No consumption - return original type
-                                            new_type = ptype.replace(" @owned", "")
-                                        quantum_returns.append((name, new_type))
-                        else:
-                            # No consumption tracked - return full array
-                            # Remove @owned annotation from return type
-                            return_type = ptype.replace(" @owned", "")
-                            quantum_returns.append((name, return_type))
-
-            if quantum_returns:
-                # Add return statements
-                if len(quantum_returns) == 1:
-                    name, ptype = quantum_returns[0]
-
-                    # Check if this is a partial return
-                    if name in consumed_in_function and "array[quantum.qubit," in ptype:
-                        # Need to return only unconsumed elements
-                        import re
-
-                        match = re.search(r"array\[quantum\.qubit, (\d+)\]", ptype)
-                        if match:
-                            int(match.group(1))
-                            original_match = re.search(
-                                r"array\[quantum\.qubit, (\d+)\]",
-                                next(pt for n, pt in params if n == name),
-                            )
-                            if original_match:
-                                original_size = int(original_match.group(1))
-                                consumed_indices = consumed_in_function[name]
-
-                                # Build array with unconsumed + explicitly reset elements
-                                #
-                                # DESIGN DECISION: Return unconsumed and explicitly reset elements
-                                # - Unconsumed: Elements never measured/consumed
-                                # - Explicitly reset: Elements reset via Prep operation (quantum.reset)
-                                # - Automatic replacements: Created for linearity, NOT returned
-                                #
-                                # This distinguishes:
-                                # 1. Explicit Prep(qubit) - semantic reset operation → RETURN
-                                # 2. Automatic post-measurement replacement → DON'T RETURN
-                                #
-                                # Examples:
-                                # - Steane verification: Prep(ancilla) → explicit reset → included
-                                # - Partial consumption: Measure(q[0]) → automatic replacement → excluded
-
-                                # Determine which consumed indices should be returned
-                                # (i.e., those that were explicitly reset)
-                                explicitly_reset_indices = set()
-                                if hasattr(self, "explicitly_reset_qubits") and name in self.explicitly_reset_qubits:
-                                    explicitly_reset_indices = self.explicitly_reset_qubits[name]
-
-                                elements_to_return = []
-                                for i in range(original_size):
-                                    # Include if: (1) not consumed, OR (2) explicitly reset
-                                    if i not in consumed_indices or i in explicitly_reset_indices:
-                                        if name in self.unpacked_vars:
-                                            # Use unpacked element name directly using original index
-                                            # NOTE: index_mapping maps original index →
-                                            # compact position for function CALLS
-                                            # But for RETURNS, we still have all original
-                                            # unpacked elements available
-                                            # So we use the original index 'i' directly!
-                                            element_name = self.unpacked_vars[name][i]
-                                            # Apply variable remapping if element was
-                                            # reassigned (e.g., Prep after Measure)
-                                            if hasattr(self, "function_var_remapping"):
-                                                element_name = self.function_var_remapping.get(
-                                                    element_name,
-                                                    element_name,
-                                                )
-                                            elements_to_return.append(
-                                                VariableRef(element_name),
-                                            )
-                                        else:
-                                            # Use array indexing
-                                            elements_to_return.append(
-                                                ArrayAccess(array_name=name, index=i),
-                                            )
-
-                                # Create array construction
-                                array_expr = FunctionCall(
-                                    func_name="array",
-                                    args=elements_to_return,
-                                )
-                                body.statements.append(
-                                    ReturnStatement(value=array_expr),
-                                )
-                    elif name in self.unpacked_vars:
-                        # Array was unpacked - check for partial consumption
-                        # CRITICAL: Also check consumed_in_function here!
-                        # The earlier check (line 1548) might have failed due to return type detection issues
-                        if name in consumed_in_function:
-                            # Partial consumption - return unconsumed + explicitly reset elements
-                            consumed_indices = consumed_in_function[name]
-                            element_names = self.unpacked_vars[name]
-
-                            # Get explicitly reset indices
-                            explicitly_reset_indices = set()
-                            if hasattr(self, "explicitly_reset_qubits") and name in self.explicitly_reset_qubits:
-                                explicitly_reset_indices = self.explicitly_reset_qubits[name]
-
-                            # Filter: include unconsumed OR explicitly reset
-                            elements_to_return = []
-                            for i, elem_name in enumerate(element_names):
-                                if i not in consumed_indices or i in explicitly_reset_indices:
-                                    # Apply variable remapping if element was reassigned (e.g., Prep after Measure)
-                                    if hasattr(self, "function_var_remapping"):
-                                        elem_name = self.function_var_remapping.get(
-                                            elem_name,
-                                            elem_name,
-                                        )
-                                    elements_to_return.append(VariableRef(elem_name))
-                            array_construction = FunctionCall(
-                                func_name="array",
-                                args=elements_to_return,
-                            )
-                            body.statements.append(
-                                ReturnStatement(value=array_construction),
-                            )
-                        elif hasattr(self, "refreshed_arrays") and name in self.refreshed_arrays:
-                            # Array was unpacked AND refreshed - return the fresh version
-                            fresh_name = self.refreshed_arrays[name]
-                            body.statements.append(
-                                ReturnStatement(value=VariableRef(fresh_name)),
-                            )
-                        else:
-                            # Array was unpacked - must reconstruct from elements for linearity
-                            # Even if no elements were consumed, the original array is "moved" by unpacking
-                            element_names = self.unpacked_vars[name]
-                            array_construction = self._create_array_reconstruction(
-                                element_names,
-                            )
-                            body.statements.append(
-                                ReturnStatement(value=array_construction),
-                            )
-                    elif name in struct_reconstruction:
-                        # Struct was decomposed - but check if it was also refreshed by function calls
-                        if hasattr(self, "refreshed_arrays") and name in self.refreshed_arrays:
-                            # Struct was refreshed - return the fresh version directly
-                            fresh_name = self.refreshed_arrays[name]
-                            body.statements.append(
-                                ReturnStatement(value=VariableRef(fresh_name)),
-                            )
-                        else:
-                            # Struct was decomposed - reconstruct it from field variables
-                            struct_info = self.struct_info[name]
-
-                            # Check if this is an @owned struct that was decomposed
-                            is_owned_struct = hasattr(self, "owned_structs") and name in self.owned_structs
-
-                            # For @owned structs, always reconstruct from decomposed variables
-                            # For regular structs, check if the unpacked variables are still valid
-                            if is_owned_struct:
-                                should_reconstruct = True
-                            else:
-                                # Check if the unpacked variables are still valid
-                                # They're only valid if we haven't passed the struct
-                                # to any @owned functions
-                                should_reconstruct = all(
-                                    struct_info["var_names"].get(suffix) in self.var_remapping
-                                    for suffix, _, _ in struct_info["fields"]
-                                )
-
-                            if should_reconstruct:
-                                # Create struct constructor call - use same order
-                                # as struct definition (sorted by suffix)
-                                constructor_args = []
-                                all_vars_available = True
-
-                                for suffix, field_type, field_size in sorted(
-                                    struct_info["fields"],
-                                ):
-                                    field_var = f"{name}_{suffix}"
-
-                                    # Check if we have a fresh version of this field variable
-                                    if hasattr(self, "refreshed_arrays") and field_var in self.refreshed_arrays:
-                                        field_var = self.refreshed_arrays[field_var]
-                                    elif hasattr(self, "var_remapping") and field_var in self.var_remapping:
-                                        field_var = self.var_remapping[field_var]
-                                    else:
-                                        # Check if the variable was consumed in operations
-                                        if hasattr(self, "consumed_vars") and field_var in self.consumed_vars:
-                                            all_vars_available = False
-                                            break
-
-                                    constructor_args.append(VariableRef(field_var))
-
-                                if all_vars_available and constructor_args:
-                                    struct_constructor = FunctionCall(
-                                        func_name=struct_info["struct_name"],
-                                        args=constructor_args,
-                                    )
-                                    body.statements.append(
-                                        ReturnStatement(value=struct_constructor),
-                                    )
-                                else:
-                                    # Variables were consumed - cannot reconstruct
-                                    # Return void or handle appropriately for @owned structs
-                                    pass
-                            else:
-                                # Unpacked variables are no longer valid - return the struct directly
-                                body.statements.append(
-                                    ReturnStatement(value=VariableRef(name)),
-                                )
-                    else:
-                        # Check if this variable was refreshed due to being borrowed
-                        # (e.g., c_d -> c_d_returned)
-                        if hasattr(self, "refreshed_arrays") and name in self.refreshed_arrays:
-                            # Use the refreshed name for the return
-                            return_name = self.refreshed_arrays[name]
-                            body.statements.append(
-                                ReturnStatement(value=VariableRef(return_name)),
-                            )
-                        elif hasattr(self, "owned_structs") and name in self.owned_structs and name in self.struct_info:
-                            # @owned struct needs reconstruction from decomposed variables
-                            struct_info = self.struct_info[name]
-
-                            # Create struct constructor call
-                            constructor_args = []
-                            all_vars_available = True
-
-                            for suffix, field_type, field_size in sorted(
-                                struct_info["fields"],
-                            ):
-                                field_var = f"{name}_{suffix}"
-
-                                # Check if we have a fresh version of this field variable
-                                if hasattr(self, "refreshed_arrays") and field_var in self.refreshed_arrays:
-                                    field_var = self.refreshed_arrays[field_var]
-                                elif hasattr(self, "var_remapping") and field_var in self.var_remapping:
-                                    field_var = self.var_remapping[field_var]
-                                else:
-                                    # Check if the variable was consumed in operations
-                                    if hasattr(self, "consumed_vars") and field_var in self.consumed_vars:
-                                        all_vars_available = False
-                                        break
-
-                                constructor_args.append(VariableRef(field_var))
-
-                            if all_vars_available and constructor_args:
-                                struct_constructor = FunctionCall(
-                                    func_name=struct_info["struct_name"],
-                                    args=constructor_args,
-                                )
-                                body.statements.append(
-                                    ReturnStatement(value=struct_constructor),
-                                )
-                        else:
-                            # Check if this variable has been refreshed by function calls
-                            var_to_return = name
-                            if hasattr(self, "refreshed_arrays") and name in self.refreshed_arrays:
-                                var_to_return = self.refreshed_arrays[name]
-                            body.statements.append(
-                                ReturnStatement(value=VariableRef(var_to_return)),
-                            )
-
-                    # Set return type
-                    return_type = ptype  # Use the potentially modified type
-                else:
-                    # Multiple arrays/structs - return tuple
-                    return_exprs = []
-                    return_types = []
-                    for name, ptype in quantum_returns:
-                        if name in self.unpacked_vars:
-                            # Array was unpacked - check if it was also refreshed by function calls
-                            if hasattr(self, "refreshed_arrays") and name in self.refreshed_arrays:
-                                # Array was refreshed after unpacking - return the fresh version
-                                fresh_name = self.refreshed_arrays[name]
-                                return_exprs.append(VariableRef(fresh_name))
-                            else:
-                                # Array was unpacked - check if elements are still available for reconstruction
-                                element_names = self.unpacked_vars[name]
-
-                                # For arrays with size 0 in return type, create empty arrays instead of reconstructing
-                                if "array[quantum.qubit, 0]" in ptype:
-                                    # All elements consumed - create empty quantum array using generator expression
-                                    # Create custom expression for: array(quantum.qubit() for _ in range(0))
-
-                                    class EmptyArrayExpression(Expression):
-                                        def analyze(self, _context):
-                                            pass  # No analysis needed for empty array
-
-                                        def render(self, _context):
-                                            return [
-                                                "array(quantum.qubit() for _ in range(0))",
-                                            ]
-
-                                    empty_array = EmptyArrayExpression()
-                                    return_exprs.append(empty_array)
-                                else:
-                                    # Check if this array has partial consumption
-                                    if name in consumed_in_function:
-                                        consumed_indices = consumed_in_function[name]
-
-                                        # Build array with unconsumed + explicitly reset elements
-                                        # See single return path (lines 1424-1465) for detailed rationale
-
-                                        # Get explicitly reset indices
-                                        explicitly_reset_indices = set()
-                                        if (
-                                            hasattr(self, "explicitly_reset_qubits")
-                                            and name in self.explicitly_reset_qubits
-                                        ):
-                                            explicitly_reset_indices = self.explicitly_reset_qubits[name]
-
-                                        elements_to_return = []
-                                        for i in range(len(element_names)):
-                                            # Include if: (1) not consumed, OR (2) explicitly reset
-                                            if i not in consumed_indices or i in explicitly_reset_indices:
-                                                element_name = element_names[i]
-                                                # Apply variable remapping if element was reassigned
-                                                # Use function_var_remapping which includes Prep changes
-                                                if hasattr(
-                                                    self,
-                                                    "function_var_remapping",
-                                                ):
-                                                    element_name = self.function_var_remapping.get(
-                                                        element_name,
-                                                        element_name,
-                                                    )
-                                                elements_to_return.append(
-                                                    VariableRef(element_name),
-                                                )
-
-                                        if elements_to_return:
-                                            # Create array from unconsumed elements
-                                            array_construction = FunctionCall(
-                                                func_name="array",
-                                                args=elements_to_return,
-                                            )
-                                            return_exprs.append(array_construction)
-                                        else:
-                                            # All elements consumed - use empty array
-                                            class EmptyArrayExpression(Expression):
-                                                def analyze(self, _context):
-                                                    pass
-
-                                                def render(self, _context):
-                                                    return [
-                                                        "array(quantum.qubit() for _ in range(0))",
-                                                    ]
-
-                                            return_exprs.append(EmptyArrayExpression())
-                                    else:
-                                        # No consumption or not tracked - standard reconstruction from all elements
-                                        array_construction = self._create_array_reconstruction(
-                                            element_names,
-                                        )
-                                        return_exprs.append(array_construction)
-                        elif name in struct_reconstruction:
-                            # Struct was decomposed - but check if it was also refreshed by function calls
-                            if hasattr(self, "refreshed_arrays") and name in self.refreshed_arrays:
-                                # Struct was refreshed - return the fresh version directly
-                                fresh_name = self.refreshed_arrays[name]
-                                return_exprs.append(VariableRef(fresh_name))
-                            else:
-                                # Struct was decomposed - check if we can still use
-                                # the decomposed variables
-                                struct_info = self.struct_info[name]
-
-                                # Check if this is an @owned struct that was decomposed
-                                is_owned_struct = hasattr(self, "owned_structs") and name in self.owned_structs
-
-                                # For @owned structs, always reconstruct from decomposed variables
-                                # For regular structs, check if the unpacked variables are still valid
-                                if is_owned_struct:
-                                    unpacked_vars_valid = True
-                                else:
-                                    # Check if the unpacked variables are still valid
-                                    unpacked_vars_valid = all(
-                                        struct_info["var_names"].get(suffix) in self.var_remapping
-                                        for suffix, _, _ in struct_info["fields"]
-                                    )
-
-                                if unpacked_vars_valid:
-                                    # Create struct constructor call - use same order
-                                    # as struct definition (sorted by suffix)
-                                    constructor_args = []
-                                    all_vars_available = True
-
-                                    for suffix, field_type, field_size in sorted(
-                                        struct_info["fields"],
-                                    ):
-                                        field_var = f"{name}_{suffix}"
-
-                                        # Check if we have a fresh version of this field variable
-                                        if hasattr(self, "refreshed_arrays") and field_var in self.refreshed_arrays:
-                                            field_var = self.refreshed_arrays[field_var]
-                                        elif hasattr(self, "var_remapping") and field_var in self.var_remapping:
-                                            field_var = self.var_remapping[field_var]
-                                        else:
-                                            # Check if the variable was consumed in operations
-                                            if hasattr(self, "consumed_vars") and field_var in self.consumed_vars:
-                                                all_vars_available = False
-                                                break
-
-                                        constructor_args.append(VariableRef(field_var))
-
-                                    if all_vars_available and constructor_args:
-                                        struct_constructor = FunctionCall(
-                                            func_name=struct_info["struct_name"],
-                                            args=constructor_args,
-                                        )
-                                        return_exprs.append(struct_constructor)
-                                    else:
-                                        # Variables were consumed - handle appropriately
-                                        var_to_return = name
-                                        if hasattr(self, "refreshed_arrays") and name in self.refreshed_arrays:
-                                            var_to_return = self.refreshed_arrays[name]
-                                        return_exprs.append(VariableRef(var_to_return))
-                                else:
-                                    # Unpacked variables are no longer valid -
-                                    # return the struct directly
-                                    # Check if this variable has been refreshed by function calls
-                                    var_to_return = name
-                                    if hasattr(self, "refreshed_arrays") and name in self.refreshed_arrays:
-                                        var_to_return = self.refreshed_arrays[name]
-                                    return_exprs.append(VariableRef(var_to_return))
-                        else:
-                            # Array/struct was not unpacked - return it directly
-                            # Check if this is an @owned struct that needs reconstruction
-                            if (
-                                hasattr(self, "owned_structs")
-                                and name in self.owned_structs
-                                and name in self.struct_info
-                            ):
-                                # @owned struct needs reconstruction from decomposed variables
-                                struct_info = self.struct_info[name]
-
-                                # Create struct constructor call
-                                constructor_args = []
-                                for suffix, field_type, field_size in sorted(
-                                    struct_info["fields"],
-                                ):
-                                    field_var = f"{name}_{suffix}"
-
-                                    # Check if we have a fresh version of this field variable
-                                    if hasattr(self, "refreshed_arrays") and field_var in self.refreshed_arrays:
-                                        field_var = self.refreshed_arrays[field_var]
-                                    elif hasattr(self, "var_remapping") and field_var in self.var_remapping:
-                                        field_var = self.var_remapping[field_var]
-
-                                    constructor_args.append(VariableRef(field_var))
-
-                                struct_constructor = FunctionCall(
-                                    func_name=struct_info["struct_name"],
-                                    args=constructor_args,
-                                )
-                                return_exprs.append(struct_constructor)
-                            else:
-                                # Check if this variable has been refreshed by function calls
-                                var_to_return = name
-                                if hasattr(self, "refreshed_arrays") and name in self.refreshed_arrays:
-                                    var_to_return = self.refreshed_arrays[name]
-                                return_exprs.append(VariableRef(var_to_return))
-
-                        # Add type to return types
-                        return_types.append(ptype)
-
-                    if return_exprs:
-                        body.statements.append(
-                            ReturnStatement(
-                                value=TupleExpression(elements=return_exprs),
-                            ),
-                        )
-                        return_type = f"tuple[{', '.join(return_types)}]"
-
-        # For procedural blocks, override return type to None even if they return arrays internally
-        if is_procedural_block:
-            return_type = "None"
-            # Also remove any return statements from the body since this is procedural
-            body.statements = [stmt for stmt in body.statements if not isinstance(stmt, ReturnStatement)]
-
-            # Add cleanup for unused quantum arrays that might have been created
-            # by function calls but not consumed (e.g., fresh variables)
-            # GENERAL APPROACH: Check for any fresh_return_vars that were created
-            if hasattr(self, "fresh_return_vars") and self.fresh_return_vars:
-                # Add discard for each fresh variable that wasn't consumed
-                # (consumed variables are tracked in consumed_arrays or consumed_resources)
-                for fresh_name, info in self.fresh_return_vars.items():
-                    # Check if this fresh variable was consumed
-                    was_consumed = False
-                    if hasattr(self, "consumed_arrays"):
-                        was_consumed = fresh_name in self.consumed_arrays
-                    if not was_consumed and hasattr(self, "consumed_resources"):
-                        was_consumed = fresh_name in self.consumed_resources
-
-                    # If the fresh array was unpacked into element vars, the
-                    # array itself was moved by the unpack -- discard_array
-                    # would error. Element-level cleanup is handled separately
-                    # (or the elements were consumed by gates/measurements).
-                    # The unpacked-state tracker keys by the *original* SLR
-                    # symbol, so we look up via the original; the fresh name
-                    # itself doesn't appear in unpacked_vars.
-                    original_name = info.get("original")
-                    if (
-                        original_name
-                        and self.var_state.is_unpacked(original_name)
-                        and hasattr(self, "refreshed_arrays")
-                        and self.refreshed_arrays.get(original_name) == fresh_name
-                    ):
-                        was_consumed = True
-
-                    if not was_consumed and info.get("is_quantum_array"):
-                        # Add discard statement
-                        discard_stmt = FunctionCall(
-                            func_name="quantum.discard_array",
-                            args=[VariableRef(fresh_name)],
-                        )
-
-                        # Wrap in expression statement
-                        class ExpressionStatement(Statement):
-                            def __init__(self, expr):
-                                self.expr = expr
-
-                            def analyze(self, context):
-                                self.expr.analyze(context)
-
-                            def render(self, context):
-                                return self.expr.render(context)
-
-                        body.statements.append(Comment(f"Discard unused {fresh_name}"))
-                        body.statements.append(ExpressionStatement(discard_stmt))
-
-                # Clear tracking for next function
-                self.fresh_return_vars = {}
-
-        # Store the return type for use in other parts of the code
-        self.current_function_return_type = return_type
-        # Store in function return types registry for later lookup
-        self.function_return_types[func_name] = return_type
-
-        return Function(
-            name=func_name,
-            params=params,
-            return_type=return_type,
-            body=body,
-            decorators=["guppy", "no_type_check"],
-        )
-
-    def _add_variable_declaration(self, var, block=None) -> None:
-        """Add variable declaration to current block."""
-        var_type = type(var).__name__
-        var_name = var.sym
-
-        # Check for renaming
-        if var_name in self.plan.renamed_variables:
-            var_name = self.plan.renamed_variables[var_name]
-
-        if var_type == "QReg":
-            # Get size for all cases
-            size = var.size
-
-            # Check allocation recommendation for this array
-            recommendation = self.allocation_recommendations.get(var.sym, {})
-
-            # Get resource plan from unified analysis if available
-            resource_plan = None
-            if self.unified_analysis:
-                resource_plan = self.unified_analysis.get_plan(var.sym)
-
-            # Check if this array needs unpacking (selective measurements)
-            needs_unpacking = var.sym in self.plan.arrays_to_unpack
-
-            # Check if this array is used in full array operations
-            needs_full_array = self._array_needs_full_allocation(var.sym, block)
-
-            # Check if this should be dynamically allocated based on usage patterns
-            # But only if it doesn't need unpacking for selective measurements
-            # AND not used in full array ops
-            # AND not a function parameter in current function
-            # AND the unified resource plan agrees with dynamic allocation
-            is_function_parameter = hasattr(self, "current_function_params") and any(
-                param_name == var.sym for param_name, _ in self.current_function_params
-            )
-
-            # Use the unified resource plan if available, otherwise fall back to recommendation
-            should_use_dynamic = False
-            if resource_plan:
-                # Resource plan from unified analysis (authoritative)
-                should_use_dynamic = resource_plan.uses_dynamic_allocation
-            else:
-                # Fall back to recommendation
-                should_use_dynamic = recommendation.get("allocation") == "dynamic"
-
-            if should_use_dynamic and not needs_unpacking and not needs_full_array and not is_function_parameter:
-                # Check if this ancilla array is used as a function parameter
-                # If so, we need to pre-allocate it despite being an ancilla
-                is_function_param = False
-                if hasattr(self, "ancilla_qubits") and var_name in self.ancilla_qubits:
-                    # This is an ancilla that was excluded from structs
-                    # It will be passed as a parameter to functions, so pre-allocate it
-                    is_function_param = True
-
-                if is_function_param:
-                    # For ancilla qubits, create individual qubits instead of arrays
-                    # This avoids @owned array passing issues that cause linearity violations
-                    self.current_block.statements.append(
-                        Comment(
-                            f"Create individual ancilla qubits for {var_name} (avoids @owned array issues)",
-                        ),
-                    )
-
-                    # Create individual qubits: c_a_0, c_a_1, c_a_2 instead of array c_a
-                    for i in range(size):
-                        qubit_name = f"{var_name}_{i}"
-                        init_expr = FunctionCall(func_name="quantum.qubit", args=[])
-                        assignment = Assignment(
-                            target=VariableRef(qubit_name),
-                            value=init_expr,
-                        )
-                        self.current_block.statements.append(assignment)
-
-                    # Mark this variable as having been decomposed into individual qubits
-                    if not hasattr(self, "decomposed_ancilla_arrays"):
-                        self.decomposed_ancilla_arrays = {}
-                    self.decomposed_ancilla_arrays[var_name] = [f"{var_name}_{i}" for i in range(size)]
-
-                    # Add a function to reconstruct the array when needed for function calls
-                    # This creates: c_a = array(c_a_0, c_a_1, c_a_2)
-                    self.current_block.statements.append(
-                        Comment(f"# Reconstruct {var_name} array for function calls"),
-                    )
-                    array_construction_args = [VariableRef(f"{var_name}_{i}") for i in range(size)]
-                    reconstruct_expr = FunctionCall(
-                        func_name="array",
-                        args=array_construction_args,
-                    )
-                    reconstruct_assignment = Assignment(
-                        target=VariableRef(var_name),
-                        value=reconstruct_expr,
-                    )
-                    self.current_block.statements.append(reconstruct_assignment)
-
-                    # Track that this array has been reconstructed - use the variable directly, not individual qubits
-                    if not hasattr(self, "reconstructed_arrays"):
-                        self.reconstructed_arrays = set()
-                    self.reconstructed_arrays.add(var_name)
-                else:
-                    # For other ancillas, don't pre-allocate array
-                    reason = recommendation.get("reason", "ancilla pattern")
-                    # Before marking for dynamic allocation, check if this variable
-                    # is used as a function argument in the current block
-                    is_function_arg = self._is_variable_used_as_function_arg(
-                        var.sym,
-                        block,
-                    )
-
-                    if is_function_arg:
-                        # For ancilla qubits used as function arguments, create individual qubits
-                        # This avoids @owned array passing issues
-                        comment_text = (
-                            f"Create individual ancilla qubits for {var_name} "
-                            f"(function argument, avoids @owned array issues)"
-                        )
-                        self.current_block.statements.append(
-                            Comment(comment_text),
-                        )
-
-                        # Create individual qubits: c_a_0, c_a_1, c_a_2 instead of array c_a
-                        for i in range(size):
-                            qubit_name = f"{var_name}_{i}"
-                            init_expr = FunctionCall(func_name="quantum.qubit", args=[])
-                            assignment = Assignment(
-                                target=VariableRef(qubit_name),
-                                value=init_expr,
-                            )
-                            self.current_block.statements.append(assignment)
-
-                        # Mark this variable as having been decomposed into individual qubits
-                        if not hasattr(self, "decomposed_ancilla_arrays"):
-                            self.decomposed_ancilla_arrays = {}
-                        self.decomposed_ancilla_arrays[var_name] = [f"{var_name}_{i}" for i in range(size)]
-                    else:
-                        # Normal dynamic allocation
-                        self.current_block.statements.append(
-                            Comment(
-                                f"# {var_name} will be allocated dynamically ({reason})",
-                            ),
-                        )
-                        # Track that this is dynamically allocated
-                        if not hasattr(self, "dynamic_allocations"):
-                            self.dynamic_allocations = set()
-                        self.dynamic_allocations.add(var.sym)
-            elif resource_plan and resource_plan.uses_dynamic_allocation:
-                # Check if all elements are local (full dynamic allocation)
-                if len(resource_plan.elements_to_allocate_locally) == size:
-                    # Don't pre-allocate - all will be allocated when first used
-                    self.current_block.statements.append(
-                        Comment(f"Qubits from {var_name} will be allocated locally"),
-                    )
-                    # Track that this is dynamically allocated
-                    if not hasattr(self, "dynamic_allocations"):
-                        self.dynamic_allocations = set()
-                    self.dynamic_allocations.add(var.sym)
-                else:
-                    # Mixed strategy - pre-allocate some, allocate others locally
-                    # But only if the array doesn't need unpacking
-                    if needs_unpacking:
-                        # Can't use mixed allocation with unpacking - fall back to full pre-allocation
-                        init_expr = FunctionCall(
-                            func_name="array",
-                            args=[
-                                FunctionCall(
-                                    func_name="quantum.qubit() for _ in range",
-                                    args=[Literal(size)],
-                                ),
-                            ],
-                        )
-                        assignment = Assignment(
-                            target=VariableRef(var_name),
-                            value=init_expr,
-                        )
-                        self.current_block.statements.append(assignment)
-                        self.current_block.statements.append(
-                            Comment(
-                                f"Note: Full pre-allocation used because {var_name} needs unpacking",
-                            ),
-                        )
-                    elif size - len(resource_plan.elements_to_allocate_locally) > 0:
-                        pre_alloc_size = size - len(
-                            resource_plan.elements_to_allocate_locally,
-                        )
-                        init_expr = FunctionCall(
-                            func_name="array",
-                            args=[
-                                FunctionCall(
-                                    func_name="quantum.qubit() for _ in range",
-                                    args=[Literal(pre_alloc_size)],
-                                ),
-                            ],
-                        )
-                        assignment = Assignment(
-                            target=VariableRef(var_name),
-                            value=init_expr,
-                        )
-                        self.current_block.statements.append(assignment)
-
-                    self.current_block.statements.append(
-                        Comment(
-                            f"Elements {sorted(resource_plan.elements_to_allocate_locally)} of "
-                            f"{var_name} will be allocated locally",
-                        ),
-                    )
-            else:
-                # Check if this is an ancilla array that should be decomposed
-                if hasattr(self, "ancilla_qubits") and var_name in self.ancilla_qubits:
-                    # Decompose ancilla arrays into individual qubits to avoid @owned linearity issues
-                    self.current_block.statements.append(
-                        Comment(
-                            f"Create individual ancilla qubits for {var_name} (avoids @owned array linearity issues)",
-                        ),
-                    )
-
-                    # Create individual qubits: c_a_0, c_a_1, c_a_2 instead of array c_a
-                    for i in range(size):
-                        qubit_name = f"{var_name}_{i}"
-                        init_expr = FunctionCall(func_name="quantum.qubit", args=[])
-                        assignment = Assignment(
-                            target=VariableRef(qubit_name),
-                            value=init_expr,
-                        )
-                        self.current_block.statements.append(assignment)
-
-                    # Mark this variable as having been decomposed into individual qubits
-                    if not hasattr(self, "decomposed_ancilla_arrays"):
-                        self.decomposed_ancilla_arrays = {}
-                    self.decomposed_ancilla_arrays[var_name] = [f"{var_name}_{i}" for i in range(size)]
-
-                    # Add a function to reconstruct the array when needed for function calls
-                    # This creates: c_a = array(c_a_0, c_a_1, c_a_2)
-                    self.current_block.statements.append(
-                        Comment(f"# Reconstruct {var_name} array for function calls"),
-                    )
-                    array_construction_args = [VariableRef(f"{var_name}_{i}") for i in range(size)]
-                    reconstruct_expr = FunctionCall(
-                        func_name="array",
-                        args=array_construction_args,
-                    )
-                    reconstruct_assignment = Assignment(
-                        target=VariableRef(var_name),
-                        value=reconstruct_expr,
-                    )
-                    self.current_block.statements.append(reconstruct_assignment)
-
-                    # Track that this array has been reconstructed - use the variable directly, not individual qubits
-                    if not hasattr(self, "reconstructed_arrays"):
-                        self.reconstructed_arrays = set()
-                    self.reconstructed_arrays.add(var_name)
-                else:
-                    # Check if this ancilla array was already decomposed into individual qubits
-                    if hasattr(self, "decomposed_ancilla_arrays") and var_name in self.decomposed_ancilla_arrays:
-                        # Skip array creation - individual qubits were already created
-                        qubit_list = ", ".join(self.decomposed_ancilla_arrays[var_name])
-                        comment_text = f"# {var_name} already decomposed into individual qubits: {qubit_list}"
-                        self.current_block.statements.append(
-                            Comment(comment_text),
-                        )
-                    else:
-                        # Default: pre-allocate all qubits
-                        init_expr = FunctionCall(
-                            func_name="array",
-                            args=[
-                                FunctionCall(
-                                    func_name="quantum.qubit() for _ in range",
-                                    args=[Literal(size)],
-                                ),
-                            ],
-                        )
-                        assignment = Assignment(
-                            target=VariableRef(var_name),
-                            value=init_expr,
-                        )
-                        self.current_block.statements.append(assignment)
-
-            # Track in context
-            var_info = VariableInfo(
-                name=var_name,
-                original_name=var.sym,
-                var_type="quantum",
-                size=size,
-                is_array=True,
-            )
-            self.context.add_variable(var_info)
-            self.scope_manager.current_context.add_variable(var_info)
-
-        elif var_type == "CReg":
-            # Create classical array
-            size = var.size
-            init_expr = FunctionCall(
-                func_name="array",
-                args=[
-                    FunctionCall(
-                        func_name="False for _ in range",
-                        args=[Literal(size)],
-                    ),
-                ],
-            )
-            assignment = Assignment(
-                target=VariableRef(var_name),
-                value=init_expr,
-            )
-            self.current_block.statements.append(assignment)
-
-            # Track in context
-            var_info = VariableInfo(
-                name=var_name,
-                original_name=var.sym,
-                var_type="classical",
-                size=size,
-                is_array=True,
-            )
-            self.context.add_variable(var_info)
-            self.scope_manager.current_context.add_variable(var_info)
-
-    def _block_consumes_quantum(self, block) -> bool:
-        """Check if a block consumes ALL quantum resources.
-
-        Only return True if the block consumes ALL its quantum inputs.
-        Most SLR functions modify arrays in-place without consuming them.
-
-        However, functions that access quantum fields within structs need @owned
-        annotation to satisfy Guppy's linearity requirements.
-        """
-        # For now, be very conservative - assume functions don't consume
-        # their parameters unless they're explicitly measurement blocks
-        # that measure ALL qubits
-
-        # Check the block name - only certain blocks truly consume all resources
-        block_name = type(block).__name__
-        if block_name in ["MeasureAll", "DiscardAll"]:
-            return True
-
-        # IMPORTANT: Functions that will access quantum fields within structs
-        # need @owned annotation for Guppy's linearity system
-        # Otherwise assume the function modifies in-place without consuming
-        return self._block_accesses_struct_quantum_fields(block)
-
-    def _analyze_consumed_parameters(self, block) -> set[str]:
-        """Analyze which quantum parameters are consumed by a block.
-
-        A parameter is consumed if:
-        1. It appears in a Measure operation that measures the full register
-        2. All its elements are measured individually
-        3. It's passed to a nested Block that consumes it
-        """
-        consumed_params = set()
-        element_measurements = {}  # Track which array elements are measured
-
-        if not hasattr(block, "ops"):
-            return consumed_params
-
-        # Recursively analyze all operations including nested blocks
-        def analyze_ops(ops_list):
-            for op in ops_list:
-                op_type = type(op).__name__
-
-                # Measurement consumes qubits
-                if op_type == "Measure":
-                    if hasattr(op, "qargs"):
-                        for qarg in op.qargs:
-                            # Check if it's a full register measurement (not indexed)
-                            if hasattr(qarg, "sym"):
-                                # This is a full register being measured
-                                consumed_params.add(qarg.sym)
-                            # Check for indexed measurements (e.g., q[0], q[1])
-                            elif hasattr(qarg, "reg") and hasattr(qarg.reg, "sym"):
-                                array_name = qarg.reg.sym
-                                if array_name not in element_measurements:
-                                    element_measurements[array_name] = set()
-                                if hasattr(qarg, "index"):
-                                    element_measurements[array_name].add(qarg.index)
-
-                # Check if this is a nested Block call
-                elif hasattr(op, "__class__") and hasattr(op.__class__, "__bases__"):
-                    from pecos.slr import Block as SlrBlock
-
-                    # Check if op is a Block subclass
-                    # Need to check the class itself, not just the base name
-                    try:
-                        if issubclass(op.__class__, SlrBlock) and hasattr(op, "ops"):
-                            # Recursively analyze nested block
-                            analyze_ops(op.ops)
-                    except (TypeError, AttributeError):
-                        # Not a class or missing expected attributes
-                        pass
-
-        # Analyze all operations
-        analyze_ops(block.ops)
-
-        # Check if arrays are consumed
-        # In Guppy, any measurement of array elements requires @owned annotation
-        # because it consumes those elements
-        for array_name, measured_indices in element_measurements.items():
-            # If any element is measured, the array is consumed and needs @owned
-            if len(measured_indices) > 0:
-                consumed_params.add(array_name)
-
-        return consumed_params
-
-    def _analyze_subscript_access(self, block) -> set[str]:
-        """Analyze which quantum arrays have subscript access in a block.
-
-        In Guppy, any subscript access (c_d[0]) marks the array as used,
-        requiring @owned annotation to avoid MoveOutOfSubscriptError.
-
-        Returns:
-            set of array names that have subscript access
-        """
-        subscripted_arrays = set()
-
-        if not hasattr(block, "ops"):
-            return subscripted_arrays
-
-        # Recursively analyze all operations
-        def analyze_ops(ops_list):
-            for op in ops_list:
-                # Check for any quantum operation with indexed arguments
-                if hasattr(op, "qargs"):
-                    for qarg in op.qargs:
-                        # Check for indexed access (e.g., q[0])
-                        if hasattr(qarg, "reg") and hasattr(qarg.reg, "sym"):
-                            array_name = qarg.reg.sym
-                            subscripted_arrays.add(array_name)
-                        # Also check for register-wide operations that will be converted to loops
-                        # (e.g., qubit.H(q) becomes for i in range(7): quantum.h(q[i]))
-                        elif hasattr(qarg, "sym") and hasattr(qarg, "elems") and len(qarg.elems) > 1:
-                            # This is a register-wide operation - will use subscripts
-                            array_name = qarg.sym
-                            subscripted_arrays.add(array_name)
-                        # else: qarg doesn't match expected patterns
-
-                # Check for classical array subscripts too
-                if hasattr(op, "cargs"):
-                    for carg in op.cargs:
-                        if hasattr(carg, "reg") and hasattr(carg.reg, "sym"):
-                            # This is classical, skip for now
-                            pass
-
-                # Check nested blocks
-                if hasattr(op, "__class__") and hasattr(op.__class__, "__bases__"):
-                    from pecos.slr import Block as SlrBlock
-
-                    try:
-                        if issubclass(op.__class__, SlrBlock) and hasattr(op, "ops"):
-                            analyze_ops(op.ops)
-                    except (TypeError, AttributeError):
-                        # Not a class or missing expected attributes
-                        pass
-
-        analyze_ops(block.ops)
-        return subscripted_arrays
-
-    def _analyze_block_element_usage(self, block) -> dict:
-        """Analyze which specific array elements are consumed vs returned by a block.
-
-        Returns:
-            dict: {
-                'consumed_elements': {'array_name': {consumed_indices}},
-                'array_sizes': {'array_name': size},
-                'returned_elements': {'array_name': {returned_indices}}
-            }
-        """
-        consumed_elements = {}
-        array_sizes = {}
-
-        if not hasattr(block, "ops"):
-            return {
-                "consumed_elements": consumed_elements,
-                "array_sizes": array_sizes,
-                "returned_elements": {},
-            }
-
-        # Analyze block to find measurements
-        def analyze_ops(ops_list):
-            for op in ops_list:
-                op_type = type(op).__name__
-
-                # Measurement consumes qubits
-                if op_type == "Measure":
-                    if hasattr(op, "qargs"):
-                        for qarg in op.qargs:
-                            # Check for indexed measurements (e.g., q[0])
-                            if hasattr(qarg, "reg") and hasattr(qarg.reg, "sym"):
-                                array_name = qarg.reg.sym
-                                if array_name not in consumed_elements:
-                                    consumed_elements[array_name] = set()
-                                if hasattr(qarg, "index"):
-                                    consumed_elements[array_name].add(qarg.index)
-
-                # Check if this is a nested Block call
-                elif hasattr(op, "__class__") and hasattr(op.__class__, "__bases__"):
-                    from pecos.slr import Block as SlrBlock
-
-                    try:
-                        if issubclass(op.__class__, SlrBlock) and hasattr(op, "ops"):
-                            # Recursively analyze nested block
-                            analyze_ops(op.ops)
-                    except (TypeError, AttributeError):
-                        # Not a class or missing expected attributes
-                        pass
-
-        # Get array sizes from block parameters
-        if hasattr(block, "q") and hasattr(block.q, "size"):
-            array_sizes["q"] = block.q.size
-
-        analyze_ops(block.ops)
-
-        # Pre-track explicit resets to know which consumed qubits are reset and should be returned
-        consumed_for_tracking = {}
-        self._track_consumed_qubits(block, consumed_for_tracking)
-
-        # Calculate returned elements
-        # = (all elements - consumed) + explicitly_reset
-        # Explicitly reset qubits are consumed by measurement but then recreated by Prep
-        returned_elements = {}
-        for array_name, size in array_sizes.items():
-            consumed = consumed_elements.get(array_name, set())
-            all_indices = set(range(size))
-            unconsumed = all_indices - consumed
-
-            # Add explicitly reset qubits (they're consumed but then reset, so should be returned)
-            explicitly_reset = set()
-            if hasattr(self, "explicitly_reset_qubits") and array_name in self.explicitly_reset_qubits:
-                explicitly_reset = self.explicitly_reset_qubits[array_name]
-
-            returned_elements[array_name] = unconsumed | explicitly_reset
-
-        return {
-            "consumed_elements": consumed_elements,
-            "array_sizes": array_sizes,
-            "returned_elements": returned_elements,
-        }
-
-    def _block_accesses_struct_quantum_fields(self, block) -> bool:
-        """Check if a block accesses quantum fields within structs.
-
-        This is important because Guppy's linearity system requires @owned
-        annotation for functions that access quantum fields within structs.
-        """
-        if not hasattr(block, "ops"):
-            return False
-
-        # If we have struct info, assume that functions accessing quantum operations
-        # will need to access quantum fields within structs
-        if self.struct_info:
-            # Check if this block has quantum operations
-            for op in block.ops:
-                # Check for quantum operations (gates, measurements, etc.)
-                op_name = type(op).__name__
-                if op_name in [
-                    "H",
-                    "X",
-                    "Y",
-                    "Z",
-                    "CX",
-                    "CY",
-                    "CZ",
-                    "Reset",
-                    "Measure",
-                    "S",
-                    "T",
-                    "Sdg",
-                    "Tdg",
-                ]:
-                    return True
-
-                # Also check for nested quantum operations
-                if hasattr(op, "ops") and self._block_accesses_struct_quantum_fields(
-                    op,
-                ):
-                    return True
-
-        return False
-
-    def _needs_unpacking_workaround(self, block) -> bool:
-        """Detect if a block needs the unpacking workaround for Guppy constraints."""
-        if not hasattr(block, "ops"):
-            return False
-
-        # Check for patterns that cause MoveOutOfSubscriptError
-        for op in block.ops:
-            op_type = type(op).__name__
-
-            # Reset operations on arrays are the main culprit
-            if op_type == "Prep" and hasattr(op, "qargs"):
-                for qarg in op.qargs:
-                    # If it's an array operation, it might cause issues
-                    if hasattr(qarg, "sym") and hasattr(qarg, "size") and qarg.size > 1:
-                        return True
-
-            # Multiple operations on the same array elements might cause issues
-            # This is a more complex heuristic we could add later
-
-            # Recursively check nested blocks
-            if hasattr(op, "ops") and self._needs_unpacking_workaround(op):
-                return True
-
-        return False
-
-    def _function_needs_unpacking(self, func_name: str) -> bool:
-        """Check if a function uses the unpacking pattern by analyzing function behavior.
-
-        This method analyzes the actual function operations rather than using hardcoded names,
-        making it general for all QEC codes.
-        """
-        _ = func_name  # Currently not used, reserved for future use
-        # Since this function is not currently used, return False for now
-        # In the future, this could analyze the function's block to determine
-        # if it performs operations that would benefit from unpacking
-        return False
-
-    def _function_consumes_parameters(self, func_name: str, block) -> bool:
-        """Check if a function consumes its quantum parameters (has @owned)."""
-        _ = func_name  # Currently not used, reserved for future use
-        # Check if we already know about this function
-        if hasattr(block, "ops"):
-            return self._block_consumes_quantum(block)
-
-        # Default: assume functions don't consume unless we know otherwise
-        return False
-
-    def _is_variable_used_as_function_arg(self, var_name: str, block) -> bool:
-        """Check if a variable is used as an argument to block operations (functions)."""
-        if not hasattr(block, "ops"):
-            return False
-
-        for op in block.ops:
-            # Check if this is a Block-type operation
-            if hasattr(op, "ops") and hasattr(op, "vars"):
-                # This is a block - check variables used by operations inside it
-                # Since constructor arguments aren't preserved, we need to analyze the inner operations
-                for inner_op in op.ops:
-                    # Check quantum arguments
-                    if hasattr(inner_op, "qargs"):
-                        for qarg in inner_op.qargs:
-                            if hasattr(qarg, "reg") and hasattr(qarg.reg, "sym"):
-                                if qarg.reg.sym == var_name:
-                                    return True
-                            elif hasattr(qarg, "sym") and qarg.sym == var_name:
-                                return True
-
-                    # Check measurement targets
-                    if hasattr(inner_op, "cout") and inner_op.cout:
-                        for cout in inner_op.cout:
-                            if hasattr(cout, "reg") and hasattr(cout.reg, "sym"):
-                                if cout.reg.sym == var_name:
-                                    return True
-                            elif hasattr(cout, "sym") and cout.sym == var_name:
-                                return True
-
-        return False
-
-    def _create_array_unpack_statement(
-        self,
-        array_name: str,
-        element_names: list[str],
-    ) -> Statement:
-        """Create an array unpacking statement: q_0, q_1, q_2 = q"""
-
-        class ArrayUnpackStatement(Statement):
-            def __init__(self, targets, source):
-                self.targets = targets
-                self.source = source
-
-            def analyze(self, context):
-                _ = context  # Not used
-
-            def render(self, context):
-                _ = context  # Not used
-                # For single element unpacking, we need a trailing comma
-                target_str = self.targets[0] + "," if len(self.targets) == 1 else ", ".join(self.targets)
-                return [f"{target_str} = {self.source}"]
-
-        return ArrayUnpackStatement(element_names, array_name)
-
-    def _create_array_construction(self, element_names: list[str]) -> Expression:
-        """Create an array construction expression: array([q_0, q_1, q_2])"""
-
-        class ArrayConstructionExpression(Expression):
-            def __init__(self, elements):
-                self.elements = elements
-
-            def analyze(self, context):
-                _ = context  # Not used
-
-            def render(self, context):
-                _ = context  # Not used
-                element_str = ", ".join(self.elements)
-                return [f"array({element_str})"]
-
-        return ArrayConstructionExpression(element_names)
-
-    def _create_array_reconstruction(self, element_names: list[str]) -> Expression:
-        """Create an array reconstruction expression for returns: array([q_0, q_1])"""
-
-        # Apply variable remapping to get the latest names
-        # Use function_var_remapping if available (includes Prep changes)
-        remapping = (
-            self.function_var_remapping
-            if hasattr(self, "function_var_remapping")
-            else self.variable_remapping if hasattr(self, "variable_remapping") else {}
-        )
-        remapped_element_names = [remapping.get(elem, elem) for elem in element_names]
-
-        class ArrayReconstructionExpression(Expression):
-            def __init__(self, elements):
-                self.elements = elements
-
-            def analyze(self, context):
-                _ = context  # Not used
-
-            def render(self, context):
-                _ = context  # Not used
-                element_str = ", ".join(self.elements)
-                return [f"array({element_str})"]
-
-        return ArrayReconstructionExpression(remapped_element_names)
-
-    def _create_struct_construction(
-        self,
-        struct_name: str,
-        field_names: list[str],
-        field_values: list[Expression],
-    ) -> Expression:
-        """Create a struct construction expression."""
-
-        class StructConstructionExpression(Expression):
-            def __init__(self, struct_name, field_names, field_values):
-                self.struct_name = struct_name
-                self.field_names = field_names
-                self.field_values = field_values
-
-            def analyze(self, context):
-                for value in self.field_values:
-                    value.analyze(context)
-
-            def render(self, context):
-                # Render as struct_name(value1, value2, ...) - positional args only
-                # Guppy doesn't support keyword arguments in struct construction
-                field_values_str = []
-                for value in self.field_values:
-                    value_str = value.render(context)[0]
-                    field_values_str.append(value_str)
-                return [f"{self.struct_name}({', '.join(field_values_str)})"]
-
-        return StructConstructionExpression(struct_name, field_names, field_values)
-
-    def _add_array_unpacking(self, array_name: str, size: int) -> None:
-        """Add array unpacking statement."""
-        # Check if this array is already unpacked in the current context
-        if hasattr(self, "unpacked_vars") and array_name in self.unpacked_vars:
-            # Array is already unpacked, don't unpack again
-            return
-
-        # Get the actual variable name (might be renamed)
-        actual_name = array_name
-        if array_name in self.plan.renamed_variables:
-            actual_name = self.plan.renamed_variables[array_name]
-
-        # Generate unpacked names
-        unpacked_names = [self._get_unique_var_name(array_name, i) for i in range(size)]
-
-        # Track unpacked vars in the builder
-        self.unpacked_vars[array_name] = unpacked_names
-
-        # Comment already added by caller, don't add another one
-
-        # Add unpacking statement
-        unpack = ArrayUnpack(
-            targets=unpacked_names,
-            source=actual_name,
-        )
-        self.current_block.statements.append(unpack)
-
-        # Update variable info
-        var = self.context.lookup_variable(actual_name)
-        if var:
-            var.is_unpacked = True
-            var.unpacked_names = unpacked_names
-
-    def _is_prep_rus_block(self, op) -> bool:
-        """Check if this is a PrepRUS block that needs special handling."""
-        return hasattr(op, "block_name") and op.block_name == "PrepRUS"
-
-    def _convert_prep_rus_special(self, op) -> Statement | None:
-        """Special conversion for PrepRUS to avoid linearity issues."""
-        # PrepRUS has a specific pattern that causes issues:
-        # 1. PrepEncodingFTZero creates fresh variables
-        # 2. Repeat with conditional PrepEncodingFTZero
-        # 3. LogZeroRot uses the variables
-
-        # We'll generate a simplified version that avoids the conditional consumption
-        self.current_block.statements.append(
-            Comment("Special handling for PrepRUS to avoid linearity issues"),
-        )
-
-        # Process the operations in PrepRUS
-        if hasattr(op, "ops"):
-            for sub_op in op.ops:
-                # Skip the Repeat block with conditional consumption
-                if type(sub_op).__name__ == "Repeat":
-                    # Instead of the loop with conditional, just do it once unconditionally
-                    self.current_block.statements.append(
-                        Comment("Simplified repeat to avoid conditional consumption"),
-                    )
-                    # Don't process the Repeat block
-                    continue
-
-                # Process other operations normally
-                stmt = self._convert_operation(sub_op)
-                if stmt:
-                    self.current_block.statements.append(stmt)
-
-        return None
-
-    def _convert_operation(self, op) -> Statement | None:
-        """Convert an SLR operation to IR statement."""
-        op_type = type(op).__name__
-
-        if op_type == "Measure":
-            return self._convert_measurement(op)
-        if op_type == "If":
-            return self._convert_if(op)
-        if op_type == "While":
-            return self._convert_while(op)
-        if op_type == "For":
-            return self._convert_for(op)
-        if op_type == "Repeat":
-            return self._convert_repeat(op)
-        if op_type == "Comment":
-            return self._convert_comment(op)
-        if op_type == "Permute":
-            return self._convert_permute(op)
-        if hasattr(op, "qargs"):
-            stmt = self._convert_quantum_gate(op)
-            # Handle case where quantum gate returns a Block
-            if stmt and type(stmt).__name__ == "Block":
-                # Add all statements from the block
-                for s in stmt.statements:
-                    self.current_block.statements.append(s)
-                return None  # Already added
-            return stmt
-        if hasattr(op, "ops") and hasattr(op, "vars"):
-            # This is a block - convert to function call
-            return self._convert_block_call(op)
-        if op_type == "SET":
-            # Classical bit assignment
-            return self._convert_set_operation(op)
-        if op_type == "Barrier":
-            # Barriers are just synchronization points, ignore in Guppy
-            return None
-        if op_type == "Return":
-            # Return is metadata for type checking and block analysis
-            # The actual return handling is done by the function generation code
-            return None
-
-        # Unknown operation
-        return Comment(f"TODO: Handle {op_type}")
-
-    def _convert_measurement(self, meas) -> Statement | None:
-        """Convert measurement operation."""
-        if not hasattr(meas, "qargs") or not meas.qargs:
-            return None
-
-        # Check if we're measuring a struct field qubit with @owned struct
-        if hasattr(meas, "qargs") and len(meas.qargs) > 0:
-            qarg = meas.qargs[0]
-            if hasattr(qarg, "reg") and hasattr(qarg.reg, "sym"):
-                array_name = qarg.reg.sym
-                # Check if this is a struct field
-                for info in self.struct_info.values():
-                    if (
-                        array_name in info["var_names"].values()
-                        and hasattr(self, "function_info")
-                        and hasattr(self, "current_function_name")
-                    ):
-                        func_info = self.function_info.get(
-                            self.current_function_name,
-                            {},
-                        )
-                        if func_info.get("has_owned_struct_params", False):
-                            # This is a known limitation - add a warning comment
-                            self.current_block.statements.append(
-                                Comment(
-                                    "WARNING: Measuring qubits from @owned struct arrays "
-                                    "is not supported by guppylang",
-                                ),
-                            )
-                            self.current_block.statements.append(
-                                Comment(
-                                    "This will cause a MoveOutOfSubscriptError during compilation",
-                                ),
-                            )
-
-        # Check if we're in a function that takes and returns a struct
-        # If so, we need to be careful about struct field access
-        if hasattr(self, "current_function_params"):
-            for param_name, param_type in self.current_function_params:
-                if "_struct" in str(param_type) and "@owned" not in str(param_type):
-                    break
-
-        # Check if this is a full array measurement
-        if (
-            len(meas.qargs) == 1
-            and hasattr(meas.qargs[0], "sym")
-            and hasattr(meas.qargs[0], "size")
-            and meas.qargs[0].size >= 1
-        ):
-            # Full array measurement
-            qreg = meas.qargs[0]
-
-            # Track full array consumption globally
-            if not hasattr(self, "consumed_resources"):
-                self.consumed_resources = {}
-            if qreg.sym not in self.consumed_resources:
-                self.consumed_resources[qreg.sym] = set()
-            self.consumed_resources[qreg.sym].update(range(qreg.size))
-
-            # Track in scope manager too
-            self.scope_manager.track_resource_usage(
-                qreg.sym,
-                set(range(qreg.size)),
-                consumed=True,
-            )
-
-            # Check if this array was dynamically allocated
-            if hasattr(self, "dynamic_allocations") and qreg.sym in self.dynamic_allocations:
-                # For dynamically allocated arrays, we need to handle this differently
-                # Generate individual measurements
-                stmts = []
-
-                # Check for target
-                if hasattr(meas, "cout") and meas.cout and len(meas.cout) == 1:
-                    cout = meas.cout[0]
-                    if hasattr(cout, "sym"):
-                        creg_name = cout.sym
-                        # Measure each individual qubit
-                        for i in range(qreg.size):
-                            ancilla_var = self._get_unique_var_name(qreg.sym, i)
-                            # Allocate if not already allocated
-                            if not hasattr(self, "allocated_ancillas"):
-                                self.allocated_ancillas = set()
-                            if ancilla_var not in self.allocated_ancillas:
-                                alloc_stmt = Assignment(
-                                    target=VariableRef(ancilla_var),
-                                    value=FunctionCall(
-                                        func_name="quantum.qubit",
-                                        args=[],
-                                    ),
-                                )
-                                stmts.append(alloc_stmt)
-                                self.allocated_ancillas.add(ancilla_var)
-
-                            # Measure individual qubit
-                            meas_call = FunctionCall(
-                                func_name="quantum.measure",
-                                args=[VariableRef(ancilla_var)],
-                            )
-                            creg_access = ArrayAccess(array_name=creg_name, index=i)
-                            assign = Assignment(target=creg_access, value=meas_call)
-                            stmts.append(assign)
-
-                        # Return block with all statements
-                        if len(stmts) == 1:
-                            return stmts[0]
-                        return Block(statements=stmts)
-                else:
-                    # No target - measure individual qubits without storing
-                    for i in range(qreg.size):
-                        # Use consistent mapping from (array_name, index) to variable name
-                        if not hasattr(self, "allocated_qubit_vars"):
-                            self.allocated_qubit_vars = {}
-
-                        array_index_key = (qreg.sym, i)
-
-                        # Check if we already have a variable for this array element
-                        if array_index_key in self.allocated_qubit_vars:
-                            ancilla_var = self.allocated_qubit_vars[array_index_key]
-                        else:
-                            # Create a new variable name for this specific array element
-                            ancilla_var = self._get_unique_var_name(qreg.sym, i)
-                            self.allocated_qubit_vars[array_index_key] = ancilla_var
-
-                            alloc_stmt = Assignment(
-                                target=VariableRef(ancilla_var),
-                                value=FunctionCall(func_name="quantum.qubit", args=[]),
-                            )
-                            stmts.append(alloc_stmt)
-
-                        # Measure and discard result
-                        meas_call = FunctionCall(
-                            func_name="quantum.measure",
-                            args=[VariableRef(ancilla_var)],
-                        )
-
-                        class ExpressionStatement(Statement):
-                            def __init__(self, expr):
-                                self.expr = expr
-
-                            def analyze(self, context):
-                                self.expr.analyze(context)
-
-                            def render(self, context):
-                                return f"_ = {self.expr.render(context)}"
-
-                        stmts.append(ExpressionStatement(meas_call))
-
-                    if len(stmts) == 1:
-                        return stmts[0]
-                    return Block(statements=stmts)
-            else:
-                # Regular pre-allocated array - use measure_array
-                qreg_ref = self._convert_qubit_ref(qreg)
-
-                # If the array was previously unpacked (e.g., to access an
-                # individual element after a function call returned it),
-                # Guppy considers the original variable name consumed by
-                # the unpack. Repack from the element vars so measure_array
-                # can take the whole array as input. We emit the repack
-                # statement *prepended* to whatever statement(s) the rest
-                # of this branch produces (see `_prepend_to_result`).
-                #
-                # var_state and the legacy `unpacked_vars` dict are both
-                # updated so other code paths agree the array is whole again.
-                repack_stmt = None
-                if hasattr(qreg, "sym") and self.var_state.is_unpacked(qreg.sym):
-                    binding = self.var_state.get(qreg.sym)
-                    repack_stmt = Assignment(
-                        target=VariableRef(qreg.sym),
-                        value=self._create_array_reconstruction(list(binding.element_names)),
-                    )
-                    self.var_state.bind_whole(qreg.sym, qreg.sym)
-                    if hasattr(self, "unpacked_vars") and qreg.sym in self.unpacked_vars:
-                        del self.unpacked_vars[qreg.sym]
-                    if hasattr(self, "context"):
-                        var = self.context.lookup_variable(qreg.sym)
-                        if var:
-                            var.is_unpacked = False
-                            var.unpacked_names = []
-                    # qreg_ref was computed *before* the repack -- recompute
-                    # so it points at the now-whole array, not stale unpacked
-                    # element variables.
-                    qreg_ref = self._convert_qubit_ref(qreg)
-
-                # Mark fresh variable as used if this is measuring a fresh variable
-                if hasattr(self, "fresh_variables_to_track") and hasattr(
-                    self,
-                    "refreshed_arrays",
-                ):
-                    # Check if qreg is using a fresh variable
-                    for orig_name, fresh_name in self.refreshed_arrays.items():
-                        if fresh_name in self.fresh_variables_to_track and orig_name == qreg.sym:
-                            # Mark this fresh variable as used
-                            self.fresh_variables_to_track[fresh_name]["used"] = True
-                            break
-
-                # Check for target
-                if hasattr(meas, "cout") and meas.cout and len(meas.cout) == 1:
-                    cout = meas.cout[0]
-                    if hasattr(cout, "sym"):
-                        # Check for renamed variable
-                        creg_name = cout.sym
-                        if creg_name in self.plan.renamed_variables:
-                            creg_name = self.plan.renamed_variables[creg_name]
-
-                        # Check if this variable is remapped (e.g., function parameter)
-                        is_function_param = False
-                        if hasattr(self, "var_remapping") and creg_name in self.var_remapping:
-                            creg_name = self.var_remapping[creg_name]
-                            # Check if this is a function parameter (not in main)
-                            is_function_param = (
-                                hasattr(self, "current_function_name") and self.current_function_name != "main"
-                            )
-
-                        # For function parameters (classical arrays), we need to update in-place
-                        # to avoid BorrowShadowedError
-                        if is_function_param:
-                            # Generate element-wise measurements
-                            stmts = []
-
-                            # IMPORTANT: Do NOT automatically replace qubits after measurement
-                            # The old logic tried to maintain array size, but this breaks partial consumption.
-                            # Only replace if allocation optimizer detected reuse.
-                            should_replace = False  # Disabled automatic replacement
-
-                            for i in range(qreg.size):
-                                # Check if the quantum array was unpacked
-                                if hasattr(self, "unpacked_vars") and qreg.sym in self.unpacked_vars:
-                                    # Use unpacked variable
-                                    element_names = self.unpacked_vars[qreg.sym]
-                                    qubit_ref = VariableRef(element_names[i])
-                                    qubit_var_name = element_names[i]
-                                else:
-                                    # Use array access
-                                    qubit_ref = ArrayAccess(
-                                        array_name=(
-                                            self._convert_qubit_ref(qreg).name
-                                            if hasattr(
-                                                self._convert_qubit_ref(qreg),
-                                                "name",
-                                            )
-                                            else qreg.sym
-                                        ),
-                                        index=i,
-                                    )
-                                    qubit_var_name = None
-
-                                meas_call = FunctionCall(
-                                    func_name="quantum.measure",
-                                    args=[qubit_ref],
-                                )
-                                # Assign to array element
-                                creg_access = ArrayAccess(array_name=creg_name, index=i)
-                                assign = Assignment(target=creg_access, value=meas_call)
-                                stmts.append(assign)
-
-                                # Replace measured qubit with fresh one if needed
-                                if should_replace and qubit_var_name:
-                                    replacement_stmt = Assignment(
-                                        target=VariableRef(qubit_var_name),
-                                        value=FunctionCall(
-                                            func_name="quantum.qubit",
-                                            args=[],
-                                        ),
-                                    )
-                                    stmts.append(replacement_stmt)
-
-                                    # Track that this qubit was replaced
-                                    if not hasattr(self, "replaced_qubits"):
-                                        self.replaced_qubits = {}
-                                    if qreg.sym not in self.replaced_qubits:
-                                        self.replaced_qubits[qreg.sym] = set()
-                                    self.replaced_qubits[qreg.sym].add(i)
-
-                            # Return block with all statements
-                            if len(stmts) == 1:
-                                return stmts[0]
-                            return Block(statements=stmts)
-                        # Not a function parameter - can reassign whole array
-                        creg_ref = VariableRef(creg_name)
-                        # Generate measure_array
-                        call = FunctionCall(
-                            func_name="quantum.measure_array",
-                            args=[qreg_ref],
-                        )
-                        result = Assignment(target=creg_ref, value=call)
-                        if repack_stmt is not None:
-                            return Block(statements=[repack_stmt, result])
-                        return result
-
-                # No target - just measure
-                call = FunctionCall(
-                    func_name="quantum.measure_array",
-                    args=[qreg_ref],
-                )
-
-                # Create expression statement wrapper
-                class ExpressionStatement(Statement):
-                    def __init__(self, expr):
-                        self.expr = expr
-
-                    def analyze(self, context):
-                        self.expr.analyze(context)
-
-                    def render(self, context):
-                        return self.expr.render(context)
-
-                result = ExpressionStatement(call)
-                if repack_stmt is not None:
-                    return Block(statements=[repack_stmt, result])
-                return result
-
-        # Handle single qubit measurement
-        if len(meas.qargs) == 1:
-            qarg = meas.qargs[0]
-            qubit_ref = self._convert_qubit_ref(qarg)
-
-            # Get target if specified
-            target_ref = None
-            if hasattr(meas, "cout") and meas.cout and len(meas.cout) == 1:
-                cout = meas.cout[0]
-                # For measurements, the target should use unpacked names if available
-                # So we pass is_assignment_target=False to use unpacked names
-                target_ref = self._convert_bit_ref(cout, is_assignment_target=False)
-
-            # Track resource consumption for linearity checking
-            if hasattr(qarg, "reg") and hasattr(qarg.reg, "sym") and hasattr(qarg, "index"):
-                array_name = qarg.reg.sym
-                qubit_index = qarg.index
-                self.scope_manager.track_resource_usage(
-                    array_name,
-                    {qubit_index},
-                    consumed=True,
-                )
-
-                # Also track globally for conditional resource balancing
-                if not hasattr(self, "consumed_resources"):
-                    self.consumed_resources = {}
-                if array_name not in self.consumed_resources:
-                    self.consumed_resources[array_name] = set()
-                self.consumed_resources[array_name].add(qubit_index)
-
-            # Generate measurement statement
-            meas_stmt = Measurement(qubit=qubit_ref, target=target_ref)
-
-            # IMPORTANT: Do NOT automatically replace measured qubits!
-            # The old "black box pattern" logic assumed functions should maintain array size,
-            # but this breaks partial consumption patterns where a function consumes some qubits
-            # and returns others. Only explicit Prep operations should create fresh qubits.
-            #
-            # The correct behavior:
-            # - Measure consumes the qubit → it's gone
-            # - If user wants to reset, they use explicit Prep(q[i]) → creates fresh qubit
-            # - Function returns only the qubits that weren't consumed
-            #
-            # Check if this qubit is marked as needing replacement due to reuse
-            # (e.g., unified analysis detected it's used again after consumption)
-            needs_replacement_for_reuse = False
-            if self.unified_analysis and hasattr(qarg, "reg") and hasattr(qarg.reg, "sym") and hasattr(qarg, "index"):
-                array_name = qarg.reg.sym
-                qubit_index = qarg.index
-                resource_plan = self.unified_analysis.get_plan(array_name)
-                if resource_plan and qubit_index in resource_plan.elements_requiring_replacement:
-                    # CRITICAL: Check if the next operation is a Prep on this same qubit
-                    # If so, skip measurement replacement - let Prep handle it
-                    next_op_is_prep_on_same_qubit = False
-                    if (
-                        hasattr(self, "current_block_ops")
-                        and hasattr(self, "current_op_index")
-                        and self.current_block_ops is not None
-                        and self.current_op_index is not None
-                    ):
-                        next_index = self.current_op_index + 1
-                        if next_index < len(self.current_block_ops):
-                            next_op = self.current_block_ops[next_index]
-                            # Check if next operation is Prep on the same qubit
-                            if type(next_op).__name__ == "Prep" and hasattr(
-                                next_op,
-                                "qargs",
-                            ):
-                                for prep_qarg in next_op.qargs:
-                                    if (
-                                        hasattr(prep_qarg, "reg")
-                                        and hasattr(prep_qarg.reg, "sym")
-                                        and prep_qarg.reg.sym == array_name
-                                        and hasattr(prep_qarg, "index")
-                                        and prep_qarg.index == qubit_index
-                                    ):
-                                        next_op_is_prep_on_same_qubit = True
-                                        break
-
-                    if not next_op_is_prep_on_same_qubit:
-                        # No Prep follows - we need to replace the qubit
-                        needs_replacement_for_reuse = True
-
-            # Only replace if allocation optimizer determined it's reused
-            if (
-                needs_replacement_for_reuse
-                and hasattr(self, "unpacked_vars")
-                and hasattr(qarg, "reg")
-                and hasattr(qarg.reg, "sym")
-                and hasattr(qarg, "index")
-            ):
-                array_name = qarg.reg.sym
-                qubit_index = qarg.index
-
-                # Check if this array is unpacked in current function
-                if array_name in self.unpacked_vars:
-                    element_names = self.unpacked_vars[array_name]
-                    if qubit_index < len(element_names):
-                        # Replace the measured qubit with a fresh one
-                        replacement_stmt = Assignment(
-                            target=VariableRef(element_names[qubit_index]),
-                            value=FunctionCall(func_name="quantum.qubit", args=[]),
-                        )
-
-                        # Track that this qubit was replaced (not consumed)
-                        if not hasattr(self, "replaced_qubits"):
-                            self.replaced_qubits = {}
-                        if array_name not in self.replaced_qubits:
-                            self.replaced_qubits[array_name] = set()
-                        self.replaced_qubits[array_name].add(qubit_index)
-
-                        # Return a block with measurement followed by replacement
-                        statements = [meas_stmt, replacement_stmt]
-                        return Block(statements=statements)
-
-            return meas_stmt
-
-        # Handle multi-qubit measurements by generating multiple single-qubit measurements
-        if len(meas.qargs) > 1:
-            # Verify we have corresponding classical outputs
-            if not hasattr(meas, "cout") or not meas.cout:
-                # No classical outputs specified - generate measurements without targets
-                measurements = []
-                for qarg in meas.qargs:
-                    qubit_ref = self._convert_qubit_ref(qarg)
-
-                    # Track resource consumption for each qubit
-                    if hasattr(qarg, "reg") and hasattr(qarg.reg, "sym") and hasattr(qarg, "index"):
-                        array_name = qarg.reg.sym
-                        qubit_index = qarg.index
-                        self.scope_manager.track_resource_usage(
-                            array_name,
-                            {qubit_index},
-                            consumed=True,
-                        )
-
-                        # Also track globally for conditional resource balancing
-                        if not hasattr(self, "consumed_resources"):
-                            self.consumed_resources = {}
-                        if array_name not in self.consumed_resources:
-                            self.consumed_resources[array_name] = set()
-                        self.consumed_resources[array_name].add(qubit_index)
-
-                    meas_stmt = Measurement(qubit=qubit_ref, target=None)
-                    measurements.append(meas_stmt)
-
-                return Block(statements=measurements)
-
-            # Multi-qubit measurement with classical outputs
-            if len(meas.cout) != len(meas.qargs):
-                # Mismatch between number of qubits and classical outputs
-                return Comment(
-                    f"ERROR: Multi-qubit measurement has {len(meas.qargs)} qubits "
-                    f"but {len(meas.cout)} classical outputs",
-                )
-
-            # Generate one measurement statement for each qubit-bit pair
-            measurements = []
-            for qarg, cout in zip(meas.qargs, meas.cout):
-                qubit_ref = self._convert_qubit_ref(qarg)
-                target_ref = self._convert_bit_ref(cout, is_assignment_target=False)
-
-                # Track resource consumption for each qubit
-                if hasattr(qarg, "reg") and hasattr(qarg.reg, "sym") and hasattr(qarg, "index"):
-                    array_name = qarg.reg.sym
-                    qubit_index = qarg.index
-                    self.scope_manager.track_resource_usage(
-                        array_name,
-                        {qubit_index},
-                        consumed=True,
-                    )
-
-                    # Also track globally for conditional resource balancing
-                    if not hasattr(self, "consumed_resources"):
-                        self.consumed_resources = {}
-                    if array_name not in self.consumed_resources:
-                        self.consumed_resources[array_name] = set()
-                    self.consumed_resources[array_name].add(qubit_index)
-
-                # Generate measurement statement
-                meas_stmt = Measurement(qubit=qubit_ref, target=target_ref)
-                measurements.append(meas_stmt)
-
-            # Return a block containing all the measurements
-            return Block(statements=measurements)
-
-        # Shouldn't reach here, but just in case
-        return Comment(f"Unhandled measurement with {len(meas.qargs)} qubits")
-
-    def _convert_qubit_ref(self, qarg) -> IRNode:
-        """Convert a qubit reference to IR."""
-        if hasattr(qarg, "reg") and hasattr(qarg.reg, "sym"):
-            array_name = qarg.reg.sym
-            original_array = array_name
-
-            # Check if this array has been remapped to a reconstructed name
-            if hasattr(self, "array_remapping") and array_name in self.array_remapping:
-                # Use the reconstructed array name instead
-                remapped_name = self.array_remapping[array_name]
-
-                # Check if the original array was unpacked after remapping
-                # If it was, use the unpacked variables instead of array indexing
-                if hasattr(self, "unpacked_vars") and array_name in self.unpacked_vars and hasattr(qarg, "index"):
-                    element_names = self.unpacked_vars[array_name]
-
-                    # CRITICAL: Check if we have index mapping for partial consumption
-                    # If so, map original index to unpacked variable index
-                    if hasattr(self, "index_mapping") and array_name in self.index_mapping:
-                        mapped_index = self.index_mapping[array_name].get(qarg.index)
-                        if mapped_index is not None and mapped_index < len(
-                            element_names,
-                        ):
-                            var_name = element_names[mapped_index]
-                            # Apply variable remapping if exists
-                            var_name = self.variable_remapping.get(var_name, var_name)
-                            return VariableRef(var_name)
-                    elif qarg.index < len(element_names) and element_names[qarg.index] is not None:
-                        # No index mapping - use direct indexing (full array return)
-                        var_name = element_names[qarg.index]
-                        # Apply variable remapping if exists
-                        var_name = self.variable_remapping.get(var_name, var_name)
-                        return VariableRef(var_name)
-
-                # Not unpacked, use array indexing with remapped name
-                if hasattr(qarg, "index"):
-                    return ArrayAccess(
-                        array=VariableRef(remapped_name),
-                        index=qarg.index,
-                        force_array_syntax=True,  # Force array syntax for remapped arrays
-                    )
-
-            # Check if this array has been refreshed by function call
-            # If it was refreshed AND then unpacked, use the unpacked variables
-            if hasattr(self, "refreshed_arrays") and array_name in self.refreshed_arrays and hasattr(qarg, "index"):
-                # Array was refreshed by function call
-                fresh_array_name = self.refreshed_arrays[array_name]
-
-                # Check if the original array name was unpacked after refresh
-                # (the unpacked_vars gets updated to point to the new unpacked elements)
-                if hasattr(self, "unpacked_vars") and array_name in self.unpacked_vars:
-                    # It was unpacked after being refreshed - use unpacked variables
-                    element_names = self.unpacked_vars[array_name]
-
-                    # CRITICAL: Check if we have index mapping for partial consumption
-                    # If so, map original index to unpacked variable index
-                    if hasattr(self, "index_mapping") and array_name in self.index_mapping:
-                        # Map original index to position in returned array
-                        mapped_index = self.index_mapping[array_name].get(qarg.index)
-                        if mapped_index is not None and mapped_index < len(
-                            element_names,
-                        ):
-                            var_name = element_names[mapped_index]
-                            # Apply variable remapping if exists
-                            var_name = self.variable_remapping.get(var_name, var_name)
-                            return VariableRef(var_name)
-                    elif qarg.index < len(element_names) and element_names[qarg.index] is not None:
-                        # No index mapping - use direct indexing (full array return)
-                        var_name = element_names[qarg.index]
-                        # Apply variable remapping if exists
-                        var_name = self.variable_remapping.get(var_name, var_name)
-                        return VariableRef(var_name)
-
-                # Also check if the fresh array itself was unpacked
-                if hasattr(self, "unpacked_vars") and fresh_array_name in self.unpacked_vars:
-                    element_names = self.unpacked_vars[fresh_array_name]
-                    if qarg.index < len(element_names) and element_names[qarg.index] is not None:
-                        var_name = element_names[qarg.index]
-                        # Apply variable remapping if exists
-                        var_name = self.variable_remapping.get(var_name, var_name)
-                        return VariableRef(var_name)
-
-                # Not unpacked - use array indexing on fresh name
-                return ArrayAccess(
-                    array=VariableRef(fresh_array_name),
-                    index=qarg.index,
-                    force_array_syntax=True,  # Force array syntax for refreshed arrays
-                )
-
-            # Check if this array has been unpacked (for ancilla arrays with @owned)
-            if hasattr(self, "unpacked_vars") and array_name in self.unpacked_vars and hasattr(qarg, "index"):
-                # This array was unpacked - use the unpacked variable directly
-                element_names = self.unpacked_vars[array_name]
-                if qarg.index < len(element_names) and element_names[qarg.index] is not None:
-                    var_name = element_names[qarg.index]
-                    # Apply variable remapping if exists
-                    var_name = self.variable_remapping.get(var_name, var_name)
-                    return VariableRef(var_name)
-                if qarg.index < len(element_names) and element_names[qarg.index] is None:
-                    # This element was consumed - this is an error case but let's fallback
-                    pass
-
-            # Check if this variable is mapped to a struct field (for @owned structs)
-            if hasattr(self, "struct_field_mapping") and original_array in self.struct_field_mapping:
-                struct_field_path = self.struct_field_mapping[original_array]
-                if "." in struct_field_path:
-                    struct_name, field_name = struct_field_path.split(".", 1)
-                    if hasattr(qarg, "index"):
-                        # Return struct.field[index]
-                        field_access = FieldAccess(
-                            obj=VariableRef(struct_name),
-                            field=field_name,
-                        )
-                        return ArrayAccess(array=field_access, index=qarg.index)
-                    # Return struct.field
-                    return FieldAccess(obj=VariableRef(struct_name), field=field_name)
-
-            # Check if this is a dynamically allocated array (ancilla)
-            if (
-                hasattr(self, "dynamic_allocations")
-                and original_array in self.dynamic_allocations
-                and hasattr(qarg, "index")
-            ):
-                # Use a consistent mapping from (array_name, index) to variable name
-                if not hasattr(self, "allocated_qubit_vars"):
-                    self.allocated_qubit_vars = {}
-
-                array_index_key = (original_array, qarg.index)
-
-                # Check if we already have a variable for this array element
-                if array_index_key in self.allocated_qubit_vars:
-                    var_name = self.allocated_qubit_vars[array_index_key]
-                    # Apply variable remapping if exists (for Prep operations)
-                    var_name = self.variable_remapping.get(var_name, var_name)
-                    return VariableRef(var_name)
-
-                # Create a new variable name for this specific array element
-                ancilla_var = self._get_unique_var_name(original_array, qarg.index)
-
-                # Record the mapping and allocate the qubit
-                self.allocated_qubit_vars[array_index_key] = ancilla_var
-
-                # Also track in allocated_ancillas for cleanup
-                if not hasattr(self, "allocated_ancillas"):
-                    self.allocated_ancillas = set()
-                self.allocated_ancillas.add(ancilla_var)
-
-                alloc_stmt = Assignment(
-                    target=VariableRef(ancilla_var),
-                    value=FunctionCall(func_name="quantum.qubit", args=[]),
-                )
-                self.current_block.statements.append(alloc_stmt)
-
-                # Apply variable remapping if exists (for Prep operations)
-                var_name = self.variable_remapping.get(ancilla_var, ancilla_var)
-                return VariableRef(var_name)
-
-            # Check if this variable is part of a struct and has been unpacked
-            if hasattr(self, "var_remapping") and original_array in self.var_remapping:
-                # Use the unpacked field variable
-                unpacked_var_name = self.var_remapping[original_array]
-                if hasattr(qarg, "index"):
-                    # Array element access with unpacked variable: c_d[0]
-                    return ArrayAccess(
-                        array=VariableRef(unpacked_var_name),
-                        index=qarg.index,
-                    )
-                # Full array access with unpacked variable: c_d
-                return VariableRef(unpacked_var_name)
-
-            # Check if this array is part of a struct (fallback)
-            for prefix, info in self.struct_info.items():
-                if array_name in info["var_names"].values():
-                    # This is a struct field
-                    suffix = next(k for k, v in info["var_names"].items() if v == array_name)
-
-                    # Check if we're in a function that takes this struct as parameter
-                    struct_param_name = prefix  # Default to the struct name
-                    if hasattr(self, "param_mapping") and prefix in self.param_mapping:
-                        struct_param_name = self.param_mapping[prefix]
-
-                    # Check if the struct has a fresh version (after function calls)
-                    if hasattr(self, "refreshed_arrays") and prefix in self.refreshed_arrays:
-                        struct_param_name = self.refreshed_arrays[prefix]
-
-                    if hasattr(qarg, "index"):
-                        # Struct field element access: c.d[0]
-                        field_access = FieldAccess(
-                            obj=VariableRef(struct_param_name),
-                            field=suffix,
-                        )
-                        return ArrayAccess(array=field_access, index=qarg.index)
-                    # Full struct field access: c.d
-                    return FieldAccess(obj=VariableRef(struct_param_name), field=suffix)
-
-            # Check if we're inside a function and need to use remapped names
-            if hasattr(self, "var_remapping") and original_array in self.var_remapping:
-                array_name = self.var_remapping[original_array]
-
-            # Check for renaming
-            if array_name in self.plan.renamed_variables:
-                array_name = self.plan.renamed_variables[array_name]
-
-            if hasattr(qarg, "index"):
-                # Array Unpacking Pattern: use unpacked variable names instead of array indexing
-                # Check both the original name and any remapped name
-                check_names = [original_array]
-                if hasattr(self, "var_remapping") and original_array in self.var_remapping:
-                    check_names.append(self.var_remapping[original_array])
-                if array_name != original_array:
-                    check_names.append(array_name)
-
-                # Try each possible name for unpacked variables
-                for check_name in check_names:
-                    if (
-                        hasattr(self, "unpacked_vars")
-                        and check_name in self.unpacked_vars
-                        # Don't use unpacked variables if the array was refreshed
-                        and check_name not in self.refreshed_arrays
-                    ):
-                        element_names = self.unpacked_vars[check_name]
-                        if qarg.index < len(element_names):
-                            var_name = element_names[qarg.index]
-                            # Apply variable remapping if exists
-                            var_name = self.variable_remapping.get(var_name, var_name)
-                            return VariableRef(var_name)
-
-                # Check if this element should be allocated locally
-                resource_plan = None
-                if self.unified_analysis:
-                    resource_plan = self.unified_analysis.get_plan(original_array)
-                if resource_plan and qarg.index in resource_plan.elements_to_allocate_locally:
-                    # This element should be allocated locally
-                    local_var_name = f"{original_array}_{qarg.index}_local"
-
-                    # Add local allocation if not already done
-                    if not hasattr(self, "_local_allocations"):
-                        self._local_allocations = set()
-
-                    if local_var_name not in self._local_allocations:
-                        self._local_allocations.add(local_var_name)
-                        # Add allocation statement
-                        alloc_stmt = Assignment(
-                            target=VariableRef(local_var_name),
-                            value=FunctionCall(func_name="quantum.qubit", args=[]),
-                        )
-                        self.current_block.statements.append(alloc_stmt)
-
-                    # Apply variable remapping if exists (for Prep operations)
-                    local_var_name = self.variable_remapping.get(
-                        local_var_name,
-                        local_var_name,
-                    )
-                    return VariableRef(local_var_name)
-
-                # Array element access
-                # Skip this shortcut - we need to check for unpacked vars first
-                # The unpacking check above should handle function cases too
-
-                # In main function, check if this array is unpacked
-                if original_array in self.plan.arrays_to_unpack:
-                    # This array should be unpacked, use unpacked name
-                    info = self.plan.arrays_to_unpack[original_array]
-                    if qarg.index < info.size:
-                        # Check if the array is actually unpacked yet
-                        var_info = self.context.lookup_variable(array_name)
-                        if var_info and var_info.is_unpacked:
-                            # Use the actual unpacked name from our tracking
-                            if array_name in self.unpacked_vars and qarg.index < len(
-                                self.unpacked_vars[array_name],
-                            ):
-                                unpacked_name = self.unpacked_vars[array_name][qarg.index]
-                            else:
-                                # Fallback to generating the name (should not normally happen)
-                                unpacked_name = self._get_unique_var_name(
-                                    original_array,
-                                    qarg.index,
-                                )
-                            # Apply variable remapping if exists (for Prep operations)
-                            unpacked_name = self.variable_remapping.get(
-                                unpacked_name,
-                                unpacked_name,
-                            )
-                            return VariableRef(unpacked_name)
-
-                # Not unpacked or inside function, use array access
-                return ArrayAccess(array_name=array_name, index=qarg.index)
-
-            # Full array reference - check if array was refreshed by function call
-            if hasattr(self, "refreshed_arrays") and original_array in self.refreshed_arrays:
-                # Use the fresh returned array name instead of the original
-                fresh_array_name = self.refreshed_arrays[original_array]
-                return VariableRef(fresh_array_name)
-
-            return VariableRef(array_name)
-        if hasattr(qarg, "sym"):
-            # Direct variable reference
-            var_name = qarg.sym
-            original_var = var_name
-
-            # Check if this variable was refreshed by function call
-            if hasattr(self, "refreshed_arrays") and original_var in self.refreshed_arrays:
-                # Use the fresh returned variable name instead of the original
-                fresh_var_name = self.refreshed_arrays[original_var]
-                return VariableRef(fresh_var_name)
-
-            # Check if we're inside a function and need to use remapped names
-            if hasattr(self, "var_remapping") and original_var in self.var_remapping:
-                var_name = self.var_remapping[original_var]
-
-            # Check for renaming
-            if var_name in self.plan.renamed_variables:
-                var_name = self.plan.renamed_variables[var_name]
-            return VariableRef(var_name)
-
-        # Fallback
-        return VariableRef(str(qarg))
-
-    def _convert_bit_ref(self, carg, *, is_assignment_target: bool = False) -> IRNode:
-        """Convert a classical bit reference to IR.
-
-        Args:
-            carg: The classical argument to convert
-            is_assignment_target: If True, always use array indexing (for assignments)
-        """
-        if hasattr(carg, "reg") and hasattr(carg.reg, "sym"):
-            array_name = carg.reg.sym
-            original_array = array_name
-
-            # Check if this array has been refreshed by function call
-            # If so, prefer array indexing over stale unpacked variables
-            if hasattr(self, "refreshed_arrays") and array_name in self.refreshed_arrays and hasattr(carg, "index"):
-                # Array was refreshed by function call - use the fresh returned name
-                fresh_array_name = self.refreshed_arrays[array_name]
-                return ArrayAccess(
-                    array=VariableRef(fresh_array_name),
-                    index=carg.index,
-                    force_array_syntax=True,  # Force array syntax for refreshed arrays
-                )
-
-            # Check if this variable is mapped to a struct field (for @owned structs)
-            if hasattr(self, "struct_field_mapping") and original_array in self.struct_field_mapping:
-                struct_field_path = self.struct_field_mapping[original_array]
-                if "." in struct_field_path:
-                    struct_name, field_name = struct_field_path.split(".", 1)
-                    if hasattr(carg, "index"):
-                        # Return struct.field[index]
-                        field_access = FieldAccess(
-                            obj=VariableRef(struct_name),
-                            field=field_name,
-                        )
-                        return ArrayAccess(array=field_access, index=carg.index)
-                    # Return struct.field
-                    return FieldAccess(obj=VariableRef(struct_name), field=field_name)
-
-            # Check if this variable is part of a struct and has been unpacked
-            if hasattr(self, "var_remapping") and original_array in self.var_remapping:
-                # Use the unpacked field variable
-                unpacked_var_name = self.var_remapping[original_array]
-                if hasattr(carg, "index"):
-                    # Array element access with unpacked variable: c_verify_prep[0]
-                    return ArrayAccess(
-                        array=VariableRef(unpacked_var_name),
-                        index=carg.index,
-                    )
-                # Full array access with unpacked variable: c_verify_prep
-                return VariableRef(unpacked_var_name)
-
-            # Check if this variable is part of a struct in main context (fallback)
-            for prefix, info in self.struct_info.items():
-                if original_array in info["var_names"].values():
-                    # Find the field name
-                    for suffix, var_name in info["var_names"].items():
-                        if var_name == original_array:
-                            # Check if the struct has been decomposed and we should use decomposed variables
-                            if hasattr(self, "var_remapping") and original_array in self.var_remapping:
-                                # Struct was decomposed - use the decomposed variable directly
-                                decomposed_var = self.var_remapping[original_array]
-                                if hasattr(carg, "index"):
-                                    return ArrayAccess(
-                                        array=VariableRef(decomposed_var),
-                                        index=carg.index,
-                                    )
-                                return VariableRef(decomposed_var)
-
-                            # Check if we're in a function that receives the struct
-                            struct_param_name = prefix
-                            if hasattr(self, "param_mapping") and prefix in self.param_mapping:
-                                struct_param_name = self.param_mapping[prefix]
-
-                            # Check if we have decomposed variables for fresh structs
-                            if hasattr(self, "refreshed_arrays") and prefix in self.refreshed_arrays:
-                                fresh_struct_name = self.refreshed_arrays[prefix]
-                                # Check if this fresh struct was decomposed
-                                if hasattr(self, "decomposed_vars") and fresh_struct_name in self.decomposed_vars:
-                                    # Use the decomposed variable
-                                    field_vars = self.decomposed_vars[fresh_struct_name]
-                                    if suffix in field_vars:
-                                        decomposed_var = field_vars[suffix]
-                                        if hasattr(carg, "index"):
-                                            return ArrayAccess(
-                                                array=VariableRef(decomposed_var),
-                                                index=carg.index,
-                                            )
-                                        return VariableRef(decomposed_var)
-                                struct_param_name = fresh_struct_name
-
-                            if hasattr(carg, "index"):
-                                # Struct field element access: c.verify_prep[0]
-                                field_access = FieldAccess(
-                                    obj=VariableRef(struct_param_name),
-                                    field=suffix,
-                                )
-                                return ArrayAccess(array=field_access, index=carg.index)
-                            # Full struct field access: c.verify_prep
-                            return FieldAccess(
-                                obj=VariableRef(struct_param_name),
-                                field=suffix,
-                            )
-
-            # Check if we're inside a function and need to use remapped names
-            if hasattr(self, "var_remapping") and original_array in self.var_remapping:
-                array_name = self.var_remapping[original_array]
-
-            # Check for renaming
-            if array_name in self.plan.renamed_variables:
-                array_name = self.plan.renamed_variables[array_name]
-
-            if hasattr(carg, "index"):
-                # Check if this array is unpacked and we're not assigning
-                var_info = self.context.lookup_variable(array_name)
-                if (
-                    not is_assignment_target
-                    and var_info
-                    and var_info.is_unpacked
-                    and hasattr(var_info, "unpacked_names")
-                ):
-                    # Use unpacked variable name for reading
-                    index = carg.index
-                    if index < len(var_info.unpacked_names):
-                        return VariableRef(var_info.unpacked_names[index])
-
-                # Use array access for assignments or non-unpacked arrays
-                return ArrayAccess(array_name=array_name, index=carg.index)
-            # Full array reference
-            return VariableRef(array_name)
-        if hasattr(carg, "sym"):
-            # Direct variable reference
-            var_name = carg.sym
-            # Check for renaming
-            if var_name in self.plan.renamed_variables:
-                var_name = self.plan.renamed_variables[var_name]
-            return VariableRef(var_name)
-
-        # Fallback
-        return VariableRef(str(carg))
-
-    def _convert_quantum_gate(self, gate) -> Statement | None:
-        """Convert quantum gate operation."""
-        gate_name = type(gate).__name__
-
-        # Regular gate mapping for in-place operations
-        gate_map = {
-            "H": "quantum.h",
-            "X": "quantum.x",
-            "Y": "quantum.y",
-            "Z": "quantum.z",
-            "S": "quantum.s",
-            "SZ": "quantum.s",
-            "SZdg": "quantum.sdg",
-            "T": "quantum.t",
-            "Tdg": "quantum.tdg",
-            "CX": "quantum.cx",
-            "CY": "quantum.cy",
-            "CZ": "quantum.cz",
-            "Prep": "quantum.qubit",  # Prep allocates a fresh qubit
-        }
-
-        if gate_name not in gate_map:
-            return Comment(f"Unknown gate: {gate_name}")
-
-        func_name = gate_map[gate_name]
-
-        # Convert qubit arguments
-        args = []
-        if hasattr(gate, "qargs") and gate.qargs:
-            # Check if this is a single-qubit gate with multiple arguments
-            if gate_name in ["H", "X", "Y", "Z", "S", "SZ", "SZdg", "T", "Tdg", "Prep"] and len(gate.qargs) > 1:
-                # Single-qubit gate applied to multiple qubits
-                # Check if all qargs are consecutive array elements from the same array
-                if (
-                    all(hasattr(qarg, "reg") and hasattr(qarg, "index") for qarg in gate.qargs)
-                    and len({qarg.reg.sym for qarg in gate.qargs}) == 1
-                ):
-                    # All from same array - check if consecutive
-                    indices = [qarg.index for qarg in gate.qargs]
-                    array_name = gate.qargs[0].reg.sym
-
-                    if indices == list(range(min(indices), max(indices) + 1)):
-                        # Consecutive indices - generate a loop
-                        loop_var = "i"
-                        start = min(indices)
-                        stop = max(indices) + 1
-
-                        # Create loop body
-                        body_block = Block()
-
-                        # Check if the array name needs remapping (for unpacked struct fields)
-                        actual_array_name = array_name
-                        if hasattr(self, "var_remapping") and array_name in self.var_remapping:
-                            actual_array_name = self.var_remapping[array_name]
-
-                        array_ref = VariableRef(actual_array_name)
-                        index_ref = VariableRef(loop_var)
-                        elem_access = ArrayAccess(array=array_ref, index=index_ref)
-                        call = FunctionCall(func_name=func_name, args=[elem_access])
-
-                        # Create expression statement wrapper
-                        class ExpressionStatement(Statement):
-                            def __init__(self, expr):
-                                self.expr = expr
-
-                            def analyze(self, context):
-                                self.expr.analyze(context)
-
-                            def render(self, context):
-                                return self.expr.render(context)
-
-                        body_block.statements.append(ExpressionStatement(call))
-
-                        # Create for loop
-                        range_call = FunctionCall(
-                            func_name="range",
-                            args=[Literal(start), Literal(stop)],
-                        )
-                        return ForStatement(
-                            loop_var=loop_var,
-                            iterable=range_call,
-                            body=body_block,
-                        )
-
-                # Not consecutive or not from same array - expand to individual calls
-                stmts = []
-                for qarg in gate.qargs:
-                    qref = self._convert_qubit_ref(qarg)
-                    call = FunctionCall(func_name=func_name, args=[qref])
-
-                    # Create expression statement wrapper
-                    class ExpressionStatement(Statement):
-                        def __init__(self, expr):
-                            self.expr = expr
-
-                        def analyze(self, context):
-                            self.expr.analyze(context)
-
-                        def render(self, context):
-                            return self.expr.render(context)
-
-                    stmts.append(ExpressionStatement(call))
-                # Return a block with all statements
-                return Block(statements=stmts)
-            # Handle multi-qubit gates with tuple arguments
-            if gate_name in ["CX", "CY", "CZ"] and all(isinstance(arg, tuple) and len(arg) == 2 for arg in gate.qargs):
-                # Multiple (control, target) pairs - generate multiple statements
-                stmts = []
-                for ctrl, tgt in gate.qargs:
-                    ctrl_ref = self._convert_qubit_ref(ctrl)
-                    tgt_ref = self._convert_qubit_ref(tgt)
-                    call = FunctionCall(func_name=func_name, args=[ctrl_ref, tgt_ref])
-
-                    # Create expression statement wrapper
-                    class ExpressionStatement(Statement):
-                        def __init__(self, expr):
-                            self.expr = expr
-
-                        def analyze(self, context):
-                            self.expr.analyze(context)
-
-                        def render(self, context):
-                            return self.expr.render(context)
-
-                    stmts.append(ExpressionStatement(call))
-                # Return a block with all statements
-                return Block(statements=stmts)
-            # Standard argument handling
-            for qarg in gate.qargs:
-                # Check if this is a full array (no index)
-                if hasattr(qarg, "sym") and hasattr(qarg, "size") and qarg.size > 1:
-                    # This is a full array - need to expand to individual gates
-                    stmts = []
-                    array_name = qarg.sym
-
-                    # Check for renaming
-                    if array_name in self.plan.renamed_variables:
-                        array_name = self.plan.renamed_variables[array_name]
-
-                    # Check if this array name needs remapping (for unpacked struct fields)
-                    if hasattr(self, "var_remapping") and array_name in self.var_remapping:
-                        array_name = self.var_remapping[array_name]
-
-                    # Apply gate to each element
-                    # For operations on arrays, we need to expand to individual operations
-                    # However, reset operations in functions with owned arrays
-                    # need special handling
-
-                    if (
-                        gate_name == "Prep"
-                        and hasattr(self, "var_remapping")
-                        and self.var_remapping
-                        and array_name in self.var_remapping
-                    ):
-                        # Array Unpacking Pattern: use unpacked variables with
-                        # functional operations
-                        stmts.append(Comment(f"Reset all qubits in {array_name}"))
-
-                        if hasattr(self, "unpacked_vars") and array_name in self.unpacked_vars:
-                            # Use unpacked variables with functional assignments
-                            # Note: Explicit reset tracking is done during consumption analysis
-                            # in _track_consumed_qubits(), not here
-                            element_names = self.unpacked_vars[array_name]
-
-                            for i in range(min(qarg.size, len(element_names))):
-                                # CRITICAL: Check if this qubit was just replaced by a measurement
-                                # If so, skip the entire Prep (qubit already fresh)
-                                if hasattr(self, "replaced_qubits") and (
-                                    array_name in self.replaced_qubits and i in self.replaced_qubits[array_name]
-                                ):
-                                    # This qubit was just replaced by measurement - skip Prep
-                                    self.replaced_qubits[array_name].discard(i)
-                                    # Add comment but no actual operation
-                                    stmts.append(
-                                        Comment(
-                                            f"Prep skipped for {element_names[i]} - already fresh from measurement",
-                                        ),
-                                    )
-                                    continue
-
-                                elem_var = VariableRef(element_names[i])
-
-                                # CRITICAL: Prep (reset) requires discard-then-allocate pattern
-                                # Can't pass old qubit as argument to quantum.qubit()
-                                # Pattern: quantum.discard(q); q = quantum.qubit()
-
-                                # 1. Discard the old qubit
-                                discard_call = FunctionCall(
-                                    func_name="quantum.discard",
-                                    args=[elem_var],
-                                )
-
-                                # Create expression statement wrapper
-                                class ExpressionStatement(Statement):
-                                    def __init__(self, expr):
-                                        self.expr = expr
-
-                                    def analyze(self, context):
-                                        self.expr.analyze(context)
-
-                                    def render(self, context):
-                                        return self.expr.render(context)
-
-                                stmts.append(ExpressionStatement(discard_call))
-
-                                # 2. Allocate fresh qubit
-                                fresh_qubit_call = FunctionCall(
-                                    func_name="quantum.qubit",
-                                    args=[],  # No arguments - fresh allocation
-                                )
-                                assignment = Assignment(
-                                    target=elem_var,
-                                    value=fresh_qubit_call,
-                                )
-                                stmts.append(assignment)
-                        else:
-                            # Fallback to array indexing if no unpacking
-                            for i in range(qarg.size):
-                                elem_ref = ArrayAccess(array_name=array_name, index=i)
-                                call = FunctionCall(
-                                    func_name=func_name,
-                                    args=[elem_ref],
-                                )
-
-                                # Create expression statement wrapper
-                                class ExpressionStatement(Statement):
-                                    def __init__(self, expr):
-                                        self.expr = expr
-
-                                    def analyze(self, context):
-                                        self.expr.analyze(context)
-
-                                    def render(self, context):
-                                        return self.expr.render(context)
-
-                                stmts.append(ExpressionStatement(call))
-                    else:
-                        # Regular case - generate a loop instead of expanding
-                        # Check if this array is part of a struct
-                        is_struct_field = False
-
-                        # First check if we have a remapped variable (unpacked struct field)
-                        # The key insight is that if we're in a function with
-                        # @owned struct parameters
-                        # and this array is a struct field that has been unpacked, we should use
-                        # the unpacked variable name directly, not struct.field notation
-                        use_unpacked = False
-                        if hasattr(self, "var_remapping") and array_name in self.var_remapping:
-                            # Check if this is a struct field that has been unpacked
-                            for prefix, info in self.struct_info.items():
-                                if array_name in info["var_names"].values() and hasattr(
-                                    self,
-                                    "current_function_params",
-                                ):
-                                    # Check if the struct is an @owned parameter
-                                    for (
-                                        param_name,
-                                        param_type,
-                                    ) in self.current_function_params:
-                                        if param_name == prefix and "@owned" in str(
-                                            param_type,
-                                        ):
-                                            use_unpacked = True
-                                            break
-                                    if use_unpacked:
-                                        break
-
-                        if use_unpacked:
-                            # Generate a loop using the unpacked variable
-                            loop_var = "i"
-                            body_block = Block()
-
-                            # Use the remapped name from var_remapping
-                            remapped_name = self.var_remapping.get(
-                                array_name,
-                                array_name,
-                            )
-                            elem_ref = ArrayAccess(
-                                array=VariableRef(remapped_name),
-                                index=VariableRef(loop_var),
-                            )
-                            call = FunctionCall(func_name=func_name, args=[elem_ref])
-
-                            # Create expression statement wrapper
-                            class ExpressionStatement(Statement):
-                                def __init__(self, expr):
-                                    self.expr = expr
-
-                                def analyze(self, context):
-                                    self.expr.analyze(context)
-
-                                def render(self, context):
-                                    return self.expr.render(context)
-
-                            body_block.statements.append(ExpressionStatement(call))
-
-                            # Create for loop
-                            range_call = FunctionCall(
-                                func_name="range",
-                                args=[Literal(0), Literal(qarg.size)],
-                            )
-                            for_stmt = ForStatement(
-                                loop_var=loop_var,
-                                iterable=range_call,
-                                body=body_block,
-                            )
-                            stmts.append(for_stmt)
-                            is_struct_field = True  # Skip the struct field check below
-
-                        if not is_struct_field:
-                            for prefix, info in self.struct_info.items():
-                                if qarg.sym in info["var_names"].values():
-                                    # Find the field name
-                                    for suffix, var_name in info["var_names"].items():
-                                        if var_name == qarg.sym:
-                                            # Check if we're in a function that receives the struct
-                                            struct_param_name = prefix
-                                            if hasattr(self, "param_mapping") and prefix in self.param_mapping:
-                                                struct_param_name = self.param_mapping[prefix]
-
-                                            # Check if the struct has a fresh version (after function calls)
-                                            if hasattr(self, "refreshed_arrays") and prefix in self.refreshed_arrays:
-                                                struct_param_name = self.refreshed_arrays[prefix]
-
-                                            # Generate a loop for struct field access
-                                            loop_var = "i"
-                                            body_block = Block()
-
-                                            field_access = FieldAccess(
-                                                obj=VariableRef(struct_param_name),
-                                                field=suffix,
-                                            )
-                                            elem_ref = ArrayAccess(
-                                                array=field_access,
-                                                index=VariableRef(loop_var),
-                                            )
-                                            call = FunctionCall(
-                                                func_name=func_name,
-                                                args=[elem_ref],
-                                            )
-
-                                        # Create expression statement wrapper
-                                        class ExpressionStatement(Statement):
-                                            def __init__(self, expr):
-                                                self.expr = expr
-
-                                            def analyze(self, context):
-                                                self.expr.analyze(context)
-
-                                            def render(self, context):
-                                                return self.expr.render(context)
-
-                                        body_block.statements.append(
-                                            ExpressionStatement(call),
-                                        )
-
-                                        # Create for loop
-                                        range_call = FunctionCall(
-                                            func_name="range",
-                                            args=[Literal(0), Literal(qarg.size)],
-                                        )
-                                        for_stmt = ForStatement(
-                                            loop_var=loop_var,
-                                            iterable=range_call,
-                                            body=body_block,
-                                        )
-                                        stmts.append(for_stmt)
-                                        is_struct_field = True
-                                        break
-                                break
-
-                        if not is_struct_field:
-                            # Not in a struct - check if array was unpacked
-                            if hasattr(self, "unpacked_vars") and array_name in self.unpacked_vars:
-                                # Array was unpacked - UNROLL the loop to use unpacked elements directly
-                                # This avoids: unpack → reconstruct → loop → unpack (AlreadyUsedError)
-                                # Instead: unpack → apply to each element (no reconstruction needed)
-                                element_names = self.unpacked_vars[array_name]
-
-                                # Unroll: apply the operation to each unpacked element
-                                for i in range(qarg.size):
-                                    if i < len(element_names):
-                                        elem_ref = VariableRef(element_names[i])
-                                        call = FunctionCall(
-                                            func_name=func_name,
-                                            args=[elem_ref],
-                                        )
-
-                                        # Create expression statement wrapper
-                                        class ExpressionStatement(Statement):
-                                            def __init__(self, expr):
-                                                self.expr = expr
-
-                                            def analyze(self, context):
-                                                self.expr.analyze(context)
-
-                                            def render(self, context):
-                                                return self.expr.render(context)
-
-                                        stmts.append(ExpressionStatement(call))
-
-                                # No need to update unpacked_vars - elements are modified in-place
-                            else:
-                                # Array not unpacked - generate a loop
-                                loop_var = "i"
-                                body_block = Block()
-
-                                # Check if the array name needs remapping (for unpacked struct fields)
-                                actual_array_name = array_name
-                                if hasattr(self, "var_remapping") and array_name in self.var_remapping:
-                                    actual_array_name = self.var_remapping[array_name]
-
-                                elem_ref = ArrayAccess(
-                                    array=VariableRef(actual_array_name),
-                                    index=VariableRef(loop_var),
-                                )
-                                call = FunctionCall(
-                                    func_name=func_name,
-                                    args=[elem_ref],
-                                )
-
-                                # Create expression statement wrapper
-                                class ExpressionStatement(Statement):
-                                    def __init__(self, expr):
-                                        self.expr = expr
-
-                                    def analyze(self, context):
-                                        self.expr.analyze(context)
-
-                                    def render(self, context):
-                                        return self.expr.render(context)
-
-                                body_block.statements.append(ExpressionStatement(call))
-
-                                # Create for loop
-                                range_call = FunctionCall(
-                                    func_name="range",
-                                    args=[Literal(0), Literal(qarg.size)],
-                                )
-                                for_stmt = ForStatement(
-                                    loop_var=loop_var,
-                                    iterable=range_call,
-                                    body=body_block,
-                                )
-                                stmts.append(for_stmt)
-
-                    # Return a block with all statements
-                    return Block(statements=stmts)
-                args.append(self._convert_qubit_ref(qarg))
-
-        # If we get here, we have regular args (not arrays)
-        if args:
-            # Create function call expression
-            call = FunctionCall(func_name=func_name, args=args)
-
-            # Special handling for Prep - it allocates a fresh qubit
-            # so we need to use assignment, not an expression statement
-            # Note: Explicit reset tracking is done during consumption analysis
-            # in _track_consumed_qubits(), not here
-            # Prep generates: discard + fresh allocation (reset pattern)
-            if gate_name == "Prep" and len(args) == 1:
-                # Get the target variable (where to store the fresh qubit)
-                target = args[0]
-
-                # CRITICAL: Check if the previous operation was a measurement on this same qubit
-                # If so, skip the discard step (qubit already consumed by measurement)
-                skip_discard = False
-                if (
-                    hasattr(self, "current_block_ops")
-                    and hasattr(self, "current_op_index")
-                    and self.current_block_ops is not None
-                    and self.current_op_index is not None
-                    and self.current_op_index > 0
-                    and hasattr(target, "name")
-                ):
-                    prev_index = self.current_op_index - 1
-                    prev_op = self.current_block_ops[prev_index]
-                    # Check if previous operation was a measurement
-                    if type(prev_op).__name__ == "Measure" and hasattr(
-                        prev_op,
-                        "qargs",
-                    ):
-                        for meas_qarg in prev_op.qargs:
-                            # Get the variable name that would have been generated for this qubit
-                            if hasattr(meas_qarg, "reg") and hasattr(
-                                meas_qarg.reg,
-                                "sym",
-                            ):
-                                array_name = meas_qarg.reg.sym
-                                # Check both unpacked vars and locally allocated vars
-                                if (
-                                    hasattr(self, "unpacked_vars")
-                                    and array_name in self.unpacked_vars
-                                    and hasattr(meas_qarg, "index")
-                                ):
-                                    element_names = self.unpacked_vars[array_name]
-                                    qubit_index = meas_qarg.index
-                                    if qubit_index < len(element_names):
-                                        meas_var_name = element_names[qubit_index]
-                                        if meas_var_name == target.name:
-                                            # Same qubit - skip discard
-                                            skip_discard = True
-                                            break
-                                # Also check if this is a locally allocated qubit (two patterns)
-                                elif hasattr(meas_qarg, "index"):
-                                    qubit_index = meas_qarg.index
-                                    # Pattern 1: {array}_{index}_local (from line 3712)
-                                    local_var_name = f"{array_name}_{qubit_index}_local"
-                                    # Pattern 2: {array}_{index} (from UNPACKED_MIXED with local allocation)
-                                    unpacked_var_name = f"{array_name}_{qubit_index}"
-
-                                    if target.name in (
-                                        local_var_name,
-                                        unpacked_var_name,
-                                    ):
-                                        # This is the same qubit that was measured - skip discard
-                                        skip_discard = True
-                                        break
-
-                # CRITICAL: Use discard-then-allocate pattern for reset
-                # Pattern: quantum.discard(q); q = quantum.qubit()
-                # BUT: If qubit was just consumed by measurement, use fresh variable name
-                # to satisfy Guppy's linear type constraints
-                stmts = []
-
-                # Determine target variable for the fresh qubit
-                if skip_discard:
-                    # Previous operation consumed the qubit
-                    # We need a fresh variable name to avoid PlaceNotUsedError
-                    old_name = target.name
-
-                    # Generate a new version for this variable
-                    version = self.variable_version_counter.get(old_name, 0) + 1
-                    self.variable_version_counter[old_name] = version
-                    new_name = f"{old_name}_{version}"
-
-                    # Add remapping so subsequent operations use the new name
-                    self.variable_remapping[old_name] = new_name
-
-                    # Track the new variable for cleanup
-                    if not hasattr(self, "allocated_ancillas"):
-                        self.allocated_ancillas = set()
-                    self.allocated_ancillas.add(new_name)
-
-                    # Allocate to the new variable
-                    fresh_target = VariableRef(new_name)
-                else:
-                    # Discard the old qubit first
-                    discard_call = FunctionCall(
-                        func_name="quantum.discard",
-                        args=[target],
-                    )
-
-                    # Create expression statement wrapper
-                    class ExpressionStatement(Statement):
-                        def __init__(self, expr):
-                            self.expr = expr
-
-                        def analyze(self, context):
-                            self.expr.analyze(context)
-
-                        def render(self, context):
-                            return self.expr.render(context)
-
-                    stmts.append(ExpressionStatement(discard_call))
-
-                    # Reuse the same variable
-                    fresh_target = target
-
-                # Allocate fresh qubit
-                fresh_qubit_call = FunctionCall(func_name="quantum.qubit", args=[])
-                stmts.append(Assignment(target=fresh_target, value=fresh_qubit_call))
-
-                return Block(statements=stmts)
-
-            # No longer use functional operations - all gates are in-place
-
-            # Create expression statement wrapper for non-functional operations
-            class ExpressionStatement(Statement):
-                def __init__(self, expr):
-                    self.expr = expr
-
-                def analyze(self, context):
-                    self.expr.analyze(context)
-
-                def render(self, context):
-                    return self.expr.render(context)
-
-            return ExpressionStatement(call)
-
-        return None
-
-    def _should_restructure_conditional_consumption(self, if_block) -> bool:
-        """Check if this If block needs restructuring to avoid conditional consumption."""
-        # Check if we're in a conditional consumption loop
-        if not (hasattr(self, "_in_conditional_consumption_loop") and self._in_conditional_consumption_loop):
-            return False
-
-        # Check if the If block contains function calls that consume variables
-        if hasattr(if_block, "ops"):
-            for op in if_block.ops:
-                if hasattr(op, "block_name") and op.block_name in [
-                    "PrepEncodingFTZero",
-                    "PrepEncodingNonFTZero",
-                ]:
-                    return True
-
-        return False
-
-    def _convert_if(self, if_block) -> Statement | None:
-        """Convert If block."""
-        # Check if this conditional needs restructuring to avoid consumption issues
-        if self._should_restructure_conditional_consumption(if_block):
-            # Restructure to avoid conditional consumption
-            # Instead of: if cond: consume(vars)
-            # We do: vars = consume(vars); if not cond: pass
-            # This ensures vars are always consumed, maintaining linearity
-
-            self.current_block.statements.append(
-                Comment("Restructured conditional to avoid consumption in conditional"),
-            )
-
-            # Execute the operations unconditionally
-            if hasattr(if_block, "ops"):
-                for op in if_block.ops:
-                    stmt = self._convert_operation(op)
-                    if stmt:
-                        self.current_block.statements.append(stmt)
-
-            # The condition check becomes a no-op since we already executed
-            return None
-
-        # Check if we have a pre-extracted condition for this If block
-        if hasattr(self, "pre_extracted_conditions") and id(if_block) in self.pre_extracted_conditions:
-            # Use the pre-extracted condition variable
-            condition_var_name = self.pre_extracted_conditions[id(if_block)]
-            condition = VariableRef(condition_var_name)
-
-            # Convert then block
-            then_block = Block()
-            if hasattr(if_block, "ops"):
-                prev_block = self.current_block
-                self.current_block = then_block
-
-                for op in if_block.ops:
-                    stmt = self._convert_operation(op)
-                    if stmt:
-                        then_block.statements.append(stmt)
-
-                self.current_block = prev_block
-
-            # Handle else block if present
-            else_block = None
-            if hasattr(if_block, "else_ops") and if_block.else_ops:
-                else_block = Block()
-                prev_block = self.current_block
-                self.current_block = else_block
-
-                for op in if_block.else_ops:
-                    stmt = self._convert_operation(op)
-                    if stmt:
-                        else_block.statements.append(stmt)
-
-                self.current_block = prev_block
-
-            return IfStatement(
-                condition=condition,
-                then_block=then_block,
-                else_block=else_block,
-            )
-
-        # Check if this If block has struct field access in loop with @owned parameters
-        if hasattr(if_block, "cond") and self._is_struct_field_in_loop_with_owned(
-            if_block.cond,
-        ):
-            # Implement a proper fix by extracting the condition value before the conditional
-            # This allows us to check the struct field without violating @owned constraints
-
-            # Extract the struct field that's being tested
-            condition_var = self._extract_condition_variable(if_block.cond)
-            if condition_var:
-                self.current_block.statements.append(
-                    Comment(
-                        "Extract condition variable to avoid @owned struct field access in loop",
-                    ),
-                )
-
-                # Create a local variable to hold the condition value
-                condition_stmt = Assignment(
-                    target=VariableRef(condition_var["var_name"]),
-                    value=self._convert_condition_value(if_block.cond),
-                )
-                self.current_block.statements.append(condition_stmt)
-
-                # Convert then block first
-                then_block = Block()
-                if hasattr(if_block, "ops"):
-                    # Enter a new scope for the If block
-                    prev_block = self.current_block
-                    self.current_block = then_block
-
-                    for op in if_block.ops:
-                        stmt = self._convert_operation(op)
-                        if stmt:
-                            then_block.statements.append(stmt)
-
-                    self.current_block = prev_block
-
-                # Now create the If statement using the extracted variable
-                if condition_var["comparison"] == "EQUIV":
-                    # For bool comparison with 1, convert to just the boolean variable
-                    # Since verify_prep[0] is bool and we're checking == 1,
-                    # this means "if verification failed" which is just the boolean value
-                    if condition_var["compare_value"] == 1:
-                        condition = VariableRef(condition_var["var_name"])
-                    else:
-                        # For other comparisons, use == operator with appropriate type
-                        condition = BinaryOp(
-                            left=VariableRef(condition_var["var_name"]),
-                            op="==",
-                            right=Literal(condition_var["compare_value"]),
-                        )
-                else:
-                    condition = VariableRef(condition_var["var_name"])
-
-                # Create and return the If statement
-                return IfStatement(
-                    condition=condition,
-                    then_block=then_block,
-                )
-            # Fallback to the conservative approach if we can't extract the condition
-            self.current_block.statements.append(
-                Comment(
-                    "Fallback: If condition with struct field access simplified for @owned compatibility",
-                ),
-            )
-
-            # Convert the If body operations unconditionally
-            if hasattr(if_block, "ops"):
-                for op in if_block.ops:
-                    stmt = self._convert_operation(op)
-                    if stmt:
-                        self.current_block.statements.append(stmt)
-
-            return None
-
-        # Convert condition
-        condition = self._convert_condition(if_block.cond)
-
-        # Track what resources were consumed before this conditional
-        # We need to ensure we don't try to re-consume them in else blocks
-        consumed_before_if = {}
-        if not hasattr(self, "consumed_resources"):
-            self.consumed_resources = {}
-        for res_name, indices in self.consumed_resources.items():
-            consumed_before_if[res_name] = indices.copy() if isinstance(indices, set) else set(indices)
-
-        # Convert then block with scope tracking
-        then_block = Block()
-        prev_block = self.current_block
-
-        with self.scope_manager.enter_scope(ScopeType.IF_THEN) as then_scope:
-            self.current_block = then_block
-
-            if hasattr(if_block, "ops"):
-                for op in if_block.ops:
-                    stmt = self._convert_operation(op)
-                    if stmt:
-                        then_block.statements.append(stmt)
-
-        # Convert else block if present
-        else_block = None
-        else_scope_info = None
-
-        if hasattr(if_block, "else_block") and if_block.else_block:
-            else_block = Block()
-
-            with self.scope_manager.enter_scope(ScopeType.IF_ELSE) as else_scope:
-                else_scope_info = else_scope
-                self.current_block = else_block
-
-                if hasattr(if_block.else_block, "ops"):
-                    for op in if_block.else_block.ops:
-                        stmt = self._convert_operation(op)
-                        if stmt:
-                            else_block.statements.append(stmt)
-
-        # Check for resource balancing needs
-        # Analyze resource consumption across branches
-        unbalanced = self.scope_manager.analyze_conditional_branches(
-            then_scope,
-            else_scope_info,
-            self.context,
-        )
-
-        # If there are unbalanced resources, we need to balance them
-        if unbalanced:
-            # Helper function to add resource consumption
-            def add_resource_consumption(block, res_name, indices):
-                # Filter out indices that were already consumed before the if statement
-                if res_name in consumed_before_if:
-                    already_consumed = consumed_before_if[res_name]
-                    indices = indices - already_consumed
-
-                if indices:
-                    block.statements.append(
-                        Comment("Consume qubits to maintain linearity"),
-                    )
-                    for idx in sorted(indices):
-                        # Check if resource is unpacked
-                        if res_name in self.unpacked_vars:
-                            element_names = self.unpacked_vars[res_name]
-                            if idx < len(element_names):
-                                # Measure the unpacked qubit
-                                meas_expr = FunctionCall(
-                                    func_name="quantum.measure",
-                                    args=[VariableRef(element_names[idx])],
-                                )
-                                block.statements.append(
-                                    Assignment(
-                                        target=VariableRef("_"),
-                                        value=meas_expr,
-                                    ),
-                                )
-                        elif hasattr(self, "dynamic_allocations") and res_name in self.dynamic_allocations:
-                            # For dynamic allocations, allocate a fresh qubit and measure it
-                            # Always allocate a fresh qubit for consumption (for linearity balancing)
-                            var_name = self._get_unique_var_name(res_name, idx)
-                            block.statements.append(
-                                Assignment(
-                                    target=VariableRef(var_name),
-                                    value=FunctionCall(
-                                        func_name="quantum.qubit",
-                                        args=[],
-                                    ),
-                                ),
-                            )
-                            # Measure the qubit
-                            meas_expr = FunctionCall(
-                                func_name="quantum.measure",
-                                args=[VariableRef(var_name)],
-                            )
-                            block.statements.append(
-                                Assignment(target=VariableRef("_"), value=meas_expr),
-                            )
-                        else:
-                            # Use array indexing
-                            meas_expr = FunctionCall(
-                                func_name="quantum.measure",
-                                args=[ArrayAccess(array_name=res_name, index=idx)],
-                            )
-                            block.statements.append(
-                                Assignment(target=VariableRef("_"), value=meas_expr),
-                            )
-
-            # If we have an else block, add balancing to both branches
-            if else_block:
-                # Add to then branch what else consumed
-                for res_name, indices in unbalanced.items():
-                    if res_name in then_scope.resource_usage:
-                        then_usage = then_scope.resource_usage[res_name]
-                        else_usage = else_scope_info.resource_usage.get(
-                            res_name,
-                            ResourceUsage(res_name, set()),
-                        )
-                        missing_in_then = else_usage.consumed - then_usage.consumed
-                        if missing_in_then:
-                            add_resource_consumption(
-                                then_block,
-                                res_name,
-                                missing_in_then,
-                            )
-
-                # Add to else branch what then consumed
-                for res_name in then_scope.resource_usage:
-                    then_usage = then_scope.resource_usage[res_name]
-                    else_usage = else_scope_info.resource_usage.get(
-                        res_name,
-                        ResourceUsage(res_name, set()),
-                    )
-                    missing_in_else = then_usage.consumed - else_usage.consumed
-                    if missing_in_else:
-                        add_resource_consumption(else_block, res_name, missing_in_else)
-            else:
-                # No else block - create one to consume resources
-                else_block = Block()
-                else_block.statements.append(
-                    Comment("Auto-generated else block for linearity"),
-                )
-
-                for res_name, indices in unbalanced.items():
-                    add_resource_consumption(else_block, res_name, indices)
-
-        self.current_block = prev_block
-
-        return IfStatement(
-            condition=condition,
-            then_block=then_block,
-            else_block=else_block,
-        )
-
-    def _convert_while(self, while_block) -> Statement | None:
-        """Convert While loop."""
-        # Convert condition
-        condition = self._convert_condition(while_block.cond)
-
-        # Convert body with scope tracking
-        body_block = Block()
-        prev_block = self.current_block
-
-        with self.scope_manager.enter_scope(ScopeType.LOOP):
-            self.current_block = body_block
-
-            if hasattr(while_block, "ops"):
-                for op in while_block.ops:
-                    stmt = self._convert_operation(op)
-                    if stmt:
-                        body_block.statements.append(stmt)
-
-        self.current_block = prev_block
-
-        return WhileStatement(
-            condition=condition,
-            body=body_block,
-        )
-
-    def _convert_for(self, for_block) -> Statement | None:
-        """Convert For loop."""
-        # Get loop variable and range
-        loop_var = for_block.var
-
-        # Determine the iteration pattern
-        if hasattr(for_block, "iterable") and for_block.iterable:
-            # For(i, iterable)
-            return self._convert_for_iterable(for_block, loop_var)
-        if hasattr(for_block, "start") and hasattr(for_block, "stop"):
-            # For(i, start, stop, [step])
-            return self._convert_for_range(for_block, loop_var)
-        # Unknown pattern
-        return Comment(f"TODO: Unsupported For loop pattern with variable {loop_var}")
-
-    def _convert_for_range(self, for_block, loop_var) -> Statement | None:
-        """Convert For loop with range pattern."""
-        start = for_block.start
-        stop = for_block.stop
-        step = getattr(for_block, "step", 1)
-
-        # Create range() call
-        if step == 1:
-            # range(start, stop)
-            range_call = FunctionCall(
-                func_name="range",
-                args=[Literal(start), Literal(stop)],
-            )
-        else:
-            # range(start, stop, step)
-            range_call = FunctionCall(
-                func_name="range",
-                args=[Literal(start), Literal(stop), Literal(step)],
-            )
-
-        # Check if we need to pre-extract conditions from If statements in the loop body
-        # This is necessary when we have @owned struct parameters and If conditions that
-        # access struct fields inside the loop
-        extracted_conditions = []
-        if self._should_pre_extract_conditions(for_block) and hasattr(for_block, "ops"):
-            # Find all If statements in the loop body and extract their conditions
-            for op in for_block.ops:
-                if type(op).__name__ == "If" and hasattr(op, "cond") and self._is_struct_field_access(op.cond):
-                    condition_var = self._generate_condition_var_name(op.cond)
-                    if condition_var:
-                        # Generate the extraction statement before the loop
-                        self.current_block.statements.append(
-                            Comment(
-                                "Pre-extract condition to avoid @owned struct field access in loop",
-                            ),
-                        )
-                        condition_stmt = Assignment(
-                            target=VariableRef(condition_var),
-                            value=self._convert_condition(op.cond),
-                        )
-                        self.current_block.statements.append(condition_stmt)
-                        extracted_conditions.append((op, condition_var))
-
-        # Convert body with scope tracking
-        body_block = Block()
-        prev_block = self.current_block
-
-        # Track extracted conditions so If converter can use them
-        if extracted_conditions:
-            if not hasattr(self, "pre_extracted_conditions"):
-                self.pre_extracted_conditions = {}
-            for if_op, var_name in extracted_conditions:
-                self.pre_extracted_conditions[id(if_op)] = var_name
-
-        with self.scope_manager.enter_scope(ScopeType.LOOP):
-            self.current_block = body_block
-
-            if hasattr(for_block, "ops"):
-                for op in for_block.ops:
-                    stmt = self._convert_operation(op)
-                    if stmt:
-                        body_block.statements.append(stmt)
-
-        self.current_block = prev_block
-
-        return ForStatement(
-            loop_var=str(loop_var),
-            iterable=range_call,
-            body=body_block,
-        )
-
-    def _convert_for_iterable(self, for_block, loop_var) -> Statement | None:
-        """Convert For loop with iterable pattern."""
-        # For now, just handle the iterable as a variable reference
-        iterable = for_block.iterable
-
-        # Try to convert it to an IR node
-        if isinstance(iterable, str):
-            iter_node = VariableRef(iterable)
-        elif hasattr(iterable, "sym"):
-            iter_node = VariableRef(iterable.sym)
-        else:
-            # Try to represent it somehow
-            iter_node = Literal(str(iterable))
-
-        # Convert body
-        body_block = Block()
-        prev_block = self.current_block
-
-        with self.scope_manager.enter_scope(ScopeType.LOOP):
-            self.current_block = body_block
-
-            if hasattr(for_block, "ops"):
-                for op in for_block.ops:
-                    stmt = self._convert_operation(op)
-                    if stmt:
-                        body_block.statements.append(stmt)
-
-        self.current_block = prev_block
-
-        return ForStatement(
-            loop_var=str(loop_var),
-            iterable=iter_node,
-            body=body_block,
-        )
-
-    def _convert_condition(self, cond) -> IRNode:
-        """Convert condition expression."""
-        cond_type = type(cond).__name__
-
-        if cond_type == "Bit":
-            # Bit reference
-            return self._convert_bit_ref(cond)
-        if cond_type == "EQUIV":
-            # Equality comparison
-
-            left = self._convert_condition(cond.left)
-            right = self._convert_condition(cond.right)
-
-            # Optimize boolean comparisons to 1
-            if isinstance(right, Literal) and right.value == 1 and type(cond.left).__name__ == "Bit":
-                # Just return the boolean value itself
-                return left
-
-            return BinaryOp(left=left, op="==", right=right)
-        if cond_type == "LT":
-            # Less than
-            left = self._convert_condition(cond.left)
-            right = self._convert_condition(cond.right)
-            return BinaryOp(left=left, op="<", right=right)
-        if cond_type == "GT":
-            # Greater than
-            left = self._convert_condition(cond.left)
-            right = self._convert_condition(cond.right)
-            return BinaryOp(left=left, op=">", right=right)
-        if cond_type == "AND":
-            # Bitwise AND (used as logical in conditions)
-            left = self._convert_condition(cond.left)
-            right = self._convert_condition(cond.right)
-            return BinaryOp(left=left, op="&", right=right)
-        if cond_type == "OR":
-            # Bitwise OR (used as logical in conditions)
-            left = self._convert_condition(cond.left)
-            right = self._convert_condition(cond.right)
-            return BinaryOp(left=left, op="|", right=right)
-        if cond_type == "NOT":
-            # Logical NOT
-            operand = self._convert_condition(cond.value)
-            return UnaryOp(op="not", operand=operand)
-        if hasattr(cond, "value"):
-            # Literal value
-            return Literal(cond.value)
-        if isinstance(cond, int | bool | str):
-            # Direct literal
-            return Literal(cond)
-
-        # Default: try to convert as bit reference
-        return self._convert_bit_ref(cond)
-
-    def _convert_repeat(self, repeat_block) -> Statement | None:
-        """Convert Repeat block to for loop."""
-        # Repeat is essentially a for loop with an anonymous variable
-        repeat_count = repeat_block.cond
-
-        # Check if this repeat block contains conditional consumption patterns
-        # that would violate linearity (e.g., conditional function calls with @owned params)
-        has_conditional_consumption = self._has_conditional_consumption_pattern(
-            repeat_block,
-        )
-
-        if has_conditional_consumption:
-            # Special handling for conditional consumption patterns
-            # Instead of a loop with conditional consumption, we need to restructure
-            # to avoid linearity violations
-            return self._convert_repeat_with_conditional_consumption(repeat_block)
-
-        # Check if conditions have already been pre-extracted at the function level
-        # If not, extract them here (for non-function contexts)
-        extracted_conditions = []
-        already_extracted = hasattr(self, "pre_extracted_conditions") and self.pre_extracted_conditions
-
-        should_extract = (
-            not already_extracted
-            and self._should_pre_extract_conditions_repeat(repeat_block)
-            and hasattr(repeat_block, "ops")
-        )
-        if should_extract:
-            # Find all If statements in the loop body and extract their conditions
-            for op in repeat_block.ops:
-                if type(op).__name__ == "If" and hasattr(op, "cond"):
-                    # Check if this condition was already pre-extracted
-                    if hasattr(self, "pre_extracted_conditions") and id(op) in self.pre_extracted_conditions:
-                        continue  # Skip - already handled
-
-                    if self._is_struct_field_access(op.cond):
-                        condition_var = self._generate_condition_var_name(op.cond)
-                        if condition_var:
-                            # Generate the extraction statement before the loop
-                            self.current_block.statements.append(
-                                Comment(
-                                    "Pre-extract condition to avoid @owned struct field access in loop",
-                                ),
-                            )
-                            condition_stmt = Assignment(
-                                target=VariableRef(condition_var),
-                                value=self._convert_condition(op.cond),
-                            )
-                            self.current_block.statements.append(condition_stmt)
-                            extracted_conditions.append((op, condition_var))
-
-        # Convert body
-        body_block = Block()
-        prev_block = self.current_block
-
-        # Track extracted conditions so If converter can use them
-        if extracted_conditions:
-            if not hasattr(self, "pre_extracted_conditions"):
-                self.pre_extracted_conditions = {}
-            for if_op, var_name in extracted_conditions:
-                self.pre_extracted_conditions[id(if_op)] = var_name
-
-        with self.scope_manager.enter_scope(ScopeType.LOOP):
-            self.current_block = body_block
-
-            if hasattr(repeat_block, "ops"):
-                for op in repeat_block.ops:
-                    stmt = self._convert_operation(op)
-                    if stmt:
-                        body_block.statements.append(stmt)
-
-        self.current_block = prev_block
-
-        # Create ForStatement with anonymous variable
-        return ForStatement(
-            loop_var="_",
-            iterable=FunctionCall(func_name="range", args=[Literal(repeat_count)]),
-            body=body_block,
-        )
-
-    def _has_conditional_consumption_pattern(self, repeat_block) -> bool:
-        """Check if a repeat block contains conditional consumption patterns."""
-        if not hasattr(repeat_block, "ops"):
-            return False
-
-        # Look for If blocks containing function calls with @owned parameters
-        for op in repeat_block.ops:
-            if type(op).__name__ == "If" and hasattr(op, "ops"):
-                for inner_op in op.ops:
-                    # Check if this is a function call that might have @owned params
-                    if hasattr(inner_op, "block_name"):
-                        # Check if this function has @owned parameters
-                        func_name = inner_op.block_name
-                        if func_name in [
-                            "PrepEncodingFTZero",
-                            "PrepEncodingNonFTZero",
-                            "PrepZeroVerify",
-                        ]:
-                            return True
-        return False
-
-    def _update_mappings_after_conditional_loop(self) -> None:
-        """Update variable mappings after a loop with conditional consumption.
-
-        After a loop with conditional consumption, variables might have been
-        conditionally replaced with fresh versions. We need to ensure that
-        subsequent operations use the right variables.
-        """
-        # For the specific pattern where we have c_d_fresh that might have been
-        # conditionally consumed to create c_d_fresh_1, we need to ensure
-        # that subsequent uses reference the original c_d_fresh (not _1)
-        # because the _1 version only exists conditionally.
-        #
-        # The proper solution would be to track which variables are guaranteed
-        # to exist and use those. For now, we'll stick with the original names.
-
-    def _convert_repeat_with_conditional_consumption(
-        self,
-        repeat_block,
-    ) -> Statement | None:
-        """Convert repeat block with conditional consumption to avoid linearity violations."""
-        repeat_count = repeat_block.cond
-
-        # For conditional consumption patterns, we need to be careful
-        # The issue is that variables might be consumed conditionally in the loop
-        # but then used unconditionally afterward
-
-        # Track that we're in a special conditional consumption context
-        self._in_conditional_consumption_loop = True
-
-        # Convert as normal for loop
-        body_block = Block()
-        prev_block = self.current_block
-
-        with self.scope_manager.enter_scope(ScopeType.LOOP):
-            self.current_block = body_block
-
-            if hasattr(repeat_block, "ops"):
-                for op in repeat_block.ops:
-                    stmt = self._convert_operation(op)
-                    if stmt:
-                        body_block.statements.append(stmt)
-
-        self.current_block = prev_block
-        self._in_conditional_consumption_loop = False
-
-        return ForStatement(
-            loop_var="_",
-            iterable=FunctionCall(func_name="range", args=[Literal(repeat_count)]),
-            body=body_block,
-        )
-
-    def _convert_comment(self, comment) -> Statement | None:
-        """Convert comment."""
-        if hasattr(comment, "txt") and comment.txt:
-            return Comment(comment.txt)
-        return None  # Skip empty comments
-
-    def _is_struct_field_in_loop_with_owned(self, cond) -> bool:
-        """Check if a condition accesses a struct field in a problematic context.
-
-        Returns True if:
-        1. We're in a loop scope
-        2. We're in a function with @owned struct parameters
-        3. The condition accesses a struct field
-        """
-        # Check if we're in a loop
-        if not hasattr(self, "scope_manager") or not self.scope_manager.is_in_loop():
-            return False
-
-        # Check if we're in a function with @owned struct parameters
-        if not hasattr(self, "function_info") or self.current_function_name == "main":
-            return False
-
-        func_info = self.function_info.get(self.current_function_name, {})
-        if not func_info.get("has_owned_struct_params", False):
-            return False
-
-        # Check if the condition accesses a struct field
-        # Handle different condition types
-        cond_type = type(cond).__name__
-
-        if cond_type == "EQUIV":
-            # For equality comparisons, check the left side
-            if hasattr(cond, "left"):
-                return self._is_struct_field_in_loop_with_owned(cond.left)
-        elif hasattr(cond, "reg") and hasattr(cond.reg, "sym"):
-            array_name = cond.reg.sym
-            # Check if this variable is a struct field
-            for info in self.struct_info.values():
-                if array_name in info["var_names"].values():
-                    return True
-
-        return False
-
-    def _extract_condition_variable(self, cond) -> dict | None:
-        """Extract information about a condition variable that accesses a struct field.
-
-        Returns a dict with:
-        - var_name: suggested variable name for the extracted value
-        - struct_field: the struct field being accessed (e.g., 'c.verify_prep[0]')
-        - comparison: the comparison type (e.g., 'EQUIV')
-        - compare_value: the value being compared against
-        """
-        cond_type = type(cond).__name__
-
-        if cond_type == "EQUIV" and hasattr(cond, "left") and hasattr(cond, "right"):
-            # Handle EQUIV(c_verify_prep[0], 1)
-            left = cond.left
-            right = cond.right
-
-            # Check if left side is a struct field access
-            if hasattr(left, "reg") and hasattr(left.reg, "sym") and hasattr(left, "index"):
-                array_name = left.reg.sym
-                index = left.index
-
-                # Check if this is a struct field
-                for prefix, info in self.struct_info.items():
-                    if array_name in info["var_names"].values():
-                        # Find the field name
-                        field_name = None
-                        for suffix, var_name in info["var_names"].items():
-                            if var_name == array_name:
-                                field_name = suffix
-                                break
-
-                        if field_name:
-                            # Extract the comparison value
-                            compare_value = getattr(right, "val", right) if hasattr(right, "val") else right
-
-                            return {
-                                "var_name": f"{field_name}_{index}_extracted",
-                                "struct_field": f"{prefix}.{field_name}[{index}]",
-                                "comparison": "EQUIV",
-                                "compare_value": compare_value,
-                            }
-
-        return None
-
-    def _convert_condition_value(self, cond) -> IRNode:
-        """Convert the struct field access part of a condition to an IR node."""
-        cond_type = type(cond).__name__
-
-        if cond_type == "EQUIV" and hasattr(cond, "left"):
-            # For EQUIV(c_verify_prep[0], 1), convert the left side (c_verify_prep[0])
-            left = cond.left
-
-            if hasattr(left, "reg") and hasattr(left.reg, "sym") and hasattr(left, "index"):
-                array_name = left.reg.sym
-                index = left.index
-
-                # Check if this is a struct field and get the struct parameter name
-                for prefix, info in self.struct_info.items():
-                    if array_name in info["var_names"].values():
-                        # Find the field name
-                        field_name = None
-                        for suffix, var_name in info["var_names"].items():
-                            if var_name == array_name:
-                                field_name = suffix
-                                break
-
-                        if field_name:
-                            # Check if the struct has been decomposed and we should use decomposed variables
-                            if hasattr(self, "var_remapping") and array_name in self.var_remapping:
-                                # Struct was decomposed - use the decomposed variable directly
-                                decomposed_var = self.var_remapping[array_name]
-                                return ArrayAccess(
-                                    array=VariableRef(decomposed_var),
-                                    index=index,
-                                )
-
-                            # Get the struct parameter name (e.g., 'c')
-                            struct_param_name = prefix
-                            if hasattr(self, "param_mapping") and prefix in self.param_mapping:
-                                struct_param_name = self.param_mapping[prefix]
-
-                            # Check if we have fresh structs - use them directly
-                            if hasattr(self, "refreshed_arrays") and prefix in self.refreshed_arrays:
-                                fresh_struct_name = self.refreshed_arrays[prefix]
-                                struct_param_name = fresh_struct_name
-                                # Don't replace field access for fresh structs
-
-                            # Create: c.verify_prep[0] - but check for decomposed variables first
-                            # Check if we have decomposed variables for this struct
-                            if hasattr(self, "decomposed_vars") and struct_param_name in self.decomposed_vars:
-                                field_vars = self.decomposed_vars[struct_param_name]
-                                if field_name in field_vars:
-                                    # Use the decomposed variable instead
-                                    decomposed_var = field_vars[field_name]
-                                    return ArrayAccess(
-                                        array=VariableRef(decomposed_var),
-                                        index=index,
-                                    )
-
-                            # Fallback to original struct field access (this should now be rare)
-                            field_access = FieldAccess(
-                                obj=VariableRef(struct_param_name),
-                                field=field_name,
-                            )
-                            return ArrayAccess(array=field_access, index=index)
-
-        # Fallback
-        return Literal(0)
-
-    def _function_has_owned_struct_params(self, params) -> bool:
-        """Check if function has @owned struct parameters."""
-        return any("@owned" in param_type and param_name in self.struct_info for param_name, param_type in params)
-
-    def _has_function_calls_before_loops(self, block) -> bool:
-        """Check if the function has function calls before loops.
-
-        This indicates that decomposed struct variables will be consumed for
-        struct reconstruction, so we can't pre-extract conditions from them.
-        """
-        if not hasattr(block, "ops"):
-            return False
-
-        # Look for function calls before any loops
-        found_function_call = False
-
-        for op in block.ops:
-            op_type = type(op).__name__
-
-            # Check for function calls (which would trigger struct reconstruction)
-            if op_type == "Call" and hasattr(op, "func"):
-                # This is a function call that might consume structs
-                found_function_call = True
-
-            # Check for Repeat/For loops - if we find function calls before loops,
-            # then we'll need to reconstruct structs and can't pre-extract
-            if op_type in ["Repeat", "For"] and found_function_call:
-                return True
-
-        return False
-
-    def _pre_extract_loop_conditions(self, block, body) -> dict:
-        """Pre-extract conditions from loops that might access @owned struct fields.
-
-        Returns a dictionary mapping If block IDs to extracted condition variable names.
-        """
-        return {}
-
-        # Disable pre-extraction for now - it causes linearity conflicts with struct reconstruction
-        # TODO: Implement proper post-function-call condition extraction
-        # The code below is currently unreachable but kept for future reference
-
-        # Find all Repeat blocks with If conditions that access struct fields
-        extracted: dict = {}  # Initialize for dead code below
-        if hasattr(block, "ops"):
-            for op in block.ops:
-                if type(op).__name__ == "Repeat" and hasattr(op, "ops"):
-                    # Check if this Repeat block contains If statements with struct field access
-                    for inner_op in op.ops:
-                        if (
-                            type(inner_op).__name__ == "If"
-                            and hasattr(
-                                inner_op,
-                                "cond",
-                            )
-                            and self._is_struct_field_access(inner_op.cond)
-                        ):
-                            # Extract this condition NOW before any operations
-                            condition_var = self._generate_condition_var_name(
-                                inner_op.cond,
-                            )
-                            if condition_var:
-                                body.statements.append(
-                                    Comment(
-                                        "Pre-extract condition to avoid @owned struct field access in loop",
-                                    ),
-                                )
-                                condition_stmt = Assignment(
-                                    target=VariableRef(condition_var),
-                                    value=self._convert_condition(inner_op.cond),
-                                )
-                                body.statements.append(condition_stmt)
-                                extracted[id(inner_op)] = condition_var
-
-        return extracted
-
-    def _should_pre_extract_conditions_repeat(self, repeat_block) -> bool:
-        """Check if we need to pre-extract conditions from this repeat block.
-
-        Returns True if:
-        1. The loop contains If statements with conditions
-        2. We're in a function with @owned struct parameters
-        3. The conditions access struct fields
-        4. BUT False if we have function calls that will consume the decomposed variables
-        """
-        # Check if we're in a function with @owned struct parameters
-        if not hasattr(self, "function_info") or self.current_function_name == "main":
-            return False
-
-        func_info = self.function_info.get(self.current_function_name, {})
-        if not func_info.get("has_owned_struct_params", False):
-            return False
-
-        # Check if we have decomposed variables that might be consumed for struct reconstruction
-        # This indicates we're in a context where pre-extraction would conflict with reconstruction
-        if hasattr(self, "decomposed_vars") and self.decomposed_vars:
-            return False
-
-        # Check if the loop contains If statements with struct field access
-        if hasattr(repeat_block, "ops"):
-            for op in repeat_block.ops:
-                if type(op).__name__ == "If" and hasattr(op, "cond") and self._is_struct_field_access(op.cond):
-                    return True
-
-        return False
-
-    def _should_pre_extract_conditions(self, for_block) -> bool:
-        """Check if we need to pre-extract conditions from this for loop.
-
-        Returns True if:
-        1. The loop contains If statements with conditions
-        2. We're in a function with @owned struct parameters OR have fresh structs from returns
-        3. The conditions access struct fields
-        """
-        # Check if we're in a function with @owned struct parameters or fresh structs
-        if not hasattr(self, "function_info") or self.current_function_name == "main":
-            return False
-
-        func_info = self.function_info.get(self.current_function_name, {})
-        has_owned_params = func_info.get("has_owned_struct_params", False)
-        has_fresh_structs = hasattr(self, "refreshed_arrays") and bool(
-            self.refreshed_arrays,
-        )
-
-        if not (has_owned_params or has_fresh_structs):
-            return False
-
-        # Check if the loop contains If statements with struct field access
-        if hasattr(for_block, "ops"):
-            for op in for_block.ops:
-                if type(op).__name__ == "If" and hasattr(op, "cond") and self._is_struct_field_access(op.cond):
-                    return True
-
-        return False
-
-    def _is_struct_field_access(self, cond) -> bool:
-        """Check if a condition accesses a struct field."""
-        cond_type = type(cond).__name__
-
-        if cond_type == "EQUIV":
-            # For equality comparisons, check the left side
-            if hasattr(cond, "left"):
-                return self._is_struct_field_access(cond.left)
-        elif cond_type == "Bit":
-            # Check if this is a struct field
-            if hasattr(cond, "reg") and hasattr(cond.reg, "sym"):
-                array_name = cond.reg.sym
-                # Check if this variable is a struct field (original or fresh)
-                for prefix, info in self.struct_info.items():
-                    # Check original struct fields
-                    if array_name in info["var_names"].values():
-                        return True
-                    # Check fresh struct field patterns (e.g., c_fresh accessing verify_prep)
-                    if hasattr(self, "refreshed_arrays"):
-                        for orig_name in self.refreshed_arrays:
-                            if orig_name == prefix:
-                                # Check if array_name matches fresh struct field pattern
-                                for field_name in info["var_names"].values():
-                                    # The condition might be accessing fresh_struct.field
-                                    if array_name == field_name:  # Original field being accessed
-                                        return True
-        elif cond_type in ["AND", "OR", "XOR", "NOT"]:
-            # Check both sides for binary ops
-            if hasattr(cond, "left") and self._is_struct_field_access(cond.left):
-                return True
-            if hasattr(cond, "right") and self._is_struct_field_access(cond.right):
-                return True
-
-        return False
-
-    def _generate_condition_var_name(self, cond) -> str | None:
-        """Generate a variable name for an extracted condition."""
-        cond_type = type(cond).__name__
-
-        if cond_type == "EQUIV" and hasattr(cond, "left"):
-            left = cond.left
-            if hasattr(left, "reg") and hasattr(left.reg, "sym") and hasattr(left, "index"):
-                array_name = left.reg.sym
-                index = left.index
-
-                # Check if this is a struct field
-                for info in self.struct_info.values():
-                    if array_name in info["var_names"].values():
-                        # Find the field name
-                        for suffix, var_name in info["var_names"].items():
-                            if var_name == array_name:
-                                return f"{suffix}_{index}_condition"
-        elif cond_type == "Bit":
-            if hasattr(cond, "reg") and hasattr(cond.reg, "sym") and hasattr(cond, "index"):
-                array_name = cond.reg.sym
-                index = cond.index
-
-                # Check if this is a struct field
-                for info in self.struct_info.values():
-                    if array_name in info["var_names"].values():
-                        # Find the field name
-                        for suffix, var_name in info["var_names"].items():
-                            if var_name == array_name:
-                                return f"{suffix}_{index}_condition"
-
-        # Generate a generic name
-        return "extracted_condition"
-
-    def _convert_set_operation(self, set_op) -> Statement | None:
-        """Convert SET operation for classical bits."""
-        if not hasattr(set_op, "left") or not hasattr(set_op, "right"):
-            return Comment("Invalid SET operation")
-
-        # Convert left side (target) - use array indexing for assignments
-        target = self._convert_bit_ref(set_op.left, is_assignment_target=True)
-
-        # Convert right side (value)
-        value = self._convert_set_value(set_op.right)
-
-        return Assignment(target=target, value=value)
-
-    def _convert_set_value(self, value, parent_op=None) -> IRNode:
-        """Convert value in SET operation.
-
-        Args:
-            value: The value to convert
-            parent_op: The parent operation type (if any) to determine if parens are needed
-        """
-        # Check if it's a literal
-        if isinstance(value, int | bool):
-            return Literal(bool(value))
-
-        # Check if it's a bit reference
-        value_type = type(value).__name__
-        if value_type == "Bit":
-            return self._convert_bit_ref(value)
-
-        # Check for bitwise operations
-        if value_type == "XOR":
-            left = self._convert_set_value(value.left, parent_op=value_type)
-            right = self._convert_set_value(value.right, parent_op=value_type)
-            result = BinaryOp(left=left, op="^", right=right)
-            # XOR has same precedence as AND, higher than OR
-            # Only need parens if parent is AND (to clarify precedence)
-            if parent_op == "AND":
-                result.needs_parens = True
-            return result
-        if value_type == "AND":
-            left = self._convert_set_value(value.left, parent_op=value_type)
-            right = self._convert_set_value(value.right, parent_op=value_type)
-            result = BinaryOp(left=left, op="&", right=right)
-            # Mark as needing parens if it's a child of |
-            if parent_op == "OR":
-                result.needs_parens = True
-            return result
-        if value_type == "OR":
-            left = self._convert_set_value(value.left, parent_op=value_type)
-            right = self._convert_set_value(value.right, parent_op=value_type)
-            return BinaryOp(left=left, op="|", right=right)
-        if value_type == "NOT":
-            # NOT might have 'operand' or be applied to first item
-            if hasattr(value, "operand"):
-                operand = self._convert_set_value(value.operand, parent_op=value_type)
-            elif hasattr(value, "value"):
-                operand = self._convert_set_value(value.value, parent_op=value_type)
-            else:
-                # Try to get the operand another way
-                operand = Literal(value=True)
-            return UnaryOp(op="not", operand=operand)
-
-        # Unknown value type - generate function call as fallback
-        args = []
-        if hasattr(value, "left"):
-            args.append(self._convert_set_value(value.left, parent_op=value_type))
-        if hasattr(value, "right"):
-            args.append(self._convert_set_value(value.right, parent_op=value_type))
-        return FunctionCall(func_name=value_type, args=args)
-
-    def _convert_permute(self, permute) -> Statement | None:
-        """Convert Permute operation."""
-        # Permute swaps registers or elements
-        # In Guppy, we can implement this using Python's swap syntax
-
-        if hasattr(permute, "elems_i") and hasattr(permute, "elems_f"):
-            elems_i = permute.elems_i
-            elems_f = permute.elems_f
-
-            # Case 1: Simple register swap (a, b = b, a)
-            if hasattr(elems_i, "sym") and hasattr(elems_f, "sym"):
-                # Full register swap
-                comment = Comment(f"Swap {elems_i.sym} and {elems_f.sym}")
-                self.current_block.statements.append(comment)
-
-                # In Guppy, we need to use a temporary variable
-                temp_var = f"_temp_{elems_i.sym}"
-
-                # temp = a
-                self.current_block.statements.append(
-                    Assignment(
-                        target=VariableRef(temp_var),
-                        value=VariableRef(elems_i.sym),
-                    ),
-                )
-
-                # a = b
-                self.current_block.statements.append(
-                    Assignment(
-                        target=VariableRef(elems_i.sym),
-                        value=VariableRef(elems_f.sym),
-                    ),
-                )
-
-                # b = temp
-                self.current_block.statements.append(
-                    Assignment(
-                        target=VariableRef(elems_f.sym),
-                        value=VariableRef(temp_var),
-                    ),
-                )
-
-                return None  # Already added statements
-
-            # Case 2: List of elements permutation
-            if isinstance(elems_i, list) and isinstance(elems_f, list):
-                if len(elems_i) != len(elems_f):
-                    return Comment("ERROR: Permutation lists must have same length")
-
-                # Analyze the permutation pattern
-                permutation_map = self._analyze_permutation(elems_i, elems_f)
-
-                if permutation_map is None:
-                    return Comment("ERROR: Invalid permutation - elements don't match")
-
-                # Generate permutation code based on the pattern
-                return self._generate_permutation_code(
-                    permutation_map,
-                    elems_i,
-                    elems_f,
-                )
-
-        # Fallback for unrecognized patterns
-        return Comment("TODO: Implement complex permutation")
-
-    def _analyze_permutation(self, elems_i, elems_f):
-        """Analyze permutation to create a mapping."""
-        # Create a set of all elements to ensure they match
-        elems_i_set = set()
-        elems_f_set = set()
-
-        # Build element signatures for comparison
-        for elem in elems_i:
-            if hasattr(elem, "reg") and hasattr(elem, "index"):
-                elems_i_set.add((elem.reg.sym, elem.index))
-            elif hasattr(elem, "sym"):
-                # Full register reference
-                elems_i_set.add((elem.sym, None))
-
-        for elem in elems_f:
-            if hasattr(elem, "reg") and hasattr(elem, "index"):
-                elems_f_set.add((elem.reg.sym, elem.index))
-            elif hasattr(elem, "sym"):
-                elems_f_set.add((elem.sym, None))
-
-        # Check if the sets match (same elements, just reordered)
-        if elems_i_set != elems_f_set:
-            return None
-
-        # Create the mapping: what goes to position i
-        # If elems_f[i] == elems_i[j], then position i gets value from position j
-        permutation_map = {}
-        for i, elem_f in enumerate(elems_f):
-            # Find which element in elems_i matches elem_f
-            for j, elem_i in enumerate(elems_i):
-                if self._elements_equal(elem_i, elem_f):
-                    permutation_map[i] = j  # position i gets value from position j
-                    break
-
-        return permutation_map
-
-    def _elements_equal(self, elem1, elem2):
-        """Check if two elements refer to the same qubit."""
-        # Both are register[index] references
-        if hasattr(elem1, "reg") and hasattr(elem1, "index") and hasattr(elem2, "reg") and hasattr(elem2, "index"):
-            return elem1.reg.sym == elem2.reg.sym and elem1.index == elem2.index
-        # Both are full register references
-        if hasattr(elem1, "sym") and hasattr(elem2, "sym"):
-            return elem1.sym == elem2.sym
-        return False
-
-    def _generate_permutation_code(self, permutation_map, elems_i, elems_f):
-        """Generate code for complex permutation patterns."""
-        _ = elems_f  # Currently not used, reserved for future use
-        # Identify cycles in the permutation
-        cycles = self._find_permutation_cycles(permutation_map)
-
-        if not cycles:
-            return Comment("Identity permutation - no action needed")
-
-        # Add comment describing the permutation
-        self.current_block.statements.append(
-            Comment(f"Permute {len(elems_i)} elements"),
-        )
-
-        # For each cycle, generate swap operations
-        for cycle in cycles:
-            if len(cycle) == 1:
-                # Fixed point, no action needed
-                continue
-            if len(cycle) == 2:
-                # Simple swap
-                self._generate_swap(elems_i[cycle[0]], elems_i[cycle[1]])
-            else:
-                # Multi-element cycle: use temporary variables
-                self._generate_cycle_permutation(cycle, elems_i)
-
-        return None  # Statements already added
-
-    def _find_permutation_cycles(self, permutation_map):
-        """Find cycles in a permutation."""
-        visited = set()
-        cycles = []
-
-        for start in permutation_map:
-            if start in visited:
-                continue
-
-            cycle = []
-            current = start
-            while current not in visited:
-                visited.add(current)
-                cycle.append(current)
-                current = permutation_map.get(current, current)
-
-            if len(cycle) > 0 and (len(cycle) > 1 or cycle[0] != permutation_map.get(cycle[0], cycle[0])):
-                cycles.append(cycle)
-
-        return cycles
-
-    def _generate_swap(self, elem1, elem2):
-        """Generate code to swap two elements."""
-        ref1 = self._convert_qubit_ref(elem1)
-        ref2 = self._convert_qubit_ref(elem2)
-
-        # Use a temporary variable
-        temp_var = "_temp_swap"
-
-        self.current_block.statements.append(
-            Assignment(target=VariableRef(temp_var), value=ref1),
-        )
-        self.current_block.statements.append(
-            Assignment(target=ref1, value=ref2),
-        )
-        self.current_block.statements.append(
-            Assignment(target=ref2, value=VariableRef(temp_var)),
-        )
-
-    def _generate_cycle_permutation(self, cycle, elements):
-        """Generate code for a multi-element cycle permutation."""
-        if len(cycle) < 2:
-            return
-
-        # Save the first element
-        first_elem = elements[cycle[0]]
-        first_ref = self._convert_qubit_ref(first_elem)
-        temp_var = "_temp_cycle"
-
-        self.current_block.statements.append(
-            Assignment(target=VariableRef(temp_var), value=first_ref),
-        )
-
-        # Shift elements in the cycle
-        for i in range(len(cycle) - 1):
-            src_elem = elements[cycle[i + 1]]
-            dst_elem = elements[cycle[i]]
-
-            src_ref = self._convert_qubit_ref(src_elem)
-            dst_ref = self._convert_qubit_ref(dst_elem)
-
-            self.current_block.statements.append(
-                Assignment(target=dst_ref, value=src_ref),
-            )
-
-        # Complete the cycle
-        last_elem = elements[cycle[-1]]
-        last_ref = self._convert_qubit_ref(last_elem)
-
-        self.current_block.statements.append(
-            Assignment(target=last_ref, value=VariableRef(temp_var)),
-        )
-
-    def _convert_block_call(self, block) -> Statement | None:
-        """Convert a block to a function call or inline expansion."""
-        block_type = type(block)
-        block_name = block_type.__name__
-
-        # Get original block info if preserved
-        original_block_name = getattr(block, "block_name", block_name)
-        original_block_module = getattr(block, "block_module", block_type.__module__)
-
-        # If we're in a loop, check if we need to restore array sizes before this call
-        if self.scope_manager.is_in_loop():
-            self._restore_array_sizes_for_block_call(block)
-
-        # Check if this is a core block that should be inlined
-        if original_block_name in self.CORE_BLOCKS:
-            # Inline core blocks
-            if hasattr(block, "ops"):
-                self.current_block.statements.append(
-                    Comment(f"Begin {block_name} block"),
-                )
-                for op in block.ops:
-                    stmt = self._convert_operation(op)
-                    if stmt:
-                        self.current_block.statements.append(stmt)
-                self.current_block.statements.append(
-                    Comment(f"End {block_name} block"),
-                )
-            return None
-
-        # For non-core blocks, create a function
-        block_signature = self._get_block_signature(block)
-
-        # Check if we already have a function for this block type
-        if block_signature not in self.block_registry:
-            # Determine struct prefix if this block operates on a struct
-            struct_prefix = None
-            deps = self._analyze_block_dependencies(block)
-
-            # Check if all variables belong to the same struct
-            for prefix, info in self.struct_info.items():
-                vars_in_this_struct = set()
-                for var in info["var_names"].values():
-                    if var in deps["quantum"] or var in deps["classical"]:
-                        vars_in_this_struct.add(var)
-
-                # If this block operates on variables from this struct, use
-                # QEC code name if available
-                if vars_in_this_struct:
-                    # Use the QEC code name if we have it, otherwise use prefix
-                    struct_prefix = info.get("qec_code_name", prefix)
-                    break
-
-            # Generate a unique function name with struct prefix
-            # Include module name if not __main__
-            base_name = original_block_name
-
-            # For Parallel blocks with content hash, include the content info
-            if len(block_signature) > 2 and original_block_name == "Parallel":
-                content_hash = block_signature[2]
-                # Create a more readable suffix from the hash
-                # e.g., "H_H" becomes "_h", "X_X" becomes "_x"
-                if content_hash:
-                    gates = content_hash.split("_")
-                    if all(g == gates[0] for g in gates):
-                        # All gates are the same type
-                        base_name += f"_{gates[0].lower()}"
-                    else:
-                        # Mixed gates - use first letter of each
-                        suffix = "_".join(g[0].lower() for g in gates[:3])  # Limit to 3
-                        base_name += f"_{suffix}"
-
-            if original_block_module and original_block_module != "__main__":
-                # Extract just the last part of the module name (e.g., 'test_linearity_patterns')
-                module_parts = original_block_module.split(".")
-                module_name = module_parts[-1] if module_parts else ""
-                if module_name and module_name.startswith("test_"):
-                    # For test modules, include the module name
-                    func_name = self._generate_function_name(
-                        f"{module_name}_{base_name}",
-                        struct_prefix,
-                    )
-                else:
-                    func_name = self._generate_function_name(base_name, struct_prefix)
-            else:
-                func_name = self._generate_function_name(base_name, struct_prefix)
-            self.block_registry[block_signature] = func_name
-
-            # Add to pending functions if not already discovered
-            if func_name not in self.discovered_functions:
-                self.pending_functions.append((block, func_name, block_signature))
-                self.discovered_functions.add(func_name)
-        else:
-            func_name = self.block_registry[block_signature]
-
-        # Generate function call
-        stmt = self._generate_function_call(func_name, block)
-        if stmt:
-            self.current_block.statements.append(stmt)
-        return None  # Already added to current block
-
-    def _get_block_signature(self, block) -> tuple:
-        """Get a unique signature for a block type."""
-        block_type = type(block)
-        block_name = block_type.__name__
-        original_block_name = getattr(block, "block_name", block_name)
-        original_block_module = getattr(block, "block_module", block_type.__module__)
-
-        # For Parallel blocks, include content hash to differentiate blocks
-        # with different operations
-        if original_block_name == "Parallel" and hasattr(block, "ops"):
-            content_hash = self._get_block_content_hash(block)
-            return (original_block_name, original_block_module, content_hash)
-
-        # For now, use block name and module as signature
-        # Could be enhanced to include parameter info
-        return (original_block_name, original_block_module)
-
-    def _generate_function_name(
-        self,
-        block_name: str,
-        struct_prefix: str | None = None,
-    ) -> str:
-        """Generate a unique function name for a block.
-
-        Args:
-            block_name: The original block name (e.g., 'H', 'PrepRUS')
-            struct_prefix: Optional struct prefix (e.g., 'c' for c_struct)
-        """
-        # Convert CamelCase to snake_case, handling acronyms better
-        import re
-
-        # First, handle transitions from lowercase to uppercase
-        snake_case = re.sub("([a-z0-9])([A-Z])", r"\1_\2", block_name)
-
-        # Then handle multiple consecutive capitals (acronyms)
-        snake_case = re.sub("([A-Z]+)([A-Z][a-z])", r"\1_\2", snake_case)
-
-        # Convert to lowercase
-        snake_case = snake_case.lower()
-
-        # Add struct prefix if provided
-        base_name = f"{struct_prefix}_{snake_case}" if struct_prefix else snake_case
-
-        # Ensure uniqueness
-        func_name = base_name
-        counter = 1
-        while func_name in self.generated_functions:
-            func_name = f"{base_name}_{counter}"
-            counter += 1
-
-        return func_name
-
-    def _get_block_content_hash(self, block) -> str:
-        """Get a hash of block operations for differentiation.
-
-        This is used to differentiate Parallel blocks with different operations.
-        """
-        ops_summary = []
-        if hasattr(block, "ops"):
-            for op in block.ops:
-                op_type = type(op).__name__
-                # Include gate types to differentiate
-                ops_summary.append(op_type)
-
-        # Create a simple hash from operation types
-        return "_".join(sorted(ops_summary)) if ops_summary else "empty"
-
-    def _generate_function_call(self, func_name: str, block) -> Statement:
-        """Generate a function call for a block."""
-        from pecos.slr.gen_codes.guppy.ir import Assignment, Comment, VariableRef
-
-        # Analyze block dependencies to determine arguments
-        deps = self._analyze_block_dependencies(block)
-
-        # Initialize as procedural, will be updated after resource flow analysis
-        is_procedural_function = True
-
-        # CRITICAL: Save which arrays are currently unpacked BEFORE processing arguments
-        # This is needed to detect if a function call return should use a fresh variable name
-        # (when the parameter was unpacked and consumed in argument processing)
-        unpacked_before_call = set()
-        if hasattr(self, "unpacked_vars"):
-            unpacked_before_call = set(self.unpacked_vars.keys())
-
-        # Determine which variables need to be passed as arguments
-        args = []
-        quantum_args = []  # Track quantum args for return value assignment
-
-        # Check if we should pass structs instead of individual arrays
-        struct_args = set()  # Structs we've already added
-        vars_in_structs = set()  # Variables that are part of structs
-
-        # First pass: identify which variables are part of structs
-        for prefix, info in self.struct_info.items():
-            for var in info["var_names"].values():
-                if var in deps["quantum"] or var in deps["classical"]:
-                    vars_in_structs.add(var)
-                    if prefix not in struct_args:
-                        # Check if this struct has been refreshed (e.g., from a previous function call)
-                        struct_to_use = prefix
-                        if hasattr(self, "refreshed_arrays") and prefix in self.refreshed_arrays:
-                            # Use the refreshed name (e.g., c_fresh instead of c)
-                            struct_to_use = self.refreshed_arrays[prefix]
-
-                        # Check if this is a struct that was decomposed and needs reconstruction
-                        # This includes @owned structs and fresh structs that were decomposed for field access
-                        needs_reconstruction = False
-                        struct_was_decomposed = struct_to_use in self.decomposed_vars or (
-                            prefix in self.decomposed_vars and struct_to_use == prefix
-                        )
-                        if hasattr(self, "decomposed_vars") and struct_was_decomposed:
-                            # Check if the struct we want to use was decomposed
-                            needs_reconstruction = True
-
-                        if needs_reconstruction:
-                            # Struct was decomposed - reconstruct it from decomposed variables
-                            struct_info = self.struct_info[prefix]
-
-                            # Create a unique name for the reconstructed struct
-                            reconstructed_var = self._get_unique_var_name(
-                                f"{prefix}_reconstructed",
-                            )
-
-                            # Create struct constructor call
-                            constructor_args = []
-
-                            # Check if we have decomposed field variables for this struct
-                            if struct_to_use in self.decomposed_vars:
-                                # Use the decomposed field variables
-                                field_mapping = self.decomposed_vars[struct_to_use]
-                                for suffix, field_type, field_size in sorted(
-                                    struct_info["fields"],
-                                ):
-                                    # Fallback to default naming if not in mapping
-                                    field_var = field_mapping.get(
-                                        suffix,
-                                        f"{struct_to_use}_{suffix}",
-                                    )
-                                    constructor_args.append(VariableRef(field_var))
-                            else:
-                                # Use the default field variable naming
-                                for suffix, field_type, field_size in sorted(
-                                    struct_info["fields"],
-                                ):
-                                    field_var = f"{prefix}_{suffix}"
-
-                                    # Check if we have a fresh version of this field variable
-                                    if hasattr(self, "refreshed_arrays") and field_var in self.refreshed_arrays:
-                                        field_var = self.refreshed_arrays[field_var]
-                                    elif hasattr(self, "var_remapping") and field_var in self.var_remapping:
-                                        field_var = self.var_remapping[field_var]
-
-                                    constructor_args.append(VariableRef(field_var))
-
-                            struct_constructor = FunctionCall(
-                                func_name=struct_info["struct_name"],
-                                args=constructor_args,
-                            )
-
-                            # Add reconstruction statement
-                            reconstruction_stmt = Assignment(
-                                target=VariableRef(reconstructed_var),
-                                value=struct_constructor,
-                            )
-                            self.current_block.statements.append(reconstruction_stmt)
-
-                            # Use the reconstructed struct
-                            struct_to_use = reconstructed_var
-
-                        # Add the struct as an argument
-                        args.append(VariableRef(struct_to_use))
-                        struct_args.add(prefix)
-                        # Track this for return value handling
-                        if var in deps["quantum"]:
-                            quantum_args.append(prefix)
-
-        # Track unpacked arrays that need restoration after procedural calls
-        saved_unpacked_arrays = []
-
-        # Black Box Pattern: Pass complete global arrays to maintain SLR semantics
-        for var in sorted(deps["quantum"] & deps["reads"]):
-            # Check if this is an ancilla that was excluded from structs
-            is_excluded_ancilla = hasattr(self, "ancilla_qubits") and var in self.ancilla_qubits
-
-            # Skip if this variable is part of a struct UNLESS it's an excluded ancilla
-            if var in vars_in_structs and not is_excluded_ancilla:
-                continue
-
-            # Check if this variable needs remapping (we're inside a function)
-            actual_var = var
-            if hasattr(self, "var_remapping") and var in self.var_remapping:
-                actual_var = self.var_remapping[var]
-
-            # For procedural functions (borrow), we can't use unpacked arrays - they need the original array
-            # For consuming functions (@owned), reconstruct the array from unpacked elements
-            # Also handle dynamically allocated arrays and decomposed ancilla arrays
-            if hasattr(self, "decomposed_ancilla_arrays") and var in self.decomposed_ancilla_arrays:
-                # Check if the array has already been reconstructed into a variable
-                if hasattr(self, "reconstructed_arrays") and var in self.reconstructed_arrays:
-                    # Check if it was unpacked AFTER reconstruction
-                    if hasattr(self, "unpacked_vars") and actual_var in self.unpacked_vars:
-                        # Array was unpacked after reconstruction - need to reconstruct again
-                        # First check if there's a refreshed version from a previous function call
-                        if hasattr(self, "refreshed_arrays") and var in self.refreshed_arrays:
-                            refreshed_name = self.refreshed_arrays[var]
-                            args.append(VariableRef(refreshed_name))
-                            quantum_args.append(var)
-                        else:
-                            # Reconstruct from unpacked elements
-                            element_names = self.unpacked_vars[actual_var]
-                            array_construction = self._create_array_construction(
-                                element_names,
-                            )
-                            args.append(array_construction)
-                            quantum_args.append(var)
-                    else:
-                        # Use the reconstructed array variable directly (not unpacked)
-                        args.append(VariableRef(actual_var))
-                        quantum_args.append(var)
-                else:
-                    # This array was decomposed into individual qubits
-                    # Check if there's a refreshed version from a previous function call
-                    if hasattr(self, "refreshed_arrays") and var in self.refreshed_arrays:
-                        # Use the refreshed array from previous function call
-                        refreshed_name = self.refreshed_arrays[var]
-                        args.append(VariableRef(refreshed_name))
-                        quantum_args.append(var)
-                    else:
-                        # Reconstruct from decomposed elements
-                        element_names = self.decomposed_ancilla_arrays[var]
-                        array_construction = self._create_array_construction(
-                            element_names,
-                        )
-                        args.append(array_construction)
-                        quantum_args.append(var)
-            elif hasattr(self, "dynamic_allocations") and var in self.dynamic_allocations:
-                # Dynamically allocated - check if there's a refreshed version first
-                if hasattr(self, "refreshed_arrays") and var in self.refreshed_arrays:
-                    # Use the refreshed array from previous function call
-                    refreshed_name = self.refreshed_arrays[var]
-                    args.append(VariableRef(refreshed_name))
-                    quantum_args.append(var)
-                else:
-                    # Dynamically allocated - construct array from individual qubits
-                    # Get the size from context
-                    var_info = self.context.lookup_variable(var)
-                    if var_info and var_info.size:
-                        size = var_info.size
-                        element_names = [f"{var}_{i}" for i in range(size)]
-                        array_construction = self._create_array_construction(
-                            element_names,
-                        )
-                        args.append(array_construction)
-                        quantum_args.append(var)
-                    else:
-                        # Fallback - just pass the variable (will likely error)
-                        args.append(VariableRef(actual_var))
-                        quantum_args.append(actual_var)
-            elif hasattr(self, "unpacked_vars") and actual_var in self.unpacked_vars:
-                # Array was unpacked (either from parameter or return value)
-                # OPTIMIZATION: If we're using ALL unpacked elements AND the array variable exists,
-                # just pass the array variable instead of reconstructing inline
-                # This happens when a function returns an array, we unpack it, then immediately
-                # pass it to another function - in this case, just use the variable!
-                element_names = self.unpacked_vars[actual_var]
-
-                # Check if we have partial consumption (via index_mapping)
-                has_partial_consumption = hasattr(self, "index_mapping") and actual_var in self.index_mapping
-
-                # Check if this was unpacked from a parameter
-                is_parameter_unpacked = (
-                    hasattr(self, "parameter_unpacked_arrays") and actual_var in self.parameter_unpacked_arrays
-                )
-
-                # Use the variable directly if:
-                # 1. No partial consumption (using all elements)
-                # 2. Not parameter-unpacked (return-unpacked arrays have the variable available)
-                # 3. The variable wasn't consumed yet
-                if not has_partial_consumption and not is_parameter_unpacked:
-                    # The array variable should still exist - use it directly
-                    args.append(VariableRef(actual_var))
-                    quantum_args.append(actual_var)
-                    # Don't delete from unpacked_vars yet - might be needed later
-                else:
-                    # Use inline array construction
-                    # This is needed for:
-                    # - Partial consumption (not all elements)
-                    # - Parameter-unpacked arrays (no array variable exists)
-                    array_construction = self._create_array_construction(element_names)
-                    args.append(array_construction)
-                    quantum_args.append(actual_var)
-
-                    # CRITICAL: After using inline construction, the unpacked elements are CONSUMED
-                    # Remove from tracking so subsequent calls use the returned value instead
-                    if hasattr(self, "parameter_unpacked_arrays"):
-                        self.parameter_unpacked_arrays.discard(actual_var)
-                    del self.unpacked_vars[actual_var]
-                    if hasattr(self, "index_mapping") and actual_var in self.index_mapping:
-                        del self.index_mapping[actual_var]
-            else:
-                # Array is already in the correct global form
-                # Check if this array has been refreshed (e.g., from a previous function call)
-                if hasattr(self, "refreshed_arrays") and var in self.refreshed_arrays:
-                    # Use the refreshed name (e.g., data_fresh instead of data)
-                    refreshed_name = self.refreshed_arrays[var]
-                    args.append(VariableRef(refreshed_name))
-                    quantum_args.append(var)  # Keep original name for tracking
-                else:
-                    args.append(VariableRef(actual_var))
-                    quantum_args.append(actual_var)
-
-        # Pass classical variables that are read or written (arrays are passed by reference)
-        for var in sorted(deps["classical"] & (deps["reads"] | deps["writes"])):
-            # Skip if this variable is part of a struct
-            if var in vars_in_structs:
-                continue
-
-            # Check if this variable needs remapping
-            actual_var = var
-            if hasattr(self, "var_remapping") and var in self.var_remapping:
-                actual_var = self.var_remapping[var]
-
-            # Classical arrays also need reconstruction if they were unpacked
-            if hasattr(self, "unpacked_vars") and actual_var in self.unpacked_vars:
-                # Reconstruct the classical array from unpacked elements
-                element_names = self.unpacked_vars[actual_var]
-                array_construction = self._create_array_construction(element_names)
-
-                # Use a unique name for reconstruction to avoid linearity violation
-                reconstructed_var = self._get_unique_var_name(f"{actual_var}_array")
-                reconstruction_stmt = Assignment(
-                    target=VariableRef(reconstructed_var),
-                    value=array_construction,
-                )
-                self.current_block.statements.append(reconstruction_stmt)
-
-                # Clear the unpacking info since we've reconstructed the array
-                del self.unpacked_vars[actual_var]
-                args.append(VariableRef(reconstructed_var))
-            else:
-                # Array is already in the correct form
-                args.append(VariableRef(actual_var))
-
-        # Create function call
-        call = FunctionCall(
-            func_name=func_name,
-            args=args,
-        )
-
-        # Use proper resource flow analysis to determine what's actually returned
-        _consumed_qubits, live_qubits = self._analyze_quantum_resource_flow(block)
-
-        # Determine if this is a procedural function based on resource flow
-        # If the block has live qubits that should be returned, it's not procedural
-        has_live_qubits = bool(live_qubits)
-        is_procedural_function = not has_live_qubits
-
-        # HYBRID APPROACH: Use smart detection for consistent function calls
-        if hasattr(self, "function_return_types") and func_name in self.function_return_types:
-            func_return_type = self.function_return_types[func_name]
-            if func_return_type == "None":
-                is_procedural_function = True
-        else:
-            # Fallback: use the same smart detection logic
-            should_be_procedural_call = self._should_function_be_procedural(
-                func_name,
-                block,
-                [(arg, "array[quantum.qubit, 2]") for arg in quantum_args],
-                has_live_qubits,
-            )
-            if should_be_procedural_call:
-                is_procedural_function = True
-
-        # Override: if function has multiple quantum args, it's likely not procedural
-        # if len(quantum_args) > 1:
-        #     is_procedural_function = False
-
-        # Override: if function returns a tuple, it's not procedural
-        # if func_name in self.function_return_types:
-        #     func_return_type = self.function_return_types[func_name]
-        #     if func_return_type.startswith("tuple["):
-        #         is_procedural_function = False
-
-        # If it appears to be procedural based on live qubits, double-check with signature
-        if is_procedural_function and hasattr(block, "__init__"):
-            import inspect
-
-            try:
-                sig = inspect.signature(block.__class__.__init__)
-                return_annotation = sig.return_annotation
-                if return_annotation is None or return_annotation is type(None) or str(return_annotation) == "None":
-                    is_procedural_function = True
-                else:
-                    is_procedural_function = False  # Has return annotation, not procedural
-            except (ValueError, TypeError, AttributeError):
-                # Default to procedural if can't inspect signature
-                # ValueError: signature cannot be determined
-                # TypeError: object is not callable
-                # AttributeError: missing expected attributes
-                is_procedural_function = True
-
-        # Now determine if the calling function consumes quantum arrays
-        deps_for_func = self._analyze_block_dependencies(block)
-        has_quantum_params = bool(deps_for_func["quantum"] & deps_for_func["reads"])
-        # Check if we're in main function
-        is_main_context = self.current_function_name == "main"
-        # Functions consume quantum arrays if they have quantum params AND the called function is not procedural
-        # This supports the nested blocks pattern where non-procedural functions return live qubits
-        function_consumes = has_quantum_params and (is_main_context or not is_procedural_function)
-
-        # Force function consumption if multiple quantum args (likely tuple return)
-        if has_quantum_params and len(quantum_args) > 1:
-            function_consumes = True
-
-        # Track consumed arrays in main function
-        # Check if the function being called has @owned parameters
-        if self.current_function_name == "main":
-            # Since function_info is not populated yet when building main,
-            # we need to be conservative and assume all quantum arrays passed to functions
-            # might have @owned parameters. This is especially true for procedural functions
-            # that have nested blocks (like prep_rus).
-
-            # For safety, mark all quantum arrays passed to functions as consumed
-            # This prevents double-use errors when arrays are passed to @owned functions
-            for arg in quantum_args:
-                if isinstance(arg, str):  # It's an array name
-                    if not hasattr(self, "consumed_resources"):
-                        self.consumed_resources = {}
-                    if arg not in self.consumed_resources:
-                        self.consumed_resources[arg] = set()
-                    # Mark the entire array as consumed conservatively
-                    # We don't know the exact size, but we can mark it as fully consumed
-                    # by using a large range (quantum arrays are typically small)
-                    self.consumed_resources[arg].update(
-                        range(100),
-                    )  # Conservative upper bound
-
-        # Use natural SLR semantics: arrays are global resources modified in-place
-        # Functions that use unpacking still return arrays at boundaries to maintain this illusion
-        # Keep track of struct arguments before filtering
-        struct_args = [arg for arg in quantum_args if isinstance(arg, str) and arg in self.struct_info]
-
-        quantum_args = [arg for arg in quantum_args if isinstance(arg, str)]  # Filter for array names
-
-        # Check if we're returning structs (already collected above)
-
-        # Check if the function returns something based on our function definitions
-        self._function_returns_something(func_name)
-
-        # CRITICAL: Determine actual return type by analyzing the block being called
-        # This is more reliable than looking it up in function_return_types which may not be populated yet
-        # APPROACH 1: Check Python type annotation on the block class
-        actual_returns_tuple = False
-        if hasattr(block, "__class__"):
-            try:
-                import inspect
-
-                sig = inspect.signature(block.__class__.__init__)
-                return_annotation = sig.return_annotation
-                if return_annotation and return_annotation is not type(None):
-                    return_str = str(return_annotation)
-                    # Check if it's a tuple type annotation
-                    actual_returns_tuple = (
-                        "tuple[" in return_str.lower()
-                        or "Tuple[" in return_str
-                        or (hasattr(return_annotation, "__origin__") and return_annotation.__origin__ is tuple)
-                    )
-            except (ValueError, TypeError, AttributeError):
-                # Can't inspect signature, will use APPROACH 2
-                pass  # Fallback to approach 2
-
-        # APPROACH 2: Infer from live_qubits analysis
-        # If live_qubits has multiple quantum arrays, function returns a tuple
-        if not actual_returns_tuple and len(live_qubits) > 1:
-            # Multiple quantum arrays are live - function returns a tuple
-            actual_returns_tuple = True
-
-        # For both @owned and non-@owned functions, only return arrays with live qubits
-        # Fully consumed arrays should not be returned
-        returned_quantum_args = []
-        for arg in quantum_args:
-            if isinstance(arg, str):
-                # Check if this arg (possibly reconstructed) maps to an original array with live qubits
-                original_name = arg
-                # Handle reconstructed array names (e.g., _q_array -> q)
-                if hasattr(self, "array_remapping") and arg in self.array_remapping:
-                    original_name = self.array_remapping[arg]
-                elif arg.startswith("_") and arg.endswith("_array"):
-                    # Try to infer original name from reconstructed name
-                    # _q_array -> q
-                    potential_original = arg[1:].replace("_array", "")
-                    if potential_original in live_qubits:
-                        original_name = potential_original
-
-                if original_name in live_qubits:
-                    returned_quantum_args.append(
-                        arg,
-                    )  # Use the actual arg name for assignment
-
-        # If we forced function_consumes but have no returned_quantum_args,
-        # assume all quantum args should be returned (common with partial consumption patterns)
-        if function_consumes and not returned_quantum_args and len(quantum_args) > 1:
-            returned_quantum_args = list(quantum_args)
-
-        # Also include structs that have live quantum fields
-        for struct_arg in struct_args:
-            if struct_arg not in returned_quantum_args and struct_arg in self.struct_info:
-                # Check if struct has any live quantum fields
-                struct_info = self.struct_info[struct_arg]
-                has_live_fields = False
-                for suffix, var_type, size in struct_info.get("fields", []):
-                    if var_type == "qubit":
-                        var_name = struct_info["var_names"].get(suffix)
-                        if var_name and var_name in live_qubits:
-                            has_live_fields = True
-                            break
-                if has_live_fields:
-                    returned_quantum_args.append(struct_arg)
-
-        # Track arrays that are consumed (passed with @owned but not returned)
-        # Also mark arrays as consumed when passed to nested blocks (even without @owned)
-        is_nested_block = False
-        try:
-            from pecos.slr import Block as SlrBlock
-
-            if hasattr(block, "__class__") and issubclass(block.__class__, SlrBlock):
-                is_nested_block = True
-        except (TypeError, AttributeError):
-            # Not a class or missing expected attributes
-            pass
-
-        if (function_consumes or is_nested_block) and hasattr(self, "consumed_arrays"):
-
-            # Check function signature for @owned parameters
-            owned_params = set()
-
-            # TEMPORARY FIX: Hardcode known @owned parameter patterns for quantum error correction functions
-            # This covers the specific functions that are causing issues in the Steane code
-            known_owned_patterns = {
-                "prep_rus": [0, 1],  # c_a and c_d are both @owned
-                "prep_encoding_ft_zero": [0, 1],  # c_a and c_d are both @owned
-                "prep_zero_verify": [0, 1],  # c_a and c_d are both @owned
-                "prep_encoding_non_ft_zero": [0],  # c_d is @owned (first parameter)
-                "log_zero_rot": [0],  # c_d is @owned (first parameter)
-                "h": [0],  # c_d is @owned (first parameter)
-            }
-
-            if func_name in known_owned_patterns:
-                owned_indices = known_owned_patterns[func_name]
-                for i in owned_indices:
-                    if i < len(quantum_args):
-                        owned_arg = quantum_args[i]
-                        owned_params.add(owned_arg)
-
-            # Try to find the function definition in the current module (future improvement)
-            # [Previous function definition lookup code can be restored later if needed]
-
-            for arg in quantum_args:
-                if isinstance(arg, str):
-                    # CRITICAL: Determine if this array should be marked as consumed
-                    # Two cases:
-                    # 1. Procedural function (returns None): ALL args are consumed
-                    # 2. Functional function (returns values): Only args NOT returned are consumed
-
-                    # Procedural function - mark all args as consumed
-                    # Functional function - only mark if not returned
-                    should_mark_consumed = True if is_procedural_function else arg not in returned_quantum_args
-
-                    if should_mark_consumed:
-                        # This array was consumed (not returned)
-                        # Track the actual array name that was passed (might be reconstructed or fresh)
-                        # Check if there's a fresh/refreshed version of this array
-                        actual_name_to_mark = arg
-                        if hasattr(self, "refreshed_arrays") and arg in self.refreshed_arrays:
-                            # Use the refreshed/fresh name (e.g., c_d_fresh instead of c_d)
-                            actual_name_to_mark = self.refreshed_arrays[arg]
-                        elif hasattr(self, "array_remapping") and arg in self.array_remapping:
-                            # Use the remapped name
-                            actual_name_to_mark = self.array_remapping[arg]
-
-                        self.consumed_arrays.add(actual_name_to_mark)
-                        # Also mark the original name to prevent double cleanup
-                        if actual_name_to_mark != arg:
-                            self.consumed_arrays.add(arg)
-
-        # For procedural functions, don't assign the result - just call the function
-        if is_procedural_function:
-            # Create expression statement for the function call (no assignment)
-            class ExpressionStatement(Statement):
-                def __init__(self, expr):
-                    self.expr = expr
-
-                def analyze(self, _context):
-                    return []
-
-                def render(self, context):
-                    return self.expr.render(context)
-
-            # After a procedural call, restore the unpacked arrays
-            # Procedural functions borrow, they don't consume, so the unpacked variables are still valid
-            if saved_unpacked_arrays:
-                for item in saved_unpacked_arrays:
-                    if len(item) == 3:  # Has reconstructed name and element names
-                        array_name, element_names, _ = item
-                        # Restore the unpacked variables - they're still valid after a borrow
-                        if not hasattr(self, "unpacked_vars"):
-                            self.unpacked_vars = {}
-                        self.unpacked_vars[array_name] = element_names
-
-            return ExpressionStatement(call)
-
-        # With the functional pattern, functions that consume quantum arrays return the live ones
-        if returned_quantum_args and function_consumes:
-            # Black Box Pattern: Function returns modified global arrays/structs
-            # Assign directly back to original names to maintain SLR semantics
-            # ALSO handle @owned functions that return reconstructed structs
-            statements = []
-
-            # Check if the function returns a tuple by looking up its return type
-            func_return_type = self.function_return_types.get(func_name, "")
-            returns_tuple = func_return_type.startswith("tuple[")
-
-            # CRITICAL: Use actual_returns_tuple from block inspection if available
-            # This is more reliable than function_return_types which may not be populated yet
-            if actual_returns_tuple:
-                returns_tuple = True
-
-            # Don't force tuple unpacking based on argument count - use actual return type
-            # A function can take multiple args but return only one (e.g., consume some, return others)
-
-            if len(returned_quantum_args) == 1 and not returns_tuple:
-                # Single return - assign back to the same variable name
-                # In Guppy's linear type system, reassigning to the same name shadows the old binding
-                name = returned_quantum_args[0]
-
-                # Handle both reconstructed array names (_q_array) and original names (q)
-                base_name = name[1:].replace("_array", "") if name.startswith("_") and name.endswith("_array") else name
-
-                # CRITICAL: If the variable was already unpacked (parameter unpacked at function start),
-                # we cannot assign to the same name - need a fresh variable name
-                # Example: def f(c_d: array @owned):
-                #   __c_d_0, ... = c_d    # c_d consumed
-                #   c_d = h(...)          # ERROR - c_d already consumed!
-                # Fix: use fresh name like c_d_fresh
-                # Use unpacked_before_call (saved state before argument processing)
-                # because argument processing may have deleted the array from unpacked_vars
-                if base_name in unpacked_before_call:
-                    # Variable was unpacked - use fresh name for assignment
-                    fresh_name = self._get_unique_var_name(f"{name}_fresh")
-                    # Clear the unpacked tracking if still present
-                    if hasattr(self, "unpacked_vars") and base_name in self.unpacked_vars:
-                        del self.unpacked_vars[base_name]
-                else:
-                    # Variable wasn't unpacked - can assign to same name (shadows old binding)
-                    fresh_name = name
-
-                # Use the appropriate variable name for the assignment
-                assignment = Assignment(target=VariableRef(fresh_name), value=call)
-                statements.append(assignment)
-
-                # Track fresh variables for cleanup in procedural functions
-                # If we created a fresh variable (not same as parameter name), track it
-                if fresh_name != name:
-                    if not hasattr(self, "fresh_return_vars"):
-                        self.fresh_return_vars = {}
-                    self.fresh_return_vars[fresh_name] = {
-                        "original": name,
-                        "func_name": func_name,
-                        "is_quantum_array": True,
-                    }
-
-                # Update context for returned variable
-                self._update_context_for_returned_variable(name, fresh_name)
-
-                # Also update array remapping for cleanup logic
-                if not hasattr(self, "array_remapping"):
-                    self.array_remapping = {}
-                self.array_remapping[name] = fresh_name
-
-                # Track this array as refreshed by function call
-                self.refreshed_arrays[name] = fresh_name
-                # Track which function refreshed this array and its position (0 for single return)
-                if not hasattr(self, "refreshed_by_function"):
-                    self.refreshed_by_function = {}
-                self.refreshed_by_function[name] = {
-                    "function": func_name,
-                    "position": 0,
-                }
-
-                # If this is a struct, decompose it to avoid field access issues
-                if name in self.struct_info:
-                    struct_info = self.struct_info[name]
-                    # Always decompose fresh structs to avoid AlreadyUsedError on field access
-                    needs_decomposition = True
-
-                    if needs_decomposition:
-                        # IMPORTANT: We cannot re-unpack from the struct because it may have been
-                        # consumed by the function call. Instead, we need to
-                        # update our var_remapping
-                        # to indicate that the unpacked variables are no longer valid.
-                        # The code should use the struct fields directly after function calls.
-
-                        # Comment explaining why we can't re-unpack
-                        statements.append(
-                            Comment(
-                                "Note: Cannot use unpacked variables after calling function with @owned struct",
-                            ),
-                        )
-
-                        # For fresh structs returned from functions, we need to decompose them immediately
-                        # to avoid AlreadyUsedError when accessing fields
-                        struct_name = struct_info["struct_name"].replace("_struct", "")
-                        decompose_func_name = f"{struct_name}_decompose"
-
-                        # Generate field variables for decomposition
-                        field_vars = []
-                        for suffix, field_type, field_size in sorted(
-                            struct_info["fields"],
-                        ):
-                            field_var = f"{fresh_name}_{suffix}"
-                            field_vars.append(field_var)
-
-                        # Add decomposition statement for the fresh struct
-                        statements.append(
-                            Comment(
-                                "Decompose fresh struct to avoid field access on consumed struct",
-                            ),
-                        )
-
-                        class TupleAssignment(Statement):
-                            def __init__(self, targets, value):
-                                self.targets = targets
-                                self.value = value
-
-                            def analyze(self, context):
-                                self.value.analyze(context)
-
-                            def render(self, context):
-                                target_str = ", ".join(self.targets)
-                                value_str = self.value.render(context)[0]
-                                return [f"{target_str} = {value_str}"]
-
-                        decompose_call = FunctionCall(
-                            func_name=decompose_func_name,
-                            args=[VariableRef(fresh_name)],
-                        )
-
-                        decomposition_stmt = TupleAssignment(
-                            targets=field_vars,
-                            value=decompose_call,
-                        )
-                        statements.append(decomposition_stmt)
-
-                        # Track decomposed variables for field access
-                        if not hasattr(self, "decomposed_vars"):
-                            self.decomposed_vars = {}
-                        field_mapping = {}
-                        for suffix, field_type, field_size in sorted(
-                            struct_info["fields"],
-                        ):
-                            field_var = f"{fresh_name}_{suffix}"
-                            field_mapping[suffix] = field_var
-                        self.decomposed_vars[fresh_name] = field_mapping
-
-                        # Update var_remapping to indicate these variables should not be used
-                        # by mapping them back to struct field access
-                        for var_name in struct_info["var_names"].values():
-                            if var_name in self.var_remapping:
-                                # This will cause future references to use struct.field notation
-                                del self.var_remapping[var_name]
-
-                # Force unpacking for arrays that need element access after function calls
-                # This is the core fix for the nested blocks MoveOutOfSubscriptError
-                # For refreshed arrays, check if they have element access that requires unpacking
-                needs_unpacking_for_refresh = False
-                if name in self.refreshed_arrays:
-                    # CRITICAL FIX: Don't automatically unpack refreshed arrays
-                    # The original analysis was for the INPUT parameter, not the refreshed return value
-                    # Only unpack if there's explicit subscript usage AFTER this call
-                    # This is handled by force_unpack_for_subscript below
-                    needs_unpacking_for_refresh = False
-
-                # CRITICAL: Only unpack returned arrays if they actually need element access
-                # Don't unpack just because the array was unpacked at function start
-                # Check if the array CURRENTLY needs unpacking based on how it's used AFTER this call
-                should_unpack_returned = (
-                    # Only unpack if actively needed for element access after this point
-                    needs_unpacking_for_refresh
-                ) and name not in self.struct_info
-
-                # CRITICAL: Always check if function returns array
-                # If so, force unpacking to avoid MoveOutOfSubscriptError
-                force_unpack_for_subscript = False
-                return_array_size_check = None
-
-                # Try to get return type from function_return_types (if already analyzed)
-                if func_name in self.function_return_types:
-                    return_type = self.function_return_types[func_name]
-                    import re
-
-                    match = re.search(r"array\[.*?,\s*(\d+)\]", return_type)
-                    if match:
-                        return_array_size_check = int(match.group(1))
-
-                        # Check if next operation uses subscript on this array
-                        # This catches the pattern: q = func(q); measure(q[0])
-                        if (
-                            hasattr(self, "current_block_ops")
-                            and hasattr(self, "current_op_index")
-                            and self.current_block_ops is not None
-                            and self.current_op_index is not None
-                        ):
-                            next_index = self.current_op_index + 1
-                            if next_index < len(self.current_block_ops):
-                                next_op = self.current_block_ops[next_index]
-                                # Check if next op uses subscript on this array
-                                if hasattr(next_op, "qargs"):
-                                    for qarg in next_op.qargs:
-                                        if (
-                                            hasattr(qarg, "reg")
-                                            and hasattr(qarg.reg, "sym")
-                                            and qarg.reg.sym == name
-                                            and hasattr(qarg, "index")
-                                        ):
-                                            # Next op uses subscript on returned array
-                                            force_unpack_for_subscript = True
-                                            break
-                else:
-                    # Function not analyzed yet - use live_qubits from block analysis
-                    # Check if this array has live qubits that indicate return size
-                    if name in live_qubits and len(live_qubits[name]) >= 1:
-                        # The block returns live qubits from this array
-                        return_array_size_check = len(live_qubits[name])
-
-                        # Check if next operation uses subscript on this array
-                        if (
-                            hasattr(self, "current_block_ops")
-                            and hasattr(self, "current_op_index")
-                            and self.current_block_ops is not None
-                            and self.current_op_index is not None
-                        ):
-                            next_index = self.current_op_index + 1
-                            if next_index < len(self.current_block_ops):
-                                next_op = self.current_block_ops[next_index]
-                                # Check if next op uses subscript on this array
-                                if hasattr(next_op, "qargs"):
-                                    for qarg in next_op.qargs:
-                                        if (
-                                            hasattr(qarg, "reg")
-                                            and hasattr(qarg.reg, "sym")
-                                            and qarg.reg.sym == name
-                                            and hasattr(qarg, "index")
-                                        ):
-                                            # Next op uses subscript on returned array
-                                            force_unpack_for_subscript = True
-                                            break
-
-                if should_unpack_returned or force_unpack_for_subscript:
-                    # Use the size we already extracted
-                    return_array_size = return_array_size_check
-
-                    # If we know the return size and it's >= 1, unpack for element access
-                    # Even size-1 arrays need unpacking to avoid MoveOutOfSubscriptError
-                    if return_array_size and return_array_size >= 1:
-                        # Generate unpacked variable names
-                        # IMPORTANT: Use unique suffix "_ret" to avoid shadowing initial allocations
-                        # When we do local_allocate strategy, we create q_0, q_1, q_2
-                        # When function returns array, we unpack to q_0_ret, q_1_ret to avoid conflicts
-                        # CRITICAL: Make names unique across multiple unpackings using a counter
-                        if not hasattr(self, "_unpack_counter"):
-                            self._unpack_counter = {}
-                        if name not in self._unpack_counter:
-                            self._unpack_counter[name] = 0
-                        else:
-                            self._unpack_counter[name] += 1
-                        unpack_suffix = (
-                            f"_ret{self._unpack_counter[name]}" if self._unpack_counter[name] > 0 else "_ret"
-                        )
-                        element_names = [f"{name}_{i}{unpack_suffix}" for i in range(return_array_size)]
-
-                        # Add unpacking statement using ArrayUnpack IR class.
-                        # When the array was refreshed by a function call (e.g.,
-                        # q → q_fresh), unpack from the refreshed name -- the
-                        # original is moved/consumed at this point. Without
-                        # this, generated Guppy looks like `q_0_ret, = q` and
-                        # Guppy rejects with WrongNumberOfUnpacksError or
-                        # AlreadyUsedError.
-                        from pecos.slr.gen_codes.guppy.ir import ArrayUnpack
-
-                        unpack_source = self.refreshed_arrays.get(name, name)
-                        unpack_stmt = ArrayUnpack(
-                            targets=element_names,
-                            source=unpack_source,
-                        )
-                        statements.append(unpack_stmt)
-
-                        # Track unpacked variables
-                        if not hasattr(self, "unpacked_vars"):
-                            self.unpacked_vars = {}
-                        self.unpacked_vars[name] = element_names
-
-                        # CRITICAL: Track index mapping for partial consumption
-                        # If live_qubits tells us which original indices are in the returned array,
-                        # create a mapping from original index → unpacked variable index
-                        index_map: dict[int, int] | None = None
-                        if name in live_qubits:
-                            original_indices = sorted(live_qubits[name])
-                            if not hasattr(self, "index_mapping"):
-                                self.index_mapping = {}
-                            # Map original index to position in returned/unpacked array
-                            index_map = {orig_idx: new_idx for new_idx, orig_idx in enumerate(original_indices)}
-                            self.index_mapping[name] = index_map
-
-                        # Mirror to unified variable state (see variable_state.py)
-                        self.var_state.bind_unpacked(name, list(element_names), index_map)
-
-                        # Update context
-                        if hasattr(self, "context"):
-                            var = self.context.lookup_variable(name)
-                            if var:
-                                var.is_unpacked = True
-                                var.unpacked_names = element_names
-
-                        # DON'T immediately reconstruct - just leave the array unpacked
-                        # Reconstruction will happen on-demand when needed (see below)
-                elif hasattr(self, "unpacked_vars") and name in self.unpacked_vars:
-                    # Classical array or other case - invalidate old unpacked variables
-                    old_element_names = self.unpacked_vars[name]
-                    del self.unpacked_vars[name]
-
-                    # Also update the context to invalidate unpacked variable information
-                    if hasattr(self, "context"):
-                        var = self.context.lookup_variable(name)
-                        if var:
-                            var.is_unpacked = False
-                            var.unpacked_names = []
-
-                    # Add comment explaining why we can't re-unpack
-                    statements.append(
-                        Comment(
-                            f"Note: Unpacked variables {old_element_names} invalidated "
-                            "after function call - array size may have changed",
-                        ),
-                    )
-                elif name in self.plan.arrays_to_unpack and name not in self.unpacked_vars:
-                    # After function calls, don't automatically re-unpack arrays
-                    # The array may have changed size and old unpacked variables are stale
-                    # Instead, use array indexing for future references
-                    statements.append(
-                        Comment(
-                            f"Note: Not re-unpacking {name} after function call - "
-                            "array may have changed size, use array indexing instead",
-                        ),
-                    )
-
-            else:
-                # HYBRID TUPLE ASSIGNMENT: Choose strategy based on function and usage patterns
-                use_fresh_variables = self._should_use_fresh_variables(
-                    func_name,
-                    quantum_args,
-                )
-
-                if use_fresh_variables:
-                    # Use fresh variables to avoid PlaceNotUsedError in problematic patterns
-                    # Generate unique names to avoid reassignment issues in loops
-                    if not hasattr(self, "_fresh_var_counter"):
-                        self._fresh_var_counter = {}
-
-                    fresh_targets = []
-
-                    # Check if we're in a consumption loop (conditional or not)
-                    in_consumption_loop = (
-                        hasattr(self, "_in_conditional_consumption_loop")
-                        and self._in_conditional_consumption_loop
-                        and hasattr(self, "scope_manager")
-                        and self.scope_manager.is_in_loop()
-                    )
-
-                    for arg in quantum_args:
-                        # If we're in a consumption loop,
-                        # reuse existing fresh names to avoid creating new variables in each iteration
-                        if in_consumption_loop and arg in self.refreshed_arrays:
-                            # Reuse the existing fresh variable name
-                            fresh_name = self.refreshed_arrays[arg]
-                            fresh_targets.append(fresh_name)
-                        else:
-                            base_name = f"{arg}_fresh"
-                            # For loops and repeated calls, use unique suffixes
-                            if base_name in self._fresh_var_counter:
-                                self._fresh_var_counter[base_name] += 1
-                                unique_name = f"{base_name}_{self._fresh_var_counter[base_name]}"
-                            else:
-                                self._fresh_var_counter[base_name] = 0
-                                unique_name = base_name
-                            fresh_targets.append(unique_name)
-                else:
-                    # Standard tuple assignment - but check if we need to avoid borrowed variables
-                    # OR if variables were unpacked before the call
-                    fresh_targets = []
-                    for arg_idx, arg in enumerate(quantum_args):
-                        # CRITICAL: Check if this parameter was already unpacked before the call
-                        # If so, we MUST use a fresh variable name (can't assign to consumed variable)
-                        # This is the same issue we fixed for single returns
-                        was_unpacked = arg in unpacked_before_call
-
-                        # Check if this variable is a borrowed parameter (not @owned)
-                        # If so, we need to use a different name to avoid BorrowShadowedError
-                        is_borrowed = False
-                        if hasattr(self, "current_function_name") and self.current_function_name:
-                            # Check if this is a function parameter
-                            func_info = self.function_info.get(
-                                self.current_function_name,
-                                {},
-                            )
-                            params = func_info.get("params", [])
-                            for param_name, param_type in params:
-                                if (
-                                    param_name == arg
-                                    and "@owned" not in param_type
-                                    and "array[quantum.qubit" in param_type
-                                ):
-                                    # This is a borrowed quantum array parameter
-                                    is_borrowed = True
-                                    break
-
-                        # Determine if we need a fresh name for any reason:
-                        # 1. Variable was unpacked before call (consumed)
-                        # 2. Variable is a borrowed parameter (can't shadow)
-                        needs_fresh_name = was_unpacked or is_borrowed
-
-                        if needs_fresh_name:
-                            # Use a fresh name to avoid:
-                            # - AlreadyUsedError (if unpacked before call)
-                            # - BorrowShadowedError (if borrowed parameter)
-                            # Check if we're in a loop - if so, reuse the existing variable name
-                            in_loop = hasattr(self, "scope_manager") and self.scope_manager.is_in_loop()
-
-                            if in_loop and hasattr(self, "refreshed_arrays") and arg in self.refreshed_arrays:
-                                # In a loop, reuse the existing refreshed name to avoid undefined variable errors
-                                fresh_name = self.refreshed_arrays[arg]
-                            elif hasattr(self, "refreshed_arrays") and arg in self.refreshed_arrays:
-                                # Not in a loop but already have a returned version, need a new unique name
-                                if not hasattr(self, "_returned_var_counter"):
-                                    self._returned_var_counter = {}
-                                base_name = f"{arg}_returned"
-                                if base_name not in self._returned_var_counter:
-                                    self._returned_var_counter[base_name] = 1
-                                else:
-                                    self._returned_var_counter[base_name] += 1
-                                fresh_name = f"{base_name}_{self._returned_var_counter[base_name]}"
-                            else:
-                                # Choose suffix based on reason for fresh name
-                                if was_unpacked:
-                                    # Use _fresh suffix for unpacked parameters (more descriptive)
-                                    fresh_name = self._get_unique_var_name(
-                                        f"{arg}_fresh",
-                                    )
-                                else:
-                                    # Use _returned suffix for borrowed parameters
-                                    fresh_name = f"{arg}_returned"
-
-                            fresh_targets.append(fresh_name)
-
-                            # Track this for later use
-                            if not hasattr(self, "refreshed_arrays"):
-                                self.refreshed_arrays = {}
-                            self.refreshed_arrays[arg] = fresh_name
-                            # Track which function refreshed this array and its position in return tuple
-                            if not hasattr(self, "refreshed_by_function"):
-                                self.refreshed_by_function = {}
-                            self.refreshed_by_function[arg] = {
-                                "function": func_name,
-                                "position": arg_idx,
-                            }
-
-                            # Also track in fresh_return_vars for cleanup in procedural functions
-                            if was_unpacked:
-                                if not hasattr(self, "fresh_return_vars"):
-                                    self.fresh_return_vars = {}
-                                self.fresh_return_vars[fresh_name] = {
-                                    "original": arg,
-                                    "func_name": func_name,
-                                    "is_quantum_array": True,
-                                }
-                        else:
-                            # Safe to use the original name (not unpacked, not borrowed)
-                            fresh_targets.append(arg)
-
-                class TupleAssignment(Statement):
-                    def __init__(self, targets, value):
-                        self.targets = targets
-                        self.value = value
-
-                    def analyze(self, context):
-                        self.value.analyze(context)
-
-                    def render(self, context):
-                        target_str = ", ".join(self.targets)
-                        value_str = self.value.render(context)[0]
-                        return [f"{target_str} = {value_str}"]
-
-                assignment = TupleAssignment(targets=fresh_targets, value=call)
-                statements.append(assignment)
-
-                # Track all refreshed/returned variables for proper return handling
-                for i, original_name in enumerate(quantum_args):
-                    if i < len(fresh_targets):
-                        fresh_name = fresh_targets[i]
-                        if fresh_name != original_name:
-                            # This variable was renamed (either _fresh or _returned)
-                            # Track it so return statements use the correct name
-                            if not hasattr(self, "refreshed_arrays"):
-                                self.refreshed_arrays = {}
-                            # Always update the mapping for return handling
-                            self.refreshed_arrays[original_name] = fresh_name
-                            # Track which function refreshed this array and its position in return tuple
-                            if not hasattr(self, "refreshed_by_function"):
-                                self.refreshed_by_function = {}
-                            self.refreshed_by_function[original_name] = {
-                                "function": func_name,
-                                "position": i,
-                            }
-
-                            # Also track in fresh_return_vars for cleanup in procedural functions
-                            # All fresh variables from tuple returns need cleanup tracking
-                            if not hasattr(self, "fresh_return_vars"):
-                                self.fresh_return_vars = {}
-                            self.fresh_return_vars[fresh_name] = {
-                                "original": original_name,
-                                "func_name": func_name,
-                                "is_quantum_array": True,
-                            }
-
-                # Check if any of the returned variables are structs and decompose them immediately
-                for var_name in fresh_targets:
-                    # Check if this variable name corresponds to a struct
-                    # It might be a fresh name (e.g., c_fresh) or original name (e.g., c)
-                    struct_info = None
-
-                    if var_name in self.struct_info:
-                        struct_info = self.struct_info[var_name]
-                    else:
-                        # Check if this is a renamed struct (e.g., c_fresh -> c)
-                        # Be precise: only match if the variable is actually a renamed version of the struct
-                        for key, info in self.struct_info.items():
-                            # Check for exact pattern: key_suffix (e.g., c_fresh)
-                            if var_name == f"{key}_fresh" or var_name == f"{key}_returned":
-                                struct_info = info
-                                break
-
-                    if struct_info:
-                        # Decompose fresh structs that will be used in loops
-                        # This allows us to access fields without consuming the struct
-                        struct_name = struct_info["struct_name"].replace("_struct", "")
-                        decompose_func_name = f"{struct_name}_decompose"
-
-                        # Generate field variables for decomposition
-                        field_vars = []
-                        for suffix, field_type, field_size in sorted(
-                            struct_info["fields"],
-                        ):
-                            field_var = f"{var_name}_{suffix}"
-                            field_vars.append(field_var)
-
-                        # Add decomposition statement
-                        statements.append(
-                            Comment(f"Decompose {var_name} for field access"),
-                        )
-
-                        decompose_call = FunctionCall(
-                            func_name=decompose_func_name,
-                            args=[VariableRef(var_name)],
-                        )
-
-                        decomposition_stmt = TupleAssignment(
-                            targets=field_vars,
-                            value=decompose_call,
-                        )
-                        statements.append(decomposition_stmt)
-
-                        # Track decomposed variables
-                        if not hasattr(self, "decomposed_vars"):
-                            self.decomposed_vars = {}
-                        field_mapping = {}
-                        for suffix, field_type, field_size in sorted(
-                            struct_info["fields"],
-                        ):
-                            field_var = f"{var_name}_{suffix}"
-                            field_mapping[suffix] = field_var
-                        self.decomposed_vars[var_name] = field_mapping
-
-                # Handle variable mapping based on whether we used fresh variables
-                if use_fresh_variables:
-                    statements.append(
-                        Comment("Using fresh variables to avoid linearity conflicts"),
-                    )
-
-                    # Check if we're in a conditional within a loop
-                    # This requires special handling to avoid linearity violations
-                    (hasattr(self, "scope_manager") and self.scope_manager.is_in_conditional_within_loop())
-
-                    # Update variable mapping so future references use the fresh names
-                    # BUT only for functions that truly "refresh" the same arrays
-                    # Functions like prep_zero_verify return different arrays, not refreshed inputs
-                    refresh_functions = [
-                        "process_qubits",  # Functions that process and return the same qubits
-                        "apply_gates",  # Functions that apply operations and return the same qubits
-                        "measure_and_reset",  # Functions that measure, reset, and return the same qubits
-                    ]
-
-                    # Check if this function actually refreshes arrays (returns processed versions of inputs)
-                    should_refresh_arrays = any(pattern in func_name.lower() for pattern in refresh_functions)
-
-                    # Additional check: if function has @owned parameters and returns fresh variables,
-                    # it's likely refreshing the arrays
-                    if not should_refresh_arrays and use_fresh_variables:
-                        # Check if any fresh target names contain "fresh" - indicates array refreshing
-                        has_fresh_returns = any("fresh" in target for target in fresh_targets)
-                        if has_fresh_returns:
-                            # Most quantum functions that return "fresh" variables are refreshing arrays
-                            # This includes verification functions that return processed versions of inputs
-                            should_refresh_arrays = True
-
-                    if should_refresh_arrays:
-                        for i, original_name in enumerate(quantum_args):
-                            if i < len(fresh_targets):
-                                fresh_name = fresh_targets[i]
-                                if fresh_name != original_name:  # Only map if actually fresh
-                                    # Check if this is a conditional fresh variable (ending in _1)
-                                    if fresh_name.endswith("_1"):
-                                        # Don't update mapping for conditional variables to avoid errors
-                                        # Conditional consumption in loops is fundamentally incompatible
-                                        # with guppylang's linearity requirements
-                                        base_fresh_name = fresh_name[:-2]  # Remove _1 suffix
-                                        self.conditional_fresh_vars[base_fresh_name] = fresh_name
-                                    elif original_name not in self.refreshed_arrays:
-                                        # Safe to update - first assignment
-                                        self.refreshed_arrays[original_name] = fresh_name
-                                        # Track which function refreshed this array and its position in return tuple
-                                        if not hasattr(self, "refreshed_by_function"):
-                                            self.refreshed_by_function = {}
-                                        self.refreshed_by_function[original_name] = {
-                                            "function": func_name,
-                                            "position": i,
-                                        }
-                                        self._update_context_for_returned_variable(
-                                            original_name,
-                                            fresh_name,
-                                        )
-                    else:
-                        # For functions that return different arrays (like prep_zero_verify),
-                        # don't map fresh variables as refreshed versions of inputs
-                        # This allows proper reconstruction from unpacked variables in returns
-                        pass
-
-                    # Immediately check if any fresh variables are likely to be unused
-                    # and add discard for them
-                    # Specifically, check for the ancilla pattern where ancilla_fresh is returned
-                    # but not used after syndrome extraction
-                    for i, original_name in enumerate(quantum_args):
-                        if i < len(fresh_targets):
-                            fresh_name = fresh_targets[i]
-                            # Check if this is likely an ancilla array that won't be used
-                            # Pattern: ancilla arrays that are measured inside the function
-                            is_ancilla = "ancilla" in original_name.lower()
-                            is_fresh = fresh_name != original_name
-                            in_main = self.current_function_name == "main"
-                            if is_ancilla and is_fresh and in_main:
-                                # Check if we're in main (where ancillas are typically not reused)
-                                # Add immediate discard for ancilla_fresh
-                                statements.append(
-                                    Comment(
-                                        f"Discard unused {fresh_name} immediately",
-                                    ),
-                                )
-                                discard_stmt = FunctionCall(
-                                    func_name="quantum.discard_array",
-                                    args=[VariableRef(fresh_name)],
-                                )
-
-                                class ExpressionStatement(Statement):
-                                    def __init__(self, expr):
-                                        self.expr = expr
-
-                                    def analyze(self, context):
-                                        self.expr.analyze(context)
-
-                                    def render(self, context):
-                                        return self.expr.render(context)
-
-                                statements.append(ExpressionStatement(discard_stmt))
-                else:
-                    statements.append(
-                        Comment("Standard tuple assignment to original variables"),
-                    )
-                    # For standard assignment, variables keep their original names
-                    # BUT don't overwrite if we already set a different mapping (e.g., for _returned variables)
-                    for i, original_name in enumerate(quantum_args):
-                        if i < len(fresh_targets):
-                            fresh_name = fresh_targets[i]
-                            # Only set to original name if we haven't already mapped to a different name
-                            if fresh_name == original_name:
-                                self.refreshed_arrays[original_name] = original_name
-                            # If fresh_name != original_name, the mapping was already set above
-
-                # Handle struct field invalidation after function call
-                for array_name in quantum_args:
-                    if array_name in self.struct_info and hasattr(
-                        self,
-                        "var_remapping",
-                    ):
-                        struct_info = self.struct_info[array_name]
-                        # Check if any of the struct's fields are in var_remapping
-                        needs_update = any(var in self.var_remapping for var in struct_info["var_names"].values())
-
-                        if needs_update:
-                            # Cannot re-unpack - invalidate the unpacked variables
-                            statements.append(
-                                Comment(
-                                    "Note: Cannot use unpacked variables after calling function with @owned struct",
-                                ),
-                            )
-
-                            # Update var_remapping to indicate these variables should not be used
-                            for var_name in struct_info["var_names"].values():
-                                if var_name in self.var_remapping:
-                                    del self.var_remapping[var_name]
-
-                # Unpack any arrays that need it after the function call
-                # BUT: Don't unpack if already unpacked (to avoid AlreadyUsedError)
-                for array_name in quantum_args:
-                    if (
-                        array_name in self.plan.unpack_at_start
-                        and array_name not in self.struct_info
-                        and array_name in self.plan.arrays_to_unpack
-                        and array_name not in self.unpacked_vars  # Don't re-unpack!
-                    ):
-                        info = self.plan.arrays_to_unpack[array_name]
-                        self._add_array_unpacking(array_name, info.size)
-
-            # Check if current function is procedural (returns None) and add discards for unused quantum arrays
-            is_in_procedural = getattr(self, "current_function_is_procedural", False)
-            if is_in_procedural and len(statements) == 1:
-                # This is a procedural function with a single assignment (likely the last operation)
-                # Check if we have an unused quantum array to discard
-                # This happens when a procedural function calls a function that returns an array
-                # but doesn't use the result
-                stmt = statements[0]
-                if isinstance(stmt, Assignment):
-                    # Check if this is an assignment to a quantum array
-                    target_name = None
-                    if hasattr(stmt.target, "name"):
-                        target_name = stmt.target.name
-
-                    # Check if this is a quantum array by checking:
-                    # 1. If it's in returned_quantum_args (passed as quantum param)
-                    # 2. Or if func_name returns a quantum array (if we know the return type)
-                    is_quantum_array = target_name in returned_quantum_args
-
-                    if not is_quantum_array and func_name in self.function_return_types:
-                        return_type = self.function_return_types[func_name]
-                        is_quantum_array = "array[quantum.qubit," in return_type
-
-                    if target_name and is_quantum_array:
-                        # This is a quantum array that was assigned but may not be used
-                        # Add a discard statement for it
-                        discard_call = FunctionCall(
-                            func_name="quantum.discard_array",
-                            args=[VariableRef(target_name)],
-                        )
-
-                        # Define ExpressionStatement locally if not already defined
-                        class ExpressionStatement(Statement):
-                            def __init__(self, expr):
-                                self.expr = expr
-
-                            def analyze(self, _context):
-                                return []
-
-                            def render(self, context):
-                                return self.expr.render(context)
-
-                        statements.append(Comment(f"Discard unused {target_name}"))
-                        statements.append(ExpressionStatement(discard_call))
-
-            # Return block with all statements
-            if len(statements) == 1:
-                return statements[0]
-            return Block(statements=statements)
-
-        # Either no quantum arrays OR function consumes its parameters
-        # In both cases, just call the function without assignment
-        class ExpressionStatement(Statement):
-            def __init__(self, expr):
-                self.expr = expr
-
-            def analyze(self, context):
-                self.expr.analyze(context)
-
-            def render(self, context):
-                return self.expr.render(context)
-
-        return ExpressionStatement(call)
-
-    def _function_returns_something(self, func_name: str) -> bool:
-        """Check if a function returns a value (not None)."""
-        # Functions that work with structs and return modified structs
-        # Check if this function name indicates it works with structs
-        if self.struct_info:
-            for info in self.struct_info.values():
-                struct_name = info.get("struct_name", "")
-                # Extract the base name from the struct name (e.g., "steane" from "steane_struct")
-                if "_struct" in struct_name:
-                    base_name = struct_name.replace("_struct", "").lower()
-                else:
-                    base_name = struct_name.lower()
-
-                if func_name.startswith(f"{base_name}_"):
-                    # Struct functions typically return the modified struct
-                    # Exception: functions ending in 'discard' or 'decompose'
-                    # don't return the struct
-                    return not (func_name.endswith(("_discard", "_decompose")))
-
-        # For other functions, assume they return something if they have quantum args
-        # This is a conservative approach
-        return False
-
-    def _analyze_quantum_resource_flow(
-        self,
-        block,
-    ) -> tuple[dict[str, set[int]], dict[str, set[int]]]:
-        """Analyze which quantum resources are consumed vs. live in a block.
-
-        Returns:
-            consumed_qubits: dict mapping qreg names to sets of consumed indices
-            live_qubits: dict mapping qreg names to sets of live indices
-        """
-        consumed_qubits = {}
-        live_qubits = {}
-
-        # Track all quantum variables used
-        all_quantum_vars = set()
-
-        if hasattr(block, "ops"):
-            for op in block.ops:
-                # Check for measurements that consume qubits
-                if type(op).__name__ == "Measure":
-                    if hasattr(op, "qargs"):
-                        for qarg in op.qargs:
-                            if hasattr(qarg, "reg") and hasattr(qarg.reg, "sym"):
-                                qreg_name = qarg.reg.sym
-                                if hasattr(qarg, "index"):
-                                    # Single qubit measurement
-                                    if qreg_name not in consumed_qubits:
-                                        consumed_qubits[qreg_name] = set()
-                                    consumed_qubits[qreg_name].add(qarg.index)
-                            elif hasattr(qarg, "sym"):
-                                # Full array measurement
-                                qreg_name = qarg.sym
-                                if hasattr(qarg, "size"):
-                                    if qreg_name not in consumed_qubits:
-                                        consumed_qubits[qreg_name] = set()
-                                    consumed_qubits[qreg_name].update(range(qarg.size))
-
-                # Check for nested Block operations that may consume qubits
-                elif hasattr(op, "ops") and hasattr(op, "vars"):
-                    # This is a nested block - analyze it recursively
-                    nested_consumed, _nested_live = self._analyze_quantum_resource_flow(
-                        op,
-                    )
-
-                    # Merge nested consumption into our tracking
-                    for qreg_name, indices in nested_consumed.items():
-                        if qreg_name not in consumed_qubits:
-                            consumed_qubits[qreg_name] = set()
-                        consumed_qubits[qreg_name].update(indices)
-
-                # Track all quantum variables used (for determining what's live)
-                if hasattr(op, "qargs"):
-                    for qarg in op.qargs:
-                        if isinstance(qarg, tuple):
-                            for sub_qarg in qarg:
-                                if hasattr(sub_qarg, "reg") and hasattr(
-                                    sub_qarg.reg,
-                                    "sym",
-                                ):
-                                    all_quantum_vars.add(sub_qarg.reg.sym)
-                                elif hasattr(sub_qarg, "sym"):
-                                    all_quantum_vars.add(sub_qarg.sym)
-                        elif hasattr(qarg, "reg") and hasattr(qarg.reg, "sym"):
-                            all_quantum_vars.add(qarg.reg.sym)
-                        elif hasattr(qarg, "sym"):
-                            all_quantum_vars.add(qarg.sym)
-
-        # Determine live qubits (used but not consumed)
-        # We need to know the actual size of arrays to determine what's live
-        # Get size information from the block's variable definitions
-        array_sizes = {}
-
-        # Check all attributes of the block for QReg/CReg definitions
-        for attr_name in dir(block):
-            if not attr_name.startswith("_"):  # Skip private attributes
-                try:
-                    attr = getattr(block, attr_name, None)
-                    if attr and hasattr(attr, "size") and hasattr(attr, "sym"):
-                        array_sizes[attr.sym] = attr.size
-                        # Add to all_quantum_vars if it's a quantum register
-                        if hasattr(attr, "__class__") and "QReg" in attr.__class__.__name__:
-                            all_quantum_vars.add(attr.sym)
-                except (AttributeError, TypeError):
-                    # Ignore attributes without expected structure
-                    pass
-
-        # Also check variable context if available
-        if hasattr(self, "context") and self.context:
-            for var_name in all_quantum_vars:
-                var_info = self.context.lookup_variable(var_name)
-                if var_info and var_info.size:
-                    array_sizes[var_name] = var_info.size
-
-        # Pre-track explicit resets to know which consumed qubits are reset and should be considered live
-        consumed_for_tracking = {}
-        self._track_consumed_qubits(block, consumed_for_tracking)
-
-        for var_name in all_quantum_vars:
-            if var_name not in consumed_qubits:
-                # Variable is used but not consumed - it's fully live
-                # Determine size from context or default
-                size = array_sizes.get(var_name, 2)  # Default to 2 if unknown
-                live_qubits[var_name] = set(range(size))
-            else:
-                # Check if only partially consumed
-                consumed_indices = consumed_qubits[var_name]
-                size = array_sizes.get(var_name, 2)  # Default to 2 if unknown
-
-                # Any indices not consumed OR explicitly reset are live
-                # Explicitly reset qubits are consumed by measurement but then recreated by Prep
-                explicitly_reset_indices = set()
-                if hasattr(self, "explicitly_reset_qubits") and var_name in self.explicitly_reset_qubits:
-                    explicitly_reset_indices = self.explicitly_reset_qubits[var_name]
-
-                live_indices = (set(range(size)) - consumed_indices) | explicitly_reset_indices
-                if live_indices:
-                    live_qubits[var_name] = live_indices
-
-        return consumed_qubits, live_qubits
-
-    def _should_function_be_procedural(
-        self,
-        func_name: str,
-        block,
-        params,
-        has_live_qubits: bool,
-    ) -> bool:
-        """
-        Smart detection to determine if a function should be procedural (return None)
-        vs functional (return tuple of quantum arrays).
-
-        Functions should be procedural if they:
-        1. Primarily do terminal operations (measurements without further quantum operations)
-        2. Are not used in patterns where quantum returns are needed afterward
-        3. Would cause PlaceNotUsedError issues with tuple returns
-
-        Functions should be functional if they:
-        1. Their quantum returns are needed for subsequent operations in the calling scope
-        2. They are part of partial consumption patterns
-        """
-
-        # Pattern-based detection for known procedural functions
-        # BUT: only if they don't have live qubits
-        procedural_patterns = [
-            "syndrome_extraction",  # Terminal syndrome measurement blocks
-            "cleanup",  # Cleanup operations
-            "discard",  # Discard operations
-        ]
-
-        # Check if this is an inner block that will be called by outer blocks
-        # Inner blocks should NOT be procedural to avoid consumption issues
-        if "inner" in func_name.lower():
-            return False
-
-        # Only apply pattern matching if there are no live qubits
-        # Functions with live qubits should return them, regardless of name
-        if not has_live_qubits:
-            for pattern in procedural_patterns:
-                if pattern in func_name.lower():
-                    # These are good candidates for procedural
-                    return True
-
-        # Functions with quantum parameters but no live qubits are good candidates for procedural
-        has_quantum_params = any("array[quantum.qubit," in param[1] for param in params if len(param) == 2)
-
-        if has_quantum_params and not has_live_qubits:
-            # This is a terminal function - good candidate for procedural
-            return True
-
-        # Check if this function would benefit from procedural approach based on operations
-        if hasattr(block, "ops"):
-            measurement_count = 0
-            gate_count = 0
-
-            for op in block.ops:
-                if hasattr(op, "__class__"):
-                    op_name = op.__class__.__name__
-                    if "Measure" in op_name:
-                        measurement_count += 1
-                    elif hasattr(op, "name") or any(gate in str(op) for gate in ["H", "X", "Y", "Z", "CX", "CZ"]):
-                        gate_count += 1
-
-            # If mostly measurements with no quantum gates, good candidate for procedural
-            # But be conservative - only if no gates at all or very few
-            # AND only if there are no live qubits to return (partial consumption must return live qubits)
-            if measurement_count > 0 and gate_count == 0 and not has_live_qubits:
-                return True
-
-        # CONSERVATIVE: Default to functional approach unless clearly terminal
-        # This avoids breaking partial consumption patterns
-        return False
-
-    def _should_use_fresh_variables(self, func_name: str, quantum_args: list) -> bool:
-        """
-        Determine if fresh variables should be used for tuple assignment.
-
-        Fresh variables help avoid PlaceNotUsedError when:
-        1. Function has complex ownership patterns (@owned mixed with borrowed)
-        2. Function might cause circular assignment issues
-        3. Function is known to cause tuple assignment problems
-        """
-
-        # Known problematic patterns that benefit from fresh variables
-        fresh_variable_patterns = [
-            "measure_ancillas",  # Mixed ownership - some params consumed, some borrowed
-            "partial_consumption",  # Partial consumption patterns
-            "process_qubits",  # Functions that process and return quantum arrays
-        ]
-
-        for pattern in fresh_variable_patterns:
-            if pattern in func_name.lower():
-                return True
-
-        # Check if we're inside a function that will return these values
-        # If the function will return these arrays, don't use fresh variables
-        # to avoid PlaceNotUsedError for unused fresh variables
-        special_funcs = ["prep_zero_verify", "prep_encoding_non_ft_zero"]
-        in_function = hasattr(self, "current_function_name") and self.current_function_name
-        if in_function and func_name in special_funcs:
-            # Check if this is the last statement in the function that will be returned
-            # For now, assume functions that manipulate and return the same arrays
-            # should NOT use fresh variables to avoid unused variable errors
-            # These functions return arrays that should be used directly
-            return False
-
-        # If function has multiple quantum arguments, it might have mixed ownership
-        # Use fresh variables to be safe
-        if len(quantum_args) > 1 and hasattr(self, "current_block") and hasattr(self.current_block, "statements"):
-            # But check if we're at the end of a function where the result will be returned
-            # In that case, don't use fresh variables
-            # This is a heuristic - if there are not many statements after this,
-            # it's likely the return statement
-            return False  # Don't use fresh variables for now
-
-        # Default: use standard tuple assignment
-        return False
-
-    def _fix_post_consuming_linearity_issues(self, body: Block) -> None:
-        """
-        Fix linearity issues by adding fresh qubit allocations after consuming operations.
-
-        When a qubit is consumed (e.g., by quantum.reset), and then used again later,
-        we need to allocate a fresh qubit to satisfy guppylang's linearity constraints.
-        """
-
-        # Track variables that have been consumed
-        new_statements = []
-
-        for stmt in body.statements:
-            # Add the current statement
-            new_statements.append(stmt)
-
-            # Check if this statement consumes any variables
-            # Note: quantum.reset is now handled with assignment (qubit = quantum.reset(qubit))
-            # so we no longer need to add automatic fresh qubit allocations
-            if hasattr(stmt, "expr") and hasattr(stmt.expr, "func_name"):
-                # Handle function calls that consume qubits
-                func_call = stmt.expr
-                if hasattr(func_call, "func_name") and func_call.func_name == "quantum.reset":
-                    # quantum.reset now uses assignment, so no need for fresh allocation
-                    # The reset operation returns the reset qubit
-                    pass
-
-        # Replace the statements
-        body.statements = new_statements
-
-    def _fix_unused_fresh_variables(self, body: Block) -> None:
-        """
-        Fix PlaceNotUsedError for fresh variables that may not be used in all execution paths.
-
-        This handles the general pattern where:
-        1. Fresh variables are created from function calls
-        2. These variables are only used conditionally in loops
-        3. Some fresh variables remain unconsumed, causing PlaceNotUsedError
-        """
-        from pecos.slr.gen_codes.guppy.ir import Comment, FunctionCall, VariableRef
-
-        # Define ExpressionStatement class for standalone function calls
-        class ExpressionStatement:
-            def __init__(self, expr):
-                self.expr = expr
-
-            def analyze(self, context):
-                self.expr.analyze(context)
-
-            def render(self, context):
-                return self.expr.render(context)
-
-        # General approach: find fresh variables that might be unused in conditional paths
-        fresh_variables_created = set()
-        fresh_variables_used_conditionally = set()
-        has_conditional_usage = False
-
-        def collect_fresh_variables(statements):
-            """Recursively collect all fresh variables created and used."""
-            for stmt in statements:
-                # Check if this is a Block and recurse into it
-                if hasattr(stmt, "statements"):
-                    collect_fresh_variables(stmt.statements)
-
-                # Find tuple assignments that create fresh variables
-                if hasattr(stmt, "targets") and len(stmt.targets) > 0:
-                    for target in stmt.targets:
-                        if isinstance(target, str) and "_fresh" in target:
-                            fresh_variables_created.add(target)
-
-                # Check for conditional statements (if/for) containing fresh variable usage
-                is_conditional = hasattr(stmt, "condition") or hasattr(stmt, "iterable")
-                has_body = hasattr(stmt, "body") and hasattr(stmt.body, "statements")
-                if is_conditional and has_body:  # IfStatement or ForStatement
-                    nonlocal has_conditional_usage
-                    has_conditional_usage = True
-                    # Look for fresh variable usage in conditional blocks
-                    self._find_fresh_usage_in_statements(
-                        stmt.body.statements,
-                        fresh_variables_used_conditionally,
-                    )
-
-        def find_procedural_functions_with_unused_fresh():
-            """Find procedural functions (return None) that might have unused fresh variables."""
-            if not (hasattr(self, "current_function_name") and self.current_function_name):
-                return False
-
-            # Check if this is a procedural function that might have the pattern
-            # Method 1: Check if already recorded in function_return_types
-            if (
-                hasattr(self, "function_return_types")
-                and self.function_return_types.get(self.current_function_name) == "None"
-            ):
-                return True
-
-            # Method 2: Check if the function body has no return statements (procedural)
-            # This is a heuristic for functions that don't explicitly return values
-            has_return_stmt = any(
-                hasattr(stmt, "value") and hasattr(stmt, "__class__") and "return" in str(type(stmt)).lower()
-                for stmt in body.statements
-            )
-
-            # Method 3: Use pattern matching - functions that end with calls to other functions
-            # but don't return their results are likely procedural
-            if not has_return_stmt and len(body.statements) > 0:
-                last_stmt = body.statements[-1]
-                if hasattr(last_stmt, "expr") and hasattr(last_stmt.expr, "func_name"):
-                    return True  # Likely procedural if ends with a function call
-
-            return False
-
-        collect_fresh_variables(body.statements)
-
-        is_procedural = find_procedural_functions_with_unused_fresh()
-
-        # If we have fresh variables created and conditional usage patterns,
-        # and this is a procedural function, add discard statements for unused fresh variables
-        if fresh_variables_created and has_conditional_usage and is_procedural:
-
-            # Find fresh variables that are likely unused in some execution paths
-            potentially_unused = fresh_variables_created - fresh_variables_used_conditionally
-
-            # Also check which fresh variables are used after conditionals (shouldn't be discarded)
-            fresh_variables_used_after_conditionals = set()
-            self._find_fresh_usage_in_statements(
-                body.statements,
-                fresh_variables_used_after_conditionals,
-            )
-
-            # Only discard variables that are not used after conditionals
-            safe_to_discard = potentially_unused - fresh_variables_used_after_conditionals
-
-            # Add discard statements before the last statement for potentially unused variables
-            last_stmt_idx = len(body.statements) - 1
-            insert_offset = 0
-
-            for fresh_var in sorted(safe_to_discard):  # Sort for consistent ordering
-                comment = Comment(
-                    f"# Discard {fresh_var} to avoid PlaceNotUsedError in conditional paths",
-                )
-                discard_call = FunctionCall(
-                    func_name="quantum.discard_array",
-                    args=[VariableRef(fresh_var)],
-                )
-                discard_stmt = ExpressionStatement(discard_call)
-
-                # Insert before the last statement
-                body.statements.insert(last_stmt_idx + insert_offset, comment)
-                body.statements.insert(last_stmt_idx + insert_offset + 1, discard_stmt)
-                insert_offset += 2
-
-    def _find_fresh_usage_in_statements(self, statements, used_set):
-        """Helper to find fresh variable usage in a list of statements."""
-        for stmt in statements:
-            if hasattr(stmt, "statements"):
-                self._find_fresh_usage_in_statements(stmt.statements, used_set)
-
-            # Look for function calls that use fresh variables as arguments
-            if hasattr(stmt, "expr") and hasattr(stmt.expr, "args"):
-                for arg in stmt.expr.args:
-                    if hasattr(arg, "name") and "_fresh" in arg.name:
-                        used_set.add(arg.name)
-
-            # Look for assignments that use fresh variables
-            if hasattr(stmt, "value") and hasattr(stmt.value, "args"):
-                for arg in stmt.value.args:
-                    if hasattr(arg, "name") and "_fresh" in arg.name:
-                        used_set.add(arg.name)
-
-    def _update_context_for_returned_variable(
-        self,
-        original_name: str,
-        fresh_name: str,
-    ) -> None:
-        """Update context to redirect variable lookups from original to fresh name."""
-        original_var = self.context.lookup_variable(original_name)
-        if original_var:
-            from pecos.slr.gen_codes.guppy.ir import ResourceState, VariableInfo
-
-            # Create new variable info for the fresh returned variable
-            new_var_info = VariableInfo(
-                name=fresh_name,
-                original_name=fresh_name,
-                var_type=original_var.var_type,
-                size=original_var.size,
-                is_array=original_var.is_array,
-                state=ResourceState.AVAILABLE,
-                is_unpacked=original_var.is_unpacked,
-                unpacked_names=(original_var.unpacked_names.copy() if original_var.unpacked_names else []),
-            )
-
-            # Add the fresh variable to context
-            self.context.add_variable(new_var_info)
-
-            # Add to refreshed arrays mapping for variable reference resolution
-            self.context.refreshed_arrays[original_name] = fresh_name
-
-            # Mark the original variable as consumed since it was moved to the returned variable
-            self.context.consumed_resources.add(original_name)
-
-    def _analyze_block_dependencies(self, block) -> dict[str, Any]:
-        """Analyze what variables a block depends on."""
-        dependencies = {
-            "reads": set(),  # Variables read
-            "writes": set(),  # Variables written
-            "quantum": set(),  # Quantum variables used
-            "classical": set(),  # Classical variables used
-        }
-
-        # Analyze operations in the block
-        if hasattr(block, "ops"):
-            for op in block.ops:
-                self._analyze_op_dependencies(op, dependencies, depth=0)
-
-        return dependencies
-
-    def _analyze_op_dependencies(
-        self,
-        op,
-        deps: dict[str, set],
-        depth: int = 0,
-    ) -> None:
-        """Analyze dependencies of a single operation."""
-        op_type = type(op).__name__
-
-        # Handle quantum gates
-        if hasattr(op, "qargs"):
-            for qarg in op.qargs:
-                # Handle tuple arguments (e.g., CX gates with (control, target) pairs)
-                if isinstance(qarg, tuple):
-                    for sub_qarg in qarg:
-                        if hasattr(sub_qarg, "reg") and hasattr(sub_qarg.reg, "sym"):
-                            var_name = sub_qarg.reg.sym
-                            deps["reads"].add(var_name)
-                            deps["quantum"].add(var_name)
-                        elif hasattr(sub_qarg, "sym"):
-                            var_name = sub_qarg.sym
-                            deps["reads"].add(var_name)
-                            deps["quantum"].add(var_name)
-                elif hasattr(qarg, "reg") and hasattr(qarg.reg, "sym"):
-                    var_name = qarg.reg.sym
-                    deps["reads"].add(var_name)
-                    deps["quantum"].add(var_name)
-                elif hasattr(qarg, "sym"):
-                    # Direct QReg reference
-                    var_name = qarg.sym
-                    deps["reads"].add(var_name)
-                    deps["quantum"].add(var_name)
-
-        # Handle measurements
-        if op_type == "Measure":
-            if hasattr(op, "qargs"):
-                for qarg in op.qargs:
-                    if hasattr(qarg, "reg") and hasattr(qarg.reg, "sym"):
-                        var_name = qarg.reg.sym
-                        deps["reads"].add(var_name)
-                        deps["quantum"].add(var_name)
-                    elif hasattr(qarg, "sym"):
-                        # Direct QReg reference
-                        var_name = qarg.sym
-                        deps["reads"].add(var_name)
-                        deps["quantum"].add(var_name)
-            if hasattr(op, "cout") and op.cout:
-                for cout in op.cout:
-                    if hasattr(cout, "reg") and hasattr(cout.reg, "sym"):
-                        var_name = cout.reg.sym
-                        deps["writes"].add(var_name)
-                        deps["classical"].add(var_name)
-                    elif hasattr(cout, "sym"):
-                        # Direct CReg reference
-                        var_name = cout.sym
-                        deps["writes"].add(var_name)
-                        deps["classical"].add(var_name)
-
-        # Handle SET operations
-        if op_type == "SET":
-            if hasattr(op, "left") and hasattr(op.left, "reg"):
-                var_name = op.left.reg.sym
-                deps["writes"].add(var_name)
-                deps["classical"].add(var_name)
-            if hasattr(op, "right"):
-                self._analyze_expression_deps(op.right, deps)
-
-        # Handle control flow
-        if op_type in ["If", "While", "For", "Repeat"]:
-            # Analyze condition
-            if hasattr(op, "condition"):
-                self._analyze_expression_deps(op.condition, deps)
-            # Analyze body operations
-            if hasattr(op, "ops"):
-                for sub_op in op.ops:
-                    self._analyze_op_dependencies(sub_op, deps, depth + 1)
-
-        # Handle nested blocks (but not too deep to avoid infinite recursion)
-        elif hasattr(op, "ops") and hasattr(op, "vars") and depth < 2:
-            # This is a block call - analyze it recursively but not too deep
-            for sub_op in op.ops:
-                self._analyze_op_dependencies(sub_op, deps, depth + 1)
-
-    def _analyze_expression_deps(self, expr, deps: dict[str, set]) -> None:
-        """Analyze dependencies in an expression."""
-        expr_type = type(expr).__name__
-
-        if expr_type == "Bit":
-            if hasattr(expr, "reg") and hasattr(expr.reg, "sym"):
-                var_name = expr.reg.sym
-                deps["reads"].add(var_name)
-                deps["classical"].add(var_name)
-        elif expr_type == "Qubit":
-            if hasattr(expr, "reg") and hasattr(expr.reg, "sym"):
-                var_name = expr.reg.sym
-                deps["reads"].add(var_name)
-                deps["quantum"].add(var_name)
-        elif hasattr(expr, "left") and hasattr(expr, "right"):
-            self._analyze_expression_deps(expr.left, deps)
-            self._analyze_expression_deps(expr.right, deps)
-        elif hasattr(expr, "value"):
-            self._analyze_expression_deps(expr.value, deps)
-
-    def _add_final_handling(self, block) -> None:
-        """Handle struct decomposition, results, and cleanup in the correct order."""
-        # First, decompose any structs that need cleanup
-        struct_decompositions = {}  # prefix -> list of decomposed variable names
-
-        for prefix, info in self.struct_info.items():
-            # Check if this struct has unconsumed quantum fields
-            has_unconsumed_quantum = False
-            for suffix, var_type, size in info["fields"]:
-                if var_type == "qubit":
-                    var_name = info["var_names"][suffix]
-                    if var_name not in self.consumed_arrays:
-                        has_unconsumed_quantum = True
-                        break
-
-            if has_unconsumed_quantum:
-                # Decompose the struct
-                qec_code_name = info.get("qec_code_name", prefix)
-                func_name = f"{qec_code_name}_decompose" if qec_code_name else f"{prefix}_decompose"
-
-                # Generate variable names for decomposed fields
-                decomposed_vars = []
-                for suffix, _, _ in sorted(info["fields"]):
-                    decomposed_vars.append(f"{prefix}_{suffix}_final")
-
-                # Create the decomposition call
-                targets = decomposed_vars
-                call = FunctionCall(
-                    func_name=func_name,
-                    args=[VariableRef(prefix)],
-                )
-
-                # Create assignment
-                target_tuple = TupleExpression(
-                    elements=[VariableRef(name) for name in targets],
-                )
-                stmt = Assignment(target=target_tuple, value=call)
-
-                self.current_block.statements.append(
-                    Comment(f"Decompose struct {prefix} for cleanup"),
-                )
-                self.current_block.statements.append(stmt)
-
-                # Store decomposition info
-                struct_decompositions[prefix] = list(
-                    zip(
-                        [f[0] for f in sorted(info["fields"])],  # suffixes
-                        decomposed_vars,
-                        [f[1] for f in sorted(info["fields"])],  # types
-                        [f[2] for f in sorted(info["fields"])],  # sizes
-                    ),
-                )
-
-        # Now add results, using decomposed variables where necessary
-        self._add_results_with_decomposition(block, struct_decompositions)
-
-        # Track what arrays have been cleaned up to avoid double-discard
-        cleaned_up_arrays = set()
-
-        # Finally, clean up quantum arrays
-        self._add_cleanup_with_decomposition(
-            block,
-            struct_decompositions,
-            cleaned_up_arrays,
-        )
-
-        # Also run the regular cleanup for non-struct arrays
-        self._add_cleanup(block, cleaned_up_arrays)
-
-    def _add_results_with_decomposition(self, block, struct_decompositions) -> None:
-        """Add result calls, using decomposed variables where necessary."""
-        if hasattr(block, "vars"):
-            for var in block.vars:
-                if type(var).__name__ == "CReg":
-                    var_name = var.sym
-
-                    # Check for renaming
-                    actual_name = var_name
-                    if var_name in self.plan.renamed_variables:
-                        actual_name = self.plan.renamed_variables[var_name]
-
-                    # Check if this variable is part of a decomposed struct
-                    value_ref = None
-                    for prefix, info in self.struct_info.items():
-                        if var_name in info["var_names"].values():
-                            # Find the field name for this variable
-                            for suffix, mapped_var in info["var_names"].items():
-                                if mapped_var == var_name:
-                                    # Check if struct was decomposed
-                                    if prefix in struct_decompositions:
-                                        # Find the decomposed variable
-                                        for (
-                                            field_suffix,
-                                            decomposed_var,
-                                            _,
-                                            _,
-                                        ) in struct_decompositions[prefix]:
-                                            if field_suffix == suffix:
-                                                value_ref = VariableRef(decomposed_var)
-                                                break
-                                    else:
-                                        # Struct not decomposed, use field access
-                                        value_ref = FieldAccess(
-                                            obj=VariableRef(prefix),
-                                            field=suffix,
-                                        )
-                                    break
-                            break
-
-                    if value_ref is None:
-                        # Check if this array was unpacked
-                        # Check both var_name (original) and actual_name (renamed)
-                        is_unpacked = var_name in self.plan.arrays_to_unpack or (
-                            hasattr(self, "unpacked_vars")
-                            and (var_name in self.unpacked_vars or actual_name in self.unpacked_vars)
-                        )
-
-                        if is_unpacked:
-                            # Array was unpacked - must reconstruct from elements for linearity
-                            element_names = None
-                            if hasattr(self, "unpacked_vars"):
-                                # Try original name first, then renamed name
-                                if var_name in self.unpacked_vars:
-                                    element_names = self.unpacked_vars[var_name]
-                                elif actual_name in self.unpacked_vars:
-                                    element_names = self.unpacked_vars[actual_name]
-
-                            if element_names:
-                                # Reconstruct the array and assign it back to the original variable
-                                reconstruction_expr = self._create_array_reconstruction(
-                                    element_names,
-                                )
-                                reconstruction_stmt = Assignment(
-                                    target=VariableRef(actual_name),
-                                    value=reconstruction_expr,
-                                )
-                                self.current_block.statements.append(
-                                    reconstruction_stmt,
-                                )
-                                value_ref = VariableRef(actual_name)
-                            else:
-                                # Fallback: use original array if unpacked_vars not available
-                                value_ref = VariableRef(actual_name)
-                        else:
-                            # Not unpacked, use direct variable reference
-                            value_ref = VariableRef(actual_name)
-
-                    # Add result call
-                    call = FunctionCall(
-                        func_name="result",
-                        args=[
-                            Literal(var.sym),  # Original name as label
-                            value_ref,  # Actual variable or decomposed field
-                        ],
-                    )
-
-                    # Create a wrapper that renders just the function call
-                    class ExpressionStatement(Statement):
-                        def __init__(self, expr):
-                            self.expr = expr
-
-                        def analyze(self, context):
-                            self.expr.analyze(context)
-
-                        def render(self, context):
-                            return self.expr.render(context)
-
-                    self.current_block.statements.append(ExpressionStatement(call))
-
-    def _add_cleanup_with_decomposition(
-        self,
-        block,
-        struct_decompositions,
-        cleaned_up_arrays,
-    ) -> None:
-        _ = block  # Currently not used
-        """Add cleanup for quantum arrays, using decomposed variables."""
-        # First handle decomposed struct fields
-        for prefix, fields in struct_decompositions.items():
-            self.current_block.statements.append(
-                Comment(f"Discard quantum fields from {prefix}"),
-            )
-            for suffix, decomposed_var, var_type, size in fields:
-                if var_type == "qubit" and decomposed_var not in cleaned_up_arrays:
-                    stmt = FunctionCall(
-                        func_name="quantum.discard_array",
-                        args=[VariableRef(decomposed_var)],
-                    )
-                    cleaned_up_arrays.add(decomposed_var)
-                    # Also track the original variable name to prevent double cleanup
-                    if prefix in self.struct_info:
-                        info = self.struct_info[prefix]
-                        if suffix in info["var_names"]:
-                            original_var = info["var_names"][suffix]
-                            cleaned_up_arrays.add(original_var)
-
-                    # Create expression statement wrapper
-                    class ExpressionStatement(Statement):
-                        def __init__(self, expr):
-                            self.expr = expr
-
-                        def analyze(self, context):
-                            self.expr.analyze(context)
-
-                        def render(self, context):
-                            return self.expr.render(context)
-
-                    self.current_block.statements.append(ExpressionStatement(stmt))
-
-        # Note: Non-struct arrays are handled in _add_cleanup, not here
-
-    def _add_cleanup(self, block, cleaned_up_arrays=None) -> None:
-        """Add cleanup for unconsumed qubits."""
-        if cleaned_up_arrays is None:
-            cleaned_up_arrays = set()
-        # Track consumed qubits during operation conversion
-        consumed = {}  # qreg_name -> set of indices
-
-        # Analyze operations to find consumed qubits
-        if hasattr(block, "ops"):
-            for op in block.ops:
-                self._track_consumed_qubits(op, consumed)
-
-        # First, check if we have structs that need cleanup
-        struct_cleanup_done = set()
-        for prefix, info in self.struct_info.items():
-            # Check if any quantum arrays in this struct need cleanup
-            needs_cleanup = False
-            for suffix, var_type, size in info["fields"]:
-                if var_type == "qubit":
-                    var_name = info["var_names"][suffix]
-                    if var_name not in self.consumed_arrays:
-                        needs_cleanup = True
-                        break
-
-            if needs_cleanup and prefix not in struct_cleanup_done:
-                # We're at the end of main, after results.
-                # We can't access struct fields directly after consuming the struct,
-                # so we'll just leave quantum arrays in structs for now.
-                # The HUGR compiler will need to handle this pattern.
-
-                # Add a comment noting this limitation
-                self.current_block.statements.append(
-                    Comment(
-                        f"Note: struct {prefix} contains unconsumed quantum arrays",
-                    ),
-                )
-
-                struct_cleanup_done.add(prefix)
-                # Mark arrays as handled
-                for suffix, var_type, size in info["fields"]:
-                    if var_type == "qubit":
-                        var_name = info["var_names"][suffix]
-                        self.consumed_arrays.add(var_name)
-
-        # First handle fresh variables from function returns
-        if hasattr(self, "fresh_variables_to_track"):
-            for fresh_name, info in self.fresh_variables_to_track.items():
-                if info["type"] == "quantum_array" and not info.get("used", False):
-                    # This fresh variable was not used, add cleanup
-                    # Check if it was already cleaned up (e.g., by being measured)
-                    original_name = info["original"]
-                    was_consumed = (hasattr(self, "consumed_arrays") and original_name in self.consumed_arrays) or (
-                        hasattr(self, "consumed_resources") and original_name in self.consumed_resources
-                    )
-
-                    if not was_consumed and fresh_name not in cleaned_up_arrays:
-                        self.current_block.statements.append(
-                            Comment(f"Discard unused fresh variable {fresh_name}"),
-                        )
-                        # Need to check if this is an array or needs special handling
-                        # For now, assume it's a quantum array that needs discard_array
-                        stmt = FunctionCall(
-                            func_name="quantum.discard_array",
-                            args=[VariableRef(fresh_name)],
-                        )
-
-                        # Create expression statement wrapper
-                        class ExpressionStatement(Statement):
-                            def __init__(self, expr):
-                                self.expr = expr
-
-                            def analyze(self, context):
-                                self.expr.analyze(context)
-
-                            def render(self, context):
-                                return self.expr.render(context)
-
-                        self.current_block.statements.append(ExpressionStatement(stmt))
-                        cleaned_up_arrays.add(fresh_name)
-
-        # Check each quantum register not in structs
-        if hasattr(block, "vars"):
-
-            for var in block.vars:
-                if type(var).__name__ == "QReg":
-                    var_name = var.sym
-
-                    # Skip if this array is part of a struct
-                    in_struct = False
-                    for prefix, info in self.struct_info.items():
-                        if var_name in info["var_names"].values():
-                            in_struct = True
-                            break
-
-                    if in_struct:
-                        continue
-                    # Check for renaming
-                    if var_name in self.plan.renamed_variables:
-                        var_name = self.plan.renamed_variables[var_name]
-
-                    consumed_indices = consumed.get(var.sym, set())
-
-                    # Check if this array was consumed by an @owned function or measurement
-                    was_consumed_by_function = hasattr(self, "consumed_arrays") and var.sym in self.consumed_arrays
-
-                    was_consumed_by_measurement = (
-                        hasattr(self, "consumed_resources") and var.sym in self.consumed_resources
-                    )
-                    was_dynamically_allocated = (
-                        hasattr(self, "dynamic_allocations") and var.sym in self.dynamic_allocations
-                    )
-
-                    # Handle partially consumed arrays
-                    # BUT: Skip if the whole array was consumed by an @owned function
-                    if len(consumed_indices) > 0 and len(consumed_indices) < var.size and not was_consumed_by_function:
-                        # Array was partially consumed - need to discard entire array
-                        if var_name not in cleaned_up_arrays:
-                            self.current_block.statements.append(
-                                Comment(f"Discard {var.sym}"),
-                            )
-                            stmt = FunctionCall(
-                                func_name="quantum.discard_array",
-                                args=[VariableRef(var_name)],
-                            )
-
-                            # Create expression statement wrapper
-                            class ExpressionStatement(Statement):
-                                def __init__(self, expr):
-                                    self.expr = expr
-
-                                def analyze(self, context):
-                                    self.expr.analyze(context)
-
-                                def render(self, context):
-                                    return self.expr.render(context)
-
-                            self.current_block.statements.append(
-                                ExpressionStatement(stmt),
-                            )
-                            cleaned_up_arrays.add(var_name)
-                    # Only discard arrays that weren't consumed by @owned functions or measurements
-                    # UNLESS they have explicitly reset qubits (which need cleanup)
-                    elif True:
-                        # Check if this array has explicitly reset qubits (from Prep operations)
-                        # Even if consumed by measurement, explicitly reset qubits need cleanup
-                        has_explicitly_reset = (
-                            hasattr(self, "explicitly_reset_qubits")
-                            and var.sym in self.explicitly_reset_qubits
-                            and len(self.explicitly_reset_qubits[var.sym]) > 0
-                        )
-
-                        if not was_consumed_by_function and (not was_consumed_by_measurement or has_explicitly_reset):
-                            if was_dynamically_allocated:
-                                # For dynamically allocated arrays, discard individual
-                                # qubits that weren't measured
-                                self.current_block.statements.append(
-                                    Comment(f"Discard dynamically allocated {var.sym}"),
-                                )
-
-                                # Check which individual qubits were allocated and not consumed
-                                if hasattr(self, "allocated_ancillas"):
-                                    # Track which variables we've already discarded to avoid duplicates
-                                    discarded_vars = set()
-
-                                    # Discard each allocated ancilla that belongs to this qreg
-                                    # We need to check all allocated ancillas that start with the qreg name
-                                    for ancilla_var in list(self.allocated_ancillas):
-                                        # Check if this ancilla belongs to the current qreg
-                                        # It should start with the qreg name followed by underscore
-                                        if ancilla_var.startswith(
-                                            (f"{var.sym}_", f"_{var.sym}_"),
-                                        ):
-                                            # Apply variable remapping if exists (for Prep operations)
-                                            var_to_discard = self.variable_remapping.get(
-                                                ancilla_var,
-                                                ancilla_var,
-                                            )
-
-                                            # Skip if we've already discarded this variable
-                                            if var_to_discard in discarded_vars:
-                                                continue
-                                            discarded_vars.add(var_to_discard)
-
-                                            discard_stmt = FunctionCall(
-                                                func_name="quantum.discard",
-                                                args=[VariableRef(var_to_discard)],
-                                            )
-
-                                            # Create expression statement wrapper
-                                            class ExpressionStatement(Statement):
-                                                def __init__(self, expr):
-                                                    self.expr = expr
-
-                                                def analyze(self, context):
-                                                    self.expr.analyze(context)
-
-                                                def render(self, context):
-                                                    return self.expr.render(context)
-
-                                            self.current_block.statements.append(
-                                                ExpressionStatement(discard_stmt),
-                                            )
-                            else:
-                                # Regular pre-allocated array
-
-                                # Skip if already consumed by a function call
-                                # Also check if the remapped name was consumed
-                                remapped_consumed = False
-                                if hasattr(self, "array_remapping") and var_name in self.array_remapping:
-                                    remapped_name = self.array_remapping[var_name]
-                                    if hasattr(self, "consumed_arrays") and remapped_name in self.consumed_arrays:
-                                        remapped_consumed = True
-
-                                # Check if array has explicitly reset qubits (from Prep operations)
-                                # These need cleanup even if consumed by measurement
-                                has_explicitly_reset = (
-                                    hasattr(self, "explicitly_reset_qubits")
-                                    and var.sym in self.explicitly_reset_qubits
-                                    and len(self.explicitly_reset_qubits[var.sym]) > 0
-                                )
-
-                                # Check if array was consumed by an @owned function call or by measurements
-                                array_consumed = (
-                                    hasattr(self, "consumed_arrays")
-                                    and (var.sym in self.consumed_arrays or var_name in self.consumed_arrays)
-                                ) or (
-                                    hasattr(self, "consumed_resources")
-                                    and (var.sym in self.consumed_resources or var_name in self.consumed_resources)
-                                )
-
-                                # Also check if this is a reconstructed array that was passed to a function
-                                is_reconstructed = (
-                                    hasattr(self, "reconstructed_arrays") and var_name in self.reconstructed_arrays
-                                )
-
-                                # Allow cleanup if:
-                                # 1. Array not already cleaned up
-                                # 2. Either not consumed OR has explicitly reset qubits
-                                # 3. Remapped version not consumed
-                                # 4. Not a reconstructed array
-                                if (
-                                    var_name not in cleaned_up_arrays
-                                    and (not array_consumed or has_explicitly_reset)
-                                    and not remapped_consumed
-                                    and not is_reconstructed
-                                ):
-                                    # Check if this array has been unpacked or remapped
-                                    # If so, we can't discard the original name
-                                    if hasattr(self, "unpacked_vars") and var_name in self.unpacked_vars:
-                                        # Array was unpacked - check if it has explicitly reset qubits
-                                        explicitly_reset_indices = set()
-                                        if (
-                                            hasattr(self, "explicitly_reset_qubits")
-                                            and var_name in self.explicitly_reset_qubits
-                                        ):
-                                            explicitly_reset_indices = self.explicitly_reset_qubits[var_name]
-
-                                        if explicitly_reset_indices:
-                                            # Check if we already did inline reconstruction
-                                            # If so, skip cleanup reconstruction to avoid AlreadyUsedError
-                                            skip_cleanup_reconstruction = (
-                                                hasattr(
-                                                    self,
-                                                    "inline_reconstructed_arrays",
-                                                )
-                                                and var_name in self.inline_reconstructed_arrays
-                                            )
-
-                                            if not skip_cleanup_reconstruction:
-                                                # Array has fresh qubits from Prep - reconstruct and discard
-                                                comment_text = (
-                                                    f"Reconstruct {var.sym} from unpacked "
-                                                    f"elements (has fresh qubits)"
-                                                )
-                                                self.current_block.statements.append(
-                                                    Comment(comment_text),
-                                                )
-
-                                                # Get unpacked element names (it's a list, not a dict)
-                                                element_names = self.unpacked_vars[var_name]
-
-                                                # Apply variable remapping to get the latest names
-                                                remapped_element_names = [
-                                                    self.variable_remapping.get(
-                                                        elem,
-                                                        elem,
-                                                    )
-                                                    for elem in element_names
-                                                ]
-
-                                                # Reconstruct array: var = array(elem1, elem2, ...)
-                                                array_elements = [VariableRef(elem) for elem in remapped_element_names]
-                                                array_constructor = FunctionCall(
-                                                    func_name="array",
-                                                    args=array_elements,
-                                                )
-                                                reconstruct_stmt = Assignment(
-                                                    target=VariableRef(var_name),
-                                                    value=array_constructor,
-                                                )
-                                                self.current_block.statements.append(
-                                                    reconstruct_stmt,
-                                                )
-
-                                            # Now discard the reconstructed array
-                                            self.current_block.statements.append(
-                                                Comment(
-                                                    f"Discard reconstructed {var.sym}",
-                                                ),
-                                            )
-                                            array_ref = VariableRef(var_name)
-                                            stmt = FunctionCall(
-                                                func_name="quantum.discard_array",
-                                                args=[array_ref],
-                                            )
-
-                                            # Create expression statement wrapper
-                                            class ExpressionStatement(Statement):
-                                                def __init__(self, expr):
-                                                    self.expr = expr
-
-                                                def analyze(self, context):
-                                                    self.expr.analyze(context)
-
-                                                def render(self, context):
-                                                    return self.expr.render(context)
-
-                                            self.current_block.statements.append(
-                                                ExpressionStatement(stmt),
-                                            )
-                                            cleaned_up_arrays.add(var_name)
-                                            # Skip the remapping/normal discard code below
-                                            continue
-                                        # Array was unpacked and fully consumed - skip discard
-                                        self.current_block.statements.append(
-                                            Comment(
-                                                f"Skip discard {var.sym} - already unpacked and consumed",
-                                            ),
-                                        )
-                                        continue
-                                    if hasattr(self, "array_remapping") and var_name in self.array_remapping:
-                                        # Array was remapped - use the new name
-                                        remapped_name = self.array_remapping[var_name]
-                                        self.current_block.statements.append(
-                                            Comment(
-                                                f"Discard {var.sym} (remapped to {remapped_name})",
-                                            ),
-                                        )
-                                        array_ref = VariableRef(remapped_name)
-                                    else:
-                                        # Normal case - use original name
-                                        self.current_block.statements.append(
-                                            Comment(f"Discard {var.sym}"),
-                                        )
-                                        array_ref = VariableRef(var_name)
-
-                                    stmt = FunctionCall(
-                                        func_name="quantum.discard_array",
-                                        args=[array_ref],
-                                    )
-
-                                    # Create expression statement wrapper
-                                    class ExpressionStatement(Statement):
-                                        def __init__(self, expr):
-                                            self.expr = expr
-
-                                        def analyze(self, context):
-                                            self.expr.analyze(context)
-
-                                        def render(self, context):
-                                            return self.expr.render(context)
-
-                                    self.current_block.statements.append(
-                                        ExpressionStatement(stmt),
-                                    )
-                                    cleaned_up_arrays.add(var_name)
-
-    def _check_has_element_operations(self, block, var_name: str) -> bool:
-        """Check if a block has element-wise operations on a variable.
-
-        This is used to determine if we should use @owned for array parameters.
-        Element-wise operations (like reset on individual elements) don't work
-        with @owned arrays in Guppy.
-        """
-        if not hasattr(block, "ops"):
-            return False
-
-        for op in block.ops:
-            op_type = type(op).__name__
-
-            # Check for Prep operations on the whole array
-            if op_type == "Prep" and hasattr(op, "qargs"):
-                for qarg in op.qargs:
-                    if hasattr(qarg, "sym") and qarg.sym == var_name:
-                        # Prep on the whole array - this needs element access
-                        return True
-
-            # Check for operations on individual elements
-            if hasattr(op, "qargs"):
-                for qarg in op.qargs:
-                    if (
-                        hasattr(qarg, "reg")
-                        and hasattr(qarg.reg, "sym")
-                        and qarg.reg.sym == var_name
-                        and hasattr(qarg, "index")
-                        and op_type in ["Prep", "Measure"]
-                    ):
-                        return True
-
-            # Recursively check nested blocks
-            if hasattr(op, "ops") and self._check_has_element_operations(op, var_name):
-                return True
-
-        return False
-
-    def _track_consumed_qubits(self, op, consumed: dict[str, set[int]]) -> None:
-        """Track which qubits are consumed by an operation or block.
-
-        Also tracks explicit Prep (reset) operations to distinguish them from
-        automatic post-measurement replacements.
-        """
-        op_type = type(op).__name__
-
-        # Handle Block types - recurse into their operations
-        if hasattr(op, "ops") and op_type not in ["Measure", "If", "Else", "While"]:
-            # This is a custom Block - analyze its operations
-            for nested_op in op.ops:
-                self._track_consumed_qubits(nested_op, consumed)
-            return
-
-        # Track explicit Prep operations - these are semantic resets that should be returned
-        if op_type == "Prep" and hasattr(op, "qargs") and op.qargs:
-            for qarg in op.qargs:
-                # Handle full array reset
-                if hasattr(qarg, "sym") and hasattr(qarg, "size"):
-                    qreg_name = qarg.sym
-                    if qreg_name not in self.explicitly_reset_qubits:
-                        self.explicitly_reset_qubits[qreg_name] = set()
-                    # Track all indices as explicitly reset
-                    for i in range(qarg.size):
-                        self.explicitly_reset_qubits[qreg_name].add(i)
-                # Handle individual qubit reset
-                elif hasattr(qarg, "reg") and hasattr(qarg.reg, "sym"):
-                    qreg_name = qarg.reg.sym
-                    if qreg_name not in self.explicitly_reset_qubits:
-                        self.explicitly_reset_qubits[qreg_name] = set()
-
-                    if hasattr(qarg, "index"):
-                        self.explicitly_reset_qubits[qreg_name].add(qarg.index)
-
-        if op_type == "Measure" and hasattr(op, "qargs") and op.qargs:
-            for qarg in op.qargs:
-                # Handle full array measurement
-                if hasattr(qarg, "sym") and hasattr(qarg, "size"):
-                    qreg_name = qarg.sym
-                    if qreg_name not in consumed:
-                        consumed[qreg_name] = set()
-                    # Mark all qubits as consumed
-                    indices = set(range(qarg.size))
-                    for i in indices:
-                        consumed[qreg_name].add(i)
-                    # Track in scope manager
-                    self.scope_manager.track_resource_usage(
-                        qreg_name,
-                        indices,
-                        consumed=True,
-                    )
-                # Handle individual qubit measurement
-                elif hasattr(qarg, "reg") and hasattr(qarg.reg, "sym"):
-                    qreg_name = qarg.reg.sym
-                    if qreg_name not in consumed:
-                        consumed[qreg_name] = set()
-
-                    if hasattr(qarg, "index"):
-                        consumed[qreg_name].add(qarg.index)
-                        # Track in scope manager
-                        self.scope_manager.track_resource_usage(
-                            qreg_name,
-                            {qarg.index},
-                            consumed=True,
-                        )
-
-        # Don't recurse into nested blocks that are separate function calls
-        # They handle their own consumption and return fresh qubits
-        # Only recurse into inline blocks (like If/Else)
-        if hasattr(op, "ops") and op_type in ["If", "Else", "While"]:
-            for nested_op in op.ops:
-                self._track_consumed_qubits(nested_op, consumed)
-
-        # Check else blocks
-        if op_type == "If" and hasattr(op, "else_block") and op.else_block and hasattr(op.else_block, "ops"):
-            for nested_op in op.else_block.ops:
-                self._track_consumed_qubits(nested_op, consumed)
-
-    def _array_needs_full_allocation(self, array_name: str, block) -> bool:
-        """Check if an array needs full allocation due to full array operations."""
-        if not hasattr(block, "ops"):
-            return False
-
-        for op in block.ops:
-            if self._operation_uses_full_array(op, array_name):
-                return True
-
-            # Check nested operations
-            if hasattr(op, "ops"):
-                for nested_op in op.ops:
-                    if self._operation_uses_full_array(nested_op, array_name):
-                        return True
-
-            # Check else blocks
-            if hasattr(op, "else_block") and op.else_block and hasattr(op.else_block, "ops"):
-                for nested_op in op.else_block.ops:
-                    if self._operation_uses_full_array(nested_op, array_name):
-                        return True
-
-        return False
-
-    def _operation_uses_full_array(self, op, array_name: str) -> bool:
-        """Check if an operation uses a full array (e.g., Measure(q) > c)."""
-        if hasattr(op, "qargs") and len(op.qargs) == 1:
-            qarg = op.qargs[0]
-            # Check for full array reference (has sym and size but no index)
-            if (
-                hasattr(qarg, "sym")
-                and qarg.sym == array_name
-                and hasattr(qarg, "size")
-                and qarg.size > 1
-                and not hasattr(qarg, "index")
-            ):
-                return True
-        return False
-
-    def _add_results(self, block) -> None:
-        """Add result() calls for classical registers."""
-        # Debug: Uncomment to see unpacked_vars state
-        if hasattr(block, "vars"):
-            for var in block.vars:
-                if type(var).__name__ == "CReg":
-                    var_name = var.sym
-
-                    # Check for renaming
-                    actual_name = var_name
-                    if var_name in self.plan.renamed_variables:
-                        actual_name = self.plan.renamed_variables[var_name]
-
-                    # Check if this variable is part of a struct
-                    value_ref = None
-                    for prefix, info in self.struct_info.items():
-                        if var_name in info["var_names"].values():
-                            # Find the field name for this variable
-                            for suffix, mapped_var in info["var_names"].items():
-                                if mapped_var == var_name:
-                                    # Access through struct field
-                                    value_ref = FieldAccess(
-                                        obj=VariableRef(prefix),
-                                        field=suffix,
-                                    )
-                                    break
-                            break
-
-                    if value_ref is None:
-                        # Check if this array was unpacked
-                        # Check both var_name (original) and actual_name (renamed)
-                        is_unpacked = var_name in self.plan.arrays_to_unpack or (
-                            hasattr(self, "unpacked_vars")
-                            and (var_name in self.unpacked_vars or actual_name in self.unpacked_vars)
-                        )
-
-                        if is_unpacked:
-                            # Array was unpacked - must reconstruct from elements for linearity
-                            element_names = None
-                            if hasattr(self, "unpacked_vars"):
-                                # Try original name first, then renamed name
-                                if var_name in self.unpacked_vars:
-                                    element_names = self.unpacked_vars[var_name]
-                                elif actual_name in self.unpacked_vars:
-                                    element_names = self.unpacked_vars[actual_name]
-
-                            if element_names:
-                                value_ref = self._create_array_reconstruction(
-                                    element_names,
-                                )
-                            else:
-                                # Fallback: use original array if unpacked_vars not available
-                                value_ref = VariableRef(actual_name)
-                        else:
-                            # Not unpacked, use direct variable reference
-                            value_ref = VariableRef(actual_name)
-
-                    # Add result call
-                    call = FunctionCall(
-                        func_name="result",
-                        args=[
-                            Literal(var.sym),  # Original name as label
-                            value_ref,  # Actual variable or struct field
-                        ],
-                    )
-
-                    # Create a wrapper that renders just the function call
-                    class ExpressionStatement(Statement):
-                        def __init__(self, expr):
-                            self.expr = expr
-
-                        def analyze(self, context):
-                            self.expr.analyze(context)
-
-                        def render(self, context):
-                            return self.expr.render(context)
-
-                    self.current_block.statements.append(ExpressionStatement(call))
-
-    def _detect_struct_patterns(self, block: SLRBlock) -> None:
-        """Detect variables that should be grouped into structs.
-
-        Looking for patterns where multiple variables share a common prefix
-        (e.g., x_d, x_a, x_c all belong to quantum code 'x').
-        """
-        # First, try to determine the quantum code class from variable metadata
-        qec_code_name = None
-        qec_instance_mapping = {}  # Maps instance name -> class name
-
-        # Check if block.vars has source class information
-        if hasattr(block, "vars") and hasattr(block.vars, "var_source_classes"):
-            # Get the source class from the metadata
-            for var_name, source_class in block.vars.var_source_classes.items():
-                # Extract the prefix from the variable name
-                if "_" in var_name:
-                    prefix = var_name.split("_")[0]
-                    if prefix not in qec_instance_mapping:
-                        qec_instance_mapping[prefix] = source_class.lower()
-                        if not qec_code_name:
-                            qec_code_name = source_class.lower()
-
-        # If no QEC class found in vars, fall back to searching operations
-        if not qec_code_name:
-            # Helper function to recursively search for QEC code
-            def find_qec_code_in_block(op, depth=0, max_depth=5):
-                if depth > max_depth:
-                    return None
-
-                results = []
-
-                # Check if this op has QEC module info
-                if hasattr(op, "__class__") and hasattr(op.__class__, "__module__"):
-                    module = op.__class__.__module__
-                    # Extract QEC code name from module path like
-                    # 'pecos.qeclib.steane.preps.pauli_states'
-                    if "pecos.qeclib." in module:
-                        parts = module.split(".")
-                        if len(parts) > 2 and "qeclib" in parts:
-                            qec_idx = parts.index("qeclib")
-                            if qec_idx + 1 < len(parts):
-                                candidate = parts[qec_idx + 1]
-                                # Skip generic names like 'qubit'
-                                if candidate not in ["qubit", "bit", "ops", "gates"]:
-                                    results.append(candidate)
-
-                # Check nested operations
-                if hasattr(op, "ops"):
-                    for nested_op in op.ops:
-                        result = find_qec_code_in_block(nested_op, depth + 1, max_depth)
-                        if result:
-                            results.append(result)
-
-                # Return the first non-generic result
-                for r in results:
-                    if r not in ["qubit", "bit", "ops", "gates"]:
-                        return r
-
-                return results[0] if results else None
-
-            # Try to find the QEC code class from the operations
-            if hasattr(block, "ops"):
-                for op in block.ops:
-                    qec_code_name = find_qec_code_in_block(op)
-                    if qec_code_name:
-                        break
-
-        # Collect all variables
-        all_vars = {}
-        if hasattr(block, "vars"):
-            for var in block.vars:
-                if hasattr(var, "sym"):
-                    var_name = var.sym
-                    all_vars[var_name] = var
-
-        # Also check context variables
-        for var_name, var_info in self.context.variables.items():
-            if var_name not in all_vars:
-                all_vars[var_name] = var_info
-
-        # Group by prefix
-        prefix_groups = {}
-        for var_name, var in all_vars.items():
-            if "_" in var_name:
-                prefix = var_name.split("_")[0]
-                suffix = "_".join(var_name.split("_")[1:])
-
-                if prefix not in prefix_groups:
-                    prefix_groups[prefix] = []
-
-                # Determine type and size
-                size = var.size if hasattr(var, "size") else 1
-
-                # Determine if quantum or classical
-                is_quantum = True
-                if hasattr(var, "is_quantum"):
-                    is_quantum = var.is_quantum
-                elif type(var).__name__ == "CReg":
-                    is_quantum = False
-                elif hasattr(var, "resource_type"):
-                    is_quantum = var.resource_type == ResourceState.QUANTUM
-
-                var_type = "qubit" if is_quantum else "bool"
-
-                # Check if this is an ancilla qubit that should be kept separate
-                is_ancilla = False
-                if var_type == "qubit" and hasattr(self, "qubit_usage_stats"):
-                    stats = self.qubit_usage_stats.get(var_name)
-                    if stats:
-                        role = stats.classify_role()
-                        if role == QubitRole.ANCILLA:
-                            is_ancilla = True
-                            # Store this for later use
-                            if not hasattr(self, "ancilla_qubits"):
-                                self.ancilla_qubits = set()
-                            self.ancilla_qubits.add(var_name)
-
-                if not is_ancilla:
-                    prefix_groups[prefix].append((suffix, var_type, size, var_name))
-
-        # Create struct info for groups with multiple related variables
-        # BUT avoid structs with too many fields due to guppylang limitations
-        # Setting to 5 to be very conservative - complex QEC codes need individual array handling
-        max_struct_fields = 5  # Limit to avoid guppylang linearity issues
-
-        for prefix, vars_list in prefix_groups.items():
-            if len(vars_list) >= 2:
-                # Check if this looks like a quantum code pattern
-                has_quantum = any(var[1] == "qubit" for var in vars_list)
-
-                # Skip struct creation if too many fields (causes guppylang issues)
-                if len(vars_list) > max_struct_fields:
-                    msg = (
-                        f"# Skipping struct creation for '{prefix}' with "
-                        f"{len(vars_list)} fields (exceeds limit of {max_struct_fields})"
-                    )
-                    print(msg)
-                    continue
-
-                if has_quantum:
-                    # Use QEC code name for struct if available, otherwise use prefix
-                    struct_base_name = qec_code_name if qec_code_name else prefix
-
-                    self.struct_info[prefix] = {
-                        "fields": [(v[0], v[1], v[2]) for v in vars_list],
-                        "struct_name": f"{struct_base_name}_struct",
-                        "var_names": {v[0]: v[3] for v in vars_list},  # suffix -> full var name
-                        "qec_code_name": qec_code_name,  # Store for function naming
-                        "ancilla_vars": getattr(
-                            self,
-                            "ancilla_qubits",
-                            set(),
-                        ),  # Track which vars were excluded
-                    }
-
-    def _generate_struct_definitions(self) -> list[str]:
-        """Generate Guppy struct definitions."""
-        lines = []
-
-        for prefix, info in sorted(self.struct_info.items()):
-            struct_name = info["struct_name"]
-
-            # Generate struct
-            lines.append("@guppy.struct")
-            lines.append("@no_type_check")
-            lines.append(f"class {struct_name}:")
-
-            # Add fields sorted by suffix
-            for suffix, var_type, size in sorted(info["fields"]):
-                field_type = f"array[{var_type}, {size}]" if size > 1 else var_type
-                lines.append(f"    {suffix}: {field_type}")
-
-            lines.append("")  # Empty line after struct
-
-        return lines
-
-    def _generate_struct_decompose_function(
-        self,
-        prefix: str,
-        info: dict,
-    ) -> Function | None:
-        """Generate a decompose function for a struct."""
-        struct_name = info["struct_name"]
-        qec_code_name = info.get("qec_code_name", prefix)
-        func_name = f"{qec_code_name}_decompose" if qec_code_name else f"{prefix}_decompose"
-
-        # Build return type - tuple of all fields
-        return_types = []
-        field_names = []
-        for suffix, var_type, size in sorted(info["fields"]):
-            field_names.append(suffix)
-            return_types.append(
-                f"array[{var_type}, {size}]" if size > 1 else var_type,
-            )
-
-        return_type = f"tuple[{', '.join(return_types)}]"
-
-        # Create function body
-        body = Block()
-
-        # The key to avoiding AlreadyUsedError: return all fields in a single expression
-        # This works because guppylang handles the struct consumption atomically
-        field_refs = [FieldAccess(obj=VariableRef(prefix), field=suffix) for suffix in field_names]
-
-        # Return all fields directly in one statement
-        return_stmt = ReturnStatement(value=TupleExpression(elements=field_refs))
-        body.statements.append(return_stmt)
-
-        return Function(
-            name=func_name,
-            params=[(prefix, f"{struct_name} @owned")],
-            return_type=return_type,
-            body=body,
-            decorators=["guppy", "no_type_check"],
-        )
-
-    def _generate_struct_discard_function(
-        self,
-        prefix: str,
-        info: dict,
-    ) -> Function | None:
-        """Generate a discard function for a struct."""
-        # Check if struct has quantum fields
-        has_quantum = any(field[1] == "qubit" for field in info["fields"])
-        if not has_quantum:
-            return None
-
-        struct_name = info["struct_name"]
-        qec_code_name = info.get("qec_code_name", prefix)
-        func_name = f"{qec_code_name}_discard" if qec_code_name else f"{prefix}_discard"
-
-        # Create function body
-        body = Block()
-
-        # We need to handle discard differently to avoid AlreadyUsedError
-        # First decompose the struct, then discard quantum fields
-
-        # Build list of field names for decomposition
-        field_names = [suffix for suffix, _, _ in sorted(info["fields"])]
-
-        # Call decompose to get all fields
-        decompose_func_name = f"{qec_code_name}_decompose" if qec_code_name else f"{prefix}_decompose"
-        decompose_call = FunctionCall(
-            func_name=decompose_func_name,
-            args=[VariableRef(prefix)],
-        )
-
-        # Create variables to hold decomposed fields
-        field_vars = [f"_{suffix}" if suffix == prefix else suffix for suffix in field_names]
-
-        # Define TupleAssignment locally
-        class TupleAssignment(Statement):
-            def __init__(self, targets, value):
-                self.targets = targets
-                self.value = value
-
-            def analyze(self, context):
-                self.value.analyze(context)
-
-            def render(self, context):
-                targets_str = ", ".join(self.targets)
-                value_lines = self.value.render(context)
-                # FunctionCall render returns a list with one string
-                value_str = value_lines[0] if value_lines else ""
-                return [f"{targets_str} = {value_str}"]
-
-        decompose_stmt = TupleAssignment(
-            targets=field_vars,
-            value=decompose_call,
-        )
-        body.statements.append(decompose_stmt)
-
-        # Now discard quantum fields
-        for i, (suffix, var_type, size) in enumerate(sorted(info["fields"])):
-            if var_type == "qubit":
-                field_var = field_vars[i]
-                stmt = FunctionCall(
-                    func_name="quantum.discard_array",
-                    args=[VariableRef(field_var)],
-                )
-
-                # Create expression statement wrapper
-                class ExpressionStatement(Statement):
-                    def __init__(self, expr):
-                        self.expr = expr
-
-                    def analyze(self, context):
-                        self.expr.analyze(context)
-
-                    def render(self, context):
-                        return self.expr.render(context)
-
-                body.statements.append(ExpressionStatement(stmt))
-
-        return Function(
-            name=func_name,
-            params=[(prefix, f"{struct_name} @owned")],
-            return_type="None",
-            body=body,
-            decorators=["guppy", "no_type_check"],
-        )
-
-    def _add_struct_initialization(
-        self,
-        prefix: str,
-        info: dict,
-        block: SLRBlock,
-    ) -> None:
-        """Add struct initialization to current block."""
-        struct_name = info["struct_name"]
-
-        # Create the struct instance
-        # For now, initialize fields individually then create struct
-        # TODO: Could be optimized to initialize struct directly
-
-        # First, declare the individual arrays
-        for suffix, var_type, size in info["fields"]:
-            var_name = info["var_names"][suffix]
-            # Find the original variable
-            for var in block.vars:
-                if hasattr(var, "sym") and var.sym == var_name:
-                    self._add_variable_declaration(var)
-                    break
-
-        # Then create struct instance
-        field_refs = []
-        for suffix, _, _ in sorted(info["fields"]):
-            var_name = info["var_names"][suffix]
-            field_refs.append(VariableRef(var_name))
-
-        # Create struct construction expression
-        struct_expr = self._create_struct_construction(
-            struct_name,
-            [f[0] for f in sorted(info["fields"])],
-            field_refs,
-        )
-
-        # Add assignment: prefix = struct_name(field1=var1, field2=var2, ...)
-        stmt = Assignment(
-            target=VariableRef(prefix),
-            value=struct_expr,
-        )
-        self.current_block.statements.append(stmt)
-
-        # Update context to track struct variable
-        self.context.add_variable(
-            VariableInfo(
-                name=prefix,
-                original_name=prefix,
-                var_type=struct_name,
-                is_struct=True,
-                struct_info=info,
-            ),
-        )
-
-        # Mark the individual arrays as part of the struct so operations use struct fields
-        for suffix, var_type, size in info["fields"]:
-            var_name = info["var_names"][suffix]
-            var_info = self.context.lookup_variable(var_name)
-            if var_info:
-                var_info.is_struct_field = True
-                var_info.struct_name = prefix
-                var_info.field_name = suffix
-
-    def _restore_array_sizes_for_block_call(self, block) -> None:
-        """Restore array sizes before a function call in a loop.
-
-        When a function returns a smaller array than it receives (e.g., consuming qubits),
-        and that result is used in a loop to call the same function again, we need to
-        restore the array size by allocating fresh qubits before the next call.
-
-        This implements the user's guidance: "We could prepare them right before we need them"
-        """
-
-        # Check if this is a block that will become a function call
-        if not hasattr(block, "ops") or not hasattr(block, "vars"):
-            return
-
-        # Analyze the block to get array size information
-        from pecos.slr.gen_codes.guppy.ir_analyzer import IRAnalyzer
-
-        analyzer = IRAnalyzer()
-        analyzer.analyze_block(block, self.context.variables)
-
-        # Analyze what this block needs
-        deps = self._analyze_block_dependencies(block)
-
-        # Determine what function this block will call
-        func_name = self._get_function_name_for_block(block)
-
-        # Check quantum arrays that this block uses
-        for var in deps["quantum"] & deps["reads"]:
-            # Skip struct variables
-            if any(var in info["var_names"].values() for info in self.struct_info.values()):
-                continue
-
-            # Check if we have a refreshed version from a previous function call
-            actual_var = var
-            if hasattr(self, "refreshed_arrays") and var in self.refreshed_arrays:
-                actual_var = self.refreshed_arrays[var]
-
-            # Get the expected size from the original variable context
-            expected_size = None
-            if var in self.context.variables:
-                var_info = self.context.variables[var]
-                if hasattr(var_info, "size"):
-                    expected_size = var_info.size
-
-            if expected_size is None:
-                continue  # Couldn't determine expected size
-
-            # Check the actual current size if the array is unpacked
-            actual_size = None
-            if hasattr(self, "unpacked_vars") and actual_var in self.unpacked_vars:
-                actual_size = len(self.unpacked_vars[actual_var])
-            if actual_size is None and actual_var != var:
-                # This is a refreshed array from a function return
-                # Try to determine its size from the upcoming function call's return type
-                actual_size = self._infer_current_array_size_from_fresh_var(
-                    var,
-                    actual_var,
-                    func_name,
-                    expected_size,
-                )
-
-            # If we have a size mismatch, restore the array size
-            if actual_size is not None and actual_size < expected_size:
-                self._insert_array_size_restoration(
-                    var,
-                    actual_var,
-                    actual_size,
-                    expected_size,
-                )
-
-    def _get_function_name_for_block(self, block) -> str | None:
-        """Determine what function name a block will call when converted."""
-        # The block has a name attribute that corresponds to the function
-        if hasattr(block, "name"):
-            return block.name
-        # If block has a __class__ attribute with the name
-        if hasattr(block, "__class__"):
-            return block.__class__.__name__.lower()
-        return None
-
-    def _infer_current_array_size_from_fresh_var(
-        self,
-        var: str,
-        _actual_var: str,
-        _func_name: str | None,
-        expected_size: int,
-    ) -> int | None:
-        """Infer the current size of a refreshed array by checking what function produced it.
-
-        This looks at refreshed_by_function to find what function was called to produce actual_var,
-        then looks up that function's return type to determine the actual size.
-        """
-        import re
-
-        # Check if we've tracked which function call produced this refreshed variable
-        if not hasattr(self, "refreshed_by_function") or var not in self.refreshed_by_function:
-            # No information about which function produced this variable
-            # This happens on the first iteration of a loop before any calls
-            return expected_size
-
-        func_info = self.refreshed_by_function[var]
-        # Extract function name and position
-        if isinstance(func_info, dict):
-            called_func_name = func_info["function"]
-            return_position = func_info.get("position", 0)
-        else:
-            called_func_name = func_info  # Legacy string format
-            return_position = 0
-
-        # Get the return type for this function
-        # Try multiple sources: function_return_types, function_info
-        return_type = None
-
-        if hasattr(self, "function_return_types") and called_func_name in self.function_return_types:
-            return_type = self.function_return_types[called_func_name]
-        elif hasattr(self, "function_info") and called_func_name in self.function_info:
-            func_info_entry = self.function_info[called_func_name]
-            if "return_type" in func_info_entry:
-                return_type = func_info_entry["return_type"]
-
-        if return_type is None and hasattr(self, "pending_functions"):
-            # Check pending functions - they haven't been built yet but we can analyze their blocks
-            for pending_block, pending_name, _pending_sig in self.pending_functions:
-                if pending_name == called_func_name:
-                    # Analyze the pending block to determine its return type
-                    return_type = self._infer_return_type_from_block(pending_block)
-                    break
-
-        if return_type is None:
-            return expected_size
-
-        # Parse the return type to extract array sizes
-        # Return type could be:
-        # - "array[quantum.qubit, N]" for single return
-        # - "tuple[array[quantum.qubit, N1], array[quantum.qubit, N2], ...]" for multiple returns
-
-        # Check if it's a tuple return
-        if return_type.startswith("tuple["):
-            # Extract all array sizes from the tuple
-            # Pattern: array[quantum.qubit, SIZE]
-            array_pattern = r"array\[quantum\.qubit,\s*(\d+)\]"
-            matches = re.findall(array_pattern, return_type)
-
-            if return_position < len(matches):
-                return int(matches[return_position])
-        else:
-            # Single return value
-            match = re.search(r"array\[quantum\.qubit,\s*(\d+)\]", return_type)
-            if match:
-                return int(match.group(1))
-
-        # If we can't determine the size, assume it's the same as expected (no restoration needed)
-        return expected_size
-
-    def _infer_return_type_from_block(self, block) -> str | None:
-        """Analyze a block to infer its return type.
-
-        Priority order:
-        1. If both block_returns annotation AND Return() statement exist, use them together
-           for precise variable-to-type mapping
-        2. If only block_returns annotation exists, use positional sizes
-        3. Fall back to analyzing block.vars and context (old behavior)
-
-        Returns:
-            A Guppy type string like "array[quantum.qubit, 2]" or
-            "tuple[array[quantum.qubit, 2], array[quantum.qubit, 7]]"
-        """
-        # BEST CASE: Both annotation and Return() statement exist
-        if hasattr(block, "__slr_return_type__") and hasattr(block, "get_return_vars"):
-            return_vars = block.get_return_vars()
-            if return_vars:
-                # We have explicit Return(var1, var2, ...) statement
-                # Combine with annotation for robust type checking
-                sizes = block.__slr_return_type__
-                if len(return_vars) == len(sizes):
-                    # Perfect match - we know which variable has which size
-                    return_types = [f"array[quantum.qubit, {size}]" for size in sizes]
-                    if len(return_types) == 1:
-                        return return_types[0]
-                    return f"tuple[{', '.join(return_types)}]"
-                # Mismatch - validation should have caught this, but proceed with annotation
-
-        # SECOND BEST: Just the annotation (positional sizes)
-        if hasattr(block, "__slr_return_type__"):
-            sizes = block.__slr_return_type__
-            return_types = [f"array[quantum.qubit, {size}]" for size in sizes]
-            if len(return_types) == 1:
-                return return_types[0]
-            return f"tuple[{', '.join(return_types)}]"
-
-        # FALLBACK: Try to infer from Return() statement variables
-        if hasattr(block, "get_return_vars"):
-            return_vars = block.get_return_vars()
-            if return_vars:
-                return self._infer_types_from_return_vars(return_vars)
-
-        # OLD FALLBACK: Try to infer from vars and context
-        if not hasattr(block, "vars") or not block.vars:
-            return None
-
-        # Get the return variables from block.vars
-        return_vars = block.vars if isinstance(block.vars, list | tuple) else [block.vars]
-        return self._infer_types_from_return_vars(return_vars)
-
-    def _infer_types_from_return_vars(self, return_vars) -> str | None:
-        """Infer Guppy types from a list of return variables by looking them up in context.
-
-        Args:
-            return_vars: List of variables to infer types for
-
-        Returns:
-            A Guppy type string or None if types couldn't be inferred
-        """
-        # For each return variable, determine its type and size
-        return_types = []
-        for var in return_vars:
-            var_name = var.sym if hasattr(var, "sym") else str(var)
-
-            # Check if the Vars object itself has size information
-            if hasattr(var, "size"):
-                size = var.size
-                return_types.append(f"array[quantum.qubit, {size}]")
-                continue
-
-            # Check if this is a quantum array in context
-            if var_name in self.context.variables:
-                var_info = self.context.variables[var_name]
-                if hasattr(var_info, "size"):
-                    # This is a quantum array
-                    size = var_info.size
-                    return_types.append(f"array[quantum.qubit, {size}]")
-                # else: Not a quantum array, skip for now
-
-        if not return_types:
-            return None
-
-        if len(return_types) == 1:
-            return return_types[0]
-        return f"tuple[{', '.join(return_types)}]"
-
-    def _infer_refreshed_array_size(
-        self,
-        var: str,
-        _actual_var: str,
-        expected_size: int,
-    ) -> int | None:
-        """Infer the size of a refreshed array from function return types.
-
-        When a function returns a smaller array than it received, we need to know
-        the actual returned size. This method looks up the function call that
-        produced the refreshed array and extracts the size from its return type.
-        """
-        import re
-
-        # Check if we've tracked which function call produced this refreshed variable
-        if not hasattr(self, "refreshed_by_function") or var not in self.refreshed_by_function:
-            # No information about which function produced this variable
-            return expected_size
-
-        func_info = self.refreshed_by_function[var]
-        func_name = func_info.get("function")
-        return_position = func_info.get(
-            "position",
-            0,
-        )  # Which element in the return tuple
-
-        # Get the return type for this function
-        if not hasattr(self, "function_return_types") or func_name not in self.function_return_types:
-            return expected_size
-
-        return_type = self.function_return_types[func_name]
-
-        # Parse the return type to extract array sizes
-        # Return type could be:
-        # - "array[quantum.qubit, N]" for single return
-        # - "tuple[array[quantum.qubit, N1], array[quantum.qubit, N2], ...]" for multiple returns
-
-        # Check if it's a tuple return
-        if return_type.startswith("tuple["):
-            # Extract all array sizes from the tuple
-            # Pattern: array[quantum.qubit, SIZE]
-            array_pattern = r"array\[quantum\.qubit,\s*(\d+)\]"
-            matches = re.findall(array_pattern, return_type)
-
-            if return_position < len(matches):
-                return int(matches[return_position])
-        else:
-            # Single return value
-            match = re.search(r"array\[quantum\.qubit,\s*(\d+)\]", return_type)
-            if match:
-                return int(match.group(1))
-
-        # If we can't determine the size, assume it's the same as expected (no restoration needed)
-        return expected_size
-
-    def _insert_array_size_restoration(
-        self,
-        var: str,
-        actual_var: str,
-        actual_size: int,
-        expected_size: int,
-    ) -> None:
-        """Insert code to restore an array to its expected size by allocating fresh qubits."""
-        from pecos.slr.gen_codes.guppy.ir import (
-            Assignment,
-            Comment,
-            FunctionCall,
-            VariableRef,
-        )
-
-        num_to_allocate = expected_size - actual_size
-
-        self.current_block.statements.append(
-            Comment(f"Restore {var} array size from {actual_size} to {expected_size}"),
-        )
-
-        # Unpack the current smaller array
-        if hasattr(self, "unpacked_vars") and actual_var in self.unpacked_vars:
-            current_elements = self.unpacked_vars[actual_var]
-        else:
-            # Create unpacking statement
-            current_elements = [f"{actual_var}_{i}" for i in range(actual_size)]
-            unpack_targets = ", ".join(current_elements)
-            self.current_block.statements.append(
-                Assignment(
-                    target=VariableRef(unpack_targets),
-                    value=VariableRef(actual_var),
-                ),
-            )
-
-        # Allocate fresh qubits
-        new_elements = []
-        for i in range(num_to_allocate):
-            fresh_var = self._get_unique_var_name(f"{var}_allocated_{actual_size + i}")
-            self.current_block.statements.append(
-                Assignment(
-                    target=VariableRef(fresh_var),
-                    value=FunctionCall(func_name="quantum.qubit", args=[]),
-                ),
-            )
-            new_elements.append(fresh_var)
-
-        # Reconstruct the full-size array and reassign to the actual_var (fresh variable)
-        # This ensures the variable stays consistently defined throughout the loop
-        all_elements = current_elements + new_elements
-
-        array_construction = self._create_array_construction(all_elements)
-        self.current_block.statements.append(
-            Assignment(
-                target=VariableRef(actual_var),
-                value=array_construction,
-            ),
-        )
diff --git a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/ir_generator.py b/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/ir_generator.py
deleted file mode 100644
index b39c587eb..000000000
--- a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/ir_generator.py
+++ /dev/null
@@ -1,79 +0,0 @@
-"""IR-based Guppy generator that uses two-pass architecture."""
-
-from __future__ import annotations
-
-import warnings
-from typing import TYPE_CHECKING
-
-from pecos.slr.gen_codes.generator import Generator
-from pecos.slr.gen_codes.guppy.dependency_analyzer import DependencyAnalyzer
-from pecos.slr.gen_codes.guppy.ir import ScopeContext
-from pecos.slr.gen_codes.guppy.ir_builder import IRBuilder
-from pecos.slr.gen_codes.guppy.ir_postprocessor import IRPostProcessor
-from pecos.slr.gen_codes.guppy.unified_resource_planner import UnifiedResourcePlanner
-
-if TYPE_CHECKING:
-    from pecos.slr import Block
-
-
-class IRGuppyGenerator(Generator):
-    """Generator that uses IR for two-pass Guppy code generation.
-
-    .. deprecated::
-        Use :func:`pecos.slr.generate` with ``target="guppy"`` instead.
-    """
-
-    def __init__(self, *, _internal: bool = False):
-        """Initialize the IR-based generator."""
-        if not _internal:
-            warnings.warn(
-                "GuppyGenerator/IRGuppyGenerator is deprecated. Use pecos.slr.generate(prog, 'guppy') instead.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-        self.output = []
-        self.variable_context = {}
-        self.dependency_analyzer = DependencyAnalyzer()
-
-    def generate_block(self, block: Block) -> None:
-        """Generate Guppy code for a block using IR."""
-        # Build variable context from block
-        self._build_variable_context(block)
-
-        # First pass: Analyze the block with unified resource planning
-        # This coordinates unpacking decisions with allocation strategies
-        planner = UnifiedResourcePlanner()
-        unified_analysis = planner.analyze(block, self.variable_context)
-
-        # Convert unified analysis to UnpackingPlan
-        # The unified planner internally runs IRAnalyzer, so we don't need to run it again
-        unpacking_plan = unified_analysis.get_unpacking_plan()
-
-        # Second pass: Build IR with both unpacking plan and unified analysis
-        builder = IRBuilder(
-            unpacking_plan,
-            unified_analysis=unified_analysis,
-            include_optimization_report=True,
-        )
-        module = builder.build_module(block, [])  # No pending functions for now
-
-        # Post-processing pass: Fix array accesses after unpacking
-        context = ScopeContext()
-        postprocessor = IRPostProcessor()
-        postprocessor.process_module(module, context)
-
-        # Third pass: Render to Guppy code
-        lines = module.render(context)
-
-        self.output = lines
-
-    def _build_variable_context(self, block: Block) -> None:
-        """Build variable context from block declarations."""
-        if hasattr(block, "vars"):
-            for var in block.vars:
-                if hasattr(var, "sym"):
-                    self.variable_context[var.sym] = var
-
-    def get_output(self) -> str:
-        """Get the generated Guppy code."""
-        return "\n".join(self.output)
diff --git a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/ir_postprocessor.py b/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/ir_postprocessor.py
deleted file mode 100644
index 664756b8f..000000000
--- a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/ir_postprocessor.py
+++ /dev/null
@@ -1,253 +0,0 @@
-"""Post-processor for IR nodes to fix array access after unpacking.
-
-This module provides a post-processing pass that runs after IR building
-but before rendering to replace ArrayAccess nodes with VariableRef nodes
-for arrays that have been unpacked.
-"""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from pecos.slr.gen_codes.guppy.ir import (
-    ArrayAccess,
-    ArrayUnpack,
-    Assignment,
-    BinaryOp,
-    Block,
-    FieldAccess,
-    ForStatement,
-    FunctionCall,
-    IfStatement,
-    IRNode,
-    Measurement,
-    MethodCall,
-    ReturnStatement,
-    ScopeContext,
-    TupleExpression,
-    UnaryOp,
-    VariableInfo,
-    VariableRef,
-    WhileStatement,
-)
-
-if TYPE_CHECKING:
-    from pecos.slr.gen_codes.guppy.ir import (
-        Function,
-        Module,
-    )
-
-
-class IRPostProcessor:
-    """Post-processes IR to fix array accesses after unpacking decisions."""
-
-    def __init__(self):
-        # Track unpacked arrays per function: func_name -> array_name -> list of unpacked variable names
-        self.unpacked_arrays_by_function: dict[str, dict[str, list[str]]] = {}
-        # Track current scope for variable lookups
-        self.current_scope: ScopeContext | None = None
-        # Track refreshed arrays per function
-        self.refreshed_arrays: dict[str, set[str]] = {}
-        # Track current function being processed
-        self.current_function: str | None = None
-
-    def process_module(self, module: Module, context: ScopeContext) -> None:
-        """Process a module and all its functions."""
-        self.current_scope = context
-
-        # Store refreshed arrays from module
-        self.refreshed_arrays = module.refreshed_arrays
-
-        # First, analyze the module to populate unpacking information
-        module.analyze(context)
-
-        # Then traverse and fix array accesses
-        for func in module.functions:
-            self._process_function(func, context)
-
-    def _process_function(self, func: Function, parent_context: ScopeContext) -> None:
-        """Process a function."""
-        # Track current function
-        self.current_function = func.name
-
-        # Initialize unpacked arrays for this function if not exists
-        if func.name not in self.unpacked_arrays_by_function:
-            self.unpacked_arrays_by_function[func.name] = {}
-
-        # Create function scope
-        func_context = ScopeContext(parent=parent_context)
-
-        # Add parameters to scope
-        for param_name, param_type in func.params:
-            var_info = VariableInfo(
-                name=param_name,
-                original_name=param_name,
-                var_type=param_type,
-            )
-            func_context.add_variable(var_info)
-
-        # Process function body
-        self._process_block(func.body, func_context)
-
-    def _process_block(self, block: Block, context: ScopeContext) -> None:
-        """Process a block of statements."""
-        old_scope = self.current_scope
-        self.current_scope = context
-
-        # First pass: collect unpacking information
-        for stmt in block.statements:
-            if isinstance(stmt, ArrayUnpack):
-                # Record unpacking info for the current function
-                if self.current_function:
-                    self.unpacked_arrays_by_function[self.current_function][stmt.source] = stmt.targets
-                # Also update the context
-                var = context.lookup_variable(stmt.source)
-                if var:
-                    var.is_unpacked = True
-                    var.unpacked_names = stmt.targets
-                else:
-                    # Create variable info if it doesn't exist
-                    var_info = VariableInfo(
-                        name=stmt.source,
-                        original_name=stmt.source,
-                        var_type="quantum",
-                        is_array=True,
-                        is_unpacked=True,
-                        unpacked_names=stmt.targets,
-                    )
-                    context.add_variable(var_info)
-
-        # Second pass: process all statements
-        for i, stmt in enumerate(block.statements):
-            block.statements[i] = self._process_node(stmt, context)
-
-        self.current_scope = old_scope
-
-    def _process_node(self, node: IRNode, context: ScopeContext) -> IRNode:
-        """Process any IR node, replacing ArrayAccess as needed."""
-        if node is None:
-            return None
-
-        # Handle ArrayAccess specially
-        if isinstance(node, ArrayAccess):
-            return self._process_array_access(node, context)
-
-        # Handle compound nodes that contain other nodes
-        if isinstance(node, Assignment):
-            node.target = self._process_node(node.target, context)
-            node.value = self._process_node(node.value, context)
-
-        elif isinstance(node, FunctionCall):
-            node.args = [self._process_node(arg, context) for arg in node.args]
-
-        elif isinstance(node, MethodCall):
-            node.obj = self._process_node(node.obj, context)
-            node.args = [self._process_node(arg, context) for arg in node.args]
-
-        elif isinstance(node, BinaryOp):
-            node.left = self._process_node(node.left, context)
-            node.right = self._process_node(node.right, context)
-
-        elif isinstance(node, UnaryOp):
-            node.operand = self._process_node(node.operand, context)
-
-        elif isinstance(node, Measurement):
-            node.qubit = self._process_node(node.qubit, context)
-            if node.target:
-                node.target = self._process_node(node.target, context)
-
-        elif isinstance(node, ReturnStatement):
-            if node.value:
-                node.value = self._process_node(node.value, context)
-
-        elif isinstance(node, TupleExpression):
-            node.elements = [self._process_node(elem, context) for elem in node.elements]
-
-        elif isinstance(node, IfStatement):
-            node.condition = self._process_node(node.condition, context)
-            self._process_block(node.then_block, ScopeContext(parent=context))
-            if node.else_block:
-                self._process_block(node.else_block, ScopeContext(parent=context))
-
-        elif isinstance(node, WhileStatement):
-            node.condition = self._process_node(node.condition, context)
-            self._process_block(node.body, ScopeContext(parent=context))
-
-        elif isinstance(node, ForStatement):
-            node.iterable = self._process_node(node.iterable, context)
-            self._process_block(node.body, ScopeContext(parent=context))
-
-        elif isinstance(node, Block):
-            self._process_block(node, context)
-
-        elif isinstance(node, FieldAccess):
-            node.obj = self._process_node(node.obj, context)
-
-        # Return the node (possibly modified)
-        return node
-
-    def _process_array_access(self, node: ArrayAccess, context: ScopeContext) -> IRNode:
-        """Process an ArrayAccess node, possibly replacing it with VariableRef."""
-        # Check if this is accessing an unpacked array
-        array_name = None
-
-        # Extract array name from different forms
-        if node.array_name:
-            # Old API: direct array name
-            array_name = node.array_name
-        elif isinstance(node.array, VariableRef):
-            # New API: array is a VariableRef
-            array_name = node.array.name
-        elif isinstance(node.array, FieldAccess):
-            # Complex case: struct.field[index]
-            # Process the field access but don't replace the array access
-            node.array = self._process_node(node.array, context)
-            return node
-
-        # Debug: Print what we're processing
-        # print(f"DEBUG: Processing ArrayAccess - array_name={array_name}, index={node.index}")
-        # print(f"DEBUG: unpacked_arrays={self.unpacked_arrays}")
-
-        # If we have an array name and a constant index, check for unpacking
-        if array_name and isinstance(node.index, int):
-            # Check if this array was refreshed by a function call
-            # If so, we should NOT convert to unpacked variable names
-            if (
-                self.current_function
-                and self.current_function in self.refreshed_arrays
-                and array_name in self.refreshed_arrays[self.current_function]
-            ):
-                # Array was refreshed, keep as ArrayAccess with force_array_syntax
-                node.force_array_syntax = True
-                # Process array and index if needed
-                if node.array and isinstance(node.array, IRNode):
-                    node.array = self._process_node(node.array, context)
-                if isinstance(node.index, IRNode):
-                    node.index = self._process_node(node.index, context)
-                return node
-
-            # Look up variable info
-            var = context.lookup_variable(array_name)
-            if var and var.is_unpacked and node.index < len(var.unpacked_names):
-                # Replace with VariableRef to the unpacked variable
-                # print(f"DEBUG: Replacing {array_name}[{node.index}] with {var.unpacked_names[node.index]}")
-                return VariableRef(var.unpacked_names[node.index])
-
-            # Also check our function-specific tracking
-            if self.current_function and self.current_function in self.unpacked_arrays_by_function:
-                func_unpacked = self.unpacked_arrays_by_function[self.current_function]
-                if array_name in func_unpacked:
-                    unpacked_names = func_unpacked[array_name]
-                    if node.index < len(unpacked_names):
-                        # print(f"DEBUG: Replacing {array_name}[{node.index}] with {unpacked_names[node.index]}")
-                        return VariableRef(unpacked_names[node.index])
-
-        # Process array if it's an IRNode
-        if node.array and isinstance(node.array, IRNode):
-            node.array = self._process_node(node.array, context)
-
-        # Process index if it's an IRNode
-        if isinstance(node.index, IRNode):
-            node.index = self._process_node(node.index, context)
-
-        return node
diff --git a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/naming.py b/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/naming.py
deleted file mode 100644
index 91b16bbd3..000000000
--- a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/naming.py
+++ /dev/null
@@ -1,138 +0,0 @@
-"""Utilities for converting block names to function names."""
-
-import re
-
-
-def class_to_function_name(class_name: str) -> str:
-    """Convert a PascalCase class name to snake_case function name.
-
-    Examples:
-        PrepareGHZ -> prepare_ghz
-        ApplyXCorrection -> apply_x_correction
-        QPEStep -> qpe_step
-        PrepareLogical0 -> prepare_logical_0
-    """
-    # First, handle the sequence of capital letters followed by lowercase (e.g., 'GHZ' -> 'ghz')
-    s1 = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", class_name)
-    # Handle lowercase (or number) followed by capital letter
-    s2 = re.sub("([a-z0-9])([A-Z])", r"\1_\2", s1)
-    # Handle letter followed by number
-    s3 = re.sub(r"([a-zA-Z])(\d)", r"\1_\2", s2)
-    return s3.lower()
-
-
-def get_module_prefix(block_class) -> str | None:
-    """Get module-based prefix for a block class.
-
-    Examples:
-        pecos.qeclib.steane.PrepareLogical0 -> steane_
-        pecos.qeclib.surface.MeasureStabilizers -> surface_
-        mypackage.circuits.teleport.BellPair -> teleport_
-    """
-    module = getattr(block_class, "__module__", "")
-    if not module:
-        return None
-
-    # Look for qeclib patterns
-    if "qeclib" in module:
-        parts = module.split(".")
-        try:
-            qeclib_idx = parts.index("qeclib")
-            if qeclib_idx + 1 < len(parts):
-                # Return the module after qeclib (e.g., 'steane', 'surface')
-                return parts[qeclib_idx + 1] + "_"
-        except (ValueError, IndexError):
-            pass
-
-    # For other patterns, look for meaningful module names
-    common_modules = {
-        "blocks",
-        "ops",
-        "operations",
-        "circuits",
-        "components",
-        "__main__",
-    }
-    parts = module.split(".")
-
-    # Skip the class name itself if it's at the end
-    if parts and parts[-1] == block_class.__name__:
-        parts = parts[:-1]
-
-    # Look backwards for a meaningful, specific module name
-    for i in range(len(parts) - 1, -1, -1):
-        part = parts[i]
-        # Skip common structural names
-        if part in common_modules:
-            continue
-        # Found a specific module name
-        return part + "_"
-
-    return None
-
-
-def get_function_name(block_class, *, use_module_prefix: bool = True) -> str:
-    """Get the full function name for a block class.
-
-    Args:
-        block_class: The block class
-        use_module_prefix: Whether to include module-based prefix
-
-    Returns:
-        Function name like 'prepare_ghz' or 'steane_prepare_logical_0'
-    """
-    # Get base name from class
-    class_name = block_class.__name__
-    base_name = class_to_function_name(class_name)
-
-    # Add module prefix if requested
-    if use_module_prefix:
-        prefix = get_module_prefix(block_class)
-        if prefix and not base_name.startswith(prefix.rstrip("_")):
-            return prefix + base_name
-
-    return base_name
-
-
-# Example usage and tests
-if __name__ == "__main__":
-    # Test class name conversion
-    test_cases = [
-        ("PrepareGHZ", "prepare_ghz"),
-        ("ApplyXCorrection", "apply_x_correction"),
-        ("QPEStep", "qpe_step"),
-        ("PrepareLogical0", "prepare_logical_0"),
-        ("CNOTGate", "cnot_gate"),
-        ("Phase90", "phase_90"),
-        ("TOffoli3", "t_offoli_3"),
-    ]
-
-    print("Class name conversions:")
-    for input_name, expected in test_cases:
-        result = class_to_function_name(input_name)
-        status = "PASS" if result == expected else "FAIL"
-        print(f"  {status} {input_name} -> {result} (expected: {expected})")
-
-    # Test module prefix extraction
-    print("\nModule prefix extraction:")
-
-    class MockClass:
-        pass
-
-    # Test different module paths
-    test_modules = [
-        ("pecos.qeclib.steane.PrepareLogical0", "steane_"),
-        ("pecos.qeclib.surface.MeasureStabilizers", "surface_"),
-        ("pecos.qeclib.bacon_shor.ExtractSyndrome", "bacon_shor_"),
-        ("mypackage.circuits.teleport.BellPair", "teleport_"),
-        ("mypackage.circuits.BellPair", None),  # 'circuits' is common
-        ("pecos.slr.blocks.CustomBlock", None),  # 'blocks' is common
-        ("__main__.MyBlock", None),
-    ]
-
-    for module_path, expected_prefix in test_modules:
-        MockClass.__module__ = module_path
-        MockClass.__name__ = module_path.split(".")[-1]
-        prefix = get_module_prefix(MockClass)
-        status = "PASS" if prefix == expected_prefix else "FAIL"
-        print(f"  {status} {module_path} -> {prefix} (expected: {expected_prefix})")
diff --git a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/qubit_state_validator.py b/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/qubit_state_validator.py
deleted file mode 100644
index c1ee4e74a..000000000
--- a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/qubit_state_validator.py
+++ /dev/null
@@ -1,329 +0,0 @@
-# Copyright 2026 The PECOS Developers
-#
-# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
-# the License. You may obtain a copy of the License at
-#
-#     https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations under the License.
-
-"""Qubit state validation for SLR programs.
-
-This module validates that quantum gates are only applied to prepared qubit slots,
-detecting compile-time errors when gates are applied to unprepared/measured qubits.
-
-The validation follows the two-state model from the QAlloc design:
-- UNPREPARED: Initial state or after measurement - cannot apply gates
-- PREPARED: After preparation - ready for gate operations
-
-Validation errors are collected and can be reported as compile-time errors.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from enum import Enum, auto
-from typing import TYPE_CHECKING, Any
-
-if TYPE_CHECKING:
-    from pecos.slr import Block as SLRBlock
-
-
-class ValidationSlotState(Enum):
-    """State of a qubit slot for validation purposes."""
-
-    UNPREPARED = auto()  # Initial state or after measurement
-    PREPARED = auto()  # After preparation, ready for gates
-
-
-@dataclass
-class StateViolation:
-    """A validation error: gate applied to unprepared slot."""
-
-    array_name: str
-    index: int
-    position: int
-    gate_name: str
-    message: str
-
-    def __str__(self) -> str:
-        return f"{self.array_name}[{self.index}] at position {self.position}: {self.message}"
-
-
-@dataclass
-class QubitStateTracker:
-    """Tracks the preparation state of qubit slots through program execution.
-
-    Used to validate that gates are only applied to prepared qubits.
-    """
-
-    # Map from (array_name, index) to current state
-    slot_states: dict[tuple[str, int], ValidationSlotState] = field(
-        default_factory=dict,
-    )
-
-    # Collected violations
-    violations: list[StateViolation] = field(default_factory=list)
-
-    # Position counter for tracking operation order
-    position: int = 0
-
-    def get_state(self, array_name: str, index: int) -> ValidationSlotState:
-        """Get the current state of a slot. Defaults to UNPREPARED."""
-        return self.slot_states.get((array_name, index), ValidationSlotState.UNPREPARED)
-
-    def mark_prepared(self, array_name: str, index: int) -> None:
-        """Mark a slot as prepared (after Prep/Init/Reset)."""
-        self.slot_states[(array_name, index)] = ValidationSlotState.PREPARED
-
-    def mark_unprepared(self, array_name: str, index: int) -> None:
-        """Mark a slot as unprepared (after measurement)."""
-        self.slot_states[(array_name, index)] = ValidationSlotState.UNPREPARED
-
-    def validate_gate(self, array_name: str, index: int, gate_name: str) -> bool:
-        """Validate that a gate can be applied to this slot.
-
-        Returns True if valid, False if violation detected.
-        """
-        state = self.get_state(array_name, index)
-        if state == ValidationSlotState.UNPREPARED:
-            self.violations.append(
-                StateViolation(
-                    array_name=array_name,
-                    index=index,
-                    position=self.position,
-                    gate_name=gate_name,
-                    message=f"Gate '{gate_name}' applied to unprepared qubit. "
-                    f"Call prepare() before applying gates.",
-                ),
-            )
-            return False
-        return True
-
-    def has_violations(self) -> bool:
-        """Check if any violations were detected."""
-        return len(self.violations) > 0
-
-    def get_violations(self) -> list[StateViolation]:
-        """Get all detected violations."""
-        return self.violations.copy()
-
-    def clear_violations(self) -> None:
-        """Clear all violations."""
-        self.violations.clear()
-
-
-class QubitStateValidator:
-    """Validates qubit state requirements in SLR programs.
-
-    Walks through the program operations and validates that:
-    1. Gates are only applied to prepared qubits
-    2. Measurements transition qubits to unprepared
-    3. Preparations transition qubits to prepared
-
-    Usage:
-        validator = QubitStateValidator()
-        violations = validator.validate(block, variable_context)
-
-        if violations:
-            for v in violations:
-                print(f"Error: {v}")
-    """
-
-    # Operations that prepare qubits
-    PREPARATION_OPS = frozenset({"Prep", "Init", "Reset", "PrepZ", "PrepX", "PrepY"})
-
-    # Operations that consume/measure qubits
-    MEASUREMENT_OPS = frozenset({"Measure", "MeasZ", "MeasX", "MeasY"})
-
-    def __init__(self, *, strict: bool = True):
-        """Initialize the validator.
-
-        Args:
-            strict: If True, all qubits start unprepared and must be explicitly prepared.
-                   If False, qubits are assumed prepared initially (legacy compatibility).
-        """
-        self.strict = strict
-        self.tracker = QubitStateTracker()
-
-    def validate(
-        self,
-        block: SLRBlock,
-        variable_context: dict[str, Any] | None = None,
-    ) -> list[StateViolation]:
-        """Validate qubit states in a block.
-
-        Args:
-            block: The SLR block to validate.
-            variable_context: Optional context of variables (QReg, CReg, etc.).
-
-        Returns:
-            List of StateViolation objects for any detected errors.
-        """
-        self.tracker = QubitStateTracker()
-        variable_context = variable_context or {}
-
-        # In non-strict mode, mark all known qubits as prepared initially
-        if not self.strict:
-            self._initialize_prepared(variable_context)
-
-        # Validate all operations
-        if hasattr(block, "ops"):
-            for op in block.ops:
-                self._validate_operation(op, variable_context)
-                self.tracker.position += 1
-
-        return self.tracker.get_violations()
-
-    def _initialize_prepared(self, variable_context: dict[str, Any]) -> None:
-        """Mark all qubits as initially prepared (legacy mode)."""
-        for var in variable_context.values():
-            if hasattr(var, "size") and hasattr(var, "sym"):
-                # Check if it's a quantum register
-                var_type = type(var).__name__
-                if var_type in ("QReg", "QAlloc"):
-                    for i in range(var.size):
-                        self.tracker.mark_prepared(var.sym, i)
-
-    def _validate_operation(
-        self,
-        op: Any,
-        variable_context: dict[str, Any],
-    ) -> None:
-        """Validate a single operation."""
-        op_name = type(op).__name__
-
-        if op_name in self.MEASUREMENT_OPS:
-            self._handle_measurement(op)
-        elif op_name in self.PREPARATION_OPS:
-            self._handle_preparation(op)
-        elif op_name == "If":
-            self._validate_if_block(op, variable_context)
-        elif op_name in ("For", "While", "Repeat"):
-            self._validate_loop_block(op, variable_context)
-        elif op_name == "Parallel":
-            self._validate_parallel_block(op, variable_context)
-        elif hasattr(op, "qargs"):
-            # This is a quantum gate
-            self._validate_gate(op)
-        elif hasattr(op, "ops"):
-            # Nested block - recurse
-            for nested_op in op.ops:
-                self._validate_operation(nested_op, variable_context)
-
-    def _handle_measurement(self, op: Any) -> None:
-        """Handle measurement: transitions qubits to unprepared."""
-        if hasattr(op, "qargs") and op.qargs:
-            for qarg in op.qargs:
-                if self._has_reg_and_index(qarg):
-                    self.tracker.mark_unprepared(qarg.reg.sym, qarg.index)
-
-    def _handle_preparation(self, op: Any) -> None:
-        """Handle preparation: transitions qubits to prepared."""
-        if hasattr(op, "qargs") and op.qargs:
-            for qarg in op.qargs:
-                if self._has_reg_and_index(qarg):
-                    self.tracker.mark_prepared(qarg.reg.sym, qarg.index)
-
-    def _validate_gate(self, op: Any) -> None:
-        """Validate a quantum gate: all qubits must be prepared."""
-        gate_name = type(op).__name__
-        if hasattr(op, "qargs") and op.qargs:
-            for qarg in op.qargs:
-                if self._has_reg_and_index(qarg):
-                    self.tracker.validate_gate(qarg.reg.sym, qarg.index, gate_name)
-
-    def _validate_if_block(
-        self,
-        if_block: Any,
-        variable_context: dict[str, Any],
-    ) -> None:
-        """Validate an if block.
-
-        For if/else, we need to be conservative: a qubit is only considered
-        prepared after the if block if it's prepared in BOTH branches.
-        """
-        # Save state before if
-        state_before = dict(self.tracker.slot_states)
-
-        # Validate then block
-        if hasattr(if_block, "ops"):
-            for op in if_block.ops:
-                self._validate_operation(op, variable_context)
-
-        # Save state after then
-        state_after_then = dict(self.tracker.slot_states)
-
-        # Reset to state before if and validate else
-        self.tracker.slot_states = dict(state_before)
-
-        if hasattr(if_block, "else_block") and if_block.else_block and hasattr(if_block.else_block, "ops"):
-            for op in if_block.else_block.ops:
-                self._validate_operation(op, variable_context)
-
-        state_after_else = dict(self.tracker.slot_states)
-
-        # Merge states: only prepared if prepared in BOTH branches
-        merged_state = {}
-        all_keys = set(state_after_then.keys()) | set(state_after_else.keys())
-        for key in all_keys:
-            then_state = state_after_then.get(key, ValidationSlotState.UNPREPARED)
-            else_state = state_after_else.get(key, ValidationSlotState.UNPREPARED)
-            # Only prepared if prepared in both branches
-            if then_state == ValidationSlotState.PREPARED and else_state == ValidationSlotState.PREPARED:
-                merged_state[key] = ValidationSlotState.PREPARED
-            else:
-                merged_state[key] = ValidationSlotState.UNPREPARED
-
-        self.tracker.slot_states = merged_state
-
-    def _validate_loop_block(
-        self,
-        loop_block: Any,
-        variable_context: dict[str, Any],
-    ) -> None:
-        """Validate a loop block.
-
-        For loops, we validate the body once but assume the state after
-        the loop could be any state that occurs during the loop.
-        """
-        # Validate loop body
-        if hasattr(loop_block, "ops"):
-            for op in loop_block.ops:
-                self._validate_operation(op, variable_context)
-
-    def _validate_parallel_block(
-        self,
-        parallel_block: Any,
-        variable_context: dict[str, Any],
-    ) -> None:
-        """Validate a parallel block."""
-        if hasattr(parallel_block, "ops"):
-            for op in parallel_block.ops:
-                self._validate_operation(op, variable_context)
-
-    def _has_reg_and_index(self, qarg: Any) -> bool:
-        """Check if a qubit argument has reg and index attributes."""
-        return hasattr(qarg, "reg") and hasattr(qarg.reg, "sym") and hasattr(qarg, "index")
-
-
-def validate_qubit_states(
-    block: SLRBlock,
-    variable_context: dict[str, Any] | None = None,
-    *,
-    strict: bool = True,
-) -> list[StateViolation]:
-    """Convenience function to validate qubit states in a block.
-
-    Args:
-        block: The SLR block to validate.
-        variable_context: Optional context of variables.
-        strict: If True, qubits must be explicitly prepared before use.
-
-    Returns:
-        List of StateViolation objects for any detected errors.
-    """
-    validator = QubitStateValidator(strict=strict)
-    return validator.validate(block, variable_context)
diff --git a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/qubit_usage_analyzer.py b/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/qubit_usage_analyzer.py
deleted file mode 100644
index ded78c7e4..000000000
--- a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/qubit_usage_analyzer.py
+++ /dev/null
@@ -1,259 +0,0 @@
-"""Analyzer for qubit usage patterns to optimize allocation strategies."""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from enum import Enum
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from pecos.slr import Block as SLRBlock
-
-
-class QubitRole(Enum):
-    """Role classification for quantum registers."""
-
-    DATA = "data"  # Long-lived data qubits
-    ANCILLA = "ancilla"  # Short-lived ancilla qubits
-    UNKNOWN = "unknown"  # Not yet classified
-
-
-@dataclass
-class QubitUsageStats:
-    """Statistics about how a quantum register is used."""
-
-    name: str
-    size: int
-
-    # Usage patterns
-    measurement_count: int = 0
-    reset_count: int = 0
-    gate_count: int = 0
-
-    # Lifetime tracking
-    first_use_position: int | None = None
-    last_use_position: int | None = None
-    measurement_positions: list[int] = field(default_factory=list)
-    reset_positions: list[int] = field(default_factory=list)
-
-    # Access patterns
-    individual_accesses: set[int] = field(default_factory=set)
-    full_array_accesses: int = 0
-
-    # Structural hints
-    is_struct_member: bool = False
-    struct_name: str | None = None
-
-    @property
-    def lifetime(self) -> int:
-        """Calculate the lifetime of this register."""
-        if self.first_use_position is None or self.last_use_position is None:
-            return 0
-        return self.last_use_position - self.first_use_position
-
-    @property
-    def measure_reset_ratio(self) -> float:
-        """Ratio of measurements+resets to total operations."""
-        total_ops = self.measurement_count + self.reset_count + self.gate_count
-        if total_ops == 0:
-            return 0.0
-        return (self.measurement_count + self.reset_count) / total_ops
-
-    @property
-    def individual_access_ratio(self) -> float:
-        """Ratio of individual element accesses to size."""
-        if self.size == 0:
-            return 0.0
-        return len(self.individual_accesses) / self.size
-
-    def classify_role(self) -> QubitRole:
-        """Classify the role of this register based on usage patterns."""
-        # Explicit ancilla naming patterns
-        if any(pattern in self.name.lower() for pattern in ["ancilla", "anc", "syndrome", "flag"]):
-            return QubitRole.ANCILLA
-
-        # Explicit data naming patterns
-        if any(pattern in self.name.lower() for pattern in ["data", "logical", "code"]):
-            return QubitRole.DATA
-
-        # Pattern-based classification
-        # High measure/reset ratio suggests ancilla
-        if self.measure_reset_ratio > 0.7:
-            return QubitRole.ANCILLA
-
-        # Short lifetime with measurements suggests ancilla
-        if self.lifetime < 10 and self.measurement_count > 0:
-            return QubitRole.ANCILLA
-
-        # Part of a struct (like QEC code) suggests data
-        if self.is_struct_member:
-            return QubitRole.DATA
-
-        # Default to data for long-lived qubits
-        if self.lifetime > 20:
-            return QubitRole.DATA
-
-        return QubitRole.UNKNOWN
-
-
-class QubitUsageAnalyzer:
-    """Analyzes qubit usage patterns to inform allocation strategies."""
-
-    def __init__(self):
-        self.register_stats: dict[str, QubitUsageStats] = {}
-        self.position_counter = 0
-
-    def analyze_block(
-        self,
-        block: SLRBlock,
-        struct_info: dict[str, dict] | None = None,
-    ) -> dict[str, QubitUsageStats]:
-        """Analyze a block and return usage statistics for each quantum register."""
-        # Reset state
-        self.register_stats.clear()
-        self.position_counter = 0
-
-        # First, collect all quantum registers
-        if hasattr(block, "vars"):
-            for var in block.vars:
-                if type(var).__name__ == "QReg" and hasattr(var, "sym"):
-                    stats = QubitUsageStats(
-                        name=var.sym,
-                        size=getattr(var, "size", 1),
-                    )
-
-                    # Check if part of a struct
-                    if struct_info:
-                        for struct_name, info in struct_info.items():
-                            if var.sym in info.get("var_names", {}).values():
-                                stats.is_struct_member = True
-                                stats.struct_name = struct_name
-                                break
-
-                    self.register_stats[var.sym] = stats
-
-        # Analyze operations
-        if hasattr(block, "ops"):
-            for op in block.ops:
-                self._analyze_operation(op)
-                self.position_counter += 1
-
-        return self.register_stats
-
-    def _analyze_operation(self, op) -> None:
-        """Analyze a single operation for qubit usage patterns."""
-        op_type = type(op).__name__
-
-        if op_type == "Measure":
-            self._analyze_measurement(op)
-        elif op_type in ["Prep", "Reset"]:
-            self._analyze_reset(op)
-        elif hasattr(op, "qargs"):
-            self._analyze_gate(op)
-        elif hasattr(op, "ops"):
-            # Nested block
-            for nested_op in op.ops:
-                self._analyze_operation(nested_op)
-
-    def _analyze_measurement(self, meas) -> None:
-        """Analyze measurement operations."""
-        if hasattr(meas, "qargs") and meas.qargs:
-            for qarg in meas.qargs:
-                reg_name = self._get_register_name(qarg)
-                if reg_name and reg_name in self.register_stats:
-                    stats = self.register_stats[reg_name]
-                    stats.measurement_count += 1
-                    stats.measurement_positions.append(self.position_counter)
-                    self._update_lifetime(stats)
-
-                    # Track access pattern
-                    if hasattr(qarg, "index"):
-                        stats.individual_accesses.add(qarg.index)
-                    elif hasattr(qarg, "size"):
-                        stats.full_array_accesses += 1
-
-    def _analyze_reset(self, reset_op) -> None:
-        """Analyze reset/prep operations."""
-        if hasattr(reset_op, "qargs") and reset_op.qargs:
-            for qarg in reset_op.qargs:
-                reg_name = self._get_register_name(qarg)
-                if reg_name and reg_name in self.register_stats:
-                    stats = self.register_stats[reg_name]
-                    stats.reset_count += 1
-                    stats.reset_positions.append(self.position_counter)
-                    self._update_lifetime(stats)
-
-    def _analyze_gate(self, gate) -> None:
-        """Analyze gate operations."""
-        if hasattr(gate, "qargs") and gate.qargs:
-            for qarg in gate.qargs:
-                # Handle tuple arguments (e.g., CX gates)
-                if isinstance(qarg, tuple):
-                    for sub_qarg in qarg:
-                        self._record_gate_usage(sub_qarg)
-                else:
-                    self._record_gate_usage(qarg)
-
-    def _record_gate_usage(self, qarg) -> None:
-        """Record usage from a gate operation."""
-        reg_name = self._get_register_name(qarg)
-        if reg_name and reg_name in self.register_stats:
-            stats = self.register_stats[reg_name]
-            stats.gate_count += 1
-            self._update_lifetime(stats)
-
-            # Track access pattern
-            if hasattr(qarg, "index"):
-                stats.individual_accesses.add(qarg.index)
-
-    def _get_register_name(self, qarg) -> str | None:
-        """Extract register name from a qubit argument."""
-        if hasattr(qarg, "reg") and hasattr(qarg.reg, "sym"):
-            return qarg.reg.sym
-        if hasattr(qarg, "sym"):
-            return qarg.sym
-        return None
-
-    def _update_lifetime(self, stats: QubitUsageStats) -> None:
-        """Update lifetime tracking for a register."""
-        if stats.first_use_position is None:
-            stats.first_use_position = self.position_counter
-        stats.last_use_position = self.position_counter
-
-    def get_allocation_recommendations(self) -> dict[str, dict]:
-        """Get allocation recommendations based on usage analysis."""
-        recommendations = {}
-
-        for reg_name, stats in self.register_stats.items():
-            role = stats.classify_role()
-
-            if role == QubitRole.ANCILLA:
-                # Ancillas benefit from dynamic allocation
-                recommendations[reg_name] = {
-                    "allocation": "dynamic",
-                    "reason": f"High measure/reset ratio ({stats.measure_reset_ratio:.2f})",
-                    "keep_packed": False,
-                    "pre_allocate": False,
-                }
-            elif role == QubitRole.DATA:
-                # Data qubits should stay bundled
-                recommendations[reg_name] = {
-                    "allocation": "static",
-                    "reason": (
-                        "Long-lived data qubits"
-                        if stats.is_struct_member
-                        else f"Low measure/reset ratio ({stats.measure_reset_ratio:.2f})"
-                    ),
-                    "keep_packed": True,
-                    "pre_allocate": True,
-                }
-            else:
-                # Default conservative approach
-                recommendations[reg_name] = {
-                    "allocation": "static",
-                    "reason": "Unknown usage pattern",
-                    "keep_packed": True,
-                    "pre_allocate": True,
-                }
-
-        return recommendations
diff --git a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/scope_manager.py b/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/scope_manager.py
deleted file mode 100644
index 0b6683322..000000000
--- a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/scope_manager.py
+++ /dev/null
@@ -1,236 +0,0 @@
-"""Enhanced scope management for IR-based code generation."""
-
-from __future__ import annotations
-
-from contextlib import contextmanager
-from dataclasses import dataclass, field
-from enum import Enum
-
-from pecos.slr.gen_codes.guppy.ir import ResourceState, ScopeContext
-
-# Maximum array size fallback when actual size cannot be determined from context
-# This is a conservative upper bound to ensure all indices are covered
-_MAX_ARRAY_SIZE_FALLBACK = 1000
-
-
-class ScopeType(Enum):
-    """Type of scope."""
-
-    MODULE = "module"
-    FUNCTION = "function"
-    BLOCK = "block"
-    IF_THEN = "if_then"
-    IF_ELSE = "if_else"
-    LOOP = "loop"
-
-
-@dataclass
-class ResourceUsage:
-    """Track resource usage in a scope."""
-
-    qreg_name: str
-    indices: set[int]
-    is_consumed: bool = False
-    is_borrowed: bool = False
-
-
-@dataclass
-class ScopeInfo:
-    """Enhanced scope information."""
-
-    scope_type: ScopeType
-    context: ScopeContext
-    resource_usage: dict[str, ResourceUsage] = field(default_factory=dict)
-    borrowed_resources: set[str] = field(default_factory=set)
-    returned_resources: set[str] = field(default_factory=set)
-
-
-class ScopeManager:
-    """Manages scope contexts for IR generation."""
-
-    def __init__(self):
-        self.scope_stack: list[ScopeInfo] = []
-        self.global_context = ScopeContext()
-
-    @property
-    def current_scope(self) -> ScopeInfo | None:
-        """Get the current scope."""
-        return self.scope_stack[-1] if self.scope_stack else None
-
-    @property
-    def current_context(self) -> ScopeContext:
-        """Get the current scope context."""
-        if self.current_scope:
-            return self.current_scope.context
-        return self.global_context
-
-    @contextmanager
-    def enter_scope(self, scope_type: ScopeType):
-        """Enter a new scope."""
-        parent_context = self.current_context
-        new_context = ScopeContext(parent=parent_context)
-        new_scope = ScopeInfo(scope_type=scope_type, context=new_context)
-
-        self.scope_stack.append(new_scope)
-        try:
-            yield new_scope
-        finally:
-            # Analyze resource flow when exiting scope
-            self._analyze_scope_exit(new_scope)
-            self.scope_stack.pop()
-
-    def _analyze_scope_exit(self, scope: ScopeInfo) -> None:
-        """Analyze resource usage when exiting a scope."""
-        # For conditional scopes, propagate resource usage to parent
-        if scope.scope_type in [ScopeType.IF_THEN, ScopeType.IF_ELSE] and self.current_scope:
-            for res_name, usage in scope.resource_usage.items():
-                if res_name not in self.current_scope.resource_usage:
-                    self.current_scope.resource_usage[res_name] = ResourceUsage(
-                        qreg_name=usage.qreg_name,
-                        indices=set(),
-                    )
-                # Merge usage
-                parent_usage = self.current_scope.resource_usage[res_name]
-                parent_usage.indices.update(usage.indices)
-                if usage.is_consumed:
-                    parent_usage.is_consumed = True
-
-    def track_resource_usage(
-        self,
-        qreg_name: str,
-        indices: set[int],
-        *,
-        consumed: bool = False,
-    ) -> None:
-        """Track usage of a quantum resource in current scope."""
-        if not self.current_scope:
-            return
-
-        if qreg_name not in self.current_scope.resource_usage:
-            self.current_scope.resource_usage[qreg_name] = ResourceUsage(
-                qreg_name=qreg_name,
-                indices=set(),
-            )
-
-        usage = self.current_scope.resource_usage[qreg_name]
-        usage.indices.update(indices)
-        if consumed:
-            usage.is_consumed = True
-
-    def mark_resource_borrowed(self, qreg_name: str) -> None:
-        """Mark a resource as borrowed in current scope."""
-        if self.current_scope:
-            self.current_scope.borrowed_resources.add(qreg_name)
-            if qreg_name in self.current_scope.resource_usage:
-                self.current_scope.resource_usage[qreg_name].is_borrowed = True
-
-    def is_in_loop(self) -> bool:
-        """Check if currently inside a loop scope."""
-        return any(scope.scope_type == ScopeType.LOOP for scope in self.scope_stack)
-
-    def is_in_conditional_within_loop(self) -> bool:
-        """Check if currently inside a conditional (if) within a loop."""
-        in_loop = False
-        in_conditional = False
-
-        for scope in self.scope_stack:
-            if scope.scope_type == ScopeType.LOOP:
-                in_loop = True
-            elif scope.scope_type in (ScopeType.IF_THEN, ScopeType.IF_ELSE) and in_loop:
-                in_conditional = True
-
-        return in_loop and in_conditional
-
-    def mark_resource_returned(self, qreg_name: str) -> None:
-        """Mark a resource as returned from current scope."""
-        if self.current_scope:
-            self.current_scope.returned_resources.add(qreg_name)
-
-    def get_unconsumed_resources(self) -> dict[str, set[int]]:
-        """Get all unconsumed quantum resources in current scope."""
-        unconsumed = {}
-
-        # Look through all variables in current context
-        context = self.current_context
-        for var_name, var_info in context.variables.items():
-            if (
-                (var_info.var_type == "quantum" and var_info.state != ResourceState.CONSUMED)
-                and var_info.is_array
-                and var_info.size
-            ):
-                # Check which indices are consumed
-                consumed_indices = set()
-                if self.current_scope and var_name in self.current_scope.resource_usage:
-                    usage = self.current_scope.resource_usage[var_name]
-                    consumed_indices = set(range(var_info.size)) if usage.is_consumed else usage.indices
-
-                # Find unconsumed indices
-                all_indices = set(range(var_info.size))
-                unconsumed_indices = all_indices - consumed_indices
-
-                if unconsumed_indices:
-                    unconsumed[var_name] = unconsumed_indices
-
-        return unconsumed
-
-    def analyze_conditional_branches(
-        self,
-        then_scope: ScopeInfo,
-        else_scope: ScopeInfo | None,
-        context: ScopeContext | None = None,
-    ) -> dict[str, set[int]]:
-        """Analyze resource consumption across conditional branches."""
-        # Get resources consumed in then branch
-        then_consumed = {}
-        for res_name, usage in then_scope.resource_usage.items():
-            if usage.is_consumed:
-                # Get actual array size from context if available
-                if context:
-                    var_info = context.lookup_variable(res_name)
-                    if var_info and var_info.size:
-                        then_consumed[res_name] = set(range(var_info.size))
-                    else:
-                        then_consumed[res_name] = set(range(_MAX_ARRAY_SIZE_FALLBACK))
-                else:
-                    then_consumed[res_name] = set(range(_MAX_ARRAY_SIZE_FALLBACK))
-            elif usage.indices:
-                then_consumed[res_name] = usage.indices
-
-        # Get resources consumed in else branch (if exists)
-        else_consumed = {}
-        if else_scope:
-            for res_name, usage in else_scope.resource_usage.items():
-                if usage.is_consumed:
-                    # Get actual array size from context if available
-                    if context:
-                        var_info = context.lookup_variable(res_name)
-                        if var_info and var_info.size:
-                            else_consumed[res_name] = set(range(var_info.size))
-                        else:
-                            else_consumed[res_name] = set(
-                                range(_MAX_ARRAY_SIZE_FALLBACK),
-                            )
-                    else:
-                        else_consumed[res_name] = set(range(_MAX_ARRAY_SIZE_FALLBACK))
-                elif usage.indices:
-                    else_consumed[res_name] = usage.indices
-
-        # Find resources that need to be balanced
-        all_resources = set(then_consumed.keys()) | set(else_consumed.keys())
-        unbalanced = {}
-
-        for res_name in all_resources:
-            then_indices = then_consumed.get(res_name, set())
-            else_indices = else_consumed.get(res_name, set())
-
-            if then_indices != else_indices:
-                # Find indices consumed in one branch but not the other
-                else_indices - then_indices
-                missing_in_else = then_indices - else_indices
-
-                # For now, we track indices missing in else branch
-                # (consumed in then but not else)
-                if missing_in_else:
-                    unbalanced[res_name] = missing_in_else
-
-        return unbalanced
diff --git a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/unified_resource_planner.py b/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/unified_resource_planner.py
deleted file mode 100644
index 9c42cc813..000000000
--- a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/unified_resource_planner.py
+++ /dev/null
@@ -1,547 +0,0 @@
-"""Unified resource planning framework for Guppy code generation.
-
-This module provides a holistic approach to resource management by combining:
-1. Array unpacking decisions (rule-based from unpacking_rules.py)
-2. Local allocation analysis (computed directly from usage patterns)
-3. Data flow analysis (precise element-level tracking from data_flow.py)
-
-The unified planner makes coordinated decisions about BOTH unpacking and allocation,
-eliminating conflicts and enabling cross-cutting optimizations.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from enum import Enum, auto
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from pecos.slr import Block as SLRBlock
-    from pecos.slr.gen_codes.guppy.data_flow import DataFlowAnalysis
-    from pecos.slr.gen_codes.guppy.ir_analyzer import ArrayAccessInfo, UnpackingPlan
-
-
-class ResourceStrategy(Enum):
-    """Unified strategy for how to manage a quantum/classical register.
-
-    This combines both unpacking and allocation decisions into a coherent plan.
-    """
-
-    # Keep as packed array, pre-allocate all elements
-    PACKED_PREALLOCATED = auto()
-
-    # Keep as packed array, allocate elements dynamically as needed
-    PACKED_DYNAMIC = auto()
-
-    # Unpack into individual variables, pre-allocate all
-    UNPACKED_PREALLOCATED = auto()
-
-    # Unpack into individual variables, allocate some locally
-    UNPACKED_MIXED = auto()
-
-    # Unpack completely, all elements allocated locally when first used
-    UNPACKED_LOCAL = auto()
-
-
-class DecisionPriority(Enum):
-    """Priority level for resource planning decisions."""
-
-    REQUIRED = auto()  # Semantic necessity (would fail otherwise)
-    RECOMMENDED = auto()  # Strong evidence for this approach
-    OPTIONAL = auto()  # Minor benefit
-    DISCOURAGED = auto()  # Minor drawback
-    FORBIDDEN = auto()  # Would cause errors
-
-
-@dataclass
-class ResourcePlan:
-    """Unified plan for managing a single register (array or unpacked).
-
-    This combines unpacking and allocation decisions into a coherent strategy.
-    """
-
-    array_name: str
-    size: int
-    is_classical: bool
-
-    # Unified strategy
-    strategy: ResourceStrategy
-
-    # Fine-grained control
-    elements_to_unpack: set[int] = field(default_factory=set)  # Which to unpack
-    elements_to_allocate_locally: set[int] = field(
-        default_factory=set,
-    )  # Which to allocate locally
-    elements_requiring_replacement: set[int] = field(
-        default_factory=set,
-    )  # Which need Prep after Measure
-
-    # Decision reasoning
-    priority: DecisionPriority = DecisionPriority.OPTIONAL
-    reasons: list[str] = field(default_factory=list)
-    evidence: dict[str, any] = field(default_factory=dict)
-
-    @property
-    def needs_unpacking(self) -> bool:
-        """Check if this register needs to be unpacked."""
-        return self.strategy in (
-            ResourceStrategy.UNPACKED_PREALLOCATED,
-            ResourceStrategy.UNPACKED_MIXED,
-            ResourceStrategy.UNPACKED_LOCAL,
-        )
-
-    @property
-    def uses_dynamic_allocation(self) -> bool:
-        """Check if this register uses any dynamic allocation."""
-        return self.strategy in (
-            ResourceStrategy.PACKED_DYNAMIC,
-            ResourceStrategy.UNPACKED_MIXED,
-            ResourceStrategy.UNPACKED_LOCAL,
-        )
-
-    def get_explanation(self) -> str:
-        """Get human-readable explanation of the plan."""
-        lines = [
-            f"Resource Plan for '{self.array_name}' (size={self.size}, "
-            f"{'classical' if self.is_classical else 'quantum'}):",
-            f"  Strategy: {self.strategy.name}",
-            f"  Priority: {self.priority.name}",
-        ]
-
-        if self.elements_to_unpack:
-            lines.append(f"  Elements to unpack: {sorted(self.elements_to_unpack)}")
-
-        if self.elements_to_allocate_locally:
-            lines.append(
-                f"  Local allocation: {sorted(self.elements_to_allocate_locally)}",
-            )
-
-        if self.elements_requiring_replacement:
-            lines.append(
-                f"  Need replacement: {sorted(self.elements_requiring_replacement)}",
-            )
-
-        if self.reasons:
-            lines.append("  Reasons:")
-            lines.extend(f"    - {reason}" for reason in self.reasons)
-
-        return "\n".join(lines)
-
-
-@dataclass
-class UnifiedResourceAnalysis:
-    """Complete resource analysis for a block.
-
-    Contains coordinated plans for all registers.
-    """
-
-    plans: dict[str, ResourcePlan] = field(default_factory=dict)
-    global_recommendations: list[str] = field(default_factory=list)
-    _original_unpacking_plan: UnpackingPlan | None = field(default=None, repr=False)
-
-    def get_plan(self, array_name: str) -> ResourcePlan | None:
-        """Get the resource plan for a specific array."""
-        return self.plans.get(array_name)
-
-    def set_original_unpacking_plan(self, plan: UnpackingPlan) -> None:
-        """Store the original UnpackingPlan from IRAnalyzer for backward compatibility."""
-        self._original_unpacking_plan = plan
-
-    def get_report(self) -> str:
-        """Generate comprehensive resource planning report."""
-        lines = [
-            "=" * 70,
-            "UNIFIED RESOURCE PLANNING REPORT",
-            "=" * 70,
-            "",
-        ]
-
-        if self.global_recommendations:
-            lines.append("Global Recommendations:")
-            lines.extend(f"  - {rec}" for rec in self.global_recommendations)
-            lines.append("")
-
-        for array_name, plan in sorted(self.plans.items()):
-            lines.append(plan.get_explanation())
-            lines.append("")
-
-        lines.extend(
-            [
-                "=" * 70,
-                f"Total registers analyzed: {len(self.plans)}",
-                f"Unpacking recommended: {sum(1 for p in self.plans.values() if p.needs_unpacking)}",
-                f"Dynamic allocation: {sum(1 for p in self.plans.values() if p.uses_dynamic_allocation)}",
-                "=" * 70,
-            ],
-        )
-
-        return "\n".join(lines)
-
-    def get_unpacking_plan(self) -> UnpackingPlan:
-        """Get the UnpackingPlan from IRAnalyzer.
-
-        The UnifiedResourcePlanner internally runs IRAnalyzer, so we always
-        have the original unpacking plan available.
-
-        Returns:
-            UnpackingPlan from IRAnalyzer with all detailed state preserved
-        """
-        # We always have the original plan because UnifiedResourcePlanner
-        # runs IRAnalyzer internally during analyze()
-        if self._original_unpacking_plan is None:
-            msg = "get_unpacking_plan() called but no original plan available"
-            raise RuntimeError(msg)
-
-        return self._original_unpacking_plan
-
-
-class UnifiedResourcePlanner:
-    """Unified planner that coordinates unpacking and allocation decisions.
-
-    This planner integrates:
-    1. Data flow analysis (precise element-level tracking)
-    2. Unpacking rules (semantic requirements from usage patterns)
-    3. Local allocation analysis (computed from consumption & reuse patterns)
-
-    The result is a coordinated ResourcePlan for each register that makes
-    coherent decisions about both unpacking and allocation.
-    """
-
-    def __init__(self):
-        self.analysis: UnifiedResourceAnalysis | None = None
-        self.original_unpacking_plan: UnpackingPlan | None = None
-
-    def analyze(
-        self,
-        block: SLRBlock,
-        variable_context: dict[str, any],
-        *,
-        array_access_info: dict[str, ArrayAccessInfo] | None = None,
-        data_flow_analysis: DataFlowAnalysis | None = None,
-    ) -> UnifiedResourceAnalysis:
-        """Perform unified resource planning for a block.
-
-        Args:
-            block: The SLR block to analyze
-            variable_context: Context of variables in the block
-            array_access_info: Optional pre-computed array access info from IRAnalyzer
-            data_flow_analysis: Optional pre-computed data flow analysis
-
-        Returns:
-            UnifiedResourceAnalysis with coordinated plans for all registers
-        """
-        self.analysis = UnifiedResourceAnalysis()
-
-        # If we don't have the required analyses, compute them now
-        if array_access_info is None:
-            from pecos.slr.gen_codes.guppy.ir_analyzer import IRAnalyzer
-
-            analyzer = IRAnalyzer()
-            plan = analyzer.analyze_block(block, variable_context)
-            array_access_info = plan.all_analyzed_arrays
-            # Store the original unpacking plan
-            self.original_unpacking_plan = plan
-
-        if data_flow_analysis is None:
-            from pecos.slr.gen_codes.guppy.data_flow import DataFlowAnalyzer
-
-            dfa = DataFlowAnalyzer()
-            data_flow_analysis = dfa.analyze(block, variable_context)
-
-        # Now perform unified planning for each array
-        for array_name, access_info in array_access_info.items():
-            plan = self._create_unified_plan(
-                array_name,
-                access_info,
-                data_flow_analysis,
-            )
-            self.analysis.plans[array_name] = plan
-
-        # Add global recommendations
-        self._add_global_recommendations()
-
-        # Store the original unpacking plan in the analysis for get_unpacking_plan()
-        if self.original_unpacking_plan:
-            self.analysis.set_original_unpacking_plan(self.original_unpacking_plan)
-
-        return self.analysis
-
-    def _create_unified_plan(
-        self,
-        array_name: str,
-        access_info: ArrayAccessInfo,
-        data_flow: DataFlowAnalysis,
-    ) -> ResourcePlan:
-        """Create a unified resource plan for a single array.
-
-        This is the core decision logic that coordinates unpacking and allocation.
-        """
-        plan = ResourcePlan(
-            array_name=array_name,
-            size=access_info.size,
-            is_classical=access_info.is_classical,
-            strategy=ResourceStrategy.PACKED_PREALLOCATED,  # Default
-        )
-
-        # Collect evidence from different analyses
-        self._collect_evidence(plan, access_info, data_flow)
-
-        # Determine which elements can be allocated locally
-        self._determine_local_allocation(plan, access_info, data_flow)
-
-        # Make coordinated decision based on all evidence
-        self._decide_strategy(plan, access_info, data_flow)
-
-        return plan
-
-    def _collect_evidence(
-        self,
-        plan: ResourcePlan,
-        access_info: ArrayAccessInfo,
-        data_flow: DataFlowAnalysis,
-    ) -> None:
-        """Collect evidence from all analyses."""
-        evidence = plan.evidence
-
-        # Evidence from array access patterns (counts for decisions)
-        evidence["has_individual_access"] = access_info.has_individual_access
-        evidence["all_elements_accessed"] = access_info.all_elements_accessed
-        evidence["has_full_array_access"] = bool(access_info.full_array_accesses)
-        evidence["elements_accessed"] = len(access_info.element_accesses)
-        evidence["elements_consumed"] = len(access_info.elements_consumed)
-        evidence["has_operations_between"] = access_info.has_operations_between
-        evidence["has_conditionals"] = access_info.has_conditionals_between
-
-        # Copy element-level information for get_unpacking_plan()
-        evidence["element_accesses"] = access_info.element_accesses
-        evidence["elements_consumed_set"] = access_info.elements_consumed
-
-        # Evidence from data flow analysis (element-level precision)
-        for (arr_name, idx), flow_info in data_flow.element_flows.items():
-            if arr_name == plan.array_name and flow_info.has_use_after_consumption():
-                plan.elements_requiring_replacement.add(idx)
-
-        # Evidence from conditional tracking (element-level)
-        conditionally_accessed = set()
-        for arr_name, idx in data_flow.conditional_accesses:
-            if arr_name == plan.array_name:
-                conditionally_accessed.add(idx)
-        evidence["conditionally_accessed_elements"] = conditionally_accessed
-
-    def _determine_local_allocation(
-        self,
-        plan: ResourcePlan,
-        access_info: ArrayAccessInfo,
-        _data_flow: DataFlowAnalysis,
-    ) -> None:
-        """Determine which elements can be allocated locally.
-
-        Elements can be allocated locally if they are:
-        - Quantum qubits (classical arrays don't use local allocation)
-        - Consumed (measured) and not reused
-        - Not in conditional scopes or loops (single-scope usage)
-        """
-        if plan.is_classical:
-            return  # Classical arrays don't use local allocation
-
-        # Find elements that are consumed and not reused
-        for idx in access_info.elements_consumed:
-            # Check if this element is reused after consumption
-            if idx in plan.elements_requiring_replacement:
-                continue  # This element is reused, can't allocate locally
-
-            # Check if used in conditionals (prevents local allocation)
-            if idx in access_info.conditionally_accessed_elements:
-                continue  # Conditional usage prevents local allocation
-
-            # This element is a good candidate for local allocation
-            plan.elements_to_allocate_locally.add(idx)
-
-    def _decide_strategy(
-        self,
-        plan: ResourcePlan,
-        access_info: ArrayAccessInfo,
-        _data_flow: DataFlowAnalysis,
-    ) -> None:
-        """Make unified strategy decision based on collected evidence.
-
-        Decision tree (in priority order):
-        1. Check for REQUIRED unpacking (semantic necessity)
-        2. Check for FORBIDDEN unpacking (would cause errors)
-        3. Check for allocation optimization opportunities
-        4. Make quality-based decisions
-
-        Note: Local allocation candidates are already determined in
-        _determine_local_allocation() and stored in plan.elements_to_allocate_locally
-        """
-        ev = plan.evidence
-
-        # Rule 1: Full array operations FORBID unpacking
-        if ev["has_full_array_access"]:
-            plan.strategy = ResourceStrategy.PACKED_PREALLOCATED
-            plan.priority = DecisionPriority.FORBIDDEN
-            plan.reasons.append(
-                "Full array operations require packed representation",
-            )
-            # Clear local allocation - packed arrays don't use it
-            plan.elements_to_allocate_locally.clear()
-            return
-
-        # Rule 2: No individual access = no unpacking needed
-        if not ev["has_individual_access"]:
-            # Check if allocation optimizer suggests dynamic allocation
-            if plan.elements_to_allocate_locally:
-                plan.strategy = ResourceStrategy.PACKED_DYNAMIC
-                plan.priority = DecisionPriority.RECOMMENDED
-                plan.reasons.append("Dynamic allocation recommended by optimizer")
-            else:
-                plan.strategy = ResourceStrategy.PACKED_PREALLOCATED
-                plan.priority = DecisionPriority.OPTIONAL
-                plan.reasons.append("No individual element access detected")
-            # Clear local allocation - packed arrays don't use it
-            plan.elements_to_allocate_locally.clear()
-            return
-
-        # Rule 3: Quantum arrays with operations after measurement REQUIRE unpacking
-        if not plan.is_classical and ev["has_operations_between"]:
-            # Check if we can use local allocation
-            if plan.elements_to_allocate_locally:
-                plan.strategy = ResourceStrategy.UNPACKED_MIXED
-                plan.elements_to_unpack = set(range(plan.size))
-                # Local elements already determined in _determine_local_allocation()
-                plan.priority = DecisionPriority.REQUIRED
-                plan.reasons.append(
-                    "Operations after measurement require unpacking (with local allocation)",
-                )
-            else:
-                plan.strategy = ResourceStrategy.UNPACKED_PREALLOCATED
-                plan.elements_to_unpack = set(range(plan.size))
-                plan.priority = DecisionPriority.REQUIRED
-                plan.reasons.append(
-                    "Operations after measurement require unpacking",
-                )
-            return
-
-        # Rule 4: Individual quantum measurements REQUIRE unpacking
-        if not plan.is_classical and ev["elements_consumed"] > 0:
-            # Determine unpacking strategy based on allocation
-            if plan.elements_to_allocate_locally:
-                # Some elements can be allocated locally
-                plan.strategy = ResourceStrategy.UNPACKED_MIXED
-                plan.elements_to_unpack = set(range(plan.size))
-                # Local elements already determined in _determine_local_allocation()
-                plan.priority = DecisionPriority.REQUIRED
-                plan.reasons.append(
-                    f"Individual quantum measurements require unpacking "
-                    f"({len(plan.elements_to_allocate_locally)} elements local)",
-                )
-            else:
-                plan.strategy = ResourceStrategy.UNPACKED_PREALLOCATED
-                plan.elements_to_unpack = set(range(plan.size))
-                plan.priority = DecisionPriority.REQUIRED
-                plan.reasons.append(
-                    "Individual quantum measurements require unpacking",
-                )
-            return
-
-        # Rule 5: Conditional element access REQUIRES unpacking
-        conditional_elements = ev.get("conditionally_accessed_elements", set())
-        if conditional_elements:
-            # Only unpack elements that are actually accessed (not just in conditionals)
-            elements_needing_unpack = conditional_elements & access_info.element_accesses
-
-            if elements_needing_unpack:
-                # Check allocation strategy
-                if plan.elements_to_allocate_locally:
-                    plan.strategy = ResourceStrategy.UNPACKED_MIXED
-                    # Local elements already determined in _determine_local_allocation()
-                else:
-                    plan.strategy = ResourceStrategy.UNPACKED_PREALLOCATED
-
-                plan.elements_to_unpack = set(range(plan.size))
-                plan.priority = DecisionPriority.REQUIRED
-                plan.reasons.append(
-                    f"Conditional access to elements {sorted(elements_needing_unpack)} requires unpacking",
-                )
-                return
-
-        # Rule 6: Single element access - prefer direct indexing
-        if ev["elements_accessed"] == 1:
-            plan.strategy = ResourceStrategy.PACKED_PREALLOCATED
-            plan.priority = DecisionPriority.RECOMMENDED
-            plan.reasons.append(
-                "Single element access - direct indexing preferred",
-            )
-            return
-
-        # Rule 7: Classical arrays with multiple accesses benefit from unpacking
-        if plan.is_classical and ev["elements_accessed"] > 1:
-            plan.strategy = ResourceStrategy.UNPACKED_PREALLOCATED
-            plan.elements_to_unpack = set(range(plan.size))
-            plan.priority = DecisionPriority.RECOMMENDED
-            plan.reasons.append(
-                f"Classical array with {ev['elements_accessed']} accesses - unpacking improves readability",
-            )
-            return
-
-        # Rule 9: Partial array usage
-        if ev["elements_accessed"] > 0 and not ev["all_elements_accessed"]:
-            access_ratio = ev["elements_accessed"] / plan.size
-            if access_ratio > 0.5:
-                plan.strategy = ResourceStrategy.UNPACKED_PREALLOCATED
-                plan.elements_to_unpack = set(range(plan.size))
-                plan.priority = DecisionPriority.OPTIONAL
-                plan.reasons.append(
-                    f"Partial array usage ({access_ratio:.0%}) - unpacking for clarity",
-                )
-                return
-
-            # Low access ratio - keep as array
-            plan.strategy = ResourceStrategy.PACKED_PREALLOCATED
-            plan.priority = DecisionPriority.OPTIONAL
-            plan.reasons.append(
-                f"Low access ratio ({access_ratio:.0%}) - keeping as array",
-            )
-            return
-
-        # Default: Keep as packed, pre-allocated (simplest approach)
-        plan.strategy = ResourceStrategy.PACKED_PREALLOCATED
-        plan.priority = DecisionPriority.OPTIONAL
-        plan.reasons.append("Default strategy - no strong evidence for alternatives")
-
-    def _add_global_recommendations(self) -> None:
-        """Add global recommendations based on overall analysis."""
-        if not self.analysis:
-            return
-
-        # Count strategies
-        strategy_counts = {}
-        for plan in self.analysis.plans.values():
-            strategy = plan.strategy
-            strategy_counts[strategy] = strategy_counts.get(strategy, 0) + 1
-
-        # Recommend patterns
-        total = len(self.analysis.plans)
-        if total == 0:
-            return
-
-        unpacked_count = sum(1 for p in self.analysis.plans.values() if p.needs_unpacking)
-        dynamic_count = sum(1 for p in self.analysis.plans.values() if p.uses_dynamic_allocation)
-
-        if unpacked_count > total * 0.7:
-            self.analysis.global_recommendations.append(
-                f"High unpacking ratio ({unpacked_count}/{total}) - "
-                "consider if element-level APIs would be more natural",
-            )
-
-        if dynamic_count > 0:
-            self.analysis.global_recommendations.append(
-                f"Dynamic allocation used for {dynamic_count}/{total} registers - ensure proper lifetime management",
-            )
-
-        # Check for potential conflicts
-        required_plans = [p for p in self.analysis.plans.values() if p.priority == DecisionPriority.REQUIRED]
-        if len(required_plans) == total and total > 1:
-            self.analysis.global_recommendations.append(
-                "All registers require unpacking - this may indicate complex control flow",
-            )
diff --git a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/unpacking_rules.py b/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/unpacking_rules.py
deleted file mode 100644
index ec6984b81..000000000
--- a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/unpacking_rules.py
+++ /dev/null
@@ -1,237 +0,0 @@
-"""Rule-based decision tree for array unpacking in Guppy code generation.
-
-This module provides a cleaner, more maintainable approach to deciding when arrays
-need to be unpacked, replacing the complex heuristic logic with explicit rules.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from enum import Enum, auto
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from pecos.slr.gen_codes.guppy.ir_analyzer import ArrayAccessInfo
-
-
-class UnpackingReason(Enum):
-    """Enumeration of reasons why an array might need unpacking."""
-
-    # Required unpacking (semantic necessity)
-    INDIVIDUAL_QUANTUM_MEASUREMENT = auto()  # Measuring individual qubits requires unpacking
-    OPERATIONS_AFTER_MEASUREMENT = auto()  # Using qubits after measurement requires replacement
-    CONDITIONAL_ELEMENT_ACCESS = auto()  # Accessing elements conditionally requires unpacking
-
-    # Optional unpacking (code quality)
-    MULTIPLE_INDIVIDUAL_ACCESSES = auto()  # Multiple element accesses cleaner when unpacked
-    PARTIAL_ARRAY_USAGE = auto()  # Not all elements used together
-
-    # No unpacking needed
-    FULL_ARRAY_ONLY = auto()  # Only full array operations (e.g., measure_array)
-    SINGLE_ELEMENT_ONLY = auto()  # Only one element accessed (use direct indexing)
-    NO_INDIVIDUAL_ACCESS = auto()  # No individual element access
-
-
-class UnpackingDecision(Enum):
-    """Decision outcome for array unpacking."""
-
-    MUST_UNPACK = auto()  # Semantically required
-    SHOULD_UNPACK = auto()  # Improves code quality
-    SHOULD_NOT_UNPACK = auto()  # Better to keep as array
-    MUST_NOT_UNPACK = auto()  # Would cause errors
-
-
-@dataclass
-class DecisionResult:
-    """Result of unpacking decision with reasoning."""
-
-    decision: UnpackingDecision
-    reason: UnpackingReason
-    explanation: str
-
-    @property
-    def should_unpack(self) -> bool:
-        """Whether the array should be unpacked."""
-        return self.decision in (
-            UnpackingDecision.MUST_UNPACK,
-            UnpackingDecision.SHOULD_UNPACK,
-        )
-
-
-class UnpackingDecisionTree:
-    """Rule-based decision tree for determining if an array needs unpacking.
-
-    This replaces the complex heuristic logic in ArrayAccessInfo.needs_unpacking
-    with an explicit, testable decision tree.
-
-    Decision rules are applied in order of priority:
-    1. Check for conditions that REQUIRE unpacking (semantic necessity)
-    2. Check for conditions that FORBID unpacking (would cause errors)
-    3. Check for conditions where unpacking IMPROVES code quality
-    4. Default to not unpacking (prefer simpler code)
-    """
-
-    def decide(self, info: ArrayAccessInfo) -> DecisionResult:
-        """Determine if an array should be unpacked based on access patterns.
-
-        Args:
-            info: Information about how the array is accessed
-
-        Returns:
-            DecisionResult with the decision and reasoning
-        """
-        # Rule 1: Full array operations forbid unpacking
-        if info.full_array_accesses:
-            return DecisionResult(
-                decision=UnpackingDecision.MUST_NOT_UNPACK,
-                reason=UnpackingReason.FULL_ARRAY_ONLY,
-                explanation=(
-                    f"Array '{info.array_name}' has full-array operations "
-                    f"(e.g., measure_array) at positions {info.full_array_accesses}. "
-                    "Unpacking would prevent these operations."
-                ),
-            )
-
-        # Rule 2: No individual access means no unpacking needed
-        if not info.has_individual_access:
-            return DecisionResult(
-                decision=UnpackingDecision.SHOULD_NOT_UNPACK,
-                reason=UnpackingReason.NO_INDIVIDUAL_ACCESS,
-                explanation=(f"Array '{info.array_name}' has no individual element access. Keeping as array."),
-            )
-
-        # Rule 3: Operations after measurement REQUIRES unpacking (quantum arrays only)
-        # This is because measured qubits are consumed and need to be replaced
-        if not info.is_classical and info.has_operations_between:
-            return DecisionResult(
-                decision=UnpackingDecision.MUST_UNPACK,
-                reason=UnpackingReason.OPERATIONS_AFTER_MEASUREMENT,
-                explanation=(
-                    f"Quantum array '{info.array_name}' has operations on qubits "
-                    "after measurement. This requires unpacking to handle qubit "
-                    "replacement correctly."
-                ),
-            )
-
-        # Rule 4: Individual quantum measurements REQUIRE unpacking
-        # This avoids MoveOutOfSubscriptError when measuring from array indices
-        if not info.is_classical and info.elements_consumed:
-            return DecisionResult(
-                decision=UnpackingDecision.MUST_UNPACK,
-                reason=UnpackingReason.INDIVIDUAL_QUANTUM_MEASUREMENT,
-                explanation=(
-                    f"Quantum array '{info.array_name}' has individual element "
-                    f"measurements (indices: {sorted(info.elements_consumed)}). "
-                    "This requires unpacking to avoid MoveOutOfSubscriptError."
-                ),
-            )
-
-        # Rule 5: Conditional element access REQUIRES unpacking
-        # Elements accessed in conditionals need to be separate variables
-        # NEW: Use precise element-level tracking if available
-        if hasattr(info, "conditionally_accessed_elements") and info.conditionally_accessed_elements:
-            # Use precise tracking - only unpack if conditionally accessed elements
-            # are also individually accessed
-            conditional_and_accessed = info.conditionally_accessed_elements & info.element_accesses
-            if conditional_and_accessed:
-                return DecisionResult(
-                    decision=UnpackingDecision.MUST_UNPACK,
-                    reason=UnpackingReason.CONDITIONAL_ELEMENT_ACCESS,
-                    explanation=(
-                        f"Array '{info.array_name}' has elements "
-                        f"{sorted(conditional_and_accessed)} accessed in conditional "
-                        "blocks. This requires unpacking for proper control flow handling."
-                    ),
-                )
-        elif info.has_conditionals_between:
-            # Fallback to old heuristic if precise tracking not available
-            return DecisionResult(
-                decision=UnpackingDecision.MUST_UNPACK,
-                reason=UnpackingReason.CONDITIONAL_ELEMENT_ACCESS,
-                explanation=(
-                    f"Array '{info.array_name}' has elements accessed in conditional "
-                    "blocks. This requires unpacking for proper control flow handling."
-                ),
-            )
-
-        # Rule 6: Single element access should use direct indexing (no unpack)
-        # This avoids PlaceNotUsedError when unpacking all but using only one
-        if len(info.element_accesses) == 1:
-            return DecisionResult(
-                decision=UnpackingDecision.SHOULD_NOT_UNPACK,
-                reason=UnpackingReason.SINGLE_ELEMENT_ONLY,
-                explanation=(
-                    f"Array '{info.array_name}' has only one element accessed "
-                    f"(index {next(iter(info.element_accesses))}). "
-                    "Using direct array indexing instead of unpacking."
-                ),
-            )
-
-        # Rule 7: Classical arrays with multiple individual accesses should unpack
-        # This produces cleaner code (e.g., c0, c1 instead of c[0], c[1])
-        if info.is_classical and len(info.element_accesses) > 1:
-            return DecisionResult(
-                decision=UnpackingDecision.SHOULD_UNPACK,
-                reason=UnpackingReason.MULTIPLE_INDIVIDUAL_ACCESSES,
-                explanation=(
-                    f"Classical array '{info.array_name}' has multiple individual "
-                    f"element accesses ({len(info.element_accesses)} elements). "
-                    "Unpacking produces cleaner code."
-                ),
-            )
-
-        # Rule 8: Partial array usage (not all elements accessed)
-        # If accessing most elements individually, unpacking may be clearer
-        if not info.all_elements_accessed and info.has_individual_access:
-            # Only unpack if accessing a significant portion (> 50%)
-            access_ratio = len(info.element_accesses) / info.size
-            if access_ratio > 0.5:
-                return DecisionResult(
-                    decision=UnpackingDecision.SHOULD_UNPACK,
-                    reason=UnpackingReason.PARTIAL_ARRAY_USAGE,
-                    explanation=(
-                        f"Array '{info.array_name}' has {len(info.element_accesses)} "
-                        f"of {info.size} elements accessed individually "
-                        f"({access_ratio:.0%}). Unpacking for clarity."
-                    ),
-                )
-            return DecisionResult(
-                decision=UnpackingDecision.SHOULD_NOT_UNPACK,
-                reason=UnpackingReason.PARTIAL_ARRAY_USAGE,
-                explanation=(
-                    f"Array '{info.array_name}' has only {len(info.element_accesses)} "
-                    f"of {info.size} elements accessed individually "
-                    f"({access_ratio:.0%}). Keeping as array."
-                ),
-            )
-
-        # Default: Don't unpack (prefer simpler code)
-        return DecisionResult(
-            decision=UnpackingDecision.SHOULD_NOT_UNPACK,
-            reason=UnpackingReason.NO_INDIVIDUAL_ACCESS,
-            explanation=(
-                f"Array '{info.array_name}' does not meet criteria for unpacking. Keeping as array for simpler code."
-            ),
-        )
-
-
-def should_unpack_array(info: ArrayAccessInfo, *, verbose: bool = False) -> bool:
-    """Convenience function to determine if an array should be unpacked.
-
-    Args:
-        info: Information about how the array is accessed
-        verbose: If True, print the decision reasoning
-
-    Returns:
-        True if the array should be unpacked, False otherwise
-    """
-    decision_tree = UnpackingDecisionTree()
-    result = decision_tree.decide(info)
-
-    if verbose:
-        print(f"Array '{info.array_name}' unpacking decision:")
-        print(f"  Decision: {result.decision.name}")
-        print(f"  Reason: {result.reason.name}")
-        print(f"  Explanation: {result.explanation}")
-
-    return result.should_unpack
diff --git a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/variable_state.py b/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/variable_state.py
deleted file mode 100644
index f5805f6ce..000000000
--- a/python/quantum-pecos/src/pecos/slr/gen_codes/guppy/variable_state.py
+++ /dev/null
@@ -1,154 +0,0 @@
-"""Unified variable-state tracking for the Guppy IR generator.
-
-The Guppy generator translates SLR programs (high-level quantum DSL) to
-Guppy source. Guppy uses linear types: every qubit must be used exactly
-once, and arrays-of-qubits get "moved" into and out of operations rather
-than mutated in place.
-
-Translating SLR to Guppy means tracking, for each SLR variable, *what
-Guppy variable currently holds it*. The form changes over the lifetime
-of the SLR variable -- it might be a whole array, get unpacked into
-element variables for individual access, get refreshed by a function
-return, get partially consumed, etc.
-
-Historically the IRGuppyGenerator did this with ~6+ separate dicts
-(`unpacked_vars`, `refreshed_arrays`, `array_remapping`, `index_mapping`,
-`variable_remapping`, `function_var_remapping`, `replaced_qubits`,
-`fresh_variables_to_track`, ...). Different code generation sites
-consult different subsets of these dicts; sites that miss a state
-transition emit Guppy that violates linearity ("AlreadyUsedError",
-"WrongNumberOfUnpacksError", etc.).
-
-This module replaces that with one model: each SLR variable has a
-*current binding* describing its Guppy form right now. Operations on the
-variable consult the binding; transitions update it. Code-generation
-sites that need the variable in a particular form call helpers like
-`ensure_whole()` which emit reconstruction statements transparently.
-
-The migration is incremental. While the legacy dicts still exist, this
-module shadows them: writes go to both, reads prefer this module. Once
-all read sites are migrated, the legacy dicts can be removed.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-
-
-@dataclass(frozen=True)
-class WholeArray:
-    """SLR variable is currently bound to a single Guppy array variable.
-
-    `guppy_name` is the live identifier; subsequent ops can reference
-    `guppy_name` directly or index into it via `guppy_name[i]`.
-    """
-
-    guppy_name: str
-
-
-@dataclass(frozen=True)
-class UnpackedArray:
-    """SLR variable was unpacked into per-element Guppy variables.
-
-    `element_names[i]` is the Guppy variable for original SLR index
-    `i` -- unless `index_mapping` is set, in which case mapping
-    `original_index -> position_in_element_names` is used (this happens
-    when a function call returned a partially-consumed array).
-    """
-
-    element_names: tuple[str, ...]
-    index_mapping: tuple[tuple[int, int], ...] = ()  # (orig_idx, position)
-
-    def position_for(self, original_index: int) -> int | None:
-        """Return the position in `element_names` for an SLR index.
-
-        With no `index_mapping`, returns `original_index` directly when in
-        bounds. With a mapping, looks up the position; returns None for
-        SLR indices that aren't present in the partial array.
-        """
-        if not self.index_mapping:
-            return original_index if original_index < len(self.element_names) else None
-        for orig, pos in self.index_mapping:
-            if orig == original_index:
-                return pos
-        return None
-
-
-@dataclass(frozen=True)
-class Consumed:
-    """SLR variable is fully consumed; subsequent references are bugs.
-
-    `reason` is a short human-readable note for diagnostics ("measured",
-    "passed to function as @owned", etc.).
-    """
-
-    reason: str = ""
-
-
-Binding = WholeArray | UnpackedArray | Consumed
-
-
-@dataclass
-class VariableState:
-    """Current Guppy bindings for SLR variables in one generation context.
-
-    A "context" is typically one Guppy function being generated -- the
-    main function or one of the extracted sub-block functions. Bindings
-    are local to a context; the same SLR variable name in different
-    contexts can have different bindings.
-    """
-
-    bindings: dict[str, Binding] = field(default_factory=dict)
-
-    def bind_whole(self, slr_name: str, guppy_name: str) -> None:
-        """Record that `slr_name` is currently held by Guppy var `guppy_name`."""
-        self.bindings[slr_name] = WholeArray(guppy_name)
-
-    def bind_unpacked(
-        self,
-        slr_name: str,
-        element_names: list[str],
-        index_mapping: dict[int, int] | None = None,
-    ) -> None:
-        """Record that `slr_name` was unpacked into per-element Guppy vars."""
-        mapping_tuple = tuple(sorted(index_mapping.items())) if index_mapping else ()
-        self.bindings[slr_name] = UnpackedArray(tuple(element_names), mapping_tuple)
-
-    def bind_consumed(self, slr_name: str, reason: str = "") -> None:
-        """Record that `slr_name` is no longer accessible."""
-        self.bindings[slr_name] = Consumed(reason)
-
-    def get(self, slr_name: str) -> Binding | None:
-        """Return current binding, or None if `slr_name` is unknown here."""
-        return self.bindings.get(slr_name)
-
-    def is_unpacked(self, slr_name: str) -> bool:
-        """True iff `slr_name` is currently in unpacked form."""
-        return isinstance(self.bindings.get(slr_name), UnpackedArray)
-
-    def is_consumed(self, slr_name: str) -> bool:
-        """True iff `slr_name` has been consumed."""
-        return isinstance(self.bindings.get(slr_name), Consumed)
-
-    def ensure_whole(self, slr_name: str) -> tuple[list[str], str | None]:
-        """Ensure `slr_name` is bound as a whole array; emit prep code if not.
-
-        Returns (preparation_lines, guppy_name). The caller emits the
-        preparation_lines (Guppy source as `array(elem_0, elem_1, ...)`
-        repacking) before whatever it does with `guppy_name`. Returns
-        ([], guppy_name) when already whole. Returns ([], None) when
-        `slr_name` is consumed or unknown -- caller should treat as a
-        programming error.
-
-        After repack, the binding is updated to WholeArray so subsequent
-        callers don't repack again.
-        """
-        binding = self.bindings.get(slr_name)
-        if isinstance(binding, WholeArray):
-            return [], binding.guppy_name
-        if isinstance(binding, UnpackedArray):
-            elements = ", ".join(binding.element_names)
-            line = f"{slr_name} = array({elements})"
-            self.bindings[slr_name] = WholeArray(slr_name)
-            return [line], slr_name
-        return [], None
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_codegen_equivalence.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_codegen_equivalence.py
index b9e7cf86d..65d154b4a 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_codegen_equivalence.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_codegen_equivalence.py
@@ -19,7 +19,6 @@
 from pecos.slr.ast import slr_to_ast
 from pecos.slr.ast.codegen import generate
 from pecos.slr.gen_codes import (
-    GuppyGenerator,
     QASMGenerator,
     QIRGenerator,
     QuantumCircuitGenerator,
@@ -174,38 +173,6 @@ def test_clifford_gates_stim(self) -> None:
         assert direct_lines == ast_lines
 
 
-class TestGuppyEquivalence:
-    """Compare Guppy output from direct SLR vs AST."""
-
-    def test_bell_state_guppy_structure(self) -> None:
-        """Test Bell state produces structurally similar Guppy."""
-        prog = Main(
-            q := QReg("q", 2),
-            qb.H(q[0]),
-            qb.CX(q[0], q[1]),
-        )
-
-        # AST path first (before direct generator mutates prog)
-        ast = slr_to_ast(prog)
-        ast_guppy = generate(ast, "guppy")
-
-        # Direct SLR path
-        gen = GuppyGenerator(_internal=True)
-        gen.generate_block(prog)
-        direct_guppy = gen.get_output()
-
-        # Both should have key elements
-        assert "@guppy" in direct_guppy or "guppy" in direct_guppy.lower()
-        assert "@guppy" in ast_guppy or "guppy" in ast_guppy.lower()
-
-        # Both should have H and CX gates
-        assert "quantum.h" in direct_guppy.lower() or ".h(" in direct_guppy.lower()
-        assert " = h(" in ast_guppy.lower()
-
-        assert "quantum.cx" in direct_guppy.lower() or ".cx(" in direct_guppy.lower()
-        assert " = cx(" in ast_guppy.lower()
-
-
 class TestQIREquivalence:
     """Compare QIR output from direct SLR vs AST."""
 
diff --git a/python/quantum-pecos/tests/pecos/slr/test_qubit_state_validator.py b/python/quantum-pecos/tests/pecos/slr/test_qubit_state_validator.py
deleted file mode 100644
index a606506d7..000000000
--- a/python/quantum-pecos/tests/pecos/slr/test_qubit_state_validator.py
+++ /dev/null
@@ -1,309 +0,0 @@
-# Copyright 2026 The PECOS Developers
-#
-# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
-# the License. You may obtain a copy of the License at
-#
-#     https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations under the License.
-
-"""Tests for QubitStateValidator - compile-time detection of unprepared qubit usage."""
-
-import pytest
-from pecos.slr import CReg, If, Main, QReg
-from pecos.slr.gen_codes.guppy.qubit_state_validator import (
-    QubitStateValidator,
-    StateViolation,
-    validate_qubit_states,
-)
-from pecos.slr.qeclib import qubit as qb
-
-
-class TestQubitStateValidatorBasic:
-    """Basic validation tests."""
-
-    def test_gate_without_prep_strict_mode(self) -> None:
-        """In strict mode, gate without prep is a violation."""
-        prog = Main(
-            q := QReg("q", 2),
-            qb.H(q[0]),  # No prep before H - should be violation
-        )
-
-        violations = validate_qubit_states(prog, strict=True)
-
-        assert len(violations) == 1
-        assert violations[0].array_name == "q"
-        assert violations[0].index == 0
-        assert "H" in violations[0].gate_name
-        assert "unprepared" in violations[0].message.lower()
-
-    def test_gate_without_prep_non_strict_mode(self) -> None:
-        """In non-strict mode (legacy), qubits start prepared."""
-        prog = Main(
-            q := QReg("q", 2),
-            qb.H(q[0]),  # No prep but non-strict mode - OK
-        )
-
-        variable_context = {"q": prog.vars.get("q")}
-        violations = validate_qubit_states(prog, variable_context, strict=False)
-
-        assert len(violations) == 0
-
-    def test_prep_then_gate_is_valid(self) -> None:
-        """Prep followed by gate is valid."""
-        prog = Main(
-            q := QReg("q", 2),
-            qb.Prep(q[0]),
-            qb.H(q[0]),  # Prep before H - valid
-        )
-
-        violations = validate_qubit_states(prog, strict=True)
-
-        assert len(violations) == 0
-
-    def test_measure_then_gate_is_violation(self) -> None:
-        """Gate after measurement without re-prep is violation."""
-        prog = Main(
-            q := QReg("q", 2),
-            c := CReg("c", 2),
-            qb.Prep(q[0]),
-            qb.Measure(q[0]) > c[0],
-            qb.H(q[0]),  # After measure, no re-prep - violation
-        )
-
-        violations = validate_qubit_states(prog, strict=True)
-
-        assert len(violations) == 1
-        assert violations[0].array_name == "q"
-        assert violations[0].index == 0
-
-    def test_measure_reprep_gate_is_valid(self) -> None:
-        """Measure, re-prep, then gate is valid."""
-        prog = Main(
-            q := QReg("q", 2),
-            c := CReg("c", 2),
-            qb.Prep(q[0]),
-            qb.Measure(q[0]) > c[0],
-            qb.Prep(q[0]),  # Re-prep after measure
-            qb.H(q[0]),  # Now valid
-        )
-
-        violations = validate_qubit_states(prog, strict=True)
-
-        assert len(violations) == 0
-
-
-class TestQubitStateValidatorMultiQubit:
-    """Tests with multiple qubits."""
-
-    def test_independent_qubit_tracking(self) -> None:
-        """Each qubit's state is tracked independently."""
-        prog = Main(
-            q := QReg("q", 3),
-            qb.Prep(q[0]),
-            qb.Prep(q[1]),
-            # q[2] not prepared
-            qb.H(q[0]),  # OK
-            qb.H(q[1]),  # OK
-            qb.H(q[2]),  # Violation - not prepared
-        )
-
-        violations = validate_qubit_states(prog, strict=True)
-
-        assert len(violations) == 1
-        assert violations[0].index == 2
-
-    def test_two_qubit_gate_both_prepared(self) -> None:
-        """Two-qubit gate requires both qubits prepared."""
-        prog = Main(
-            q := QReg("q", 2),
-            qb.Prep(q[0]),
-            qb.Prep(q[1]),
-            qb.CX(q[0], q[1]),  # Both prepared - valid
-        )
-
-        violations = validate_qubit_states(prog, strict=True)
-
-        assert len(violations) == 0
-
-    def test_two_qubit_gate_one_unprepared(self) -> None:
-        """Two-qubit gate with one unprepared qubit is violation."""
-        prog = Main(
-            q := QReg("q", 2),
-            qb.Prep(q[0]),
-            # q[1] not prepared
-            qb.CX(q[0], q[1]),  # q[1] unprepared - violation
-        )
-
-        violations = validate_qubit_states(prog, strict=True)
-
-        assert len(violations) == 1
-        assert violations[0].index == 1
-
-    def test_two_qubit_gate_both_unprepared(self) -> None:
-        """Two-qubit gate with both unprepared is two violations."""
-        prog = Main(
-            q := QReg("q", 2),
-            qb.CX(q[0], q[1]),  # Both unprepared - two violations
-        )
-
-        violations = validate_qubit_states(prog, strict=True)
-
-        assert len(violations) == 2
-
-
-class TestQubitStateValidatorConditionals:
-    """Tests with conditional blocks."""
-
-    def test_if_block_both_branches_prepare(self) -> None:
-        """If both branches prepare, qubit is prepared after."""
-        prog = Main(
-            q := QReg("q", 1),
-            c := CReg("c", 1),
-            If(c[0] == 1)
-            .Then(
-                qb.Prep(q[0]),
-            )
-            .Else(
-                qb.Prep(q[0]),
-            ),
-            qb.H(q[0]),  # Prepared in both branches - valid
-        )
-
-        variable_context = {"q": prog.vars.get("q"), "c": prog.vars.get("c")}
-        violations = validate_qubit_states(prog, variable_context, strict=True)
-
-        assert len(violations) == 0
-
-    def test_if_block_only_then_prepares(self) -> None:
-        """If only then branch prepares, qubit may be unprepared after."""
-        prog = Main(
-            q := QReg("q", 1),
-            c := CReg("c", 1),
-            If(c[0] == 1).Then(
-                qb.Prep(q[0]),
-            ),
-            # No else - q[0] may not be prepared
-            qb.H(q[0]),  # May be unprepared - violation
-        )
-
-        variable_context = {"q": prog.vars.get("q"), "c": prog.vars.get("c")}
-        violations = validate_qubit_states(prog, variable_context, strict=True)
-
-        # Should detect violation - qubit not prepared in else branch
-        assert len(violations) >= 1
-
-
-class TestQubitStateValidatorQECPattern:
-    """Tests for typical QEC patterns."""
-
-    def test_syndrome_extraction_pattern(self) -> None:
-        """Typical syndrome extraction: prep, use, measure, re-prep cycle."""
-        prog = Main(
-            data := QReg("data", 2),
-            ancilla := QReg("ancilla", 1),
-            c := CReg("c", 1),
-            # Initialize data qubits
-            qb.Prep(data[0]),
-            qb.Prep(data[1]),
-            # Syndrome extraction round 1
-            qb.Prep(ancilla[0]),
-            qb.CX(data[0], ancilla[0]),
-            qb.CX(data[1], ancilla[0]),
-            qb.Measure(ancilla[0]) > c[0],
-            # Syndrome extraction round 2
-            qb.Prep(ancilla[0]),  # Re-prep after measure
-            qb.CX(data[0], ancilla[0]),
-            qb.CX(data[1], ancilla[0]),
-            qb.Measure(ancilla[0]) > c[0],
-        )
-
-        violations = validate_qubit_states(prog, strict=True)
-
-        assert len(violations) == 0
-
-    def test_missing_reprep_in_qec_cycle(self) -> None:
-        """Detect missing re-prep in QEC cycle."""
-        prog = Main(
-            data := QReg("data", 1),
-            ancilla := QReg("ancilla", 1),
-            c := CReg("c", 1),
-            # Initialize
-            qb.Prep(data[0]),
-            qb.Prep(ancilla[0]),
-            # Round 1
-            qb.CX(data[0], ancilla[0]),
-            qb.Measure(ancilla[0]) > c[0],
-            # Round 2 - MISSING re-prep of ancilla
-            qb.CX(data[0], ancilla[0]),  # ancilla[0] is unprepared - violation
-        )
-
-        violations = validate_qubit_states(prog, strict=True)
-
-        assert len(violations) == 1
-        assert violations[0].array_name == "ancilla"
-        assert violations[0].index == 0
-
-
-class TestStateViolation:
-    """Tests for StateViolation dataclass."""
-
-    def test_string_representation(self) -> None:
-        """StateViolation has readable string representation."""
-        violation = StateViolation(
-            array_name="q",
-            index=2,
-            position=5,
-            gate_name="H",
-            message="Test message",
-        )
-
-        s = str(violation)
-        assert "q[2]" in s
-        assert "position 5" in s
-        assert "Test message" in s
-
-
-class TestValidatorClass:
-    """Tests for QubitStateValidator class directly."""
-
-    def test_validator_reusable(self) -> None:
-        """Validator can be reused for multiple blocks."""
-        validator = QubitStateValidator(strict=True)
-
-        prog1 = Main(
-            q := QReg("q", 1),
-            qb.H(q[0]),
-        )
-
-        prog2 = Main(
-            q := QReg("q", 1),
-            qb.Prep(q[0]),
-            qb.H(q[0]),
-        )
-
-        violations1 = validator.validate(prog1)
-        violations2 = validator.validate(prog2)
-
-        assert len(violations1) == 1
-        assert len(violations2) == 0
-
-    def test_strict_flag(self) -> None:
-        """Strict flag controls initial state assumption."""
-        prog = Main(
-            q := QReg("q", 1),
-            qb.H(q[0]),
-        )
-
-        strict_validator = QubitStateValidator(strict=True)
-        non_strict_validator = QubitStateValidator(strict=False)
-
-        variable_context = {"q": prog.vars.get("q")}
-
-        strict_violations = strict_validator.validate(prog)
-        non_strict_violations = non_strict_validator.validate(prog, variable_context)
-
-        assert len(strict_violations) == 1
-        assert len(non_strict_violations) == 0
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/demo_improvements.py b/python/quantum-pecos/tests/slr_tests/guppy/demo_improvements.py
deleted file mode 100644
index 9c50d392b..000000000
--- a/python/quantum-pecos/tests/slr_tests/guppy/demo_improvements.py
+++ /dev/null
@@ -1,168 +0,0 @@
-"""Demonstration of SLR to Guppy improvements.
-
-This script shows how the three improvements work together to produce
-better code generation with precise, element-level analysis.
-"""
-
-from pecos.slr import CReg, If, Main, QReg
-from pecos.slr.gen_codes.guppy.data_flow import DataFlowAnalyzer
-from pecos.slr.gen_codes.guppy.ir_analyzer import IRAnalyzer
-from pecos.slr.qeclib import qubit
-
-
-def demo_scenario(name: str, prog: Main, variables: dict) -> None:
-    """Demonstrate analysis for a scenario."""
-    print(f"\n{'='*70}")
-    print(f"Scenario: {name}")
-    print(f"{'='*70}\n")
-
-    # Run data flow analysis
-    data_flow_analyzer = DataFlowAnalyzer()
-    data_flow = data_flow_analyzer.analyze(prog, variables)
-
-    # Run IR analysis (which integrates data flow)
-    ir_analyzer = IRAnalyzer()
-    ir_analyzer.analyze_block(prog, variables)
-
-    # Show results for each array
-    for array_name in sorted(variables.keys()):
-        if array_name in ir_analyzer.array_info:
-            info = ir_analyzer.array_info[array_name]
-            print(
-                f"\nArray '{array_name}' (size={info.size}, classical={info.is_classical})",
-            )
-            print(f"  Element accesses: {sorted(info.element_accesses)}")
-            print(f"  Elements consumed: {sorted(info.elements_consumed)}")
-
-            # NEW: Show precise conditional tracking
-            if hasattr(info, "conditionally_accessed_elements"):
-                print(
-                    f"  Conditionally accessed: {sorted(info.conditionally_accessed_elements)}",
-                )
-
-            # Show data flow insights
-            requires_unpacking_flow = data_flow.array_requires_unpacking(array_name)
-            requires_unpacking_decision = info.needs_unpacking
-
-            print(f"  Data flow says unpack: {requires_unpacking_flow}")
-            print(f"  Decision tree says unpack: {requires_unpacking_decision}")
-
-            if requires_unpacking_decision:
-                print("  WILL be unpacked")
-            else:
-                print("  Will NOT be unpacked")
-
-
-def main() -> None:
-    """Run all demonstration scenarios."""
-    print("\n" + "=" * 70)
-    print("SLR TO GUPPY IMPROVEMENTS DEMONSTRATION")
-    print("=" * 70)
-    print("\nShowing how the three improvements work together:")
-    print("1. Rule-Based Decision Tree")
-    print("2. Data Flow Analysis")
-    print("3. Conditional Refinement")
-
-    # Scenario 1: Syndrome Extraction (False positive eliminated!)
-    print("\n" + "=" * 70)
-    print("IMPROVEMENT: Syndrome extraction no longer causes false positives")
-    print("=" * 70)
-
-    prog1 = Main(
-        data := QReg("data", 3),
-        ancilla := QReg("ancilla", 2),
-        syndrome := CReg("syndrome", 2),
-        # Entangle
-        qubit.CX(data[0], ancilla[0]),
-        qubit.CX(data[1], ancilla[0]),
-        # Measure ancillas
-        qubit.Measure(ancilla[0]) > syndrome[0],
-        qubit.Measure(ancilla[1]) > syndrome[1],
-        # Continue using data qubits (different from ancillas!)
-        qubit.H(data[0]),
-        qubit.H(data[1]),
-    )
-
-    demo_scenario(
-        "Syndrome Extraction",
-        prog1,
-        {"data": data, "ancilla": ancilla, "syndrome": syndrome},
-    )
-
-    print("\nBEFORE: Would unpack 'data' (false positive)")
-    print("AFTER: 'data' NOT unpacked (correct!)")
-
-    # Scenario 2: Partial Conditional (Element-level precision!)
-    print("\n" + "=" * 70)
-    print("IMPROVEMENT: Only conditionally accessed elements tracked")
-    print("=" * 70)
-
-    prog2 = Main(
-        q := QReg("q", 4),
-        c := CReg("c", 1),
-        # Use q[0], q[1], q[2] unconditionally
-        qubit.H(q[0]),
-        qubit.H(q[1]),
-        qubit.H(q[2]),
-        qubit.Measure(q[0]) > c[0],
-        # Only q[3] is conditional
-        If(c[0]).Then(
-            qubit.X(q[3]),
-        ),
-    )
-
-    demo_scenario("Partial Conditional Access", prog2, {"q": q, "c": c})
-
-    print("\nBEFORE: Would mark ALL elements as conditional")
-    print("AFTER: Only q[3] marked as conditional (precise!)")
-
-    # Scenario 3: Measure-Prep-Use (Replacement tracked!)
-    print("\n" + "=" * 70)
-    print("IMPROVEMENT: Prep replacement tracked in data flow")
-    print("=" * 70)
-
-    prog3 = Main(
-        q := QReg("q", 1),
-        c := CReg("c", 1),
-        qubit.H(q[0]),
-        qubit.Measure(q[0]) > c[0],
-        qubit.Prep(q[0]),  # Replacement!
-        qubit.H(q[0]),  # Use after replacement - OK!
-    )
-
-    demo_scenario("Measure-Prep-Use Pattern", prog3, {"q": q, "c": c})
-
-    print("\nBEFORE: Would unpack 'q' (false positive)")
-    print("AFTER: 'q' NOT unpacked because of Prep (correct!)")
-
-    # Scenario 4: Different Element Usage (Element-level tracking!)
-    print("\n" + "=" * 70)
-    print("IMPROVEMENT: Different elements tracked separately")
-    print("=" * 70)
-
-    prog4 = Main(
-        q := QReg("q", 3),
-        c := CReg("c", 1),
-        qubit.Measure(q[0]) > c[0],  # Measure q[0]
-        qubit.X(q[1]),  # Use q[1] (different!)
-        qubit.H(q[2]),  # Use q[2] (different!)
-    )
-
-    demo_scenario("Different Element Usage", prog4, {"q": q, "c": c})
-
-    print("\nBEFORE: Would unpack 'q' (operation after measurement)")
-    print("AFTER: 'q' NOT unpacked (different elements!)")
-
-    print("\n" + "=" * 70)
-    print("DEMONSTRATION COMPLETE")
-    print("=" * 70)
-    print("\nKey Improvements:")
-    print("1. Element-level precision (not array-level)")
-    print("2. Data flow tracking (replacement detection)")
-    print("3. Conditional refinement (specific indices)")
-    print("4. Rule-based decisions (explainable)")
-    print()
-
-
-if __name__ == "__main__":
-    main()
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/demo_unpacking_rules.py b/python/quantum-pecos/tests/slr_tests/guppy/demo_unpacking_rules.py
deleted file mode 100644
index 853378f64..000000000
--- a/python/quantum-pecos/tests/slr_tests/guppy/demo_unpacking_rules.py
+++ /dev/null
@@ -1,103 +0,0 @@
-"""Demonstration of the rule-based unpacking decision tree.
-
-This script shows how the new system provides clear, explainable decisions
-about array unpacking, replacing the complex heuristic logic.
-"""
-
-from pecos.slr.gen_codes.guppy.ir_analyzer import ArrayAccessInfo
-from pecos.slr.gen_codes.guppy.unpacking_rules import should_unpack_array
-
-
-def demo_scenario(name: str, info: ArrayAccessInfo) -> None:
-    """Demonstrate unpacking decision for a scenario."""
-    print(f"\n{'='*70}")
-    print(f"Scenario: {name}")
-    print(f"{'='*70}")
-    print(f"Array: {info.array_name} (size={info.size}, classical={info.is_classical})")
-    print(f"Element accesses: {sorted(info.element_accesses)}")
-    print(f"Elements consumed: {sorted(info.elements_consumed)}")
-    print(f"Full array accesses: {info.full_array_accesses}")
-    print(f"Has operations between: {info.has_operations_between}")
-    print(f"Has conditionals between: {info.has_conditionals_between}")
-    print()
-
-    # Get decision with verbose output
-    should_unpack_array(info, verbose=True)
-
-
-def main() -> None:
-    """Run demonstrations of various scenarios."""
-    print("\n" + "=" * 70)
-    print("RULE-BASED UNPACKING DECISION TREE DEMONSTRATION")
-    print("=" * 70)
-
-    # Scenario 1: Full array measurement
-    info1 = ArrayAccessInfo(array_name="q", size=5, is_classical=False)
-    info1.full_array_accesses.append(10)
-    info1.element_accesses.add(0)  # Also has individual access
-    demo_scenario("Full Array Measurement (prevents unpacking)", info1)
-
-    # Scenario 2: Individual quantum measurements
-    info2 = ArrayAccessInfo(array_name="q", size=3, is_classical=False)
-    info2.element_accesses.add(0)
-    info2.element_accesses.add(1)
-    info2.elements_consumed.add(0)
-    info2.elements_consumed.add(1)
-    demo_scenario("Individual Quantum Measurements (requires unpacking)", info2)
-
-    # Scenario 3: Operations after measurement
-    info3 = ArrayAccessInfo(array_name="q", size=3, is_classical=False)
-    info3.element_accesses.add(0)
-    info3.elements_consumed.add(0)
-    info3.has_operations_between = True
-    demo_scenario("Operations After Measurement (requires unpacking)", info3)
-
-    # Scenario 4: Conditional access
-    info4 = ArrayAccessInfo(array_name="c", size=4, is_classical=True)
-    info4.element_accesses.add(0)
-    info4.element_accesses.add(1)
-    info4.has_conditionals_between = True
-    demo_scenario("Conditional Element Access (requires unpacking)", info4)
-
-    # Scenario 5: Single element only
-    info5 = ArrayAccessInfo(array_name="q", size=5, is_classical=False)
-    info5.element_accesses.add(2)
-    demo_scenario("Single Element Access (use direct indexing)", info5)
-
-    # Scenario 6: Multiple classical accesses
-    info6 = ArrayAccessInfo(array_name="c", size=4, is_classical=True)
-    info6.element_accesses.add(0)
-    info6.element_accesses.add(1)
-    info6.element_accesses.add(2)
-    demo_scenario("Multiple Classical Accesses (cleaner when unpacked)", info6)
-
-    # Scenario 7: Partial array usage (high ratio)
-    info7 = ArrayAccessInfo(array_name="q", size=5, is_classical=False)
-    info7.element_accesses.add(0)
-    info7.element_accesses.add(2)
-    info7.element_accesses.add(4)
-    demo_scenario("Partial Array Usage - High Ratio (60%)", info7)
-
-    # Scenario 8: Partial array usage (low ratio)
-    info8 = ArrayAccessInfo(array_name="q", size=10, is_classical=False)
-    info8.element_accesses.add(0)
-    info8.element_accesses.add(5)
-    demo_scenario("Partial Array Usage - Low Ratio (20%)", info8)
-
-    # Scenario 9: No individual access
-    info9 = ArrayAccessInfo(array_name="q", size=5, is_classical=False)
-    demo_scenario("No Individual Element Access", info9)
-
-    print("\n" + "=" * 70)
-    print("DEMONSTRATION COMPLETE")
-    print("=" * 70)
-    print("\nKey Improvements:")
-    print("1. Clear, explainable decisions with reasoning")
-    print("2. Explicit rules instead of complex heuristics")
-    print("3. Easy to test and validate each rule")
-    print("4. Maintainable and extensible")
-    print()
-
-
-if __name__ == "__main__":
-    main()
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_allocation_optimization.py b/python/quantum-pecos/tests/slr_tests/guppy/test_allocation_optimization.py
deleted file mode 100644
index f6064ef38..000000000
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_allocation_optimization.py
+++ /dev/null
@@ -1,188 +0,0 @@
-"""Test allocation optimization in Guppy code generation."""
-
-from pecos.slr import CReg, For, If, Main, QReg
-from pecos.slr.gen_codes.guppy.ir_generator import IRGuppyGenerator
-from pecos.slr.qeclib import qubit
-from pecos.slr.qeclib.qubit.measures import Measure
-
-
-def test_short_lived_ancilla_optimization() -> None:
-    """Test that short-lived ancilla qubits are allocated locally."""
-    prog = Main(
-        data := QReg("data", 3),
-        ancilla := QReg("ancilla", 2),
-        temp1 := CReg("temp1", 1),
-        temp2 := CReg("temp2", 1),
-        results := CReg("results", 3),
-        # Use data normally
-        qubit.H(data[0]),
-        qubit.CX(data[0], data[1]),
-        # Short-lived ancilla use - should be optimized
-        qubit.H(ancilla[0]),
-        Measure(ancilla[0]) > temp1[0],
-        # Another short-lived use - should be optimized
-        qubit.X(ancilla[1]),
-        Measure(ancilla[1]) > temp2[0],
-        # Measure data
-        Measure(data) > results,
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Check for unified resource planning report
-    assert "UNIFIED RESOURCE PLANNING REPORT" in code or "Optimization Report" in code
-    # Should have optimization analysis (unified or allocation report)
-    assert "short-lived" in code.lower() or "local allocation" in code.lower()
-
-
-def test_reused_ancilla_no_optimization() -> None:
-    """Test that reused ancilla qubits are not optimized (allocated upfront)."""
-    prog = Main(
-        data := QReg("data", 2),
-        ancilla := QReg("ancilla", 1),
-        temp1 := CReg("temp1", 1),
-        temp2 := CReg("temp2", 1),
-        results := CReg("results", 2),
-        # First use of ancilla
-        qubit.H(ancilla[0]),
-        qubit.CX(data[0], ancilla[0]),
-        Measure(ancilla[0]) > temp1[0],
-        # Reuse the same ancilla - should prevent optimization
-        qubit.X(ancilla[0]),
-        qubit.CZ(data[1], ancilla[0]),
-        Measure(ancilla[0]) > temp2[0],
-        Measure(data) > results,
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Should not optimize reused qubits
-    # Unified report shows "need replacement" or old report shows "reused after consumption"
-    assert (
-        "reused after consumption" in code.lower()
-        or "pre_allocate" in code
-        or "need replacement" in code.lower()
-        or "UNPACKED_PREALLOCATED" in code
-    )
-
-
-def test_mixed_allocation_strategy() -> None:
-    """Test mixed allocation where some elements are local, others pre-allocated."""
-    prog = Main(
-        mixed := QReg("mixed", 4),
-        long_lived := CReg("long_lived", 1),
-        short1 := CReg("short1", 1),
-        short2 := CReg("short2", 1),
-        results := CReg("results", 3),
-        # Long-lived use of mixed[0] - should be pre-allocated
-        qubit.H(mixed[0]),
-        qubit.CX(mixed[0], mixed[1]),
-        qubit.CZ(mixed[0], mixed[2]),
-        qubit.H(mixed[0]),
-        Measure(mixed[0]) > long_lived[0],
-        # Short-lived use of mixed[1] - could be local
-        qubit.X(mixed[1]),
-        Measure(mixed[1]) > short1[0],
-        # Short-lived use of mixed[2] - could be local
-        qubit.Y(mixed[2]),
-        Measure(mixed[2]) > short2[0],
-        # Never use mixed[3] - should be noted
-        Measure(mixed[0:3]) > results,
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Should have optimization or unified planning report
-    assert "UNIFIED RESOURCE PLANNING REPORT" in code or "Optimization Report" in code
-
-
-def test_conditional_scope_prevents_optimization() -> None:
-    """Test that qubits used in conditionals are not optimized."""
-    prog = Main(
-        q := QReg("q", 2),
-        flag := CReg("flag", 1),
-        conditional_result := CReg("conditional_result", 1),
-        Measure(q[0]) > flag[0],
-        If(flag[0]).Then(
-            # This use is in a conditional scope - should prevent optimization
-            qubit.X(q[1]),
-            Measure(q[1]) > conditional_result[0],
-        ),
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Should have optimization or unified planning report
-    assert "UNIFIED RESOURCE PLANNING REPORT" in code or "Optimization Report" in code
-
-
-def test_loop_scope_prevents_optimization() -> None:
-    """Test that qubits used in loops are not optimized."""
-    prog = Main(
-        q := QReg("q", 3),
-        results := CReg("results", 3),
-        For("i", 0, 3).Do(
-            # This use is in a loop scope - should prevent optimization
-            qubit.H(q[0]),
-            qubit.X(q[1]),
-        ),
-        Measure(q) > results,
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Should have optimization or unified planning report
-    assert "UNIFIED RESOURCE PLANNING REPORT" in code or "Optimization Report" in code
-
-
-def test_optimization_report_generation() -> None:
-    """Test that optimization reports are generated correctly."""
-    prog = Main(
-        simple := QReg("simple", 2),
-        result1 := CReg("result1", 1),
-        result2 := CReg("result2", 1),
-        # Simple pattern - allocate and immediately measure
-        qubit.H(simple[0]),
-        Measure(simple[0]) > result1[0],
-        qubit.X(simple[1]),
-        Measure(simple[1]) > result2[0],
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Should have detailed optimization or unified planning report
-    assert "UNIFIED RESOURCE PLANNING REPORT" in code or "=== Qubit Allocation Optimization Report ===" in code
-    assert "simple" in code.lower()  # Array name mentioned
-    assert "Strategy:" in code
-
-
-def test_never_used_qubits() -> None:
-    """Test detection of never-used qubits."""
-    prog = Main(
-        used := QReg("used", 1),
-        _unused := QReg("unused", 2),
-        results := CReg("results", 1),
-        # Only use one register
-        qubit.H(used[0]),
-        Measure(used) > results,
-        # unused register is never touched
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Should detect unused qubits
-    assert "never used" in code.lower() or "unused" in code.lower()
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_complex_permutations.py b/python/quantum-pecos/tests/slr_tests/guppy/test_complex_permutations.py
deleted file mode 100644
index e0db28770..000000000
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_complex_permutations.py
+++ /dev/null
@@ -1,172 +0,0 @@
-"""Test complex permutation patterns in quantum circuits."""
-
-from pecos.slr import CReg, Main, Permute, QReg
-from pecos.slr.gen_codes.guppy.ir_generator import IRGuppyGenerator
-from pecos.slr.qeclib import qubit
-from pecos.slr.qeclib.qubit.measures import Measure
-
-
-def test_permute_identity() -> None:
-    """Test identity permutation (no change)."""
-    prog = Main(
-        q := QReg("q", 3),
-        # Identity permutation
-        Permute([q[0], q[1], q[2]], [q[0], q[1], q[2]]),
-        Measure(q) > CReg("c", 3),
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Identity permutation should be recognized
-    # Currently generates cycles but they're all fixed points
-    assert "quantum.measure_array(q)" in code
-
-
-def test_permute_reverse() -> None:
-    """Test reversing array elements."""
-    prog = Main(
-        q := QReg("q", 5),
-        # Initialize with pattern
-        qubit.X(q[0]),
-        qubit.Y(q[1]),
-        qubit.Z(q[2]),
-        qubit.H(q[3]),
-        qubit.SZ(q[4]),
-        # Reverse the array
-        Permute([q[0], q[1], q[2], q[3], q[4]], [q[4], q[3], q[2], q[1], q[0]]),
-        Measure(q) > CReg("c", 5),
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Should generate swaps
-    assert "_temp_swap" in code
-    assert "# Permute 5 elements" in code
-
-
-def test_permute_rotate() -> None:
-    """Test rotation of elements."""
-    prog = Main(
-        q := QReg("q", 4),
-        # Rotate left by 1: [0,1,2,3] -> [1,2,3,0]
-        Permute([q[0], q[1], q[2], q[3]], [q[1], q[2], q[3], q[0]]),
-        Measure(q) > CReg("c", 4),
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Should generate a cycle
-    assert "_temp_cycle" in code
-
-
-def test_permute_complex_pattern() -> None:
-    """Test complex permutation with multiple cycles."""
-    prog = Main(
-        a := QReg("a", 6),
-        # Complex permutation:
-        # 0->2, 2->4, 4->0 (cycle 1)
-        # 1->3, 3->5, 5->1 (cycle 2)
-        Permute(
-            [a[0], a[1], a[2], a[3], a[4], a[5]],
-            [a[2], a[3], a[4], a[5], a[0], a[1]],
-        ),
-        Measure(a) > CReg("c", 6),
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Should have permutation operations
-    assert "# Permute 6 elements" in code
-    assert "_temp_" in code  # Either swap or cycle
-
-
-def test_permute_partial_registers() -> None:
-    """Test permuting parts of different registers."""
-    prog = Main(
-        x := QReg("x", 3),
-        y := QReg("y", 3),
-        # Mix elements from both registers
-        Permute([x[0], x[1], y[0], y[1]], [y[1], x[0], y[0], x[1]]),
-        Measure(x) > CReg("cx", 3),
-        Measure(y) > CReg("cy", 3),
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Should handle cross-register permutations
-    assert "# Permute 4 elements" in code
-
-
-def test_permute_with_gates() -> None:
-    """Test permutation interleaved with quantum gates."""
-    prog = Main(
-        q := QReg("q", 3),
-        # Initial gates
-        qubit.H(q[0]),
-        qubit.CX(q[0], q[1]),
-        # First permutation: rotate
-        Permute([q[0], q[1], q[2]], [q[1], q[2], q[0]]),
-        # More gates on permuted qubits
-        qubit.CX(q[0], q[1]),  # Now acts on what was q[1] and q[2]
-        # Second permutation: swap first two
-        Permute([q[0], q[1], q[2]], [q[1], q[0], q[2]]),
-        Measure(q) > CReg("c", 3),
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Should have multiple permutations
-    assert code.count("# Permute") >= 2
-
-
-def test_permute_error_mismatched_elements() -> None:
-    """Test error handling for mismatched element lists."""
-    prog = Main(
-        a := QReg("a", 3),
-        b := QReg("b", 2),
-        # Try to permute with different elements
-        Permute([a[0], a[1], a[2]], [b[0], b[1], a[0]]),
-        Measure(a) > CReg("ca", 3),
-        Measure(b) > CReg("cb", 2),
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Should generate error comment
-    assert "ERROR: Invalid permutation" in code
-
-
-def test_permute_single_cycle() -> None:
-    """Test single large cycle permutation."""
-    prog = Main(
-        q := QReg("q", 7),
-        # Single cycle touching all elements: 0->1->2->3->4->5->6->0
-        Permute(
-            [q[0], q[1], q[2], q[3], q[4], q[5], q[6]],
-            [q[1], q[2], q[3], q[4], q[5], q[6], q[0]],
-        ),
-        Measure(q) > CReg("c", 7),
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Should use cycle temporary
-    assert "_temp_cycle" in code
-    # Should have exactly 7 assignments in the cycle
-    assert code.count(" = q[") == 7  # 6 shifts + 1 from temp
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_conditional_refinement.py b/python/quantum-pecos/tests/slr_tests/guppy/test_conditional_refinement.py
deleted file mode 100644
index a696c4536..000000000
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_conditional_refinement.py
+++ /dev/null
@@ -1,297 +0,0 @@
-"""Test suite for refined conditional analysis.
-
-This tests the improvement where we track WHICH specific elements are
-conditionally accessed, rather than marking the entire array as conditional.
-"""
-
-from pecos.slr import CReg, If, Main, QReg
-from pecos.slr.gen_codes.guppy.ir_analyzer import IRAnalyzer
-from pecos.slr.qeclib import qubit
-
-
-class TestConditionalElementTracking:
-    """Test element-level conditional access tracking."""
-
-    def test_single_element_conditional(self) -> None:
-        """Only one element conditional - shouldn't affect others."""
-        prog = Main(
-            q := QReg("q", 3),
-            c := CReg("c", 1),
-            qubit.Measure(q[0]) > c[0],
-            If(c[0]).Then(
-                qubit.X(q[1]),  # Only q[1] is conditional
-            ),
-            qubit.H(q[2]),  # q[2] is not conditional
-        )
-
-        analyzer = IRAnalyzer()
-        analyzer.analyze_block(prog, {"q": q, "c": c})
-
-        # Check that we track which specific elements are conditional
-        q_info = analyzer.array_info["q"]
-        assert hasattr(q_info, "conditionally_accessed_elements")
-        assert 1 in q_info.conditionally_accessed_elements  # q[1] is conditional
-        assert 2 not in q_info.conditionally_accessed_elements  # q[2] is not
-
-    def test_multiple_elements_conditional(self) -> None:
-        """Multiple elements conditional - track all of them."""
-        prog = Main(
-            q := QReg("q", 4),
-            c := CReg("c", 2),
-            qubit.Measure(q[0]) > c[0],
-            qubit.Measure(q[1]) > c[1],
-            If(c[0]).Then(
-                qubit.X(q[2]),  # q[2] conditional on c[0]
-            ),
-            If(c[1]).Then(
-                qubit.Z(q[3]),  # q[3] conditional on c[1]
-            ),
-        )
-
-        analyzer = IRAnalyzer()
-        analyzer.analyze_block(prog, {"q": q, "c": c})
-
-        q_info = analyzer.array_info["q"]
-        assert 2 in q_info.conditionally_accessed_elements
-        assert 3 in q_info.conditionally_accessed_elements
-        # q[0] and q[1] are measured but not used conditionally after
-        assert 0 not in q_info.conditionally_accessed_elements
-        assert 1 not in q_info.conditionally_accessed_elements
-
-    def test_classical_element_in_condition(self) -> None:
-        """Classical element used in condition."""
-        prog = Main(
-            q := QReg("q", 2),
-            c := CReg("c", 3),
-            qubit.Measure(q[0]) > c[0],
-            qubit.Measure(q[1]) > c[1],
-            If(c[0]).Then(  # c[0] is in condition
-                qubit.X(q[0]),
-            ),
-        )
-
-        analyzer = IRAnalyzer()
-        analyzer.analyze_block(prog, {"q": q, "c": c})
-
-        c_info = analyzer.array_info["c"]
-        assert 0 in c_info.conditionally_accessed_elements  # c[0] in condition
-        assert 1 not in c_info.conditionally_accessed_elements  # c[1] not in condition
-        assert 2 not in c_info.conditionally_accessed_elements  # c[2] never used
-
-    def test_nested_conditionals(self) -> None:
-        """Nested conditional blocks."""
-        prog = Main(
-            q := QReg("q", 3),
-            c := CReg("c", 2),
-            qubit.Measure(q[0]) > c[0],
-            qubit.Measure(q[1]) > c[1],
-            If(c[0]).Then(
-                If(c[1]).Then(
-                    qubit.X(q[2]),  # q[2] conditional on both
-                ),
-            ),
-        )
-
-        analyzer = IRAnalyzer()
-        analyzer.analyze_block(prog, {"q": q, "c": c})
-
-        c_info = analyzer.array_info["c"]
-        q_info = analyzer.array_info["q"]
-
-        # Both c[0] and c[1] are in conditions
-        assert 0 in c_info.conditionally_accessed_elements
-        assert 1 in c_info.conditionally_accessed_elements
-
-        # q[2] is conditionally accessed
-        assert 2 in q_info.conditionally_accessed_elements
-
-
-class TestConditionalUnpackingDecisions:
-    """Test that unpacking decisions use refined conditional tracking."""
-
-    def test_no_unpacking_for_non_conditional_elements(self) -> None:
-        """Elements not used conditionally shouldn't force unpacking."""
-        prog = Main(
-            q := QReg("q", 3),
-            c := CReg("c", 1),
-            # Use q[0] and q[1] normally (not conditional)
-            qubit.H(q[0]),
-            qubit.CX(q[0], q[1]),
-            qubit.Measure(q[0]) > c[0],
-            # Only q[2] is conditional
-            If(c[0]).Then(
-                qubit.X(q[2]),
-            ),
-        )
-
-        analyzer = IRAnalyzer()
-        plan = analyzer.analyze_block(prog, {"q": q, "c": c})
-
-        # q should be unpacked because q[2] is conditionally accessed
-        # But the decision should note that it's only because of q[2]
-        q_info = analyzer.array_info["q"]
-        assert q_info.conditionally_accessed_elements == {2}
-
-        # Verify unpacking happens (because of q[2])
-        assert "q" in plan.arrays_to_unpack
-
-    def test_unpacking_only_when_necessary(self) -> None:
-        """Don't unpack if conditional element not in element_accesses."""
-        prog = Main(
-            q := QReg("q", 2),
-            c := CReg("c", 1),
-            qubit.H(q[0]),
-            qubit.Measure(q[0]) > c[0],
-            # c[0] is in condition, but we don't access q elements conditionally
-            If(c[0]).Then(
-                # Empty then block
-            ),
-        )
-
-        analyzer = IRAnalyzer()
-        analyzer.analyze_block(prog, {"q": q, "c": c})
-
-        c_info = analyzer.array_info["c"]
-        # c[0] is in condition
-        assert 0 in c_info.conditionally_accessed_elements
-        # But since only one element (c[0]) and it's just in condition,
-        # unpacking decision depends on other rules
-
-    def test_mixed_conditional_and_unconditional(self) -> None:
-        """Mix of conditional and unconditional access."""
-        prog = Main(
-            q := QReg("q", 4),
-            c := CReg("c", 2),
-            # Unconditional uses
-            qubit.H(q[0]),
-            qubit.H(q[1]),
-            # Measurements
-            qubit.Measure(q[2]) > c[0],
-            qubit.Measure(q[3]) > c[1],
-            # Conditional uses
-            If(c[0]).Then(
-                qubit.X(q[0]),  # q[0] used both unconditionally and conditionally
-            ),
-            If(c[1]).Then(
-                qubit.Z(q[1]),  # q[1] used both unconditionally and conditionally
-            ),
-        )
-
-        analyzer = IRAnalyzer()
-        analyzer.analyze_block(prog, {"q": q, "c": c})
-
-        q_info = analyzer.array_info["q"]
-        # q[0] and q[1] are conditionally accessed
-        assert 0 in q_info.conditionally_accessed_elements
-        assert 1 in q_info.conditionally_accessed_elements
-        # q[2] and q[3] are measured but not used after
-        assert 2 not in q_info.conditionally_accessed_elements
-        assert 3 not in q_info.conditionally_accessed_elements
-
-
-class TestConditionalImprovements:
-    """Test specific improvements from refined conditional analysis."""
-
-    def test_syndrome_with_partial_conditional(self) -> None:
-        """Syndrome extraction with only some qubits conditional."""
-        prog = Main(
-            data := QReg("data", 3),
-            ancilla := QReg("ancilla", 2),
-            syndrome := CReg("syndrome", 2),
-            # Entangle
-            qubit.CX(data[0], ancilla[0]),
-            qubit.CX(data[1], ancilla[0]),
-            qubit.CX(data[1], ancilla[1]),
-            qubit.CX(data[2], ancilla[1]),
-            # Measure
-            qubit.Measure(ancilla[0]) > syndrome[0],
-            qubit.Measure(ancilla[1]) > syndrome[1],
-            # Conditional correction on only ONE data qubit
-            If(syndrome[0]).Then(
-                qubit.X(data[0]),  # Only data[0] is conditional
-            ),
-            # data[1] and data[2] are NOT conditional
-            qubit.H(data[1]),
-            qubit.H(data[2]),
-        )
-
-        analyzer = IRAnalyzer()
-        analyzer.analyze_block(
-            prog,
-            {"data": data, "ancilla": ancilla, "syndrome": syndrome},
-        )
-
-        data_info = analyzer.array_info["data"]
-        # Only data[0] should be marked as conditional
-        assert 0 in data_info.conditionally_accessed_elements
-        assert 1 not in data_info.conditionally_accessed_elements
-        assert 2 not in data_info.conditionally_accessed_elements
-
-    def test_teleportation_pattern(self) -> None:
-        """Quantum teleportation with bob corrections."""
-        prog = Main(
-            alice := QReg("alice", 1),
-            bob := QReg("bob", 1),
-            epr := QReg("epr", 1),
-            c := CReg("c", 2),
-            # EPR pair
-            qubit.H(epr[0]),
-            qubit.CX(epr[0], bob[0]),
-            # Alice's operations
-            qubit.CX(alice[0], epr[0]),
-            qubit.H(alice[0]),
-            # Measurements
-            qubit.Measure(alice[0]) > c[0],
-            qubit.Measure(epr[0]) > c[1],
-            # Bob's corrections - bob[0] is conditional
-            If(c[1]).Then(
-                qubit.X(bob[0]),
-            ),
-            If(c[0]).Then(
-                qubit.Z(bob[0]),
-            ),
-        )
-
-        analyzer = IRAnalyzer()
-        analyzer.analyze_block(
-            prog,
-            {"alice": alice, "bob": bob, "epr": epr, "c": c},
-        )
-
-        bob_info = analyzer.array_info["bob"]
-        c_info = analyzer.array_info["c"]
-
-        # bob[0] is conditionally accessed
-        assert 0 in bob_info.conditionally_accessed_elements
-
-        # c[0] and c[1] are in conditions
-        assert 0 in c_info.conditionally_accessed_elements
-        assert 1 in c_info.conditionally_accessed_elements
-
-    def test_partial_array_conditional_vs_full(self) -> None:
-        """Verify we don't mark entire array when only part is conditional."""
-        prog = Main(
-            q := QReg("q", 5),
-            c := CReg("c", 1),
-            # Use q[0], q[1], q[2] unconditionally
-            qubit.H(q[0]),
-            qubit.H(q[1]),
-            qubit.H(q[2]),
-            qubit.Measure(q[0]) > c[0],
-            # Only q[3] is conditional
-            If(c[0]).Then(
-                qubit.X(q[3]),
-            ),
-            # q[4] is never used
-        )
-
-        analyzer = IRAnalyzer()
-        analyzer.analyze_block(prog, {"q": q, "c": c})
-
-        q_info = analyzer.array_info["q"]
-
-        # Only q[3] should be conditional
-        assert q_info.conditionally_accessed_elements == {3}
-
-        # All used elements should be in element_accesses
-        assert q_info.element_accesses == {0, 1, 2, 3}
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_data_flow.py b/python/quantum-pecos/tests/slr_tests/guppy/test_data_flow.py
deleted file mode 100644
index ed73be50f..000000000
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_data_flow.py
+++ /dev/null
@@ -1,296 +0,0 @@
-"""Test suite for data flow analysis."""
-
-from pecos.slr import CReg, If, Main, QReg
-from pecos.slr.gen_codes.guppy.data_flow import DataFlowAnalyzer
-from pecos.slr.qeclib import qubit
-
-
-class TestDataFlowBasics:
-    """Test basic data flow tracking."""
-
-    def test_simple_gate_no_measurement(self) -> None:
-        """Gates without measurement don't require unpacking."""
-        prog = Main(
-            q := QReg("q", 3),
-            qubit.H(q[0]),
-            qubit.CX(q[0], q[1]),
-            qubit.H(q[2]),
-        )
-
-        analyzer = DataFlowAnalyzer()
-        analysis = analyzer.analyze(prog, {"q": q})
-
-        # No measurements, so no unpacking needed
-        assert not analysis.array_requires_unpacking("q")
-        assert len(analysis.elements_requiring_unpacking()) == 0
-
-    def test_measurement_only_no_reuse(self) -> None:
-        """Measurement without reuse doesn't require unpacking."""
-        prog = Main(
-            q := QReg("q", 2),
-            c := CReg("c", 2),
-            qubit.H(q[0]),
-            qubit.Measure(q[0]) > c[0],
-            qubit.Measure(q[1]) > c[1],
-        )
-
-        analyzer = DataFlowAnalyzer()
-        analysis = analyzer.analyze(prog, {"q": q, "c": c})
-
-        # Measurements but no reuse after measurement
-        assert not analysis.array_requires_unpacking("q")
-        assert len(analysis.elements_requiring_unpacking()) == 0
-
-    def test_measure_then_use_same_qubit(self) -> None:
-        """Measuring then using the same qubit REQUIRES unpacking."""
-        prog = Main(
-            q := QReg("q", 2),
-            c := CReg("c", 2),
-            qubit.H(q[0]),
-            qubit.Measure(q[0]) > c[0],
-            qubit.X(q[0]),  # Use after measurement - requires unpacking!
-        )
-
-        analyzer = DataFlowAnalyzer()
-        analysis = analyzer.analyze(prog, {"q": q, "c": c})
-
-        # q[0] is used after measurement - requires unpacking
-        assert analysis.array_requires_unpacking("q")
-        requiring = analysis.elements_requiring_unpacking()
-        assert ("q", 0) in requiring
-        assert ("q", 1) not in requiring
-
-    def test_measure_then_use_different_qubit(self) -> None:
-        """Measuring one qubit then using a different qubit is fine."""
-        prog = Main(
-            q := QReg("q", 2),
-            c := CReg("c", 2),
-            qubit.H(q[0]),
-            qubit.Measure(q[0]) > c[0],
-            qubit.X(q[1]),  # Different qubit - no problem!
-        )
-
-        analyzer = DataFlowAnalyzer()
-        analysis = analyzer.analyze(prog, {"q": q, "c": c})
-
-        # q[0] measured, q[1] used - no unpacking needed
-        assert not analysis.array_requires_unpacking("q")
-        assert len(analysis.elements_requiring_unpacking()) == 0
-
-    def test_measure_prep_then_use(self) -> None:
-        """Measure, Prep (replacement), then use is OK."""
-        prog = Main(
-            q := QReg("q", 1),
-            c := CReg("c", 1),
-            qubit.H(q[0]),
-            qubit.Measure(q[0]) > c[0],
-            qubit.Prep(q[0]),  # Replacement
-            qubit.H(q[0]),  # Use after replacement - OK!
-        )
-
-        analyzer = DataFlowAnalyzer()
-        analysis = analyzer.analyze(prog, {"q": q, "c": c})
-
-        # Replacement between measurement and use - no unpacking needed
-        assert not analysis.array_requires_unpacking("q")
-        assert len(analysis.elements_requiring_unpacking()) == 0
-
-
-class TestDataFlowConditionals:
-    """Test data flow with conditional operations."""
-
-    def test_conditional_gate(self) -> None:
-        """Conditional gates are tracked."""
-        prog = Main(
-            q := QReg("q", 2),
-            c := CReg("c", 1),
-            qubit.Measure(q[0]) > c[0],
-            If(c[0]).Then(
-                qubit.X(q[1]),  # Conditional on measurement
-            ),
-        )
-
-        analyzer = DataFlowAnalyzer()
-        analysis = analyzer.analyze(prog, {"q": q, "c": c})
-
-        # Conditional access is tracked
-        assert ("c", 0) in analysis.conditional_accesses
-        assert ("q", 1) in analysis.conditional_accesses
-
-    def test_conditional_reset_pattern(self) -> None:
-        """Common error correction pattern: measure, conditionally reset."""
-        prog = Main(
-            q := QReg("q", 1),
-            c := CReg("c", 1),
-            qubit.H(q[0]),
-            qubit.Measure(q[0]) > c[0],
-            If(c[0]).Then(
-                qubit.X(q[0]),  # Conditional flip based on measurement
-            ),
-        )
-
-        analyzer = DataFlowAnalyzer()
-        analysis = analyzer.analyze(prog, {"q": q, "c": c})
-
-        # q[0] is used conditionally after measurement
-        assert analysis.array_requires_unpacking("q")
-        assert ("q", 0) in analysis.elements_requiring_unpacking()
-
-
-class TestDataFlowComplexPatterns:
-    """Test complex data flow patterns."""
-
-    def test_multiple_measurements_different_qubits(self) -> None:
-        """Multiple measurements on different qubits."""
-        prog = Main(
-            q := QReg("q", 4),
-            c := CReg("c", 4),
-            # Measure qubits 0 and 1
-            qubit.Measure(q[0]) > c[0],
-            qubit.Measure(q[1]) > c[1],
-            # Use qubits 2 and 3 (not measured)
-            qubit.H(q[2]),
-            qubit.CX(q[2], q[3]),
-        )
-
-        analyzer = DataFlowAnalyzer()
-        analysis = analyzer.analyze(prog, {"q": q, "c": c})
-
-        # No qubits used after their own measurement
-        assert not analysis.array_requires_unpacking("q")
-        assert len(analysis.elements_requiring_unpacking()) == 0
-
-    def test_syndrome_extraction_pattern(self) -> None:
-        """Syndrome extraction: measure ancillas, use data qubits."""
-        prog = Main(
-            data := QReg("data", 3),
-            ancilla := QReg("ancilla", 2),
-            syndrome := CReg("syndrome", 2),
-            # Entangle
-            qubit.CX(data[0], ancilla[0]),
-            qubit.CX(data[1], ancilla[0]),
-            qubit.CX(data[1], ancilla[1]),
-            qubit.CX(data[2], ancilla[1]),
-            # Measure ancillas
-            qubit.Measure(ancilla[0]) > syndrome[0],
-            qubit.Measure(ancilla[1]) > syndrome[1],
-            # Continue using data qubits
-            qubit.H(data[0]),
-            qubit.H(data[1]),
-            qubit.H(data[2]),
-        )
-
-        analyzer = DataFlowAnalyzer()
-        analysis = analyzer.analyze(
-            prog,
-            {"data": data, "ancilla": ancilla, "syndrome": syndrome},
-        )
-
-        # Ancillas measured but not reused - no unpacking
-        assert not analysis.array_requires_unpacking("ancilla")
-        # Data qubits never measured - no unpacking
-        assert not analysis.array_requires_unpacking("data")
-        assert len(analysis.elements_requiring_unpacking()) == 0
-
-    def test_repeated_measurement_cycle(self) -> None:
-        """Repeated measurement cycles with replacement."""
-        prog = Main(
-            q := QReg("q", 1),
-            c := CReg("c", 3),
-            # Cycle 1
-            qubit.H(q[0]),
-            qubit.Measure(q[0]) > c[0],
-            qubit.Prep(q[0]),
-            # Cycle 2
-            qubit.H(q[0]),
-            qubit.Measure(q[0]) > c[1],
-            qubit.Prep(q[0]),
-            # Cycle 3
-            qubit.H(q[0]),
-            qubit.Measure(q[0]) > c[2],
-        )
-
-        analyzer = DataFlowAnalyzer()
-        analysis = analyzer.analyze(prog, {"q": q, "c": c})
-
-        # Each measurement is followed by Prep before next use
-        # No unpacking needed
-        assert not analysis.array_requires_unpacking("q")
-        assert len(analysis.elements_requiring_unpacking()) == 0
-
-    def test_partial_qubit_reuse(self) -> None:
-        """Some qubits reused after measurement, others not."""
-        prog = Main(
-            q := QReg("q", 3),
-            c := CReg("c", 3),
-            # Measure all
-            qubit.Measure(q[0]) > c[0],
-            qubit.Measure(q[1]) > c[1],
-            qubit.Measure(q[2]) > c[2],
-            # Reuse only q[1]
-            qubit.X(q[1]),  # This one needs unpacking!
-        )
-
-        analyzer = DataFlowAnalyzer()
-        analysis = analyzer.analyze(prog, {"q": q, "c": c})
-
-        # Only q[1] requires unpacking
-        assert analysis.array_requires_unpacking("q")
-        requiring = analysis.elements_requiring_unpacking()
-        assert ("q", 0) not in requiring
-        assert ("q", 1) in requiring
-        assert ("q", 2) not in requiring
-
-
-class TestDataFlowEdgeCases:
-    """Test edge cases in data flow analysis."""
-
-    def test_empty_program(self) -> None:
-        """Empty program."""
-        prog = Main(
-            q := QReg("q", 2),
-        )
-
-        analyzer = DataFlowAnalyzer()
-        analysis = analyzer.analyze(prog, {"q": q})
-
-        assert not analysis.array_requires_unpacking("q")
-        assert len(analysis.elements_requiring_unpacking()) == 0
-
-    def test_measurement_without_storage(self) -> None:
-        """Measurement without storing result."""
-        prog = Main(
-            q := QReg("q", 1),
-            qubit.H(q[0]),
-            qubit.Measure(q[0]),  # No classical storage
-        )
-
-        analyzer = DataFlowAnalyzer()
-        analysis = analyzer.analyze(prog, {"q": q})
-
-        # Measurement tracked even without classical storage
-        flow = analysis.element_flows.get(("q", 0))
-        assert flow is not None
-        assert len(flow.consumed_at) == 1
-
-    def test_use_before_and_after_measurement(self) -> None:
-        """Use before and after measurement."""
-        prog = Main(
-            q := QReg("q", 1),
-            c := CReg("c", 1),
-            qubit.H(q[0]),  # Before
-            qubit.X(q[0]),  # Before
-            qubit.Measure(q[0]) > c[0],
-            qubit.X(q[0]),  # After - requires unpacking!
-        )
-
-        analyzer = DataFlowAnalyzer()
-        analysis = analyzer.analyze(prog, {"q": q, "c": c})
-
-        # Uses before measurement are fine, but use after requires unpacking
-        assert analysis.array_requires_unpacking("q")
-        assert ("q", 0) in analysis.elements_requiring_unpacking()
-
-        # Check that all uses are tracked
-        flow = analysis.element_flows[("q", 0)]
-        assert len(flow.uses) == 4  # H, X, Measure, X
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_hugr_error_messages.py b/python/quantum-pecos/tests/slr_tests/guppy/test_hugr_error_messages.py
deleted file mode 100644
index 1e371a368..000000000
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_hugr_error_messages.py
+++ /dev/null
@@ -1,116 +0,0 @@
-"""Test improved HUGR error messages."""
-
-from pecos.slr import CReg, Main, QReg
-from pecos.slr.qeclib.qubit.measures import Measure
-
-
-def test_place_not_used_error() -> None:
-    """Test improved error message for unconsumed quantum registers."""
-    # Test the error handler directly since our IR generator adds cleanup
-    from pecos.slr.gen_codes.guppy.hugr_error_handler import HugrErrorHandler
-
-    # Code that would fail with PlaceNotUsedError
-    bad_code = """
-@guppy
-def main() -> None:
-    q = array(quantum.qubit() for _ in range(3))
-    c = quantum.measure(q[0])
-    # q[1] and q[2] are not consumed
-"""
-
-    # Create a mock error that guppy would produce
-    mock_error = Exception(
-        "PlaceNotUsedError: Variable(name='q') has not been fully consumed",
-    )
-
-    handler = HugrErrorHandler(bad_code)
-    error_msg = handler.analyze_error(mock_error)
-
-    # print("\nImproved error message:")
-    # print(error_msg)
-
-    # Check that the error message is helpful
-    assert "PlaceNotUsedError" in error_msg
-    assert "was not consumed" in error_msg
-    assert "Add a measurement" in error_msg
-    assert "Example fix:" in error_msg
-    assert "quantum.measure" in error_msg
-
-
-def test_move_out_of_subscript_error() -> None:
-    """Test improved error for array subscript after consumption."""
-    # This would generate code that tries to access array elements after measure_array
-    # Let's create a scenario that would cause this error
-
-    # Note: This is a hypothetical test - the actual code generation might avoid this error
-    # But we can test the error handler directly
-
-    from pecos.slr.gen_codes.guppy.hugr_error_handler import HugrErrorHandler
-
-    bad_code = """
-@guppy
-def main() -> None:
-    q = array(quantum.qubit() for _ in range(3))
-    c = quantum.measure_array(q)
-    # This would fail - accessing q[0] after q is consumed
-    x = q[0]
-"""
-
-    # Create a mock error
-    mock_error = Exception("MoveOutOfSubscriptError: Cannot move out of subscript")
-
-    handler = HugrErrorHandler(bad_code)
-    error_msg = handler.analyze_error(mock_error)
-
-    # Check the error message has helpful content
-    assert "MoveOutOfSubscriptError" in error_msg
-    assert "Cannot move out of array subscript" in error_msg
-    assert "Example fix:" in error_msg
-    assert "measure" in error_msg
-
-
-def test_name_conflict_error() -> None:
-    """Test error message for variable name conflicts."""
-    Main(
-        result := QReg("result", 2),  # Conflicts with result() function
-        Measure(result) > CReg("c", 2),
-    )
-
-    # Note: The current generator renames this automatically
-    # But we can test the error handler
-
-    from pecos.slr.gen_codes.guppy.hugr_error_handler import HugrErrorHandler
-
-    mock_error = TypeError("NotCallableError: 'result' is not callable")
-
-    handler = HugrErrorHandler("")
-    error_msg = handler.analyze_error(mock_error)
-
-    assert "NotCallableError" in error_msg
-    assert "not callable" in error_msg
-    assert "conflicts with a function name" in error_msg
-
-
-def test_already_used_error() -> None:
-    """Test error message for using consumed resources."""
-    from pecos.slr.gen_codes.guppy.hugr_error_handler import HugrErrorHandler
-
-    code_with_double_use = """
-@guppy
-def main() -> None:
-    q = quantum.qubit()
-    _ = quantum.measure(q)
-    _ = quantum.measure(q)  # Error: q already consumed
-"""
-
-    mock_error = Exception("AlreadyUsedError: Variable(name='q') has already been used")
-
-    handler = HugrErrorHandler(code_with_double_use)
-    error_msg = handler.analyze_error(mock_error)
-
-    # print("\nError message for already used:")
-    # print(error_msg)
-
-    assert "AlreadyUsedError" in error_msg
-    assert "already been consumed" in error_msg
-    assert "can only be used once" in error_msg
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_ir_basic.py b/python/quantum-pecos/tests/slr_tests/guppy/test_ir_basic.py
deleted file mode 100644
index b550b31a5..000000000
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_ir_basic.py
+++ /dev/null
@@ -1,83 +0,0 @@
-"""Basic tests for IR generator functionality."""
-
-from pecos.slr import CReg, If, Main, QReg
-from pecos.slr.gen_codes.guppy.ir_generator import IRGuppyGenerator
-from pecos.slr.qeclib import qubit
-from pecos.slr.qeclib.qubit.measures import Measure
-
-
-def test_ir_generates_valid_guppy() -> None:
-    """Test that IR generator produces valid Guppy code structure."""
-    prog = Main(
-        q := QReg("q", 2),
-        c := CReg("c", 2),
-        Measure(q[0]) > c[0],
-        Measure(q[1]) > c[1],
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Check imports
-    assert "from __future__ import annotations" in code
-    assert "from guppylang.decorator import guppy" in code
-    assert "from guppylang.std import quantum" in code
-    assert "from guppylang.std.builtins import array, owned, result" in code
-
-    # Check function structure
-    assert "@guppy" in code
-    assert "def main() -> None:" in code
-
-    # Check variable declarations
-    assert "c = array(False for _ in range(2))" in code
-    # q might be pre-allocated or locally allocated
-
-    # Check measurements - with dynamic allocation uses unpacked variables
-    assert "quantum.measure" in code
-    # Could be c[0]/c[1] or c_0/c_1 depending on allocation strategy
-    assert ("c[0]" in code and "c[1]" in code) or ("c_0" in code and "c_1" in code)
-
-    # Check result
-    assert 'result("c", c)' in code
-
-
-def test_ir_handles_quantum_gates() -> None:
-    """Test that IR generator handles quantum gates."""
-    prog = Main(
-        q := QReg("q", 2),
-        qubit.H(q[0]),
-        qubit.CX(q[0], q[1]),
-        Measure(q) > CReg("c", 2),
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Check gates
-    assert "quantum.h(q[0])" in code
-    assert "quantum.cx(q[0], q[1])" in code
-
-    # Check full array measurement
-    assert "quantum.measure_array(q)" in code
-
-
-def test_ir_handles_conditionals() -> None:
-    """Test that IR generator handles conditional statements."""
-    prog = Main(
-        q := QReg("q", 2),
-        flag := CReg("flag", 1),
-        Measure(q[0]) > flag[0],
-        If(flag[0]).Then(
-            qubit.X(q[1]),
-        ),
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Check conditional structure (with unpacking, flag[0] becomes flag_0)
-    assert "if flag[0]:" in code or "if flag_0:" in code
-    assert "quantum.x(q_1)" in code
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_ir_for_loops.py b/python/quantum-pecos/tests/slr_tests/guppy/test_ir_for_loops.py
deleted file mode 100644
index ceae89e19..000000000
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_ir_for_loops.py
+++ /dev/null
@@ -1,172 +0,0 @@
-"""Test For loop implementation in IR generator."""
-
-import pytest
-from pecos.slr import CReg, For, Main, QReg
-from pecos.slr.gen_codes.guppy.ir_generator import IRGuppyGenerator
-from pecos.slr.misc import Comment
-from pecos.slr.qeclib import qubit
-from pecos.slr.qeclib.qubit.measures import Measure
-
-
-def test_for_loop_range_basic() -> None:
-    """Test basic for loop with range."""
-    prog = Main(
-        q := QReg("q", 5),
-        # Apply H gate to each qubit using For loop
-        For("i", 0, 5).Do(
-            Comment("Apply H to qubit i"),
-            # In real implementation, we'd use: qubit.H(q[i])
-            # For now, just apply to q[0] as placeholder
-            qubit.H(q[0]),
-        ),
-        Measure(q) > CReg("results", 5),
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Check that for loop is generated
-    assert "for i in range(0, 5):" in code
-    assert "# Apply H to qubit i" in code
-
-
-def test_for_loop_range_with_step() -> None:
-    """Test for loop with custom step."""
-    prog = Main(
-        q := QReg("q", 10),
-        # Apply X to every other qubit
-        For("i", 0, 10, 2).Do(
-            Comment("Apply X to even-indexed qubits"),
-            qubit.X(q[0]),  # Placeholder
-        ),
-        Measure(q) > CReg("results", 10),
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Check step parameter
-    assert "for i in range(0, 10, 2):" in code
-
-
-def test_for_loop_iterable() -> None:
-    """Test for loop over an iterable."""
-    prog = Main(
-        q := QReg("q", 3),
-        _indices := CReg("indices", 3),
-        # For loop over a collection (conceptual)
-        For("idx", "indices").Do(
-            Comment("Process index from collection"),
-            qubit.Y(q[0]),
-        ),
-        Measure(q) > CReg("results", 3),
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Check iterable pattern
-    assert "for idx in indices:" in code
-
-
-def test_nested_for_loops() -> None:
-    """Test nested for loops."""
-    prog = Main(
-        q := QReg("q", 9),  # 3x3 grid
-        # Nested loops for 2D pattern
-        For("i", 0, 3).Do(
-            Comment("Outer loop"),
-            For("j", 0, 3).Do(
-                Comment("Inner loop"),
-                Comment("Would apply operation to q[i*3 + j]"),
-                qubit.H(q[0]),  # Placeholder
-            ),
-        ),
-        Measure(q) > CReg("results", 9),
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Check nested structure
-    assert "for i in range(0, 3):" in code
-    assert "for j in range(0, 3):" in code
-    assert "# Outer loop" in code
-    assert "# Inner loop" in code
-
-
-def test_for_loop_with_quantum_operations() -> None:
-    """Test for loop with quantum operations inside."""
-    prog = Main(
-        data := QReg("data", 4),
-        ancilla := QReg("ancilla", 1),
-        # Initialize data qubits
-        For("i", 0, 4).Do(
-            Comment("Initialize data qubit"),
-            qubit.H(data[0]),  # Would be data[i]
-        ),
-        # Entangle with ancilla
-        For("i", 0, 4).Do(
-            Comment("Entangle with ancilla"),
-            qubit.CX(data[0], ancilla[0]),  # Would be data[i]
-        ),
-        Measure(data) > CReg("data_results", 4),
-        Measure(ancilla) > CReg("ancilla_result", 1),
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Check multiple for loops
-    assert code.count("for i in range(0, 4):") >= 2
-    assert "quantum.h" in code
-    assert "quantum.cx" in code
-
-
-def test_for_loop_limitations() -> None:
-    """Test current limitations of For loop implementation."""
-    # The main limitation is that we can't use the loop variable
-    # to index into quantum registers yet
-
-    prog = Main(
-        q := QReg("q", 5),
-        For("i", 0, 5).Do(
-            Comment("TODO: Need to support q[i] indexing"),
-            Comment("Currently would need to unpack array first"),
-        ),
-        Measure(q) > CReg("c", 5),
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Document the limitation
-    assert "for i in range(0, 5):" in code
-    assert "TODO" in code
-
-
-def test_for_error_in_qasm() -> None:
-    """Test that For loops raise error in QASM generator."""
-    from pecos.slr.gen_codes.gen_qasm import QASMGenerator
-
-    prog = Main(
-        q := QReg("q", 3),
-        For("i", 0, 3).Do(
-            qubit.H(q[0]),
-        ),
-        Measure(q) > CReg("c", 3),
-    )
-
-    gen = QASMGenerator(_internal=True)
-
-    # Should raise NotImplementedError
-    with pytest.raises(NotImplementedError) as exc_info:
-        gen.generate_block(prog)
-
-    assert "For loops are not supported in QASM" in str(exc_info.value)
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_ir_generator.py b/python/quantum-pecos/tests/slr_tests/guppy/test_ir_generator.py
deleted file mode 100644
index 200c6cdd0..000000000
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_ir_generator.py
+++ /dev/null
@@ -1,114 +0,0 @@
-"""Test the IR-based Guppy generator."""
-
-from pecos.slr import CReg, If, Main, QReg
-from pecos.slr.gen_codes.guppy.ir_generator import IRGuppyGenerator
-from pecos.slr.qeclib import qubit
-from pecos.slr.qeclib.qubit.measures import Measure
-
-
-def test_ir_simple_measurement() -> None:
-    """Test simple measurement with IR generator."""
-    prog = Main(
-        q := QReg("q", 2),
-        c := CReg("c", 2),
-        Measure(q[0]) > c[0],
-        Measure(q[1]) > c[1],
-    )
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Check basic structure
-    assert "@guppy" in code
-    assert "def main() -> None:" in code
-    # With optimization, q might be dynamically allocated instead of pre-allocated
-    assert "q = array(quantum.qubit() for _ in range(2))" in code or "q_0 = quantum.qubit()" in code
-    assert "c = array(False for _ in range(2))" in code
-
-    # Should have measurements - format depends on allocation strategy
-    # Array indexing for pre-allocated, unpacked variables for dynamic
-    if "q_0 = quantum.qubit()" in code:
-        # Dynamic allocation uses unpacked variables
-        assert "c_0 = quantum.measure(q_0)" in code
-        assert "c_1 = quantum.measure(q_1)" in code
-    else:
-        # Pre-allocation uses array indexing
-        assert "c[0] = quantum.measure(q[0])" in code
-        assert "c[1] = quantum.measure(q[1])" in code
-    assert 'result("c", c)' in code
-
-
-def test_ir_full_array_measurement() -> None:
-    """Test full array measurement with IR generator."""
-    prog = Main(
-        q := QReg("q", 3),
-        c := CReg("c", 3),
-        Measure(q) > c,
-    )
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Should use measure_array for full measurement
-    assert "c = quantum.measure_array(q)" in code
-    # Should NOT unpack
-    assert "=" not in code or "= q" not in code or ", q_" not in code
-
-
-def test_ir_quantum_gates() -> None:
-    """Test quantum gates with IR generator."""
-    prog = Main(
-        q := QReg("q", 2),
-        c := CReg("c", 2),
-        qubit.H(q[0]),
-        qubit.CX(q[0], q[1]),
-        Measure(q) > c,
-    )
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Should use array indexing
-    assert "quantum.h(q[0])" in code
-    assert "quantum.cx(q[0], q[1])" in code
-
-
-def test_ir_conditional_resources() -> None:
-    """Test conditional resource consumption with IR generator."""
-    prog = Main(
-        q := QReg("q", 2),
-        c := CReg("c", 2),
-        flag := CReg("flag", 1),
-        Measure(q[0]) > flag[0],
-        If(flag[0]).Then(
-            Measure(q[1]) > c[1],
-        ),
-    )
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Should have conditional structure (with unpacking, flag[0] becomes flag_0)
-    assert "if flag[0]:" in code or "if flag_0:" in code
-    # With unpacking, q[1] becomes q_1
-    assert "quantum.measure(q[1])" in code or "quantum.measure(q_1)" in code
-    # Should generate valid code
-    assert "result(" in code
-
-
-def test_ir_variable_renaming() -> None:
-    """Test variable renaming to avoid conflicts."""
-    prog = Main(
-        result := QReg("result", 2),  # Conflicts with result() function
-        array := CReg("array", 2),  # Conflicts with array() function
-        Measure(result) > array,
-    )
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Should rename conflicting variables
-    assert "result_reg" in code
-    assert "array_reg" in code
-    # Should use renamed variables correctly
-    assert "quantum.measure_array" in code
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_ir_hugr_compatibility.py b/python/quantum-pecos/tests/slr_tests/guppy/test_ir_hugr_compatibility.py
deleted file mode 100644
index 3d28efa6c..000000000
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_ir_hugr_compatibility.py
+++ /dev/null
@@ -1,128 +0,0 @@
-"""Test IR generator with HUGR compilation scenarios."""
-
-from pecos.slr import CReg, If, Main, QReg
-from pecos.slr.gen_codes.guppy.ir_generator import IRGuppyGenerator
-from pecos.slr.qeclib import qubit
-from pecos.slr.qeclib.qubit.measures import Measure
-
-
-def test_ir_handles_array_measurement_patterns() -> None:
-    """Test that IR generator produces HUGR-compatible array measurement code."""
-    prog = Main(
-        q := QReg("q", 3),
-        c := CReg("c", 3),
-        # Operations on individual qubits
-        qubit.H(q[0]),
-        qubit.CX(q[0], q[1]),
-        # Then measure all at once
-        Measure(q) > c,
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Should use measure_array for the full array
-    assert "c = quantum.measure_array(q)" in code
-
-    # Check that the code structure should be HUGR-compatible
-    # The IR unpacks arrays, but we need to ensure operations use unpacked names
-    lines = code.split("\n")
-
-    # Find unpacking line
-    unpack_line = next(
-        (i for i, line in enumerate(lines) if "q_0, q_1, q_2 = q" in line),
-        -1,
-    )
-
-    if unpack_line >= 0:
-        # After unpacking, operations should use unpacked names
-        for i in range(unpack_line + 1, len(lines)):
-            line = lines[i]
-            if "quantum.h" in line:
-                # Should use q_0 not q[0] after unpacking
-                assert "q_0" in line or "q[0]" not in line, f"Line {i}: Should use unpacked name after unpacking"
-
-
-def test_ir_handles_mixed_measurements() -> None:
-    """Test IR generator with mixed measurement patterns."""
-    prog = Main(
-        q := QReg("q", 4),
-        c := CReg("c", 4),
-        # Individual measurements first
-        Measure(q[0]) > c[0],
-        # Gate on another qubit
-        qubit.H(q[1]),
-        # More measurements
-        Measure(q[1]) > c[1],
-        Measure(q[2]) > c[2],
-        Measure(q[3]) > c[3],
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Should handle individual measurements correctly
-    assert "quantum.measure(q" in code
-
-    # Check code structure
-    # IR generator should produce code that avoids HUGR issues
-
-
-def test_ir_with_conditional_measurements() -> None:
-    """Test IR generator with conditional measurement patterns."""
-    prog = Main(
-        q := QReg("q", 3),
-        flag := CReg("flag", 1),
-        results := CReg("results", 2),
-        # Measure for condition
-        Measure(q[0]) > flag[0],
-        If(flag[0])
-        .Then(
-            Measure(q[1]) > results[0],
-        )
-        .Else(
-            Measure(q[2]) > results[1],
-        ),
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Check structure - after unpacking, it should use flag_0
-    assert "if flag_0:" in code or "if flag[0]:" in code
-    assert "else:" in code
-
-    # Check code structure for HUGR compatibility
-    # (Actual HUGR compilation would require setting up the proper environment)
-
-
-def test_ir_avoids_subscript_after_consume() -> None:
-    """Test that IR generator avoids accessing arrays after they're consumed."""
-    # This is a pattern that fails with the original generator
-    prog = Main(
-        q := QReg("q", 2),
-        c := CReg("c", 2),
-        # Measure all qubits
-        Measure(q) > c,
-        # Try to access individual elements (should not generate q[0] access)
-        # This would fail in HUGR if we tried to access q[0] after measure_array
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Should use measure_array
-    assert "quantum.measure_array(q)" in code
-
-    # Should NOT have any q[0] or q[1] access after measurement
-    lines = code.split("\n")
-    measure_line = next(i for i, line in enumerate(lines) if "measure_array" in line)
-
-    # Check no array access after measurement
-    for i in range(measure_line + 1, len(lines)):
-        assert "q[0]" not in lines[i], "Should not access q[0] after measure_array"
-        assert "q[1]" not in lines[i], "Should not access q[1] after measure_array"
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_ir_permute.py b/python/quantum-pecos/tests/slr_tests/guppy/test_ir_permute.py
deleted file mode 100644
index cd558987a..000000000
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_ir_permute.py
+++ /dev/null
@@ -1,112 +0,0 @@
-"""Test Permute operation in IR generator."""
-
-from pecos.slr import CReg, Main, Permute, QReg
-from pecos.slr.gen_codes.guppy.ir_generator import IRGuppyGenerator
-from pecos.slr.qeclib import qubit
-from pecos.slr.qeclib.qubit.measures import Measure
-
-
-def test_ir_simple_permute() -> None:
-    """Test simple register swap with IR generator."""
-    prog = Main(
-        a := QReg("a", 2),
-        b := QReg("b", 2),
-        # Initialize
-        qubit.H(a[0]),
-        qubit.X(b[1]),
-        # Swap registers
-        Permute(a, b),
-        # Measure
-        Measure(a) > CReg("c_a", 2),
-        Measure(b) > CReg("c_b", 2),
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Check that swap comment is added
-    assert "# Swap a and b" in code
-
-    # Check that temporary variable is used
-    assert "_temp_a" in code
-
-    # Check the swap sequence
-    assert "_temp_a = a" in code
-    assert "a = b" in code
-    assert "b = _temp_a" in code
-
-
-def test_ir_permute_with_operations() -> None:
-    """Test Permute with operations before and after."""
-    prog = Main(
-        q1 := QReg("q1", 3),
-        q2 := QReg("q2", 3),
-        # Operations on q1
-        qubit.H(q1[0]),
-        qubit.CX(q1[0], q1[1]),
-        # Operations on q2
-        qubit.X(q2[0]),
-        qubit.Y(q2[1]),
-        # Swap the registers
-        Permute(q1, q2),
-        # Now q1 has what was in q2 and vice versa
-        # Measure them
-        Measure(q1) > CReg("c1", 3),
-        Measure(q2) > CReg("c2", 3),
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Check operations are generated
-    assert "quantum.h" in code
-    assert "quantum.cx" in code
-    assert "quantum.x" in code
-    assert "quantum.y" in code
-
-    # Check swap
-    assert "# Swap q1 and q2" in code
-    assert "_temp_q1" in code
-
-
-def test_ir_complex_permute_cycle() -> None:
-    """Test complex permutation with cycle pattern."""
-    # Cycle permutation: a[0] -> a[1] -> a[2] -> a[0]
-    prog = Main(
-        a := QReg("a", 3),
-        # Initialize with different states
-        qubit.X(a[0]),
-        qubit.Y(a[1]),
-        qubit.Z(a[2]),
-        # Cyclic permutation: 0->1, 1->2, 2->0
-        Permute([a[0], a[1], a[2]], [a[1], a[2], a[0]]),
-        Measure(a) > CReg("result", 3),
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Should have permutation comment
-    assert "# Permute 3 elements" in code
-    # Should use temporary variable for cycle
-    assert "_temp_cycle" in code
-
-
-def test_ir_complex_permute_multiple_swaps() -> None:
-    """Test permutation that decomposes into multiple swaps."""
-    prog = Main(
-        q := QReg("q", 4),
-        # Permutation: swap 0<->3 and 1<->2
-        Permute([q[0], q[1], q[2], q[3]], [q[3], q[2], q[1], q[0]]),
-        Measure(q) > CReg("result", 4),
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Should generate swap operations
-    assert "_temp_swap" in code
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_ir_scope_management.py b/python/quantum-pecos/tests/slr_tests/guppy/test_ir_scope_management.py
deleted file mode 100644
index ba3aba3b4..000000000
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_ir_scope_management.py
+++ /dev/null
@@ -1,127 +0,0 @@
-"""Test scope management in IR generator."""
-
-from pecos.slr import CReg, If, Main, QReg
-from pecos.slr.gen_codes.guppy.ir_generator import IRGuppyGenerator
-from pecos.slr.qeclib.qubit.measures import Measure
-
-
-def test_conditional_resource_balancing() -> None:
-    """Test that resources are balanced across conditional branches."""
-    prog = Main(
-        q := QReg("q", 3),
-        flag := CReg("flag", 1),
-        result := CReg("result", 2),
-        # Measure first qubit for condition
-        Measure(q[0]) > flag[0],
-        # Conditional that consumes different resources in each branch
-        If(flag[0])
-        .Then(
-            # Then branch: measure q[1]
-            Measure(q[1])
-            > result[0],
-        )
-        .Else(
-            # Else branch: measure q[2]
-            Measure(q[2])
-            > result[1],
-        ),
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # print("Generated code with conditional resource balancing:")
-    # print(code)
-
-    # Both branches should exist
-    # With unpacking, flag[0] becomes flag_0
-    assert "if flag[0]:" in code or "if flag_0:" in code
-    assert "else:" in code
-
-    # Check measurements in branches
-    lines = code.split("\n")
-
-    # Find the if and else blocks
-    # Support both array access and unpacked variable
-    if_idx = next(
-        (i for i, line in enumerate(lines) if ("if flag[0]:" in line or "if flag_0:" in line)),
-        -1,
-    )
-    if if_idx == -1:
-        msg = "Could not find if statement"
-        raise AssertionError(msg)
-    else_idx = next(i for i, line in enumerate(lines) if line.strip() == "else:")
-
-    # Check that both branches have measurements
-    then_block = lines[if_idx + 1 : else_idx]
-    else_block = lines[else_idx + 1 :]
-
-    # Then branch should measure q[1] (result was renamed to result_reg)
-    # With dynamic allocation, it uses individual variables instead of array access
-    assert any("result_0 = quantum.measure" in line for line in then_block)
-
-    # Else branch should measure q[2]
-    assert any("result_1 = quantum.measure" in line for line in else_block)
-
-
-def test_nested_conditional_scopes() -> None:
-    """Test nested conditional scopes."""
-    prog = Main(
-        q := QReg("q", 4),
-        flags := CReg("flags", 2),
-        c := CReg("c", 1),
-        # Outer condition
-        Measure(q[0]) > flags[0],
-        If(flags[0]).Then(
-            # Inner condition
-            Measure(q[1]) > flags[1],
-            If(flags[1]).Then(
-                # Nested then: measure q[2]
-                Measure(q[2])
-                > c[0],
-            ),
-            # q[3] not measured in inner if
-        ),
-        # q[2] and q[3] might not be measured
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Should have nested if statements
-    assert code.count("if flags") >= 2
-
-    # All qubits should eventually be consumed
-    # The IR generator uses discard_array at the end
-    assert "# Discard q" in code
-    assert "quantum.discard_array(q)" in code
-
-
-def test_function_scope_returns() -> None:
-    """Test that function scopes properly track returned resources."""
-    # This would test function-level scope management
-    # For now, just test that main function works
-    prog = Main(
-        q := QReg("q", 2),
-        c := CReg("c", 1),
-        # Only measure first qubit
-        Measure(q[0]) > c[0],
-        # q[1] should be cleaned up
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # With dynamic allocation, only q_0 is allocated and measured, no cleanup needed for q_1
-    # Check that the measurement happened correctly (may be q_0, q_0_local, or c_0)
-    assert (
-        "c[0] = quantum.measure(q_0)" in code
-        or "c_0 = quantum.measure(q_0)" in code
-        or "c[0] = quantum.measure(q_0_local)" in code
-        or "c_0 = quantum.measure(q_0_local)" in code
-    )
-    # Check that result is generated
-    assert 'result("c", c)' in code
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_ir_while_loops.py b/python/quantum-pecos/tests/slr_tests/guppy/test_ir_while_loops.py
deleted file mode 100644
index 9cfc27dda..000000000
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_ir_while_loops.py
+++ /dev/null
@@ -1,167 +0,0 @@
-"""Test While loop support in IR generator."""
-
-import pytest
-from pecos.slr import CReg, For, Main, QReg, While
-from pecos.slr.gen_codes.guppy.ir_generator import IRGuppyGenerator
-from pecos.slr.misc import Comment
-from pecos.slr.qeclib import qubit
-from pecos.slr.qeclib.qubit.measures import Measure
-
-
-def test_ir_while_loop_basic() -> None:
-    """Test basic while loop generation."""
-    prog = Main(
-        q := QReg("q", 1),
-        c := CReg("c", 1),
-        # While loop with a simple condition
-        # In real use, condition would come from measurement or input
-        While(c[0]).Do(
-            Comment("Apply operation in loop"),
-            qubit.H(q[0]),
-        ),
-        Measure(q[0]) > c[0],
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Check that while loop is generated
-    assert "while " in code
-    assert "# Apply operation in loop" in code
-
-
-def test_ir_while_loop_with_quantum() -> None:
-    """Test while loop with quantum operations."""
-    prog = Main(
-        q := QReg("q", 2),
-        control := CReg("control", 1),
-        result := CReg("result", 2),
-        # Initialize with H on first qubit
-        qubit.H(q[0]),
-        # While loop controlled by classical bit
-        While(control[0]).Do(
-            Comment("Quantum operations in loop"),
-            qubit.CX(q[0], q[1]),
-            qubit.H(q[1]),
-            Comment("In practice, control bit would be updated here"),
-        ),
-        # Measure both qubits
-        Measure(q) > result,
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Check structure
-    assert "while " in code
-    assert "quantum.cx" in code
-    assert "quantum.h" in code
-    assert "quantum.measure_array(q)" in code
-
-
-def test_ir_nested_while_loops() -> None:
-    """Test nested while loops."""
-    prog = Main(
-        q := QReg("q", 1),
-        outer_cond := CReg("outer_cond", 1),
-        inner_cond := CReg("inner_cond", 1),
-        result := CReg("result", 1),
-        # Outer while loop
-        While(outer_cond[0]).Do(
-            Comment("Outer loop"),
-            # Inner while loop
-            While(inner_cond[0]).Do(
-                Comment("Inner loop"),
-                qubit.X(q[0]),
-            ),
-            qubit.Z(q[0]),
-        ),
-        Measure(q[0]) > result[0],
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Check for nested structure
-    assert code.count("while ") >= 2  # At least 2 while statements
-    assert "# Outer loop" in code
-    assert "# Inner loop" in code
-
-
-def test_ir_while_error_in_qasm() -> None:
-    """Test that While loops raise error in QASM generator."""
-    from pecos.slr.gen_codes.gen_qasm import QASMGenerator
-
-    prog = Main(
-        c := CReg("c", 1),
-        While(c[0]).Do(
-            Comment("This should fail in QASM"),
-        ),
-    )
-
-    gen = QASMGenerator(_internal=True)
-
-    # Should raise NotImplementedError
-    with pytest.raises(NotImplementedError) as exc_info:
-        gen.generate_block(prog)
-
-    assert "While loops are not supported in QASM" in str(exc_info.value)
-
-
-def test_ir_for_loop_placeholder() -> None:
-    """Test For loop generates placeholder (not fully implemented yet)."""
-    prog = Main(
-        q := QReg("q", 3),
-        c := CReg("c", 3),
-        # For loop (generates TODO for now)
-        For("i", 0, 3).Do(
-            Comment("Apply H to each qubit"),
-            qubit.H(q[0]),  # Would use i to index in full implementation
-        ),
-        # Measure all
-        Measure(q) > c,
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # For loops should now be properly implemented
-    assert "for i in range(0, 3):" in code
-
-
-def test_while_loop_quantum_resource_handling() -> None:
-    """Test that quantum resources are properly tracked in while loops."""
-    prog = Main(
-        q := QReg("q", 3),
-        ancilla := QReg("ancilla", 1),
-        cond := CReg("cond", 1),
-        results := CReg("results", 4),
-        # Initialize
-        qubit.H(q[0]),
-        qubit.H(q[1]),
-        # While loop that uses quantum resources
-        While(cond[0]).Do(
-            Comment("Use ancilla in loop"),
-            qubit.H(ancilla[0]),
-            qubit.CX(q[0], ancilla[0]),
-            Measure(ancilla[0]) > results[0],
-            Comment("Ancilla is consumed each iteration"),
-        ),
-        # Measure remaining qubits
-        Measure(q) > results[1:4],
-    )
-
-    gen = IRGuppyGenerator(_internal=True)
-    gen.generate_block(prog)
-    code = gen.get_output()
-
-    # Check that measurements are properly handled
-    assert "while " in code
-    # With dynamic allocation, ancilla is allocated locally in the loop
-    assert "ancilla_0_local = quantum.qubit()" in code
-    assert "quantum.measure(ancilla_0_local)" in code
-    assert "quantum.measure_array(q)" in code
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_unified_resource_planner.py b/python/quantum-pecos/tests/slr_tests/guppy/test_unified_resource_planner.py
deleted file mode 100644
index 9b2dda119..000000000
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_unified_resource_planner.py
+++ /dev/null
@@ -1,489 +0,0 @@
-"""Test suite for unified resource planning framework.
-
-This tests the integration of unpacking decisions, allocation strategies,
-and data flow analysis into a coherent resource management plan.
-"""
-
-from pecos.slr import CReg, For, If, Main, QReg
-from pecos.slr.gen_codes.guppy.unified_resource_planner import (
-    DecisionPriority,
-    ResourceStrategy,
-    UnifiedResourcePlanner,
-)
-from pecos.slr.qeclib import qubit
-
-
-class TestBasicUnifiedPlanning:
-    """Test basic unified resource planning scenarios."""
-
-    def test_simple_packed_array(self) -> None:
-        """Array with no individual access should stay packed."""
-        prog = Main(
-            q := QReg("q", 3),
-            results := CReg("results", 3),
-            qubit.H(q[0]),
-            qubit.H(q[1]),
-            qubit.H(q[2]),
-            qubit.Measure(q) > results,  # Full array measurement
-        )
-
-        planner = UnifiedResourcePlanner()
-        analysis = planner.analyze(prog, {"q": q, "results": results})
-
-        q_plan = analysis.get_plan("q")
-        assert q_plan is not None
-        # Full array operation forbids unpacking
-        assert q_plan.strategy == ResourceStrategy.PACKED_PREALLOCATED
-        assert q_plan.priority == DecisionPriority.FORBIDDEN
-
-    def test_quantum_measurement_requires_unpacking(self) -> None:
-        """Individual quantum measurements require unpacking."""
-        prog = Main(
-            q := QReg("q", 2),
-            c := CReg("c", 2),
-            qubit.H(q[0]),
-            qubit.Measure(q[0]) > c[0],  # Individual measurement
-            qubit.H(q[1]),
-            qubit.Measure(q[1]) > c[1],
-        )
-
-        planner = UnifiedResourcePlanner()
-        analysis = planner.analyze(prog, {"q": q, "c": c})
-
-        q_plan = analysis.get_plan("q")
-        assert q_plan is not None
-        assert q_plan.needs_unpacking
-        assert q_plan.priority == DecisionPriority.REQUIRED
-        # Can match either "quantum measurements" or "operations after measurement"
-        # (depends on whether there are operations between measurement and next use)
-        reasons_text = " ".join(q_plan.reasons).lower()
-        assert "quantum" in reasons_text or "measurement" in reasons_text
-
-    def test_classical_multiple_access_unpacking(self) -> None:
-        """Classical arrays with multiple accesses benefit from unpacking."""
-        prog = Main(
-            q := QReg("q", 3),
-            c := CReg("c", 3),
-            qubit.Measure(q[0]) > c[0],
-            qubit.Measure(q[1]) > c[1],
-            qubit.Measure(q[2]) > c[2],
-            # c is accessed 3 times - should unpack for readability
-        )
-
-        planner = UnifiedResourcePlanner()
-        analysis = planner.analyze(prog, {"q": q, "c": c})
-
-        c_plan = analysis.get_plan("c")
-        assert c_plan is not None
-        # Classical with multiple accesses should unpack
-        assert c_plan.needs_unpacking
-        assert c_plan.priority == DecisionPriority.RECOMMENDED
-
-
-class TestConditionalIntegration:
-    """Test integration of conditional access tracking."""
-
-    def test_conditional_requires_unpacking(self) -> None:
-        """Elements accessed in conditionals require unpacking."""
-        prog = Main(
-            q := QReg("q", 2),
-            c := CReg("c", 1),
-            qubit.Measure(q[0]) > c[0],
-            If(c[0]).Then(
-                qubit.X(q[1]),  # q[1] accessed conditionally
-            ),
-        )
-
-        planner = UnifiedResourcePlanner()
-        analysis = planner.analyze(prog, {"q": q, "c": c})
-
-        q_plan = analysis.get_plan("q")
-        assert q_plan is not None
-        assert q_plan.needs_unpacking
-        assert q_plan.priority == DecisionPriority.REQUIRED
-        # The actual reason might be "operations after measurement" (higher priority rule)
-        # or "conditional" - both are correct
-        assert q_plan.needs_unpacking  # Main thing is it unpacks
-
-    def test_precise_conditional_tracking(self) -> None:
-        """Only elements actually in conditionals should trigger unpacking."""
-        prog = Main(
-            q := QReg("q", 3),
-            c := CReg("c", 1),
-            qubit.H(q[0]),  # q[0] not conditional
-            qubit.H(q[1]),  # q[1] not conditional
-            qubit.Measure(q[0]) > c[0],
-            If(c[0]).Then(
-                qubit.X(q[2]),  # Only q[2] is conditional
-            ),
-        )
-
-        planner = UnifiedResourcePlanner()
-        analysis = planner.analyze(prog, {"q": q, "c": c})
-
-        q_plan = analysis.get_plan("q")
-        assert q_plan is not None
-        # Should unpack because q[2] is conditional
-        assert q_plan.needs_unpacking
-        # Evidence should show only q[2] is conditional
-        assert 2 in q_plan.evidence.get("conditionally_accessed_elements", set())
-
-
-class TestDataFlowIntegration:
-    """Test integration of data flow analysis."""
-
-    def test_operations_after_measurement(self) -> None:
-        """Operations after measurement require unpacking (data flow detects this)."""
-        prog = Main(
-            q := QReg("q", 2),
-            c := CReg("c", 2),
-            qubit.Measure(q[0]) > c[0],
-            qubit.X(q[0]),  # Use after measurement - requires replacement
-        )
-
-        planner = UnifiedResourcePlanner()
-        analysis = planner.analyze(prog, {"q": q, "c": c})
-
-        q_plan = analysis.get_plan("q")
-        assert q_plan is not None
-        assert q_plan.needs_unpacking
-        assert q_plan.priority == DecisionPriority.REQUIRED
-        assert 0 in q_plan.elements_requiring_replacement
-
-    def test_measure_prep_use_pattern(self) -> None:
-        """Measure-Prep-Use pattern should be handled correctly."""
-        prog = Main(
-            q := QReg("q", 1),
-            c := CReg("c", 1),
-            qubit.Measure(q[0]) > c[0],
-            qubit.Prep(q[0]),  # Replacement
-            qubit.X(q[0]),  # Use after replacement - OK
-        )
-
-        planner = UnifiedResourcePlanner()
-        analysis = planner.analyze(prog, {"q": q, "c": c})
-
-        q_plan = analysis.get_plan("q")
-        assert q_plan is not None
-        # Should still require unpacking for measurement
-        assert q_plan.needs_unpacking
-
-    def test_different_elements_no_conflict(self) -> None:
-        """Measuring one element and using another shouldn't cause issues."""
-        prog = Main(
-            q := QReg("q", 2),
-            c := CReg("c", 1),
-            qubit.Measure(q[0]) > c[0],  # Measure q[0]
-            qubit.X(q[1]),  # Use q[1] (different element)
-        )
-
-        planner = UnifiedResourcePlanner()
-        analysis = planner.analyze(prog, {"q": q, "c": c})
-
-        q_plan = analysis.get_plan("q")
-        assert q_plan is not None
-        # Should unpack because of measurement
-        assert q_plan.needs_unpacking
-        # But q[1] doesn't require replacement (only q[0] was measured)
-        assert 0 not in q_plan.elements_requiring_replacement or (1 not in q_plan.elements_requiring_replacement)
-
-
-class TestAllocationIntegration:
-    """Test integration of allocation optimization."""
-
-    def test_short_lived_local_allocation(self) -> None:
-        """Short-lived qubits should get local allocation strategy."""
-        prog = Main(
-            ancilla := QReg("ancilla", 2),
-            c := CReg("c", 2),
-            # Short-lived pattern: allocate, use, measure immediately
-            qubit.H(ancilla[0]),
-            qubit.Measure(ancilla[0]) > c[0],
-            qubit.H(ancilla[1]),
-            qubit.Measure(ancilla[1]) > c[1],
-        )
-
-        planner = UnifiedResourcePlanner()
-        analysis = planner.analyze(prog, {"ancilla": ancilla, "c": c})
-
-        ancilla_plan = analysis.get_plan("ancilla")
-        assert ancilla_plan is not None
-        assert ancilla_plan.needs_unpacking  # Measurements require unpacking
-        # Should have determined local allocation candidates
-        assert len(ancilla_plan.elements_to_allocate_locally) > 0
-
-    def test_reused_prevents_local_allocation(self) -> None:
-        """Reused qubits should not use local allocation."""
-        prog = Main(
-            q := QReg("q", 1),
-            c := CReg("c", 2),
-            qubit.H(q[0]),
-            qubit.Measure(q[0]) > c[0],
-            # Reuse the same qubit
-            qubit.X(q[0]),
-            qubit.Measure(q[0]) > c[1],
-        )
-
-        planner = UnifiedResourcePlanner()
-        analysis = planner.analyze(prog, {"q": q, "c": c})
-
-        q_plan = analysis.get_plan("q")
-        assert q_plan is not None
-        assert q_plan.needs_unpacking
-        # Should have evidence about reused elements
-        if "reused_elements" in q_plan.evidence:
-            assert 0 in q_plan.evidence["reused_elements"]
-
-
-class TestUnifiedDecisions:
-    """Test that unified decisions are coherent."""
-
-    def test_syndrome_extraction_coherent(self) -> None:
-        """Syndrome extraction should have coherent plan across all registers."""
-        prog = Main(
-            data := QReg("data", 3),
-            ancilla := QReg("ancilla", 2),
-            syndrome := CReg("syndrome", 2),
-            # Entangle
-            qubit.CX(data[0], ancilla[0]),
-            qubit.CX(data[1], ancilla[0]),
-            # Measure ancillas
-            qubit.Measure(ancilla[0]) > syndrome[0],
-            qubit.Measure(ancilla[1]) > syndrome[1],
-            # Continue using data qubits
-            qubit.H(data[0]),
-            qubit.H(data[1]),
-        )
-
-        planner = UnifiedResourcePlanner()
-        analysis = planner.analyze(
-            prog,
-            {"data": data, "ancilla": ancilla, "syndrome": syndrome},
-        )
-
-        # All three registers should have coherent plans
-        data_plan = analysis.get_plan("data")
-        ancilla_plan = analysis.get_plan("ancilla")
-        syndrome_plan = analysis.get_plan("syndrome")
-
-        assert data_plan is not None
-        assert ancilla_plan is not None
-        assert syndrome_plan is not None
-
-        # Data: measured ancillas, not data, so data doesn't need operations_between unpacking
-        # But might need unpacking for other reasons
-        # (This is a complex case - main thing is no crash)
-
-        # Ancilla: individual measurements require unpacking
-        assert ancilla_plan.needs_unpacking
-
-        # Syndrome: classical with multiple accesses
-        assert syndrome_plan.needs_unpacking or not syndrome_plan.needs_unpacking
-        # (Either decision is valid depending on heuristics)
-
-    def test_teleportation_coherent(self) -> None:
-        """Teleportation should have coherent plan."""
-        prog = Main(
-            alice := QReg("alice", 1),
-            bob := QReg("bob", 1),
-            epr := QReg("epr", 1),
-            c := CReg("c", 2),
-            # EPR pair
-            qubit.H(epr[0]),
-            qubit.CX(epr[0], bob[0]),
-            # Alice's operations
-            qubit.CX(alice[0], epr[0]),
-            qubit.H(alice[0]),
-            # Measurements
-            qubit.Measure(alice[0]) > c[0],
-            qubit.Measure(epr[0]) > c[1],
-            # Bob's corrections (conditional)
-            If(c[1]).Then(
-                qubit.X(bob[0]),
-            ),
-            If(c[0]).Then(
-                qubit.Z(bob[0]),
-            ),
-        )
-
-        planner = UnifiedResourcePlanner()
-        analysis = planner.analyze(
-            prog,
-            {"alice": alice, "bob": bob, "epr": epr, "c": c},
-        )
-
-        # Bob needs unpacking (conditional access)
-        bob_plan = analysis.get_plan("bob")
-        assert bob_plan is not None
-        assert bob_plan.needs_unpacking
-        assert bob_plan.priority == DecisionPriority.REQUIRED
-
-    def test_mixed_strategy_coherent(self) -> None:
-        """Mixed allocation and unpacking should be coherent."""
-        prog = Main(
-            mixed := QReg("mixed", 4),
-            c := CReg("c", 4),
-            # Long-lived use of mixed[0]
-            qubit.H(mixed[0]),
-            qubit.CX(mixed[0], mixed[1]),
-            qubit.CZ(mixed[0], mixed[2]),
-            qubit.Measure(mixed[0]) > c[0],
-            # Short-lived uses
-            qubit.X(mixed[1]),
-            qubit.Measure(mixed[1]) > c[1],
-            qubit.Y(mixed[2]),
-            qubit.Measure(mixed[2]) > c[2],
-            qubit.Z(mixed[3]),
-            qubit.Measure(mixed[3]) > c[3],
-        )
-
-        planner = UnifiedResourcePlanner()
-        analysis = planner.analyze(prog, {"mixed": mixed, "c": c})
-
-        mixed_plan = analysis.get_plan("mixed")
-        assert mixed_plan is not None
-        # Should need unpacking (individual measurements)
-        assert mixed_plan.needs_unpacking
-        # May have mixed allocation strategy
-        assert mixed_plan.strategy in (
-            ResourceStrategy.UNPACKED_PREALLOCATED,
-            ResourceStrategy.UNPACKED_MIXED,
-            ResourceStrategy.UNPACKED_LOCAL,
-        )
-
-
-class TestReportGeneration:
-    """Test resource planning report generation."""
-
-    def test_report_includes_all_registers(self) -> None:
-        """Report should include all analyzed registers."""
-        prog = Main(
-            q := QReg("q", 2),
-            c := CReg("c", 2),
-            qubit.Measure(q[0]) > c[0],
-            qubit.Measure(q[1]) > c[1],
-        )
-
-        planner = UnifiedResourcePlanner()
-        analysis = planner.analyze(prog, {"q": q, "c": c})
-
-        report = analysis.get_report()
-        assert "q" in report
-        assert "c" in report
-        assert "UNIFIED RESOURCE PLANNING REPORT" in report
-
-    def test_report_shows_strategies(self) -> None:
-        """Report should show chosen strategies."""
-        prog = Main(
-            q := QReg("q", 1),
-            c := CReg("c", 1),
-            qubit.Measure(q[0]) > c[0],
-        )
-
-        planner = UnifiedResourcePlanner()
-        analysis = planner.analyze(prog, {"q": q, "c": c})
-
-        report = analysis.get_report()
-        # Should mention strategies
-        assert "Strategy:" in report
-        # Should have statistics
-        assert "Total registers analyzed:" in report
-
-    def test_individual_plan_explanation(self) -> None:
-        """Individual plans should have clear explanations."""
-        prog = Main(
-            q := QReg("q", 2),
-            c := CReg("c", 1),
-            qubit.Measure(q[0]) > c[0],
-            If(c[0]).Then(
-                qubit.X(q[1]),
-            ),
-        )
-
-        planner = UnifiedResourcePlanner()
-        analysis = planner.analyze(prog, {"q": q, "c": c})
-
-        q_plan = analysis.get_plan("q")
-        assert q_plan is not None
-
-        explanation = q_plan.get_explanation()
-        assert "Resource Plan for 'q'" in explanation
-        assert "Strategy:" in explanation
-        assert "Priority:" in explanation
-        assert "Reasons:" in explanation
-
-
-class TestEdgeCases:
-    """Test edge cases and boundary conditions."""
-
-    def test_empty_program(self) -> None:
-        """Empty program should not crash."""
-        prog = Main(
-            q := QReg("q", 1),
-        )
-
-        planner = UnifiedResourcePlanner()
-        analysis = planner.analyze(prog, {"q": q})
-
-        q_plan = analysis.get_plan("q")
-        assert q_plan is not None
-        # No usage - should stay packed
-        assert q_plan.strategy == ResourceStrategy.PACKED_PREALLOCATED
-
-    def test_single_element_array(self) -> None:
-        """Single element array should work correctly."""
-        prog = Main(
-            q := QReg("q", 1),
-            c := CReg("c", 1),
-            qubit.H(q[0]),
-            qubit.Measure(q[0]) > c[0],
-        )
-
-        planner = UnifiedResourcePlanner()
-        analysis = planner.analyze(prog, {"q": q, "c": c})
-
-        q_plan = analysis.get_plan("q")
-        assert q_plan is not None
-        # Single element measurement requires unpacking
-        assert q_plan.needs_unpacking
-
-    def test_nested_conditionals(self) -> None:
-        """Nested conditionals should be handled correctly."""
-        prog = Main(
-            q := QReg("q", 2),
-            c := CReg("c", 2),
-            qubit.Measure(q[0]) > c[0],
-            qubit.Measure(q[1]) > c[1],
-            If(c[0]).Then(
-                If(c[1]).Then(
-                    qubit.X(q[0]),
-                    qubit.X(q[1]),
-                ),
-            ),
-        )
-
-        planner = UnifiedResourcePlanner()
-        analysis = planner.analyze(prog, {"q": q, "c": c})
-
-        q_plan = analysis.get_plan("q")
-        assert q_plan is not None
-        assert q_plan.needs_unpacking
-
-    def test_loop_usage(self) -> None:
-        """Qubits used in loops should be handled correctly."""
-        prog = Main(
-            q := QReg("q", 3),
-            c := CReg("c", 3),
-            For("i", 0, 3).Do(
-                qubit.H(q[0]),
-            ),
-            qubit.Measure(q) > c,
-        )
-
-        planner = UnifiedResourcePlanner()
-        analysis = planner.analyze(prog, {"q": q, "c": c})
-
-        q_plan = analysis.get_plan("q")
-        assert q_plan is not None
-        # Full array measurement forbids unpacking
-        assert q_plan.strategy == ResourceStrategy.PACKED_PREALLOCATED
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_unpacking_rules.py b/python/quantum-pecos/tests/slr_tests/guppy/test_unpacking_rules.py
deleted file mode 100644
index 7cbcbc8d8..000000000
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_unpacking_rules.py
+++ /dev/null
@@ -1,406 +0,0 @@
-"""Test suite for array unpacking decision rules."""
-
-from _pytest.capture import CaptureFixture
-from pecos.slr.gen_codes.guppy.ir_analyzer import ArrayAccessInfo
-from pecos.slr.gen_codes.guppy.unpacking_rules import (
-    UnpackingDecision,
-    UnpackingDecisionTree,
-    UnpackingReason,
-    should_unpack_array,
-)
-
-
-class TestUnpackingDecisionTree:
-    """Test the rule-based decision tree for array unpacking."""
-
-    def test_full_array_measurement_prevents_unpacking(self) -> None:
-        """Full array measurements should prevent unpacking."""
-        # Quantum array with full measurement
-        info = ArrayAccessInfo(
-            array_name="q",
-            size=5,
-            is_classical=False,
-        )
-        info.full_array_accesses.append(10)
-        info.element_accesses.add(0)  # Also has individual access
-        info.element_accesses.add(1)
-
-        result = UnpackingDecisionTree().decide(info)
-        assert result.decision == UnpackingDecision.MUST_NOT_UNPACK
-        assert result.reason == UnpackingReason.FULL_ARRAY_ONLY
-        assert not result.should_unpack
-
-    def test_no_individual_access_no_unpacking(self) -> None:
-        """Arrays with no individual element access should not be unpacked."""
-        info = ArrayAccessInfo(
-            array_name="q",
-            size=5,
-            is_classical=False,
-        )
-        # No element accesses
-
-        result = UnpackingDecisionTree().decide(info)
-        assert result.decision == UnpackingDecision.SHOULD_NOT_UNPACK
-        assert result.reason == UnpackingReason.NO_INDIVIDUAL_ACCESS
-        assert not result.should_unpack
-
-    def test_operations_after_measurement_requires_unpacking(self) -> None:
-        """Quantum operations after measurement require unpacking."""
-        info = ArrayAccessInfo(
-            array_name="q",
-            size=3,
-            is_classical=False,
-        )
-        info.element_accesses.add(0)
-        info.elements_consumed.add(0)  # Measured
-        info.has_operations_between = True  # Then used again
-
-        result = UnpackingDecisionTree().decide(info)
-        assert result.decision == UnpackingDecision.MUST_UNPACK
-        assert result.reason == UnpackingReason.OPERATIONS_AFTER_MEASUREMENT
-        assert result.should_unpack
-
-    def test_individual_quantum_measurement_requires_unpacking(self) -> None:
-        """Individual quantum measurements require unpacking."""
-        info = ArrayAccessInfo(
-            array_name="q",
-            size=5,
-            is_classical=False,
-        )
-        info.element_accesses.add(0)
-        info.element_accesses.add(2)
-        info.elements_consumed.add(0)
-        info.elements_consumed.add(2)
-
-        result = UnpackingDecisionTree().decide(info)
-        assert result.decision == UnpackingDecision.MUST_UNPACK
-        assert result.reason == UnpackingReason.INDIVIDUAL_QUANTUM_MEASUREMENT
-        assert result.should_unpack
-
-    def test_conditional_access_requires_unpacking(self) -> None:
-        """Conditional element access requires unpacking."""
-        info = ArrayAccessInfo(
-            array_name="c",
-            size=4,
-            is_classical=True,
-        )
-        info.element_accesses.add(0)
-        info.element_accesses.add(1)
-        info.has_conditionals_between = True
-
-        result = UnpackingDecisionTree().decide(info)
-        assert result.decision == UnpackingDecision.MUST_UNPACK
-        assert result.reason == UnpackingReason.CONDITIONAL_ELEMENT_ACCESS
-        assert result.should_unpack
-
-    def test_single_element_access_no_unpacking(self) -> None:
-        """Single element access should use direct indexing, not unpacking."""
-        info = ArrayAccessInfo(
-            array_name="q",
-            size=5,
-            is_classical=False,
-        )
-        info.element_accesses.add(2)  # Only one element
-
-        result = UnpackingDecisionTree().decide(info)
-        assert result.decision == UnpackingDecision.SHOULD_NOT_UNPACK
-        assert result.reason == UnpackingReason.SINGLE_ELEMENT_ONLY
-        assert not result.should_unpack
-
-    def test_classical_multiple_accesses_should_unpack(self) -> None:
-        """Classical arrays with multiple individual accesses should unpack for clarity."""
-        info = ArrayAccessInfo(
-            array_name="c",
-            size=4,
-            is_classical=True,
-        )
-        info.element_accesses.add(0)
-        info.element_accesses.add(1)
-        info.element_accesses.add(2)
-
-        result = UnpackingDecisionTree().decide(info)
-        assert result.decision == UnpackingDecision.SHOULD_UNPACK
-        assert result.reason == UnpackingReason.MULTIPLE_INDIVIDUAL_ACCESSES
-        assert result.should_unpack
-
-    def test_partial_array_high_ratio_should_unpack(self) -> None:
-        """Partial array usage with high access ratio should unpack."""
-        info = ArrayAccessInfo(
-            array_name="q",
-            size=5,
-            is_classical=False,
-        )
-        # Access 3 of 5 elements (60%)
-        info.element_accesses.add(0)
-        info.element_accesses.add(2)
-        info.element_accesses.add(4)
-
-        # Note: This won't trigger quantum measurement rule since no elements consumed
-        result = UnpackingDecisionTree().decide(info)
-        assert result.decision == UnpackingDecision.SHOULD_UNPACK
-        assert result.reason == UnpackingReason.PARTIAL_ARRAY_USAGE
-        assert result.should_unpack
-
-    def test_partial_array_low_ratio_should_not_unpack(self) -> None:
-        """Partial array usage with low access ratio should not unpack."""
-        info = ArrayAccessInfo(
-            array_name="q",
-            size=10,
-            is_classical=False,
-        )
-        # Access only 2 of 10 elements (20%)
-        info.element_accesses.add(0)
-        info.element_accesses.add(5)
-
-        result = UnpackingDecisionTree().decide(info)
-        # Could be SINGLE_ELEMENT_ONLY or PARTIAL_ARRAY_USAGE depending on rule order
-        assert result.decision == UnpackingDecision.SHOULD_NOT_UNPACK
-        assert not result.should_unpack
-
-    def test_convenience_function_verbose(self, capsys: CaptureFixture[str]) -> None:
-        """Test the convenience function with verbose output."""
-        info = ArrayAccessInfo(
-            array_name="test_array",
-            size=3,
-            is_classical=True,
-        )
-        info.element_accesses.add(0)
-        info.element_accesses.add(1)
-
-        result = should_unpack_array(info, verbose=True)
-        assert result is True
-
-        captured = capsys.readouterr()
-        assert "test_array" in captured.out
-        assert "SHOULD_UNPACK" in captured.out
-        assert "MULTIPLE_INDIVIDUAL_ACCESSES" in captured.out
-
-
-class TestRealWorldScenarios:
-    """Test realistic scenarios from actual SLR code."""
-
-    def test_simple_quantum_circuit_no_measurement(self) -> None:
-        """Simple circuit with gates only, no measurements - should not unpack."""
-        # Example: H(q[0]); CX(q[0], q[1]); H(q[1])
-        info = ArrayAccessInfo(
-            array_name="q",
-            size=2,
-            is_classical=False,
-        )
-        info.element_accesses.add(0)
-        info.element_accesses.add(1)
-        # No measurements, no consumption
-        # All elements accessed (100%), no special conditions
-
-        result = UnpackingDecisionTree().decide(info)
-        # Should NOT unpack - all elements accessed, can use array operations
-        # The default behavior prefers simpler code (no unpacking)
-        assert not result.should_unpack
-
-    def test_measure_all_qubits_into_classical(self) -> None:
-        """Measure entire quantum register into classical register."""
-        # Example: Measure(q) > c
-        q_info = ArrayAccessInfo(
-            array_name="q",
-            size=5,
-            is_classical=False,
-        )
-        q_info.full_array_accesses.append(10)
-
-        c_info = ArrayAccessInfo(
-            array_name="c",
-            size=5,
-            is_classical=True,
-        )
-        # Classical register receives results but no individual access
-
-        q_result = UnpackingDecisionTree().decide(q_info)
-        c_result = UnpackingDecisionTree().decide(c_info)
-
-        assert not q_result.should_unpack  # Full array measurement
-        assert not c_result.should_unpack  # No individual access
-
-    def test_measure_individual_qubits(self) -> None:
-        """Measure individual qubits separately."""
-        # Example: Measure(q[0]) > c[0]; Measure(q[1]) > c[1]
-        q_info = ArrayAccessInfo(
-            array_name="q",
-            size=3,
-            is_classical=False,
-        )
-        q_info.element_accesses.add(0)
-        q_info.element_accesses.add(1)
-        q_info.elements_consumed.add(0)
-        q_info.elements_consumed.add(1)
-
-        c_info = ArrayAccessInfo(
-            array_name="c",
-            size=3,
-            is_classical=True,
-        )
-        c_info.element_accesses.add(0)
-        c_info.element_accesses.add(1)
-
-        q_result = UnpackingDecisionTree().decide(q_info)
-        c_result = UnpackingDecisionTree().decide(c_info)
-
-        assert q_result.should_unpack  # Individual quantum measurements
-        assert c_result.should_unpack  # Multiple classical accesses
-
-    def test_conditional_reset_pattern(self) -> None:
-        """Conditional reset based on measurement - common error correction pattern."""
-        # Example: m = Measure(q[0]) > c[0]; if c[0]: X(q[0])
-        info = ArrayAccessInfo(
-            array_name="c",
-            size=1,
-            is_classical=True,
-        )
-        info.element_accesses.add(0)
-        info.has_conditionals_between = True
-
-        result = UnpackingDecisionTree().decide(info)
-        assert result.should_unpack  # Conditional access requires unpacking
-
-    def test_measure_then_replace_pattern(self) -> None:
-        """Measure qubit, then replace with fresh qubit - needs unpacking."""
-        # Example: Measure(q[0]); Prep(q[0]); H(q[0])
-        info = ArrayAccessInfo(
-            array_name="q",
-            size=3,
-            is_classical=False,
-        )
-        info.element_accesses.add(0)
-        info.elements_consumed.add(0)
-        info.has_operations_between = True
-
-        result = UnpackingDecisionTree().decide(info)
-        assert result.should_unpack  # Operations after measurement
-
-    def test_partial_measurement_syndrome_extraction(self) -> None:
-        """Measure ancilla qubits for syndrome extraction, keep data qubits."""
-        # Example: ancilla = q[5:10]; Measure(ancilla) > syndrome
-        # Data qubits q[0:5] still used
-        ancilla_info = ArrayAccessInfo(
-            array_name="ancilla",
-            size=5,
-            is_classical=False,
-        )
-        ancilla_info.full_array_accesses.append(20)
-
-        syndrome_info = ArrayAccessInfo(
-            array_name="syndrome",
-            size=5,
-            is_classical=True,
-        )
-        # No individual access
-
-        ancilla_result = UnpackingDecisionTree().decide(ancilla_info)
-        syndrome_result = UnpackingDecisionTree().decide(syndrome_info)
-
-        assert not ancilla_result.should_unpack  # Full array measurement
-        assert not syndrome_result.should_unpack  # No individual access
-
-    def test_steane_code_pattern(self) -> None:
-        """Steane code with data and ancilla qubits."""
-        # Data qubits: individual gates
-        data_info = ArrayAccessInfo(
-            array_name="data",
-            size=7,
-            is_classical=False,
-        )
-        for i in range(7):
-            data_info.element_accesses.add(i)
-
-        # Ancilla qubits: measured individually
-        ancilla_info = ArrayAccessInfo(
-            array_name="ancilla",
-            size=6,
-            is_classical=False,
-        )
-        for i in range(6):
-            ancilla_info.element_accesses.add(i)
-            ancilla_info.elements_consumed.add(i)
-
-        data_result = UnpackingDecisionTree().decide(data_info)
-        ancilla_result = UnpackingDecisionTree().decide(ancilla_info)
-
-        # Data: all elements accessed with no special conditions - default is no unpack
-        # (can use array operations efficiently)
-        assert not data_result.should_unpack
-        # Ancilla: individual measurements REQUIRE unpacking
-        assert ancilla_result.should_unpack
-
-
-class TestEdgeCases:
-    """Test edge cases and boundary conditions."""
-
-    def test_empty_array(self) -> None:
-        """Array of size 0."""
-        info = ArrayAccessInfo(
-            array_name="empty",
-            size=0,
-            is_classical=False,
-        )
-
-        result = UnpackingDecisionTree().decide(info)
-        assert not result.should_unpack
-
-    def test_size_one_array(self) -> None:
-        """Array of size 1."""
-        info = ArrayAccessInfo(
-            array_name="single",
-            size=1,
-            is_classical=False,
-        )
-        info.element_accesses.add(0)
-
-        result = UnpackingDecisionTree().decide(info)
-        # Single element access should not unpack
-        assert not result.should_unpack
-        assert result.reason == UnpackingReason.SINGLE_ELEMENT_ONLY
-
-    def test_conflicting_indicators(self) -> None:
-        """Array with both full access and individual access."""
-        info = ArrayAccessInfo(
-            array_name="conflict",
-            size=3,
-            is_classical=False,
-        )
-        info.full_array_accesses.append(5)  # Full access at position 5
-        info.element_accesses.add(0)  # Individual access
-        info.element_accesses.add(1)
-
-        result = UnpackingDecisionTree().decide(info)
-        # Full array access takes precedence (MUST_NOT_UNPACK)
-        assert not result.should_unpack
-        assert result.reason == UnpackingReason.FULL_ARRAY_ONLY
-
-    def test_all_elements_individually_accessed(self) -> None:
-        """All array elements accessed individually."""
-        info = ArrayAccessInfo(
-            array_name="all",
-            size=4,
-            is_classical=True,
-        )
-        for i in range(4):
-            info.element_accesses.add(i)
-
-        result = UnpackingDecisionTree().decide(info)
-        # Multiple individual accesses on classical array
-        assert result.should_unpack
-        assert result.reason == UnpackingReason.MULTIPLE_INDIVIDUAL_ACCESSES
-
-    def test_exactly_50_percent_access_ratio(self) -> None:
-        """Test boundary at 50% access ratio."""
-        info = ArrayAccessInfo(
-            array_name="half",
-            size=4,
-            is_classical=False,
-        )
-        info.element_accesses.add(0)
-        info.element_accesses.add(1)
-        # 2 of 4 = 50%
-
-        result = UnpackingDecisionTree().decide(info)
-        # Should not unpack at exactly 50% (threshold is > 0.5)
-        assert not result.should_unpack

From d849669b03209ed26bf2a28c58571f55254d52b8 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Thu, 14 May 2026 19:52:56 -0600
Subject: [PATCH 025/136] Apply Codex review fixes: no-arg entrypoint wrap +
 compile diagnostics + stale comments + 3-cycle and cross-register Permute
 coverage

---
 .../src/pecos/slr/slr_converter.py            | 91 +++++++++++++++++--
 .../pecos/unit/test_slr_converter_guppy.py    |  5 +-
 .../tests/slr_tests/ast_guppy/__init__.py     |  7 +-
 .../tests/slr_tests/ast_guppy/_harness.py     | 12 +--
 .../slr_tests/ast_guppy/test_ast_hugr.py      | 28 ++++++
 .../slr_tests/ast_guppy/test_v1_behavioral.py | 41 +++++++++
 .../guppy/test_conditional_resources.py       |  5 +-
 7 files changed, 167 insertions(+), 22 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/slr_converter.py b/python/quantum-pecos/src/pecos/slr/slr_converter.py
index 23248a04d..0d28b269d 100644
--- a/python/quantum-pecos/src/pecos/slr/slr_converter.py
+++ b/python/quantum-pecos/src/pecos/slr/slr_converter.py
@@ -185,7 +185,26 @@ def hugr(self):
         return self._compile_hugr()
 
     def _compile_hugr(self):
+        from pecos.slr.ast import AllocatorDecl, RegisterDecl
+
         guppy_code = self._generate_guppy()
+        program = self._to_ast()
+
+        allocator_sizes: dict[str, int] = {}
+        for decl in getattr(program, "declarations", ()):
+            if isinstance(decl, AllocatorDecl) and decl.parent is None:
+                allocator_sizes.setdefault(decl.name, decl.capacity)
+        if getattr(program, "allocator", None) is not None:
+            top = program.allocator
+            if isinstance(top, AllocatorDecl) and top.parent is None:
+                allocator_sizes.setdefault(top.name, top.capacity)
+
+        result_cregs: list[RegisterDecl] = [
+            decl for decl in getattr(program, "declarations", ()) if isinstance(decl, RegisterDecl) and decl.is_result
+        ]
+
+        wrapper = _build_no_arg_entry_wrapper(allocator_sizes, result_cregs)
+        full_source = guppy_code + wrapper
 
         import importlib.util
         import linecache
@@ -196,13 +215,13 @@ def _compile_hugr(self):
 
         with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
             temp_file = Path(f.name)
-            f.write(guppy_code)
+            f.write(full_source)
 
         module_name = f"_ast_guppy_generated_{temp_file.stem}"
         linecache.cache[str(temp_file)] = (
-            len(guppy_code),
+            len(full_source),
             None,
-            guppy_code.splitlines(keepends=True),
+            full_source.splitlines(keepends=True),
             str(temp_file),
         )
 
@@ -217,12 +236,21 @@ def _compile_hugr(self):
             sys.modules[module_name] = module
             spec.loader.exec_module(module)
 
-            main_func = getattr(module, "main", None)
-            if main_func is None:
-                msg = "No main function found in AST-generated Guppy source"
+            entry_func = getattr(module, "entry", None)
+            if entry_func is None:
+                msg = "No entry function found in AST-generated Guppy source"
                 raise RuntimeError(msg)
 
-            return main_func.compile_function()
+            try:
+                return entry_func.compile()
+            except (AttributeError, TypeError, ValueError, RuntimeError) as exc:
+                truncated = _truncate_source_for_error(full_source)
+                msg = (
+                    f"Failed to compile AST-generated Guppy to HUGR.\n\n"
+                    f"Error: {type(exc).__name__}: {exc}\n\n"
+                    f"Generated Guppy source (truncated):\n{truncated}"
+                )
+                raise RuntimeError(msg) from exc
         finally:
             sys.modules.pop(module_name, None)
             linecache.cache.pop(str(temp_file), None)
@@ -307,3 +335,52 @@ def from_quantum_circuit(cls, qc, *, optimize_parallel: bool = True):
             optimizer = ParallelOptimizer()
             slr_block = optimizer.transform(slr_block)
         return slr_block
+
+
+def _build_no_arg_entry_wrapper(allocator_sizes, result_cregs) -> str:
+    """Generate a no-arg `entry()` wrapper around AST-emitted parameterized `main(...)`.
+
+    The AST emitter produces `main(q: array[qubit, N] @ owned, ...)`. Downstream
+    HUGR consumers (Hugr adapter, Selene) require a no-arg entrypoint, matching
+    the legacy IR generator's shape. This wrapper allocates each root allocator
+    and forwards to main, returning result CReg bits as a flat tuple of bools.
+    """
+    body_lines: list[str] = [
+        f"    {allocator} = array(qubit() for _ in range({size}))" for allocator, size in allocator_sizes.items()
+    ]
+    call_args = ", ".join(allocator_sizes.keys())
+    call_expr = f"main({call_args})"
+
+    if result_cregs:
+        if len(result_cregs) == 1:
+            body_lines.append(f"    {result_cregs[0].name} = {call_expr}")
+        else:
+            result_names = ", ".join(decl.name for decl in result_cregs)
+            body_lines.append(f"    {result_names} = {call_expr}")
+
+        return_parts: list[str] = []
+        for decl in result_cregs:
+            return_parts.extend(f"{decl.name}[{i}]" for i in range(decl.size))
+        return_expr = ", ".join(return_parts)
+        if len(return_parts) == 1:
+            return_expr += ","
+        body_lines.append(f"    return {return_expr}")
+
+        bool_count = sum(decl.size for decl in result_cregs)
+        return_ann = "tuple[bool]" if bool_count == 1 else "tuple[" + ", ".join(["bool"] * bool_count) + "]"
+    else:
+        body_lines.append(f"    {call_expr}")
+        return_ann = "None"
+
+    body = "\n".join(body_lines) if body_lines else "    pass"
+    return f"\n\n@guppy\ndef entry() -> {return_ann}:\n{body}\n"
+
+
+def _truncate_source_for_error(source: str, max_lines: int = 80) -> str:
+    """Truncate Guppy source for an error message. Shows first max_lines plus tail."""
+    lines = source.splitlines()
+    if len(lines) <= max_lines:
+        return source
+    head = lines[: max_lines - 10]
+    tail = lines[-10:]
+    return "\n".join([*head, f"... ({len(lines) - max_lines} lines elided) ...", *tail])
diff --git a/python/quantum-pecos/tests/pecos/unit/test_slr_converter_guppy.py b/python/quantum-pecos/tests/pecos/unit/test_slr_converter_guppy.py
index 9c0b60d0a..8a4aa247c 100644
--- a/python/quantum-pecos/tests/pecos/unit/test_slr_converter_guppy.py
+++ b/python/quantum-pecos/tests/pecos/unit/test_slr_converter_guppy.py
@@ -12,8 +12,9 @@
 """Tests for SlrConverter Guppy functionality.
 
 The v1 AST -> Guppy emitter is exercised via compile-and-run acceptance tests
-under ``tests/slr_tests/ast_guppy/``. Tests here cover surviving non-string
-checks (`SlrConverter.hugr()` legacy IR path, basic structural sanity) only.
+under ``tests/slr_tests/ast_guppy/``. Tests here cover basic structural sanity
+of `SlrConverter.hugr()` (AST-routed post-cutover, wraps `main` in a no-arg
+`entry()` and compiles that).
 """
 
 from pecos.slr import CReg, Main, QReg, SlrConverter
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/__init__.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/__init__.py
index d405f6835..41a4ba8b1 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/__init__.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/__init__.py
@@ -14,7 +14,8 @@
 on this branch (`feat/ast-guppy-v1`). As features land, the xfail
 mark comes off the corresponding test.
 
-Do not route acceptance through `SlrConverter.hugr()` until cutover
-(Step 4 in the forward path); `hugr()` still falls back to the
-legacy IR generator and would mask AST-path failures.
+Post-cutover, `SlrConverter.hugr()` is also AST-routed (wraps `main`
+in a no-arg `entry()` and compiles that). Acceptance tests prefer
+`SlrConverter.guppy()` / `_harness.assert_ast_guppy_compiles` so
+failures point at the parameterized function, not the entry wrapper.
 """
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/_harness.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/_harness.py
index 2b461dbcb..83b2002c4 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/_harness.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/_harness.py
@@ -6,13 +6,11 @@
 file, imports it as a fresh module, and calls `main.compile_function()`
 on the resulting Guppy function.
 
-This is intentionally NOT routed through `SlrConverter.hugr()`. That
-path still falls back to the legacy IR generator and would mask
-AST-path failures.
-
-Reference for the compile machinery:
-`pecos/slr/gen_codes/guppy/hugr_compiler.py::HugrCompiler.compile_to_hugr`
-does the same dance for the legacy IR path; we lift the technique.
+Post-cutover, `SlrConverter.hugr()` also routes through the AST path
+(wrapping `main(...)` in a no-arg `entry()` and calling
+`entry.compile()`). This harness compiles `main.compile_function()`
+directly so failures point at the parameterized function, not at the
+entry wrapper.
 """
 
 from __future__ import annotations
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
index e7100095e..536c9bf5b 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
@@ -67,3 +67,31 @@ def test_hugr_accepts_inline_measure_creg_result() -> None:
     hugr = SlrConverter(prog).hugr()
 
     assert hugr is not None
+
+
+def test_hugr_returns_no_arg_entrypoint_runnable_via_hugr_adapter() -> None:
+    """Pin the post-cutover entrypoint contract.
+
+    `SlrConverter.hugr()` must return a Package whose `to_str()` produces
+    HUGR JSON for a no-arg entrypoint -- the same shape `Guppy(func).compile()`
+    would produce. This is required for downstream consumers (`pecos.Hugr(bytes)`,
+    Selene runtime, `pecos_rslib.HugrProgram`) that expect a runnable program,
+    not a parameterized function definition.
+    """
+    from pecos import Hugr, selene_engine, sim
+
+    prog = Main(
+        q := QReg("q", 2),
+        c := CReg("c", 2),
+        qb.H(q[0]),
+        qb.CX(q[0], q[1]),
+        Measure(q) > c,
+    )
+
+    package = SlrConverter(prog).hugr()
+    hugr_bytes = package.to_str().encode("utf-8")
+
+    result = sim(Hugr(hugr_bytes)).classical(selene_engine()).qubits(2).seed(42).run(10)
+
+    raw = result.to_dict() if hasattr(result, "to_dict") else result
+    assert raw, "Hugr adapter produced no measurement records from .hugr() output"
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py
index e50194f10..b4c9be7da 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py
@@ -127,6 +127,47 @@ def test_quantum_permute_is_observed_by_later_measurements(self) -> None:
         assert all(r["measurement_0"] == 0 for r in records)
         assert all(r["measurement_1"] == 1 for r in records)
 
+    def test_quantum_permute_three_cycle(self) -> None:
+        """3-cycle Permute (q0, q1, q2) -> (q2, q0, q1).
+
+        State before permute: |1>|0>|0> (X on q[0]). Permute moves the X
+        excitation from slot 0 to slot 1 in the post-permute view, so a
+        per-slot measurement should read out (0, 1, 0).
+        """
+        prog = Main(
+            q := QReg("q", 3),
+            c := CReg("c", 3),
+            qb.X(q[0]),
+            Permute([q[0], q[1], q[2]], [q[2], q[0], q[1]]),
+            Measure(q[0]) > c[0],
+            Measure(q[1]) > c[1],
+            Measure(q[2]) > c[2],
+        )
+        records = run_ast_guppy_via_selene(prog, shots=10)
+        assert all(r["measurement_0"] == 0 for r in records)
+        assert all(r["measurement_1"] == 1 for r in records)
+        assert all(r["measurement_2"] == 0 for r in records)
+
+    def test_quantum_permute_cross_register(self) -> None:
+        """Permute spanning two QRegs must remap slots across owned-local groups."""
+        prog = Main(
+            a := QReg("a", 2),
+            b := QReg("b", 2),
+            c := CReg("c", 4),
+            qb.X(a[0]),
+            qb.X(b[1]),
+            Permute([a[0], a[1], b[0], b[1]], [b[1], b[0], a[1], a[0]]),
+            Measure(a[0]) > c[0],
+            Measure(a[1]) > c[1],
+            Measure(b[0]) > c[2],
+            Measure(b[1]) > c[3],
+        )
+        records = run_ast_guppy_via_selene(prog, shots=10)
+        assert all(r["measurement_0"] == 1 for r in records)
+        assert all(r["measurement_1"] == 0 for r in records)
+        assert all(r["measurement_2"] == 0 for r in records)
+        assert all(r["measurement_3"] == 1 for r in records)
+
 
 # ── Bell / GHZ correlation tests ──────────────────────────────────────────
 
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_conditional_resources.py b/python/quantum-pecos/tests/slr_tests/guppy/test_conditional_resources.py
index 362f373bc..4d35f9625 100644
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_conditional_resources.py
+++ b/python/quantum-pecos/tests/slr_tests/guppy/test_conditional_resources.py
@@ -7,9 +7,8 @@
 the supported state-preserving conditional in
 ``tests/slr_tests/ast_guppy/test_v1_acceptance.py::TestControlFlow``.
 
-The remaining test below targets the legacy ``SlrConverter.hugr()``
-path, which still routes through the legacy IR generator and is
-unaffected by the AST emitter rewrite.
+The remaining test below exercises a supported state-preserving
+conditional through ``SlrConverter.hugr()`` (AST-routed post-cutover).
 """
 
 import pytest

From c0c59c78e6faf52fe8e8d409d43977be0ab2c03b Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Thu, 14 May 2026 20:11:48 -0600
Subject: [PATCH 026/136] Fix Codex review v2 findings: entry wrapper mirrors
 emitter return shape (explicit Return passthrough + inline CReg result
 capture); broaden compile diagnostic catch; promote wrapper to shared
 entry_wrapper module

---
 .../pecos/slr/ast/codegen/entry_wrapper.py    | 199 ++++++++++++++++++
 .../src/pecos/slr/slr_converter.py            |  70 +-----
 .../slr_tests/ast_guppy/_selene_harness.py    |  86 +-------
 .../slr_tests/ast_guppy/test_ast_hugr.py      |  46 +++-
 4 files changed, 257 insertions(+), 144 deletions(-)
 create mode 100644 python/quantum-pecos/src/pecos/slr/ast/codegen/entry_wrapper.py

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/entry_wrapper.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/entry_wrapper.py
new file mode 100644
index 000000000..a4400da86
--- /dev/null
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/entry_wrapper.py
@@ -0,0 +1,199 @@
+# Copyright 2026 The PECOS Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations under the License.
+
+"""No-arg `entry()` wrapper for AST-emitted parameterized `main(...)`.
+
+The AST emitter produces `main(q: array[qubit, N] @ owned, ...)`. Downstream
+HUGR consumers (`pecos.Hugr(bytes)`, `pecos_rslib.HugrProgram`, the Selene
+runtime) require a no-arg entrypoint, matching the legacy IR generator's
+shape. This module builds that wrapper by mirroring the same return-shape
+logic the emitter uses, so the wrapper signature matches main's exactly.
+
+Three modes match `AstToGuppy._return_type`:
+- Explicit `Return(...)` -> pass through main's return value unchanged.
+- One or more result CRegs (declared or inline-from-Measure) -> flatten to
+  `tuple[bool, ...]` for Selene's measurement-record model.
+- Neither -> `entry() -> None` and discard.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from pecos.slr.ast import (
+    AllocatorDecl,
+    BitExpr,
+    ForStmt,
+    IfStmt,
+    LiteralExpr,
+    MeasureOp,
+    ParallelBlock,
+    RegisterDecl,
+    RepeatStmt,
+    ReturnOp,
+    WhileStmt,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from pecos.slr.ast import Expression, Program, Statement
+
+
+@dataclass(frozen=True)
+class EntryWrapperInfo:
+    """Metadata extracted from the AST program for building the wrapper."""
+
+    allocator_sizes: dict[str, int]
+    result_cregs: list[RegisterDecl]
+    explicit_return: ReturnOp | None
+
+
+def build_no_arg_entry_wrapper(program: Program) -> tuple[str, EntryWrapperInfo]:
+    """Generate the wrapper source and return the metadata used to build it.
+
+    Returns:
+        A `(source, info)` tuple. `source` is the Guppy snippet defining
+        `entry()`; concatenate it after the main source. `info` exposes the
+        allocator sizes, result CRegs, and explicit Return (if any) that the
+        caller may need (e.g., Selene's measurement-key generation).
+    """
+    info = _collect_info(program)
+    source = _render_wrapper(info)
+    return source, info
+
+
+def _collect_info(program: Program) -> EntryWrapperInfo:
+    allocator_sizes: dict[str, int] = {}
+    for decl in getattr(program, "declarations", ()):
+        if isinstance(decl, AllocatorDecl) and decl.parent is None:
+            allocator_sizes.setdefault(decl.name, decl.capacity)
+    top = getattr(program, "allocator", None)
+    if isinstance(top, AllocatorDecl) and top.parent is None:
+        allocator_sizes.setdefault(top.name, top.capacity)
+
+    declared: dict[str, RegisterDecl] = {}
+    for decl in getattr(program, "declarations", ()):
+        if isinstance(decl, RegisterDecl):
+            declared[decl.name] = decl
+
+    body = getattr(program, "body", ())
+    inline_max: dict[str, int] = {}
+    _walk_for_measure_results(body, declared, inline_max)
+
+    result_cregs: list[RegisterDecl] = [decl for decl in declared.values() if decl.is_result]
+    for name, max_index in inline_max.items():
+        result_cregs.append(RegisterDecl(name=name, size=max_index + 1, is_result=True))
+
+    explicit_return = body[-1] if body and isinstance(body[-1], ReturnOp) else None
+
+    return EntryWrapperInfo(
+        allocator_sizes=allocator_sizes,
+        result_cregs=result_cregs,
+        explicit_return=explicit_return,
+    )
+
+
+def _walk_for_measure_results(
+    body: Iterable[Statement],
+    declared: dict[str, RegisterDecl],
+    inline_max: dict[str, int],
+) -> None:
+    for stmt in body:
+        if isinstance(stmt, MeasureOp):
+            for ref in stmt.results:
+                if ref.register not in declared:
+                    inline_max[ref.register] = max(inline_max.get(ref.register, -1), ref.index)
+        elif isinstance(stmt, IfStmt):
+            _walk_for_measure_results(stmt.then_body, declared, inline_max)
+            _walk_for_measure_results(stmt.else_body, declared, inline_max)
+        elif isinstance(stmt, (RepeatStmt, ForStmt, WhileStmt, ParallelBlock)):
+            _walk_for_measure_results(stmt.body, declared, inline_max)
+
+
+def _render_wrapper(info: EntryWrapperInfo) -> str:
+    body_lines: list[str] = [
+        f"    {name} = array(qubit() for _ in range({size}))" for name, size in info.allocator_sizes.items()
+    ]
+    call_args = ", ".join(info.allocator_sizes.keys())
+    call_expr = f"main({call_args})"
+
+    if info.explicit_return is not None:
+        body_lines.append(f"    return {call_expr}")
+        return_ann = _explicit_return_type(info)
+    elif info.result_cregs:
+        if len(info.result_cregs) == 1:
+            body_lines.append(f"    {info.result_cregs[0].name} = {call_expr}")
+        else:
+            names = ", ".join(decl.name for decl in info.result_cregs)
+            body_lines.append(f"    {names} = {call_expr}")
+
+        flat: list[str] = []
+        for decl in info.result_cregs:
+            flat.extend(f"{decl.name}[{i}]" for i in range(decl.size))
+        return_expr = ", ".join(flat)
+        if len(flat) == 1:
+            return_expr += ","
+        body_lines.append(f"    return {return_expr}")
+
+        bool_count = sum(decl.size for decl in info.result_cregs)
+        return_ann = "tuple[bool]" if bool_count == 1 else "tuple[" + ", ".join(["bool"] * bool_count) + "]"
+    else:
+        body_lines.append(f"    {call_expr}")
+        return_ann = "None"
+
+    body = "\n".join(body_lines) if body_lines else "    pass"
+    return f"\n\n@guppy\ndef entry() -> {return_ann}:\n{body}\n"
+
+
+def _explicit_return_type(info: EntryWrapperInfo) -> str:
+    assert info.explicit_return is not None  # noqa: S101
+    creg_sizes = {decl.name: decl.size for decl in info.result_cregs}
+    types = [_return_value_type(value, info.allocator_sizes, creg_sizes) for value in info.explicit_return.values]
+    return _tuple_type(types)
+
+
+def _return_value_type(value: Expression | str, allocator_sizes: dict[str, int], creg_sizes: dict[str, int]) -> str:
+    if isinstance(value, str):
+        if value in allocator_sizes:
+            return f"array[qubit, {allocator_sizes[value]}]"
+        if value in creg_sizes:
+            return f"array[bool, {creg_sizes[value]}]"
+        msg = f"Unsupported Guppy return value {value!r}"
+        raise ValueError(msg)
+    if isinstance(value, BitExpr):
+        return "bool"
+    if isinstance(value, LiteralExpr) and isinstance(value.value, bool):
+        return "bool"
+    if isinstance(value, LiteralExpr) and isinstance(value.value, int):
+        return "int"
+    msg = f"Unsupported Guppy return expression {value!r}"
+    raise ValueError(msg)
+
+
+def _tuple_type(types: list[str]) -> str:
+    """Mirror `AstToGuppy._tuple_type`: empty -> None, single -> bare, multi -> tuple[...]."""
+    if not types:
+        return "None"
+    if len(types) == 1:
+        return types[0]
+    return "tuple[" + ", ".join(types) + "]"
+
+
+def truncate_source_for_error(source: str, max_lines: int = 80) -> str:
+    """Truncate generated Guppy source for inclusion in an error message."""
+    lines = source.splitlines()
+    if len(lines) <= max_lines:
+        return source
+    head = lines[: max_lines - 10]
+    tail = lines[-10:]
+    return "\n".join([*head, f"... ({len(lines) - max_lines} lines elided) ...", *tail])
diff --git a/python/quantum-pecos/src/pecos/slr/slr_converter.py b/python/quantum-pecos/src/pecos/slr/slr_converter.py
index 0d28b269d..cf7823386 100644
--- a/python/quantum-pecos/src/pecos/slr/slr_converter.py
+++ b/python/quantum-pecos/src/pecos/slr/slr_converter.py
@@ -185,25 +185,12 @@ def hugr(self):
         return self._compile_hugr()
 
     def _compile_hugr(self):
-        from pecos.slr.ast import AllocatorDecl, RegisterDecl
+        from pecos.slr.ast.codegen.entry_wrapper import build_no_arg_entry_wrapper, truncate_source_for_error
 
         guppy_code = self._generate_guppy()
         program = self._to_ast()
 
-        allocator_sizes: dict[str, int] = {}
-        for decl in getattr(program, "declarations", ()):
-            if isinstance(decl, AllocatorDecl) and decl.parent is None:
-                allocator_sizes.setdefault(decl.name, decl.capacity)
-        if getattr(program, "allocator", None) is not None:
-            top = program.allocator
-            if isinstance(top, AllocatorDecl) and top.parent is None:
-                allocator_sizes.setdefault(top.name, top.capacity)
-
-        result_cregs: list[RegisterDecl] = [
-            decl for decl in getattr(program, "declarations", ()) if isinstance(decl, RegisterDecl) and decl.is_result
-        ]
-
-        wrapper = _build_no_arg_entry_wrapper(allocator_sizes, result_cregs)
+        wrapper, _info = build_no_arg_entry_wrapper(program)
         full_source = guppy_code + wrapper
 
         import importlib.util
@@ -243,8 +230,8 @@ def _compile_hugr(self):
 
             try:
                 return entry_func.compile()
-            except (AttributeError, TypeError, ValueError, RuntimeError) as exc:
-                truncated = _truncate_source_for_error(full_source)
+            except Exception as exc:
+                truncated = truncate_source_for_error(full_source)
                 msg = (
                     f"Failed to compile AST-generated Guppy to HUGR.\n\n"
                     f"Error: {type(exc).__name__}: {exc}\n\n"
@@ -335,52 +322,3 @@ def from_quantum_circuit(cls, qc, *, optimize_parallel: bool = True):
             optimizer = ParallelOptimizer()
             slr_block = optimizer.transform(slr_block)
         return slr_block
-
-
-def _build_no_arg_entry_wrapper(allocator_sizes, result_cregs) -> str:
-    """Generate a no-arg `entry()` wrapper around AST-emitted parameterized `main(...)`.
-
-    The AST emitter produces `main(q: array[qubit, N] @ owned, ...)`. Downstream
-    HUGR consumers (Hugr adapter, Selene) require a no-arg entrypoint, matching
-    the legacy IR generator's shape. This wrapper allocates each root allocator
-    and forwards to main, returning result CReg bits as a flat tuple of bools.
-    """
-    body_lines: list[str] = [
-        f"    {allocator} = array(qubit() for _ in range({size}))" for allocator, size in allocator_sizes.items()
-    ]
-    call_args = ", ".join(allocator_sizes.keys())
-    call_expr = f"main({call_args})"
-
-    if result_cregs:
-        if len(result_cregs) == 1:
-            body_lines.append(f"    {result_cregs[0].name} = {call_expr}")
-        else:
-            result_names = ", ".join(decl.name for decl in result_cregs)
-            body_lines.append(f"    {result_names} = {call_expr}")
-
-        return_parts: list[str] = []
-        for decl in result_cregs:
-            return_parts.extend(f"{decl.name}[{i}]" for i in range(decl.size))
-        return_expr = ", ".join(return_parts)
-        if len(return_parts) == 1:
-            return_expr += ","
-        body_lines.append(f"    return {return_expr}")
-
-        bool_count = sum(decl.size for decl in result_cregs)
-        return_ann = "tuple[bool]" if bool_count == 1 else "tuple[" + ", ".join(["bool"] * bool_count) + "]"
-    else:
-        body_lines.append(f"    {call_expr}")
-        return_ann = "None"
-
-    body = "\n".join(body_lines) if body_lines else "    pass"
-    return f"\n\n@guppy\ndef entry() -> {return_ann}:\n{body}\n"
-
-
-def _truncate_source_for_error(source: str, max_lines: int = 80) -> str:
-    """Truncate Guppy source for an error message. Shows first max_lines plus tail."""
-    lines = source.splitlines()
-    if len(lines) <= max_lines:
-        return source
-    head = lines[: max_lines - 10]
-    tail = lines[-10:]
-    return "\n".join([*head, f"... ({len(lines) - max_lines} lines elided) ...", *tail])
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py
index dafcbd8f0..2dbf2d5ac 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py
@@ -34,11 +34,13 @@
 
 from pecos import Guppy, selene_engine, sim
 from pecos.slr import SlrConverter
-from pecos.slr.ast import AllocatorDecl, RegisterDecl, slr_to_ast
+from pecos.slr.ast import slr_to_ast
+from pecos.slr.ast.codegen.entry_wrapper import build_no_arg_entry_wrapper
 
 if TYPE_CHECKING:
     import pecos_rslib
     from pecos.slr import Block
+    from pecos.slr.ast import RegisterDecl
 
 
 _DEFAULT_SHOTS = 100
@@ -65,52 +67,22 @@ def run_ast_guppy_via_selene(
     ast_source = SlrConverter(slr_program).guppy()
     program = slr_to_ast(slr_program)
 
-    allocator_sizes = _allocator_sizes(program)
-    cregs = _result_cregs(program)
-    if not cregs:
+    wrapper, info = build_no_arg_entry_wrapper(program)
+    if not info.result_cregs or info.explicit_return is not None:
         msg = (
-            "Behavioral test requires at least one result CReg. "
+            "Selene behavioral test requires at least one result CReg and no explicit Return. "
             "v1 acceptance Selene tests should declare CRegs and write measurement bits into them."
         )
         raise ValueError(msg)
 
-    wrapper = _build_entry_wrapper(allocator_sizes, cregs)
     full_source = ast_source + wrapper
 
     entry_func = _import_entry_function(full_source)
-    total_qubits = sum(allocator_sizes.values())
+    total_qubits = sum(info.allocator_sizes.values())
 
-    result = (
-        sim(Guppy(entry_func))
-        .classical(selene_engine())
-        .qubits(max(total_qubits, 1))
-        .seed(seed)
-        .run(shots)
-    )
+    result = sim(Guppy(entry_func)).classical(selene_engine()).qubits(max(total_qubits, 1)).seed(seed).run(shots)
 
-    return _shot_records(result, _result_keys(cregs))
-
-
-def _allocator_sizes(program: object) -> dict[str, int]:
-    """Map root allocator name -> capacity. Same iteration order as the emitter."""
-    sizes: dict[str, int] = {}
-    for decl in getattr(program, "declarations", ()):
-        if isinstance(decl, AllocatorDecl) and decl.parent is None:
-            sizes.setdefault(decl.name, decl.capacity)
-    if getattr(program, "allocator", None) is not None:
-        decl = program.allocator
-        if isinstance(decl, AllocatorDecl) and decl.parent is None:
-            sizes.setdefault(decl.name, decl.capacity)
-    return sizes
-
-
-def _result_cregs(program: object) -> list[RegisterDecl]:
-    """Return result-flagged CReg declarations in declaration order."""
-    return [
-        decl
-        for decl in getattr(program, "declarations", ())
-        if isinstance(decl, RegisterDecl) and decl.is_result
-    ]
+    return _shot_records(result, _result_keys(info.result_cregs))
 
 
 def _result_keys(cregs: list[RegisterDecl]) -> list[str]:
@@ -129,46 +101,6 @@ def _result_keys(cregs: list[RegisterDecl]) -> list[str]:
     return keys
 
 
-def _build_entry_wrapper(
-    allocator_sizes: dict[str, int],
-    cregs: list[RegisterDecl],
-) -> str:
-    """Generate the no-arg `entry()` wrapper that Selene needs.
-
-    Wrapper allocates each root allocator's qubits, calls the AST-
-    emitted `main(...)` with them, and unpacks the returned CReg
-    arrays into a flat tuple of bools.
-    """
-    if not cregs:
-        msg = "Refusing to build wrapper without result CRegs"
-        raise ValueError(msg)
-
-    bool_count = sum(decl.size for decl in cregs)
-    return_ann = "tuple[bool]" if bool_count == 1 else "tuple[" + ", ".join(["bool"] * bool_count) + "]"
-
-    body_lines: list[str] = [
-        f"    {allocator} = array(qubit() for _ in range({size}))" for allocator, size in allocator_sizes.items()
-    ]
-
-    call_args = ", ".join(allocator_sizes.keys())
-    if len(cregs) == 1:
-        body_lines.append(f"    {cregs[0].name} = main({call_args})")
-    else:
-        result_names = ", ".join(decl.name for decl in cregs)
-        body_lines.append(f"    {result_names} = main({call_args})")
-
-    return_parts: list[str] = []
-    for decl in cregs:
-        return_parts.extend(f"{decl.name}[{i}]" for i in range(decl.size))
-    return_expr = ", ".join(return_parts)
-    if len(return_parts) == 1:
-        return_expr += ","
-    body_lines.append(f"    return {return_expr}")
-
-    body = "\n".join(body_lines)
-    return f"\n\n@guppy\ndef entry() -> {return_ann}:\n{body}\n"
-
-
 def _import_entry_function(source: str) -> object:
     """Write source to a temp file, import, and return the `entry` callable."""
     with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
index 536c9bf5b..18613ef22 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import pytest
-from pecos.slr import CReg, For, LoopVar, Main, QReg, SlrConverter, While
+from pecos.slr import CReg, For, LoopVar, Main, QReg, Return, SlrConverter, While
 from pecos.slr.ast.codegen.guppy import GuppyCodegenError
 from pecos.slr.qeclib import qubit as qb
 from pecos.slr.qeclib.qubit.measures import Measure
@@ -95,3 +95,47 @@ def test_hugr_returns_no_arg_entrypoint_runnable_via_hugr_adapter() -> None:
 
     raw = result.to_dict() if hasattr(result, "to_dict") else result
     assert raw, "Hugr adapter produced no measurement records from .hugr() output"
+
+
+def test_hugr_supports_explicit_return_of_root_allocator() -> None:
+    """Regression for Codex finding #1.
+
+    A v1 program with an explicit `Return(q)` (no result CRegs) must compile.
+    The wrapper must pass main's return value through, not silently discard it
+    (which produces Guppy `UnnamedExprNotUsedError`).
+    """
+    prog = Main(
+        q := QReg("q", 1),
+        qb.H(q[0]),
+        Return(q),
+    )
+
+    hugr = SlrConverter(prog).hugr()
+
+    assert hugr is not None
+
+
+def test_hugr_inline_measure_creg_round_trips_through_selene() -> None:
+    """Regression for Codex finding #2.
+
+    The AST emitter infers inline `CReg("final", n)` registers from
+    `Measure(q) > CReg(...)` and main returns them. The entry wrapper must
+    capture and flatten those results -- not discard them -- so downstream
+    consumers see measurement records.
+    """
+    from pecos import Hugr, selene_engine, sim
+
+    prog = Main(
+        q := QReg("qi", 2),
+        qb.H(q[0]),
+        qb.CX(q[0], q[1]),
+        Measure(q) > CReg("final", 2),
+    )
+
+    package = SlrConverter(prog).hugr()
+    hugr_bytes = package.to_str().encode("utf-8")
+
+    result = sim(Hugr(hugr_bytes)).classical(selene_engine()).qubits(2).seed(42).run(10)
+
+    raw = result.to_dict() if hasattr(result, "to_dict") else result
+    assert raw, "Inline-CReg .hugr() output produced no measurement records"

From 139912b04275d3aa55c6e870824a526018b90d8b Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Thu, 14 May 2026 20:23:38 -0600
Subject: [PATCH 027/136] Mirror emitter for non-result-CReg Return values;
 cover nested-control-flow inline Measure in regression tests

---
 .../pecos/slr/ast/codegen/entry_wrapper.py    | 20 ++++++-
 .../slr_tests/ast_guppy/test_ast_hugr.py      | 59 ++++++++++++++++++-
 2 files changed, 75 insertions(+), 4 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/entry_wrapper.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/entry_wrapper.py
index a4400da86..c36b3c580 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/entry_wrapper.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/entry_wrapper.py
@@ -51,11 +51,19 @@
 
 @dataclass(frozen=True)
 class EntryWrapperInfo:
-    """Metadata extracted from the AST program for building the wrapper."""
+    """Metadata extracted from the AST program for building the wrapper.
+
+    `all_creg_sizes` mirrors the emitter's `context.registers` lookup view
+    used by `AstToGuppy._return_value_type`: every declared CReg (regardless
+    of `is_result`) plus every inline-Measure-introduced result CReg. Needed
+    so an explicit `Return(...)` referencing a non-result-flagged declared
+    CReg resolves the same way the emitter does (not as `ValueError`).
+    """
 
     allocator_sizes: dict[str, int]
     result_cregs: list[RegisterDecl]
     explicit_return: ReturnOp | None
+    all_creg_sizes: dict[str, int]
 
 
 def build_no_arg_entry_wrapper(program: Program) -> tuple[str, EntryWrapperInfo]:
@@ -94,12 +102,17 @@ def _collect_info(program: Program) -> EntryWrapperInfo:
     for name, max_index in inline_max.items():
         result_cregs.append(RegisterDecl(name=name, size=max_index + 1, is_result=True))
 
+    all_creg_sizes: dict[str, int] = {name: decl.size for name, decl in declared.items()}
+    for name, max_index in inline_max.items():
+        all_creg_sizes[name] = max_index + 1
+
     explicit_return = body[-1] if body and isinstance(body[-1], ReturnOp) else None
 
     return EntryWrapperInfo(
         allocator_sizes=allocator_sizes,
         result_cregs=result_cregs,
         explicit_return=explicit_return,
+        all_creg_sizes=all_creg_sizes,
     )
 
 
@@ -157,8 +170,9 @@ def _render_wrapper(info: EntryWrapperInfo) -> str:
 
 def _explicit_return_type(info: EntryWrapperInfo) -> str:
     assert info.explicit_return is not None  # noqa: S101
-    creg_sizes = {decl.name: decl.size for decl in info.result_cregs}
-    types = [_return_value_type(value, info.allocator_sizes, creg_sizes) for value in info.explicit_return.values]
+    types = [
+        _return_value_type(value, info.allocator_sizes, info.all_creg_sizes) for value in info.explicit_return.values
+    ]
     return _tuple_type(types)
 
 
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
index 18613ef22..e92a650c6 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import pytest
-from pecos.slr import CReg, For, LoopVar, Main, QReg, Return, SlrConverter, While
+from pecos.slr import CReg, For, LoopVar, Main, QReg, Repeat, Return, SlrConverter, While
 from pecos.slr.ast.codegen.guppy import GuppyCodegenError
 from pecos.slr.qeclib import qubit as qb
 from pecos.slr.qeclib.qubit.measures import Measure
@@ -139,3 +139,60 @@ def test_hugr_inline_measure_creg_round_trips_through_selene() -> None:
 
     raw = result.to_dict() if hasattr(result, "to_dict") else result
     assert raw, "Inline-CReg .hugr() output produced no measurement records"
+
+
+def test_hugr_inline_measure_creg_inside_nested_repeat() -> None:
+    """Walker must descend into nested control-flow bodies (Repeat/If/For/While/Parallel).
+
+    `Measure(q[0]) > CReg("flag", 1)` is buried inside a Repeat body. The wrapper's
+    `_walk_for_measure_results` must still find "flag" as an inline result register
+    and the entry wrapper must capture+flatten it -- otherwise the package compiles
+    but downstream sees no measurement record from the nested Measure.
+    """
+    from pecos import Hugr, selene_engine, sim
+
+    prog = Main(
+        q := QReg("q", 1),
+        Repeat(2).block(
+            qb.X(q[0]),
+            Measure(q[0]) > CReg("flag", 1),
+            qb.Prep(q[0]),
+        ),
+    )
+
+    package = SlrConverter(prog).hugr()
+    hugr_bytes = package.to_str().encode("utf-8")
+
+    result = sim(Hugr(hugr_bytes)).classical(selene_engine()).qubits(1).seed(42).run(5)
+
+    raw = result.to_dict() if hasattr(result, "to_dict") else result
+    assert raw, "Nested inline-CReg .hugr() output produced no measurement records"
+
+
+def test_hugr_explicit_return_of_non_result_creg() -> None:
+    """Pin entry_wrapper / emitter parity on declared non-result CRegs.
+
+    The emitter's `_return_value_type` resolves any declared CReg name in
+    `Return(...)` -- `is_result` is not consulted. The wrapper must mirror
+    this exactly so it can't silently diverge. Without this fix the wrapper's
+    `_explicit_return_type` looked up only `info.result_cregs` (filtered to
+    `is_result=True`), so `Return(c)` for `c = CReg(..., result=False)` would
+    raise `ValueError` while the emitter happily compiled.
+
+    Note: the combo `result=False` + `Return(c)` is itself a design quirk
+    (the two flags say opposite things). Whether v1 should reject this in
+    preflight, or whether SLR should adopt a `result()` / explicit-output
+    mechanism instead, is a separate v1-followup question. This test only
+    pins wrapper/emitter parity for the current semantics.
+    """
+    prog = Main(
+        q := QReg("q", 1),
+        c := CReg("c", 1, result=False),
+        qb.Prep(q[0]),
+        Measure(q[0]) > c[0],
+        Return(c),
+    )
+
+    hugr = SlrConverter(prog).hugr()
+
+    assert hugr is not None

From bb58b52d044b97854a73d02a6e5d7a6b29b8f03a Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Thu, 14 May 2026 20:41:12 -0600
Subject: [PATCH 028/136] Widen compile-error diagnostics to module-load
 failures; factor out _load_and_compile_entry helper

---
 .../src/pecos/slr/slr_converter.py            | 46 ++++++++++++-------
 1 file changed, 29 insertions(+), 17 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/slr_converter.py b/python/quantum-pecos/src/pecos/slr/slr_converter.py
index cf7823386..9609231d7 100644
--- a/python/quantum-pecos/src/pecos/slr/slr_converter.py
+++ b/python/quantum-pecos/src/pecos/slr/slr_converter.py
@@ -193,7 +193,6 @@ def _compile_hugr(self):
         wrapper, _info = build_no_arg_entry_wrapper(program)
         full_source = guppy_code + wrapper
 
-        import importlib.util
         import linecache
         import sys
         import tempfile
@@ -213,23 +212,8 @@ def _compile_hugr(self):
         )
 
         try:
-            spec = importlib.util.spec_from_file_location(module_name, temp_file)
-            if spec is None or spec.loader is None:
-                msg = "Failed to create module spec for AST-generated Guppy source"
-                raise RuntimeError(msg)
-
-            module = importlib.util.module_from_spec(spec)
-            module.__file__ = str(temp_file)
-            sys.modules[module_name] = module
-            spec.loader.exec_module(module)
-
-            entry_func = getattr(module, "entry", None)
-            if entry_func is None:
-                msg = "No entry function found in AST-generated Guppy source"
-                raise RuntimeError(msg)
-
             try:
-                return entry_func.compile()
+                return _load_and_compile_entry(temp_file, module_name)
             except Exception as exc:
                 truncated = truncate_source_for_error(full_source)
                 msg = (
@@ -322,3 +306,31 @@ def from_quantum_circuit(cls, qc, *, optimize_parallel: bool = True):
             optimizer = ParallelOptimizer()
             slr_block = optimizer.transform(slr_block)
         return slr_block
+
+
+def _load_and_compile_entry(temp_file, module_name: str):
+    """Import the AST-generated module from `temp_file` and compile its `entry()`.
+
+    Failures here (spec creation, exec_module raising on import/decorator/syntax
+    errors, missing `entry`, Guppy compile errors) propagate to the caller so a
+    single outer except can attach the generated source to the error message.
+    """
+    import importlib.util
+    import sys
+
+    spec = importlib.util.spec_from_file_location(module_name, temp_file)
+    if spec is None or spec.loader is None:
+        msg = "Failed to create module spec for AST-generated Guppy source"
+        raise RuntimeError(msg)
+
+    module = importlib.util.module_from_spec(spec)
+    module.__file__ = str(temp_file)
+    sys.modules[module_name] = module
+    spec.loader.exec_module(module)
+
+    entry_func = getattr(module, "entry", None)
+    if entry_func is None:
+        msg = "No entry function found in AST-generated Guppy source"
+        raise RuntimeError(msg)
+
+    return entry_func.compile()

From 975768b868139e93b3c1b3eed12a2bcdbbd8cf3f Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Thu, 14 May 2026 22:38:05 -0600
Subject: [PATCH 029/136] v2 Phase 1: add Print(value, *, tag=None,
 namespace='result') with SLR class, PrintOp AST node, Guppy result()
 emission, QASM comment fallback, and 15 Selene-roundtrip behavioral tests

---
 .../quantum-pecos/src/pecos/slr/__init__.py   |   3 +-
 .../src/pecos/slr/ast/__init__.py             |   2 +
 .../src/pecos/slr/ast/codegen/guppy.py        |  41 +++-
 .../src/pecos/slr/ast/codegen/qasm.py         |   6 +
 .../src/pecos/slr/ast/converter.py            |  25 ++
 .../quantum-pecos/src/pecos/slr/ast/nodes.py  |  28 +++
 .../src/pecos/slr/ast/pretty_print.py         |   6 +
 .../src/pecos/slr/ast/serialize.py            |   2 +
 .../src/pecos/slr/ast/visitor.py              |   7 +
 python/quantum-pecos/src/pecos/slr/misc.py    |  86 ++++++-
 .../tests/slr_tests/ast_guppy/test_print.py   | 222 ++++++++++++++++++
 11 files changed, 424 insertions(+), 4 deletions(-)
 create mode 100644 python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py

diff --git a/python/quantum-pecos/src/pecos/slr/__init__.py b/python/quantum-pecos/src/pecos/slr/__init__.py
index a08a5deea..37f6a2b34 100644
--- a/python/quantum-pecos/src/pecos/slr/__init__.py
+++ b/python/quantum-pecos/src/pecos/slr/__init__.py
@@ -90,7 +90,7 @@
 from pecos.slr.main import (
     Main as SLR,
 )
-from pecos.slr.misc import Barrier, Comment, Parallel, Permute, Return
+from pecos.slr.misc import Barrier, Comment, Parallel, Permute, Print, Return
 from pecos.slr.qalloc import QAlloc, QubitRef, SlotState
 from pecos.slr.slr_converter import SlrConverter
 from pecos.slr.types import Array
@@ -177,6 +177,7 @@ def generate(
     "Main",
     "Parallel",
     "Permute",
+    "Print",
     # Qubit allocator (new)
     "QAlloc",
     # Legacy register (kept for compatibility)
diff --git a/python/quantum-pecos/src/pecos/slr/ast/__init__.py b/python/quantum-pecos/src/pecos/slr/ast/__init__.py
index 47c5ed1b7..de0545342 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/__init__.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/__init__.py
@@ -165,6 +165,7 @@ def visit_gate(self, node: GateOp) -> int:
     ParallelBlock,
     PermuteOp,
     PrepareOp,
+    PrintOp,
     # Program
     Program,
     QubitTypeExpr,
@@ -231,6 +232,7 @@ def visit_gate(self, node: GateOp) -> int:
     "ParallelBlock",
     "PermuteOp",
     "PrepareOp",
+    "PrintOp",
     # Program
     "Program",
     "QubitStateTracker",
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
index a28bf4dab..391cd9e3f 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
@@ -63,6 +63,7 @@
         CommentOp,
         Expression,
         PermuteOp,
+        PrintOp,
         Program,
         SlotRef,
         Statement,
@@ -357,7 +358,7 @@ def _emit_stmt(self, stmt: Statement) -> list[str]:
             msg = "AST -> Guppy v1 supports Return only as the final root-level statement"
             raise GuppyCodegenError(msg)
 
-        from pecos.slr.ast.nodes import AssignOp, BarrierOp, CommentOp, PermuteOp  # noqa: PLC0415
+        from pecos.slr.ast.nodes import AssignOp, BarrierOp, CommentOp, PermuteOp, PrintOp  # noqa: PLC0415
 
         if isinstance(stmt, AssignOp):
             return self._emit_assign(stmt)
@@ -367,6 +368,8 @@ def _emit_stmt(self, stmt: Statement) -> list[str]:
             return self._emit_comment(stmt)
         if isinstance(stmt, PermuteOp):
             return self._emit_permute(stmt)
+        if isinstance(stmt, PrintOp):
+            return self._emit_print(stmt)
 
         msg = f"Unsupported AST statement for Guppy codegen: {type(stmt).__name__}"
         raise GuppyCodegenError(msg)
@@ -526,6 +529,42 @@ def _emit_block(self, body: tuple[Statement, ...]) -> list[str]:
             lines.extend(self._emit_stmt(stmt))
         return lines
 
+    def _emit_print(self, node: PrintOp) -> list[str]:
+        """Lower PrintOp to a Guppy `result(<namespace>.<tag>, <value>)` call.
+
+        Per v2-print.md, Print is scope-orthogonal: it does not allocate, does
+        not touch the result-register set, and does not affect main's return
+        type. Path-signature consistency for Print inside If branches and
+        inline-CReg definite-assignment are enforced by separate validation
+        passes; this emitter assumes both have already accepted the AST.
+        """
+        full_tag = f"{node.namespace}.{node.tag}"
+
+        value_expr: str
+        if isinstance(node.value, BitRef):
+            register = node.value.register
+            if register not in self.context.registers:
+                msg = (
+                    f"Print(c[{node.value.index}]) references unknown CReg {register!r}; "
+                    "declare the CReg or measure into it before Print."
+                )
+                raise GuppyCodegenError(msg)
+            value_expr = f"{register}[{node.value.index}]"
+        elif isinstance(node.value, str):
+            register = node.value
+            if register not in self.context.registers:
+                msg = (
+                    f"Print({register}) references unknown CReg {register!r}; "
+                    "declare the CReg or measure into it before Print."
+                )
+                raise GuppyCodegenError(msg)
+            value_expr = register
+        else:
+            msg = f"Unsupported Print value type for Guppy codegen: {type(node.value).__name__}"
+            raise GuppyCodegenError(msg)
+
+        return [f'{self.context.indent()}result("{full_tag}", {value_expr})']
+
     def _emit_permute(self, node: PermuteOp) -> list[str]:
         if len(node.sources) != len(node.targets):
             msg = "Permute source/target length mismatch"
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qasm.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qasm.py
index 2242fe699..bbb9b1357 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qasm.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qasm.py
@@ -60,6 +60,7 @@
         ParallelBlock,
         PermuteOp,
         PrepareOp,
+        PrintOp,
         Program,
         RepeatStmt,
         ReturnOp,
@@ -444,6 +445,11 @@ def visit_return(self, _node: ReturnOp) -> list[str]:
         """Return is not a QASM concept - ignored."""
         return []
 
+    def visit_print(self, node: PrintOp) -> list[str]:
+        """Print has no native QASM equivalent; emit as a comment for traceability."""
+        value_repr = node.value if isinstance(node.value, str) else f"{node.value.register}[{node.value.index}]"
+        return [f"// Print {node.namespace}.{node.tag} {value_repr}"]
+
     def visit_permute(self, node: PermuteOp) -> list[str]:
         """Handle permutation.
 
diff --git a/python/quantum-pecos/src/pecos/slr/ast/converter.py b/python/quantum-pecos/src/pecos/slr/ast/converter.py
index 1bacf6ab9..e7169590e 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/converter.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/converter.py
@@ -53,6 +53,7 @@
     ParallelBlock,
     PermuteOp,
     PrepareOp,
+    PrintOp,
     Program,
     QubitTypeExpr,
     RegisterDecl,
@@ -359,6 +360,9 @@ def _convert_statement(self, op: Any) -> Statement | None:
         if op_class == "Permute":
             return self._convert_permute(op)
 
+        if op_class == "Print":
+            return self._convert_print(op)
+
         # Assignment operations
         if op_class == "SET":
             return self._convert_assignment(op)
@@ -669,6 +673,27 @@ def _convert_permute(self, op: Any) -> PermuteOp:
             add_comment=add_comment,
         )
 
+    def _convert_print(self, op: Any) -> PrintOp:
+        """Convert an SLR Print to an AST PrintOp.
+
+        SLR-side already validated tag/namespace characters, derived the tag
+        from the value's name when omitted, and rejected non-CReg/Bit values.
+        AST conversion lowers the value into AST shape: a `BitRef` for
+        Bit values, or a CReg name string for whole-register Print.
+        """
+        value: BitRef | str
+        if hasattr(op.value, "reg") and hasattr(op.value, "index"):
+            # Bit reference (e.g., c[0]).
+            value = self._convert_bit_ref(op.value)
+        elif hasattr(op.value, "sym"):
+            # Whole CReg.
+            value = op.value.sym
+        else:
+            msg = f"Print value must be a CReg or Bit; got {type(op.value).__name__}"
+            raise TypeError(msg)
+
+        return PrintOp(value=value, tag=op.tag, namespace=op.namespace)
+
     def _convert_assignment(self, op: Any) -> AssignOp:
         """Convert an SLR SET operation to an AST AssignOp."""
         # Target
diff --git a/python/quantum-pecos/src/pecos/slr/ast/nodes.py b/python/quantum-pecos/src/pecos/slr/ast/nodes.py
index f79d1013c..2550e97bd 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/nodes.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/nodes.py
@@ -519,6 +519,34 @@ def children(self) -> Sequence[AstNode]:
         return tuple(v for v in self.values if isinstance(v, AstNode))
 
 
+@dataclass(frozen=True, kw_only=True)
+class PrintOp(Statement):
+    """Emit an intermediate streamed value at the call site.
+
+    Lowers to Guppy's `result(name, value)`. Scope-orthogonal side-effect:
+    does not allocate, does not modify the result-register set used for
+    return-shape computation.
+
+    `value` is either a `BitRef` (single bit) or a register name string
+    (whole-CReg emission). `tag` is the resolved tag (the SLR-side
+    conversion derives the default from the value's name when the user
+    did not pass `tag=` explicitly). `namespace` is the tag prefix; the
+    full emitted Guppy tag is `f"{namespace}.{tag}"`.
+    """
+
+    value: BitRef | str
+    tag: str
+    namespace: str = "result"
+
+    def accept(self, visitor: AstVisitor[T]) -> T:
+        return visitor.visit_print(self)
+
+    def children(self) -> Sequence[AstNode]:
+        if isinstance(self.value, AstNode):
+            return (self.value,)
+        return ()
+
+
 @dataclass(frozen=True, kw_only=True)
 class PermuteOp(Statement):
     """Permute qubit register assignments.
diff --git a/python/quantum-pecos/src/pecos/slr/ast/pretty_print.py b/python/quantum-pecos/src/pecos/slr/ast/pretty_print.py
index caeb88c36..1dd4802e7 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/pretty_print.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/pretty_print.py
@@ -56,6 +56,7 @@
         ParallelBlock,
         PermuteOp,
         PrepareOp,
+        PrintOp,
         Program,
         RepeatStmt,
         ReturnOp,
@@ -245,6 +246,11 @@ def visit_permute(self, node: PermuteOp) -> str:
         targets = ", ".join(node.targets)
         return f"Permute([{sources}], [{targets}])"
 
+    def visit_print(self, node: PrintOp) -> str:
+        """Visit print."""
+        value = node.value if isinstance(node.value, str) else f"{node.value.register}[{node.value.index}]"
+        return f'Print({value}, tag="{node.tag}", namespace="{node.namespace}")'
+
     # Control flow
 
     def visit_if(self, node: IfStmt) -> str:
diff --git a/python/quantum-pecos/src/pecos/slr/ast/serialize.py b/python/quantum-pecos/src/pecos/slr/ast/serialize.py
index 03dcd7212..a8f9dd142 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/serialize.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/serialize.py
@@ -53,6 +53,7 @@
     ParallelBlock,
     PermuteOp,
     PrepareOp,
+    PrintOp,
     Program,
     QubitTypeExpr,
     RegisterDecl,
@@ -91,6 +92,7 @@
     "ParallelBlock": ParallelBlock,
     "PermuteOp": PermuteOp,
     "PrepareOp": PrepareOp,
+    "PrintOp": PrintOp,
     "Program": Program,
     "QubitTypeExpr": QubitTypeExpr,
     "RegisterDecl": RegisterDecl,
diff --git a/python/quantum-pecos/src/pecos/slr/ast/visitor.py b/python/quantum-pecos/src/pecos/slr/ast/visitor.py
index c1290114f..b07ebc00b 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/visitor.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/visitor.py
@@ -42,6 +42,7 @@
         ParallelBlock,
         PermuteOp,
         PrepareOp,
+        PrintOp,
         Program,
         QubitTypeExpr,
         RegisterDecl,
@@ -88,6 +89,8 @@ def visit_return(self, node: ReturnOp) -> T_co: ...
 
     def visit_permute(self, node: PermuteOp) -> T_co: ...
 
+    def visit_print(self, node: PrintOp) -> T_co: ...
+
     # Control flow
     def visit_if(self, node: IfStmt) -> T_co: ...
 
@@ -202,6 +205,10 @@ def visit_return(self, node: ReturnOp) -> T:
     def visit_permute(self, _node: PermuteOp) -> T:
         return self.default_result()
 
+    def visit_print(self, node: PrintOp) -> T:
+        results = self.visit_children(node)
+        return self.combine_results(results)
+
     # Control flow
 
     def visit_if(self, node: IfStmt) -> T:
diff --git a/python/quantum-pecos/src/pecos/slr/misc.py b/python/quantum-pecos/src/pecos/slr/misc.py
index a1f40322b..38549141c 100644
--- a/python/quantum-pecos/src/pecos/slr/misc.py
+++ b/python/quantum-pecos/src/pecos/slr/misc.py
@@ -10,13 +10,17 @@
 # specific language governing permissions and limitations under the License.
 from __future__ import annotations
 
+import re
 from typing import TYPE_CHECKING
 
+from pecos.slr.block import Block
+from pecos.slr.fund import Statement
+from pecos.slr.vars import Bit, CReg, SymbolicBit
+
 if TYPE_CHECKING:
     from pecos.slr.vars import Elem, QReg, Qubit, Reg
 
-from pecos.slr.block import Block
-from pecos.slr.fund import Statement
+_TAG_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
 
 
 class Barrier(Statement):
@@ -89,3 +93,81 @@ def __init__(self, *return_vars) -> None:
             *return_vars: Variables to return, in order. Can be QReg, Qubit, Bit, or other variables.
         """
         self.return_vars = return_vars
+
+
+class Print(Statement):
+    """Emit an intermediate streamed value at the call site.
+
+    Lowers to Guppy's ``result(name, value)``. Scope-orthogonal side-effect:
+    does not touch block ownership or compile-time return shape.
+
+    The emitted Guppy tag is ``f"{namespace}.{tag}"``. Default namespace is
+    ``"result"``. If ``tag`` is not provided it is derived from ``value``'s
+    name (CReg name, or ``f"{reg}_{index}"`` for a Bit).
+
+    Args:
+        value: A CReg or Bit (CReg element). Phase 1 supports these only.
+            Expression values (e.g. ``c[0] ^ c[1]``), SymbolicBit, and other
+            types are rejected at construction time.
+        tag: Explicit tag string overriding the derived name. Must match
+            ``[A-Za-z_][A-Za-z0-9_]*`` (Python identifier rules).
+        namespace: Tag prefix. Default ``"result"``. Must match
+            ``[A-Za-z_][A-Za-z0-9_]*``.
+
+    Example:
+        Main(
+            c := CReg("c", 2),
+            ...,
+            Print(c),                       # tag "result.c"
+            Print(c[0], tag="first"),       # tag "result.first"
+            Print(c, namespace="debug"),    # tag "debug.c"
+        )
+    """
+
+    def __init__(self, value, *, tag: str | None = None, namespace: str = "result") -> None:
+        """Construction-time validation per `v2-print.md`.
+
+        Validates value type, tag/namespace character rules, and derives the
+        default tag from the value's name. AST/Guppy-level checks (path-
+        signature consistency in If/Elif, inline-CReg definite-assignment)
+        run later during emission.
+        """
+        if isinstance(value, SymbolicBit):
+            msg = "Print does not support SymbolicBit (LoopVar-indexed) values; this is v2-defer scope."
+            raise TypeError(msg)
+        if not isinstance(value, (CReg, Bit)):
+            msg = (
+                f"Print(value, ...) requires a CReg or Bit value; got {type(value).__name__}. "
+                "Expression values (e.g. c[0] ^ c[1]) are deferred to v2.1 and must be passed with explicit tag=...; "
+                "Phase 1 supports CReg and Bit only."
+            )
+            raise TypeError(msg)
+
+        if not _TAG_RE.match(namespace):
+            msg = (
+                f"Print namespace {namespace!r} must match [A-Za-z_][A-Za-z0-9_]* "
+                "(Python identifier rules). The dot is reserved as the namespace-tag separator."
+            )
+            raise ValueError(msg)
+
+        if tag is None:
+            tag = self._derive_tag(value)
+        elif not _TAG_RE.match(tag):
+            msg = (
+                f"Print tag {tag!r} must match [A-Za-z_][A-Za-z0-9_]* "
+                "(Python identifier rules). The dot is reserved as the namespace-tag separator."
+            )
+            raise ValueError(msg)
+
+        self.value = value
+        self.tag = tag
+        self.namespace = namespace
+
+    @staticmethod
+    def _derive_tag(value: CReg | Bit) -> str:
+        if isinstance(value, CReg):
+            return value.sym
+        if isinstance(value, Bit):
+            return f"{value.reg.sym}_{value.index}"
+        msg = f"Cannot derive Print tag from {type(value).__name__}"
+        raise TypeError(msg)
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
new file mode 100644
index 000000000..57970fe3e
--- /dev/null
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
@@ -0,0 +1,222 @@
+# Copyright 2026 The PECOS Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations under the License.
+
+"""Phase 1 behavioral tests for `Print(value, *, tag=None, namespace="result")`.
+
+Print lowers to Guppy's `result(name, value)` and surfaces in Selene's parsed
+result dict under the key `f"{namespace}.{tag}"`. Tests verify:
+
+- Tag derivation from CReg / Bit values (Print(c) -> tag "result.c";
+  Print(c[0]) -> tag "result.c_0").
+- Explicit tag/namespace overrides.
+- Print inside Repeat(n) and fixed-bound For emits event-list under same key.
+- Construction-time rejection of invalid values, tags, and namespaces.
+"""
+
+from __future__ import annotations
+
+import pytest
+from pecos import Hugr, selene_engine, sim
+from pecos.slr import CReg, For, Main, Print, QReg, Repeat, SlrConverter
+from pecos.slr.qeclib import qubit as qb
+from pecos.slr.qeclib.qubit.measures import Measure
+
+
+def _run_and_get_result_dict(prog: Main, *, shots: int = 10, seed: int = 42, qubits: int = 1) -> dict:
+    """Compile prog via SlrConverter, run through Selene, return raw result dict."""
+    package = SlrConverter(prog).hugr()
+    hugr_bytes = package.to_str().encode("utf-8")
+    result = sim(Hugr(hugr_bytes)).classical(selene_engine()).qubits(qubits).seed(seed).run(shots)
+    raw = result.to_dict() if hasattr(result, "to_dict") else result
+    assert isinstance(raw, dict)
+    return raw
+
+
+# ── Tag derivation ───────────────────────────────────────────────────────
+
+
+class TestTagDerivation:
+    """Print's default tag is derived from the value's name."""
+
+    def test_print_whole_creg_derives_register_name(self) -> None:
+        """Print(c) emits under tag "result.c"."""
+        prog = Main(
+            q := QReg("q", 2),
+            c := CReg("c", 2),
+            qb.X(q[0]),
+            Measure(q) > c,
+            Print(c),
+        )
+        raw = _run_and_get_result_dict(prog, qubits=2)
+        assert "result.c" in raw, f"expected 'result.c' tag in {list(raw.keys())}"
+
+    def test_print_bit_ref_derives_register_index_name(self) -> None:
+        """Print(c[0]) emits under tag "result.c_0"."""
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            qb.X(q[0]),
+            Measure(q[0]) > c[0],
+            Print(c[0]),
+        )
+        raw = _run_and_get_result_dict(prog)
+        assert "result.c_0" in raw, f"expected 'result.c_0' tag in {list(raw.keys())}"
+
+
+# ── Namespace + tag overrides ────────────────────────────────────────────
+
+
+class TestNamespaceAndTag:
+    """Namespace prefixes the tag; explicit tag overrides derived name."""
+
+    def test_namespace_debug_emits_under_debug_prefix(self) -> None:
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            qb.X(q[0]),
+            Measure(q[0]) > c[0],
+            Print(c, namespace="debug"),
+        )
+        raw = _run_and_get_result_dict(prog)
+        assert "debug.c" in raw
+
+    def test_explicit_tag_overrides_derived(self) -> None:
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            qb.X(q[0]),
+            Measure(q[0]) > c[0],
+            Print(c, tag="step_1"),
+        )
+        raw = _run_and_get_result_dict(prog)
+        assert "result.step_1" in raw
+
+    def test_namespace_and_tag_together(self) -> None:
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            qb.X(q[0]),
+            Measure(q[0]) > c[0],
+            Print(c, tag="r1", namespace="debug"),
+        )
+        raw = _run_and_get_result_dict(prog)
+        assert "debug.r1" in raw
+
+
+# ── Loop bodies ──────────────────────────────────────────────────────────
+
+
+class TestPrintInLoops:
+    """Print inside Repeat(n) and fixed-bound For emits n times under the same tag."""
+
+    def test_print_in_repeat_emits_event_list(self) -> None:
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            Repeat(3).block(
+                qb.X(q[0]),
+                Measure(q[0]) > c[0],
+                qb.Prep(q[0]),
+                Print(c, tag="iter"),
+            ),
+        )
+        raw = _run_and_get_result_dict(prog, shots=5)
+        # tag emitted thrice per shot; Selene returns event-list under the key
+        assert "result.iter" in raw, f"expected 'result.iter' in {list(raw.keys())}"
+
+    def test_print_in_static_for_emits_event_list(self) -> None:
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            For("i", 0, 2).Do(
+                qb.X(q[0]),
+                Measure(q[0]) > c[0],
+                qb.Prep(q[0]),
+                Print(c, tag="loop"),
+            ),
+        )
+        raw = _run_and_get_result_dict(prog, shots=5)
+        assert "result.loop" in raw
+
+
+# ── Construction-time negative tests ─────────────────────────────────────
+
+
+class TestPrintConstructionRejection:
+    """SLR-construction-time validation rejects bad inputs immediately."""
+
+    def test_print_of_non_creg_value_rejected(self) -> None:
+        with pytest.raises(TypeError, match="requires a CReg or Bit value"):
+            Print(42)
+
+    def test_print_with_invalid_tag_chars_rejected(self) -> None:
+        c = CReg("c", 1)
+        with pytest.raises(ValueError, match="must match"):
+            Print(c, tag="bad-tag")
+
+    def test_print_with_invalid_namespace_chars_rejected(self) -> None:
+        c = CReg("c", 1)
+        with pytest.raises(ValueError, match="must match"):
+            Print(c, namespace="1bad")
+
+    def test_print_with_namespace_containing_dot_rejected(self) -> None:
+        """The dot is reserved as the namespace-tag separator."""
+        c = CReg("c", 1)
+        with pytest.raises(ValueError, match="must match"):
+            Print(c, namespace="bad.namespace")
+
+    def test_print_tag_can_use_underscore_and_digits(self) -> None:
+        """Identifier-rule chars are accepted."""
+        c = CReg("c", 1)
+        p = Print(c, tag="syn_round_0")
+        assert p.tag == "syn_round_0"
+
+    def test_print_namespace_with_underscore_accepted(self) -> None:
+        c = CReg("c", 1)
+        p = Print(c, namespace="my_ns")
+        assert p.namespace == "my_ns"
+
+
+# ── Print does not change program return shape ──────────────────────────
+
+
+class TestPrintScopeOrthogonal:
+    """Print is a side-effect; it does not allocate, does not affect main's return type."""
+
+    def test_print_does_not_break_implicit_return(self) -> None:
+        """v1 implicit return of result CRegs still works alongside Print."""
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            qb.X(q[0]),
+            Measure(q[0]) > c[0],
+            Print(c),
+        )
+        raw = _run_and_get_result_dict(prog)
+        # Both Print's tag and the implicit return's tag should be present.
+        assert "result.c" in raw
+
+    def test_multiple_prints_same_tag_become_event_list(self) -> None:
+        """Two Print(c) calls in the same body emit the tag twice per shot."""
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            qb.X(q[0]),
+            Measure(q[0]) > c[0],
+            Print(c, tag="early"),
+            qb.Prep(q[0]),
+            qb.X(q[0]),
+            Measure(q[0]) > c[0],
+            Print(c, tag="late"),
+        )
+        raw = _run_and_get_result_dict(prog)
+        assert "result.early" in raw
+        assert "result.late" in raw

From fc82ea7822b84d6080895108e684deb0fada02a7 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Thu, 14 May 2026 22:51:00 -0600
Subject: [PATCH 030/136] Phase 1 Print: apply Codex tracer-bullet review
 (validate derived tags, document Selene tag-mode flip, strengthen
 loop/multi-Print tests with event-list shape assertions, explicit Print-skip
 in QIR/Stim/QuantumCircuit, import result from guppylang.std.builtins)

---
 .../src/pecos/slr/ast/codegen/guppy.py        |   2 +-
 .../src/pecos/slr/ast/codegen/qir.py          |   5 +
 .../pecos/slr/ast/codegen/quantum_circuit.py  |   5 +
 .../src/pecos/slr/ast/codegen/stim.py         |   5 +
 python/quantum-pecos/src/pecos/slr/misc.py    |   5 +-
 .../tests/slr_tests/ast_guppy/test_print.py   | 130 +++++++++++++++---
 6 files changed, 129 insertions(+), 23 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
index 391cd9e3f..243f8ffc6 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
@@ -251,7 +251,7 @@ def _reject_child_allocators(self) -> None:
     def _imports(self) -> list[str]:
         return [
             "from guppylang import guppy",
-            "from guppylang.std.builtins import array, owned",
+            "from guppylang.std.builtins import array, owned, result",
             "from guppylang.std.mem import mem_swap",
             "from guppylang.std.quantum import discard, measure, qubit",
             f"from guppylang.std.quantum.functional import {FUNCTIONAL_GATE_IMPORTS}",
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
index 5ad44075b..c2dbae6a7 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
@@ -47,6 +47,7 @@
     ParallelBlock,
     PermuteOp,
     PrepareOp,
+    PrintOp,
     RegisterDecl,
     RepeatStmt,
     SlotRef,
@@ -390,6 +391,10 @@ def _process_statement(self, stmt: Statement) -> None:
             self._process_parallel(stmt)
         elif isinstance(stmt, PermuteOp):
             self._process_permute(stmt)
+        elif isinstance(stmt, PrintOp):
+            # Phase 1: Print is Guppy-only. Other codegens drop the streamed
+            # value silently. Revisit per-codegen if a user need surfaces.
+            return
 
     def _process_gate(self, node: GateOp) -> None:
         """Process a gate operation."""
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py
index 981d63f4a..5f01c976d 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py
@@ -39,6 +39,7 @@
     ParallelBlock,
     PermuteOp,
     PrepareOp,
+    PrintOp,
     RegisterDecl,
     RepeatStmt,
     WhileStmt,
@@ -259,6 +260,10 @@ def _process_statement(self, stmt: Statement) -> None:
             self._process_parallel(stmt)
         elif isinstance(stmt, PermuteOp):
             self._process_permute(stmt)
+        elif isinstance(stmt, PrintOp):
+            # Phase 1: Print is Guppy-only. Other codegens drop the streamed
+            # value silently. Revisit per-codegen if a user need surfaces.
+            return
 
     def _process_gate(self, node: GateOp) -> None:
         """Process a gate operation."""
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/stim.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/stim.py
index 7d2768f37..394570986 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/stim.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/stim.py
@@ -39,6 +39,7 @@
     ParallelBlock,
     PermuteOp,
     PrepareOp,
+    PrintOp,
     RegisterDecl,
     RepeatStmt,
     WhileStmt,
@@ -249,6 +250,10 @@ def _process_statement(self, stmt: Statement) -> None:
             self._process_parallel(stmt)
         elif isinstance(stmt, PermuteOp):
             self._process_permute(stmt)
+        elif isinstance(stmt, PrintOp):
+            # Phase 1: Print is Guppy-only. Other codegens drop the streamed
+            # value silently. Revisit per-codegen if a user need surfaces.
+            return
         # Other statement types (Comment, Assign, Return) don't generate Stim output
 
     def _process_gate(self, node: GateOp) -> None:
diff --git a/python/quantum-pecos/src/pecos/slr/misc.py b/python/quantum-pecos/src/pecos/slr/misc.py
index 38549141c..a5cfb2d4b 100644
--- a/python/quantum-pecos/src/pecos/slr/misc.py
+++ b/python/quantum-pecos/src/pecos/slr/misc.py
@@ -152,10 +152,11 @@ def __init__(self, value, *, tag: str | None = None, namespace: str = "result")
 
         if tag is None:
             tag = self._derive_tag(value)
-        elif not _TAG_RE.match(tag):
+        if not _TAG_RE.match(tag):
             msg = (
                 f"Print tag {tag!r} must match [A-Za-z_][A-Za-z0-9_]* "
-                "(Python identifier rules). The dot is reserved as the namespace-tag separator."
+                "(Python identifier rules). The dot is reserved as the namespace-tag separator. "
+                "Tags derived from non-identifier register names are rejected; pass tag=... explicitly."
             )
             raise ValueError(msg)
 
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
index 57970fe3e..4a971a2c9 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
@@ -117,34 +117,54 @@ def test_namespace_and_tag_together(self) -> None:
 class TestPrintInLoops:
     """Print inside Repeat(n) and fixed-bound For emits n times under the same tag."""
 
-    def test_print_in_repeat_emits_event_list(self) -> None:
+    def test_print_in_repeat_emits_event_per_iteration(self) -> None:
+        """Each shot emits the tag once per Repeat iteration; assert count + value.
+
+        Selene shape for `Print(c)` of a single-bit CReg: the dict value is
+        a list of per-shot lists, each inner list holding one int per Print
+        call. Example for 2 shots x 3 iterations: `[[1,1,1], [1,1,1]]`.
+        """
+        shots = 5
+        n_iters = 3
         prog = Main(
             q := QReg("q", 1),
             c := CReg("c", 1),
-            Repeat(3).block(
+            Repeat(n_iters).block(
                 qb.X(q[0]),
                 Measure(q[0]) > c[0],
                 qb.Prep(q[0]),
                 Print(c, tag="iter"),
             ),
         )
-        raw = _run_and_get_result_dict(prog, shots=5)
-        # tag emitted thrice per shot; Selene returns event-list under the key
+        raw = _run_and_get_result_dict(prog, shots=shots)
         assert "result.iter" in raw, f"expected 'result.iter' in {list(raw.keys())}"
-
-    def test_print_in_static_for_emits_event_list(self) -> None:
+        events = raw["result.iter"]
+        assert len(events) == shots, f"expected {shots} per-shot event lists, got {len(events)}"
+        for shot_events in events:
+            assert len(shot_events) == n_iters, f"expected {n_iters} events per shot, got {len(shot_events)}"
+            # Each iteration prepared then measured X|0>=|1>; expect every event = 1.
+            assert all(int(bit) == 1 for bit in shot_events), shot_events
+
+    def test_print_in_static_for_emits_event_per_iteration(self) -> None:
+        shots = 5
+        n_iters = 2
         prog = Main(
             q := QReg("q", 1),
             c := CReg("c", 1),
-            For("i", 0, 2).Do(
+            For("i", 0, n_iters).Do(
                 qb.X(q[0]),
                 Measure(q[0]) > c[0],
                 qb.Prep(q[0]),
                 Print(c, tag="loop"),
             ),
         )
-        raw = _run_and_get_result_dict(prog, shots=5)
+        raw = _run_and_get_result_dict(prog, shots=shots)
         assert "result.loop" in raw
+        events = raw["result.loop"]
+        assert len(events) == shots
+        for shot_events in events:
+            assert len(shot_events) == n_iters
+            assert all(int(bit) == 1 for bit in shot_events), shot_events
 
 
 # ── Construction-time negative tests ─────────────────────────────────────
@@ -184,28 +204,73 @@ def test_print_namespace_with_underscore_accepted(self) -> None:
         p = Print(c, namespace="my_ns")
         assert p.namespace == "my_ns"
 
+    def test_print_derived_tag_validated_against_identifier_rules(self) -> None:
+        """A CReg named with non-identifier chars yields a non-identifier derived tag.
+
+        Construction must reject it; the user should pass `tag=...` explicitly.
+        Without this check the value would silently produce a malformed
+        `result()` tag.
+        """
+        bad_creg = CReg("bad-name", 1)
+        with pytest.raises(ValueError, match="must match"):
+            Print(bad_creg)
+
+
+# ── Print and Selene's runtime output ───────────────────────────────────
+
+
+class TestPrintAndSeleneOutput:
+    """Print does not change the SLR/AST/Guppy return shape, but Selene's runtime
+    flips representation modes once any `result()` call is present.
 
-# ── Print does not change program return shape ──────────────────────────
+    Empirically (verified 2026-05-14):
 
+    - No Print, implicit return: Selene exposes return-tuple positionally as
+      `measurement_N` keys.
+    - Any Print, implicit return still present in Guppy `return ...`: Selene
+      switches to result-tag mode and the `measurement_N` keys are NOT
+      exposed; only `result()` tags appear in `to_dict()`.
 
-class TestPrintScopeOrthogonal:
-    """Print is a side-effect; it does not allocate, does not affect main's return type."""
+    So Print is **AST-scope-orthogonal** (no AST/Guppy return shape change)
+    but **Selene-runtime-mode-flipping** (presence of any `result()` switches
+    the output dict's representation). v2 breaking-migration anticipates this
+    by making Print/Return the only output mechanisms.
+    """
 
-    def test_print_does_not_break_implicit_return(self) -> None:
-        """v1 implicit return of result CRegs still works alongside Print."""
+    def test_no_print_yields_implicit_measurement_records(self) -> None:
+        """Sanity baseline: no Print, Selene exposes return-tuple as measurement_N."""
         prog = Main(
             q := QReg("q", 1),
             c := CReg("c", 1),
             qb.X(q[0]),
             Measure(q[0]) > c[0],
-            Print(c),
         )
-        raw = _run_and_get_result_dict(prog)
-        # Both Print's tag and the implicit return's tag should be present.
-        assert "result.c" in raw
+        raw = _run_and_get_result_dict(prog, shots=2)
+        assert "measurement_0" in raw
+        assert all(int(bit) == 1 for bit in raw["measurement_0"])
+        # Tag-mode keys are absent in this mode.
+        assert "result.c" not in raw
+
+    def test_print_switches_selene_to_tag_mode_and_hides_measurement_records(self) -> None:
+        """Adding any Print suppresses the implicit `measurement_N` keys.
+
+        This is a Selene runtime behavior, not an AST/Guppy semantics change:
+        the generated Guppy still has `return c`, but Selene's parsed dict
+        only shows result tags when any `result()` call exists.
+        """
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            qb.X(q[0]),
+            Measure(q[0]) > c[0],
+            Print(c, tag="p"),
+        )
+        raw = _run_and_get_result_dict(prog, shots=2)
+        assert "result.p" in raw
+        assert "measurement_0" not in raw, f"expected measurement_0 hidden in tag mode, got {list(raw.keys())}"
 
-    def test_multiple_prints_same_tag_become_event_list(self) -> None:
-        """Two Print(c) calls in the same body emit the tag twice per shot."""
+    def test_multiple_prints_distinct_tags_each_appear(self) -> None:
+        """Two Prints with distinct tags each yield a separate result-dict key."""
         prog = Main(
             q := QReg("q", 1),
             c := CReg("c", 1),
@@ -217,6 +282,31 @@ def test_multiple_prints_same_tag_become_event_list(self) -> None:
             Measure(q[0]) > c[0],
             Print(c, tag="late"),
         )
-        raw = _run_and_get_result_dict(prog)
+        raw = _run_and_get_result_dict(prog, shots=2)
         assert "result.early" in raw
         assert "result.late" in raw
+
+    def test_two_prints_same_tag_become_event_list(self) -> None:
+        """Two Print(c, tag="same") calls emit the tag twice per shot under one key.
+
+        Selene returns an event-list shape `{tag: [[ev0_shot0, ev1_shot0], ...]}`.
+        """
+        shots = 3
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            qb.X(q[0]),
+            Measure(q[0]) > c[0],
+            Print(c, tag="same"),
+            qb.Prep(q[0]),
+            qb.X(q[0]),
+            Measure(q[0]) > c[0],
+            Print(c, tag="same"),  # same tag, second emission
+        )
+        raw = _run_and_get_result_dict(prog, shots=shots)
+        assert "result.same" in raw
+        events = raw["result.same"]
+        assert len(events) == shots, f"expected {shots} per-shot event lists, got {len(events)}"
+        for shot_events in events:
+            assert len(shot_events) == 2, f"expected 2 events per shot, got {len(shot_events)}"
+            assert all(int(bit) == 1 for bit in shot_events), shot_events

From f2ebb32c323f207d77023d39175295632f2e697e Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Thu, 14 May 2026 23:00:42 -0600
Subject: [PATCH 031/136] Phase 1 Print: path-signature validator rejects
 asymmetric If branches + non-static loops with Print bodies (9 new tests)

---
 .../src/pecos/slr/ast/codegen/guppy.py        | 117 +++++++++++++++
 .../tests/slr_tests/ast_guppy/test_print.py   | 141 +++++++++++++++++-
 2 files changed, 257 insertions(+), 1 deletion(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
index 243f8ffc6..e02239f71 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
@@ -160,6 +160,10 @@ def generate(self, program: Program) -> list[str]:
         self.context.linearity = GuppyLinearityState.from_allocators(self.context.root_allocators)
         self._reject_child_allocators()
 
+        # Phase 1 Print AST-level validators (run before emission so failures
+        # point at the source program, not the generated Guppy).
+        self._validate_print_paths(program.body)
+
         body = list(program.body)
         explicit_return = self._validate_return_position(body)
         emitted_body = body[:-1] if explicit_return else body
@@ -336,6 +340,119 @@ def _count_returns(self, body: list[Statement] | tuple[Statement, ...]) -> int:
                 count += self._count_returns(stmt.body)
         return count
 
+    def _validate_print_paths(self, body: tuple[Statement, ...]) -> None:
+        """Validate Print path-signature consistency across If/Elif branches.
+
+        Walks the body once, descending into nested control flow. For each
+        If, both `then_body` and `else_body` (recursively) must emit the
+        same ordered sequence of Print events. `Repeat(n)` and static-bound
+        `For(name, start, stop[, step])` multiply inner signatures by the
+        static trip count. Non-static `For` and `While` reject Prints in
+        Phase 1 since the trip count is not statically known.
+
+        Side effect: raises `GuppyCodegenError` if any validation fails.
+        """
+        from pecos.slr.ast.nodes import PrintOp  # noqa: PLC0415
+
+        self._collect_print_path_signature(body, PrintOp)
+
+    def _collect_print_path_signature(
+        self,
+        body: tuple[Statement, ...],
+        print_op_cls: type,
+    ) -> tuple[tuple[str, str, str, int], ...]:
+        """Return the ordered Print signature for `body`, validating as we go.
+
+        Each Print emission contributes one signature tuple:
+        `(namespace, tag, value_kind, value_shape)` where `value_kind` is
+        `"creg"` (whole register) or `"bit"` (single bit) and
+        `value_shape` is the register size (or 1 for bit refs).
+
+        Side effects:
+        - Raises `GuppyCodegenError` if an `If` body has asymmetric Print
+          signatures across `then_body` / `else_body`.
+        - Raises `GuppyCodegenError` if a non-static `For` or any `While`
+          contains a Print in its body.
+        """
+        signature: list[tuple[str, str, str, int]] = []
+        for stmt in body:
+            if isinstance(stmt, print_op_cls):
+                signature.append(self._print_op_event(stmt))
+            elif isinstance(stmt, IfStmt):
+                then_sig = self._collect_print_path_signature(stmt.then_body, print_op_cls)
+                else_sig = self._collect_print_path_signature(stmt.else_body, print_op_cls)
+                if then_sig != else_sig:
+                    msg = (
+                        "Print path-signature mismatch across If branches:\n"
+                        f"  Then: {then_sig}\n"
+                        f"  Else: {else_sig}\n"
+                        "Phase 1 requires symmetric Print emission across all branches of an "
+                        "If/Elif chain. Either add the missing Print(s) to the lighter branch, "
+                        "or move the Print outside the If."
+                    )
+                    raise GuppyCodegenError(msg)
+                signature.extend(then_sig)
+            elif isinstance(stmt, RepeatStmt):
+                inner = self._collect_print_path_signature(stmt.body, print_op_cls)
+                signature.extend(inner * stmt.count)
+            elif isinstance(stmt, ForStmt):
+                inner = self._collect_print_path_signature(stmt.body, print_op_cls)
+                if inner:
+                    trip = self._static_for_trip_count(stmt)
+                    if trip is None:
+                        msg = (
+                            "Print inside non-static `For` is not supported in Phase 1. "
+                            "Use `Repeat(n)` or `For(name, start, stop)` with literal int "
+                            "start/stop/step, or move the Print outside the For body."
+                        )
+                        raise GuppyCodegenError(msg)
+                    signature.extend(inner * trip)
+            elif isinstance(stmt, WhileStmt):
+                inner = self._collect_print_path_signature(stmt.body, print_op_cls)
+                if inner:
+                    msg = (
+                        "Print inside `While` is not supported in Phase 1 (no static trip "
+                        "count). Move the Print outside the While body."
+                    )
+                    raise GuppyCodegenError(msg)
+            elif isinstance(stmt, ParallelBlock):
+                signature.extend(self._collect_print_path_signature(stmt.body, print_op_cls))
+        return tuple(signature)
+
+    def _print_op_event(self, op) -> tuple[str, str, str, int]:
+        if isinstance(op.value, BitRef):
+            return (op.namespace, op.tag, "bit", 1)
+        # str = whole CReg name
+        decl = self.context.registers.get(op.value)
+        shape = decl.size if decl is not None else 0
+        return (op.namespace, op.tag, "creg", shape)
+
+    def _static_for_trip_count(self, stmt: ForStmt) -> int | None:
+        """Compute static trip count for a `For(name, start, stop[, step])`.
+
+        Returns the integer trip count when start/stop/step are all integer
+        literals; returns None otherwise (Phase 1 then rejects Print in the
+        loop body via `_collect_print_path_signature`).
+        """
+        start = self._static_int(stmt.start)
+        stop = self._static_int(stmt.stop)
+        if start is None or stop is None:
+            return None
+        step = 1
+        if stmt.step is not None:
+            step_val = self._static_int(stmt.step)
+            if step_val is None:
+                return None
+            step = step_val
+        if step == 0:
+            return None
+        return len(range(start, stop, step))
+
+    def _static_int(self, expr) -> int | None:
+        if isinstance(expr, LiteralExpr) and isinstance(expr.value, int) and not isinstance(expr.value, bool):
+            return expr.value
+        return None
+
     def _emit_stmt(self, stmt: Statement) -> list[str]:
         if isinstance(stmt, GateOp):
             return self._emit_gate(stmt)
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
index 4a971a2c9..51fdb5758 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
@@ -25,7 +25,8 @@
 
 import pytest
 from pecos import Hugr, selene_engine, sim
-from pecos.slr import CReg, For, Main, Print, QReg, Repeat, SlrConverter
+from pecos.slr import CReg, For, If, Main, Print, QReg, Repeat, SlrConverter
+from pecos.slr.ast.codegen.guppy import GuppyCodegenError
 from pecos.slr.qeclib import qubit as qb
 from pecos.slr.qeclib.qubit.measures import Measure
 
@@ -310,3 +311,141 @@ def test_two_prints_same_tag_become_event_list(self) -> None:
         for shot_events in events:
             assert len(shot_events) == 2, f"expected 2 events per shot, got {len(shot_events)}"
             assert all(int(bit) == 1 for bit in shot_events), shot_events
+
+
+# ── Path-signature validator (If/Elif symmetry) ──────────────────────────
+
+
+class TestPathSignatureValidator:
+    """Reject asymmetric Print emission across If/Elif branches.
+
+    Phase 1 requires that the ordered sequence of Print events along every
+    conditional path is identical. Selene's parsed-result dict expects
+    rectangular tag emission per shot; asymmetric emission triggers a
+    register-count mismatch at runtime, so the AST validator fails fast.
+    """
+
+    def test_then_only_print_rejected(self) -> None:
+        """Print in `Then` with no Else (or empty Else) → asymmetric."""
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            qb.X(q[0]),
+            Measure(q[0]) > c[0],
+            If(c[0]).Then(Print(c, tag="only_then")),
+        )
+        with pytest.raises(GuppyCodegenError, match="path-signature mismatch"):
+            SlrConverter(prog).hugr()
+
+    def test_symmetric_if_then_else_accepted(self) -> None:
+        """Same Print on both branches compiles."""
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            qb.X(q[0]),
+            Measure(q[0]) > c[0],
+            If(c[0]).Then(Print(c, tag="branch_taken")).Else(Print(c, tag="branch_taken")),
+        )
+        SlrConverter(prog).hugr()
+
+    def test_asymmetric_tag_rejected(self) -> None:
+        """Same shape, different tags across branches → reject."""
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            qb.X(q[0]),
+            Measure(q[0]) > c[0],
+            If(c[0]).Then(Print(c, tag="branch_a")).Else(Print(c, tag="branch_b")),
+        )
+        with pytest.raises(GuppyCodegenError, match="path-signature mismatch"):
+            SlrConverter(prog).hugr()
+
+    def test_asymmetric_multiplicity_rejected(self) -> None:
+        """Two Prints in Then, one in Else → reject."""
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            qb.X(q[0]),
+            Measure(q[0]) > c[0],
+            If(c[0])
+            .Then(
+                Print(c, tag="event"),
+                Print(c, tag="event"),
+            )
+            .Else(Print(c, tag="event")),
+        )
+        with pytest.raises(GuppyCodegenError, match="path-signature mismatch"):
+            SlrConverter(prog).hugr()
+
+    def test_asymmetric_namespace_rejected(self) -> None:
+        """Same tag, different namespace across branches → reject."""
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            qb.X(q[0]),
+            Measure(q[0]) > c[0],
+            If(c[0]).Then(Print(c, tag="x")).Else(Print(c, namespace="debug", tag="x")),
+        )
+        with pytest.raises(GuppyCodegenError, match="path-signature mismatch"):
+            SlrConverter(prog).hugr()
+
+    def test_static_repeat_with_print_compiles(self) -> None:
+        """Repeat(n) with Print inside is fine (static trip count)."""
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            Repeat(3).block(
+                qb.X(q[0]),
+                Measure(q[0]) > c[0],
+                qb.Prep(q[0]),
+                Print(c, tag="iter"),
+            ),
+        )
+        SlrConverter(prog).hugr()
+
+    def test_static_for_with_print_compiles(self) -> None:
+        """For with literal start/stop and Print inside compiles."""
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            For("i", 0, 3).Do(
+                qb.X(q[0]),
+                Measure(q[0]) > c[0],
+                qb.Prep(q[0]),
+                Print(c, tag="loop"),
+            ),
+        )
+        SlrConverter(prog).hugr()
+
+    def test_nested_if_with_symmetric_prints_accepted(self) -> None:
+        """Outer If has symmetric Prints; inner If has symmetric Prints."""
+        prog = Main(
+            q := QReg("q", 2),
+            c := CReg("c", 2),
+            qb.X(q[0]),
+            Measure(q[0]) > c[0],
+            Measure(q[1]) > c[1],
+            If(c[0])
+            .Then(
+                If(c[1]).Then(Print(c, tag="inner")).Else(Print(c, tag="inner")),
+                Print(c, tag="outer"),
+            )
+            .Else(
+                If(c[1]).Then(Print(c, tag="inner")).Else(Print(c, tag="inner")),
+                Print(c, tag="outer"),
+            ),
+        )
+        SlrConverter(prog).hugr()
+
+    def test_nested_if_with_asymmetric_inner_rejected(self) -> None:
+        """Inner If has asymmetric Prints; rejected at the inner If."""
+        prog = Main(
+            q := QReg("q", 2),
+            c := CReg("c", 2),
+            qb.X(q[0]),
+            Measure(q[0]) > c[0],
+            Measure(q[1]) > c[1],
+            If(c[0]).Then(If(c[1]).Then(Print(c, tag="leak"))),  # Else missing on inner
+        )
+        with pytest.raises(GuppyCodegenError, match="path-signature mismatch"):
+            SlrConverter(prog).hugr()

From 517f1fcc31efc0a2c6d64514c92406247decb4a2 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Thu, 14 May 2026 23:08:04 -0600
Subject: [PATCH 032/136] Phase 1 Print: inline-CReg definite-assignment
 dataflow validator + 8 tests (Codex's Print-before-Measure soundness gap
 closed)

---
 .../src/pecos/slr/ast/codegen/guppy.py        |  97 +++++++++++++++
 .../tests/slr_tests/ast_guppy/test_print.py   | 112 ++++++++++++++++++
 2 files changed, 209 insertions(+)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
index e02239f71..bc9371461 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
@@ -163,6 +163,7 @@ def generate(self, program: Program) -> list[str]:
         # Phase 1 Print AST-level validators (run before emission so failures
         # point at the source program, not the generated Guppy).
         self._validate_print_paths(program.body)
+        self._validate_print_inline_creg_assignment(program)
 
         body = list(program.body)
         explicit_return = self._validate_return_position(body)
@@ -453,6 +454,102 @@ def _static_int(self, expr) -> int | None:
             return expr.value
         return None
 
+    def _validate_print_inline_creg_assignment(self, program: Program) -> None:
+        """Reject Print of an inline CReg before any Measure has written to it.
+
+        Inline CRegs are those introduced only by `Measure(q) > CReg(...)` --
+        they appear in `context.registers` via `_collect_implicit_measure_registers`
+        but not in `program.declarations`. Without explicit user declaration in
+        `Main(...)`, the runtime sees an auto-initialized all-False register if a
+        Print runs before any Measure has populated it. That silent zero-emission
+        is the bug; this validator rejects it.
+
+        Declared CRegs (those in `program.declarations`) are NOT validated --
+        users who explicitly declare a CReg are acknowledging the zero-init.
+
+        Granularity: CReg-level (not bit-level). Any Measure into any bit of an
+        inline CReg marks the whole CReg as "assigned" for both `Print(c)` and
+        `Print(c[i])` reads. Bit-level definite-assignment is a v2.1 refinement.
+        """
+        declared = {d.name for d in program.declarations if isinstance(d, RegisterDecl)}
+        inline_cregs = {name for name in self.context.registers if name not in declared}
+        if not inline_cregs:
+            return
+        assigned: set[str] = set()
+        self._check_print_inline_assignment(program.body, assigned, inline_cregs)
+
+    def _check_print_inline_assignment(
+        self,
+        body: tuple[Statement, ...],
+        assigned: set[str],
+        inline_cregs: set[str],
+    ) -> None:
+        """Walk body left-to-right; mutate `assigned` in-place across the path.
+
+        At control-flow joins, merge per-path assignment sets:
+        - `If(...)`: definite-after = intersection of `then`/`else` post-states.
+        - `Repeat(n>=1)` / static `For(count>=1)`: body runs at least once, so
+          inner assignments propagate.
+        - `Repeat(0)` / static `For(count<=0)` / unknown `For` / `While`:
+          body may not run, so the outer `assigned` is preserved.
+        - `Parallel`: treated as sequential (matches the emitter's flatten
+          behavior).
+        """
+        from pecos.slr.ast.nodes import PrintOp  # noqa: PLC0415
+
+        for stmt in body:
+            if isinstance(stmt, MeasureOp):
+                for ref in stmt.results:
+                    if ref.register in inline_cregs:
+                        assigned.add(ref.register)
+            elif isinstance(stmt, PrintOp):
+                self._check_print_inline_read(stmt, assigned, inline_cregs)
+            elif isinstance(stmt, IfStmt):
+                then_assigned = set(assigned)
+                self._check_print_inline_assignment(stmt.then_body, then_assigned, inline_cregs)
+                else_assigned = set(assigned)
+                self._check_print_inline_assignment(stmt.else_body, else_assigned, inline_cregs)
+                assigned.update(then_assigned & else_assigned)
+            elif isinstance(stmt, RepeatStmt):
+                if stmt.count >= 1:
+                    inner_assigned = set(assigned)
+                    self._check_print_inline_assignment(stmt.body, inner_assigned, inline_cregs)
+                    assigned.update(inner_assigned)
+                # count == 0: body doesn't run; assigned unchanged.
+            elif isinstance(stmt, ForStmt):
+                trip = self._static_for_trip_count(stmt)
+                if trip is not None and trip >= 1:
+                    inner_assigned = set(assigned)
+                    self._check_print_inline_assignment(stmt.body, inner_assigned, inline_cregs)
+                    assigned.update(inner_assigned)
+                else:
+                    # Body may not run (trip 0 or unknown). Walk for Print
+                    # validation but do not propagate assignments to outer.
+                    self._check_print_inline_assignment(stmt.body, set(assigned), inline_cregs)
+            elif isinstance(stmt, WhileStmt):
+                # Body may not run; walk for validation, do not propagate.
+                self._check_print_inline_assignment(stmt.body, set(assigned), inline_cregs)
+            elif isinstance(stmt, ParallelBlock):
+                # Sequential flatten semantics.
+                self._check_print_inline_assignment(stmt.body, assigned, inline_cregs)
+
+    def _check_print_inline_read(self, op, assigned: set[str], inline_cregs: set[str]) -> None:
+        if isinstance(op.value, BitRef):
+            reg = op.value.register
+        elif isinstance(op.value, str):
+            reg = op.value
+        else:
+            return  # unrecognized; emit-time check handles it
+        if reg in inline_cregs and reg not in assigned:
+            msg = (
+                f"Print references inline CReg {reg!r} before any Measure has written to it. "
+                "Print would emit the all-False auto-initialized value, not a measurement result. "
+                f"Move the Print after a `Measure(...) > {reg}` that runs on every path, or "
+                f"declare {reg!r} explicitly as a positional in Main(...) if you intend to "
+                "print the zero-initialized state."
+            )
+            raise GuppyCodegenError(msg)
+
     def _emit_stmt(self, stmt: Statement) -> list[str]:
         if isinstance(stmt, GateOp):
             return self._emit_gate(stmt)
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
index 51fdb5758..f6fffec68 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
@@ -449,3 +449,115 @@ def test_nested_if_with_asymmetric_inner_rejected(self) -> None:
         )
         with pytest.raises(GuppyCodegenError, match="path-signature mismatch"):
             SlrConverter(prog).hugr()
+
+
+# ── Inline-CReg definite-assignment validator ────────────────────────────
+
+
+class TestInlineCRegDefiniteAssignment:
+    """Reject `Print(inline_creg)` when no prior Measure has populated it.
+
+    Inline CRegs (those introduced only via `Measure(q) > CReg(...)` without
+    being declared as a positional in `Main(...)`) auto-initialize to all-False
+    at the start of `main()` in the generated Guppy. A `Print` running before
+    any Measure has written to such a CReg silently emits zeros, which the
+    user almost certainly did not intend.
+
+    Declared CRegs are NOT validated: explicit declaration is the user's
+    acknowledgement of the zero-init.
+    """
+
+    def test_print_before_measure_on_inline_creg_rejected(self) -> None:
+        """The exact case Codex flagged in the tracer-bullet review."""
+        inline = CReg("inline", 1)
+        prog = Main(
+            q := QReg("q", 1),
+            qb.X(q[0]),
+            Print(inline, tag="before_measure"),
+            Measure(q[0]) > inline[0],
+        )
+        with pytest.raises(GuppyCodegenError, match=r"references inline CReg .* before any Measure"):
+            SlrConverter(prog).hugr()
+
+    def test_print_after_measure_on_inline_creg_accepted(self) -> None:
+        """Same shape, Print after Measure → OK."""
+        inline = CReg("inline", 1)
+        prog = Main(
+            q := QReg("q", 1),
+            qb.X(q[0]),
+            Measure(q[0]) > inline[0],
+            Print(inline, tag="after_measure"),
+        )
+        SlrConverter(prog).hugr()
+
+    def test_print_of_declared_creg_before_measure_accepted(self) -> None:
+        """Declared CReg (in Main.vars) is user-acknowledged zero-init; Print OK."""
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),  # declared positional, not inline
+            Print(c, tag="zero_init"),  # user knows c starts all-False
+            qb.X(q[0]),
+            Measure(q[0]) > c[0],
+            Print(c, tag="after"),
+        )
+        SlrConverter(prog).hugr()
+
+    def test_print_bit_ref_before_measure_on_inline_creg_rejected(self) -> None:
+        """Print(c[0]) where c is inline-only also rejected."""
+        inline = CReg("inline", 2)
+        prog = Main(
+            q := QReg("q", 2),
+            qb.X(q[0]),
+            Print(inline[0], tag="early"),
+            Measure(q[0]) > inline[0],
+            Measure(q[1]) > inline[1],
+        )
+        with pytest.raises(GuppyCodegenError, match=r"references inline CReg .* before any Measure"):
+            SlrConverter(prog).hugr()
+
+    def test_inline_creg_assigned_in_both_if_branches_propagates(self) -> None:
+        """Measure in both Then and Else marks the CReg assigned after the If."""
+        inline = CReg("inline", 1)
+        prog = Main(
+            q := QReg("q", 2),
+            c := CReg("c", 1),
+            qb.X(q[0]),
+            Measure(q[0]) > c[0],
+            If(c[0]).Then(qb.X(q[1]), Measure(q[1]) > inline[0]).Else(Measure(q[1]) > inline[0]),
+            Print(inline, tag="post_if"),
+        )
+        SlrConverter(prog).hugr()
+
+    def test_inline_creg_assigned_only_in_then_does_not_propagate(self) -> None:
+        """Measure in Then only → after-If, inline still not definitely assigned."""
+        inline = CReg("inline", 1)
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            qb.X(q[0]),
+            Measure(q[0]) > c[0],
+            If(c[0]).Then(Measure(q[0]) > inline[0]),
+            Print(inline, tag="maybe"),
+        )
+        with pytest.raises(GuppyCodegenError, match=r"references inline CReg .* before any Measure"):
+            SlrConverter(prog).hugr()
+
+    def test_inline_creg_assigned_in_repeat_body_propagates(self) -> None:
+        """Repeat(n) with n>=1 runs body at least once; assignment propagates out."""
+        inline = CReg("inline", 1)
+        prog = Main(
+            q := QReg("q", 1),
+            Repeat(3).block(qb.X(q[0]), Measure(q[0]) > inline[0], qb.Prep(q[0])),
+            Print(inline, tag="post_repeat"),
+        )
+        SlrConverter(prog).hugr()
+
+    def test_inline_creg_assigned_in_static_for_propagates(self) -> None:
+        """Static For with trip>=1 propagates assignment."""
+        inline = CReg("inline", 1)
+        prog = Main(
+            q := QReg("q", 1),
+            For("i", 0, 2).Do(qb.X(q[0]), Measure(q[0]) > inline[0], qb.Prep(q[0])),
+            Print(inline, tag="post_for"),
+        )
+        SlrConverter(prog).hugr()

From 92eec4df2001d285e74006ce095bccf4752a5a92 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Thu, 14 May 2026 23:19:59 -0600
Subject: [PATCH 033/136] Phase 1 Print: tighten inline-CReg validator to
 bit-level (Codex tracer-bullet finding Q4) + add missing coverage tests
 (While/Parallel/Repeat(0)/partial-CReg)

---
 .../src/pecos/slr/ast/codegen/guppy.py        |  70 +++++++----
 .../tests/slr_tests/ast_guppy/test_print.py   | 117 +++++++++++++++++-
 2 files changed, 158 insertions(+), 29 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
index bc9371461..f4945897d 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
@@ -455,7 +455,7 @@ def _static_int(self, expr) -> int | None:
         return None
 
     def _validate_print_inline_creg_assignment(self, program: Program) -> None:
-        """Reject Print of an inline CReg before any Measure has written to it.
+        """Reject Print of an inline CReg bit before Measure has written to it.
 
         Inline CRegs are those introduced only by `Measure(q) > CReg(...)` --
         they appear in `context.registers` via `_collect_implicit_measure_registers`
@@ -467,21 +467,24 @@ def _validate_print_inline_creg_assignment(self, program: Program) -> None:
         Declared CRegs (those in `program.declarations`) are NOT validated --
         users who explicitly declare a CReg are acknowledging the zero-init.
 
-        Granularity: CReg-level (not bit-level). Any Measure into any bit of an
-        inline CReg marks the whole CReg as "assigned" for both `Print(c)` and
-        `Print(c[i])` reads. Bit-level definite-assignment is a v2.1 refinement.
+        Granularity: **bit-level**. The validator tracks `(register, bit_index)`
+        pairs. `Print(c[i])` requires the specific `(c, i)` to be assigned;
+        whole-CReg `Print(c)` requires every bit `0..size-1` (inferred size) to
+        be assigned. Bit-level tracking also acts as a bounds check: a `Print`
+        referencing an index past the inferred size is rejected because that
+        `(reg, index)` cannot have been added by any Measure.
         """
         declared = {d.name for d in program.declarations if isinstance(d, RegisterDecl)}
         inline_cregs = {name for name in self.context.registers if name not in declared}
         if not inline_cregs:
             return
-        assigned: set[str] = set()
+        assigned: set[tuple[str, int]] = set()
         self._check_print_inline_assignment(program.body, assigned, inline_cregs)
 
     def _check_print_inline_assignment(
         self,
         body: tuple[Statement, ...],
-        assigned: set[str],
+        assigned: set[tuple[str, int]],
         inline_cregs: set[str],
     ) -> None:
         """Walk body left-to-right; mutate `assigned` in-place across the path.
@@ -490,8 +493,9 @@ def _check_print_inline_assignment(
         - `If(...)`: definite-after = intersection of `then`/`else` post-states.
         - `Repeat(n>=1)` / static `For(count>=1)`: body runs at least once, so
           inner assignments propagate.
-        - `Repeat(0)` / static `For(count<=0)` / unknown `For` / `While`:
-          body may not run, so the outer `assigned` is preserved.
+        - `Repeat(0)` / static `For(count<=0)` / non-static `For` / `While`:
+          body may not run. Walk for validation (catch unreachable invalid
+          Prints), but do NOT propagate inner assignments to the outer scope.
         - `Parallel`: treated as sequential (matches the emitter's flatten
           behavior).
         """
@@ -501,7 +505,7 @@ def _check_print_inline_assignment(
             if isinstance(stmt, MeasureOp):
                 for ref in stmt.results:
                     if ref.register in inline_cregs:
-                        assigned.add(ref.register)
+                        assigned.add((ref.register, ref.index))
             elif isinstance(stmt, PrintOp):
                 self._check_print_inline_read(stmt, assigned, inline_cregs)
             elif isinstance(stmt, IfStmt):
@@ -515,7 +519,9 @@ def _check_print_inline_assignment(
                     inner_assigned = set(assigned)
                     self._check_print_inline_assignment(stmt.body, inner_assigned, inline_cregs)
                     assigned.update(inner_assigned)
-                # count == 0: body doesn't run; assigned unchanged.
+                else:
+                    # count == 0: body doesn't run. Walk for validation; do not propagate.
+                    self._check_print_inline_assignment(stmt.body, set(assigned), inline_cregs)
             elif isinstance(stmt, ForStmt):
                 trip = self._static_for_trip_count(stmt)
                 if trip is not None and trip >= 1:
@@ -523,32 +529,44 @@ def _check_print_inline_assignment(
                     self._check_print_inline_assignment(stmt.body, inner_assigned, inline_cregs)
                     assigned.update(inner_assigned)
                 else:
-                    # Body may not run (trip 0 or unknown). Walk for Print
-                    # validation but do not propagate assignments to outer.
                     self._check_print_inline_assignment(stmt.body, set(assigned), inline_cregs)
             elif isinstance(stmt, WhileStmt):
-                # Body may not run; walk for validation, do not propagate.
                 self._check_print_inline_assignment(stmt.body, set(assigned), inline_cregs)
             elif isinstance(stmt, ParallelBlock):
-                # Sequential flatten semantics.
                 self._check_print_inline_assignment(stmt.body, assigned, inline_cregs)
 
-    def _check_print_inline_read(self, op, assigned: set[str], inline_cregs: set[str]) -> None:
+    def _check_print_inline_read(self, op, assigned: set[tuple[str, int]], inline_cregs: set[str]) -> None:
         if isinstance(op.value, BitRef):
             reg = op.value.register
+            if reg not in inline_cregs:
+                return
+            if (reg, op.value.index) not in assigned:
+                msg = (
+                    f"Print references inline CReg bit {reg}[{op.value.index}] before any "
+                    f"Measure has written to it. Print would emit the auto-initialized False "
+                    f"value (or read past the inferred register bound), not a measurement "
+                    f"result. Move the Print after a Measure(...) > {reg}[{op.value.index}] "
+                    f"that runs on every path, or declare {reg!r} explicitly as a positional "
+                    f"in Main(...) if you intend to print the zero-initialized state."
+                )
+                raise GuppyCodegenError(msg)
         elif isinstance(op.value, str):
             reg = op.value
-        else:
-            return  # unrecognized; emit-time check handles it
-        if reg in inline_cregs and reg not in assigned:
-            msg = (
-                f"Print references inline CReg {reg!r} before any Measure has written to it. "
-                "Print would emit the all-False auto-initialized value, not a measurement result. "
-                f"Move the Print after a `Measure(...) > {reg}` that runs on every path, or "
-                f"declare {reg!r} explicitly as a positional in Main(...) if you intend to "
-                "print the zero-initialized state."
-            )
-            raise GuppyCodegenError(msg)
+            if reg not in inline_cregs:
+                return
+            decl = self.context.registers.get(reg)
+            if decl is None:
+                return  # unknown; emit-time check handles it
+            unassigned = [i for i in range(decl.size) if (reg, i) not in assigned]
+            if unassigned:
+                msg = (
+                    f"Print(whole-CReg) references inline CReg {reg!r} but not all bits have "
+                    f"been written by Measure. Inferred register size is {decl.size}; "
+                    f"unassigned bit indices: {unassigned}. Move the Print after Measures that "
+                    f"cover every bit of {reg!r}, or declare {reg!r} explicitly as a positional "
+                    f"in Main(...)."
+                )
+                raise GuppyCodegenError(msg)
 
     def _emit_stmt(self, stmt: Statement) -> list[str]:
         if isinstance(stmt, GateOp):
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
index f6fffec68..5e40e7128 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
@@ -476,7 +476,7 @@ def test_print_before_measure_on_inline_creg_rejected(self) -> None:
             Print(inline, tag="before_measure"),
             Measure(q[0]) > inline[0],
         )
-        with pytest.raises(GuppyCodegenError, match=r"references inline CReg .* before any Measure"):
+        with pytest.raises(GuppyCodegenError, match=r"references inline CReg"):
             SlrConverter(prog).hugr()
 
     def test_print_after_measure_on_inline_creg_accepted(self) -> None:
@@ -512,7 +512,7 @@ def test_print_bit_ref_before_measure_on_inline_creg_rejected(self) -> None:
             Measure(q[0]) > inline[0],
             Measure(q[1]) > inline[1],
         )
-        with pytest.raises(GuppyCodegenError, match=r"references inline CReg .* before any Measure"):
+        with pytest.raises(GuppyCodegenError, match=r"references inline CReg"):
             SlrConverter(prog).hugr()
 
     def test_inline_creg_assigned_in_both_if_branches_propagates(self) -> None:
@@ -539,7 +539,7 @@ def test_inline_creg_assigned_only_in_then_does_not_propagate(self) -> None:
             If(c[0]).Then(Measure(q[0]) > inline[0]),
             Print(inline, tag="maybe"),
         )
-        with pytest.raises(GuppyCodegenError, match=r"references inline CReg .* before any Measure"):
+        with pytest.raises(GuppyCodegenError, match=r"references inline CReg"):
             SlrConverter(prog).hugr()
 
     def test_inline_creg_assigned_in_repeat_body_propagates(self) -> None:
@@ -561,3 +561,114 @@ def test_inline_creg_assigned_in_static_for_propagates(self) -> None:
             Print(inline, tag="post_for"),
         )
         SlrConverter(prog).hugr()
+
+    def test_print_inline_bit_with_only_other_bit_measured_rejected(self) -> None:
+        """Codex's exact bit-level soundness gap: Measure(inline[0]); Print(inline[1])
+        should be rejected, not silently emit a runtime out-of-bounds read.
+
+        Before bit-level tracking the validator marked the whole inline CReg as
+        "assigned" after any bit was measured, so Print(inline[1]) compiled and
+        Selene panicked at runtime. Bit-level tracking + the inferred-size
+        bound make this a clean construct-time rejection.
+        """
+        inline = CReg("inline", 2)
+        prog = Main(
+            q := QReg("q", 2),
+            qb.X(q[0]),
+            Measure(q[0]) > inline[0],
+            Print(inline[1], tag="bit1"),
+        )
+        with pytest.raises(GuppyCodegenError, match=r"references inline CReg"):
+            SlrConverter(prog).hugr()
+
+    def test_print_whole_inline_creg_with_all_bits_measured_accepted(self) -> None:
+        """Print(inline) is OK when every inferred bit has been Measure-assigned."""
+        inline = CReg("inline", 2)
+        prog = Main(
+            q := QReg("q", 2),
+            qb.X(q[0]),
+            Measure(q[0]) > inline[0],
+            Measure(q[1]) > inline[1],
+            Print(inline, tag="full"),
+        )
+        SlrConverter(prog).hugr()
+
+    def test_print_whole_inline_creg_with_partial_assignment_rejected(self) -> None:
+        """Print(inline) where one bit was only assigned in If.Then is rejected
+        after the If join (intersection of paths excludes the Then-only bit).
+
+        Error message lists the unassigned indices to point at what's missing.
+        """
+        inline = CReg("inline", 2)
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            qb.X(q[0]),
+            Measure(q[0]) > c[0],
+            qb.Prep(q[0]),
+            Measure(q[0]) > inline[0],  # inline[0] always assigned
+            If(c[0]).Then(qb.Prep(q[0]), Measure(q[0]) > inline[1]).Else(),
+            # inline[1] only assigned on the Then branch -> partial
+            Print(inline, tag="partial"),
+        )
+        with pytest.raises(GuppyCodegenError, match=r"not all bits"):
+            SlrConverter(prog).hugr()
+
+
+# ── Additional path-signature edge cases per Codex's review ─────────────
+
+
+class TestPathSignatureEdgeCases:
+    """Coverage Codex called out as missing in f2ebb32c."""
+
+    def test_while_with_print_rejected(self) -> None:
+        """While body with Print is rejected (v1 also rejects While outright)."""
+        from pecos.slr import While
+
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            qb.X(q[0]),
+            Measure(q[0]) > c[0],
+            While(c[0] == 0).Do(
+                Print(c, tag="loop"),
+                qb.Prep(q[0]),
+                Measure(q[0]) > c[0],
+            ),
+        )
+        with pytest.raises(GuppyCodegenError):
+            SlrConverter(prog).hugr()
+
+    def test_parallel_block_with_print_compiles(self) -> None:
+        """`Parallel(Print(c[0]), Print(c[1]))` compiles -- Parallel is sequential."""
+        from pecos.slr import Parallel
+
+        prog = Main(
+            q := QReg("q", 2),
+            c := CReg("c", 2),
+            qb.X(q[0]),
+            qb.X(q[1]),
+            Measure(q[0]) > c[0],
+            Measure(q[1]) > c[1],
+            Parallel(
+                Print(c[0], tag="bit0"),
+                Print(c[1], tag="bit1"),
+            ),
+        )
+        SlrConverter(prog).hugr()
+
+    def test_repeat_zero_with_print_walks_body_for_validation(self) -> None:
+        """Repeat(0) body never runs at runtime, but invalid Print constructs
+        inside it are still rejected at validation time. Assignments inside do
+        not propagate to the outer scope.
+        """
+        inline = CReg("inline", 1)
+        prog = Main(
+            q := QReg("q", 1),
+            Repeat(0).block(
+                Print(inline, tag="never_runs"),  # inline never written anywhere
+            ),
+            Measure(q[0]) > inline[0],
+        )
+        with pytest.raises(GuppyCodegenError, match=r"references inline CReg"):
+            SlrConverter(prog).hugr()

From 6efe8c360e98453fefd2645f2703f32788c852b8 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Thu, 14 May 2026 23:29:13 -0600
Subject: [PATCH 034/136] Phase 1 Print: reject whole-CReg Print of inline CReg
 outright (Codex v2 review Q2 -- prevents silent register shrink); rewrite
 affected tests at bit-level; add Codex shrink-case regression + direct AST
 non-static For test

---
 .../src/pecos/slr/ast/codegen/guppy.py        |  29 ++--
 .../tests/slr_tests/ast_guppy/test_print.py   | 126 +++++++++++++-----
 2 files changed, 111 insertions(+), 44 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
index f4945897d..0ceb71927 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
@@ -554,19 +554,22 @@ def _check_print_inline_read(self, op, assigned: set[tuple[str, int]], inline_cr
             reg = op.value
             if reg not in inline_cregs:
                 return
-            decl = self.context.registers.get(reg)
-            if decl is None:
-                return  # unknown; emit-time check handles it
-            unassigned = [i for i in range(decl.size) if (reg, i) not in assigned]
-            if unassigned:
-                msg = (
-                    f"Print(whole-CReg) references inline CReg {reg!r} but not all bits have "
-                    f"been written by Measure. Inferred register size is {decl.size}; "
-                    f"unassigned bit indices: {unassigned}. Move the Print after Measures that "
-                    f"cover every bit of {reg!r}, or declare {reg!r} explicitly as a positional "
-                    f"in Main(...)."
-                )
-                raise GuppyCodegenError(msg)
+            # Reject whole-CReg Print of an inline CReg outright in Phase 1.
+            # The user-stated `CReg(name, size)` size is lost during inline-from-
+            # Measure inference (only Measure-targeted bit indices contribute to
+            # the inferred RegisterDecl.size). Emitting `result(tag, c)` for the
+            # inferred c can silently shrink the register relative to the user's
+            # intent. Require either an explicit Main(...) declaration (then the
+            # CReg is no longer inline and whole-CReg Print is allowed) or per-bit
+            # `Print(c[i], ...)` calls.
+            msg = (
+                f"Print(whole-CReg) of inline CReg {reg!r} is rejected in Phase 1. "
+                "Whole-register Print can silently shrink an inline CReg because the "
+                "original `CReg(name, size)` size is lost during inline-from-Measure "
+                f"inference. Declare {reg!r} as a positional in `Main(...)` (then whole-"
+                f"CReg Print is allowed) or print individual bits via `Print({reg}[i], ...)`."
+            )
+            raise GuppyCodegenError(msg)
 
     def _emit_stmt(self, stmt: Statement) -> list[str]:
         if isinstance(stmt, GateOp):
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
index 5e40e7128..f8fb76839 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
@@ -467,26 +467,30 @@ class TestInlineCRegDefiniteAssignment:
     acknowledgement of the zero-init.
     """
 
-    def test_print_before_measure_on_inline_creg_rejected(self) -> None:
-        """The exact case Codex flagged in the tracer-bullet review."""
+    def test_print_bit_before_measure_on_inline_creg_rejected(self) -> None:
+        """Codex's original tracer-bullet bug case, lifted to bit-level form.
+
+        Print(inline[0]) before Measure(...) > inline[0] is rejected because
+        bit-level definite-assignment hasn't been established for index 0.
+        """
         inline = CReg("inline", 1)
         prog = Main(
             q := QReg("q", 1),
             qb.X(q[0]),
-            Print(inline, tag="before_measure"),
+            Print(inline[0], tag="before_measure"),
             Measure(q[0]) > inline[0],
         )
         with pytest.raises(GuppyCodegenError, match=r"references inline CReg"):
             SlrConverter(prog).hugr()
 
-    def test_print_after_measure_on_inline_creg_accepted(self) -> None:
-        """Same shape, Print after Measure → OK."""
+    def test_print_bit_after_measure_on_inline_creg_accepted(self) -> None:
+        """Print(inline[0]) after Measure(...) > inline[0] → OK."""
         inline = CReg("inline", 1)
         prog = Main(
             q := QReg("q", 1),
             qb.X(q[0]),
             Measure(q[0]) > inline[0],
-            Print(inline, tag="after_measure"),
+            Print(inline[0], tag="after_measure"),
         )
         SlrConverter(prog).hugr()
 
@@ -516,7 +520,7 @@ def test_print_bit_ref_before_measure_on_inline_creg_rejected(self) -> None:
             SlrConverter(prog).hugr()
 
     def test_inline_creg_assigned_in_both_if_branches_propagates(self) -> None:
-        """Measure in both Then and Else marks the CReg assigned after the If."""
+        """Measure-into-bit on both Then and Else marks the bit assigned after the If."""
         inline = CReg("inline", 1)
         prog = Main(
             q := QReg("q", 2),
@@ -524,12 +528,12 @@ def test_inline_creg_assigned_in_both_if_branches_propagates(self) -> None:
             qb.X(q[0]),
             Measure(q[0]) > c[0],
             If(c[0]).Then(qb.X(q[1]), Measure(q[1]) > inline[0]).Else(Measure(q[1]) > inline[0]),
-            Print(inline, tag="post_if"),
+            Print(inline[0], tag="post_if"),
         )
         SlrConverter(prog).hugr()
 
     def test_inline_creg_assigned_only_in_then_does_not_propagate(self) -> None:
-        """Measure in Then only → after-If, inline still not definitely assigned."""
+        """Measure-into-bit in Then only → after-If, that bit still not definitely assigned."""
         inline = CReg("inline", 1)
         prog = Main(
             q := QReg("q", 1),
@@ -537,28 +541,28 @@ def test_inline_creg_assigned_only_in_then_does_not_propagate(self) -> None:
             qb.X(q[0]),
             Measure(q[0]) > c[0],
             If(c[0]).Then(Measure(q[0]) > inline[0]),
-            Print(inline, tag="maybe"),
+            Print(inline[0], tag="maybe"),
         )
         with pytest.raises(GuppyCodegenError, match=r"references inline CReg"):
             SlrConverter(prog).hugr()
 
     def test_inline_creg_assigned_in_repeat_body_propagates(self) -> None:
-        """Repeat(n) with n>=1 runs body at least once; assignment propagates out."""
+        """Repeat(n) with n>=1 runs body at least once; bit assignment propagates out."""
         inline = CReg("inline", 1)
         prog = Main(
             q := QReg("q", 1),
             Repeat(3).block(qb.X(q[0]), Measure(q[0]) > inline[0], qb.Prep(q[0])),
-            Print(inline, tag="post_repeat"),
+            Print(inline[0], tag="post_repeat"),
         )
         SlrConverter(prog).hugr()
 
     def test_inline_creg_assigned_in_static_for_propagates(self) -> None:
-        """Static For with trip>=1 propagates assignment."""
+        """Static For with trip>=1 propagates bit assignment."""
         inline = CReg("inline", 1)
         prog = Main(
             q := QReg("q", 1),
             For("i", 0, 2).Do(qb.X(q[0]), Measure(q[0]) > inline[0], qb.Prep(q[0])),
-            Print(inline, tag="post_for"),
+            Print(inline[0], tag="post_for"),
         )
         SlrConverter(prog).hugr()
 
@@ -581,8 +585,16 @@ def test_print_inline_bit_with_only_other_bit_measured_rejected(self) -> None:
         with pytest.raises(GuppyCodegenError, match=r"references inline CReg"):
             SlrConverter(prog).hugr()
 
-    def test_print_whole_inline_creg_with_all_bits_measured_accepted(self) -> None:
-        """Print(inline) is OK when every inferred bit has been Measure-assigned."""
+    def test_whole_inline_creg_print_rejected_outright(self) -> None:
+        """Phase 1 rejects whole-CReg Print of an inline CReg unconditionally.
+
+        Even when every inferred bit has been Measure-assigned, whole-CReg
+        Print of an inline CReg silently shrinks the register relative to the
+        user's CReg(name, size) intent -- inline-from-Measure inference only
+        sees Measure-targeted indices, so the inferred RegisterDecl.size can
+        be smaller than what the user wrote. Phase 1 fail-fast: require
+        explicit Main(...) declaration or per-bit Print.
+        """
         inline = CReg("inline", 2)
         prog = Main(
             q := QReg("q", 2),
@@ -591,29 +603,43 @@ def test_print_whole_inline_creg_with_all_bits_measured_accepted(self) -> None:
             Measure(q[1]) > inline[1],
             Print(inline, tag="full"),
         )
-        SlrConverter(prog).hugr()
+        with pytest.raises(GuppyCodegenError, match=r"Print\(whole-CReg\) of inline CReg"):
+            SlrConverter(prog).hugr()
 
-    def test_print_whole_inline_creg_with_partial_assignment_rejected(self) -> None:
-        """Print(inline) where one bit was only assigned in If.Then is rejected
-        after the If join (intersection of paths excludes the Then-only bit).
+    def test_whole_inline_creg_print_codex_shrink_case_rejected(self) -> None:
+        """Regression for Codex's tracer-bullet review v2: whole-CReg Print of an
+        inline CReg silently emitting a register smaller than the user declared.
 
-        Error message lists the unassigned indices to point at what's missing.
+        Before this fix, `inline = CReg("inline", 2)` with only inline[0]
+        measured + `Print(inline)` would compile and emit `result("result.whole",
+        inline)` against a size-1 inferred register (max_measured_index + 1),
+        silently losing the user's stated size 2.
         """
         inline = CReg("inline", 2)
         prog = Main(
-            q := QReg("q", 1),
-            c := CReg("c", 1),
+            q := QReg("q", 2),
             qb.X(q[0]),
-            Measure(q[0]) > c[0],
-            qb.Prep(q[0]),
-            Measure(q[0]) > inline[0],  # inline[0] always assigned
-            If(c[0]).Then(qb.Prep(q[0]), Measure(q[0]) > inline[1]).Else(),
-            # inline[1] only assigned on the Then branch -> partial
-            Print(inline, tag="partial"),
+            Measure(q[0]) > inline[0],
+            Print(inline, tag="whole"),
         )
-        with pytest.raises(GuppyCodegenError, match=r"not all bits"):
+        with pytest.raises(GuppyCodegenError, match=r"Print\(whole-CReg\) of inline CReg"):
             SlrConverter(prog).hugr()
 
+    def test_whole_declared_creg_print_accepted(self) -> None:
+        """When the CReg is declared in Main(...), it's no longer inline and
+        whole-CReg Print is allowed (user-acknowledged size).
+        """
+        prog = Main(
+            q := QReg("q", 2),
+            c := CReg("c", 2),  # declared positional -> not inline
+            qb.X(q[0]),
+            qb.X(q[1]),
+            Measure(q[0]) > c[0],
+            Measure(q[1]) > c[1],
+            Print(c, tag="whole"),
+        )
+        SlrConverter(prog).hugr()
+
 
 # ── Additional path-signature edge cases per Codex's review ─────────────
 
@@ -666,9 +692,47 @@ def test_repeat_zero_with_print_walks_body_for_validation(self) -> None:
         prog = Main(
             q := QReg("q", 1),
             Repeat(0).block(
-                Print(inline, tag="never_runs"),  # inline never written anywhere
+                Print(inline[0], tag="never_runs"),  # inline[0] never written anywhere
             ),
             Measure(q[0]) > inline[0],
         )
         with pytest.raises(GuppyCodegenError, match=r"references inline CReg"):
             SlrConverter(prog).hugr()
+
+    def test_non_static_for_with_print_via_ast_rejected(self) -> None:
+        """Direct AST-level test for non-static For body containing Print.
+
+        v1's public SLR API doesn't allow non-static For bounds (start/stop
+        must be int literals), so this case isn't reachable via Main/Print
+        construction. Build the AST directly to pin the validator's defensive
+        rejection in `_static_for_trip_count`.
+        """
+        from pecos.slr.ast import (
+            AllocatorDecl,
+            ForStmt,
+            LiteralExpr,
+            PrintOp,
+            Program,
+            VarExpr,
+        )
+        from pecos.slr.ast.codegen.guppy import AstToGuppy
+
+        # main(q: array[qubit, 1] @ owned):
+        #   for i in range(x, 3):     # start is a VarExpr (non-literal) -> non-static
+        #       Print(c, tag="loop")  # rejected: Print inside non-static For
+        prog = Program(
+            name="main",
+            declarations=(AllocatorDecl(name="q", capacity=1, parent=None),),
+            body=(
+                ForStmt(
+                    variable="i",
+                    start=VarExpr(name="x"),
+                    stop=LiteralExpr(value=3),
+                    body=(PrintOp(value="c", tag="loop", namespace="result"),),
+                ),
+            ),
+        )
+
+        emitter = AstToGuppy()
+        with pytest.raises(GuppyCodegenError, match=r"non-static `For`"):
+            emitter.generate(prog)

From 95a36ee1e0f1050bcb99239548b956bacb5cb28d Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Fri, 15 May 2026 00:21:50 -0600
Subject: [PATCH 035/136] Phase 1 Print: adversarial tests (cross-codegen
 byte-identity + Selene shape edge cases + QASM exactly-one-comment assertion)

---
 .../tests/slr_tests/ast_guppy/test_print.py   | 178 ++++++++++++++++++
 1 file changed, 178 insertions(+)

diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
index f8fb76839..b71d4a172 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
@@ -736,3 +736,181 @@ def test_non_static_for_with_print_via_ast_rejected(self) -> None:
         emitter = AstToGuppy()
         with pytest.raises(GuppyCodegenError, match=r"non-static `For`"):
             emitter.generate(prog)
+
+
+# ── Cross-codegen byte-identity (per Codex review v2-blockcall-resource-effects) ─
+
+
+class TestCrossCodegenPrintEmission:
+    """Pin the behavior of each non-Guppy codegen when Print is inserted.
+
+    Empirically probed 2026-05-14 against a Bell-state program with and without
+    a trailing `Print(c, tag="debug")`:
+
+    - **QASM**: emits `// Print result.debug c` as a comment line; output is
+      *not* byte-identical (intentional, per the doc's "comment-only across
+      non-Guppy" plan).
+    - **QIR**, **Stim**, **QuantumCircuit**: silently skip PrintOp via their
+      isinstance-dispatch fallback (no else clause). Output is byte-identical.
+
+    These tests pin both behaviors. If a future change starts emitting in
+    QIR/Stim/QC, this catches it. If QASM stops emitting the comment, this
+    catches it.
+    """
+
+    @staticmethod
+    def _bell_no_print() -> Main:
+        return Main(
+            q := QReg("q", 2),
+            c := CReg("c", 2),
+            qb.H(q[0]),
+            qb.CX(q[0], q[1]),
+            Measure(q) > c,
+        )
+
+    @staticmethod
+    def _bell_with_print() -> Main:
+        return Main(
+            q := QReg("q", 2),
+            c := CReg("c", 2),
+            qb.H(q[0]),
+            qb.CX(q[0], q[1]),
+            Measure(q) > c,
+            Print(c, tag="debug"),
+        )
+
+    def test_qasm_emits_print_as_exactly_one_comment_line(self) -> None:
+        """QASM adds exactly one `// Print result.debug c` line; otherwise identical.
+
+        Per Codex round-3 review: "in `added_lines`" is too loose -- a future
+        regression could add extra lines silently and the test would still pass.
+        Assert the added line is exactly `[expected_comment]` (one line, no more).
+        """
+        a = SlrConverter(self._bell_no_print()).qasm()
+        b = SlrConverter(self._bell_with_print()).qasm()
+        assert a != b, "expected QASM to emit a Print comment, not silently skip"
+        expected_added = "// Print result.debug c"
+        # Set-diff the line lists to detect ALL additions, not just whether
+        # the expected line is somewhere among them.
+        added_lines = [line for line in b.splitlines() if line not in a.splitlines()]
+        assert added_lines == [expected_added], f"expected exactly [{expected_added!r}] added lines, got {added_lines}"
+
+    def test_qir_byte_identical(self) -> None:
+        """QIR silently drops Print; pre/post output is byte-identical."""
+        a = SlrConverter(self._bell_no_print()).qir()
+        b = SlrConverter(self._bell_with_print()).qir()
+        assert a == b, "QIR Print emission must be a silent skip (Phase 1 policy)"
+
+    def test_stim_byte_identical(self) -> None:
+        a = str(SlrConverter(self._bell_no_print()).stim())
+        b = str(SlrConverter(self._bell_with_print()).stim())
+        assert a == b, "Stim Print emission must be a silent skip (Phase 1 policy)"
+
+    def test_quantum_circuit_byte_identical(self) -> None:
+        a = str(SlrConverter(self._bell_no_print()).quantum_circuit())
+        b = str(SlrConverter(self._bell_with_print()).quantum_circuit())
+        assert a == b, "QuantumCircuit Print emission must be a silent skip (Phase 1 policy)"
+
+
+# ── Selene shape edge cases (probed 2026-05-14) ──────────────────────────
+
+
+class TestSeleneShapeEdgeCases:
+    """Pin non-obvious Selene `to_dict()` shapes that grug guessed wrong about.
+
+    These tests use empirically-probed reference shapes. If Selene's
+    representation changes, the test fails loudly and the doc text in
+    `v2-print.md` needs updating.
+    """
+
+    def test_multibit_creg_print_in_repeat_flattens_iterations_into_inner_list(self) -> None:
+        """Selene flattens iteration x bit into a single inner list per shot.
+
+        Empirical shape for 2-shot x 2-iter x 2-bit:
+            {'result.iter': [[1, 0, 1, 0], [1, 0, 1, 0]]}
+        NOT nested per-iteration like `[[[1,0],[1,0]], [[1,0],[1,0]]]`.
+
+        Pinning matters: a future Selene change could nest by iteration, which
+        would break user code that consumes the flat layout.
+        """
+        prog = Main(
+            q := QReg("q", 2),
+            c := CReg("c", 2),
+            Repeat(2).block(
+                qb.X(q[0]),
+                Measure(q[0]) > c[0],
+                qb.Prep(q[0]),
+                Print(c, tag="iter"),
+            ),
+        )
+        raw = _run_and_get_result_dict(prog, shots=3, qubits=2)
+        assert "result.iter" in raw
+        events = raw["result.iter"]
+        assert len(events) == 3, f"expected 3 per-shot lists, got {len(events)}"
+        # Each shot: 2 iterations x 2 bits = 4 ints flat.
+        # X on q[0] each iter -> c[0] = 1; c[1] never measured -> 0.
+        # Iteration order: [c[0]_iter0, c[1]_iter0, c[0]_iter1, c[1]_iter1].
+        expected_per_shot = [1, 0, 1, 0]
+        for shot_events in events:
+            assert list(shot_events) == expected_per_shot, shot_events
+
+    def test_empty_main_returns_empty_dict_no_measurements(self) -> None:
+        """Empty Main() compiles to a no-op program; Selene to_dict() is empty."""
+        from pecos import Hugr, selene_engine, sim
+
+        prog = Main()
+        package = SlrConverter(prog).hugr()
+        hugr_bytes = package.to_str().encode("utf-8")
+        result = sim(Hugr(hugr_bytes)).classical(selene_engine()).qubits(1).seed(42).run(2)
+        raw = result.to_dict() if hasattr(result, "to_dict") else result
+        assert raw == {}, f"expected empty result dict for empty Main(), got {raw}"
+
+    def test_single_print_single_bit_creg_flat_per_shot_list(self) -> None:
+        """Selene shape: ONE Print of a single-bit declared CReg → flat int per shot.
+
+        Empirical shape: `{'result.zero_init': [0, 0]}` for 2 shots.
+
+        NOT `[[0], [0]]` -- when there's exactly one event per shot and the
+        event is a single bit, Selene flattens to a plain int. Pin this so
+        users writing `result.tag[shot]` get a stable contract.
+        """
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            Print(c, tag="zero_init"),  # before Measure: bit is the False init
+            Measure(q[0]) > c[0],
+        )
+        raw = _run_and_get_result_dict(prog, shots=2)
+        assert "result.zero_init" in raw
+        events = raw["result.zero_init"]
+        assert len(events) == 2
+        # Each shot is a bare int, not a list.
+        for shot_value in events:
+            assert isinstance(shot_value, int), f"expected int per shot, got {type(shot_value).__name__}"
+            assert shot_value == 0  # Print before Measure -> auto-init False
+
+    def test_single_print_multibit_creg_list_per_shot(self) -> None:
+        """Selene shape: ONE Print of a multi-bit declared CReg → list of bits per shot.
+
+        Empirical: `{'result.tag': [[1, 0], [1, 0]]}` for 2 shots x 2-bit CReg.
+        Contrast with the single-bit case above which returns a flat int per shot.
+        """
+        prog = Main(
+            q := QReg("q", 2),
+            c := CReg("c", 2),
+            qb.X(q[0]),
+            Measure(q[0]) > c[0],
+            Measure(q[1]) > c[1],
+            Print(c, tag="pair"),
+        )
+        raw = _run_and_get_result_dict(prog, shots=2, qubits=2)
+        assert "result.pair" in raw
+        events = raw["result.pair"]
+        assert len(events) == 2
+        for shot_value in events:
+            # Multi-bit: list of 2 ints per shot.
+            assert hasattr(shot_value, "__len__"), f"expected list per shot, got {type(shot_value).__name__}"
+            assert len(shot_value) == 2
+            # X on q[0] -> c[0]=1; c[1]=0.
+            assert int(shot_value[0]) == 1
+            assert int(shot_value[1]) == 0

From 068bba34ca48b9e3c88243015fd4bce9fc83397d Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Fri, 15 May 2026 00:23:00 -0600
Subject: [PATCH 036/136] Phase 2 deprecation warnings: CReg(result=False)
 construction-time warning + Main(...) implicit-return warning fired SLR-wide
 across all codegen entry points (cached per converter, stacklevel attributes
 to user, walker tightened to skip false-positive no-result Measure and
 result=False-only targets)

---
 .../src/pecos/slr/slr_converter.py            | 123 ++++++++
 python/quantum-pecos/src/pecos/slr/vars.py    |  26 +-
 .../ast_guppy/test_deprecation_warnings.py    | 279 ++++++++++++++++++
 3 files changed, 423 insertions(+), 5 deletions(-)
 create mode 100644 python/quantum-pecos/tests/slr_tests/ast_guppy/test_deprecation_warnings.py

diff --git a/python/quantum-pecos/src/pecos/slr/slr_converter.py b/python/quantum-pecos/src/pecos/slr/slr_converter.py
index 9609231d7..beb808360 100644
--- a/python/quantum-pecos/src/pecos/slr/slr_converter.py
+++ b/python/quantum-pecos/src/pecos/slr/slr_converter.py
@@ -46,12 +46,44 @@ def __init__(self, block: Main | None = None, *, optimize_parallel: bool = True)
         self._original_block = block
         self._block = block
         self._optimize_parallel = optimize_parallel
+        # Phase 2: fire deprecation warning once per SlrConverter for any
+        # program that relies on the implicit-return rule. Cached so multiple
+        # codegen calls on the same converter do not spam the user.
+        self._implicit_return_warned = False
 
         # Apply transformations if requested and block is provided
         if block is not None and optimize_parallel:
             optimizer = ParallelOptimizer()
             self._block = optimizer.transform(self._block)
 
+    def _maybe_warn_implicit_return_deprecation(self) -> None:
+        """Phase 2 deprecation: warn once per converter when implicit return is in use.
+
+        Fires from every user-facing codegen entry point (`.qasm()`,
+        `.qir()`, `.qir_bc()`, `.guppy()`, `.hugr()`, `.stim()`,
+        `.quantum_circuit()`, `.generate(...)`). SLR-wide rather than
+        Guppy/HUGR-only -- the v2 Phase 3b breaking change is an SLR-API
+        change (drop `result=` kwarg + mandatory Return) that affects every
+        downstream codegen consumer.
+
+        Walks the SLR block directly (not the AST) so we don't trip the
+        slr-to-ast converter on programs the Guppy v1 preflight is supposed
+        to reject (e.g. symbolic LoopVar indexing). Means we read SLR-level
+        Measure.cout and CReg.result, not AST MeasureOp.results / RegisterDecl.is_result.
+
+        Stacklevel attribution: this method is called directly from the
+        public entry point, so `warnings.warn(..., stacklevel=3)` walks
+        past the warn site, past this method, past the public method, and
+        attributes the warning to the user's call site.
+        """
+        if self._implicit_return_warned or self._original_block is None:
+            return
+        self._implicit_return_warned = True  # Cache early to avoid re-walk on cycle.
+        import warnings
+
+        if _slr_block_relies_on_implicit_return(self._original_block):
+            warnings.warn(_IMPLICIT_RETURN_WARNING_MSG, DeprecationWarning, stacklevel=3)
+
     def _to_ast(self):
         """Convert the SLR block to AST."""
         if self._block is None:
@@ -80,6 +112,7 @@ def generate(
             Generated code as a string
         """
         del add_versions  # Deprecated parameter, kept for backwards compatibility
+        self._maybe_warn_implicit_return_deprecation()
         if target == Language.QASM:
             return self._generate_qasm(include_header=not skip_headers)
         if target in [Language.QIR, Language.QIRBC]:
@@ -146,6 +179,7 @@ def qasm(self, *, skip_headers: bool = False, add_versions: bool = False) -> str
             Generated QASM code as a string
         """
         del add_versions  # Deprecated parameter, kept for backwards compatibility
+        self._maybe_warn_implicit_return_deprecation()
         return self._generate_qasm(include_header=not skip_headers)
 
     def qir(self) -> str:
@@ -154,6 +188,7 @@ def qir(self) -> str:
         Returns:
             Generated QIR code as a string
         """
+        self._maybe_warn_implicit_return_deprecation()
         return self._generate_qir()
 
     def qir_bc(self) -> bytes:
@@ -162,6 +197,7 @@ def qir_bc(self) -> bytes:
         Returns:
             Generated QIR bytecode
         """
+        self._maybe_warn_implicit_return_deprecation()
         return self._generate_qir(bytecode=True)
 
     def guppy(self) -> str:
@@ -170,6 +206,7 @@ def guppy(self) -> str:
         Returns:
             Generated Guppy code as a string
         """
+        self._maybe_warn_implicit_return_deprecation()
         return self._generate_guppy()
 
     def hugr(self):
@@ -182,6 +219,7 @@ def hugr(self):
             ImportError: If guppylang is not available
             RuntimeError: If compilation fails
         """
+        self._maybe_warn_implicit_return_deprecation()
         return self._compile_hugr()
 
     def _compile_hugr(self):
@@ -236,6 +274,7 @@ def stim(self) -> stim.Circuit:
         """
         from pecos.slr.ast.codegen.stim import ast_to_stim
 
+        self._maybe_warn_implicit_return_deprecation()
         ast = self._to_ast()
         return ast_to_stim(ast)
 
@@ -247,6 +286,7 @@ def quantum_circuit(self) -> QuantumCircuit:
         """
         from pecos.slr.ast.codegen.quantum_circuit import ast_to_quantum_circuit
 
+        self._maybe_warn_implicit_return_deprecation()
         ast = self._to_ast()
         return ast_to_quantum_circuit(ast)
 
@@ -308,6 +348,89 @@ def from_quantum_circuit(cls, qc, *, optimize_parallel: bool = True):
         return slr_block
 
 
+def _slr_block_relies_on_implicit_return(block) -> bool:
+    """True if the v1 emitter would expose any CReg via the implicit-return rule.
+
+    Walks the SLR-level Main block (`block.vars`, `block.ops`) rather than the
+    AST so we don't trigger slr-to-ast conversion on programs the Guppy v1
+    preflight should reject (e.g. symbolic LoopVar indexing in `For(i,
+    range(n))` where `i` is a `LoopVar`).
+
+    Implicit return fires when both:
+
+    1. The block has no top-level `Return(...)` (no explicit Return).
+    2. There exists at least one CReg the emitter would include in `main`'s
+       return tuple:
+       a. A declared CReg in `block.vars` with `result=True` (the default) --
+          exposed even if never measured (auto-init to all-False).
+       b. A CReg referenced as a `Measure(...) > c[i]` target where `c` is
+          NOT in `block.vars` -- inline CRegs inferred at AST time get
+          `is_result=True` automatically.
+
+    Programs with `Measure(q[0])` (no `> c[i]`) or measuring exclusively
+    into declared `result=False` CRegs do NOT trigger.
+    """
+    # Class names used for SLR-level type matching. Avoids cyclic imports
+    # at module load time.
+    if _slr_block_has_explicit_return(block):
+        return False
+
+    declared_creg_names: set[str] = set()
+    has_declared_result_creg = False
+    for var in getattr(block, "vars", ()):
+        if type(var).__name__ == "CReg":
+            declared_creg_names.add(getattr(var, "sym", ""))
+            if getattr(var, "result", True):
+                has_declared_result_creg = True
+    if has_declared_result_creg:
+        return True
+
+    return _slr_walk_for_inline_measure_target(getattr(block, "ops", ()), declared_creg_names)
+
+
+def _slr_block_has_explicit_return(block) -> bool:
+    """True if `block` has a top-level Return statement."""
+    return any(type(op).__name__ == "Return" for op in getattr(block, "ops", ()))
+
+
+def _slr_walk_for_inline_measure_target(ops, declared_creg_names: set[str]) -> bool:
+    """Recurse SLR ops for any Measure-into-inline-CReg target."""
+    for op in ops:
+        type_name = type(op).__name__
+        if type_name == "Measure":
+            cout = getattr(op, "cout", None)
+            if cout is not None:
+                for bit in cout:
+                    reg = getattr(bit, "reg", None)
+                    reg_name = getattr(reg, "sym", None) if reg is not None else None
+                    if reg_name is not None and reg_name not in declared_creg_names:
+                        return True  # Inline target -- inferred is_result=True.
+        elif type_name == "If":
+            # If has `.ops` (Then-branch) and `.else_block` (an Else Block or None).
+            if _slr_walk_for_inline_measure_target(getattr(op, "ops", ()), declared_creg_names):
+                return True
+            else_block = getattr(op, "else_block", None)
+            if else_block is not None and _slr_walk_for_inline_measure_target(
+                getattr(else_block, "ops", ()),
+                declared_creg_names,
+            ):
+                return True
+        elif hasattr(op, "ops"):
+            # Any other Block subclass (Repeat, For, While, Parallel, plain Block) has `.ops`.
+            if _slr_walk_for_inline_measure_target(op.ops, declared_creg_names):
+                return True
+    return False
+
+
+_IMPLICIT_RETURN_WARNING_MSG = (
+    "Implicit return of result-flagged CRegs from `Main(...)` is deprecated "
+    "and will be removed in the SLR v2 breaking transition (Phase 3b). Add "
+    "an explicit `Return(...)` listing the CRegs (or values) you want exposed; "
+    "mid-program measurement output can use `Print(...)`. See pecos-docs "
+    "design/slr/v2-breaking-migration.md for migration guidance."
+)
+
+
 def _load_and_compile_entry(temp_file, module_name: str):
     """Import the AST-generated module from `temp_file` and compile its `entry()`.
 
diff --git a/python/quantum-pecos/src/pecos/slr/vars.py b/python/quantum-pecos/src/pecos/slr/vars.py
index afd0d31f5..6b4455e78 100644
--- a/python/quantum-pecos/src/pecos/slr/vars.py
+++ b/python/quantum-pecos/src/pecos/slr/vars.py
@@ -12,6 +12,8 @@
 
 from __future__ import annotations
 
+import warnings
+
 from pecos.slr.cops import SET, PyCOp
 
 # TODO: Make it a VarDef
@@ -216,16 +218,30 @@ def resolve(self, value: int) -> Qubit:
 
 class CReg(Reg, PyCOp):
     def __init__(self, sym: str, size: int, *, result: bool = True) -> None:
-        """
-        Representation for a collection of bits.
+        """Representation for a collection of bits.
 
         Args:
-            sym:
-            size:
-            result: Whether this register is a result register (default True)
+            sym: Register name.
+            size: Number of bits.
+            result: **Deprecated.** Whether this register is a result register
+                (default True). Phase 2 of the v2 output-model redesign
+                deprecates this kwarg; Phase 3b removes it. Use explicit
+                `Return(...)` and `Print(...)` to control output instead. See
+                `~/Repos/pecos-docs/design/slr/v2-breaking-migration.md` for
+                the migration path.
         """
         super().__init__(sym, size, elem_type=Bit)
         self.result = result
+        if result is False:
+            warnings.warn(
+                "`CReg(..., result=False)` is deprecated and will be removed in "
+                "the SLR v2 breaking transition (Phase 3b). Use explicit "
+                "`Return(...)` and `Print(...)` to control which registers are "
+                "exposed to the runtime. See pecos-docs "
+                "design/slr/v2-breaking-migration.md for migration guidance.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
 
     @property
     def _symbolic_elem_type(self) -> type[SymbolicBit]:
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_deprecation_warnings.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_deprecation_warnings.py
new file mode 100644
index 000000000..ff49e29d0
--- /dev/null
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_deprecation_warnings.py
@@ -0,0 +1,279 @@
+# Copyright 2026 The PECOS Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations under the License.
+
+"""Phase 2 deprecation warnings for v2 SLR output-model redesign.
+
+v2's breaking transition (Phase 3b in
+`~/Repos/pecos-docs/design/slr/v2-breaking-migration.md`) will:
+
+- Remove the `result=` kwarg from `CReg`.
+- Make `Return(...)` mandatory for any exposed output; drop the implicit
+  return-of-all-result-CRegs rule.
+
+Phase 2 (this commit) gives users one release of warning before the breaking
+flip. Both warnings are `DeprecationWarning` so CI surfaces them under
+`-W error::DeprecationWarning` without breaking default usage.
+"""
+
+from __future__ import annotations
+
+import warnings
+
+import pytest
+from pecos.slr import CReg, Main, QReg, Return, SlrConverter
+from pecos.slr.qeclib import qubit as qb
+from pecos.slr.qeclib.qubit.measures import Measure
+
+
+class TestCRegResultKwargDeprecation:
+    """`CReg(..., result=False)` warns at construction time."""
+
+    def test_creg_with_result_false_emits_deprecation_warning(self) -> None:
+        with pytest.warns(DeprecationWarning, match=r"`CReg\(\.\.\., result=False\)`"):
+            CReg("c", 1, result=False)
+
+    def test_creg_with_default_result_does_not_warn(self) -> None:
+        """The default (result=True) is the legacy behavior; don't warn on it.
+
+        That avoids spamming every existing SLR program with deprecation
+        noise. Programs that explicitly opt into result=False get the warning.
+        """
+        with warnings.catch_warnings():
+            warnings.simplefilter("error")  # turn any warning into a test failure
+            CReg("c", 1)
+
+    def test_creg_with_explicit_result_true_does_not_warn(self) -> None:
+        """Explicit result=True is also the default behavior; not deprecated."""
+        with warnings.catch_warnings():
+            warnings.simplefilter("error")
+            CReg("c", 1, result=True)
+
+    def test_warning_points_at_user_call_site(self) -> None:
+        """The DeprecationWarning's stacklevel should attribute to the user code,
+        not to CReg.__init__ itself. Use stacklevel=2 so the warning's filename
+        matches this test file.
+        """
+        with pytest.warns(DeprecationWarning, match=r"`CReg\(\.\.\., result=False\)`") as record:
+            CReg("c", 1, result=False)
+        assert len(record) == 1
+        # The recorded warning's filename should be this test file.
+        assert "test_deprecation_warnings.py" in record[0].filename
+
+
+class TestImplicitReturnDeprecation:
+    """Programs with measurements but no explicit `Return(...)` warn at
+    `.guppy()` / `.hugr()` time.
+    """
+
+    def test_implicit_return_warns_on_program_with_measure_no_return(self) -> None:
+        """Classic v1 pattern: Measure into result CReg, no explicit Return.
+        v2 will require Return; warn now.
+        """
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            qb.X(q[0]),
+            Measure(q[0]) > c[0],
+        )
+        with pytest.warns(DeprecationWarning, match=r"Implicit return"):
+            SlrConverter(prog).guppy()
+
+    def test_explicit_return_silences_warning(self) -> None:
+        """With explicit Return, no deprecation warning fires."""
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            qb.X(q[0]),
+            Measure(q[0]) > c[0],
+            Return(c),
+        )
+        with warnings.catch_warnings():
+            # Promote DeprecationWarning to error so any fire = test failure.
+            warnings.simplefilter("error", DeprecationWarning)
+            SlrConverter(prog).guppy()
+
+    def test_no_measurement_does_not_warn(self) -> None:
+        """A program with no Measure has nothing to implicitly return.
+
+        Don't pester users with the implicit-return warning when there's
+        no implicit-return behavior to deprecate.
+        """
+        prog = Main(
+            q := QReg("q", 1),
+            qb.H(q[0]),
+        )
+        with warnings.catch_warnings():
+            warnings.simplefilter("error", DeprecationWarning)
+            SlrConverter(prog).guppy()
+
+    def test_empty_main_does_not_warn(self) -> None:
+        prog = Main()
+        with warnings.catch_warnings():
+            warnings.simplefilter("error", DeprecationWarning)
+            SlrConverter(prog).guppy()
+
+    def test_measure_inside_repeat_triggers_warning(self) -> None:
+        """The walker descends into Repeat / For / While / Parallel / If bodies."""
+        from pecos.slr import Repeat
+
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            Repeat(2).block(qb.X(q[0]), Measure(q[0]) > c[0], qb.Prep(q[0])),
+        )
+        with pytest.warns(DeprecationWarning, match=r"Implicit return"):
+            SlrConverter(prog).guppy()
+
+    def test_measure_inside_if_triggers_warning(self) -> None:
+        from pecos.slr import If
+
+        prog = Main(
+            q := QReg("q", 2),
+            c := CReg("c", 1),
+            d := CReg("d", 1),
+            qb.X(q[0]),
+            Measure(q[0]) > c[0],
+            If(c[0]).Then(Measure(q[1]) > d[0]).Else(Measure(q[1]) > d[0]),
+        )
+        with pytest.warns(DeprecationWarning, match=r"Implicit return"):
+            SlrConverter(prog).guppy()
+
+    def test_warning_does_not_block_compilation(self) -> None:
+        """The deprecation warning is non-blocking; .guppy() and .hugr() still
+        succeed. Only Phase 3b makes the breaking change.
+        """
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            qb.X(q[0]),
+            Measure(q[0]) > c[0],
+        )
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", DeprecationWarning)
+            source = SlrConverter(prog).guppy()
+            assert "result.c" not in source  # no Print emitted; only return
+            package = SlrConverter(prog).hugr()
+            assert package is not None
+
+    def test_warning_points_at_user_call_site(self) -> None:
+        """Stacklevel must attribute to the user's .guppy()/.hugr()/etc. call site,
+        not to internals of slr_converter.py. Empirically verified post-Codex's
+        review (round 2): stacklevel=3 from `_maybe_warn_implicit_return_deprecation`
+        walks past the warn line, past the helper, past the public method,
+        landing on the user.
+        """
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            qb.X(q[0]),
+            Measure(q[0]) > c[0],
+        )
+        with pytest.warns(DeprecationWarning, match=r"Implicit return") as record:
+            SlrConverter(prog).guppy()
+        assert len(record) == 1
+        assert (
+            "test_deprecation_warnings.py" in record[0].filename
+        ), f"expected warning attributed to this test file; got {record[0].filename}"
+
+    def test_warning_fires_only_once_per_converter(self) -> None:
+        """Cached on the SlrConverter instance: multiple codegen calls share one warning."""
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            qb.X(q[0]),
+            Measure(q[0]) > c[0],
+        )
+        converter = SlrConverter(prog)
+        with warnings.catch_warnings(record=True) as caught:
+            warnings.simplefilter("always", DeprecationWarning)
+            converter.guppy()
+            converter.qasm()
+            converter.hugr()
+        deprecation = [w for w in caught if issubclass(w.category, DeprecationWarning)]
+        # Exactly one implicit-return warning across the three codegen calls.
+        implicit_return_warnings = [w for w in deprecation if "Implicit return" in str(w.message)]
+        assert (
+            len(implicit_return_warnings) == 1
+        ), f"expected 1 implicit-return warning across 3 codegen calls, got {len(implicit_return_warnings)}"
+
+    def test_warning_fires_for_qasm_qir_stim_quantum_circuit_too(self) -> None:
+        """Phase 2 deprecation is SLR-wide (not Guppy/HUGR-only): every public
+        codegen entry point on SlrConverter fires the warning, because the
+        v2 breaking change is an SLR-API change downstream consumers all see.
+        """
+        for entry in ("qasm", "guppy", "hugr", "qir", "stim", "quantum_circuit"):
+            prog = Main(
+                q := QReg("q", 1),
+                c := CReg("c", 1),
+                qb.X(q[0]),
+                Measure(q[0]) > c[0],
+            )
+            with pytest.warns(DeprecationWarning, match=r"Implicit return"):
+                getattr(SlrConverter(prog), entry)()
+
+    def test_measure_with_no_result_does_not_warn(self) -> None:
+        """`Measure(q[0])` without a `> c[i]` results tuple writes to no CReg,
+        so the implicit-return rule is not engaged. Don't warn.
+
+        Codex tracer-bullet review v3: the original walker treated *any*
+        MeasureOp as evidence of implicit-return reliance, which was a
+        false positive for measure-and-discard patterns.
+        """
+        prog = Main(
+            q := QReg("q", 1),
+            qb.X(q[0]),
+            Measure(q[0]),  # discard the result
+        )
+        with warnings.catch_warnings():
+            warnings.simplefilter("error", DeprecationWarning)
+            SlrConverter(prog).guppy()
+
+    def test_measure_into_only_result_false_creg_does_not_warn(self) -> None:
+        """When the only Measure target is a declared `result=False` CReg,
+        nothing flows through the implicit-return rule. Don't warn.
+
+        (The CReg(result=False) construction itself emits its own deprecation;
+        we suppress that here so the test focuses on the implicit-return check.)
+        """
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", DeprecationWarning)
+            scratch = CReg("scratch", 1, result=False)
+
+        prog = Main(
+            q := QReg("q", 1),
+            scratch,  # declared positional, result=False -> opt-out
+            qb.X(q[0]),
+            Measure(q[0]) > scratch[0],
+        )
+        with warnings.catch_warnings(record=True) as caught:
+            warnings.simplefilter("always", DeprecationWarning)
+            SlrConverter(prog).guppy()
+        # No implicit-return warning should fire.
+        implicit_return_warnings = [w for w in caught if "Implicit return" in str(w.message)]
+        assert len(implicit_return_warnings) == 0, (
+            "result=False-only Measure should not trigger implicit-return warning; "
+            f"got {[str(w.message) for w in implicit_return_warnings]}"
+        )
+
+    def test_declared_result_creg_without_measure_still_warns(self) -> None:
+        """Declared `is_result=True` CRegs are implicitly returned even if never
+        measured (they auto-init to all-False). v2 will require Return; warn.
+
+        This is a positive case where the *Measure-presence* alone is not the
+        trigger -- the trigger is "any is_result=True CReg + no explicit Return".
+        """
+        prog = Main(
+            q := QReg("q", 1),
+            CReg("c", 1),  # declared, default is_result=True; not bound (just registered in Main.vars)
+            qb.X(q[0]),  # no Measure
+        )
+        with pytest.warns(DeprecationWarning, match=r"Implicit return"):
+            SlrConverter(prog).guppy()

From 6f3dc61686fe581443dcb924f03ecf53a4839e9c Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Fri, 15 May 2026 10:47:08 -0600
Subject: [PATCH 037/136] Land Phase 3a.0-3a.3 iters 1-4: BlockDecl/BlockCall
 AST + Guppy emitter + 7 Steane Block conversions.

---
 .../src/pecos/slr/ast/__init__.py             |  10 +
 .../pecos/slr/ast/codegen/_block_flatten.py   | 262 ++++++
 .../src/pecos/slr/ast/codegen/guppy.py        | 214 ++++-
 .../src/pecos/slr/ast/codegen/qasm.py         |   2 +
 .../src/pecos/slr/ast/codegen/qir.py          |   3 +
 .../pecos/slr/ast/codegen/quantum_circuit.py  |   3 +
 .../src/pecos/slr/ast/codegen/stim.py         |   3 +
 .../src/pecos/slr/ast/converter.py            | 233 ++++-
 .../quantum-pecos/src/pecos/slr/ast/nodes.py  |  87 ++
 .../src/pecos/slr/ast/optimizations/base.py   |   1 +
 .../slr/ast/optimizations/identity_removal.py |   1 +
 .../slr/ast/optimizations/rotation_merging.py |   1 +
 .../src/pecos/slr/ast/pretty_print.py         |  55 +-
 .../src/pecos/slr/ast/serialize.py            |  10 +-
 .../src/pecos/slr/ast/visitor.py              |  23 +
 .../slr/qeclib/steane/gates_sq/hadamards.py   |   8 +-
 .../slr/qeclib/steane/gates_sq/paulis.py      |  20 +-
 .../qeclib/steane/gates_tq/transversal_tq.py  |  27 +
 .../slr/transforms/parallel_optimizer.py      |  45 +-
 .../ast_guppy/test_block_call_smoke.py        | 863 ++++++++++++++++++
 .../ast_guppy/test_qeclib_selene_corpus.py    | 304 ++++++
 21 files changed, 2157 insertions(+), 18 deletions(-)
 create mode 100644 python/quantum-pecos/src/pecos/slr/ast/codegen/_block_flatten.py
 create mode 100644 python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
 create mode 100644 python/quantum-pecos/tests/slr_tests/ast_guppy/test_qeclib_selene_corpus.py

diff --git a/python/quantum-pecos/src/pecos/slr/ast/__init__.py b/python/quantum-pecos/src/pecos/slr/ast/__init__.py
index 47c5ed1b7..6ccfab483 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/__init__.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/__init__.py
@@ -152,6 +152,10 @@ def visit_gate(self, node: GateOp) -> int:
     # References
     BitRef,
     BitTypeExpr,
+    # Reusable blocks
+    BlockCall,
+    BlockDecl,
+    BlockInput,
     CommentOp,
     Declaration,
     Expression,
@@ -170,6 +174,7 @@ def visit_gate(self, node: GateOp) -> int:
     QubitTypeExpr,
     RegisterDecl,
     RepeatStmt,
+    ResourceEffect,
     ReturnOp,
     SlotRef,
     SourceLocation,
@@ -210,6 +215,10 @@ def visit_gate(self, node: GateOp) -> int:
     "BitExpr",
     "BitRef",
     "BitTypeExpr",
+    # Reusable blocks (Phase 3a.1)
+    "BlockCall",
+    "BlockDecl",
+    "BlockInput",
     "CodegenOptions",
     "CodegenResult",
     "CollectingVisitor",
@@ -239,6 +248,7 @@ def visit_gate(self, node: GateOp) -> int:
     "RepeatStmt",
     "ResourceCount",
     "ResourceCounter",
+    "ResourceEffect",
     "ReturnOp",
     # References
     "SlotRef",
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/_block_flatten.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/_block_flatten.py
new file mode 100644
index 000000000..52f609b59
--- /dev/null
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/_block_flatten.py
@@ -0,0 +1,262 @@
+# Copyright 2026 The PECOS Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations under the License.
+
+"""Phase 3a.2 BlockDecl/BlockCall flattening for non-Guppy codegens.
+
+Non-Guppy codegens (qasm, qir, stim, quantum_circuit) cannot represent
+reusable functions, so a `BlockCall` is inlined at its call site by
+substituting each input parameter name with the corresponding
+`arg_binding` outer-scope allocator name.
+
+The Guppy emitter does NOT use this pass: it lowers `BlockDecl` to
+`@guppy def` and `BlockCall` to a packed-array call.
+
+See `~/Repos/pecos-docs/design/slr/v2-blockcall-resource-effects.md`.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING
+
+from pecos.slr.ast.nodes import (
+    BarrierOp,
+    BlockCall,
+    ForStmt,
+    GateOp,
+    IfStmt,
+    MeasureOp,
+    ParallelBlock,
+    PermuteOp,
+    PrepareOp,
+    Program,
+    RepeatStmt,
+    SlotRef,
+    WhileStmt,
+)
+
+_PERMUTE_REF_RE = re.compile(r"([A-Za-z_]\w*)(\[\d+\])?$")
+
+if TYPE_CHECKING:
+    from pecos.slr.ast.nodes import BlockDecl, Statement
+
+
+def validate_unique_block_decl_names(program: Program) -> None:
+    """Raise ValueError if any BlockDecl name appears more than once.
+
+    Shared precondition check (Codex 2026-05-15 review #3): both the Guppy
+    emitter and the non-Guppy flatten pass require globally-unique BlockDecl
+    names. Keeping the check in one place ensures the contract stays in sync
+    across codegens.
+    """
+    seen: set[str] = set()
+    for decl in program.block_decls:
+        if decl.name in seen:
+            msg = f"Duplicate BlockDecl name {decl.name!r}"
+            raise ValueError(msg)
+        seen.add(decl.name)
+
+
+def flatten_block_calls(program: Program) -> Program:
+    """Return a new Program with every BlockCall inlined and no BlockDecls left.
+
+    The substitution rule maps each `BlockDecl` input parameter name to the
+    `BlockCall.arg_bindings` outer-scope allocator name throughout the body.
+    Quantum-only in Phase 3a.1.
+    """
+    if not program.block_decls:
+        return program
+
+    validate_unique_block_decl_names(program)
+    decls = {decl.name: decl for decl in program.block_decls}
+    new_body = _flatten_stmts(program.body, decls)
+    return Program(
+        name=program.name,
+        declarations=program.declarations,
+        body=new_body,
+        returns=program.returns,
+        allocator=program.allocator,
+        block_decls=(),
+    )
+
+
+def _flatten_stmts(body: tuple[Statement, ...], decls: dict[str, BlockDecl]) -> tuple[Statement, ...]:
+    out: list[Statement] = []
+    for stmt in body:
+        if isinstance(stmt, BlockCall):
+            inlined = _inline_call(stmt, decls)
+            out.extend(_flatten_stmts(inlined, decls))
+            continue
+
+        if isinstance(stmt, IfStmt):
+            out.append(
+                IfStmt(
+                    condition=stmt.condition,
+                    then_body=_flatten_stmts(stmt.then_body, decls),
+                    else_body=_flatten_stmts(stmt.else_body, decls),
+                    location=stmt.location,
+                ),
+            )
+            continue
+
+        if isinstance(stmt, RepeatStmt):
+            out.append(
+                RepeatStmt(count=stmt.count, body=_flatten_stmts(stmt.body, decls), location=stmt.location),
+            )
+            continue
+
+        if isinstance(stmt, ForStmt):
+            out.append(
+                ForStmt(
+                    variable=stmt.variable,
+                    start=stmt.start,
+                    stop=stmt.stop,
+                    step=stmt.step,
+                    body=_flatten_stmts(stmt.body, decls),
+                    location=stmt.location,
+                ),
+            )
+            continue
+
+        if isinstance(stmt, WhileStmt):
+            out.append(
+                WhileStmt(
+                    condition=stmt.condition,
+                    body=_flatten_stmts(stmt.body, decls),
+                    location=stmt.location,
+                ),
+            )
+            continue
+
+        if isinstance(stmt, ParallelBlock):
+            out.append(ParallelBlock(body=_flatten_stmts(stmt.body, decls), location=stmt.location))
+            continue
+
+        out.append(stmt)
+    return tuple(out)
+
+
+def _inline_call(call: BlockCall, decls: dict[str, BlockDecl]) -> tuple[Statement, ...]:
+    decl = decls.get(call.callee)
+    if decl is None:
+        msg = f"BlockCall references undefined block {call.callee!r}"
+        raise ValueError(msg)
+    if len(call.arg_bindings) != len(decl.inputs):
+        msg = (
+            f"BlockCall {call.callee!r}: {len(call.arg_bindings)} arg_bindings but "
+            f"BlockDecl declares {len(decl.inputs)} inputs"
+        )
+        raise ValueError(msg)
+    mapping = {inp.name: arg for inp, arg in zip(decl.inputs, call.arg_bindings, strict=True)}
+    return tuple(_substitute(stmt, mapping) for stmt in decl.body)
+
+
+def _substitute(stmt: Statement, mapping: dict[str, str]) -> Statement:
+    """Rewrite every SlotRef.allocator and PrepareOp/BarrierOp allocator name."""
+    if isinstance(stmt, GateOp):
+        return GateOp(
+            gate=stmt.gate,
+            targets=tuple(_sub_slot(t, mapping) for t in stmt.targets),
+            params=stmt.params,
+            location=stmt.location,
+        )
+    if isinstance(stmt, MeasureOp):
+        return MeasureOp(
+            targets=tuple(_sub_slot(t, mapping) for t in stmt.targets),
+            results=stmt.results,
+            location=stmt.location,
+        )
+    if isinstance(stmt, PrepareOp):
+        return PrepareOp(
+            allocator=mapping.get(stmt.allocator, stmt.allocator),
+            slots=stmt.slots,
+            location=stmt.location,
+        )
+    if isinstance(stmt, BarrierOp):
+        return BarrierOp(
+            allocators=tuple(mapping.get(a, a) for a in stmt.allocators),
+            location=stmt.location,
+        )
+    if isinstance(stmt, IfStmt):
+        return IfStmt(
+            condition=stmt.condition,
+            then_body=tuple(_substitute(s, mapping) for s in stmt.then_body),
+            else_body=tuple(_substitute(s, mapping) for s in stmt.else_body),
+            location=stmt.location,
+        )
+    if isinstance(stmt, RepeatStmt):
+        return RepeatStmt(
+            count=stmt.count,
+            body=tuple(_substitute(s, mapping) for s in stmt.body),
+            location=stmt.location,
+        )
+    if isinstance(stmt, ForStmt):
+        return ForStmt(
+            variable=stmt.variable,
+            start=stmt.start,
+            stop=stmt.stop,
+            step=stmt.step,
+            body=tuple(_substitute(s, mapping) for s in stmt.body),
+            location=stmt.location,
+        )
+    if isinstance(stmt, WhileStmt):
+        return WhileStmt(
+            condition=stmt.condition,
+            body=tuple(_substitute(s, mapping) for s in stmt.body),
+            location=stmt.location,
+        )
+    if isinstance(stmt, ParallelBlock):
+        return ParallelBlock(body=tuple(_substitute(s, mapping) for s in stmt.body), location=stmt.location)
+    if isinstance(stmt, PermuteOp):
+        return PermuteOp(
+            sources=tuple(_sub_permute_ref(r, mapping) for r in stmt.sources),
+            targets=tuple(_sub_permute_ref(r, mapping) for r in stmt.targets),
+            add_comment=stmt.add_comment,
+            location=stmt.location,
+        )
+    if isinstance(stmt, BlockCall):
+        # Nested BlockCall: rewrite arg_bindings/out_bindings from outer names to
+        # input parameter names. Codex 2026-05-15 review #1.
+        return BlockCall(
+            callee=stmt.callee,
+            arg_bindings=tuple(mapping.get(a, a) for a in stmt.arg_bindings),
+            out_bindings=tuple(mapping.get(a, a) for a in stmt.out_bindings),
+            location=stmt.location,
+        )
+    # Pass through statements that don't reference slot allocators directly.
+    return stmt
+
+
+def _sub_permute_ref(ref: str, mapping: dict[str, str]) -> str:
+    """Rewrite PermuteOp source/target strings of the form `name` or `name[idx]`.
+
+    If the ref doesn't match, pass through UNLESS the ref textually mentions a
+    mapped allocator -- in that case raise rather than silently leak the outer
+    name into the flattened body (Codex 2026-05-15 review).
+    """
+    match = _PERMUTE_REF_RE.fullmatch(ref)
+    if match is None:
+        for key in mapping:
+            if key in ref:
+                msg = (
+                    f"Cannot substitute PermuteOp ref {ref!r}: unsupported "
+                    f"ref form mentions mapped allocator {key!r}"
+                )
+                raise ValueError(msg)
+        return ref
+    name, suffix = match.group(1), match.group(2) or ""
+    return f"{mapping.get(name, name)}{suffix}"
+
+
+def _sub_slot(ref: SlotRef, mapping: dict[str, str]) -> SlotRef:
+    if ref.allocator not in mapping:
+        return ref
+    return SlotRef(allocator=mapping[ref.allocator], index=ref.index, location=ref.location)
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
index a28bf4dab..e49983b45 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
@@ -21,8 +21,9 @@
 
 import re
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, cast
 
+from pecos.slr.ast.codegen._block_flatten import validate_unique_block_decl_names
 from pecos.slr.ast.codegen.guppy_linearity import (
     GuppyLinearityState,
     LinearityError,
@@ -31,11 +32,13 @@
 )
 from pecos.slr.ast.nodes import (
     AllocatorDecl,
+    ArrayTypeExpr,
     BinaryExpr,
     BinaryOp,
     BitExpr,
     BitRef,
     BitTypeExpr,
+    BlockCall,
     ForStmt,
     GateKind,
     GateOp,
@@ -47,6 +50,7 @@
     QubitTypeExpr,
     RegisterDecl,
     RepeatStmt,
+    ResourceEffect,
     ReturnOp,
     UnaryExpr,
     UnaryOp,
@@ -60,6 +64,8 @@
     from pecos.slr.ast.nodes import (
         AssignOp,
         BarrierOp,
+        BlockDecl,
+        BlockInput,
         CommentOp,
         Expression,
         PermuteOp,
@@ -150,9 +156,28 @@ class AstToGuppy:
     def __init__(self) -> None:
         """Initialize the generator."""
         self.context = GuppyContext()
+        self._block_decls: dict[str, BlockDecl] = {}
 
     def generate(self, program: Program) -> list[str]:
         """Generate Guppy code for a program."""
+        validate_unique_block_decl_names(program)
+        self.context = GuppyContext()
+        self._block_decls = {decl.name: decl for decl in program.block_decls}
+        for decl in program.block_decls:
+            self._validate_block_decl(decl)
+
+        lines = self._imports()
+
+        for decl in program.block_decls:
+            lines.append("")
+            lines.extend(self._generate_block_decl(decl))
+
+        lines.append("")
+        lines.extend(self._generate_main(program))
+        return lines
+
+    def _generate_main(self, program: Program) -> list[str]:
+        """Emit the main Guppy function for the program body."""
         self.context = GuppyContext()
         self._collect_declarations(program)
         self._collect_implicit_measure_registers(program.body)
@@ -163,9 +188,7 @@ def generate(self, program: Program) -> list[str]:
         explicit_return = self._validate_return_position(body)
         emitted_body = body[:-1] if explicit_return else body
 
-        lines = self._imports()
-        lines.append("")
-        lines.append("@guppy")
+        lines: list[str] = ["@guppy"]
         lines.append(f"def {program.name.lower()}({self._render_params()}) -> {self._return_type(explicit_return)}:")
 
         self.context.push_indent()
@@ -192,6 +215,78 @@ def generate(self, program: Program) -> list[str]:
         self.context.pop_indent()
         return lines
 
+    def _validate_block_decl(self, decl: BlockDecl) -> None:
+        """Reject BlockDecl shapes that the v1 Guppy emitter cannot lower."""
+        for inp in decl.inputs:
+            if not isinstance(inp.type_expr, ArrayTypeExpr) or not isinstance(inp.type_expr.element, QubitTypeExpr):
+                msg = (
+                    f"BlockDecl {decl.name!r} input {inp.name!r}: only array[qubit, N] inputs "
+                    f"are supported in Phase 3a.1 (got {type(inp.type_expr).__name__})"
+                )
+                raise GuppyCodegenError(msg)
+            if inp.effect not in {ResourceEffect.LIVE_PRESERVED, ResourceEffect.CONSUMED}:
+                msg = (
+                    f"BlockDecl {decl.name!r} input {inp.name!r}: only LIVE_PRESERVED and "
+                    f"CONSUMED effects are supported in Phase 3a.1 (got {inp.effect.name})"
+                )
+                raise GuppyCodegenError(msg)
+        if decl.return_op is not None:
+            msg = (
+                f"BlockDecl {decl.name!r}: explicit Return inside BlockDecl is not yet "
+                "supported in Phase 3a.1; live_preserved inputs are returned implicitly"
+            )
+            raise GuppyCodegenError(msg)
+
+    def _generate_block_decl(self, decl: BlockDecl) -> list[str]:
+        """Emit a BlockDecl as a top-level Guppy @guppy def function."""
+        saved_context = self.context
+        self.context = GuppyContext()
+        # _validate_block_decl guarantees every type_expr is ArrayTypeExpr[QubitTypeExpr].
+        input_arrays: list[tuple[str, int]] = [
+            (inp.name, cast("ArrayTypeExpr", inp.type_expr).size) for inp in decl.inputs
+        ]
+        for name, size in input_arrays:
+            self.context.root_allocators[name] = size
+        self.context.linearity = GuppyLinearityState.from_allocators(self.context.root_allocators)
+
+        live_inputs = tuple(inp for inp in decl.inputs if inp.effect is ResourceEffect.LIVE_PRESERVED)
+        live_sizes = [cast("ArrayTypeExpr", inp.type_expr).size for inp in live_inputs]
+        return_types = [f"array[qubit, {size}]" for size in live_sizes]
+        return_type_str = self._tuple_type(return_types)
+
+        params = ", ".join(f"{name}: array[qubit, {size}] @ owned" for name, size in input_arrays)
+
+        lines: list[str] = ["@guppy", f"def {decl.name}({params}) -> {return_type_str}:"]
+
+        self.context.push_indent()
+        body_lines: list[str] = []
+        body_lines.extend(self._emit_entry_unpacks())
+
+        for stmt in decl.body:
+            body_lines.extend(self._emit_stmt(stmt))
+
+        # Auto-emit return for live_preserved inputs; consume their slots so the
+        # linearity tracker reflects ownership leaving the function.
+        if live_inputs:
+            arrays = [self._consume_allocator_for_return(inp.name) for inp in live_inputs]
+            if len(arrays) == 1:
+                body_lines.append(f"{self.context.indent()}return {arrays[0]}")
+            else:
+                body_lines.append(f"{self.context.indent()}return {', '.join(arrays)}")
+        # consumed inputs must be discarded inside the body (caller's responsibility
+        # to ensure the body does so; the smoke test covers this).
+        else:
+            body_lines.extend(self._emit_end_cleanup())
+
+        if body_lines:
+            lines.extend(body_lines)
+        else:
+            lines.append(f"{self.context.indent()}pass")
+
+        self.context.pop_indent()
+        self.context = saved_context
+        return lines
+
     def _collect_declarations(self, program: Program) -> None:
         for decl in program.declarations:
             if isinstance(decl, AllocatorDecl):
@@ -353,6 +448,8 @@ def _emit_stmt(self, stmt: Statement) -> list[str]:
             raise GuppyCodegenError(msg)
         if isinstance(stmt, ParallelBlock):
             return self._emit_parallel(stmt)
+        if isinstance(stmt, BlockCall):
+            return self._emit_block_call(stmt)
         if isinstance(stmt, ReturnOp):
             msg = "AST -> Guppy v1 supports Return only as the final root-level statement"
             raise GuppyCodegenError(msg)
@@ -520,6 +617,115 @@ def _emit_for(self, node: ForStmt) -> list[str]:
     def _emit_parallel(self, node: ParallelBlock) -> list[str]:
         return self._emit_block(node.body)
 
+    def _emit_block_call(self, node: BlockCall) -> list[str]:
+        """Lower a BlockCall to a packed array(...) call + unpack pattern.
+
+        For each input the caller's outer-allocator locals are packed into an
+        array literal. The call's return tuple unpacks back into locals for
+        every `LIVE_PRESERVED` input. `CONSUMED` inputs leave their outer
+        slots in the CONSUMED state.
+        """
+        decl = self._block_decls.get(node.callee)
+        if decl is None:
+            msg = f"BlockCall references undefined block {node.callee!r}"
+            raise GuppyCodegenError(msg)
+
+        if len(node.arg_bindings) != len(decl.inputs):
+            msg = (
+                f"BlockCall {node.callee!r}: {len(node.arg_bindings)} arg_bindings "
+                f"but BlockDecl declares {len(decl.inputs)} inputs"
+            )
+            raise GuppyCodegenError(msg)
+
+        # Phase 1: validate every arg + out binding BEFORE touching linearity state, so
+        # a late-raised GuppyCodegenError can't leave the tracker half-consumed (Codex
+        # 2026-05-15 review).
+        validated_args: list[tuple[BlockInput, str, int]] = []
+        live_inputs_out: list[BlockInput] = []
+        for inp, arg_name in zip(decl.inputs, node.arg_bindings, strict=True):
+            # _validate_block_decl guarantees type_expr is ArrayTypeExpr[QubitTypeExpr].
+            input_size = cast("ArrayTypeExpr", inp.type_expr).size
+            if arg_name not in self.context.root_allocators:
+                msg = (
+                    f"BlockCall {node.callee!r} arg {arg_name!r} must be an outer root "
+                    "allocator name"
+                )
+                raise GuppyCodegenError(msg)
+            outer_size = self.context.root_allocators[arg_name]
+            if outer_size != input_size:
+                msg = (
+                    f"BlockCall {node.callee!r} arg {arg_name!r} size {outer_size} "
+                    f"does not match input {inp.name!r} size {input_size}"
+                )
+                raise GuppyCodegenError(msg)
+            validated_args.append((inp, arg_name, outer_size))
+            if inp.effect is ResourceEffect.LIVE_PRESERVED:
+                live_inputs_out.append(inp)
+
+        if len(node.out_bindings) != len(live_inputs_out):
+            expected = [inp.name for inp in live_inputs_out]
+            msg = (
+                f"BlockCall {node.callee!r}: out_bindings {node.out_bindings} count "
+                f"does not match expected return positions {expected}"
+            )
+            raise GuppyCodegenError(msg)
+
+        for out_name, inp in zip(node.out_bindings, live_inputs_out, strict=True):
+            self._require_out_binding_matches(node.callee, out_name, inp)
+
+        # Phase 2: now that every check passed, consume slots and emit code.
+        linearity = self._linearity()
+        arg_exprs: list[str] = []
+        for _inp, arg_name, outer_size in validated_args:
+            locals_ = [linearity.consume(Slot(arg_name, i)) for i in range(outer_size)]
+            arg_exprs.append(f"array({', '.join(locals_)})")
+
+        call_expr = f"{node.callee}({', '.join(arg_exprs)})"
+        lines: list[str] = []
+
+        if not live_inputs_out:
+            lines.append(f"{self.context.indent()}{call_expr}")
+            return lines
+
+        if len(live_inputs_out) == 1:
+            out_name = node.out_bindings[0]
+            ret_temp = self.context.temp("call_ret")
+            lines.append(f"{self.context.indent()}{ret_temp} = {call_expr}")
+            lines.extend(self._unpack_return_array(out_name, ret_temp))
+            return lines
+
+        ret_temps = [self.context.temp("call_ret") for _ in live_inputs_out]
+        lines.append(f"{self.context.indent()}{', '.join(ret_temps)} = {call_expr}")
+        for ret_temp, out_name in zip(ret_temps, node.out_bindings, strict=True):
+            lines.extend(self._unpack_return_array(out_name, ret_temp))
+        return lines
+
+    def _require_out_binding_matches(self, callee: str, out_name: str, inp: BlockInput) -> None:
+        # _validate_block_decl guarantees type_expr is ArrayTypeExpr[QubitTypeExpr].
+        input_size = cast("ArrayTypeExpr", inp.type_expr).size
+        if out_name not in self.context.root_allocators:
+            msg = f"BlockCall {callee!r} out_binding {out_name!r} is not an outer allocator"
+            raise GuppyCodegenError(msg)
+        outer_size = self.context.root_allocators[out_name]
+        if outer_size != input_size:
+            msg = (
+                f"BlockCall {callee!r} out_binding {out_name!r} size {outer_size} "
+                f"does not match input {inp.name!r} size {input_size}"
+            )
+            raise GuppyCodegenError(msg)
+
+    def _unpack_return_array(self, out_name: str, ret_temp: str) -> list[str]:
+        size = self.context.root_allocators[out_name]
+        new_locals = [f"{out_name}_{i}" for i in range(size)]
+        if size == 1:
+            line = f"{self.context.indent()}{new_locals[0]}, = {ret_temp}"
+        else:
+            line = f"{self.context.indent()}{', '.join(new_locals)} = {ret_temp}"
+        linearity = self._linearity()
+        for i, local in enumerate(new_locals):
+            linearity.set_live(Slot(out_name, i), local)
+        return [line]
+
     def _emit_block(self, body: tuple[Statement, ...]) -> list[str]:
         lines: list[str] = []
         for stmt in body:
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qasm.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qasm.py
index 2242fe699..e563463dc 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qasm.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qasm.py
@@ -32,6 +32,7 @@
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING
 
+from pecos.slr.ast.codegen._block_flatten import flatten_block_calls
 from pecos.slr.ast.nodes import (
     AllocatorDecl,
     BinaryExpr,
@@ -218,6 +219,7 @@ def generate(self, program: Program) -> list[str]:
         Returns:
             List of code lines.
         """
+        program = flatten_block_calls(program)
         self.context = QasmContext()
         return self.visit(program)
 
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
index 5ad44075b..502b82bcd 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
@@ -30,6 +30,7 @@
 from typing import TYPE_CHECKING, Any
 
 import pecos as pc
+from pecos.slr.ast.codegen._block_flatten import flatten_block_calls
 from pecos.slr.ast.nodes import (
     AllocatorDecl,
     AssignOp,
@@ -182,6 +183,8 @@ def generate(self, program: Program) -> str:
             msg = "LLVM dependencies not available. Install with 'pip install pecos[qir]'"
             raise ImportError(msg)
 
+        program = flatten_block_calls(program)
+
         self.context = QirCodeGenContext()
         self._gate_cache = {}
         self._creg_ptrs = {}
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py
index 981d63f4a..3e0fbdecc 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py
@@ -28,6 +28,7 @@
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING
 
+from pecos.slr.ast.codegen._block_flatten import flatten_block_calls
 from pecos.slr.ast.nodes import (
     AllocatorDecl,
     BarrierOp,
@@ -166,6 +167,8 @@ def generate(self, program: Program) -> QuantumCircuit:
         """
         from pecos.circuits.quantum_circuit import QuantumCircuit  # noqa: PLC0415
 
+        program = flatten_block_calls(program)
+
         self.context = QCCodeGenContext()
         self.circuit = QuantumCircuit()
         self._in_parallel = False
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/stim.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/stim.py
index 7d2768f37..f97c573ce 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/stim.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/stim.py
@@ -28,6 +28,7 @@
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING
 
+from pecos.slr.ast.codegen._block_flatten import flatten_block_calls
 from pecos.slr.ast.nodes import (
     AllocatorDecl,
     BarrierOp,
@@ -165,6 +166,8 @@ def generate(self, program: Program) -> stim.Circuit:
         """
         import stim  # noqa: PLC0415
 
+        program = flatten_block_calls(program)
+
         self.context = StimCodeGenContext()
         self.circuit = stim.Circuit()
 
diff --git a/python/quantum-pecos/src/pecos/slr/ast/converter.py b/python/quantum-pecos/src/pecos/slr/ast/converter.py
index 1bacf6ab9..23c4728e0 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/converter.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/converter.py
@@ -31,6 +31,7 @@
 
 from __future__ import annotations
 
+import re
 from typing import TYPE_CHECKING, Any
 
 from pecos.slr.ast.nodes import (
@@ -43,6 +44,9 @@
     BitExpr,
     BitRef,
     BitTypeExpr,
+    BlockCall,
+    BlockDecl,
+    BlockInput,
     CommentOp,
     ForStmt,
     GateKind,
@@ -57,6 +61,7 @@
     QubitTypeExpr,
     RegisterDecl,
     RepeatStmt,
+    ResourceEffect,
     ReturnOp,
     SlotRef,
     UnaryExpr,
@@ -159,6 +164,8 @@ class SlrToAst:
     def __init__(self) -> None:
         """Initialize the converter."""
         self._position = 0  # Track position for source locations
+        self._block_decls: list[BlockDecl] = []  # Hoisted BlockDecls accumulated during convert()
+        self._decl_counter = 0
 
     def convert(self, block: Main | Block) -> Program:
         """Convert an SLR Main/Block to an AST Program.
@@ -170,6 +177,8 @@ def convert(self, block: Main | Block) -> Program:
             An AST Program node.
         """
         self._position = 0
+        self._block_decls = []
+        self._decl_counter = 0
 
         # Get the block name
         name = getattr(block, "block_name", block.__class__.__name__)
@@ -200,6 +209,7 @@ def convert(self, block: Main | Block) -> Program:
             body=tuple(body),
             returns=returns,
             allocator=allocator,
+            block_decls=tuple(self._block_decls),
         )
 
     def _convert_declarations(self, block: Block) -> list:
@@ -365,12 +375,88 @@ def _convert_statement(self, op: Any) -> Statement | None:
 
         # Nested blocks (Block subclasses)
         if hasattr(op, "ops"):
-            # This is a nested block - flatten its statements into the parent
-            # We return a special marker that _convert_statements will handle
+            # Phase 3a.1: a Block subclass that declares `block_inputs` opts in to
+            # BlockDecl/BlockCall lowering. Without it, the legacy flatten path
+            # remains the default for all qeclib Blocks until Phase 3a.3.
+            if _has_block_inputs(op):
+                return self._convert_block_call(op)
+
+            # Legacy flatten path.
             return ("__FLATTEN__", self._convert_statements(op.ops))
 
         return None
 
+    def _convert_block_call(self, block: Block) -> BlockCall:
+        """Build a BlockDecl + BlockCall pair from a Block subclass with `block_inputs`.
+
+        Each call site emits a fresh BlockDecl (no dedup in Phase 3a.1; dedup is
+        a Phase 3a.3 optimization once qeclib conversion lands). The BlockDecl
+        body is the block's `ops` with allocator names rewritten from the
+        outer-scope binding name to the input parameter name.
+        """
+        inputs_spec = type(block).block_inputs  # type: ignore[attr-defined]
+        # Map input name -> (resource effect enum, outer-scope binding name, size, kind="qubit"|"bit")
+        bindings: list[tuple[str, ResourceEffect, str, int]] = []
+        substitution: dict[str, str] = {}  # outer allocator/register name -> input param name
+        for input_name, effect_value in inputs_spec.items():
+            if not hasattr(block, input_name):
+                msg = (
+                    f"Block {type(block).__name__!r} declares input {input_name!r} but the "
+                    f"instance does not bind self.{input_name} (set it in __init__ after super().__init__())"
+                )
+                raise ValueError(msg)
+            var = getattr(block, input_name)
+            outer_name = getattr(var, "sym", None) or getattr(var, "name", None)
+            if outer_name is None:
+                msg = (
+                    f"Block {type(block).__name__!r} input {input_name!r} bound to "
+                    f"{var!r} which has no .sym/.name attribute"
+                )
+                raise ValueError(msg)
+            size = getattr(var, "size", None) or getattr(var, "capacity", None)
+            if size is None:
+                msg = f"Block {type(block).__name__!r} input {input_name!r}: cannot determine size from {var!r}"
+                raise ValueError(msg)
+            effect = _normalize_effect(effect_value, where=f"Block {type(block).__name__!r} input {input_name!r}")
+            bindings.append((input_name, effect, outer_name, size))
+            substitution[outer_name] = input_name
+
+        # Build the BlockDecl body by converting block.ops in a NEW sub-converter, then
+        # rewriting allocator names from outer -> input parameter via _substitute.
+        # Share `_decl_counter` so nested converted Blocks get globally-unique names
+        # (Codex 2026-05-15 review #2: nested same-class Blocks were colliding on
+        # `inner_0` because each sub-converter restarted its counter at 0).
+        sub = SlrToAst()
+        sub._decl_counter = self._decl_counter  # type: ignore[attr-defined]
+        sub_body = sub._convert_statements(block.ops)  # type: ignore[attr-defined]
+        self._decl_counter = sub._decl_counter  # type: ignore[attr-defined]
+        rewritten_body = tuple(_substitute_stmt(stmt, substitution) for stmt in sub_body)
+
+        # Inputs are array[qubit, N] (Phase 3a.1 only supports quantum arrays).
+        block_inputs: list[BlockInput] = []
+        for input_name, effect, _outer, size in bindings:
+            block_inputs.append(
+                BlockInput(
+                    name=input_name,
+                    effect=effect,
+                    type_expr=ArrayTypeExpr(element=QubitTypeExpr(), size=size),
+                ),
+            )
+
+        # Unique decl name per call site (Phase 3a.1; dedup arrives in Phase 3a.3).
+        decl_name = f"{type(block).__name__.lower()}_{self._decl_counter}"
+        self._decl_counter += 1
+
+        decl = BlockDecl(name=decl_name, inputs=tuple(block_inputs), body=rewritten_body)
+        # Hoist any block_decls emitted by the sub-converter (nested BlockCalls) first.
+        self._block_decls.extend(sub._block_decls)
+        self._block_decls.append(decl)
+
+        # Build the BlockCall referencing the outer-scope names.
+        arg_bindings = tuple(outer for _name, _eff, outer, _sz in bindings)
+        live_out = tuple(outer for _name, eff, outer, _sz in bindings if eff is ResourceEffect.LIVE_PRESERVED)
+        return BlockCall(callee=decl_name, arg_bindings=arg_bindings, out_bindings=live_out)
+
     def _convert_gate(self, gate: Any) -> Statement:
         """Convert an SLR gate to an AST GateOp, PrepareOp, or MeasureOp."""
         gate_name = gate.sym
@@ -752,3 +838,146 @@ def slr_to_ast(block: Main | Block) -> Program:
     """
     converter = SlrToAst()
     return converter.convert(block)
+
+
+# === Phase 3a.1 BlockDecl/BlockCall helpers ===
+
+_EFFECT_NAME_MAP: dict[str, ResourceEffect] = {
+    "live_preserved": ResourceEffect.LIVE_PRESERVED,
+    "consumed": ResourceEffect.CONSUMED,
+    "produced": ResourceEffect.PRODUCED,
+    "dropped": ResourceEffect.DROPPED,
+}
+
+
+def _has_block_inputs(block: Block) -> bool:
+    return isinstance(getattr(type(block), "block_inputs", None), dict)
+
+
+def _normalize_effect(value: Any, *, where: str) -> ResourceEffect:
+    """Accept either a ResourceEffect enum or its lowercased string name."""
+    if isinstance(value, ResourceEffect):
+        return value
+    if isinstance(value, str):
+        normalized = value.lower()
+        if normalized in _EFFECT_NAME_MAP:
+            return _EFFECT_NAME_MAP[normalized]
+    msg = (
+        f"{where}: effect {value!r} is not a valid ResourceEffect. "
+        f"Expected one of: ResourceEffect enum, or strings {sorted(_EFFECT_NAME_MAP)}"
+    )
+    raise ValueError(msg)
+
+
+def _substitute_stmt(stmt: Any, mapping: dict[str, str]) -> Any:
+    """Rewrite SlotRef allocator + PrepareOp/BarrierOp allocator names per mapping.
+
+    Used to build a BlockDecl body that references parameter names rather than
+    the outer-scope binding names captured during the instance walk.
+    """
+    if isinstance(stmt, GateOp):
+        return GateOp(
+            gate=stmt.gate,
+            targets=tuple(_substitute_slot(t, mapping) for t in stmt.targets),
+            params=stmt.params,
+            location=stmt.location,
+        )
+    if isinstance(stmt, MeasureOp):
+        return MeasureOp(
+            targets=tuple(_substitute_slot(t, mapping) for t in stmt.targets),
+            results=stmt.results,
+            location=stmt.location,
+        )
+    if isinstance(stmt, PrepareOp):
+        return PrepareOp(
+            allocator=mapping.get(stmt.allocator, stmt.allocator),
+            slots=stmt.slots,
+            location=stmt.location,
+        )
+    if isinstance(stmt, BarrierOp):
+        return BarrierOp(
+            allocators=tuple(mapping.get(a, a) for a in stmt.allocators),
+            location=stmt.location,
+        )
+    if isinstance(stmt, IfStmt):
+        return IfStmt(
+            condition=stmt.condition,
+            then_body=tuple(_substitute_stmt(s, mapping) for s in stmt.then_body),
+            else_body=tuple(_substitute_stmt(s, mapping) for s in stmt.else_body),
+            location=stmt.location,
+        )
+    if isinstance(stmt, RepeatStmt):
+        return RepeatStmt(
+            count=stmt.count,
+            body=tuple(_substitute_stmt(s, mapping) for s in stmt.body),
+            location=stmt.location,
+        )
+    if isinstance(stmt, ForStmt):
+        return ForStmt(
+            variable=stmt.variable,
+            start=stmt.start,
+            stop=stmt.stop,
+            step=stmt.step,
+            body=tuple(_substitute_stmt(s, mapping) for s in stmt.body),
+            location=stmt.location,
+        )
+    if isinstance(stmt, WhileStmt):
+        return WhileStmt(
+            condition=stmt.condition,
+            body=tuple(_substitute_stmt(s, mapping) for s in stmt.body),
+            location=stmt.location,
+        )
+    if isinstance(stmt, ParallelBlock):
+        return ParallelBlock(
+            body=tuple(_substitute_stmt(s, mapping) for s in stmt.body),
+            location=stmt.location,
+        )
+    if isinstance(stmt, PermuteOp):
+        return PermuteOp(
+            sources=tuple(_substitute_permute_ref(r, mapping) for r in stmt.sources),
+            targets=tuple(_substitute_permute_ref(r, mapping) for r in stmt.targets),
+            add_comment=stmt.add_comment,
+            location=stmt.location,
+        )
+    if isinstance(stmt, BlockCall):
+        # Nested BlockCall inside a converted Block: arg_bindings/out_bindings were
+        # captured against the OUTER scope when the sub-converter ran. Rewrite them
+        # to use the parent Block's parameter names (Codex 2026-05-15 review #1).
+        return BlockCall(
+            callee=stmt.callee,
+            arg_bindings=tuple(mapping.get(a, a) for a in stmt.arg_bindings),
+            out_bindings=tuple(mapping.get(a, a) for a in stmt.out_bindings),
+            location=stmt.location,
+        )
+    return stmt
+
+
+def _substitute_slot(ref: SlotRef, mapping: dict[str, str]) -> SlotRef:
+    if ref.allocator not in mapping:
+        return ref
+    return SlotRef(allocator=mapping[ref.allocator], index=ref.index, location=ref.location)
+
+
+_PERMUTE_REF_RE = re.compile(r"([A-Za-z_]\w*)(\[\d+\])?$")
+
+
+def _substitute_permute_ref(ref: str, mapping: dict[str, str]) -> str:
+    """Rewrite PermuteOp source/target strings (`name` or `name[idx]`).
+
+    If the ref doesn't match the bare-name / indexed-name regex, pass it
+    through unchanged UNLESS the ref textually mentions a mapped allocator,
+    in which case raise -- silently leaking the outer name into the BlockDecl
+    body would be a fragile failure mode (Codex 2026-05-15 review).
+    """
+    match = _PERMUTE_REF_RE.fullmatch(ref)
+    if match is None:
+        for key in mapping:
+            if key in ref:
+                msg = (
+                    f"Cannot substitute PermuteOp ref {ref!r}: unsupported "
+                    f"ref form mentions mapped allocator {key!r}"
+                )
+                raise ValueError(msg)
+        return ref
+    name, suffix = match.group(1), match.group(2) or ""
+    return f"{mapping.get(name, name)}{suffix}"
diff --git a/python/quantum-pecos/src/pecos/slr/ast/nodes.py b/python/quantum-pecos/src/pecos/slr/ast/nodes.py
index f79d1013c..b32e88637 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/nodes.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/nodes.py
@@ -214,6 +214,18 @@ class UnaryOp(Enum):
     NEG = auto()
 
 
+class ResourceEffect(Enum):
+    """Effect declared by a `BlockDecl` input on the outer scope's binding.
+
+    See `~/Repos/pecos-docs/design/slr/v2-blockcall-resource-effects.md`.
+    """
+
+    LIVE_PRESERVED = auto()  # caller binding survives the call unchanged
+    CONSUMED = auto()  # caller binding is invalidated by the call
+    PRODUCED = auto()  # callee writes; caller's binding is rebound from return
+    DROPPED = auto()  # callee discards; caller binding is invalidated
+
+
 # =============================================================================
 # References
 # =============================================================================
@@ -620,6 +632,72 @@ def children(self) -> Sequence[AstNode]:
         return self.body
 
 
+# =============================================================================
+# Reusable block declarations (Phase 3a.1)
+# =============================================================================
+
+
+@dataclass(frozen=True, kw_only=True)
+class BlockInput(AstNode):
+    """One declared input parameter to a `BlockDecl`.
+
+    See `~/Repos/pecos-docs/design/slr/v2-blockcall-resource-effects.md`.
+    """
+
+    name: str
+    effect: ResourceEffect
+    type_expr: TypeExpr
+
+    def accept(self, visitor: AstVisitor[T]) -> T:
+        return visitor.visit_block_input(self)
+
+    def children(self) -> Sequence[AstNode]:
+        return (self.type_expr,)
+
+
+@dataclass(frozen=True, kw_only=True)
+class BlockDecl(AstNode):
+    """Reusable Block declaration that lowers to a top-level Guppy function.
+
+    Non-Guppy codegens inline `body` at every `BlockCall` site.
+    """
+
+    name: str
+    inputs: tuple[BlockInput, ...]
+    body: tuple[Statement, ...]
+    return_op: ReturnOp | None = None
+
+    def accept(self, visitor: AstVisitor[T]) -> T:
+        return visitor.visit_block_decl(self)
+
+    def children(self) -> Sequence[AstNode]:
+        nodes: list[AstNode] = list(self.inputs)
+        nodes.extend(self.body)
+        if self.return_op is not None:
+            nodes.append(self.return_op)
+        return nodes
+
+
+@dataclass(frozen=True, kw_only=True)
+class BlockCall(Statement):
+    """Invoke a `BlockDecl` from the outer scope.
+
+    `arg_bindings` lists outer-scope binding names in the same order as the
+    callee's declared inputs (one per input).
+    `out_bindings` lists outer-scope names that receive the callee's outputs
+    (`live_preserved`/`produced` inputs + explicit `Return` values, in
+    declaration order then return order). Empty for callees that return
+    nothing.
+    """
+
+    callee: str
+    arg_bindings: tuple[str, ...]
+    out_bindings: tuple[str, ...] = ()
+
+    def accept(self, visitor: AstVisitor[T]) -> T:
+        return visitor.visit_block_call(self)
+
+
 # =============================================================================
 # Program
 # =============================================================================
@@ -641,6 +719,7 @@ class Program(AstNode):
     body: tuple[Statement, ...] = ()
     returns: tuple[TypeExpr, ...] = ()
     allocator: AllocatorDecl | None = None  # Base allocator
+    block_decls: tuple[BlockDecl, ...] = ()
 
     def accept(self, visitor: AstVisitor[T]) -> T:
         return visitor.visit_program(self)
@@ -650,10 +729,18 @@ def children(self) -> Sequence[AstNode]:
         if self.allocator:
             nodes.append(self.allocator)
         nodes.extend(self.declarations)
+        nodes.extend(self.block_decls)
         nodes.extend(self.body)
         nodes.extend(self.returns)
         return nodes
 
+    def get_block_decl(self, name: str) -> BlockDecl | None:
+        """Find a BlockDecl by name."""
+        for decl in self.block_decls:
+            if decl.name == name:
+                return decl
+        return None
+
     def get_allocator(self, name: str) -> AllocatorDecl | None:
         """Find an allocator declaration by name."""
         if self.allocator and self.allocator.name == name:
diff --git a/python/quantum-pecos/src/pecos/slr/ast/optimizations/base.py b/python/quantum-pecos/src/pecos/slr/ast/optimizations/base.py
index 24d9b5798..6e4dda800 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/optimizations/base.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/optimizations/base.py
@@ -111,6 +111,7 @@ def optimize(self, program: Program) -> OptimizationResult:
             body=optimized_body,
             returns=program.returns,
             allocator=program.allocator,
+            block_decls=program.block_decls,
             location=program.location,
         )
 
diff --git a/python/quantum-pecos/src/pecos/slr/ast/optimizations/identity_removal.py b/python/quantum-pecos/src/pecos/slr/ast/optimizations/identity_removal.py
index fb2bb9f83..7c4ac3a2b 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/optimizations/identity_removal.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/optimizations/identity_removal.py
@@ -74,6 +74,7 @@ def optimize(self, program: Program) -> OptimizationResult:
             body=optimized_body,
             returns=program.returns,
             allocator=program.allocator,
+            block_decls=program.block_decls,
             location=program.location,
         )
 
diff --git a/python/quantum-pecos/src/pecos/slr/ast/optimizations/rotation_merging.py b/python/quantum-pecos/src/pecos/slr/ast/optimizations/rotation_merging.py
index 577c01e03..d38235a5d 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/optimizations/rotation_merging.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/optimizations/rotation_merging.py
@@ -77,6 +77,7 @@ def optimize(self, program: Program) -> OptimizationResult:
             body=optimized_body,
             returns=program.returns,
             allocator=program.allocator,
+            block_decls=program.block_decls,
             location=program.location,
         )
 
diff --git a/python/quantum-pecos/src/pecos/slr/ast/pretty_print.py b/python/quantum-pecos/src/pecos/slr/ast/pretty_print.py
index caeb88c36..26cd3084b 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/pretty_print.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/pretty_print.py
@@ -31,9 +31,12 @@
 
 from pecos.slr.ast.nodes import (
     AllocatorDecl,
+    ArrayTypeExpr,
     BinaryOp,
     BitRef,
+    BitTypeExpr,
     Expression,
+    QubitTypeExpr,
     RegisterDecl,
     UnaryOp,
 )
@@ -47,6 +50,9 @@
         BarrierOp,
         BinaryExpr,
         BitExpr,
+        BlockCall,
+        BlockDecl,
+        BlockInput,
         CommentOp,
         ForStmt,
         GateOp,
@@ -61,6 +67,7 @@
         ReturnOp,
         SlotRef,
         Statement,
+        TypeExpr,
         UnaryExpr,
         VarExpr,
         WhileStmt,
@@ -134,7 +141,14 @@ def _with_indent(self) -> _IndentContext:
 
     def visit_program(self, node: Program) -> str:
         """Visit program node."""
-        lines = ["Main("]
+        # BlockDecls are hoisted above the Main block in the rendering so the
+        # output reads top-down (defs first, call sites below).
+        lines: list[str] = []
+        for decl in node.block_decls:
+            lines.append(self.visit_block_decl(decl))
+            lines.append("")
+
+        lines.append("Main(")
         self._level += 1
 
         # Allocator
@@ -316,6 +330,45 @@ def visit_parallel(self, node: ParallelBlock) -> str:
         lines.append(")")
         return "\n".join(lines)
 
+    # Reusable blocks (Phase 3a.1)
+
+    def visit_block_decl(self, node: BlockDecl) -> str:
+        """Visit a BlockDecl, rendering it as a reusable function-like declaration."""
+        inputs_str = ", ".join(self.visit_block_input(inp) for inp in node.inputs)
+        lines = [f'BlockDecl("{node.name}", inputs=[{inputs_str}]):']
+
+        self._level += 1
+        if not node.body and node.return_op is None:
+            lines.append(self._indented("pass"))
+        else:
+            lines.extend(self._indented(f"{self.format_statement(stmt)},") for stmt in node.body)
+            if node.return_op is not None:
+                lines.append(self._indented(f"{self.format_statement(node.return_op)},"))
+        self._level -= 1
+        return "\n".join(lines)
+
+    def visit_block_input(self, node: BlockInput) -> str:
+        """Visit a BlockInput, rendering it as `name: type @ effect`."""
+        return f"{node.name}: {self._format_type_expr(node.type_expr)} @ {node.effect.name.lower()}"
+
+    def visit_block_call(self, node: BlockCall) -> str:
+        """Visit a BlockCall as a parenthesized invocation site."""
+        args = ", ".join(node.arg_bindings)
+        if node.out_bindings:
+            outs = ", ".join(node.out_bindings)
+            return f"({outs}) = BlockCall({node.callee!r}, {args})"
+        return f"BlockCall({node.callee!r}, {args})"
+
+    def _format_type_expr(self, type_expr: TypeExpr) -> str:
+        """Render a TypeExpr inline (BlockInput rendering uses this)."""
+        if isinstance(type_expr, ArrayTypeExpr):
+            return f"array[{self._format_type_expr(type_expr.element)}, {type_expr.size}]"
+        if isinstance(type_expr, QubitTypeExpr):
+            return "qubit"
+        if isinstance(type_expr, BitTypeExpr):
+            return "bit"
+        return type_expr.accept(self)
+
     # References
 
     def visit_slot_ref(self, node: SlotRef) -> str:
diff --git a/python/quantum-pecos/src/pecos/slr/ast/serialize.py b/python/quantum-pecos/src/pecos/slr/ast/serialize.py
index 03dcd7212..62868369d 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/serialize.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/serialize.py
@@ -43,6 +43,9 @@
     BitExpr,
     BitRef,
     BitTypeExpr,
+    BlockCall,
+    BlockDecl,
+    BlockInput,
     CommentOp,
     ForStmt,
     GateKind,
@@ -57,6 +60,7 @@
     QubitTypeExpr,
     RegisterDecl,
     RepeatStmt,
+    ResourceEffect,
     ReturnOp,
     SlotRef,
     SourceLocation,
@@ -82,6 +86,9 @@
     "BitExpr": BitExpr,
     "BitRef": BitRef,
     "BitTypeExpr": BitTypeExpr,
+    "BlockCall": BlockCall,
+    "BlockDecl": BlockDecl,
+    "BlockInput": BlockInput,
     "CommentOp": CommentOp,
     "ForStmt": ForStmt,
     "GateOp": GateOp,
@@ -108,6 +115,7 @@
     "GateKind": GateKind,
     "BinaryOp": BinaryOp,
     "UnaryOp": UnaryOp,
+    "ResourceEffect": ResourceEffect,
 }
 
 
@@ -139,7 +147,7 @@ def _serialize_value(value: Any) -> Any:
         return None
     if isinstance(value, (int, float, bool, str)):
         return value
-    if isinstance(value, (GateKind, BinaryOp, UnaryOp)):
+    if isinstance(value, (GateKind, BinaryOp, UnaryOp, ResourceEffect)):
         return {"_enum": type(value).__name__, "value": value.name}
     if isinstance(value, tuple):
         return [_serialize_value(v) for v in value]
diff --git a/python/quantum-pecos/src/pecos/slr/ast/visitor.py b/python/quantum-pecos/src/pecos/slr/ast/visitor.py
index c1290114f..9a60341ce 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/visitor.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/visitor.py
@@ -33,6 +33,9 @@
         BitExpr,
         BitRef,
         BitTypeExpr,
+        BlockCall,
+        BlockDecl,
+        BlockInput,
         CommentOp,
         ForStmt,
         GateOp,
@@ -88,6 +91,13 @@ def visit_return(self, node: ReturnOp) -> T_co: ...
 
     def visit_permute(self, node: PermuteOp) -> T_co: ...
 
+    # Reusable blocks (Phase 3a.1)
+    def visit_block_decl(self, node: BlockDecl) -> T_co: ...
+
+    def visit_block_input(self, node: BlockInput) -> T_co: ...
+
+    def visit_block_call(self, node: BlockCall) -> T_co: ...
+
     # Control flow
     def visit_if(self, node: IfStmt) -> T_co: ...
 
@@ -202,6 +212,19 @@ def visit_return(self, node: ReturnOp) -> T:
     def visit_permute(self, _node: PermuteOp) -> T:
         return self.default_result()
 
+    # Reusable blocks
+
+    def visit_block_decl(self, node: BlockDecl) -> T:
+        results = self.visit_children(node)
+        return self.combine_results(results)
+
+    def visit_block_input(self, node: BlockInput) -> T:
+        results = self.visit_children(node)
+        return self.combine_results(results)
+
+    def visit_block_call(self, _node: BlockCall) -> T:
+        return self.default_result()
+
     # Control flow
 
     def visit_if(self, node: IfStmt) -> T:
diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/steane/gates_sq/hadamards.py b/python/quantum-pecos/src/pecos/slr/qeclib/steane/gates_sq/hadamards.py
index aad20599d..5a05ca30e 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/steane/gates_sq/hadamards.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/steane/gates_sq/hadamards.py
@@ -15,6 +15,8 @@
 # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 # specific language governing permissions and limitations under the License.
 
+from typing import ClassVar
+
 from pecos.slr import Block, Comment, QReg
 from pecos.slr.qeclib import qubit
 
@@ -28,6 +30,8 @@ class H(Block):
     Y -> -Y
     """
 
+    block_inputs: ClassVar[dict[str, str]] = {"q": "live_preserved"}
+
     def __init__(self, q: QReg) -> None:
         """Initialize a logical Hadamard gate on the Steane code.
 
@@ -42,7 +46,9 @@ def __init__(self, q: QReg) -> None:
             msg = f"Size of register {len(q.elems)} != 7"
             raise Exception(msg)
 
-        super().__init__(
+        super().__init__()
+        self.q = q
+        self.extend(
             Comment("Logical H"),
             qubit.H(q),
         )
diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/steane/gates_sq/paulis.py b/python/quantum-pecos/src/pecos/slr/qeclib/steane/gates_sq/paulis.py
index b34ac9591..4ff48c79c 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/steane/gates_sq/paulis.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/steane/gates_sq/paulis.py
@@ -15,6 +15,8 @@
 # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 # specific language governing permissions and limitations under the License.
 
+from typing import ClassVar
+
 from pecos.slr import Block, Comment, QReg
 from pecos.slr.qeclib import qubit
 
@@ -28,6 +30,8 @@ class X(Block):
     Y -> -Y
     """
 
+    block_inputs: ClassVar[dict[str, str]] = {"q": "live_preserved"}
+
     def __init__(self, q: QReg) -> None:
         """Initialize a logical Pauli X gate on the Steane code.
 
@@ -42,7 +46,9 @@ def __init__(self, q: QReg) -> None:
             msg = f"Size of register {len(q.elems)} != 7"
             raise Exception(msg)
 
-        super().__init__(
+        super().__init__()
+        self.q = q
+        self.extend(
             Comment("Logical X"),
             qubit.X(q[4]),
             qubit.X(q[5]),
@@ -59,6 +65,8 @@ class Y(Block):
     Y -> Y
     """
 
+    block_inputs: ClassVar[dict[str, str]] = {"q": "live_preserved"}
+
     def __init__(self, q: QReg) -> None:
         """Initialize a logical Pauli Y gate on the Steane code.
 
@@ -73,7 +81,9 @@ def __init__(self, q: QReg) -> None:
             msg = f"Size of register {len(q.elems)} != 7"
             raise Exception(msg)
 
-        super().__init__(
+        super().__init__()
+        self.q = q
+        self.extend(
             Comment("Logical Y"),
             qubit.Y(q[4]),
             qubit.Y(q[5]),
@@ -90,6 +100,8 @@ class Z(Block):
     Y -> -Y
     """
 
+    block_inputs: ClassVar[dict[str, str]] = {"q": "live_preserved"}
+
     def __init__(self, q: QReg) -> None:
         """Initialize a logical Pauli Z gate on the Steane code.
 
@@ -104,7 +116,9 @@ def __init__(self, q: QReg) -> None:
             msg = f"Size of register {len(q.elems)} != 7"
             raise Exception(msg)
 
-        super().__init__(
+        super().__init__()
+        self.q = q
+        self.extend(
             Comment("Logical Z"),
             qubit.Z(q[4]),
             qubit.Z(q[5]),
diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/steane/gates_tq/transversal_tq.py b/python/quantum-pecos/src/pecos/slr/qeclib/steane/gates_tq/transversal_tq.py
index 6b1ed60b7..17b4099ef 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/steane/gates_tq/transversal_tq.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/steane/gates_tq/transversal_tq.py
@@ -15,6 +15,8 @@
 # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 # specific language governing permissions and limitations under the License.
 
+from typing import ClassVar
+
 from pecos.slr import Barrier, Block, Comment, QReg
 from pecos.slr.qeclib import qubit
 
@@ -26,6 +28,14 @@ class CX(Block):
     two logical qubits encoded in the Steane code.
     """
 
+    # Phase 3a.3: declare resource effects so SLR -> AST emits BlockDecl + BlockCall
+    # instead of inlining. Both registers are live_preserved -- the body applies a
+    # transversal CX pairwise (no internal measurements).
+    block_inputs: ClassVar[dict[str, str]] = {
+        "q1": "live_preserved",
+        "q2": "live_preserved",
+    }
+
     def __init__(self, q1: QReg, q2: QReg, *, barrier: bool = True) -> None:
         """Initialize a transversal logical CX gate on two Steane code logical qubits.
 
@@ -47,6 +57,9 @@ def __init__(self, q1: QReg, q2: QReg, *, barrier: bool = True) -> None:
             raise Exception(msg)
 
         super().__init__()
+        # SLR -> AST converter reads these to bind block_inputs param names to outer-scope refs.
+        self.q1 = q1
+        self.q2 = q2
         self.extend(
             Comment("Transversal Logical CX"),
         )
@@ -78,6 +91,11 @@ class CY(Block):
     two logical qubits encoded in the Steane code.
     """
 
+    block_inputs: ClassVar[dict[str, str]] = {
+        "q1": "live_preserved",
+        "q2": "live_preserved",
+    }
+
     def __init__(self, q1: QReg, q2: QReg) -> None:
         """Initialize a transversal logical CY gate on two Steane code logical qubits.
 
@@ -110,6 +128,8 @@ def __init__(self, q1: QReg, q2: QReg) -> None:
             ),
             Barrier(q1, q2),
         )
+        self.q1 = q1
+        self.q2 = q2
 
 
 class CZ(Block):
@@ -119,6 +139,11 @@ class CZ(Block):
     two logical qubits encoded in the Steane code.
     """
 
+    block_inputs: ClassVar[dict[str, str]] = {
+        "q1": "live_preserved",
+        "q2": "live_preserved",
+    }
+
     def __init__(self, q1: QReg, q2: QReg) -> None:
         """Initialize a transversal logical CZ gate on two Steane code logical qubits.
 
@@ -151,6 +176,8 @@ def __init__(self, q1: QReg, q2: QReg) -> None:
             ),
             Barrier(q1, q2),
         )
+        self.q1 = q1
+        self.q2 = q2
 
 
 class SZZ(Block):
diff --git a/python/quantum-pecos/src/pecos/slr/transforms/parallel_optimizer.py b/python/quantum-pecos/src/pecos/slr/transforms/parallel_optimizer.py
index 78f85f745..c8a448949 100644
--- a/python/quantum-pecos/src/pecos/slr/transforms/parallel_optimizer.py
+++ b/python/quantum-pecos/src/pecos/slr/transforms/parallel_optimizer.py
@@ -92,9 +92,22 @@ def _transform_block(self, block: Block) -> Block:
         elif isinstance(block, Main) and type(block) is Main:
             new_block = Main(*new_ops)
         elif isinstance(block, Block):
-            # Use isinstance to handle Block subclasses
-            new_block = Block(*new_ops)
-            # Preserve block metadata if available
+            # For Block subclasses, preserve class identity so class-level
+            # attributes (block_inputs, block_returns, etc.) and any instance
+            # state set by the subclass __init__ (e.g. `self.q1`, `self.q2`
+            # bound for `block_inputs` lookup) survive the optimization pass.
+            # Reconstructing via `Block(*new_ops)` here would erase that state
+            # and cause Phase 3a.3 converted Blocks to silently fall back to
+            # the v1 flatten path. (Codex 2026-05-15 review #4.)
+            cls = type(block)
+            if cls is Block:
+                new_block = Block(*new_ops)
+            else:
+                new_block = cls.__new__(cls)
+                new_block.__dict__.update(block.__dict__)
+                new_block.ops = list(new_ops)
+            # The metadata copy below is redundant for the subclass case (already
+            # carried via __dict__) but kept for the plain-Block branch.
             if hasattr(block, "block_name"):
                 new_block.block_name = block.block_name
             if hasattr(block, "block_module"):
@@ -152,15 +165,35 @@ def _transform_parallel(self, parallel: Parallel) -> Block | Parallel:
     def _can_optimize_parallel(self, parallel: Parallel) -> bool:
         """Check if a Parallel block can be safely optimized.
 
-        Returns False if the block contains control flow (If/Repeat).
+        Returns False if the block contains control flow (If/Repeat) or any
+        converted Block (a Block subclass with class-level `block_inputs`).
+        Splatting a converted Block's body into the surrounding Parallel
+        would destroy its scope boundary -- the BlockCall lowering needs the
+        Block to remain a single op in the AST. (Codex 2026-05-15 review #1
+        of fix-pass-3.)
         """
         for op in parallel.ops:
             if isinstance(op, If | Repeat):
                 return False
-            if isinstance(op, Block) and self._contains_control_flow(op):
-                return False
+            if isinstance(op, Block):
+                if hasattr(type(op), "block_inputs"):
+                    return False
+                if self._contains_control_flow(op):
+                    return False
+                if self._contains_converted_block(op):
+                    return False
         return True
 
+    def _contains_converted_block(self, block: Block) -> bool:
+        """Check if a Block (recursively) contains any converted Block."""
+        for op in block.ops:
+            if isinstance(op, Block):
+                if hasattr(type(op), "block_inputs"):
+                    return True
+                if self._contains_converted_block(op):
+                    return True
+        return False
+
     def _contains_control_flow(self, block: Block) -> bool:
         """Check if a block contains any control flow operations."""
         for op in block.ops:
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
new file mode 100644
index 000000000..befdb9ad1
--- /dev/null
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
@@ -0,0 +1,863 @@
+# Copyright 2026 The PECOS Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations under the License.
+
+"""Phase 3a.1 smoke tests for BlockDecl / BlockCall.
+
+Builds AST programs directly (without going through SLR) to exercise the new
+Guppy emitter codepaths:
+- `BlockDecl` lowers to a `@guppy def` top-level function
+- `BlockCall` lowers to `array(...)` pack + call + unpack
+- `LIVE_PRESERVED` inputs leave outer-scope slots in the LIVE state post-call
+- `CONSUMED` inputs leave outer-scope slots in the CONSUMED state post-call
+
+See `~/Repos/pecos-docs/design/slr/v2-blockcall-resource-effects.md`.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import ClassVar
+
+import pytest
+from pecos.slr.ast import (
+    AllocatorDecl,
+    ArrayTypeExpr,
+    BitRef,
+    BlockCall,
+    BlockDecl,
+    BlockInput,
+    GateKind,
+    GateOp,
+    MeasureOp,
+    PrepareOp,
+    Program,
+    QubitTypeExpr,
+    RegisterDecl,
+    ResourceEffect,
+    SlotRef,
+    ast_to_guppy,
+)
+from pecos.slr.ast.codegen.guppy import GuppyCodegenError
+
+
+def _bell_program() -> Program:
+    """Program with a `bell` BlockDecl that applies H + CX to a 2-qubit array."""
+    bell = BlockDecl(
+        name="bell",
+        inputs=(
+            BlockInput(
+                name="q",
+                effect=ResourceEffect.LIVE_PRESERVED,
+                type_expr=ArrayTypeExpr(element=QubitTypeExpr(), size=2),
+            ),
+        ),
+        body=(
+            GateOp(gate=GateKind.H, targets=(SlotRef(allocator="q", index=0),)),
+            GateOp(
+                gate=GateKind.CX,
+                targets=(
+                    SlotRef(allocator="q", index=0),
+                    SlotRef(allocator="q", index=1),
+                ),
+            ),
+        ),
+    )
+    return Program(
+        name="main",
+        allocator=AllocatorDecl(name="outer_q", capacity=2),
+        declarations=(RegisterDecl(name="c", size=2),),
+        block_decls=(bell,),
+        body=(
+            PrepareOp(allocator="outer_q"),
+            BlockCall(
+                callee="bell",
+                arg_bindings=("outer_q",),
+                out_bindings=("outer_q",),
+            ),
+            MeasureOp(
+                targets=(
+                    SlotRef(allocator="outer_q", index=0),
+                    SlotRef(allocator="outer_q", index=1),
+                ),
+                results=(
+                    BitRef(register="c", index=0),
+                    BitRef(register="c", index=1),
+                ),
+            ),
+        ),
+    )
+
+
+class TestBlockDeclGuppySource:
+    """Inspect the generated Guppy source for shape correctness."""
+
+    def test_live_preserved_block_lowers_to_guppy_def_with_array_return(self) -> None:
+        source = ast_to_guppy(_bell_program())
+
+        # The BlockDecl emits its own @guppy def above main.
+        assert re.search(r"@guppy\s*\n\s*def bell\(q: array\[qubit, 2\] @ owned\) -> array\[qubit, 2\]:", source)
+        # Body unpacks the array, applies H + CX, and returns the repacked array.
+        assert "q_0, q_1 = q" in source
+        assert "q_0 = h(q_0)" in source
+        assert "q_0, q_1 = cx(q_0, q_1)" in source
+        assert "return array(q_0, q_1)" in source
+
+    def test_block_call_packs_unpacks_around_call(self) -> None:
+        source = ast_to_guppy(_bell_program())
+
+        # The call site packs the outer locals, calls bell, and unpacks the return.
+        assert re.search(r"_call_ret_\d+\s*=\s*bell\(array\(outer_q_0, outer_q_1\)\)", source)
+        assert re.search(r"outer_q_0, outer_q_1\s*=\s*_call_ret_\d+", source)
+
+
+class TestBlockCallValidation:
+    """Edge cases the Guppy emitter must reject with clear errors."""
+
+    def test_undefined_callee_rejected(self) -> None:
+        prog = Program(
+            name="main",
+            allocator=AllocatorDecl(name="outer_q", capacity=2),
+            body=(
+                BlockCall(callee="missing_block", arg_bindings=("outer_q",), out_bindings=("outer_q",)),
+            ),
+        )
+        with pytest.raises(GuppyCodegenError, match=r"undefined block 'missing_block'"):
+            ast_to_guppy(prog)
+
+    def test_arg_count_mismatch_rejected(self) -> None:
+        bell = BlockDecl(
+            name="bell",
+            inputs=(
+                BlockInput(
+                    name="q",
+                    effect=ResourceEffect.LIVE_PRESERVED,
+                    type_expr=ArrayTypeExpr(element=QubitTypeExpr(), size=2),
+                ),
+            ),
+            body=(),
+        )
+        prog = Program(
+            name="main",
+            allocator=AllocatorDecl(name="outer_q", capacity=2),
+            block_decls=(bell,),
+            body=(
+                BlockCall(callee="bell", arg_bindings=("outer_q", "outer_q"), out_bindings=("outer_q",)),
+            ),
+        )
+        with pytest.raises(GuppyCodegenError, match=r"2 arg_bindings but BlockDecl declares 1"):
+            ast_to_guppy(prog)
+
+    def test_unsupported_effect_rejected(self) -> None:
+        """`PRODUCED` and `DROPPED` effects are not lowered in Phase 3a.1."""
+        bell = BlockDecl(
+            name="bell",
+            inputs=(
+                BlockInput(
+                    name="q",
+                    effect=ResourceEffect.PRODUCED,
+                    type_expr=ArrayTypeExpr(element=QubitTypeExpr(), size=2),
+                ),
+            ),
+            body=(),
+        )
+        prog = Program(
+            name="main",
+            allocator=AllocatorDecl(name="outer_q", capacity=2),
+            block_decls=(bell,),
+            body=(),
+        )
+        with pytest.raises(GuppyCodegenError, match=r"PRODUCED"):
+            ast_to_guppy(prog)
+
+    def test_unsupported_input_type_rejected(self) -> None:
+        """Only `array[qubit, N]` inputs are supported in Phase 3a.1."""
+        from pecos.slr.ast.nodes import BitTypeExpr
+
+        bell = BlockDecl(
+            name="bell",
+            inputs=(
+                BlockInput(
+                    name="c",
+                    effect=ResourceEffect.LIVE_PRESERVED,
+                    type_expr=ArrayTypeExpr(element=BitTypeExpr(), size=2),
+                ),
+            ),
+            body=(),
+        )
+        prog = Program(
+            name="main",
+            allocator=AllocatorDecl(name="outer_q", capacity=2),
+            block_decls=(bell,),
+            body=(),
+        )
+        with pytest.raises(GuppyCodegenError, match=r"only array\[qubit, N\] inputs"):
+            ast_to_guppy(prog)
+
+    def test_size_mismatch_rejected(self) -> None:
+        bell = BlockDecl(
+            name="bell",
+            inputs=(
+                BlockInput(
+                    name="q",
+                    effect=ResourceEffect.LIVE_PRESERVED,
+                    type_expr=ArrayTypeExpr(element=QubitTypeExpr(), size=2),
+                ),
+            ),
+            body=(),
+        )
+        prog = Program(
+            name="main",
+            allocator=AllocatorDecl(name="outer_q", capacity=3),
+            block_decls=(bell,),
+            body=(
+                BlockCall(callee="bell", arg_bindings=("outer_q",), out_bindings=("outer_q",)),
+            ),
+        )
+        with pytest.raises(GuppyCodegenError, match=r"size 3 does not match input 'q' size 2"):
+            ast_to_guppy(prog)
+
+
+class TestBlockCallNonGuppyFlatten:
+    """Phase 3a.2: non-Guppy codegens inline BlockCall byte-identical to a flat program."""
+
+    def test_qasm_blockcall_matches_inlined_program(self) -> None:
+        """QASM output for a BlockCall program matches the hand-flattened program."""
+        from pecos.slr.ast.codegen import generate as codegen_generate
+
+        with_block = _bell_program()
+
+        # The same program with the bell body inlined and no BlockDecl/BlockCall.
+        flat = Program(
+            name="main",
+            allocator=AllocatorDecl(name="outer_q", capacity=2),
+            declarations=(RegisterDecl(name="c", size=2),),
+            body=(
+                PrepareOp(allocator="outer_q"),
+                GateOp(gate=GateKind.H, targets=(SlotRef(allocator="outer_q", index=0),)),
+                GateOp(
+                    gate=GateKind.CX,
+                    targets=(
+                        SlotRef(allocator="outer_q", index=0),
+                        SlotRef(allocator="outer_q", index=1),
+                    ),
+                ),
+                MeasureOp(
+                    targets=(
+                        SlotRef(allocator="outer_q", index=0),
+                        SlotRef(allocator="outer_q", index=1),
+                    ),
+                    results=(
+                        BitRef(register="c", index=0),
+                        BitRef(register="c", index=1),
+                    ),
+                ),
+            ),
+        )
+
+        assert codegen_generate(with_block, "qasm") == codegen_generate(flat, "qasm")
+
+
+class TestConvertedQeclibBlocksUseBlockCallPath:
+    """Lock in that each Phase 3a.3-converted Steane Block actually goes through
+    the BlockCall lowering path -- not silently flattening.
+
+    Goes through `SlrConverter(prog).guppy()` end-to-end (not just `slr_to_ast`)
+    so this catches regressions in any production transform between SLR and
+    AST (e.g., ParallelOptimizer dropping class identity, Codex 2026-05-15
+    review #4).
+    """
+
+    def _assert_uses_block_call(self, prog: object, expected_callee_prefix: str) -> None:
+        from pecos.slr import SlrConverter
+
+        guppy_src = SlrConverter(prog).guppy()
+        # The converted Block must emit its own @guppy def with a name starting
+        # with `{class_name_lower}_`. Pre-fix, ParallelOptimizer destroyed class
+        # identity and the body was inlined into main(), so no such def was
+        # emitted.
+        assert (
+            f"def {expected_callee_prefix}" in guppy_src
+        ), f"expected '@guppy def {expected_callee_prefix}...' in source, got:\n{guppy_src}"
+
+    def test_steane_cx_uses_block_call(self) -> None:
+        from pecos.slr import CReg, Main, QReg
+        from pecos.slr.qeclib.steane.gates_tq import transversal_tq as steane_tq
+
+        prog = Main(a := QReg("a", 7), b := QReg("b", 7), CReg("c", 14), steane_tq.CX(a, b))
+        self._assert_uses_block_call(prog, "cx_")
+
+    def test_steane_cy_uses_block_call(self) -> None:
+        from pecos.slr import CReg, Main, QReg
+        from pecos.slr.qeclib.steane.gates_tq import transversal_tq as steane_tq
+
+        prog = Main(a := QReg("a", 7), b := QReg("b", 7), CReg("c", 14), steane_tq.CY(a, b))
+        self._assert_uses_block_call(prog, "cy_")
+
+    def test_steane_cz_uses_block_call(self) -> None:
+        from pecos.slr import CReg, Main, QReg
+        from pecos.slr.qeclib.steane.gates_tq import transversal_tq as steane_tq
+
+        prog = Main(a := QReg("a", 7), b := QReg("b", 7), CReg("c", 14), steane_tq.CZ(a, b))
+        self._assert_uses_block_call(prog, "cz_")
+
+    def test_steane_logical_x_uses_block_call(self) -> None:
+        from pecos.slr import CReg, Main, QReg
+        from pecos.slr.qeclib.steane.gates_sq import paulis as steane_paulis
+
+        prog = Main(q := QReg("q", 7), CReg("c", 7), steane_paulis.X(q))
+        self._assert_uses_block_call(prog, "x_")
+
+    def test_steane_logical_y_uses_block_call(self) -> None:
+        from pecos.slr import CReg, Main, QReg
+        from pecos.slr.qeclib.steane.gates_sq import paulis as steane_paulis
+
+        prog = Main(q := QReg("q", 7), CReg("c", 7), steane_paulis.Y(q))
+        self._assert_uses_block_call(prog, "y_")
+
+    def test_steane_logical_z_uses_block_call(self) -> None:
+        from pecos.slr import CReg, Main, QReg
+        from pecos.slr.qeclib.steane.gates_sq import paulis as steane_paulis
+
+        prog = Main(q := QReg("q", 7), CReg("c", 7), steane_paulis.Z(q))
+        self._assert_uses_block_call(prog, "z_")
+
+    def test_steane_logical_h_uses_block_call(self) -> None:
+        from pecos.slr import CReg, Main, QReg
+        from pecos.slr.qeclib.steane.gates_sq import hadamards as steane_h
+
+        prog = Main(q := QReg("q", 7), CReg("c", 7), steane_h.H(q))
+        self._assert_uses_block_call(prog, "h_")
+
+
+class TestConsumedEffect:
+    """End-to-end coverage for CONSUMED inputs (Codex 2026-05-15 review caught this gap).
+
+    The Phase 3a.1 validator allows CONSUMED in BlockDecl.inputs, and the
+    `_emit_block_call` code path marks the outer slot CONSUMED post-call. But
+    no existing test confirmed that a subsequent outer-scope reference raises
+    a LinearityError. Add a direct-AST test that pins this behavior.
+    """
+
+    def _build_consume_then_reuse_program(self) -> Program:
+        """A BlockDecl whose `q` input is CONSUMED + a body that measures it; caller
+        attempts to use the slot again afterwards.
+        """
+        consume = BlockDecl(
+            name="consume",
+            inputs=(
+                BlockInput(
+                    name="q",
+                    effect=ResourceEffect.CONSUMED,
+                    type_expr=ArrayTypeExpr(element=QubitTypeExpr(), size=1),
+                ),
+            ),
+            body=(
+                # Measure the consumed input so the BlockDecl body itself is sound
+                # (otherwise Guppy linearity inside the BlockDecl would complain).
+                MeasureOp(targets=(SlotRef(allocator="q", index=0),)),
+            ),
+        )
+        return Program(
+            name="main",
+            allocator=AllocatorDecl(name="outer_q", capacity=1),
+            declarations=(RegisterDecl(name="c", size=1),),
+            block_decls=(consume,),
+            body=(
+                PrepareOp(allocator="outer_q"),
+                BlockCall(callee="consume", arg_bindings=("outer_q",), out_bindings=()),
+                # After the call outer_q[0] is CONSUMED; reusing it must raise.
+                MeasureOp(
+                    targets=(SlotRef(allocator="outer_q", index=0),),
+                    results=(BitRef(register="c", index=0),),
+                ),
+            ),
+        )
+
+    def test_outer_reuse_after_consumed_raises(self) -> None:
+        from pecos.slr.ast.codegen.guppy_linearity import LinearityError
+
+        prog = self._build_consume_then_reuse_program()
+        with pytest.raises(LinearityError, match=r"outer_q\[0\] is consumed"):
+            ast_to_guppy(prog)
+
+
+class TestNestedConvertedBlocks:
+    """Nested converted Blocks: an Outer Block whose body contains an Inner Block.
+
+    Codex 2026-05-15 review #1+#2 caught two bugs in nested support:
+    - `_substitute_stmt` had no BlockCall branch, so nested calls leaked outer
+      allocator names into the parent BlockDecl body.
+    - Each sub-converter restarted `_decl_counter` at 0, causing name collisions
+      when the same Block class appeared both top-level and nested.
+    """
+
+    def _build_nested_program(self) -> object:
+        from pecos.slr import Block, CReg, Main, QReg
+        from pecos.slr.qeclib import qubit as qb
+        from pecos.slr.qeclib.qubit.measures import Measure
+
+        class InnerBlock(Block):
+            block_inputs: ClassVar[dict[str, str]] = {"q": "live_preserved"}
+
+            def __init__(self, q: QReg) -> None:
+                super().__init__()
+                self.q = q
+                self.extend(qb.H(q[0]))
+
+        class OuterBlock(Block):
+            block_inputs: ClassVar[dict[str, str]] = {"q": "live_preserved"}
+
+            def __init__(self, q: QReg) -> None:
+                super().__init__()
+                self.q = q
+                self.extend(InnerBlock(q))
+
+        return Main(
+            outer := QReg("outer", 2),
+            c := CReg("c", 2),
+            qb.Prep(outer),
+            OuterBlock(outer),
+            Measure(outer) > c,
+        )
+
+    def test_nested_block_call_arg_bindings_substitute_to_parent_param(self) -> None:
+        from pecos.slr.ast import slr_to_ast
+
+        prog = self._build_nested_program()
+        ast = slr_to_ast(prog)
+
+        # Two BlockDecls, both with unique counter-suffixed names.
+        decl_names = [d.name for d in ast.block_decls]
+        assert len(decl_names) == 2, decl_names
+        assert len(set(decl_names)) == 2, f"decl names not unique: {decl_names}"
+        inner_decl = next(d for d in ast.block_decls if d.name.startswith("innerblock_"))
+        outer_decl = next(d for d in ast.block_decls if d.name.startswith("outerblock_"))
+
+        # The OUTER decl's body must contain a BlockCall to inner whose
+        # arg_bindings use the OUTER's parameter name "q", not the user's
+        # outer-scope allocator name "outer".
+        nested_calls = [s for s in outer_decl.body if isinstance(s, BlockCall)]
+        assert len(nested_calls) == 1, nested_calls
+        nested = nested_calls[0]
+        assert nested.callee == inner_decl.name
+        assert nested.arg_bindings == ("q",), nested.arg_bindings
+        assert nested.out_bindings == ("q",), nested.out_bindings
+
+    def test_top_level_inner_plus_outer_containing_inner_have_unique_names(self) -> None:
+        """Codex review #2: same Block class top-level AND nested must not collide."""
+        from pecos.slr import Block, CReg, Main, QReg
+        from pecos.slr.ast import slr_to_ast
+        from pecos.slr.qeclib import qubit as qb
+        from pecos.slr.qeclib.qubit.measures import Measure
+
+        class InnerBlock(Block):
+            block_inputs: ClassVar[dict[str, str]] = {"q": "live_preserved"}
+
+            def __init__(self, q: QReg) -> None:
+                super().__init__()
+                self.q = q
+                self.extend(qb.H(q[0]))
+
+        class OuterBlock(Block):
+            block_inputs: ClassVar[dict[str, str]] = {"q": "live_preserved"}
+
+            def __init__(self, q: QReg) -> None:
+                super().__init__()
+                self.q = q
+                self.extend(InnerBlock(q))
+
+        prog = Main(
+            outer := QReg("outer", 2),
+            c := CReg("c", 2),
+            qb.Prep(outer),
+            InnerBlock(outer),
+            OuterBlock(outer),
+            Measure(outer) > c,
+        )
+        ast = slr_to_ast(prog)
+        decl_names = [d.name for d in ast.block_decls]
+        # Three decls: two innerblock_* (top-level + nested) and one outerblock_*.
+        assert len(decl_names) == 3, decl_names
+        assert len(set(decl_names)) == 3, f"decl names not unique: {decl_names}"
+
+    def test_nested_block_call_compiles_via_guppy(self) -> None:
+        """End-to-end: nested BlockCall lowers via Guppy emitter without error."""
+        from pecos.slr import SlrConverter
+
+        prog = self._build_nested_program()
+        # SlrConverter.guppy() routes through the AST path; if substitution or
+        # counter sharing were broken, this would raise GuppyCodegenError.
+        guppy_src = SlrConverter(prog).guppy()
+        # Sanity: both function definitions are emitted.
+        assert "def innerblock_" in guppy_src
+        assert "def outerblock_" in guppy_src
+        # The nested call inside outer must reference inner by its hoisted name.
+        assert re.search(r"innerblock_\d+\(", guppy_src)
+
+
+class TestPrettyPrintHandlesBlockNodes:
+    """Codex 2026-05-15 fix-pass-4 review: `pretty_print` crashed on any program
+    containing a BlockCall because the visitor inherited `default_result()` which
+    raises NotImplementedError. Lock in that pretty_print emits both BlockDecls
+    and BlockCalls cleanly.
+    """
+
+    def test_pretty_print_emits_block_decl_and_block_call(self) -> None:
+        from pecos.slr.ast.pretty_print import pretty_print
+
+        decl = BlockDecl(
+            name="bell",
+            inputs=(
+                BlockInput(
+                    name="q",
+                    effect=ResourceEffect.LIVE_PRESERVED,
+                    type_expr=ArrayTypeExpr(element=QubitTypeExpr(), size=2),
+                ),
+            ),
+            body=(GateOp(gate=GateKind.H, targets=(SlotRef(allocator="q", index=0),)),),
+        )
+        prog = Program(
+            name="main",
+            allocator=AllocatorDecl(name="outer_q", capacity=2),
+            block_decls=(decl,),
+            body=(
+                BlockCall(callee="bell", arg_bindings=("outer_q",), out_bindings=("outer_q",)),
+            ),
+        )
+        # Pre-fix this raised NotImplementedError from BaseVisitor.default_result().
+        rendered = pretty_print(prog)
+        assert 'BlockDecl("bell"' in rendered
+        assert "q: array[qubit, 2] @ live_preserved" in rendered
+        assert "qb.H(q[0])" in rendered
+        assert "BlockCall('bell', outer_q)" in rendered
+
+
+class TestConvertedBlocksInsideParallel:
+    """Codex 2026-05-15 fix-pass-3 review #1: a converted Block inside Parallel(...)
+    used to silently flatten because ParallelOptimizer's `_collect_operations`
+    splatted the Block's body into the surrounding Parallel, destroying its
+    scope boundary. The fix bails out of `_can_optimize_parallel` when any
+    direct or transitive child is a converted Block.
+    """
+
+    def test_parallel_with_converted_block_preserves_block_call_via_slr_converter(self) -> None:
+        from pecos.slr import CReg, Main, QReg, SlrConverter
+        from pecos.slr.misc import Parallel
+        from pecos.slr.qeclib.qubit.measures import Measure
+        from pecos.slr.qeclib.steane.gates_sq.hadamards import H as SteaneH
+
+        prog = Main(
+            q := QReg("q", 7),
+            c := CReg("c", 7),
+            Parallel(SteaneH(q)),
+            Measure(q) > c,
+        )
+        guppy_src = SlrConverter(prog).guppy()
+        # Pre-fix, Parallel splatted the Steane H body into 7 individual h() calls
+        # in main(), and no `def h_0` was emitted.
+        assert "def h_" in guppy_src, f"BlockCall path bypassed by Parallel; source:\n{guppy_src}"
+        # And the call site references the hoisted def.
+        assert re.search(r"h_\d+\(", guppy_src)
+
+
+class TestAstOptimizationPreservesBlockDecls:
+    """Codex 2026-05-15 fix-pass-3 review #2: AST optimization passes were
+    reconstructing Program without `block_decls=`, leaving any contained
+    BlockCalls dangling. Lock in `block_decls` survival across each pass.
+    """
+
+    def _program_with_block_decl(self) -> Program:
+        decl = BlockDecl(
+            name="b",
+            inputs=(
+                BlockInput(
+                    name="q",
+                    effect=ResourceEffect.LIVE_PRESERVED,
+                    type_expr=ArrayTypeExpr(element=QubitTypeExpr(), size=1),
+                ),
+            ),
+            body=(GateOp(gate=GateKind.H, targets=(SlotRef(allocator="q", index=0),)),),
+        )
+        return Program(
+            name="main",
+            allocator=AllocatorDecl(name="outer_q", capacity=1),
+            block_decls=(decl,),
+            body=(
+                BlockCall(callee="b", arg_bindings=("outer_q",), out_bindings=("outer_q",)),
+            ),
+        )
+
+    def test_gate_cancellation_pass_preserves_block_decls(self) -> None:
+        from pecos.slr.ast.optimizations.gate_cancellation import GateCancellationPass
+
+        prog = self._program_with_block_decl()
+        result = GateCancellationPass().optimize(prog)
+        assert result.program.block_decls == prog.block_decls
+
+    def test_identity_removal_pass_preserves_block_decls(self) -> None:
+        from pecos.slr.ast.optimizations.identity_removal import IdentityRemovalPass
+
+        prog = self._program_with_block_decl()
+        result = IdentityRemovalPass().optimize(prog)
+        assert result.program.block_decls == prog.block_decls
+
+    def test_rotation_merging_pass_preserves_block_decls(self) -> None:
+        from pecos.slr.ast.optimizations.rotation_merging import RotationMergingPass
+
+        prog = self._program_with_block_decl()
+        result = RotationMergingPass().optimize(prog)
+        assert result.program.block_decls == prog.block_decls
+
+
+class TestDuplicateBlockDeclNameValidation:
+    """Shared validate_unique_block_decl_names contract (Codex review #3)."""
+
+    def _duplicate_decl_program(self) -> Program:
+        decl = BlockDecl(
+            name="dup",
+            inputs=(
+                BlockInput(
+                    name="q",
+                    effect=ResourceEffect.LIVE_PRESERVED,
+                    type_expr=ArrayTypeExpr(element=QubitTypeExpr(), size=2),
+                ),
+            ),
+            body=(),
+        )
+        return Program(
+            name="main",
+            allocator=AllocatorDecl(name="outer_q", capacity=2),
+            block_decls=(decl, decl),
+            body=(),
+        )
+
+    def test_guppy_emitter_rejects_duplicate_block_decl_names(self) -> None:
+        prog = self._duplicate_decl_program()
+        with pytest.raises(ValueError, match=r"Duplicate BlockDecl name 'dup'"):
+            ast_to_guppy(prog)
+
+    def test_flatten_pass_rejects_duplicate_block_decl_names(self) -> None:
+        from pecos.slr.ast.codegen._block_flatten import flatten_block_calls
+
+        prog = self._duplicate_decl_program()
+        with pytest.raises(ValueError, match=r"Duplicate BlockDecl name 'dup'"):
+            flatten_block_calls(prog)
+
+
+class TestBlockBodyStatementSubstitution:
+    """Phase 3a.1 substitution must cover every SLR statement type that names allocators.
+
+    Codex 2026-05-15 review caught that PermuteOp (which carries source/target
+    register names as strings, not SlotRefs) was silently passed through in
+    both `converter._substitute_stmt` and `_block_flatten._substitute`. Lock
+    in coverage with a regression test.
+    """
+
+    def test_permute_inside_block_inputs_substitutes_in_both_paths(self) -> None:
+        from pecos.slr import Block, CReg, Main, QReg
+        from pecos.slr.ast import slr_to_ast
+        from pecos.slr.ast.codegen._block_flatten import flatten_block_calls
+        from pecos.slr.ast.nodes import PermuteOp
+        from pecos.slr.misc import Permute
+        from pecos.slr.qeclib import qubit as qb
+        from pecos.slr.qeclib.qubit.measures import Measure
+
+        class SwapBlock(Block):
+            block_inputs: ClassVar[dict[str, str]] = {"q": "live_preserved"}
+
+            def __init__(self, q: QReg) -> None:
+                super().__init__()
+                self.q = q
+                self.extend(Permute([q[0], q[1]], [q[1], q[0]]))
+
+        prog = Main(
+            outer := QReg("outer", 2),
+            c := CReg("c", 2),
+            qb.Prep(outer),
+            SwapBlock(outer),
+            Measure(outer) > c,
+        )
+        ast = slr_to_ast(prog)
+
+        # BlockDecl body must reference the INPUT parameter name "q", not the outer
+        # allocator name "outer". Pre-fix, sources/targets leaked the outer name.
+        assert len(ast.block_decls) == 1
+        decl_body = ast.block_decls[0].body
+        assert len(decl_body) == 1
+        assert isinstance(decl_body[0], PermuteOp)
+        assert decl_body[0].sources == ("q[0]", "q[1]")
+        assert decl_body[0].targets == ("q[1]", "q[0]")
+
+        # Non-Guppy flatten path must rewrite the OTHER direction: input names
+        # back to the outer allocator. Pre-fix, the body still said "q[0]"/"q[1]".
+        flat = flatten_block_calls(ast)
+        permute_stmts = [s for s in flat.body if isinstance(s, PermuteOp)]
+        assert len(permute_stmts) == 1
+        assert permute_stmts[0].sources == ("outer[0]", "outer[1]")
+        assert permute_stmts[0].targets == ("outer[1]", "outer[0]")
+
+    def test_unparseable_permute_ref_mentioning_mapped_key_raises(self) -> None:
+        """Defensive raise (Codex 2026-05-15 review question 3): if a PermuteOp ref
+        cannot be parsed by the bare-name / `name[idx]` regex AND the ref textually
+        mentions a mapped allocator, raise instead of silently leaking outer names.
+        """
+        from pecos.slr.ast.codegen._block_flatten import _sub_permute_ref
+        from pecos.slr.ast.converter import _substitute_permute_ref
+
+        mapping = {"outer": "q"}
+        # Slice-form ref mentioning a mapped allocator -- not produced by SLR today
+        # but if the codegen layer ever sees one, it must raise rather than pass
+        # the unsubstituted string through.
+        with pytest.raises(ValueError, match=r"mapped allocator 'outer'"):
+            _substitute_permute_ref("outer[0:2]", mapping)
+        with pytest.raises(ValueError, match=r"mapped allocator 'outer'"):
+            _sub_permute_ref("outer[0:2]", mapping)
+
+        # Unrelated unparseable ref (not in mapping) passes through unchanged.
+        assert _substitute_permute_ref("other[0:2]", mapping) == "other[0:2]"
+        assert _sub_permute_ref("other[0:2]", mapping) == "other[0:2]"
+
+
+class TestSlrBlockInputsWiring:
+    """Phase 3a.1: an SLR Block with class-level `block_inputs` lowers to BlockDecl/BlockCall."""
+
+    def test_slr_block_with_inputs_emits_block_decl_and_call(self) -> None:
+        """slr_to_ast on a Main containing a Block with `block_inputs` produces a BlockDecl + BlockCall."""
+        from pecos.slr import CReg, Main, QReg
+        from pecos.slr.ast import slr_to_ast
+        from pecos.slr.block import Block
+        from pecos.slr.qeclib import qubit as qb
+        from pecos.slr.qeclib.qubit.measures import Measure
+
+        class BellBlock(Block):
+            block_inputs: ClassVar[dict[str, str]] = {"q": "live_preserved"}
+
+            def __init__(self, q: QReg) -> None:
+                super().__init__()
+                self.q = q
+                self.extend(qb.H(q[0]), qb.CX(q[0], q[1]))
+
+        prog = Main(
+            outer_q := QReg("outer_q", 2),
+            c := CReg("c", 2),
+            qb.Prep(outer_q),
+            BellBlock(outer_q),
+            Measure(outer_q) > c,
+        )
+        ast = slr_to_ast(prog)
+
+        assert len(ast.block_decls) == 1
+        decl = ast.block_decls[0]
+        assert decl.name.startswith("bellblock_")
+        assert len(decl.inputs) == 1
+        assert decl.inputs[0].name == "q"
+        assert decl.inputs[0].effect is ResourceEffect.LIVE_PRESERVED
+        # Body uses the parameter name "q" not the outer-scope name "outer_q":
+        assert isinstance(decl.body[0], GateOp)
+        assert decl.body[0].targets[0].allocator == "q"
+
+        # One BlockCall in the Main body referencing the decl with the outer scope name:
+        calls = [s for s in ast.body if isinstance(s, BlockCall)]
+        assert len(calls) == 1
+        assert calls[0].callee == decl.name
+        assert calls[0].arg_bindings == ("outer_q",)
+        assert calls[0].out_bindings == ("outer_q",)
+
+    def test_slr_block_inputs_end_to_end_selene_bell_correlation(self) -> None:
+        """SLR Block with block_inputs -> AST -> Guppy -> Hugr -> Selene: Bell-state correlation."""
+        import warnings
+
+        from pecos import Hugr, selene_engine, sim
+        from pecos.slr import CReg, Main, QReg, SlrConverter
+        from pecos.slr.block import Block
+        from pecos.slr.qeclib import qubit as qb
+        from pecos.slr.qeclib.qubit.measures import Measure
+
+        class BellBlock(Block):
+            block_inputs: ClassVar[dict[str, str]] = {"q": "live_preserved"}
+
+            def __init__(self, q: QReg) -> None:
+                super().__init__()
+                self.q = q
+                self.extend(qb.H(q[0]), qb.CX(q[0], q[1]))
+
+        prog = Main(
+            outer_q := QReg("outer_q", 2),
+            c := CReg("c", 2),
+            qb.Prep(outer_q),
+            BellBlock(outer_q),
+            Measure(outer_q) > c,
+        )
+
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", DeprecationWarning)
+            package = SlrConverter(prog).hugr()
+            hugr_bytes = package.to_str().encode("utf-8")
+            result = sim(Hugr(hugr_bytes)).classical(selene_engine()).qubits(2).seed(42).run(8)
+        raw = result.to_dict() if hasattr(result, "to_dict") else result
+        m0 = raw["measurement_0"]
+        m1 = raw["measurement_1"]
+        for shot, (a, b) in enumerate(zip(m0, m1, strict=True)):
+            assert a == b, f"Bell correlation violated at shot {shot}: m0={a} m1={b}"
+        assert set(m0) == {0, 1}, f"expected both outcomes across 8 shots, got {set(m0)}"
+
+
+class TestBlockCallSelene:
+    """End-to-end Selene roundtrip: the BlockCall must actually run."""
+
+    def test_bell_block_call_produces_correlated_outcomes(self) -> None:
+        """After BlockCall to bell, outer_q is still LIVE; Measure shows |00>/|11>."""
+        import importlib.util
+        import sys
+        import tempfile
+        import warnings
+        from pathlib import Path
+
+        from pecos import Hugr, selene_engine, sim
+        from pecos.slr.ast.codegen.entry_wrapper import build_no_arg_entry_wrapper
+
+        program = _bell_program()
+        main_source = ast_to_guppy(program)
+        entry_source, _info = build_no_arg_entry_wrapper(program)
+        full_source = main_source + entry_source
+
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+            path = Path(f.name)
+            f.write(full_source)
+
+        spec = importlib.util.spec_from_file_location(f"_bell_smoke_{path.stem}", path)
+        assert spec is not None
+        assert spec.loader is not None
+        module = importlib.util.module_from_spec(spec)
+        sys.modules[spec.name] = module
+        try:
+            spec.loader.exec_module(module)
+        except BaseException as exc:
+            err = f"Generated Guppy failed to import:\n{full_source}\n---\n{exc}"
+            raise AssertionError(err) from exc
+
+        package = module.entry.compile()
+        hugr_bytes = package.to_str().encode("utf-8")
+
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", DeprecationWarning)
+            result = sim(Hugr(hugr_bytes)).classical(selene_engine()).qubits(2).seed(42).run(8)
+        raw = result.to_dict() if hasattr(result, "to_dict") else result
+        assert isinstance(raw, dict)
+        m0 = raw["measurement_0"]
+        m1 = raw["measurement_1"]
+        assert len(m0) == 8
+        assert len(m1) == 8
+        # Bell-state correlation: every shot should have m0 == m1.
+        for shot, (a, b) in enumerate(zip(m0, m1, strict=True)):
+            assert a == b, f"Bell correlation violated at shot {shot}: m0={a} m1={b}"
+        # And there's at least one 0 and one 1 across 8 shots (sanity: not always 0).
+        assert set(m0) == {0, 1}, f"expected both outcomes across 8 shots, got {set(m0)}"
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qeclib_selene_corpus.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qeclib_selene_corpus.py
new file mode 100644
index 000000000..bc0995056
--- /dev/null
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qeclib_selene_corpus.py
@@ -0,0 +1,304 @@
+# Copyright 2026 The PECOS Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations under the License.
+
+"""qeclib Selene roundtrip corpus (Phase 3a.0 + 3a.3 byte-identity safety net).
+
+Per `~/Repos/pecos-docs/design/slr/v2-blockcall-resource-effects.md`, this
+corpus pins per-shot measurement records under fixed seed for each tracked
+qeclib Block class. Each entry was first pinned **pre-conversion** (when
+the Block was still flattened) and remained byte-identical **post-conversion**
+(once `block_inputs` was declared and the SLR converter began emitting
+BlockDecl + BlockCall).
+
+When a Phase 3a.3 iteration converts a new Block, the workflow is:
+1. Pin its Selene record here against today's flattened compile.
+2. Add `block_inputs` to the Block class.
+3. Re-run this corpus; identical records prove behavior preservation.
+
+Empirical records were probed on phase3a-blockcall branch on 2026-05-15.
+Steane CX/CY/CZ + Steane X/Y/Z + Steane H are converted; their entries
+now exercise the BlockCall path (parametrized lock-in in
+`test_block_call_smoke.py::TestConvertedQeclibBlocksUseBlockCallPath`).
+
+## Scope (Phase 3a.0 baseline + Phase 3a.3 iters 1-4 conversions)
+
+Pattern A Blocks only -- side-effect-only Blocks that compile under v1
+without errors. Phase 3a.1 + 3a.2 + 3a.3 iters 1-4 have landed on
+`phase3a-blockcall`; the Steane Block rows below now exercise the
+real BlockCall lowering path.
+
+Pattern B Blocks (Steane preps, surface_std_pz, color488 syn
+extraction) currently fail v1 compile and are v2-defer-XFAIL in the
+audit manifest; they'll join this corpus in later Phase 3a.3
+iterations once the shape-gap expansions (single-qubit input,
+single-bit input with write-back, list[Qubit] bundles,
+PRODUCED/DROPPED effects) land.
+
+## Tracked Blocks
+
+| Block | qeclib path | Effect classification (tentative) |
+|---|---|---|
+| `Check` | qeclib/generic/check.py | data: live_preserved; ancilla: consumed; out: live_preserved |
+| `Check1Flag` | qeclib/generic/check_1flag.py | live_preserved data; consumed ancilla/flag; live_preserved out/flag |
+| `transversal_tq` (CX) | qeclib/generic/transversal.py | both registers: live_preserved (no internal measurements) |
+| Steane CX/CY/CZ | qeclib/steane/gates_tq/transversal_tq.py | both registers: live_preserved (converted iters 1+2) |
+| Steane X/Y/Z | qeclib/steane/gates_sq/paulis.py | single register: live_preserved (converted iter 3) |
+| Steane H | qeclib/steane/gates_sq/hadamards.py | single register: live_preserved (converted iter 4) |
+
+The audit log lives in
+`~/Repos/pecos-docs/design/slr/v2-blockcall-resource-effects.md`.
+"""
+
+from __future__ import annotations
+
+import warnings
+
+from pecos import Hugr, selene_engine, sim
+from pecos.slr import CReg, Main, QReg, SlrConverter
+from pecos.slr.qeclib import qubit as qb
+from pecos.slr.qeclib.generic.check import Check
+from pecos.slr.qeclib.generic.check_1flag import Check1Flag
+from pecos.slr.qeclib.generic.transversal import transversal_tq
+from pecos.slr.qeclib.qubit.measures import Measure
+from pecos.slr.qeclib.steane.gates_sq import hadamards as steane_h
+from pecos.slr.qeclib.steane.gates_sq import paulis as steane_paulis
+from pecos.slr.qeclib.steane.gates_tq import transversal_tq as steane_tq
+
+
+def _run_via_selene(prog: Main, *, shots: int = 4, seed: int = 42, qubits: int) -> dict:
+    """Compile prog through SlrConverter.hugr() and run through Selene.
+
+    Suppresses Phase 2 implicit-return DeprecationWarning during the
+    roundtrip; the corpus targets the current v1 implicit-return behavior
+    deliberately. When Phase 3b makes the breaking change, this helper
+    plus the assertions below will be updated together.
+    """
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", DeprecationWarning)
+        package = SlrConverter(prog).hugr()
+        hugr_bytes = package.to_str().encode("utf-8")
+        result = sim(Hugr(hugr_bytes)).classical(selene_engine()).qubits(qubits).seed(seed).run(shots)
+    raw = result.to_dict() if hasattr(result, "to_dict") else result
+    assert isinstance(raw, dict)
+    return raw
+
+
+class TestQeclibCheck:
+    """Pin Selene records for `qeclib.generic.check.Check` (Pattern A)."""
+
+    def test_check_xyz_on_zero_state_pinned_records(self) -> None:
+        """Check([q[0], q[1], q[2]], "XYZ", q[3], c[0]) on |000> data.
+
+        Ancilla is the only measurement target; data qubits are
+        live_preserved through the Check. Probe-pinned 4-shot records.
+        """
+        prog = Main(
+            q := QReg("q", 4),
+            c := CReg("c", 1),
+            Check([q[0], q[1], q[2]], "XYZ", q[3], c[0], with_barriers=True),
+        )
+        raw = _run_via_selene(prog, shots=4, seed=42, qubits=4)
+        # Empirical probe 2026-05-15: {'measurement_0': [1, 0, 0, 1]}
+        assert raw == {"measurement_0": [1, 0, 0, 1]}, raw
+
+    def test_check_xyz_on_plus_state_pinned_records(self) -> None:
+        """Same Check, data q[0]/q[1] put into |+> by H before the Check.
+
+        Probe-pinned 4-shot records show that the Hadamard prep doesn't
+        change the deterministic-under-fixed-seed ancilla measurement
+        record (Check internal randomness is what dominates).
+        """
+        prog = Main(
+            q := QReg("q", 4),
+            c := CReg("c", 1),
+            qb.H(q[0]),
+            qb.H(q[1]),
+            Check([q[0], q[1], q[2]], "XYZ", q[3], c[0], with_barriers=True),
+        )
+        raw = _run_via_selene(prog, shots=4, seed=42, qubits=4)
+        # Empirical probe 2026-05-15: {'measurement_0': [1, 0, 0, 1]}
+        assert raw == {"measurement_0": [1, 0, 0, 1]}, raw
+
+
+class TestQeclibCheck1Flag:
+    """Pin Selene records for `qeclib.generic.check_1flag.Check1Flag` (Pattern A)."""
+
+    def test_check_1flag_xyz_on_zero_state_pinned_records(self) -> None:
+        """Check1Flag with a flag qubit + two classical output bits.
+
+        Both ancilla (q[3]) and flag (q[4]) are consumed; data qubits and
+        the two classical bits are live_preserved.
+        """
+        prog = Main(
+            q := QReg("q", 5),
+            c := CReg("c", 2),
+            Check1Flag([q[0], q[1], q[2]], "XYZ", q[3], q[4], c[0], c[1], with_barriers=True),
+        )
+        raw = _run_via_selene(prog, shots=4, seed=42, qubits=5)
+        # Empirical probe 2026-05-15:
+        # {'measurement_0': [1, 0, 0, 1], 'measurement_1': [0, 0, 0, 0]}
+        assert raw == {
+            "measurement_0": [1, 0, 0, 1],
+            "measurement_1": [0, 0, 0, 0],
+        }, raw
+
+
+class TestQeclibTransversalCX:
+    """Pin Selene records for `qeclib.generic.transversal.transversal_tq` (Pattern A).
+
+    transversal_tq applies a 2-qubit gate (CX here) elementwise across two
+    QRegs. No internal measurements -- it's pure live_preserved on both
+    input registers, with classical output coming from the trailing
+    explicit Measure(a) / Measure(b) at Main scope.
+    """
+
+    def test_transversal_cx_propagates_x_pinned_records(self) -> None:
+        """X on a[0] and a[2], then transversal CX(a, b) -> b[0] and b[2] flip."""
+        prog = Main(
+            a := QReg("a", 3),
+            b := QReg("b", 3),
+            c := CReg("c", 6),
+            qb.X(a[0]),
+            qb.X(a[2]),
+            transversal_tq(qb.CX, a, b),
+            Measure(a) > c[0:3],
+            Measure(b) > c[3:6],
+        )
+        raw = _run_via_selene(prog, shots=4, seed=42, qubits=6)
+        # Empirical probe 2026-05-15: each measurement_N has 4 identical shots
+        # because gates are deterministic (no H anywhere).
+        assert raw == {
+            "measurement_0": [1, 1, 1, 1],  # a[0]: X -> measured 1
+            "measurement_1": [0, 0, 0, 0],  # a[1]: untouched -> 0
+            "measurement_2": [1, 1, 1, 1],  # a[2]: X -> measured 1
+            "measurement_3": [1, 1, 1, 1],  # b[0]: flipped by CX from a[0]=1
+            "measurement_4": [0, 0, 0, 0],  # b[1]: CX from a[1]=0
+            "measurement_5": [1, 1, 1, 1],  # b[2]: flipped by CX from a[2]=1
+        }, raw
+
+    def test_transversal_cx_pure_zero_pinned_records(self) -> None:
+        """transversal CX on |000>|000> -> all zeros (CX from 0 is identity)."""
+        prog = Main(
+            a := QReg("a", 3),
+            b := QReg("b", 3),
+            c := CReg("c", 6),
+            transversal_tq(qb.CX, a, b),
+            Measure(a) > c[0:3],
+            Measure(b) > c[3:6],
+        )
+        raw = _run_via_selene(prog, shots=4, seed=42, qubits=6)
+        # Empirical probe 2026-05-15: |000>|000> through CX stays |000>|000>;
+        # all 6 measurements are [0, 0, 0, 0] across 4 shots.
+        assert raw == {f"measurement_{i}": [0, 0, 0, 0] for i in range(6)}, raw
+
+
+class TestQeclibSteaneTransversalCX:
+    """Pin Selene records for `qeclib.steane.gates_tq.transversal_tq.CX` (Pattern A).
+
+    Steane logical CX is a transversal pairwise CX between two 7-qubit registers
+    (the two logical Steane patches). Both registers are live_preserved (no internal
+    measurements). Phase 3a.3 conversion adds `block_inputs={"q1": "live_preserved",
+    "q2": "live_preserved"}` and these pinned records must remain byte-identical.
+    """
+
+    def _x_all_then_gate_then_measure(self, gate_class: type) -> Main:
+        """Helper: a=|1>^7 (X on each), apply two-register gate, measure both registers."""
+        return Main(
+            a := QReg("a", 7),
+            b := QReg("b", 7),
+            c := CReg("c", 14),
+            qb.X(a[0]),
+            qb.X(a[1]),
+            qb.X(a[2]),
+            qb.X(a[3]),
+            qb.X(a[4]),
+            qb.X(a[5]),
+            qb.X(a[6]),
+            gate_class(a, b),
+            Measure(a) > c[0:7],
+            Measure(b) > c[7:14],
+        )
+
+    def test_steane_cx_all_ones_to_zero_propagates_pinned_records(self) -> None:
+        """a in |1>^7 (each X applied), b in |0>^7; Steane CX should flip b to |1>^7."""
+        raw = _run_via_selene(self._x_all_then_gate_then_measure(steane_tq.CX), shots=4, seed=42, qubits=14)
+        # Empirical probe 2026-05-15: all 14 measurements are [1, 1, 1, 1] across 4 shots.
+        # a stays |1>^7 (X is preserved through Steane CX); b becomes |1>^7 from CX propagation.
+        assert raw == {f"measurement_{i}": [1, 1, 1, 1] for i in range(14)}, raw
+
+    def test_steane_cy_all_ones_to_zero_propagates_pinned_records(self) -> None:
+        """Steane CY also propagates X (since Y = iXZ; X-stab passes through both factors)."""
+        raw = _run_via_selene(self._x_all_then_gate_then_measure(steane_tq.CY), shots=4, seed=42, qubits=14)
+        # Empirical probe 2026-05-15: same |1>^14 pattern as Steane CX.
+        assert raw == {f"measurement_{i}": [1, 1, 1, 1] for i in range(14)}, raw
+
+    def test_steane_cz_x_on_control_only_phase_propagates_pinned_records(self) -> None:
+        """Steane CZ propagates phase, not bit-flips: a stays |1>^7, b stays |0>^7."""
+        raw = _run_via_selene(self._x_all_then_gate_then_measure(steane_tq.CZ), shots=4, seed=42, qubits=14)
+        # Empirical probe 2026-05-15: a's 7 qubits measure 1 (X preserved), b's 7 measure 0
+        # (CZ doesn't propagate Z stabilizer to the standard basis measurement).
+        expected: dict[str, list[int]] = {f"measurement_{i}": [1, 1, 1, 1] for i in range(7)}
+        expected.update({f"measurement_{i}": [0, 0, 0, 0] for i in range(7, 14)})
+        assert raw == expected, raw
+
+
+class TestQeclibSteaneLogicalPaulis:
+    """Pin Selene records for `qeclib.steane.gates_sq.paulis.{X,Y,Z}` (Pattern A).
+
+    Steane logical X/Y/Z apply the gate transversally on a subset of physical qubits
+    (q[4], q[5], q[6]) for the 7-qubit code. Single-input live_preserved blocks.
+    """
+
+    def _gate_then_measure(self, gate_class: type) -> Main:
+        return Main(
+            q := QReg("q", 7),
+            c := CReg("c", 7),
+            gate_class(q),
+            Measure(q) > c,
+        )
+
+    def test_steane_logical_x_on_zero_pinned_records(self) -> None:
+        """Steane X applies X to q[4..6]; q[0..3] stay |0>, q[4..6] become |1>."""
+        raw = _run_via_selene(self._gate_then_measure(steane_paulis.X), shots=4, seed=42, qubits=7)
+        # Empirical probe 2026-05-15:
+        expected: dict[str, list[int]] = {f"measurement_{i}": [0, 0, 0, 0] for i in range(4)}
+        expected.update({f"measurement_{i}": [1, 1, 1, 1] for i in range(4, 7)})
+        assert raw == expected, raw
+
+    def test_steane_logical_y_on_zero_pinned_records(self) -> None:
+        """Steane Y applies Y to q[4..6]; in Z-basis measurement outcomes match Steane X."""
+        raw = _run_via_selene(self._gate_then_measure(steane_paulis.Y), shots=4, seed=42, qubits=7)
+        # Empirical probe 2026-05-15: q[0..3] stay 0, q[4..6] become 1 (same as X
+        # because Y|0> = i|1>; Z-basis ignores the global phase).
+        expected: dict[str, list[int]] = {f"measurement_{i}": [0, 0, 0, 0] for i in range(4)}
+        expected.update({f"measurement_{i}": [1, 1, 1, 1] for i in range(4, 7)})
+        assert raw == expected, raw
+
+    def test_steane_logical_z_on_zero_pinned_records(self) -> None:
+        """Steane Z applies Z to q[4..6]; phase only, all measure 0 in Z-basis."""
+        raw = _run_via_selene(self._gate_then_measure(steane_paulis.Z), shots=4, seed=42, qubits=7)
+        # Empirical probe 2026-05-15: all 7 measurements are [0, 0, 0, 0] across 4
+        # shots (Z is phase-only on |0> eigenstates).
+        assert raw == {f"measurement_{i}": [0, 0, 0, 0] for i in range(7)}, raw
+
+    def test_steane_logical_h_on_zero_pinned_records(self) -> None:
+        """Steane H on |0>^7 -> |+>^7; Z-basis measurement is seeded-random per-qubit per-shot."""
+        raw = _run_via_selene(self._gate_then_measure(steane_h.H), shots=4, seed=42, qubits=7)
+        # Empirical probe 2026-05-15: pinned per-qubit, per-shot bit pattern.
+        assert raw == {
+            "measurement_0": [1, 1, 1, 0],
+            "measurement_1": [0, 1, 1, 0],
+            "measurement_2": [0, 1, 1, 1],
+            "measurement_3": [1, 0, 1, 0],
+            "measurement_4": [0, 0, 0, 0],
+            "measurement_5": [0, 0, 1, 1],
+            "measurement_6": [0, 1, 1, 1],
+        }, raw

From ec3bedb64ceb08359039240a322ed46b9ed6c402 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Fri, 15 May 2026 11:31:54 -0600
Subject: [PATCH 038/136] Phase 3a.3 iter 5a-prep: typed BlockArg sum type for
 BlockCall arg/out bindings (AllocatorArg + four shape stubs).

---
 .../src/pecos/slr/ast/__init__.py             | 21 +++--
 .../pecos/slr/ast/codegen/_block_flatten.py   | 55 ++++++++++-
 .../src/pecos/slr/ast/codegen/guppy.py        | 37 ++++++--
 .../src/pecos/slr/ast/converter.py            | 54 ++++++++++-
 .../quantum-pecos/src/pecos/slr/ast/nodes.py  | 91 +++++++++++++++++--
 .../src/pecos/slr/ast/pretty_print.py         | 29 +++++-
 .../src/pecos/slr/ast/serialize.py            | 10 ++
 .../src/pecos/slr/ast/visitor.py              | 40 +++++++-
 .../ast_guppy/test_block_call_smoke.py        | 49 +++++++---
 9 files changed, 339 insertions(+), 47 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/__init__.py b/python/quantum-pecos/src/pecos/slr/ast/__init__.py
index 6598905ef..e46fda47b 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/__init__.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/__init__.py
@@ -134,6 +134,8 @@ def visit_gate(self, node: GateOp) -> int:
 from pecos.slr.ast.compare import ast_equal, compare_ast, nodes_equal
 from pecos.slr.ast.converter import SlrToAst, slr_to_ast
 from pecos.slr.ast.nodes import (
+    # Reusable blocks
+    AllocatorArg,
     # Declarations
     AllocatorDecl,
     # Types
@@ -148,11 +150,12 @@ def visit_gate(self, node: GateOp) -> int:
     BinaryExpr,
     # Enums
     BinaryOp,
+    BitBundleArg,
     BitExpr,
     # References
     BitRef,
     BitTypeExpr,
-    # Reusable blocks
+    BlockArg,
     BlockCall,
     BlockDecl,
     BlockInput,
@@ -172,11 +175,14 @@ def visit_gate(self, node: GateOp) -> int:
     PrintOp,
     # Program
     Program,
+    QubitBundleArg,
     QubitTypeExpr,
     RegisterDecl,
     RepeatStmt,
     ResourceEffect,
     ReturnOp,
+    SingleBitArg,
+    SingleQubitArg,
     SlotRef,
     SourceLocation,
     Statement,
@@ -196,27 +202,25 @@ def visit_gate(self, node: GateOp) -> int:
 )
 
 __all__ = [
+    "AllocatorArg",
     "AllocatorDecl",
     "AllocatorTypeExpr",
     "ArrayTypeExpr",
     "AssignOp",
-    # Base
     "AstNode",
-    # Analysis
     "AstQubitStateValidator",
-    # Code generation
     "AstToGuppy",
     "AstToQasm",
-    # Visitors
     "AstVisitor",
     "BarrierOp",
     "BaseVisitor",
     "BinaryExpr",
     "BinaryOp",
+    "BitBundleArg",
     "BitExpr",
     "BitRef",
     "BitTypeExpr",
-    # Reusable blocks (Phase 3a.1)
+    "BlockArg",
     "BlockCall",
     "BlockDecl",
     "BlockInput",
@@ -244,6 +248,7 @@ def visit_gate(self, node: GateOp) -> int:
     "PrintOp",
     # Program
     "Program",
+    "QubitBundleArg",
     "QubitStateTracker",
     "QubitTypeExpr",
     "RegisterDecl",
@@ -252,9 +257,9 @@ def visit_gate(self, node: GateOp) -> int:
     "ResourceCounter",
     "ResourceEffect",
     "ReturnOp",
-    # References
+    "SingleBitArg",
+    "SingleQubitArg",
     "SlotRef",
-    # Converter
     "SlrToAst",
     "SourceLocation",
     "StateViolation",
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/_block_flatten.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/_block_flatten.py
index 52f609b59..4b718818d 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/_block_flatten.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/_block_flatten.py
@@ -28,7 +28,10 @@
 from typing import TYPE_CHECKING
 
 from pecos.slr.ast.nodes import (
+    AllocatorArg,
     BarrierOp,
+    BitBundleArg,
+    BitRef,
     BlockCall,
     ForStmt,
     GateOp,
@@ -38,7 +41,10 @@
     PermuteOp,
     PrepareOp,
     Program,
+    QubitBundleArg,
     RepeatStmt,
+    SingleBitArg,
+    SingleQubitArg,
     SlotRef,
     WhileStmt,
 )
@@ -46,7 +52,7 @@
 _PERMUTE_REF_RE = re.compile(r"([A-Za-z_]\w*)(\[\d+\])?$")
 
 if TYPE_CHECKING:
-    from pecos.slr.ast.nodes import BlockDecl, Statement
+    from pecos.slr.ast.nodes import BlockArg, BlockDecl, Statement
 
 
 def validate_unique_block_decl_names(program: Program) -> None:
@@ -155,7 +161,21 @@ def _inline_call(call: BlockCall, decls: dict[str, BlockDecl]) -> tuple[Statemen
             f"BlockDecl declares {len(decl.inputs)} inputs"
         )
         raise ValueError(msg)
-    mapping = {inp.name: arg for inp, arg in zip(decl.inputs, call.arg_bindings, strict=True)}
+    # Build a name-level mapping from BlockDecl input parameter names to the outer
+    # binding name. Only AllocatorArg is supported in the iter 5a flatten path;
+    # richer args (single qubit/bit, bundles) need full slot-level rewriting
+    # which lands with their respective flatten support iterations.
+    mapping: dict[str, str] = {}
+    for inp, arg in zip(decl.inputs, call.arg_bindings, strict=True):
+        if isinstance(arg, AllocatorArg):
+            mapping[inp.name] = arg.name
+        else:
+            msg = (
+                f"Flatten pass does not yet support BlockArg {type(arg).__name__} for "
+                f"input {inp.name!r} of {call.callee!r}; only AllocatorArg is supported "
+                "in Phase 3a.3 iter 5a"
+            )
+            raise NotImplementedError(msg)
     return tuple(_substitute(stmt, mapping) for stmt in decl.body)
 
 
@@ -227,14 +247,41 @@ def _substitute(stmt: Statement, mapping: dict[str, str]) -> Statement:
         # input parameter names. Codex 2026-05-15 review #1.
         return BlockCall(
             callee=stmt.callee,
-            arg_bindings=tuple(mapping.get(a, a) for a in stmt.arg_bindings),
-            out_bindings=tuple(mapping.get(a, a) for a in stmt.out_bindings),
+            arg_bindings=tuple(_sub_block_arg(a, mapping) for a in stmt.arg_bindings),
+            out_bindings=tuple(_sub_block_arg(a, mapping) for a in stmt.out_bindings),
             location=stmt.location,
         )
     # Pass through statements that don't reference slot allocators directly.
     return stmt
 
 
+def _sub_block_arg(arg: BlockArg, mapping: dict[str, str]) -> BlockArg:
+    """Rewrite a BlockArg's referenced names per the mapping (for nested calls)."""
+    if isinstance(arg, AllocatorArg):
+        return AllocatorArg(name=mapping.get(arg.name, arg.name), location=arg.location)
+    if isinstance(arg, SingleQubitArg):
+        return SingleQubitArg(slot=_sub_slot(arg.slot, mapping), location=arg.location)
+    if isinstance(arg, SingleBitArg):
+        return SingleBitArg(bit=_sub_bit_ref(arg.bit, mapping), location=arg.location)
+    if isinstance(arg, QubitBundleArg):
+        return QubitBundleArg(
+            slots=tuple(_sub_slot(s, mapping) for s in arg.slots),
+            location=arg.location,
+        )
+    if isinstance(arg, BitBundleArg):
+        return BitBundleArg(
+            bits=tuple(_sub_bit_ref(b, mapping) for b in arg.bits),
+            location=arg.location,
+        )
+    return arg
+
+
+def _sub_bit_ref(ref: BitRef, mapping: dict[str, str]) -> BitRef:
+    if ref.register not in mapping:
+        return ref
+    return BitRef(register=mapping[ref.register], index=ref.index, location=ref.location)
+
+
 def _sub_permute_ref(ref: str, mapping: dict[str, str]) -> str:
     """Rewrite PermuteOp source/target strings of the form `name` or `name[idx]`.
 
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
index 4c2a35ff4..e433618d8 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
@@ -31,6 +31,7 @@
     SlotState,
 )
 from pecos.slr.ast.nodes import (
+    AllocatorArg,
     AllocatorDecl,
     ArrayTypeExpr,
     BinaryExpr,
@@ -878,10 +879,21 @@ def _emit_block_call(self, node: BlockCall) -> list[str]:
         # Phase 1: validate every arg + out binding BEFORE touching linearity state, so
         # a late-raised GuppyCodegenError can't leave the tracker half-consumed (Codex
         # 2026-05-15 review).
+        # Phase 3a.3 iter 5a: arg_bindings are typed BlockArg now. This emitter
+        # currently only supports AllocatorArg (whole-allocator binding); richer
+        # arg shapes (SingleQubitArg/SingleBitArg/QubitBundleArg/BitBundleArg) land
+        # with their respective Phase 3a.3 iterations.
         validated_args: list[tuple[BlockInput, str, int]] = []
         live_inputs_out: list[BlockInput] = []
-        for inp, arg_name in zip(decl.inputs, node.arg_bindings, strict=True):
-            # _validate_block_decl guarantees type_expr is ArrayTypeExpr[QubitTypeExpr].
+        for inp, arg in zip(decl.inputs, node.arg_bindings, strict=True):
+            if not isinstance(arg, AllocatorArg):
+                msg = (
+                    f"BlockCall {node.callee!r} arg for input {inp.name!r}: only "
+                    f"AllocatorArg is supported in Phase 3a.3 iter 5a (got "
+                    f"{type(arg).__name__})"
+                )
+                raise GuppyCodegenError(msg)
+            arg_name = arg.name
             input_size = cast("ArrayTypeExpr", inp.type_expr).size
             if arg_name not in self.context.root_allocators:
                 msg = (
@@ -903,13 +915,22 @@ def _emit_block_call(self, node: BlockCall) -> list[str]:
         if len(node.out_bindings) != len(live_inputs_out):
             expected = [inp.name for inp in live_inputs_out]
             msg = (
-                f"BlockCall {node.callee!r}: out_bindings {node.out_bindings} count "
-                f"does not match expected return positions {expected}"
+                f"BlockCall {node.callee!r}: out_bindings count "
+                f"({len(node.out_bindings)}) does not match expected return positions {expected}"
             )
             raise GuppyCodegenError(msg)
 
-        for out_name, inp in zip(node.out_bindings, live_inputs_out, strict=True):
-            self._require_out_binding_matches(node.callee, out_name, inp)
+        validated_outs: list[str] = []
+        for out, inp in zip(node.out_bindings, live_inputs_out, strict=True):
+            if not isinstance(out, AllocatorArg):
+                msg = (
+                    f"BlockCall {node.callee!r} out_binding for input {inp.name!r}: "
+                    f"only AllocatorArg is supported in Phase 3a.3 iter 5a (got "
+                    f"{type(out).__name__})"
+                )
+                raise GuppyCodegenError(msg)
+            self._require_out_binding_matches(node.callee, out.name, inp)
+            validated_outs.append(out.name)
 
         # Phase 2: now that every check passed, consume slots and emit code.
         linearity = self._linearity()
@@ -926,7 +947,7 @@ def _emit_block_call(self, node: BlockCall) -> list[str]:
             return lines
 
         if len(live_inputs_out) == 1:
-            out_name = node.out_bindings[0]
+            out_name = validated_outs[0]
             ret_temp = self.context.temp("call_ret")
             lines.append(f"{self.context.indent()}{ret_temp} = {call_expr}")
             lines.extend(self._unpack_return_array(out_name, ret_temp))
@@ -934,7 +955,7 @@ def _emit_block_call(self, node: BlockCall) -> list[str]:
 
         ret_temps = [self.context.temp("call_ret") for _ in live_inputs_out]
         lines.append(f"{self.context.indent()}{', '.join(ret_temps)} = {call_expr}")
-        for ret_temp, out_name in zip(ret_temps, node.out_bindings, strict=True):
+        for ret_temp, out_name in zip(ret_temps, validated_outs, strict=True):
             lines.extend(self._unpack_return_array(out_name, ret_temp))
         return lines
 
diff --git a/python/quantum-pecos/src/pecos/slr/ast/converter.py b/python/quantum-pecos/src/pecos/slr/ast/converter.py
index c5c24d518..15a3b98d6 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/converter.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/converter.py
@@ -35,12 +35,14 @@
 from typing import TYPE_CHECKING, Any
 
 from pecos.slr.ast.nodes import (
+    AllocatorArg,
     AllocatorDecl,
     ArrayTypeExpr,
     AssignOp,
     BarrierOp,
     BinaryExpr,
     BinaryOp,
+    BitBundleArg,
     BitExpr,
     BitRef,
     BitTypeExpr,
@@ -59,11 +61,14 @@
     PrepareOp,
     PrintOp,
     Program,
+    QubitBundleArg,
     QubitTypeExpr,
     RegisterDecl,
     RepeatStmt,
     ResourceEffect,
     ReturnOp,
+    SingleBitArg,
+    SingleQubitArg,
     SlotRef,
     UnaryExpr,
     UnaryOp,
@@ -73,6 +78,7 @@
 
 if TYPE_CHECKING:
     from pecos.slr.ast.nodes import (
+        BlockArg,
         Expression,
         Statement,
         TypeExpr,
@@ -456,9 +462,15 @@ def _convert_block_call(self, block: Block) -> BlockCall:
         self._block_decls.extend(sub._block_decls)
         self._block_decls.append(decl)
 
-        # Build the BlockCall referencing the outer-scope names.
-        arg_bindings = tuple(outer for _name, _eff, outer, _sz in bindings)
-        live_out = tuple(outer for _name, eff, outer, _sz in bindings if eff is ResourceEffect.LIVE_PRESERVED)
+        # Build the BlockCall referencing the outer-scope names. Whole-allocator
+        # binding is the only shape produced by SLR-side wiring today; other
+        # BlockArg shapes (SingleQubitArg, SingleBitArg, QubitBundleArg,
+        # BitBundleArg) are direct-AST constructions only until later iter 5x
+        # SLR-side support lands.
+        arg_bindings: tuple[BlockArg, ...] = tuple(AllocatorArg(name=outer) for _n, _e, outer, _s in bindings)
+        live_out: tuple[BlockArg, ...] = tuple(
+            AllocatorArg(name=outer) for _n, eff, outer, _s in bindings if eff is ResourceEffect.LIVE_PRESERVED
+        )
         return BlockCall(callee=decl_name, arg_bindings=arg_bindings, out_bindings=live_out)
 
     def _convert_gate(self, gate: Any) -> Statement:
@@ -970,8 +982,8 @@ def _substitute_stmt(stmt: Any, mapping: dict[str, str]) -> Any:
         # to use the parent Block's parameter names (Codex 2026-05-15 review #1).
         return BlockCall(
             callee=stmt.callee,
-            arg_bindings=tuple(mapping.get(a, a) for a in stmt.arg_bindings),
-            out_bindings=tuple(mapping.get(a, a) for a in stmt.out_bindings),
+            arg_bindings=tuple(_substitute_block_arg(a, mapping) for a in stmt.arg_bindings),
+            out_bindings=tuple(_substitute_block_arg(a, mapping) for a in stmt.out_bindings),
             location=stmt.location,
         )
     return stmt
@@ -983,6 +995,38 @@ def _substitute_slot(ref: SlotRef, mapping: dict[str, str]) -> SlotRef:
     return SlotRef(allocator=mapping[ref.allocator], index=ref.index, location=ref.location)
 
 
+def _substitute_bit_ref(ref: BitRef, mapping: dict[str, str]) -> BitRef:
+    if ref.register not in mapping:
+        return ref
+    return BitRef(register=mapping[ref.register], index=ref.index, location=ref.location)
+
+
+def _substitute_block_arg(arg: BlockArg, mapping: dict[str, str]) -> BlockArg:
+    """Rewrite a BlockArg through the outer -> parameter-name mapping.
+
+    Used when a parent converted Block's body contains a nested BlockCall;
+    the nested call's arg_bindings/out_bindings reference outer allocator
+    or register names that must be renamed to parent input parameter names.
+    """
+    if isinstance(arg, AllocatorArg):
+        return AllocatorArg(name=mapping.get(arg.name, arg.name), location=arg.location)
+    if isinstance(arg, SingleQubitArg):
+        return SingleQubitArg(slot=_substitute_slot(arg.slot, mapping), location=arg.location)
+    if isinstance(arg, SingleBitArg):
+        return SingleBitArg(bit=_substitute_bit_ref(arg.bit, mapping), location=arg.location)
+    if isinstance(arg, QubitBundleArg):
+        return QubitBundleArg(
+            slots=tuple(_substitute_slot(s, mapping) for s in arg.slots),
+            location=arg.location,
+        )
+    if isinstance(arg, BitBundleArg):
+        return BitBundleArg(
+            bits=tuple(_substitute_bit_ref(b, mapping) for b in arg.bits),
+            location=arg.location,
+        )
+    return arg
+
+
 _PERMUTE_REF_RE = re.compile(r"([A-Za-z_]\w*)(\[\d+\])?$")
 
 
diff --git a/python/quantum-pecos/src/pecos/slr/ast/nodes.py b/python/quantum-pecos/src/pecos/slr/ast/nodes.py
index 4dfb13eb2..562f63c10 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/nodes.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/nodes.py
@@ -706,25 +706,102 @@ def children(self) -> Sequence[AstNode]:
         return nodes
 
 
+# ---- BlockCall argument types (Phase 3a.3 iter 5a typed sum type) ----
+
+
+@dataclass(frozen=True, kw_only=True)
+class BlockArg(AstNode, ABC):
+    """Base class for `BlockCall` argument bindings.
+
+    Each BlockInput on the callee is bound to exactly one BlockArg at the
+    caller, describing what outer-scope state the input refers to.
+    """
+
+
+@dataclass(frozen=True, kw_only=True)
+class AllocatorArg(BlockArg):
+    """Whole-allocator binding: every slot of an outer-scope allocator."""
+
+    name: str
+
+    def accept(self, visitor: AstVisitor[T]) -> T:
+        return visitor.visit_allocator_arg(self)
+
+
+@dataclass(frozen=True, kw_only=True)
+class SingleQubitArg(BlockArg):
+    """Single-qubit slot binding."""
+
+    slot: SlotRef
+
+    def accept(self, visitor: AstVisitor[T]) -> T:
+        return visitor.visit_single_qubit_arg(self)
+
+    def children(self) -> Sequence[AstNode]:
+        return (self.slot,)
+
+
+@dataclass(frozen=True, kw_only=True)
+class SingleBitArg(BlockArg):
+    """Single classical-bit binding (write-back via array[bool, 1] proxy in emitter)."""
+
+    bit: BitRef
+
+    def accept(self, visitor: AstVisitor[T]) -> T:
+        return visitor.visit_single_bit_arg(self)
+
+    def children(self) -> Sequence[AstNode]:
+        return (self.bit,)
+
+
+@dataclass(frozen=True, kw_only=True)
+class QubitBundleArg(BlockArg):
+    """Non-contiguous bundle of qubit slots packed into a single array[qubit, N]."""
+
+    slots: tuple[SlotRef, ...]
+
+    def accept(self, visitor: AstVisitor[T]) -> T:
+        return visitor.visit_qubit_bundle_arg(self)
+
+    def children(self) -> Sequence[AstNode]:
+        return self.slots
+
+
+@dataclass(frozen=True, kw_only=True)
+class BitBundleArg(BlockArg):
+    """Non-contiguous bundle of classical bits packed into a single array[bool, N]."""
+
+    bits: tuple[BitRef, ...]
+
+    def accept(self, visitor: AstVisitor[T]) -> T:
+        return visitor.visit_bit_bundle_arg(self)
+
+    def children(self) -> Sequence[AstNode]:
+        return self.bits
+
+
 @dataclass(frozen=True, kw_only=True)
 class BlockCall(Statement):
     """Invoke a `BlockDecl` from the outer scope.
 
-    `arg_bindings` lists outer-scope binding names in the same order as the
-    callee's declared inputs (one per input).
-    `out_bindings` lists outer-scope names that receive the callee's outputs
-    (`live_preserved`/`produced` inputs + explicit `Return` values, in
-    declaration order then return order). Empty for callees that return
+    `arg_bindings` lists outer-scope bindings (typed `BlockArg`) in the same
+    order as the callee's declared inputs (one per input).
+    `out_bindings` lists outer-scope bindings that receive the callee's
+    outputs (`live_preserved`/`produced` inputs + explicit `Return` values,
+    in declaration order then return order). Empty for callees that return
     nothing.
     """
 
     callee: str
-    arg_bindings: tuple[str, ...]
-    out_bindings: tuple[str, ...] = ()
+    arg_bindings: tuple[BlockArg, ...]
+    out_bindings: tuple[BlockArg, ...] = ()
 
     def accept(self, visitor: AstVisitor[T]) -> T:
         return visitor.visit_block_call(self)
 
+    def children(self) -> Sequence[AstNode]:
+        return (*self.arg_bindings, *self.out_bindings)
+
 
 # =============================================================================
 # Program
diff --git a/python/quantum-pecos/src/pecos/slr/ast/pretty_print.py b/python/quantum-pecos/src/pecos/slr/ast/pretty_print.py
index a7ff68d87..6d7cf9c8e 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/pretty_print.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/pretty_print.py
@@ -50,6 +50,7 @@
         BarrierOp,
         BinaryExpr,
         BitExpr,
+        BlockArg,
         BlockCall,
         BlockDecl,
         BlockInput,
@@ -359,12 +360,36 @@ def visit_block_input(self, node: BlockInput) -> str:
 
     def visit_block_call(self, node: BlockCall) -> str:
         """Visit a BlockCall as a parenthesized invocation site."""
-        args = ", ".join(node.arg_bindings)
+        args = ", ".join(self._format_block_arg(a) for a in node.arg_bindings)
         if node.out_bindings:
-            outs = ", ".join(node.out_bindings)
+            outs = ", ".join(self._format_block_arg(a) for a in node.out_bindings)
             return f"({outs}) = BlockCall({node.callee!r}, {args})"
         return f"BlockCall({node.callee!r}, {args})"
 
+    def _format_block_arg(self, arg: BlockArg) -> str:
+        """Render a BlockArg inline (for visit_block_call)."""
+        from pecos.slr.ast.nodes import (  # noqa: PLC0415  -- subclass dispatch
+            AllocatorArg,
+            BitBundleArg,
+            QubitBundleArg,
+            SingleBitArg,
+            SingleQubitArg,
+        )
+
+        if isinstance(arg, AllocatorArg):
+            return arg.name
+        if isinstance(arg, SingleQubitArg):
+            return self.visit_slot_ref(arg.slot)
+        if isinstance(arg, SingleBitArg):
+            return self.visit_bit_ref(arg.bit)
+        if isinstance(arg, QubitBundleArg):
+            inner = ", ".join(self.visit_slot_ref(s) for s in arg.slots)
+            return f"[{inner}]"
+        if isinstance(arg, BitBundleArg):
+            inner = ", ".join(self.visit_bit_ref(b) for b in arg.bits)
+            return f"[{inner}]"
+        return repr(arg)
+
     def _format_type_expr(self, type_expr: TypeExpr) -> str:
         """Render a TypeExpr inline (BlockInput rendering uses this)."""
         if isinstance(type_expr, ArrayTypeExpr):
diff --git a/python/quantum-pecos/src/pecos/slr/ast/serialize.py b/python/quantum-pecos/src/pecos/slr/ast/serialize.py
index 00b821398..6244f9f72 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/serialize.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/serialize.py
@@ -33,6 +33,7 @@
 from typing import TYPE_CHECKING, Any
 
 from pecos.slr.ast.nodes import (
+    AllocatorArg,
     AllocatorDecl,
     AllocatorTypeExpr,
     ArrayTypeExpr,
@@ -40,6 +41,7 @@
     BarrierOp,
     BinaryExpr,
     BinaryOp,
+    BitBundleArg,
     BitExpr,
     BitRef,
     BitTypeExpr,
@@ -58,11 +60,14 @@
     PrepareOp,
     PrintOp,
     Program,
+    QubitBundleArg,
     QubitTypeExpr,
     RegisterDecl,
     RepeatStmt,
     ResourceEffect,
     ReturnOp,
+    SingleBitArg,
+    SingleQubitArg,
     SlotRef,
     SourceLocation,
     UnaryExpr,
@@ -87,9 +92,14 @@
     "BitExpr": BitExpr,
     "BitRef": BitRef,
     "BitTypeExpr": BitTypeExpr,
+    "AllocatorArg": AllocatorArg,
+    "BitBundleArg": BitBundleArg,
     "BlockCall": BlockCall,
     "BlockDecl": BlockDecl,
     "BlockInput": BlockInput,
+    "QubitBundleArg": QubitBundleArg,
+    "SingleBitArg": SingleBitArg,
+    "SingleQubitArg": SingleQubitArg,
     "CommentOp": CommentOp,
     "ForStmt": ForStmt,
     "GateOp": GateOp,
diff --git a/python/quantum-pecos/src/pecos/slr/ast/visitor.py b/python/quantum-pecos/src/pecos/slr/ast/visitor.py
index 0a727bddb..b5776008a 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/visitor.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/visitor.py
@@ -24,12 +24,14 @@
 
 if TYPE_CHECKING:
     from pecos.slr.ast.nodes import (
+        AllocatorArg,
         AllocatorDecl,
         AllocatorTypeExpr,
         ArrayTypeExpr,
         AssignOp,
         BarrierOp,
         BinaryExpr,
+        BitBundleArg,
         BitExpr,
         BitRef,
         BitTypeExpr,
@@ -47,10 +49,13 @@
         PrepareOp,
         PrintOp,
         Program,
+        QubitBundleArg,
         QubitTypeExpr,
         RegisterDecl,
         RepeatStmt,
         ReturnOp,
+        SingleBitArg,
+        SingleQubitArg,
         SlotRef,
         UnaryExpr,
         VarExpr,
@@ -101,6 +106,17 @@ def visit_block_input(self, node: BlockInput) -> T_co: ...
 
     def visit_block_call(self, node: BlockCall) -> T_co: ...
 
+    # BlockCall argument bindings (Phase 3a.3 iter 5a)
+    def visit_allocator_arg(self, node: AllocatorArg) -> T_co: ...
+
+    def visit_single_qubit_arg(self, node: SingleQubitArg) -> T_co: ...
+
+    def visit_single_bit_arg(self, node: SingleBitArg) -> T_co: ...
+
+    def visit_qubit_bundle_arg(self, node: QubitBundleArg) -> T_co: ...
+
+    def visit_bit_bundle_arg(self, node: BitBundleArg) -> T_co: ...
+
     # Control flow
     def visit_if(self, node: IfStmt) -> T_co: ...
 
@@ -229,9 +245,31 @@ def visit_block_input(self, node: BlockInput) -> T:
         results = self.visit_children(node)
         return self.combine_results(results)
 
-    def visit_block_call(self, _node: BlockCall) -> T:
+    def visit_block_call(self, node: BlockCall) -> T:
+        results = self.visit_children(node)
+        return self.combine_results(results)
+
+    # BlockCall argument bindings
+
+    def visit_allocator_arg(self, _node: AllocatorArg) -> T:
         return self.default_result()
 
+    def visit_single_qubit_arg(self, node: SingleQubitArg) -> T:
+        results = self.visit_children(node)
+        return self.combine_results(results)
+
+    def visit_single_bit_arg(self, node: SingleBitArg) -> T:
+        results = self.visit_children(node)
+        return self.combine_results(results)
+
+    def visit_qubit_bundle_arg(self, node: QubitBundleArg) -> T:
+        results = self.visit_children(node)
+        return self.combine_results(results)
+
+    def visit_bit_bundle_arg(self, node: BitBundleArg) -> T:
+        results = self.visit_children(node)
+        return self.combine_results(results)
+
     # Control flow
 
     def visit_if(self, node: IfStmt) -> T:
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
index befdb9ad1..9bb0a08c5 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
@@ -28,6 +28,7 @@
 
 import pytest
 from pecos.slr.ast import (
+    AllocatorArg,
     AllocatorDecl,
     ArrayTypeExpr,
     BitRef,
@@ -79,8 +80,8 @@ def _bell_program() -> Program:
             PrepareOp(allocator="outer_q"),
             BlockCall(
                 callee="bell",
-                arg_bindings=("outer_q",),
-                out_bindings=("outer_q",),
+                arg_bindings=(AllocatorArg(name="outer_q"),),
+                out_bindings=(AllocatorArg(name="outer_q"),),
             ),
             MeasureOp(
                 targets=(
@@ -126,7 +127,11 @@ def test_undefined_callee_rejected(self) -> None:
             name="main",
             allocator=AllocatorDecl(name="outer_q", capacity=2),
             body=(
-                BlockCall(callee="missing_block", arg_bindings=("outer_q",), out_bindings=("outer_q",)),
+                BlockCall(
+                    callee="missing_block",
+                    arg_bindings=(AllocatorArg(name="outer_q"),),
+                    out_bindings=(AllocatorArg(name="outer_q"),),
+                ),
             ),
         )
         with pytest.raises(GuppyCodegenError, match=r"undefined block 'missing_block'"):
@@ -149,7 +154,11 @@ def test_arg_count_mismatch_rejected(self) -> None:
             allocator=AllocatorDecl(name="outer_q", capacity=2),
             block_decls=(bell,),
             body=(
-                BlockCall(callee="bell", arg_bindings=("outer_q", "outer_q"), out_bindings=("outer_q",)),
+                BlockCall(
+                    callee="bell",
+                    arg_bindings=(AllocatorArg(name="outer_q"), AllocatorArg(name="outer_q")),
+                    out_bindings=(AllocatorArg(name="outer_q"),),
+                ),
             ),
         )
         with pytest.raises(GuppyCodegenError, match=r"2 arg_bindings but BlockDecl declares 1"):
@@ -218,7 +227,11 @@ def test_size_mismatch_rejected(self) -> None:
             allocator=AllocatorDecl(name="outer_q", capacity=3),
             block_decls=(bell,),
             body=(
-                BlockCall(callee="bell", arg_bindings=("outer_q",), out_bindings=("outer_q",)),
+                BlockCall(
+                    callee="bell",
+                    arg_bindings=(AllocatorArg(name="outer_q"),),
+                    out_bindings=(AllocatorArg(name="outer_q"),),
+                ),
             ),
         )
         with pytest.raises(GuppyCodegenError, match=r"size 3 does not match input 'q' size 2"):
@@ -372,7 +385,11 @@ def _build_consume_then_reuse_program(self) -> Program:
             block_decls=(consume,),
             body=(
                 PrepareOp(allocator="outer_q"),
-                BlockCall(callee="consume", arg_bindings=("outer_q",), out_bindings=()),
+                BlockCall(
+                    callee="consume",
+                    arg_bindings=(AllocatorArg(name="outer_q"),),
+                    out_bindings=(),
+                ),
                 # After the call outer_q[0] is CONSUMED; reusing it must raise.
                 MeasureOp(
                     targets=(SlotRef(allocator="outer_q", index=0),),
@@ -448,8 +465,8 @@ def test_nested_block_call_arg_bindings_substitute_to_parent_param(self) -> None
         assert len(nested_calls) == 1, nested_calls
         nested = nested_calls[0]
         assert nested.callee == inner_decl.name
-        assert nested.arg_bindings == ("q",), nested.arg_bindings
-        assert nested.out_bindings == ("q",), nested.out_bindings
+        assert nested.arg_bindings == (AllocatorArg(name="q"),), nested.arg_bindings
+        assert nested.out_bindings == (AllocatorArg(name="q"),), nested.out_bindings
 
     def test_top_level_inner_plus_outer_containing_inner_have_unique_names(self) -> None:
         """Codex review #2: same Block class top-level AND nested must not collide."""
@@ -529,7 +546,11 @@ def test_pretty_print_emits_block_decl_and_block_call(self) -> None:
             allocator=AllocatorDecl(name="outer_q", capacity=2),
             block_decls=(decl,),
             body=(
-                BlockCall(callee="bell", arg_bindings=("outer_q",), out_bindings=("outer_q",)),
+                BlockCall(
+                    callee="bell",
+                    arg_bindings=(AllocatorArg(name="outer_q"),),
+                    out_bindings=(AllocatorArg(name="outer_q"),),
+                ),
             ),
         )
         # Pre-fix this raised NotImplementedError from BaseVisitor.default_result().
@@ -591,7 +612,11 @@ def _program_with_block_decl(self) -> Program:
             allocator=AllocatorDecl(name="outer_q", capacity=1),
             block_decls=(decl,),
             body=(
-                BlockCall(callee="b", arg_bindings=("outer_q",), out_bindings=("outer_q",)),
+                BlockCall(
+                    callee="b",
+                    arg_bindings=(AllocatorArg(name="outer_q"),),
+                    out_bindings=(AllocatorArg(name="outer_q"),),
+                ),
             ),
         )
 
@@ -768,8 +793,8 @@ def __init__(self, q: QReg) -> None:
         calls = [s for s in ast.body if isinstance(s, BlockCall)]
         assert len(calls) == 1
         assert calls[0].callee == decl.name
-        assert calls[0].arg_bindings == ("outer_q",)
-        assert calls[0].out_bindings == ("outer_q",)
+        assert calls[0].arg_bindings == (AllocatorArg(name="outer_q"),)
+        assert calls[0].out_bindings == (AllocatorArg(name="outer_q"),)
 
     def test_slr_block_inputs_end_to_end_selene_bell_correlation(self) -> None:
         """SLR Block with block_inputs -> AST -> Guppy -> Hugr -> Selene: Bell-state correlation."""

From 0f71cfc23e302e1661d2c6dd4c313732628b39bd Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Fri, 15 May 2026 12:18:15 -0600
Subject: [PATCH 039/136] Fix Codex review of BlockArg refactor: flatten path
 now rejects deferred BlockArg shapes in out_bindings (symmetric with
 arg_bindings); add 4 lock-in tests across Guppy + flatten paths.

---
 .../pecos/slr/ast/codegen/_block_flatten.py   |  18 ++-
 .../ast_guppy/test_block_call_smoke.py        | 122 ++++++++++++++++++
 2 files changed, 138 insertions(+), 2 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/_block_flatten.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/_block_flatten.py
index 4b718818d..bdae40cdc 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/_block_flatten.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/_block_flatten.py
@@ -75,8 +75,9 @@ def flatten_block_calls(program: Program) -> Program:
     """Return a new Program with every BlockCall inlined and no BlockDecls left.
 
     The substitution rule maps each `BlockDecl` input parameter name to the
-    `BlockCall.arg_bindings` outer-scope allocator name throughout the body.
-    Quantum-only in Phase 3a.1.
+    typed `BlockCall.arg_bindings` BlockArg. In Phase 3a.3 iter 5a only
+    `AllocatorArg` is supported; richer BlockArg shapes raise
+    `NotImplementedError`. Quantum-only in Phase 3a.1.
     """
     if not program.block_decls:
         return program
@@ -176,6 +177,19 @@ def _inline_call(call: BlockCall, decls: dict[str, BlockDecl]) -> tuple[Statemen
                 "in Phase 3a.3 iter 5a"
             )
             raise NotImplementedError(msg)
+    # Symmetric out_bindings validation: silently allowing a deferred BlockArg
+    # subclass here would yield byte-identical flatten output (since
+    # out_bindings don't affect the inlined body in iter 5a) but would mask the
+    # fact that the caller used an unsupported shape -- a silent-fallback class
+    # of bug (Codex 2026-05-15 review of fix-pass-5).
+    for out in call.out_bindings:
+        if not isinstance(out, AllocatorArg):
+            msg = (
+                f"Flatten pass does not yet support BlockArg {type(out).__name__} in "
+                f"out_bindings of {call.callee!r}; only AllocatorArg is supported in "
+                "Phase 3a.3 iter 5a"
+            )
+            raise NotImplementedError(msg)
     return tuple(_substitute(stmt, mapping) for stmt in decl.body)
 
 
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
index 9bb0a08c5..a20568a04 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
@@ -642,6 +642,128 @@ def test_rotation_merging_pass_preserves_block_decls(self) -> None:
         assert result.program.block_decls == prog.block_decls
 
 
+class TestDeferredBlockArgRejection:
+    """Phase 3a.3 iter 5a scope: only `AllocatorArg` is supported by the
+    emitter / flatten paths. The four deferred BlockArg subclasses
+    (`SingleQubitArg`, `SingleBitArg`, `QubitBundleArg`, `BitBundleArg`) MUST
+    raise cleanly in BOTH the Guppy emitter AND the non-Guppy flatten pass --
+    silently inlining a deferred shape would mask user errors (Codex
+    2026-05-15 fix-pass-5 review caught this on `out_bindings`).
+    """
+
+    def _program_with_deferred_arg(self, *, deferred_in_args: bool, arg_subclass: type) -> Program:
+        from pecos.slr.ast.nodes import (
+            BitBundleArg,
+            BitRef,
+            QubitBundleArg,
+            SingleBitArg,
+            SingleQubitArg,
+            SlotRef,
+        )
+
+        # Build a representative instance of the deferred subclass.
+        if arg_subclass is SingleQubitArg:
+            deferred = SingleQubitArg(slot=SlotRef(allocator="outer_q", index=0))
+        elif arg_subclass is SingleBitArg:
+            deferred = SingleBitArg(bit=BitRef(register="c", index=0))
+        elif arg_subclass is QubitBundleArg:
+            deferred = QubitBundleArg(slots=(SlotRef(allocator="outer_q", index=0),))
+        elif arg_subclass is BitBundleArg:
+            deferred = BitBundleArg(bits=(BitRef(register="c", index=0),))
+        else:
+            msg = f"unsupported subclass {arg_subclass}"
+            raise AssertionError(msg)
+
+        decl = BlockDecl(
+            name="b",
+            inputs=(
+                BlockInput(
+                    name="q",
+                    effect=ResourceEffect.LIVE_PRESERVED,
+                    type_expr=ArrayTypeExpr(element=QubitTypeExpr(), size=1),
+                ),
+            ),
+            body=(GateOp(gate=GateKind.H, targets=(SlotRef(allocator="q", index=0),)),),
+        )
+        if deferred_in_args:
+            call = BlockCall(
+                callee="b",
+                arg_bindings=(deferred,),
+                out_bindings=(AllocatorArg(name="outer_q"),),
+            )
+        else:
+            call = BlockCall(
+                callee="b",
+                arg_bindings=(AllocatorArg(name="outer_q"),),
+                out_bindings=(deferred,),
+            )
+        return Program(
+            name="main",
+            allocator=AllocatorDecl(name="outer_q", capacity=1),
+            declarations=(RegisterDecl(name="c", size=1),),
+            block_decls=(decl,),
+            body=(call,),
+        )
+
+    def test_deferred_arg_bindings_raise_in_flatten(self) -> None:
+        from pecos.slr.ast.codegen._block_flatten import flatten_block_calls
+        from pecos.slr.ast.nodes import (
+            BitBundleArg,
+            QubitBundleArg,
+            SingleBitArg,
+            SingleQubitArg,
+        )
+
+        for subclass in (SingleQubitArg, SingleBitArg, QubitBundleArg, BitBundleArg):
+            prog = self._program_with_deferred_arg(deferred_in_args=True, arg_subclass=subclass)
+            with pytest.raises(NotImplementedError, match=subclass.__name__):
+                flatten_block_calls(prog)
+
+    def test_deferred_out_bindings_raise_in_flatten(self) -> None:
+        """Codex 2026-05-15 fix-pass-5 review caught: out_bindings used to be
+        silently accepted by `_inline_call` even when they were a deferred
+        BlockArg shape, while Guppy correctly rejected them.
+        """
+        from pecos.slr.ast.codegen._block_flatten import flatten_block_calls
+        from pecos.slr.ast.nodes import (
+            BitBundleArg,
+            QubitBundleArg,
+            SingleBitArg,
+            SingleQubitArg,
+        )
+
+        for subclass in (SingleQubitArg, SingleBitArg, QubitBundleArg, BitBundleArg):
+            prog = self._program_with_deferred_arg(deferred_in_args=False, arg_subclass=subclass)
+            with pytest.raises(NotImplementedError, match=subclass.__name__):
+                flatten_block_calls(prog)
+
+    def test_deferred_arg_bindings_raise_in_guppy(self) -> None:
+        from pecos.slr.ast.nodes import (
+            BitBundleArg,
+            QubitBundleArg,
+            SingleBitArg,
+            SingleQubitArg,
+        )
+
+        for subclass in (SingleQubitArg, SingleBitArg, QubitBundleArg, BitBundleArg):
+            prog = self._program_with_deferred_arg(deferred_in_args=True, arg_subclass=subclass)
+            with pytest.raises(GuppyCodegenError, match=subclass.__name__):
+                ast_to_guppy(prog)
+
+    def test_deferred_out_bindings_raise_in_guppy(self) -> None:
+        from pecos.slr.ast.nodes import (
+            BitBundleArg,
+            QubitBundleArg,
+            SingleBitArg,
+            SingleQubitArg,
+        )
+
+        for subclass in (SingleQubitArg, SingleBitArg, QubitBundleArg, BitBundleArg):
+            prog = self._program_with_deferred_arg(deferred_in_args=False, arg_subclass=subclass)
+            with pytest.raises(GuppyCodegenError, match=subclass.__name__):
+                ast_to_guppy(prog)
+
+
 class TestDuplicateBlockDeclNameValidation:
     """Shared validate_unique_block_decl_names contract (Codex review #3)."""
 

From eaa7a6f15405c0dbb1bf29fdf4319b5485e21726 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Fri, 15 May 2026 12:36:25 -0600
Subject: [PATCH 040/136] Phase 3a.3 iter 5b: single-qubit BlockInput type +
 SingleQubitArg call-site shape end-to-end in Guppy emitter.

---
 .../src/pecos/slr/ast/codegen/guppy.py        | 267 +++++++++++++-----
 .../ast_guppy/test_block_call_smoke.py        | 182 ++++++++++--
 2 files changed, 359 insertions(+), 90 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
index e433618d8..083b404a4 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
@@ -53,6 +53,7 @@
     RepeatStmt,
     ResourceEffect,
     ReturnOp,
+    SingleQubitArg,
     UnaryExpr,
     UnaryOp,
     VarExpr,
@@ -225,10 +226,17 @@ def _generate_main(self, program: Program) -> list[str]:
     def _validate_block_decl(self, decl: BlockDecl) -> None:
         """Reject BlockDecl shapes that the v1 Guppy emitter cannot lower."""
         for inp in decl.inputs:
-            if not isinstance(inp.type_expr, ArrayTypeExpr) or not isinstance(inp.type_expr.element, QubitTypeExpr):
+            # Phase 3a.3 iter 5a: array[qubit, N]. Iter 5b adds single qubit
+            # (bare `QubitTypeExpr`). Later iters add single bit + bundles.
+            is_qubit = isinstance(inp.type_expr, QubitTypeExpr)
+            is_qubit_array = isinstance(inp.type_expr, ArrayTypeExpr) and isinstance(
+                inp.type_expr.element, QubitTypeExpr,
+            )
+            if not (is_qubit or is_qubit_array):
                 msg = (
-                    f"BlockDecl {decl.name!r} input {inp.name!r}: only array[qubit, N] inputs "
-                    f"are supported in Phase 3a.1 (got {type(inp.type_expr).__name__})"
+                    f"BlockDecl {decl.name!r} input {inp.name!r}: only array[qubit, N] "
+                    f"and bare qubit inputs are supported in Phase 3a.3 iter 5b "
+                    f"(got {type(inp.type_expr).__name__})"
                 )
                 raise GuppyCodegenError(msg)
             if inp.effect not in {ResourceEffect.LIVE_PRESERVED, ResourceEffect.CONSUMED}:
@@ -245,43 +253,88 @@ def _validate_block_decl(self, decl: BlockDecl) -> None:
             raise GuppyCodegenError(msg)
 
     def _generate_block_decl(self, decl: BlockDecl) -> list[str]:
-        """Emit a BlockDecl as a top-level Guppy @guppy def function."""
+        """Emit a BlockDecl as a top-level Guppy @guppy def function.
+
+        Each input is one of (Phase 3a.3 iter 5b scope):
+        - `array[qubit, N]`: parameter `name: array[qubit, N] @ owned`,
+          unpacks at entry into `name_0..name_{N-1}` slots.
+        - bare `qubit`: parameter `name: qubit @ owned`, aliased to its
+          1-slot linearity binding at entry.
+
+        Future iters add single-bit (`array[bool, 1]` proxy), bundle args,
+        and PRODUCED/DROPPED effects.
+        """
         saved_context = self.context
         self.context = GuppyContext()
-        # _validate_block_decl guarantees every type_expr is ArrayTypeExpr[QubitTypeExpr].
-        input_arrays: list[tuple[str, int]] = [
-            (inp.name, cast("ArrayTypeExpr", inp.type_expr).size) for inp in decl.inputs
-        ]
-        for name, size in input_arrays:
+        # Categorize each input as either a single qubit (size 1, not unpacked)
+        # or an array[qubit, N] (size N, unpacked at entry). `_validate_block_decl`
+        # guarantees the type_expr is one of those two shapes.
+        input_shapes: list[tuple[str, int, bool]] = []  # (name, size, is_array)
+        for inp in decl.inputs:
+            if isinstance(inp.type_expr, QubitTypeExpr):
+                input_shapes.append((inp.name, 1, False))
+            else:
+                arr = cast("ArrayTypeExpr", inp.type_expr)
+                input_shapes.append((inp.name, arr.size, True))
+        for name, size, _ in input_shapes:
             self.context.root_allocators[name] = size
         self.context.linearity = GuppyLinearityState.from_allocators(self.context.root_allocators)
 
-        live_inputs = tuple(inp for inp in decl.inputs if inp.effect is ResourceEffect.LIVE_PRESERVED)
-        live_sizes = [cast("ArrayTypeExpr", inp.type_expr).size for inp in live_inputs]
-        return_types = [f"array[qubit, {size}]" for size in live_sizes]
+        live_inputs = tuple(
+            (inp, shape)
+            for inp, shape in zip(decl.inputs, input_shapes, strict=True)
+            if inp.effect is ResourceEffect.LIVE_PRESERVED
+        )
+
+        return_types: list[str] = []
+        for _inp, (_name, size, is_array) in live_inputs:
+            return_types.append(f"array[qubit, {size}]" if is_array else "qubit")
         return_type_str = self._tuple_type(return_types)
 
-        params = ", ".join(f"{name}: array[qubit, {size}] @ owned" for name, size in input_arrays)
+        param_parts: list[str] = []
+        for name, size, is_array in input_shapes:
+            if is_array:
+                param_parts.append(f"{name}: array[qubit, {size}] @ owned")
+            else:
+                param_parts.append(f"{name}: qubit @ owned")
+        params = ", ".join(param_parts)
 
         lines: list[str] = ["@guppy", f"def {decl.name}({params}) -> {return_type_str}:"]
 
         self.context.push_indent()
         body_lines: list[str] = []
-        body_lines.extend(self._emit_entry_unpacks())
+        linearity = self._linearity()
+        # Per-input entry bindings: array inputs unpack into per-slot locals;
+        # single-qubit inputs alias the param to its single slot's linearity local.
+        for name, size, is_array in input_shapes:
+            if is_array:
+                locals_for = [binding.local for slot, binding in linearity.bindings() if slot.allocator == name]
+                lhs = ", ".join(locals_for)
+                if size == 1:
+                    lhs += ","
+                body_lines.append(f"{self.context.indent()}{lhs} = {name}")
+            else:
+                slot_local = linearity.live(Slot(name, 0))
+                body_lines.append(f"{self.context.indent()}{slot_local} = {name}")
 
         for stmt in decl.body:
             body_lines.extend(self._emit_stmt(stmt))
 
         # Auto-emit return for live_preserved inputs; consume their slots so the
-        # linearity tracker reflects ownership leaving the function.
+        # linearity tracker reflects ownership leaving the function. Single-qubit
+        # live_preserved inputs return their single slot's local directly; array
+        # inputs repack the per-slot locals into `array(...)`.
         if live_inputs:
-            arrays = [self._consume_allocator_for_return(inp.name) for inp in live_inputs]
-            if len(arrays) == 1:
-                body_lines.append(f"{self.context.indent()}return {arrays[0]}")
+            return_exprs: list[str] = []
+            for _inp, (name, _size, is_array) in live_inputs:
+                if is_array:
+                    return_exprs.append(self._consume_allocator_for_return(name))
+                else:
+                    return_exprs.append(linearity.consume(Slot(name, 0)))
+            if len(return_exprs) == 1:
+                body_lines.append(f"{self.context.indent()}return {return_exprs[0]}")
             else:
-                body_lines.append(f"{self.context.indent()}return {', '.join(arrays)}")
-        # consumed inputs must be discarded inside the body (caller's responsibility
-        # to ensure the body does so; the smoke test covers this).
+                body_lines.append(f"{self.context.indent()}return {', '.join(return_exprs)}")
         else:
             body_lines.extend(self._emit_end_cleanup())
 
@@ -857,12 +910,18 @@ def _emit_parallel(self, node: ParallelBlock) -> list[str]:
         return self._emit_block(node.body)
 
     def _emit_block_call(self, node: BlockCall) -> list[str]:
-        """Lower a BlockCall to a packed array(...) call + unpack pattern.
-
-        For each input the caller's outer-allocator locals are packed into an
-        array literal. The call's return tuple unpacks back into locals for
-        every `LIVE_PRESERVED` input. `CONSUMED` inputs leave their outer
-        slots in the CONSUMED state.
+        """Lower a BlockCall to a packed-array call + unpack pattern.
+
+        Per-input dispatch (Phase 3a.3 iter 5b scope):
+        - `array[qubit, N]` input + `AllocatorArg(name=outer)`: pack the
+          outer allocator's slots into `array(outer_0, outer_1, ...)`,
+          unpack the returned array back into the same slots.
+        - bare `qubit` input + `SingleQubitArg(slot=outer[i])`: pass the
+          outer slot's local directly (no array wrap), rebind it from the
+          returned single qubit value.
+
+        Other BlockArg subclasses (`SingleBitArg`, `QubitBundleArg`,
+        `BitBundleArg`) raise -- they land with later iterations.
         """
         decl = self._block_decls.get(node.callee)
         if decl is None:
@@ -879,36 +938,13 @@ def _emit_block_call(self, node: BlockCall) -> list[str]:
         # Phase 1: validate every arg + out binding BEFORE touching linearity state, so
         # a late-raised GuppyCodegenError can't leave the tracker half-consumed (Codex
         # 2026-05-15 review).
-        # Phase 3a.3 iter 5a: arg_bindings are typed BlockArg now. This emitter
-        # currently only supports AllocatorArg (whole-allocator binding); richer
-        # arg shapes (SingleQubitArg/SingleBitArg/QubitBundleArg/BitBundleArg) land
-        # with their respective Phase 3a.3 iterations.
-        validated_args: list[tuple[BlockInput, str, int]] = []
+        # Each validated_args entry is tagged with "array" or "single_qubit" so the
+        # Phase-2 emit step knows how to pack the call argument.
+        validated_args: list[tuple[BlockInput, str, tuple]] = []
         live_inputs_out: list[BlockInput] = []
         for inp, arg in zip(decl.inputs, node.arg_bindings, strict=True):
-            if not isinstance(arg, AllocatorArg):
-                msg = (
-                    f"BlockCall {node.callee!r} arg for input {inp.name!r}: only "
-                    f"AllocatorArg is supported in Phase 3a.3 iter 5a (got "
-                    f"{type(arg).__name__})"
-                )
-                raise GuppyCodegenError(msg)
-            arg_name = arg.name
-            input_size = cast("ArrayTypeExpr", inp.type_expr).size
-            if arg_name not in self.context.root_allocators:
-                msg = (
-                    f"BlockCall {node.callee!r} arg {arg_name!r} must be an outer root "
-                    "allocator name"
-                )
-                raise GuppyCodegenError(msg)
-            outer_size = self.context.root_allocators[arg_name]
-            if outer_size != input_size:
-                msg = (
-                    f"BlockCall {node.callee!r} arg {arg_name!r} size {outer_size} "
-                    f"does not match input {inp.name!r} size {input_size}"
-                )
-                raise GuppyCodegenError(msg)
-            validated_args.append((inp, arg_name, outer_size))
+            kind, info = self._validate_block_call_arg(node.callee, inp, arg)
+            validated_args.append((inp, kind, info))
             if inp.effect is ResourceEffect.LIVE_PRESERVED:
                 live_inputs_out.append(inp)
 
@@ -920,24 +956,25 @@ def _emit_block_call(self, node: BlockCall) -> list[str]:
             )
             raise GuppyCodegenError(msg)
 
-        validated_outs: list[str] = []
+        validated_outs: list[tuple[str, tuple]] = []
         for out, inp in zip(node.out_bindings, live_inputs_out, strict=True):
-            if not isinstance(out, AllocatorArg):
-                msg = (
-                    f"BlockCall {node.callee!r} out_binding for input {inp.name!r}: "
-                    f"only AllocatorArg is supported in Phase 3a.3 iter 5a (got "
-                    f"{type(out).__name__})"
-                )
-                raise GuppyCodegenError(msg)
-            self._require_out_binding_matches(node.callee, out.name, inp)
-            validated_outs.append(out.name)
+            kind, info = self._validate_block_call_arg(node.callee, inp, out, is_out=True)
+            validated_outs.append((kind, info))
 
         # Phase 2: now that every check passed, consume slots and emit code.
         linearity = self._linearity()
         arg_exprs: list[str] = []
-        for _inp, arg_name, outer_size in validated_args:
-            locals_ = [linearity.consume(Slot(arg_name, i)) for i in range(outer_size)]
-            arg_exprs.append(f"array({', '.join(locals_)})")
+        for _inp, kind, info in validated_args:
+            if kind == "array":
+                arg_name, outer_size = info
+                locals_ = [linearity.consume(Slot(arg_name, i)) for i in range(outer_size)]
+                arg_exprs.append(f"array({', '.join(locals_)})")
+            elif kind == "single_qubit":
+                outer_alloc, outer_index = info
+                arg_exprs.append(linearity.consume(Slot(outer_alloc, outer_index)))
+            else:
+                msg = f"Unsupported validated arg kind {kind!r}"  # pragma: no cover
+                raise GuppyCodegenError(msg)
 
         call_expr = f"{node.callee}({', '.join(arg_exprs)})"
         lines: list[str] = []
@@ -947,18 +984,104 @@ def _emit_block_call(self, node: BlockCall) -> list[str]:
             return lines
 
         if len(live_inputs_out) == 1:
-            out_name = validated_outs[0]
+            kind, info = validated_outs[0]
             ret_temp = self.context.temp("call_ret")
             lines.append(f"{self.context.indent()}{ret_temp} = {call_expr}")
-            lines.extend(self._unpack_return_array(out_name, ret_temp))
+            lines.extend(self._unpack_block_call_return(kind, info, ret_temp))
             return lines
 
         ret_temps = [self.context.temp("call_ret") for _ in live_inputs_out]
         lines.append(f"{self.context.indent()}{', '.join(ret_temps)} = {call_expr}")
-        for ret_temp, out_name in zip(ret_temps, validated_outs, strict=True):
-            lines.extend(self._unpack_return_array(out_name, ret_temp))
+        for ret_temp, (kind, info) in zip(ret_temps, validated_outs, strict=True):
+            lines.extend(self._unpack_block_call_return(kind, info, ret_temp))
         return lines
 
+    def _validate_block_call_arg(
+        self,
+        callee: str,
+        inp: BlockInput,
+        arg: object,
+        *,
+        is_out: bool = False,
+    ) -> tuple[str, tuple]:
+        """Cross-check input type and BlockArg shape; return (kind, info).
+
+        kind is "array" with info = (outer_alloc_name, outer_size), or
+        "single_qubit" with info = (outer_alloc_name, outer_index).
+        """
+        position = "out_binding" if is_out else "arg"
+        if isinstance(arg, AllocatorArg):
+            if not isinstance(inp.type_expr, ArrayTypeExpr):
+                msg = (
+                    f"BlockCall {callee!r} {position} for input {inp.name!r}: "
+                    f"AllocatorArg requires an array[qubit, N] input (got "
+                    f"{type(inp.type_expr).__name__})"
+                )
+                raise GuppyCodegenError(msg)
+            input_size = inp.type_expr.size
+            if arg.name not in self.context.root_allocators:
+                msg = (
+                    f"BlockCall {callee!r} {position} {arg.name!r} must be an outer root "
+                    "allocator name"
+                )
+                raise GuppyCodegenError(msg)
+            outer_size = self.context.root_allocators[arg.name]
+            if outer_size != input_size:
+                msg = (
+                    f"BlockCall {callee!r} {position} {arg.name!r} size {outer_size} "
+                    f"does not match input {inp.name!r} size {input_size}"
+                )
+                raise GuppyCodegenError(msg)
+            return "array", (arg.name, outer_size)
+
+        if isinstance(arg, SingleQubitArg):
+            if not isinstance(inp.type_expr, QubitTypeExpr):
+                msg = (
+                    f"BlockCall {callee!r} {position} for input {inp.name!r}: "
+                    f"SingleQubitArg requires a bare qubit input (got "
+                    f"{type(inp.type_expr).__name__})"
+                )
+                raise GuppyCodegenError(msg)
+            slot = arg.slot
+            if slot.allocator not in self.context.root_allocators:
+                msg = (
+                    f"BlockCall {callee!r} {position} for input {inp.name!r}: slot "
+                    f"{slot.allocator}[{slot.index}] references an unknown outer allocator"
+                )
+                raise GuppyCodegenError(msg)
+            outer_size = self.context.root_allocators[slot.allocator]
+            if not (0 <= slot.index < outer_size):
+                msg = (
+                    f"BlockCall {callee!r} {position} for input {inp.name!r}: slot "
+                    f"index {slot.index} out of bounds for allocator "
+                    f"{slot.allocator!r} of size {outer_size}"
+                )
+                raise GuppyCodegenError(msg)
+            return "single_qubit", (slot.allocator, slot.index)
+
+        msg = (
+            f"BlockCall {callee!r} {position} for input {inp.name!r}: BlockArg "
+            f"{type(arg).__name__} is not yet supported in Phase 3a.3 iter 5b"
+        )
+        raise GuppyCodegenError(msg)
+
+    def _unpack_block_call_return(self, kind: str, info: tuple, ret_temp: str) -> list[str]:
+        """Unpack a single return value back into outer-scope linearity bindings."""
+        linearity = self._linearity()
+        if kind == "array":
+            out_name, _outer_size = info
+            return self._unpack_return_array(out_name, ret_temp)
+        if kind == "single_qubit":
+            outer_alloc, outer_index = info
+            # Bind the returned qubit to a fresh local that the linearity tracker
+            # treats as the new owner of the outer slot. Uses the standard
+            # `{allocator}_{index}` naming so subsequent gates resolve cleanly.
+            new_local = f"{outer_alloc}_{outer_index}"
+            linearity.set_live(Slot(outer_alloc, outer_index), new_local)
+            return [f"{self.context.indent()}{new_local} = {ret_temp}"]
+        msg = f"Unsupported return kind {kind!r}"  # pragma: no cover
+        raise GuppyCodegenError(msg)
+
     def _require_out_binding_matches(self, callee: str, out_name: str, inp: BlockInput) -> None:
         # _validate_block_decl guarantees type_expr is ArrayTypeExpr[QubitTypeExpr].
         input_size = cast("ArrayTypeExpr", inp.type_expr).size
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
index a20568a04..9abe5d574 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
@@ -207,7 +207,7 @@ def test_unsupported_input_type_rejected(self) -> None:
             block_decls=(bell,),
             body=(),
         )
-        with pytest.raises(GuppyCodegenError, match=r"only array\[qubit, N\] inputs"):
+        with pytest.raises(GuppyCodegenError, match=r"only array\[qubit, N\] and bare qubit inputs"):
             ast_to_guppy(prog)
 
     def test_size_mismatch_rejected(self) -> None:
@@ -642,12 +642,165 @@ def test_rotation_merging_pass_preserves_block_decls(self) -> None:
         assert result.program.block_decls == prog.block_decls
 
 
+class TestSingleQubitInputSupport:
+    """Phase 3a.3 iter 5b: single-qubit (bare `qubit`) input + `SingleQubitArg`
+    at the call site. Validator accepts `QubitTypeExpr` as a BlockInput type;
+    emitter renders `name: qubit @ owned` and passes the outer slot's local
+    directly (no array wrap); LIVE_PRESERVED rebinds the slot from the
+    returned single qubit value.
+    """
+
+    def _build_single_qubit_program(self, *, consumed: bool) -> Program:
+        from pecos.slr.ast.nodes import SingleQubitArg
+
+        effect = ResourceEffect.CONSUMED if consumed else ResourceEffect.LIVE_PRESERVED
+        body: tuple = (GateOp(gate=GateKind.H, targets=(SlotRef(allocator="q", index=0),)),)
+        if consumed:
+            # Consumed inputs must be measured / discarded inside the body.
+            body = (*body, MeasureOp(targets=(SlotRef(allocator="q", index=0),)))
+        decl = BlockDecl(
+            name="b",
+            inputs=(
+                BlockInput(name="q", effect=effect, type_expr=QubitTypeExpr()),
+            ),
+            body=body,
+        )
+        out_bindings = (
+            () if consumed else (SingleQubitArg(slot=SlotRef(allocator="outer_q", index=1)),)
+        )
+        # For LIVE_PRESERVED, measure outer_q[1] after the call (it's still live).
+        # For CONSUMED, outer_q[1] is consumed by the call; measure a different
+        # slot (outer_q[0]) so the linearity tracker stays sound.
+        trailing_measure = MeasureOp(
+            targets=(SlotRef(allocator="outer_q", index=0 if consumed else 1),),
+            results=(BitRef(register="c", index=0),),
+        )
+        return Program(
+            name="main",
+            allocator=AllocatorDecl(name="outer_q", capacity=3),
+            declarations=(RegisterDecl(name="c", size=1),),
+            block_decls=(decl,),
+            body=(
+                PrepareOp(allocator="outer_q"),
+                BlockCall(
+                    callee="b",
+                    arg_bindings=(SingleQubitArg(slot=SlotRef(allocator="outer_q", index=1)),),
+                    out_bindings=out_bindings,
+                ),
+                trailing_measure,
+            ),
+        )
+
+    def test_single_qubit_live_preserved_renders_bare_qubit_param(self) -> None:
+        source = ast_to_guppy(self._build_single_qubit_program(consumed=False))
+        # Block decl: `def b(q: qubit @ owned) -> qubit:`
+        assert re.search(r"@guppy\s*\n\s*def b\(q: qubit @ owned\) -> qubit:", source)
+        # Body: aliased entry, H on q_0, return q_0
+        assert "q_0 = q\n" in source
+        assert "q_0 = h(q_0)" in source
+        assert "return q_0" in source
+        # Call site: pass outer_q_1 directly (no array wrap)
+        assert re.search(r"_call_ret_\d+\s*=\s*b\(outer_q_1\)", source)
+        # Unpack: rebinds outer_q_1 from the returned single qubit
+        assert re.search(r"outer_q_1\s*=\s*_call_ret_\d+", source)
+
+    def test_single_qubit_consumed_no_return_type(self) -> None:
+        source = ast_to_guppy(self._build_single_qubit_program(consumed=True))
+        # No live_preserved input -> return type is None
+        assert re.search(r"@guppy\s*\n\s*def b\(q: qubit @ owned\) -> None:", source)
+        # Bare call (no ret_temp assignment) since no live outputs
+        assert re.search(r"^\s*b\(outer_q_1\)$", source, re.MULTILINE)
+
+    def test_single_qubit_arg_mismatched_input_type_rejected(self) -> None:
+        """A SingleQubitArg paired with an array[qubit, N] input must raise."""
+        from pecos.slr.ast.nodes import SingleQubitArg
+
+        decl = BlockDecl(
+            name="b",
+            inputs=(
+                BlockInput(
+                    name="q",
+                    effect=ResourceEffect.LIVE_PRESERVED,
+                    type_expr=ArrayTypeExpr(element=QubitTypeExpr(), size=2),
+                ),
+            ),
+            body=(),
+        )
+        prog = Program(
+            name="main",
+            allocator=AllocatorDecl(name="outer_q", capacity=3),
+            block_decls=(decl,),
+            body=(
+                BlockCall(
+                    callee="b",
+                    arg_bindings=(SingleQubitArg(slot=SlotRef(allocator="outer_q", index=1)),),
+                    out_bindings=(SingleQubitArg(slot=SlotRef(allocator="outer_q", index=1)),),
+                ),
+            ),
+        )
+        with pytest.raises(GuppyCodegenError, match=r"SingleQubitArg requires a bare qubit input"):
+            ast_to_guppy(prog)
+
+    def test_allocator_arg_with_single_qubit_input_rejected(self) -> None:
+        """Symmetric: AllocatorArg paired with a bare-qubit input must raise."""
+        decl = BlockDecl(
+            name="b",
+            inputs=(
+                BlockInput(
+                    name="q",
+                    effect=ResourceEffect.LIVE_PRESERVED,
+                    type_expr=QubitTypeExpr(),
+                ),
+            ),
+            body=(),
+        )
+        prog = Program(
+            name="main",
+            allocator=AllocatorDecl(name="outer_q", capacity=2),
+            block_decls=(decl,),
+            body=(
+                BlockCall(
+                    callee="b",
+                    arg_bindings=(AllocatorArg(name="outer_q"),),
+                    out_bindings=(AllocatorArg(name="outer_q"),),
+                ),
+            ),
+        )
+        with pytest.raises(GuppyCodegenError, match=r"AllocatorArg requires an array\[qubit, N\] input"):
+            ast_to_guppy(prog)
+
+    def test_single_qubit_slot_index_out_of_bounds_rejected(self) -> None:
+        from pecos.slr.ast.nodes import SingleQubitArg
+
+        decl = BlockDecl(
+            name="b",
+            inputs=(
+                BlockInput(name="q", effect=ResourceEffect.LIVE_PRESERVED, type_expr=QubitTypeExpr()),
+            ),
+            body=(),
+        )
+        prog = Program(
+            name="main",
+            allocator=AllocatorDecl(name="outer_q", capacity=2),  # only indices 0..1
+            block_decls=(decl,),
+            body=(
+                BlockCall(
+                    callee="b",
+                    arg_bindings=(SingleQubitArg(slot=SlotRef(allocator="outer_q", index=5)),),
+                    out_bindings=(SingleQubitArg(slot=SlotRef(allocator="outer_q", index=5)),),
+                ),
+            ),
+        )
+        with pytest.raises(GuppyCodegenError, match=r"slot index 5 out of bounds"):
+            ast_to_guppy(prog)
+
+
 class TestDeferredBlockArgRejection:
-    """Phase 3a.3 iter 5a scope: only `AllocatorArg` is supported by the
-    emitter / flatten paths. The four deferred BlockArg subclasses
-    (`SingleQubitArg`, `SingleBitArg`, `QubitBundleArg`, `BitBundleArg`) MUST
-    raise cleanly in BOTH the Guppy emitter AND the non-Guppy flatten pass --
-    silently inlining a deferred shape would mask user errors (Codex
+    """Phase 3a.3 iter 5b scope: `AllocatorArg` and `SingleQubitArg` are
+    supported by the emitter / flatten paths. The three remaining deferred
+    BlockArg subclasses (`SingleBitArg`, `QubitBundleArg`, `BitBundleArg`)
+    MUST raise cleanly in BOTH the Guppy emitter AND the non-Guppy flatten
+    pass -- silently inlining a deferred shape would mask user errors (Codex
     2026-05-15 fix-pass-5 review caught this on `out_bindings`).
     """
 
@@ -657,14 +810,11 @@ def _program_with_deferred_arg(self, *, deferred_in_args: bool, arg_subclass: ty
             BitRef,
             QubitBundleArg,
             SingleBitArg,
-            SingleQubitArg,
             SlotRef,
         )
 
         # Build a representative instance of the deferred subclass.
-        if arg_subclass is SingleQubitArg:
-            deferred = SingleQubitArg(slot=SlotRef(allocator="outer_q", index=0))
-        elif arg_subclass is SingleBitArg:
+        if arg_subclass is SingleBitArg:
             deferred = SingleBitArg(bit=BitRef(register="c", index=0))
         elif arg_subclass is QubitBundleArg:
             deferred = QubitBundleArg(slots=(SlotRef(allocator="outer_q", index=0),))
@@ -711,10 +861,9 @@ def test_deferred_arg_bindings_raise_in_flatten(self) -> None:
             BitBundleArg,
             QubitBundleArg,
             SingleBitArg,
-            SingleQubitArg,
         )
 
-        for subclass in (SingleQubitArg, SingleBitArg, QubitBundleArg, BitBundleArg):
+        for subclass in (SingleBitArg, QubitBundleArg, BitBundleArg):
             prog = self._program_with_deferred_arg(deferred_in_args=True, arg_subclass=subclass)
             with pytest.raises(NotImplementedError, match=subclass.__name__):
                 flatten_block_calls(prog)
@@ -729,10 +878,9 @@ def test_deferred_out_bindings_raise_in_flatten(self) -> None:
             BitBundleArg,
             QubitBundleArg,
             SingleBitArg,
-            SingleQubitArg,
         )
 
-        for subclass in (SingleQubitArg, SingleBitArg, QubitBundleArg, BitBundleArg):
+        for subclass in (SingleBitArg, QubitBundleArg, BitBundleArg):
             prog = self._program_with_deferred_arg(deferred_in_args=False, arg_subclass=subclass)
             with pytest.raises(NotImplementedError, match=subclass.__name__):
                 flatten_block_calls(prog)
@@ -742,10 +890,9 @@ def test_deferred_arg_bindings_raise_in_guppy(self) -> None:
             BitBundleArg,
             QubitBundleArg,
             SingleBitArg,
-            SingleQubitArg,
         )
 
-        for subclass in (SingleQubitArg, SingleBitArg, QubitBundleArg, BitBundleArg):
+        for subclass in (SingleBitArg, QubitBundleArg, BitBundleArg):
             prog = self._program_with_deferred_arg(deferred_in_args=True, arg_subclass=subclass)
             with pytest.raises(GuppyCodegenError, match=subclass.__name__):
                 ast_to_guppy(prog)
@@ -755,10 +902,9 @@ def test_deferred_out_bindings_raise_in_guppy(self) -> None:
             BitBundleArg,
             QubitBundleArg,
             SingleBitArg,
-            SingleQubitArg,
         )
 
-        for subclass in (SingleQubitArg, SingleBitArg, QubitBundleArg, BitBundleArg):
+        for subclass in (SingleBitArg, QubitBundleArg, BitBundleArg):
             prog = self._program_with_deferred_arg(deferred_in_args=False, arg_subclass=subclass)
             with pytest.raises(GuppyCodegenError, match=subclass.__name__):
                 ast_to_guppy(prog)

From 2455747c8f7756c3fd8b1fb7215d3118bfd57d68 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Fri, 15 May 2026 13:35:45 -0600
Subject: [PATCH 041/136] Fix Codex iter-5b review: reject mismatched arg/out
 bindings for LIVE_PRESERVED inputs (would emit invalid Guppy); add
 flatten-rejection lock-in for SingleQubitArg + clarify test docstring.

---
 .../src/pecos/slr/ast/codegen/guppy.py        |  23 +++-
 .../ast_guppy/test_block_call_smoke.py        | 105 +++++++++++++++++-
 2 files changed, 121 insertions(+), 7 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
index 083b404a4..5015661a4 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
@@ -957,8 +957,29 @@ def _emit_block_call(self, node: BlockCall) -> list[str]:
             raise GuppyCodegenError(msg)
 
         validated_outs: list[tuple[str, tuple]] = []
-        for out, inp in zip(node.out_bindings, live_inputs_out, strict=True):
+        # Build a quick lookup of (validated_args index) for each LIVE_PRESERVED input.
+        live_arg_index: dict[int, int] = {}
+        live_count = 0
+        for arg_index, inp in enumerate(decl.inputs):
+            if inp.effect is ResourceEffect.LIVE_PRESERVED:
+                live_arg_index[live_count] = arg_index
+                live_count += 1
+        for out_idx, (out, inp) in enumerate(zip(node.out_bindings, live_inputs_out, strict=True)):
             kind, info = self._validate_block_call_arg(node.callee, inp, out, is_out=True)
+            # Cross-check: a LIVE_PRESERVED input's out_binding MUST reference the same
+            # outer-scope slot/allocator as its arg_binding. Otherwise the emitter would
+            # blindly set_live() on a slot that was never consumed, producing invalid
+            # Guppy where the never-consumed slot is overwritten (Codex 2026-05-15
+            # iter-5b review).
+            arg_kind, arg_info = validated_args[live_arg_index[out_idx]][1:]
+            if (kind, info) != (arg_kind, arg_info):
+                msg = (
+                    f"BlockCall {node.callee!r}: LIVE_PRESERVED input {inp.name!r} "
+                    f"must use matching arg_binding and out_binding (same slot for "
+                    f"SingleQubitArg, same allocator name for AllocatorArg); got "
+                    f"arg={arg_kind}{arg_info} vs out={kind}{info}"
+                )
+                raise GuppyCodegenError(msg)
             validated_outs.append((kind, info))
 
         # Phase 2: now that every check passed, consume slots and emit code.
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
index 9abe5d574..45705fa39 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
@@ -769,6 +769,67 @@ def test_allocator_arg_with_single_qubit_input_rejected(self) -> None:
         with pytest.raises(GuppyCodegenError, match=r"AllocatorArg requires an array\[qubit, N\] input"):
             ast_to_guppy(prog)
 
+    def test_single_qubit_mismatched_arg_out_slot_rejected(self) -> None:
+        """Codex 2026-05-15 iter-5b review: a LIVE_PRESERVED single-qubit input
+        whose `arg_binding` and `out_binding` reference DIFFERENT outer slots
+        used to produce invalid Guppy (set_live() overwriting a never-consumed
+        slot). The emitter must reject this with a clean GuppyCodegenError.
+        """
+        from pecos.slr.ast.nodes import SingleQubitArg
+
+        decl = BlockDecl(
+            name="b",
+            inputs=(
+                BlockInput(name="q", effect=ResourceEffect.LIVE_PRESERVED, type_expr=QubitTypeExpr()),
+            ),
+            body=(),
+        )
+        prog = Program(
+            name="main",
+            allocator=AllocatorDecl(name="outer_q", capacity=3),
+            block_decls=(decl,),
+            body=(
+                BlockCall(
+                    callee="b",
+                    arg_bindings=(SingleQubitArg(slot=SlotRef(allocator="outer_q", index=1)),),
+                    out_bindings=(SingleQubitArg(slot=SlotRef(allocator="outer_q", index=2)),),
+                ),
+            ),
+        )
+        with pytest.raises(GuppyCodegenError, match=r"must use matching arg_binding and out_binding"):
+            ast_to_guppy(prog)
+
+    def test_allocator_mismatched_arg_out_name_rejected(self) -> None:
+        """Symmetric: AllocatorArg arg_binding != out_binding name for a
+        LIVE_PRESERVED input must also raise (same bug class).
+        """
+        decl = BlockDecl(
+            name="b",
+            inputs=(
+                BlockInput(
+                    name="q",
+                    effect=ResourceEffect.LIVE_PRESERVED,
+                    type_expr=ArrayTypeExpr(element=QubitTypeExpr(), size=2),
+                ),
+            ),
+            body=(),
+        )
+        prog = Program(
+            name="main",
+            allocator=AllocatorDecl(name="outer_q", capacity=2),
+            declarations=(AllocatorDecl(name="other_q", capacity=2),),
+            block_decls=(decl,),
+            body=(
+                BlockCall(
+                    callee="b",
+                    arg_bindings=(AllocatorArg(name="outer_q"),),
+                    out_bindings=(AllocatorArg(name="other_q"),),
+                ),
+            ),
+        )
+        with pytest.raises(GuppyCodegenError, match=r"must use matching arg_binding and out_binding"):
+            ast_to_guppy(prog)
+
     def test_single_qubit_slot_index_out_of_bounds_rejected(self) -> None:
         from pecos.slr.ast.nodes import SingleQubitArg
 
@@ -796,14 +857,46 @@ def test_single_qubit_slot_index_out_of_bounds_rejected(self) -> None:
 
 
 class TestDeferredBlockArgRejection:
-    """Phase 3a.3 iter 5b scope: `AllocatorArg` and `SingleQubitArg` are
-    supported by the emitter / flatten paths. The three remaining deferred
-    BlockArg subclasses (`SingleBitArg`, `QubitBundleArg`, `BitBundleArg`)
-    MUST raise cleanly in BOTH the Guppy emitter AND the non-Guppy flatten
-    pass -- silently inlining a deferred shape would mask user errors (Codex
-    2026-05-15 fix-pass-5 review caught this on `out_bindings`).
+    """Phase 3a.3 iter 5b scope:
+    - `AllocatorArg` is supported in BOTH the Guppy emitter AND the non-Guppy
+      flatten path.
+    - `SingleQubitArg` is supported in the Guppy emitter ONLY; flatten support
+      is deferred (full slot-level body rewriting needed). See
+      `test_single_qubit_arg_rejected_in_flatten_pass` below.
+    - `SingleBitArg`, `QubitBundleArg`, `BitBundleArg` MUST raise cleanly in
+      BOTH paths -- silently inlining a deferred shape would mask user errors
+      (Codex 2026-05-15 fix-pass-5 + iter-5b reviews caught this family).
     """
 
+    def test_single_qubit_arg_rejected_in_flatten_pass(self) -> None:
+        """SingleQubitArg in flatten path: deferred until full slot-level body
+        rewriting lands. Lock-in: clean NotImplementedError, no silent inline.
+        """
+        from pecos.slr.ast.codegen._block_flatten import flatten_block_calls
+        from pecos.slr.ast.nodes import SingleQubitArg
+
+        decl = BlockDecl(
+            name="b",
+            inputs=(
+                BlockInput(name="q", effect=ResourceEffect.LIVE_PRESERVED, type_expr=QubitTypeExpr()),
+            ),
+            body=(GateOp(gate=GateKind.H, targets=(SlotRef(allocator="q", index=0),)),),
+        )
+        prog = Program(
+            name="main",
+            allocator=AllocatorDecl(name="outer_q", capacity=3),
+            block_decls=(decl,),
+            body=(
+                BlockCall(
+                    callee="b",
+                    arg_bindings=(SingleQubitArg(slot=SlotRef(allocator="outer_q", index=1)),),
+                    out_bindings=(SingleQubitArg(slot=SlotRef(allocator="outer_q", index=1)),),
+                ),
+            ),
+        )
+        with pytest.raises(NotImplementedError, match=r"SingleQubitArg"):
+            flatten_block_calls(prog)
+
     def _program_with_deferred_arg(self, *, deferred_in_args: bool, arg_subclass: type) -> Program:
         from pecos.slr.ast.nodes import (
             BitBundleArg,

From b650289d7690cdf3b9a2da40d066b1f5060d2d4c Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Fri, 15 May 2026 17:58:52 -0600
Subject: [PATCH 042/136] Phase 3a.3 iter 5c: single-bit BlockInput via
 array[bool,1] write-back proxy + SingleBitArg call-site shape end-to-end in
 Guppy emitter.

---
 .../src/pecos/slr/ast/codegen/guppy.py        | 148 +++++++++---
 .../ast_guppy/test_block_call_smoke.py        | 217 +++++++++++++++---
 2 files changed, 291 insertions(+), 74 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
index 5015661a4..7935da742 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
@@ -53,6 +53,7 @@
     RepeatStmt,
     ResourceEffect,
     ReturnOp,
+    SingleBitArg,
     SingleQubitArg,
     UnaryExpr,
     UnaryOp,
@@ -226,20 +227,33 @@ def _generate_main(self, program: Program) -> list[str]:
     def _validate_block_decl(self, decl: BlockDecl) -> None:
         """Reject BlockDecl shapes that the v1 Guppy emitter cannot lower."""
         for inp in decl.inputs:
-            # Phase 3a.3 iter 5a: array[qubit, N]. Iter 5b adds single qubit
-            # (bare `QubitTypeExpr`). Later iters add single bit + bundles.
+            # Phase 3a.3 iter 5a: array[qubit, N]. Iter 5b: single qubit (bare
+            # `QubitTypeExpr`). Iter 5c: single classical bit (bare
+            # `BitTypeExpr`, lowered via an array[bool, 1] write-back proxy).
+            # Later iters add qubit/bit bundles.
             is_qubit = isinstance(inp.type_expr, QubitTypeExpr)
             is_qubit_array = isinstance(inp.type_expr, ArrayTypeExpr) and isinstance(
                 inp.type_expr.element, QubitTypeExpr,
             )
-            if not (is_qubit or is_qubit_array):
+            is_bit = isinstance(inp.type_expr, BitTypeExpr)
+            if not (is_qubit or is_qubit_array or is_bit):
                 msg = (
-                    f"BlockDecl {decl.name!r} input {inp.name!r}: only array[qubit, N] "
-                    f"and bare qubit inputs are supported in Phase 3a.3 iter 5b "
-                    f"(got {type(inp.type_expr).__name__})"
+                    f"BlockDecl {decl.name!r} input {inp.name!r}: only array[qubit, N], "
+                    f"bare qubit, and bare bit inputs are supported in Phase 3a.3 "
+                    f"iter 5c (got {type(inp.type_expr).__name__})"
                 )
                 raise GuppyCodegenError(msg)
-            if inp.effect not in {ResourceEffect.LIVE_PRESERVED, ResourceEffect.CONSUMED}:
+            if is_bit:
+                # A classical bit is copyable; CONSUMED/PRODUCED/DROPPED don't
+                # apply. A write-back bit always survives the call.
+                if inp.effect is not ResourceEffect.LIVE_PRESERVED:
+                    msg = (
+                        f"BlockDecl {decl.name!r} input {inp.name!r}: bare bit inputs "
+                        f"must be LIVE_PRESERVED (got {inp.effect.name}); a classical "
+                        "bit is copyable so consumed/produced/dropped do not apply"
+                    )
+                    raise GuppyCodegenError(msg)
+            elif inp.effect not in {ResourceEffect.LIVE_PRESERVED, ResourceEffect.CONSUMED}:
                 msg = (
                     f"BlockDecl {decl.name!r} input {inp.name!r}: only LIVE_PRESERVED and "
                     f"CONSUMED effects are supported in Phase 3a.1 (got {inp.effect.name})"
@@ -255,29 +269,38 @@ def _validate_block_decl(self, decl: BlockDecl) -> None:
     def _generate_block_decl(self, decl: BlockDecl) -> list[str]:
         """Emit a BlockDecl as a top-level Guppy @guppy def function.
 
-        Each input is one of (Phase 3a.3 iter 5b scope):
+        Each input is one of (Phase 3a.3 iter 5c scope):
         - `array[qubit, N]`: parameter `name: array[qubit, N] @ owned`,
           unpacks at entry into `name_0..name_{N-1}` slots.
         - bare `qubit`: parameter `name: qubit @ owned`, aliased to its
           1-slot linearity binding at entry.
+        - bare `bit`: parameter `name: array[bool, 1] @ owned` (write-back
+          proxy); body BitRefs to `name` render as `name[0]`; the array is
+          returned so the caller sees the mutation.
 
-        Future iters add single-bit (`array[bool, 1]` proxy), bundle args,
-        and PRODUCED/DROPPED effects.
+        Future iters add qubit/bit bundles and PRODUCED/DROPPED effects.
         """
         saved_context = self.context
         self.context = GuppyContext()
-        # Categorize each input as either a single qubit (size 1, not unpacked)
-        # or an array[qubit, N] (size N, unpacked at entry). `_validate_block_decl`
-        # guarantees the type_expr is one of those two shapes.
-        input_shapes: list[tuple[str, int, bool]] = []  # (name, size, is_array)
+        # Categorize each input. `_validate_block_decl` guarantees the type_expr
+        # is one of: bare qubit, array[qubit, N], or bare bit. `size` is the
+        # qubit-array length (1 for single qubit, unused for bit).
+        input_shapes: list[tuple[str, str, int]] = []  # (name, kind, size)
         for inp in decl.inputs:
-            if isinstance(inp.type_expr, QubitTypeExpr):
-                input_shapes.append((inp.name, 1, False))
+            if isinstance(inp.type_expr, BitTypeExpr):
+                input_shapes.append((inp.name, "single_bit", 1))
+            elif isinstance(inp.type_expr, QubitTypeExpr):
+                input_shapes.append((inp.name, "single_qubit", 1))
             else:
                 arr = cast("ArrayTypeExpr", inp.type_expr)
-                input_shapes.append((inp.name, arr.size, True))
-        for name, size, _ in input_shapes:
-            self.context.root_allocators[name] = size
+                input_shapes.append((inp.name, "qubit_array", arr.size))
+        for name, kind, size in input_shapes:
+            if kind == "single_bit":
+                # Register the bit-input name so body BitRefs (`name[0]`) render;
+                # do NOT emit an initializer -- it's a bound parameter.
+                self.context.registers[name] = RegisterDecl(name=name, size=1, is_result=False)
+            else:
+                self.context.root_allocators[name] = size
         self.context.linearity = GuppyLinearityState.from_allocators(self.context.root_allocators)
 
         live_inputs = tuple(
@@ -287,16 +310,23 @@ def _generate_block_decl(self, decl: BlockDecl) -> list[str]:
         )
 
         return_types: list[str] = []
-        for _inp, (_name, size, is_array) in live_inputs:
-            return_types.append(f"array[qubit, {size}]" if is_array else "qubit")
+        for _inp, (_name, kind, size) in live_inputs:
+            if kind == "qubit_array":
+                return_types.append(f"array[qubit, {size}]")
+            elif kind == "single_qubit":
+                return_types.append("qubit")
+            else:  # single_bit
+                return_types.append("array[bool, 1]")
         return_type_str = self._tuple_type(return_types)
 
         param_parts: list[str] = []
-        for name, size, is_array in input_shapes:
-            if is_array:
+        for name, kind, size in input_shapes:
+            if kind == "qubit_array":
                 param_parts.append(f"{name}: array[qubit, {size}] @ owned")
-            else:
+            elif kind == "single_qubit":
                 param_parts.append(f"{name}: qubit @ owned")
+            else:  # single_bit write-back proxy
+                param_parts.append(f"{name}: array[bool, 1] @ owned")
         params = ", ".join(param_parts)
 
         lines: list[str] = ["@guppy", f"def {decl.name}({params}) -> {return_type_str}:"]
@@ -305,32 +335,37 @@ def _generate_block_decl(self, decl: BlockDecl) -> list[str]:
         body_lines: list[str] = []
         linearity = self._linearity()
         # Per-input entry bindings: array inputs unpack into per-slot locals;
-        # single-qubit inputs alias the param to its single slot's linearity local.
-        for name, size, is_array in input_shapes:
-            if is_array:
+        # single-qubit inputs alias the param to its single slot's linearity
+        # local; single-bit inputs need no entry binding (the param IS the
+        # array[bool, 1] the body writes to via `name[0]`).
+        for name, kind, size in input_shapes:
+            if kind == "qubit_array":
                 locals_for = [binding.local for slot, binding in linearity.bindings() if slot.allocator == name]
                 lhs = ", ".join(locals_for)
                 if size == 1:
                     lhs += ","
                 body_lines.append(f"{self.context.indent()}{lhs} = {name}")
-            else:
+            elif kind == "single_qubit":
                 slot_local = linearity.live(Slot(name, 0))
                 body_lines.append(f"{self.context.indent()}{slot_local} = {name}")
+            # single_bit: no entry binding needed.
 
         for stmt in decl.body:
             body_lines.extend(self._emit_stmt(stmt))
 
-        # Auto-emit return for live_preserved inputs; consume their slots so the
-        # linearity tracker reflects ownership leaving the function. Single-qubit
-        # live_preserved inputs return their single slot's local directly; array
-        # inputs repack the per-slot locals into `array(...)`.
+        # Auto-emit return for live_preserved inputs. Qubit-array inputs repack
+        # per-slot locals into `array(...)`; single-qubit inputs return their
+        # slot's local; single-bit inputs return the (mutated) array[bool, 1]
+        # parameter directly.
         if live_inputs:
             return_exprs: list[str] = []
-            for _inp, (name, _size, is_array) in live_inputs:
-                if is_array:
+            for _inp, (name, kind, _size) in live_inputs:
+                if kind == "qubit_array":
                     return_exprs.append(self._consume_allocator_for_return(name))
-                else:
+                elif kind == "single_qubit":
                     return_exprs.append(linearity.consume(Slot(name, 0)))
+                else:  # single_bit: the array param itself
+                    return_exprs.append(name)
             if len(return_exprs) == 1:
                 body_lines.append(f"{self.context.indent()}return {return_exprs[0]}")
             else:
@@ -993,6 +1028,11 @@ def _emit_block_call(self, node: BlockCall) -> list[str]:
             elif kind == "single_qubit":
                 outer_alloc, outer_index = info
                 arg_exprs.append(linearity.consume(Slot(outer_alloc, outer_index)))
+            elif kind == "single_bit":
+                # Wrap the outer CReg bit into a 1-element bool array (write-back
+                # proxy). Bits are copyable, so no linearity consume.
+                register, bit_index = info
+                arg_exprs.append(f"array({register}[{bit_index}])")
             else:
                 msg = f"Unsupported validated arg kind {kind!r}"  # pragma: no cover
                 raise GuppyCodegenError(msg)
@@ -1027,8 +1067,10 @@ def _validate_block_call_arg(
     ) -> tuple[str, tuple]:
         """Cross-check input type and BlockArg shape; return (kind, info).
 
-        kind is "array" with info = (outer_alloc_name, outer_size), or
-        "single_qubit" with info = (outer_alloc_name, outer_index).
+        kind is one of:
+        - "array": info = (outer_alloc_name, outer_size)
+        - "single_qubit": info = (outer_alloc_name, outer_index)
+        - "single_bit": info = (outer_register_name, outer_bit_index)
         """
         position = "out_binding" if is_out else "arg"
         if isinstance(arg, AllocatorArg):
@@ -1080,9 +1122,34 @@ def _validate_block_call_arg(
                 raise GuppyCodegenError(msg)
             return "single_qubit", (slot.allocator, slot.index)
 
+        if isinstance(arg, SingleBitArg):
+            if not isinstance(inp.type_expr, BitTypeExpr):
+                msg = (
+                    f"BlockCall {callee!r} {position} for input {inp.name!r}: "
+                    f"SingleBitArg requires a bare bit input (got "
+                    f"{type(inp.type_expr).__name__})"
+                )
+                raise GuppyCodegenError(msg)
+            bit = arg.bit
+            if bit.register not in self.context.registers:
+                msg = (
+                    f"BlockCall {callee!r} {position} for input {inp.name!r}: bit "
+                    f"{bit.register}[{bit.index}] references an unknown outer CReg"
+                )
+                raise GuppyCodegenError(msg)
+            reg_size = self.context.registers[bit.register].size
+            if not (0 <= bit.index < reg_size):
+                msg = (
+                    f"BlockCall {callee!r} {position} for input {inp.name!r}: bit "
+                    f"index {bit.index} out of bounds for CReg {bit.register!r} "
+                    f"of size {reg_size}"
+                )
+                raise GuppyCodegenError(msg)
+            return "single_bit", (bit.register, bit.index)
+
         msg = (
             f"BlockCall {callee!r} {position} for input {inp.name!r}: BlockArg "
-            f"{type(arg).__name__} is not yet supported in Phase 3a.3 iter 5b"
+            f"{type(arg).__name__} is not yet supported in Phase 3a.3 iter 5c"
         )
         raise GuppyCodegenError(msg)
 
@@ -1100,6 +1167,11 @@ def _unpack_block_call_return(self, kind: str, info: tuple, ret_temp: str) -> li
             new_local = f"{outer_alloc}_{outer_index}"
             linearity.set_live(Slot(outer_alloc, outer_index), new_local)
             return [f"{self.context.indent()}{new_local} = {ret_temp}"]
+        if kind == "single_bit":
+            # Write the mutated bit back into the outer CReg. Bits are copyable
+            # so there's no linearity rebind -- just a value assignment.
+            register, bit_index = info
+            return [f"{self.context.indent()}{register}[{bit_index}] = {ret_temp}[0]"]
         msg = f"Unsupported return kind {kind!r}"  # pragma: no cover
         raise GuppyCodegenError(msg)
 
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
index 45705fa39..eb10af6dd 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
@@ -32,6 +32,7 @@
     AllocatorDecl,
     ArrayTypeExpr,
     BitRef,
+    BitTypeExpr,
     BlockCall,
     BlockDecl,
     BlockInput,
@@ -207,7 +208,7 @@ def test_unsupported_input_type_rejected(self) -> None:
             block_decls=(bell,),
             body=(),
         )
-        with pytest.raises(GuppyCodegenError, match=r"only array\[qubit, N\] and bare qubit inputs"):
+        with pytest.raises(GuppyCodegenError, match=r"only array\[qubit, N\], bare qubit, and bare bit inputs"):
             ast_to_guppy(prog)
 
     def test_size_mismatch_rejected(self) -> None:
@@ -856,18 +857,181 @@ def test_single_qubit_slot_index_out_of_bounds_rejected(self) -> None:
             ast_to_guppy(prog)
 
 
+class TestSingleBitInputSupport:
+    """Phase 3a.3 iter 5c: single classical-bit (bare `BitTypeExpr`) input +
+    `SingleBitArg` at the call site. The bit is modeled as an
+    `array[bool, 1] @ owned` write-back proxy: the callee mutates `name[0]`,
+    returns the array, and the caller writes it back into the outer CReg bit.
+    """
+
+    def _build_single_bit_program(self) -> Program:
+        from pecos.slr.ast.nodes import SingleBitArg, SingleQubitArg
+
+        # Block: measure a borrowed qubit into a single-bit write-back input.
+        decl = BlockDecl(
+            name="b",
+            inputs=(
+                BlockInput(name="a", effect=ResourceEffect.CONSUMED, type_expr=QubitTypeExpr()),
+                BlockInput(name="out", effect=ResourceEffect.LIVE_PRESERVED, type_expr=BitTypeExpr()),
+            ),
+            body=(
+                GateOp(gate=GateKind.H, targets=(SlotRef(allocator="a", index=0),)),
+                MeasureOp(
+                    targets=(SlotRef(allocator="a", index=0),),
+                    results=(BitRef(register="out", index=0),),
+                ),
+            ),
+        )
+        return Program(
+            name="main",
+            allocator=AllocatorDecl(name="outer_q", capacity=2),
+            declarations=(RegisterDecl(name="c", size=2),),
+            block_decls=(decl,),
+            body=(
+                PrepareOp(allocator="outer_q"),
+                BlockCall(
+                    callee="b",
+                    arg_bindings=(
+                        SingleQubitArg(slot=SlotRef(allocator="outer_q", index=0)),
+                        SingleBitArg(bit=BitRef(register="c", index=1)),
+                    ),
+                    out_bindings=(SingleBitArg(bit=BitRef(register="c", index=1)),),
+                ),
+                MeasureOp(
+                    targets=(SlotRef(allocator="outer_q", index=1),),
+                    results=(BitRef(register="c", index=0),),
+                ),
+            ),
+        )
+
+    def test_single_bit_renders_array_bool_proxy(self) -> None:
+        source = ast_to_guppy(self._build_single_bit_program())
+        # Param uses the array[bool, 1] write-back proxy.
+        assert re.search(r"def b\(a: qubit @ owned, out: array\[bool, 1\] @ owned\) -> array\[bool, 1\]:", source)
+        # Body writes the measurement into out[0] and returns the array.
+        assert "out[0] = measure(a_0)" in source
+        assert "return out" in source
+        # Call site wraps the outer CReg bit, then writes it back.
+        assert re.search(r"_call_ret_\d+\s*=\s*b\(outer_q_0, array\(c\[1\]\)\)", source)
+        assert re.search(r"c\[1\]\s*=\s*_call_ret_\d+\[0\]", source)
+
+    def test_single_bit_must_be_live_preserved(self) -> None:
+        decl = BlockDecl(
+            name="b",
+            inputs=(
+                BlockInput(name="out", effect=ResourceEffect.CONSUMED, type_expr=BitTypeExpr()),
+            ),
+            body=(),
+        )
+        prog = Program(
+            name="main",
+            allocator=AllocatorDecl(name="outer_q", capacity=1),
+            block_decls=(decl,),
+            body=(),
+        )
+        with pytest.raises(GuppyCodegenError, match=r"bare bit inputs\s+must be LIVE_PRESERVED"):
+            ast_to_guppy(prog)
+
+    def test_single_bit_arg_mismatched_input_type_rejected(self) -> None:
+        from pecos.slr.ast.nodes import SingleBitArg
+
+        decl = BlockDecl(
+            name="b",
+            inputs=(
+                BlockInput(
+                    name="q",
+                    effect=ResourceEffect.LIVE_PRESERVED,
+                    type_expr=ArrayTypeExpr(element=QubitTypeExpr(), size=2),
+                ),
+            ),
+            body=(),
+        )
+        prog = Program(
+            name="main",
+            allocator=AllocatorDecl(name="outer_q", capacity=2),
+            declarations=(RegisterDecl(name="c", size=1),),
+            block_decls=(decl,),
+            body=(
+                BlockCall(
+                    callee="b",
+                    arg_bindings=(SingleBitArg(bit=BitRef(register="c", index=0)),),
+                    out_bindings=(SingleBitArg(bit=BitRef(register="c", index=0)),),
+                ),
+            ),
+        )
+        with pytest.raises(GuppyCodegenError, match=r"SingleBitArg requires a bare bit input"):
+            ast_to_guppy(prog)
+
+    def test_single_bit_index_out_of_bounds_rejected(self) -> None:
+        from pecos.slr.ast.nodes import SingleBitArg
+
+        decl = BlockDecl(
+            name="b",
+            inputs=(
+                BlockInput(name="out", effect=ResourceEffect.LIVE_PRESERVED, type_expr=BitTypeExpr()),
+            ),
+            body=(),
+        )
+        prog = Program(
+            name="main",
+            allocator=AllocatorDecl(name="outer_q", capacity=1),
+            declarations=(RegisterDecl(name="c", size=2),),  # indices 0..1
+            block_decls=(decl,),
+            body=(
+                BlockCall(
+                    callee="b",
+                    arg_bindings=(SingleBitArg(bit=BitRef(register="c", index=9)),),
+                    out_bindings=(SingleBitArg(bit=BitRef(register="c", index=9)),),
+                ),
+            ),
+        )
+        with pytest.raises(GuppyCodegenError, match=r"bit index 9 out of bounds"):
+            ast_to_guppy(prog)
+
+
 class TestDeferredBlockArgRejection:
-    """Phase 3a.3 iter 5b scope:
+    """Phase 3a.3 iter 5c scope:
     - `AllocatorArg` is supported in BOTH the Guppy emitter AND the non-Guppy
       flatten path.
-    - `SingleQubitArg` is supported in the Guppy emitter ONLY; flatten support
-      is deferred (full slot-level body rewriting needed). See
-      `test_single_qubit_arg_rejected_in_flatten_pass` below.
-    - `SingleBitArg`, `QubitBundleArg`, `BitBundleArg` MUST raise cleanly in
-      BOTH paths -- silently inlining a deferred shape would mask user errors
-      (Codex 2026-05-15 fix-pass-5 + iter-5b reviews caught this family).
+    - `SingleQubitArg` and `SingleBitArg` are supported in the Guppy emitter
+      ONLY; flatten support is deferred (full slot/bit-level body rewriting
+      needed). See `test_single_qubit_arg_rejected_in_flatten_pass` and
+      `test_single_bit_arg_rejected_in_flatten_pass` below.
+    - `QubitBundleArg`, `BitBundleArg` MUST raise cleanly in BOTH paths --
+      silently inlining a deferred shape would mask user errors (Codex
+      2026-05-15 fix-pass-5 + iter-5b reviews caught this family).
     """
 
+    def test_single_bit_arg_rejected_in_flatten_pass(self) -> None:
+        """SingleBitArg in flatten path: deferred until bit-level body rewriting
+        lands. Lock-in: clean NotImplementedError, no silent inline.
+        """
+        from pecos.slr.ast.codegen._block_flatten import flatten_block_calls
+        from pecos.slr.ast.nodes import SingleBitArg
+
+        decl = BlockDecl(
+            name="b",
+            inputs=(
+                BlockInput(name="out", effect=ResourceEffect.LIVE_PRESERVED, type_expr=BitTypeExpr()),
+            ),
+            body=(),
+        )
+        prog = Program(
+            name="main",
+            allocator=AllocatorDecl(name="outer_q", capacity=1),
+            declarations=(RegisterDecl(name="c", size=1),),
+            block_decls=(decl,),
+            body=(
+                BlockCall(
+                    callee="b",
+                    arg_bindings=(SingleBitArg(bit=BitRef(register="c", index=0)),),
+                    out_bindings=(SingleBitArg(bit=BitRef(register="c", index=0)),),
+                ),
+            ),
+        )
+        with pytest.raises(NotImplementedError, match=r"SingleBitArg"):
+            flatten_block_calls(prog)
+
     def test_single_qubit_arg_rejected_in_flatten_pass(self) -> None:
         """SingleQubitArg in flatten path: deferred until full slot-level body
         rewriting lands. Lock-in: clean NotImplementedError, no silent inline.
@@ -902,14 +1066,11 @@ def _program_with_deferred_arg(self, *, deferred_in_args: bool, arg_subclass: ty
             BitBundleArg,
             BitRef,
             QubitBundleArg,
-            SingleBitArg,
             SlotRef,
         )
 
         # Build a representative instance of the deferred subclass.
-        if arg_subclass is SingleBitArg:
-            deferred = SingleBitArg(bit=BitRef(register="c", index=0))
-        elif arg_subclass is QubitBundleArg:
+        if arg_subclass is QubitBundleArg:
             deferred = QubitBundleArg(slots=(SlotRef(allocator="outer_q", index=0),))
         elif arg_subclass is BitBundleArg:
             deferred = BitBundleArg(bits=(BitRef(register="c", index=0),))
@@ -950,13 +1111,9 @@ def _program_with_deferred_arg(self, *, deferred_in_args: bool, arg_subclass: ty
 
     def test_deferred_arg_bindings_raise_in_flatten(self) -> None:
         from pecos.slr.ast.codegen._block_flatten import flatten_block_calls
-        from pecos.slr.ast.nodes import (
-            BitBundleArg,
-            QubitBundleArg,
-            SingleBitArg,
-        )
+        from pecos.slr.ast.nodes import BitBundleArg, QubitBundleArg
 
-        for subclass in (SingleBitArg, QubitBundleArg, BitBundleArg):
+        for subclass in (QubitBundleArg, BitBundleArg):
             prog = self._program_with_deferred_arg(deferred_in_args=True, arg_subclass=subclass)
             with pytest.raises(NotImplementedError, match=subclass.__name__):
                 flatten_block_calls(prog)
@@ -967,37 +1124,25 @@ def test_deferred_out_bindings_raise_in_flatten(self) -> None:
         BlockArg shape, while Guppy correctly rejected them.
         """
         from pecos.slr.ast.codegen._block_flatten import flatten_block_calls
-        from pecos.slr.ast.nodes import (
-            BitBundleArg,
-            QubitBundleArg,
-            SingleBitArg,
-        )
+        from pecos.slr.ast.nodes import BitBundleArg, QubitBundleArg
 
-        for subclass in (SingleBitArg, QubitBundleArg, BitBundleArg):
+        for subclass in (QubitBundleArg, BitBundleArg):
             prog = self._program_with_deferred_arg(deferred_in_args=False, arg_subclass=subclass)
             with pytest.raises(NotImplementedError, match=subclass.__name__):
                 flatten_block_calls(prog)
 
     def test_deferred_arg_bindings_raise_in_guppy(self) -> None:
-        from pecos.slr.ast.nodes import (
-            BitBundleArg,
-            QubitBundleArg,
-            SingleBitArg,
-        )
+        from pecos.slr.ast.nodes import BitBundleArg, QubitBundleArg
 
-        for subclass in (SingleBitArg, QubitBundleArg, BitBundleArg):
+        for subclass in (QubitBundleArg, BitBundleArg):
             prog = self._program_with_deferred_arg(deferred_in_args=True, arg_subclass=subclass)
             with pytest.raises(GuppyCodegenError, match=subclass.__name__):
                 ast_to_guppy(prog)
 
     def test_deferred_out_bindings_raise_in_guppy(self) -> None:
-        from pecos.slr.ast.nodes import (
-            BitBundleArg,
-            QubitBundleArg,
-            SingleBitArg,
-        )
+        from pecos.slr.ast.nodes import BitBundleArg, QubitBundleArg
 
-        for subclass in (SingleBitArg, QubitBundleArg, BitBundleArg):
+        for subclass in (QubitBundleArg, BitBundleArg):
             prog = self._program_with_deferred_arg(deferred_in_args=False, arg_subclass=subclass)
             with pytest.raises(GuppyCodegenError, match=subclass.__name__):
                 ast_to_guppy(prog)

From 1533925c1333fdcb889d291f95ab82167f7e70ab Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Fri, 15 May 2026 21:20:44 -0600
Subject: [PATCH 043/136] Phase 3a.3 iter 5d: QubitBundleArg non-contiguous
 slot-bundle call-site shape end-to-end in Guppy emitter (pack/unpack across
 arbitrary allocators, duplicate/bounds/size validation).

---
 .../src/pecos/slr/ast/codegen/guppy.py        |  66 ++++-
 .../ast_guppy/test_block_call_smoke.py        | 248 +++++++++++++++---
 2 files changed, 276 insertions(+), 38 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
index 7935da742..e7bdb96f0 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
@@ -48,6 +48,7 @@
     MeasureOp,
     ParallelBlock,
     PrepareOp,
+    QubitBundleArg,
     QubitTypeExpr,
     RegisterDecl,
     RepeatStmt,
@@ -1033,6 +1034,10 @@ def _emit_block_call(self, node: BlockCall) -> list[str]:
                 # proxy). Bits are copyable, so no linearity consume.
                 register, bit_index = info
                 arg_exprs.append(f"array({register}[{bit_index}])")
+            elif kind == "qubit_bundle":
+                # Pack arbitrary (non-contiguous) outer slots into one array.
+                locals_ = [linearity.consume(Slot(alloc, idx)) for alloc, idx in info]
+                arg_exprs.append(f"array({', '.join(locals_)})")
             else:
                 msg = f"Unsupported validated arg kind {kind!r}"  # pragma: no cover
                 raise GuppyCodegenError(msg)
@@ -1147,9 +1152,57 @@ def _validate_block_call_arg(
                 raise GuppyCodegenError(msg)
             return "single_bit", (bit.register, bit.index)
 
+        if isinstance(arg, QubitBundleArg):
+            if not isinstance(inp.type_expr, ArrayTypeExpr) or not isinstance(
+                inp.type_expr.element, QubitTypeExpr,
+            ):
+                msg = (
+                    f"BlockCall {callee!r} {position} for input {inp.name!r}: "
+                    f"QubitBundleArg requires an array[qubit, N] input (got "
+                    f"{type(inp.type_expr).__name__})"
+                )
+                raise GuppyCodegenError(msg)
+            input_size = inp.type_expr.size
+            if len(arg.slots) != input_size:
+                msg = (
+                    f"BlockCall {callee!r} {position} for input {inp.name!r}: "
+                    f"QubitBundleArg has {len(arg.slots)} slots but input "
+                    f"{inp.name!r} expects {input_size}"
+                )
+                raise GuppyCodegenError(msg)
+            resolved: list[tuple[str, int]] = []
+            seen: set[tuple[str, int]] = set()
+            for slot in arg.slots:
+                if slot.allocator not in self.context.root_allocators:
+                    msg = (
+                        f"BlockCall {callee!r} {position} for input {inp.name!r}: "
+                        f"bundle slot {slot.allocator}[{slot.index}] references an "
+                        "unknown outer allocator"
+                    )
+                    raise GuppyCodegenError(msg)
+                outer_size = self.context.root_allocators[slot.allocator]
+                if not (0 <= slot.index < outer_size):
+                    msg = (
+                        f"BlockCall {callee!r} {position} for input {inp.name!r}: "
+                        f"bundle slot index {slot.index} out of bounds for allocator "
+                        f"{slot.allocator!r} of size {outer_size}"
+                    )
+                    raise GuppyCodegenError(msg)
+                key = (slot.allocator, slot.index)
+                if key in seen:
+                    msg = (
+                        f"BlockCall {callee!r} {position} for input {inp.name!r}: "
+                        f"bundle references slot {slot.allocator}[{slot.index}] more "
+                        "than once (a qubit cannot be passed twice)"
+                    )
+                    raise GuppyCodegenError(msg)
+                seen.add(key)
+                resolved.append(key)
+            return "qubit_bundle", tuple(resolved)
+
         msg = (
             f"BlockCall {callee!r} {position} for input {inp.name!r}: BlockArg "
-            f"{type(arg).__name__} is not yet supported in Phase 3a.3 iter 5c"
+            f"{type(arg).__name__} is not yet supported in Phase 3a.3 iter 5d"
         )
         raise GuppyCodegenError(msg)
 
@@ -1172,6 +1225,17 @@ def _unpack_block_call_return(self, kind: str, info: tuple, ret_temp: str) -> li
             # so there's no linearity rebind -- just a value assignment.
             register, bit_index = info
             return [f"{self.context.indent()}{register}[{bit_index}] = {ret_temp}[0]"]
+        if kind == "qubit_bundle":
+            # Destructure the returned array back into the SAME outer slots the
+            # bundle consumed, rebinding each via the canonical local name.
+            new_locals = [f"{alloc}_{idx}" for alloc, idx in info]
+            if len(new_locals) == 1:
+                line = f"{self.context.indent()}{new_locals[0]}, = {ret_temp}"
+            else:
+                line = f"{self.context.indent()}{', '.join(new_locals)} = {ret_temp}"
+            for (alloc, idx), local in zip(info, new_locals, strict=True):
+                linearity.set_live(Slot(alloc, idx), local)
+            return [line]
         msg = f"Unsupported return kind {kind!r}"  # pragma: no cover
         raise GuppyCodegenError(msg)
 
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
index eb10af6dd..94c1783f2 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
@@ -989,19 +989,204 @@ def test_single_bit_index_out_of_bounds_rejected(self) -> None:
             ast_to_guppy(prog)
 
 
+class TestQubitBundleInputSupport:
+    """Phase 3a.3 iter 5d: a single `array[qubit, N]` BlockInput bound at the
+    call site to a non-contiguous bundle of N arbitrary outer slots via
+    `QubitBundleArg(slots=(...))`. The BlockDecl side is unchanged from the
+    AllocatorArg case -- only the caller's slot-bundling differs.
+    """
+
+    def _build_bundle_program(self) -> Program:
+        from pecos.slr.ast.nodes import QubitBundleArg
+
+        # Block: H on q[0], CX(q[0], q[1]) over a 2-qubit array input.
+        decl = BlockDecl(
+            name="bell",
+            inputs=(
+                BlockInput(
+                    name="q",
+                    effect=ResourceEffect.LIVE_PRESERVED,
+                    type_expr=ArrayTypeExpr(element=QubitTypeExpr(), size=2),
+                ),
+            ),
+            body=(
+                GateOp(gate=GateKind.H, targets=(SlotRef(allocator="q", index=0),)),
+                GateOp(
+                    gate=GateKind.CX,
+                    targets=(SlotRef(allocator="q", index=0), SlotRef(allocator="q", index=1)),
+                ),
+            ),
+        )
+        # Bundle picks non-contiguous slots a[2] and b[0] across two allocators.
+        bundle = QubitBundleArg(
+            slots=(SlotRef(allocator="a", index=2), SlotRef(allocator="b", index=0)),
+        )
+        return Program(
+            name="main",
+            allocator=AllocatorDecl(name="a", capacity=3),
+            declarations=(AllocatorDecl(name="b", capacity=2), RegisterDecl(name="c", size=2)),
+            block_decls=(decl,),
+            body=(
+                PrepareOp(allocator="a"),
+                PrepareOp(allocator="b"),
+                BlockCall(callee="bell", arg_bindings=(bundle,), out_bindings=(bundle,)),
+                MeasureOp(
+                    targets=(SlotRef(allocator="a", index=2), SlotRef(allocator="b", index=0)),
+                    results=(BitRef(register="c", index=0), BitRef(register="c", index=1)),
+                ),
+            ),
+        )
+
+    def test_qubit_bundle_packs_and_unpacks_arbitrary_slots(self) -> None:
+        source = ast_to_guppy(self._build_bundle_program())
+        # Call site packs the two non-contiguous slot locals into one array.
+        assert re.search(r"_call_ret_\d+\s*=\s*bell\(array\(a_2, b_0\)\)", source)
+        # Return destructures back into the SAME slots' canonical locals.
+        assert re.search(r"a_2, b_0\s*=\s*_call_ret_\d+", source)
+        # Downstream measure sees the rebound slots.
+        assert "c[0] = measure(a_2)" in source
+        assert "c[1] = measure(b_0)" in source
+
+    def test_qubit_bundle_size_mismatch_rejected(self) -> None:
+        from pecos.slr.ast.nodes import QubitBundleArg
+
+        decl = BlockDecl(
+            name="b",
+            inputs=(
+                BlockInput(
+                    name="q",
+                    effect=ResourceEffect.LIVE_PRESERVED,
+                    type_expr=ArrayTypeExpr(element=QubitTypeExpr(), size=3),
+                ),
+            ),
+            body=(),
+        )
+        prog = Program(
+            name="main",
+            allocator=AllocatorDecl(name="outer_q", capacity=3),
+            block_decls=(decl,),
+            body=(
+                BlockCall(
+                    callee="b",
+                    arg_bindings=(QubitBundleArg(slots=(SlotRef(allocator="outer_q", index=0),)),),
+                    out_bindings=(QubitBundleArg(slots=(SlotRef(allocator="outer_q", index=0),)),),
+                ),
+            ),
+        )
+        with pytest.raises(GuppyCodegenError, match=r"has 1 slots but input 'q' expects 3"):
+            ast_to_guppy(prog)
+
+    def test_qubit_bundle_duplicate_slot_rejected(self) -> None:
+        from pecos.slr.ast.nodes import QubitBundleArg
+
+        decl = BlockDecl(
+            name="b",
+            inputs=(
+                BlockInput(
+                    name="q",
+                    effect=ResourceEffect.LIVE_PRESERVED,
+                    type_expr=ArrayTypeExpr(element=QubitTypeExpr(), size=2),
+                ),
+            ),
+            body=(),
+        )
+        dup = QubitBundleArg(
+            slots=(SlotRef(allocator="outer_q", index=1), SlotRef(allocator="outer_q", index=1)),
+        )
+        prog = Program(
+            name="main",
+            allocator=AllocatorDecl(name="outer_q", capacity=3),
+            block_decls=(decl,),
+            body=(BlockCall(callee="b", arg_bindings=(dup,), out_bindings=(dup,)),),
+        )
+        with pytest.raises(GuppyCodegenError, match=r"more than once \(a qubit cannot be passed twice\)"):
+            ast_to_guppy(prog)
+
+    def test_qubit_bundle_out_of_bounds_slot_rejected(self) -> None:
+        from pecos.slr.ast.nodes import QubitBundleArg
+
+        decl = BlockDecl(
+            name="b",
+            inputs=(
+                BlockInput(
+                    name="q",
+                    effect=ResourceEffect.LIVE_PRESERVED,
+                    type_expr=ArrayTypeExpr(element=QubitTypeExpr(), size=1),
+                ),
+            ),
+            body=(),
+        )
+        bad = QubitBundleArg(slots=(SlotRef(allocator="outer_q", index=9),))
+        prog = Program(
+            name="main",
+            allocator=AllocatorDecl(name="outer_q", capacity=2),
+            block_decls=(decl,),
+            body=(BlockCall(callee="b", arg_bindings=(bad,), out_bindings=(bad,)),),
+        )
+        with pytest.raises(GuppyCodegenError, match=r"bundle slot index 9 out of bounds"):
+            ast_to_guppy(prog)
+
+
 class TestDeferredBlockArgRejection:
-    """Phase 3a.3 iter 5c scope:
+    """Phase 3a.3 iter 5d scope:
     - `AllocatorArg` is supported in BOTH the Guppy emitter AND the non-Guppy
       flatten path.
-    - `SingleQubitArg` and `SingleBitArg` are supported in the Guppy emitter
-      ONLY; flatten support is deferred (full slot/bit-level body rewriting
-      needed). See `test_single_qubit_arg_rejected_in_flatten_pass` and
-      `test_single_bit_arg_rejected_in_flatten_pass` below.
-    - `QubitBundleArg`, `BitBundleArg` MUST raise cleanly in BOTH paths --
-      silently inlining a deferred shape would mask user errors (Codex
-      2026-05-15 fix-pass-5 + iter-5b reviews caught this family).
+    - `SingleQubitArg`, `SingleBitArg`, `QubitBundleArg` are supported in the
+      Guppy emitter ONLY; flatten support is deferred (full slot/bit-level
+      body rewriting needed). Each has a dedicated
+      `test_<shape>_arg_rejected_in_flatten_pass` lock-in below.
+    - `BitBundleArg` MUST raise cleanly in BOTH paths -- silently inlining a
+      deferred shape would mask user errors (Codex 2026-05-15 fix-pass-5 +
+      iter-5b reviews caught this family).
     """
 
+    def test_qubit_bundle_arg_rejected_in_flatten_pass(self) -> None:
+        """QubitBundleArg in flatten path: deferred until non-contiguous
+        slot-level body rewriting lands. Lock-in: clean NotImplementedError.
+        """
+        from pecos.slr.ast.codegen._block_flatten import flatten_block_calls
+        from pecos.slr.ast.nodes import QubitBundleArg
+
+        decl = BlockDecl(
+            name="b",
+            inputs=(
+                BlockInput(
+                    name="q",
+                    effect=ResourceEffect.LIVE_PRESERVED,
+                    type_expr=ArrayTypeExpr(element=QubitTypeExpr(), size=2),
+                ),
+            ),
+            body=(GateOp(gate=GateKind.H, targets=(SlotRef(allocator="q", index=0),)),),
+        )
+        prog = Program(
+            name="main",
+            allocator=AllocatorDecl(name="outer_q", capacity=3),
+            block_decls=(decl,),
+            body=(
+                BlockCall(
+                    callee="b",
+                    arg_bindings=(
+                        QubitBundleArg(
+                            slots=(
+                                SlotRef(allocator="outer_q", index=0),
+                                SlotRef(allocator="outer_q", index=2),
+                            ),
+                        ),
+                    ),
+                    out_bindings=(
+                        QubitBundleArg(
+                            slots=(
+                                SlotRef(allocator="outer_q", index=0),
+                                SlotRef(allocator="outer_q", index=2),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+        )
+        with pytest.raises(NotImplementedError, match=r"QubitBundleArg"):
+            flatten_block_calls(prog)
+
     def test_single_bit_arg_rejected_in_flatten_pass(self) -> None:
         """SingleBitArg in flatten path: deferred until bit-level body rewriting
         lands. Lock-in: clean NotImplementedError, no silent inline.
@@ -1062,17 +1247,10 @@ def test_single_qubit_arg_rejected_in_flatten_pass(self) -> None:
             flatten_block_calls(prog)
 
     def _program_with_deferred_arg(self, *, deferred_in_args: bool, arg_subclass: type) -> Program:
-        from pecos.slr.ast.nodes import (
-            BitBundleArg,
-            BitRef,
-            QubitBundleArg,
-            SlotRef,
-        )
+        from pecos.slr.ast.nodes import BitBundleArg, BitRef
 
         # Build a representative instance of the deferred subclass.
-        if arg_subclass is QubitBundleArg:
-            deferred = QubitBundleArg(slots=(SlotRef(allocator="outer_q", index=0),))
-        elif arg_subclass is BitBundleArg:
+        if arg_subclass is BitBundleArg:
             deferred = BitBundleArg(bits=(BitRef(register="c", index=0),))
         else:
             msg = f"unsupported subclass {arg_subclass}"
@@ -1111,12 +1289,11 @@ def _program_with_deferred_arg(self, *, deferred_in_args: bool, arg_subclass: ty
 
     def test_deferred_arg_bindings_raise_in_flatten(self) -> None:
         from pecos.slr.ast.codegen._block_flatten import flatten_block_calls
-        from pecos.slr.ast.nodes import BitBundleArg, QubitBundleArg
+        from pecos.slr.ast.nodes import BitBundleArg
 
-        for subclass in (QubitBundleArg, BitBundleArg):
-            prog = self._program_with_deferred_arg(deferred_in_args=True, arg_subclass=subclass)
-            with pytest.raises(NotImplementedError, match=subclass.__name__):
-                flatten_block_calls(prog)
+        prog = self._program_with_deferred_arg(deferred_in_args=True, arg_subclass=BitBundleArg)
+        with pytest.raises(NotImplementedError, match="BitBundleArg"):
+            flatten_block_calls(prog)
 
     def test_deferred_out_bindings_raise_in_flatten(self) -> None:
         """Codex 2026-05-15 fix-pass-5 review caught: out_bindings used to be
@@ -1124,28 +1301,25 @@ def test_deferred_out_bindings_raise_in_flatten(self) -> None:
         BlockArg shape, while Guppy correctly rejected them.
         """
         from pecos.slr.ast.codegen._block_flatten import flatten_block_calls
-        from pecos.slr.ast.nodes import BitBundleArg, QubitBundleArg
+        from pecos.slr.ast.nodes import BitBundleArg
 
-        for subclass in (QubitBundleArg, BitBundleArg):
-            prog = self._program_with_deferred_arg(deferred_in_args=False, arg_subclass=subclass)
-            with pytest.raises(NotImplementedError, match=subclass.__name__):
-                flatten_block_calls(prog)
+        prog = self._program_with_deferred_arg(deferred_in_args=False, arg_subclass=BitBundleArg)
+        with pytest.raises(NotImplementedError, match="BitBundleArg"):
+            flatten_block_calls(prog)
 
     def test_deferred_arg_bindings_raise_in_guppy(self) -> None:
-        from pecos.slr.ast.nodes import BitBundleArg, QubitBundleArg
+        from pecos.slr.ast.nodes import BitBundleArg
 
-        for subclass in (QubitBundleArg, BitBundleArg):
-            prog = self._program_with_deferred_arg(deferred_in_args=True, arg_subclass=subclass)
-            with pytest.raises(GuppyCodegenError, match=subclass.__name__):
-                ast_to_guppy(prog)
+        prog = self._program_with_deferred_arg(deferred_in_args=True, arg_subclass=BitBundleArg)
+        with pytest.raises(GuppyCodegenError, match="BitBundleArg"):
+            ast_to_guppy(prog)
 
     def test_deferred_out_bindings_raise_in_guppy(self) -> None:
-        from pecos.slr.ast.nodes import BitBundleArg, QubitBundleArg
+        from pecos.slr.ast.nodes import BitBundleArg
 
-        for subclass in (QubitBundleArg, BitBundleArg):
-            prog = self._program_with_deferred_arg(deferred_in_args=False, arg_subclass=subclass)
-            with pytest.raises(GuppyCodegenError, match=subclass.__name__):
-                ast_to_guppy(prog)
+        prog = self._program_with_deferred_arg(deferred_in_args=False, arg_subclass=BitBundleArg)
+        with pytest.raises(GuppyCodegenError, match="BitBundleArg"):
+            ast_to_guppy(prog)
 
 
 class TestDuplicateBlockDeclNameValidation:

From f64ad098e10662fd01cd6d630144bbaf3a3d4111 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Fri, 15 May 2026 21:36:30 -0600
Subject: [PATCH 044/136] Iter-5d Codex polish: end-to-end Selene lock-in for
 cross-allocator bundle; pre-consume cross-input qubit-slot alias check;
 refresh stale _emit_block_call docstring + mismatch message.

---
 .../src/pecos/slr/ast/codegen/guppy.py        |  46 +++++++-
 .../ast_guppy/test_block_call_smoke.py        | 109 +++++++++++++++++-
 2 files changed, 148 insertions(+), 7 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
index e7bdb96f0..1076f291a 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
@@ -948,16 +948,21 @@ def _emit_parallel(self, node: ParallelBlock) -> list[str]:
     def _emit_block_call(self, node: BlockCall) -> list[str]:
         """Lower a BlockCall to a packed-array call + unpack pattern.
 
-        Per-input dispatch (Phase 3a.3 iter 5b scope):
+        Per-input dispatch (Phase 3a.3 iter 5d scope):
         - `array[qubit, N]` input + `AllocatorArg(name=outer)`: pack the
           outer allocator's slots into `array(outer_0, outer_1, ...)`,
           unpack the returned array back into the same slots.
         - bare `qubit` input + `SingleQubitArg(slot=outer[i])`: pass the
           outer slot's local directly (no array wrap), rebind it from the
           returned single qubit value.
+        - bare `bit` input + `SingleBitArg(bit=c[i])`: wrap into an
+          `array[bool, 1]` write-back proxy, write the mutated bit back.
+        - `array[qubit, N]` input + `QubitBundleArg(slots=(...))`: pack N
+          arbitrary (possibly non-contiguous, cross-allocator) outer slots,
+          unpack the returned array back into the same slots.
 
-        Other BlockArg subclasses (`SingleBitArg`, `QubitBundleArg`,
-        `BitBundleArg`) raise -- they land with later iterations.
+        The remaining BlockArg subclass (`BitBundleArg`) raises -- it lands
+        with a later iteration.
         """
         decl = self._block_decls.get(node.callee)
         if decl is None:
@@ -1011,13 +1016,44 @@ def _emit_block_call(self, node: BlockCall) -> list[str]:
             if (kind, info) != (arg_kind, arg_info):
                 msg = (
                     f"BlockCall {node.callee!r}: LIVE_PRESERVED input {inp.name!r} "
-                    f"must use matching arg_binding and out_binding (same slot for "
-                    f"SingleQubitArg, same allocator name for AllocatorArg); got "
+                    f"must use an identical arg_binding and out_binding (same "
+                    f"allocator name for AllocatorArg; same slot for "
+                    f"SingleQubitArg; same bit for SingleBitArg; same ordered "
+                    f"slot tuple for QubitBundleArg); got "
                     f"arg={arg_kind}{arg_info} vs out={kind}{info}"
                 )
                 raise GuppyCodegenError(msg)
             validated_outs.append((kind, info))
 
+        # Cross-input aliasing check (still Phase 1, pre-consume): two distinct
+        # quantum arg_bindings must not reference the same outer qubit slot.
+        # Without this, the overlap would only surface mid-Phase-2 as a
+        # LinearityError ("slot consumed") with the tracker half-mutated. Raising
+        # here keeps the "all validation before linearity mutation" invariant
+        # strict (Codex 2026-05-15 iter-5d review #3). Bits are copyable so
+        # single_bit args are excluded.
+        seen_slots: dict[tuple[str, int], str] = {}
+        for inp, kind, info in validated_args:
+            if kind == "array":
+                alloc, outer_size = info
+                slots = [(alloc, i) for i in range(outer_size)]
+            elif kind == "single_qubit":
+                slots = [info]
+            elif kind == "qubit_bundle":
+                slots = list(info)
+            else:  # single_bit -- no qubit slots
+                continue
+            for slot in slots:
+                if slot in seen_slots:
+                    msg = (
+                        f"BlockCall {node.callee!r}: qubit slot "
+                        f"{slot[0]}[{slot[1]}] is referenced by more than one "
+                        f"arg_binding (inputs {seen_slots[slot]!r} and "
+                        f"{inp.name!r}); a qubit cannot be passed to two inputs"
+                    )
+                    raise GuppyCodegenError(msg)
+                seen_slots[slot] = inp.name
+
         # Phase 2: now that every check passed, consume slots and emit code.
         linearity = self._linearity()
         arg_exprs: list[str] = []
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
index 94c1783f2..f51bd3e86 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
@@ -797,7 +797,7 @@ def test_single_qubit_mismatched_arg_out_slot_rejected(self) -> None:
                 ),
             ),
         )
-        with pytest.raises(GuppyCodegenError, match=r"must use matching arg_binding and out_binding"):
+        with pytest.raises(GuppyCodegenError, match=r"must use an identical arg_binding and out_binding"):
             ast_to_guppy(prog)
 
     def test_allocator_mismatched_arg_out_name_rejected(self) -> None:
@@ -828,7 +828,7 @@ def test_allocator_mismatched_arg_out_name_rejected(self) -> None:
                 ),
             ),
         )
-        with pytest.raises(GuppyCodegenError, match=r"must use matching arg_binding and out_binding"):
+        with pytest.raises(GuppyCodegenError, match=r"must use an identical arg_binding and out_binding"):
             ast_to_guppy(prog)
 
     def test_single_qubit_slot_index_out_of_bounds_rejected(self) -> None:
@@ -1047,6 +1047,111 @@ def test_qubit_bundle_packs_and_unpacks_arbitrary_slots(self) -> None:
         assert "c[0] = measure(a_2)" in source
         assert "c[1] = measure(b_0)" in source
 
+    def test_qubit_bundle_end_to_end_selene_bell_correlation(self) -> None:
+        """Compile + run the cross-allocator bundle program through Selene.
+
+        Codex 2026-05-15 iter-5d review #1: the support test was string-shape
+        only; the iter-5b r1 blocker proved a string can look right while the
+        Guppy fails its own linearity. This compiles the generated Guppy via
+        the entry wrapper and pins the seeded Selene records (the bundled
+        slots a[2] and b[0] form a Bell pair, so the two measurements are
+        perfectly correlated per shot).
+        """
+        import importlib.util
+        import sys
+        import tempfile
+        import warnings
+        from pathlib import Path
+
+        from pecos import Hugr, selene_engine, sim
+        from pecos.slr.ast.codegen.entry_wrapper import build_no_arg_entry_wrapper
+
+        program = self._build_bundle_program()
+        main_source = ast_to_guppy(program)
+        entry_source, _info = build_no_arg_entry_wrapper(program)
+        full_source = main_source + entry_source
+
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+            path = Path(f.name)
+            f.write(full_source)
+
+        spec = importlib.util.spec_from_file_location(f"_bundle_smoke_{path.stem}", path)
+        assert spec is not None
+        assert spec.loader is not None
+        module = importlib.util.module_from_spec(spec)
+        sys.modules[spec.name] = module
+        try:
+            spec.loader.exec_module(module)
+        except BaseException as exc:
+            err = f"Generated Guppy failed to import:\n{full_source}\n---\n{exc}"
+            raise AssertionError(err) from exc
+
+        package = module.entry.compile()
+        hugr_bytes = package.to_str().encode("utf-8")
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", DeprecationWarning)
+            result = sim(Hugr(hugr_bytes)).classical(selene_engine()).qubits(5).seed(42).run(8)
+        raw = result.to_dict() if hasattr(result, "to_dict") else result
+        # Empirical probe 2026-05-15 (matches Codex's independent r1 probe):
+        assert raw == {
+            "measurement_0": [1, 0, 0, 1, 0, 0, 0, 1],
+            "measurement_1": [1, 0, 0, 1, 0, 0, 0, 1],
+        }, raw
+        # Bell correlation: bundled slots a[2] and b[0] measure identically.
+        assert raw["measurement_0"] == raw["measurement_1"], raw
+
+    def test_qubit_bundle_cross_input_alias_rejected_pre_consume(self) -> None:
+        """Codex 2026-05-15 iter-5d review #3: a slot referenced by two distinct
+        quantum arg_bindings must raise a clean GuppyCodegenError in Phase 1
+        (pre-consume), not a mid-Phase-2 LinearityError with the tracker
+        half-mutated.
+        """
+        from pecos.slr.ast.nodes import QubitBundleArg, SingleQubitArg
+
+        decl = BlockDecl(
+            name="b",
+            inputs=(
+                BlockInput(name="x", effect=ResourceEffect.CONSUMED, type_expr=QubitTypeExpr()),
+                BlockInput(
+                    name="ys",
+                    effect=ResourceEffect.LIVE_PRESERVED,
+                    type_expr=ArrayTypeExpr(element=QubitTypeExpr(), size=2),
+                ),
+            ),
+            body=(MeasureOp(targets=(SlotRef(allocator="x", index=0),)),),
+        )
+        # outer_q[0] is bound to BOTH input x (single qubit) and the bundle ys.
+        prog = Program(
+            name="main",
+            allocator=AllocatorDecl(name="outer_q", capacity=3),
+            block_decls=(decl,),
+            body=(
+                PrepareOp(allocator="outer_q"),
+                BlockCall(
+                    callee="b",
+                    arg_bindings=(
+                        SingleQubitArg(slot=SlotRef(allocator="outer_q", index=0)),
+                        QubitBundleArg(
+                            slots=(
+                                SlotRef(allocator="outer_q", index=0),
+                                SlotRef(allocator="outer_q", index=1),
+                            ),
+                        ),
+                    ),
+                    out_bindings=(
+                        QubitBundleArg(
+                            slots=(
+                                SlotRef(allocator="outer_q", index=0),
+                                SlotRef(allocator="outer_q", index=1),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+        )
+        with pytest.raises(GuppyCodegenError, match=r"referenced by more than one arg_binding"):
+            ast_to_guppy(prog)
+
     def test_qubit_bundle_size_mismatch_rejected(self) -> None:
         from pecos.slr.ast.nodes import QubitBundleArg
 

From 490f483a3b34e9a8841c0c19380f54d42182a4a0 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Fri, 15 May 2026 22:15:58 -0600
Subject: [PATCH 045/136] Iter-5d r2 polish: add asymmetric bundle test that
 genuinely pins unpack order; reword Bell test to not over-claim
 order-sensitivity; fix stale validated_args tag comment.

---
 .../src/pecos/slr/ast/codegen/guppy.py        |  5 +-
 .../ast_guppy/test_block_call_smoke.py        | 88 +++++++++++++++++++
 2 files changed, 91 insertions(+), 2 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
index 1076f291a..ba42c183f 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
@@ -979,8 +979,9 @@ def _emit_block_call(self, node: BlockCall) -> list[str]:
         # Phase 1: validate every arg + out binding BEFORE touching linearity state, so
         # a late-raised GuppyCodegenError can't leave the tracker half-consumed (Codex
         # 2026-05-15 review).
-        # Each validated_args entry is tagged with "array" or "single_qubit" so the
-        # Phase-2 emit step knows how to pack the call argument.
+        # Each validated_args entry is tagged with one of "array",
+        # "single_qubit", "single_bit", or "qubit_bundle" so the Phase-2 emit
+        # step knows how to pack the call argument.
         validated_args: list[tuple[BlockInput, str, tuple]] = []
         live_inputs_out: list[BlockInput] = []
         for inp, arg in zip(decl.inputs, node.arg_bindings, strict=True):
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
index f51bd3e86..c6c656b68 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
@@ -1056,6 +1056,12 @@ def test_qubit_bundle_end_to_end_selene_bell_correlation(self) -> None:
         the entry wrapper and pins the seeded Selene records (the bundled
         slots a[2] and b[0] form a Bell pair, so the two measurements are
         perfectly correlated per shot).
+
+        Note: this is a *compile + behavior* gate, not an unpack-order gate.
+        Bell measurements are symmetric, so a swapped bundle unpack order
+        would still pass here. `test_qubit_bundle_asymmetric_unpack_order`
+        below pins unpack order with an asymmetric bundle (Codex 2026-05-15
+        iter-5d r2 review #1).
         """
         import importlib.util
         import sys
@@ -1100,6 +1106,88 @@ def test_qubit_bundle_end_to_end_selene_bell_correlation(self) -> None:
         # Bell correlation: bundled slots a[2] and b[0] measure identically.
         assert raw["measurement_0"] == raw["measurement_1"], raw
 
+    def test_qubit_bundle_asymmetric_unpack_order(self) -> None:
+        """Pin bundle unpack ORDER with an asymmetric program.
+
+        Codex 2026-05-15 iter-5d r2 review #1: the Bell-correlation test is
+        symmetric, so a swapped bundle unpack (`b_0, a_2 = ret` instead of
+        `a_2, b_0 = ret`) still passes it. Here the block applies X to q[0]
+        ONLY, so the two bundled slots end in DIFFERENT states: a[2] (<- q[0],
+        X'd) measures 1, b[0] (<- q[1], untouched) measures 0. A swapped
+        unpack would flip both records, failing this test.
+        """
+        import importlib.util
+        import sys
+        import tempfile
+        import warnings
+        from pathlib import Path
+
+        from pecos import Hugr, selene_engine, sim
+        from pecos.slr.ast.codegen.entry_wrapper import build_no_arg_entry_wrapper
+        from pecos.slr.ast.nodes import QubitBundleArg
+
+        decl = BlockDecl(
+            name="asym",
+            inputs=(
+                BlockInput(
+                    name="q",
+                    effect=ResourceEffect.LIVE_PRESERVED,
+                    type_expr=ArrayTypeExpr(element=QubitTypeExpr(), size=2),
+                ),
+            ),
+            # X on q[0] ONLY -- breaks the symmetry between the two bundled slots.
+            body=(GateOp(gate=GateKind.X, targets=(SlotRef(allocator="q", index=0),)),),
+        )
+        bundle = QubitBundleArg(
+            slots=(SlotRef(allocator="a", index=2), SlotRef(allocator="b", index=0)),
+        )
+        program = Program(
+            name="main",
+            allocator=AllocatorDecl(name="a", capacity=3),
+            declarations=(AllocatorDecl(name="b", capacity=2), RegisterDecl(name="c", size=2)),
+            block_decls=(decl,),
+            body=(
+                PrepareOp(allocator="a"),
+                PrepareOp(allocator="b"),
+                BlockCall(callee="asym", arg_bindings=(bundle,), out_bindings=(bundle,)),
+                MeasureOp(
+                    targets=(SlotRef(allocator="a", index=2), SlotRef(allocator="b", index=0)),
+                    results=(BitRef(register="c", index=0), BitRef(register="c", index=1)),
+                ),
+            ),
+        )
+        main_source = ast_to_guppy(program)
+        entry_source, _info = build_no_arg_entry_wrapper(program)
+        full_source = main_source + entry_source
+
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+            path = Path(f.name)
+            f.write(full_source)
+
+        spec = importlib.util.spec_from_file_location(f"_bundle_asym_{path.stem}", path)
+        assert spec is not None
+        assert spec.loader is not None
+        module = importlib.util.module_from_spec(spec)
+        sys.modules[spec.name] = module
+        try:
+            spec.loader.exec_module(module)
+        except BaseException as exc:
+            err = f"Generated Guppy failed to import:\n{full_source}\n---\n{exc}"
+            raise AssertionError(err) from exc
+
+        package = module.entry.compile()
+        hugr_bytes = package.to_str().encode("utf-8")
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", DeprecationWarning)
+            result = sim(Hugr(hugr_bytes)).classical(selene_engine()).qubits(5).seed(42).run(4)
+        raw = result.to_dict() if hasattr(result, "to_dict") else result
+        # Empirical probe 2026-05-15: a[2] <- X'd q[0] -> 1; b[0] <- untouched
+        # q[1] -> 0. Swapped unpack order would yield the inverse.
+        assert raw == {
+            "measurement_0": [1, 1, 1, 1],
+            "measurement_1": [0, 0, 0, 0],
+        }, raw
+
     def test_qubit_bundle_cross_input_alias_rejected_pre_consume(self) -> None:
         """Codex 2026-05-15 iter-5d review #3: a slot referenced by two distinct
         quantum arg_bindings must raise a clean GuppyCodegenError in Phase 1

From 74ea9cc5152baed9a769f1871b9773429369e05b Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sat, 16 May 2026 00:04:01 -0600
Subject: [PATCH 046/136] Phase 3a.3 iter 5e.1: unify BlockDecl-body
 substitution into shared BodyRemap + recursive substitute_stmt
 (slot/bit-level, reject-on-partial); converter + flatten both delegate to it;
 24 synthetic non-identity tests. Byte-identical on the 7 Steane conversions.

---
 .../src/pecos/slr/ast/_block_substitution.py  | 376 ++++++++++++++++++
 .../pecos/slr/ast/codegen/_block_flatten.py   | 200 ++--------
 .../src/pecos/slr/ast/converter.py            | 161 +-------
 .../ast_guppy/test_block_call_smoke.py        |  39 +-
 .../ast_guppy/test_block_substitution.py      | 282 +++++++++++++
 5 files changed, 714 insertions(+), 344 deletions(-)
 create mode 100644 python/quantum-pecos/src/pecos/slr/ast/_block_substitution.py
 create mode 100644 python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_substitution.py

diff --git a/python/quantum-pecos/src/pecos/slr/ast/_block_substitution.py b/python/quantum-pecos/src/pecos/slr/ast/_block_substitution.py
new file mode 100644
index 000000000..369b49c6e
--- /dev/null
+++ b/python/quantum-pecos/src/pecos/slr/ast/_block_substitution.py
@@ -0,0 +1,376 @@
+# Copyright 2026 The PECOS Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations under the License.
+
+"""Phase 3a.3 iter 5e.1 -- shared BlockDecl-body reference substitution.
+
+`BodyRemap` is a bidirectional slot/bit/whole-name remap. Two consumers
+build it in opposite directions but use the identical substitution core:
+
+- `converter._convert_block_call` builds an OUTER -> PARAM remap, turning a
+  Block instance's body into a reusable `BlockDecl` body.
+- `_block_flatten._inline_call` builds the inverse PARAM -> OUTER remap,
+  inlining a `BlockDecl` body at its call site for non-Guppy codegens.
+
+Unifying both into one `substitute_stmt` eliminates the
+fix-one-forget-the-mirror bug class (Codex caught PermuteOp and BlockCall
+gaps in earlier passes precisely because two parallel copies drifted).
+
+`substitute_stmt` is **fully recursive** over every node that can carry a
+`SlotRef` / `BitRef` / expression, including the spots the pre-5e
+allocator-name-only substitution silently skipped (`MeasureOp.results`,
+`AssignOp`, `PrintOp`, `ReturnOp`, conditions, `GateOp.params`,
+`ForStmt` bounds, nested `BlockCall`).
+
+Name-level refs (`BarrierOp`, bare `PermuteOp`, `PrepareOp(slots=None)`,
+`VarExpr`, str `ReturnOp`/`AssignOp` targets) cannot express a partial
+(single-qubit / bundle / single-bit) binding; touching a partially-bound
+outer name raises `BodySubstitutionError` rather than silently leaking it.
+
+See `~/Repos/pecos-docs/design/slr/v2-iter5e-check-conversion-plan.md`.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING
+
+from pecos.slr.ast.nodes import (
+    AllocatorArg,
+    AssignOp,
+    BarrierOp,
+    BinaryExpr,
+    BitBundleArg,
+    BitExpr,
+    BitRef,
+    BlockCall,
+    CommentOp,
+    ForStmt,
+    GateOp,
+    IfStmt,
+    LiteralExpr,
+    MeasureOp,
+    ParallelBlock,
+    PermuteOp,
+    PrepareOp,
+    PrintOp,
+    QubitBundleArg,
+    RepeatStmt,
+    ReturnOp,
+    SingleBitArg,
+    SingleQubitArg,
+    SlotRef,
+    UnaryExpr,
+    VarExpr,
+    WhileStmt,
+)
+
+if TYPE_CHECKING:
+    from pecos.slr.ast.nodes import BlockArg, Expression, Statement
+
+# A PermuteOp source/target string is either a bare name or `name[idx]`.
+_PERMUTE_REF_RE = re.compile(r"([A-Za-z_]\w*)(?:\[(\d+)\])?$")
+
+
+class BodySubstitutionError(ValueError):
+    """A body reference cannot be substituted (e.g. partial-binding name use).
+
+    Subclasses `ValueError` so existing call sites/tests that expect a
+    `ValueError` from the old per-helper substitution keep working.
+    """
+
+
+class BodyRemap:
+    """Slot/bit/whole-name remap for BlockDecl body rewriting.
+
+    Tables map a source `(name, index)` to a destination `(name, index)`.
+    `whole_alloc` records names that are bound *completely* (a whole-`QReg`
+    binding); only those may be renamed at the name level. Any name that
+    appears in a per-slot/per-bit binding (single qubit, bundle, single
+    bit) is recorded as *partial*: name-level use of it is rejected.
+    """
+
+    def __init__(self) -> None:
+        self._slot: dict[tuple[str, int], tuple[str, int]] = {}
+        self._bit: dict[tuple[str, int], tuple[str, int]] = {}
+        self._whole_alloc: dict[str, str] = {}
+        self._partial_names: set[str] = set()
+
+    # ---- builders ----
+
+    def add_whole_alloc(self, src: str, dst: str, size: int) -> None:
+        """Bind a whole QReg `src` (size N) to `dst`, identity per-slot."""
+        self._whole_alloc[src] = dst
+        for i in range(size):
+            self._slot[(src, i)] = (dst, i)
+
+    def add_slot(self, src: tuple[str, int], dst: tuple[str, int]) -> None:
+        """Bind one outer qubit slot; marks `src` allocator partial."""
+        self._slot[src] = dst
+        self._partial_names.add(src[0])
+
+    def add_bit(self, src: tuple[str, int], dst: tuple[str, int]) -> None:
+        """Bind one outer classical bit; marks `src` register partial."""
+        self._bit[src] = dst
+        self._partial_names.add(src[0])
+
+    # ---- lookups ----
+
+    def slot(self, ref: SlotRef) -> SlotRef:
+        dst = self._slot.get((ref.allocator, ref.index))
+        if dst is None:
+            return ref
+        return SlotRef(allocator=dst[0], index=dst[1], location=ref.location)
+
+    def bit(self, ref: BitRef) -> BitRef:
+        dst = self._bit.get((ref.register, ref.index))
+        if dst is None:
+            return ref
+        return BitRef(register=dst[0], index=dst[1], location=ref.location)
+
+    def whole_name(self, name: str, *, context: str) -> str:
+        """Rename a whole-allocator/register name; reject if partially bound.
+
+        Unmapped names pass through unchanged (they reference allocators not
+        bound by any input -- a Block-local register, say).
+        """
+        if name in self._whole_alloc:
+            return self._whole_alloc[name]
+        if name in self._partial_names:
+            msg = (
+                f"{context} references {name!r}, which is only partially bound "
+                f"(a single-qubit / bundle / single-bit input). A whole-name "
+                f"reference cannot express that binding -- pass the whole "
+                f"register, or restructure the Block so the body does not use "
+                f"{name!r} by bare name."
+            )
+            raise BodySubstitutionError(msg)
+        return name
+
+
+def substitute_stmt(stmt: Statement, remap: BodyRemap) -> Statement:
+    """Return `stmt` with every slot/bit/expression reference remapped."""
+    if isinstance(stmt, GateOp):
+        return GateOp(
+            gate=stmt.gate,
+            targets=tuple(remap.slot(t) for t in stmt.targets),
+            params=tuple(_sub_expr(p, remap) for p in stmt.params),
+            location=stmt.location,
+        )
+    if isinstance(stmt, MeasureOp):
+        return MeasureOp(
+            targets=tuple(remap.slot(t) for t in stmt.targets),
+            results=tuple(remap.bit(r) for r in stmt.results),
+            location=stmt.location,
+        )
+    if isinstance(stmt, PrepareOp):
+        return _sub_prepare(stmt, remap)
+    if isinstance(stmt, BarrierOp):
+        return BarrierOp(
+            allocators=tuple(
+                remap.whole_name(a, context="Barrier") for a in stmt.allocators
+            ),
+            location=stmt.location,
+        )
+    if isinstance(stmt, AssignOp):
+        target = stmt.target
+        new_target = (
+            remap.bit(target)
+            if isinstance(target, BitRef)
+            else remap.whole_name(target, context="assignment target")
+        )
+        return AssignOp(
+            target=new_target,
+            value=_sub_expr(stmt.value, remap),
+            location=stmt.location,
+        )
+    if isinstance(stmt, ReturnOp):
+        return ReturnOp(
+            values=tuple(
+                _sub_expr(v, remap)
+                if not isinstance(v, str)
+                else remap.whole_name(v, context="Return value")
+                for v in stmt.values
+            ),
+            location=stmt.location,
+        )
+    if isinstance(stmt, PrintOp):
+        value = stmt.value
+        new_value = (
+            remap.bit(value)
+            if isinstance(value, BitRef)
+            else remap.whole_name(value, context="Print value")
+        )
+        return PrintOp(
+            value=new_value,
+            tag=stmt.tag,
+            namespace=stmt.namespace,
+            location=stmt.location,
+        )
+    if isinstance(stmt, IfStmt):
+        return IfStmt(
+            condition=_sub_expr(stmt.condition, remap),
+            then_body=tuple(substitute_stmt(s, remap) for s in stmt.then_body),
+            else_body=tuple(substitute_stmt(s, remap) for s in stmt.else_body),
+            location=stmt.location,
+        )
+    if isinstance(stmt, WhileStmt):
+        return WhileStmt(
+            condition=_sub_expr(stmt.condition, remap),
+            body=tuple(substitute_stmt(s, remap) for s in stmt.body),
+            location=stmt.location,
+        )
+    if isinstance(stmt, ForStmt):
+        return ForStmt(
+            variable=stmt.variable,
+            start=_sub_expr(stmt.start, remap),
+            stop=_sub_expr(stmt.stop, remap),
+            step=None if stmt.step is None else _sub_expr(stmt.step, remap),
+            body=tuple(substitute_stmt(s, remap) for s in stmt.body),
+            location=stmt.location,
+        )
+    if isinstance(stmt, RepeatStmt):
+        return RepeatStmt(
+            count=stmt.count,  # plain int -- no refs
+            body=tuple(substitute_stmt(s, remap) for s in stmt.body),
+            location=stmt.location,
+        )
+    if isinstance(stmt, ParallelBlock):
+        return ParallelBlock(
+            body=tuple(substitute_stmt(s, remap) for s in stmt.body),
+            location=stmt.location,
+        )
+    if isinstance(stmt, PermuteOp):
+        return PermuteOp(
+            sources=tuple(_sub_permute_ref(r, remap) for r in stmt.sources),
+            targets=tuple(_sub_permute_ref(r, remap) for r in stmt.targets),
+            add_comment=stmt.add_comment,
+            location=stmt.location,
+        )
+    if isinstance(stmt, BlockCall):
+        return BlockCall(
+            callee=stmt.callee,
+            arg_bindings=tuple(_sub_block_arg(a, remap) for a in stmt.arg_bindings),
+            out_bindings=tuple(_sub_block_arg(a, remap) for a in stmt.out_bindings),
+            location=stmt.location,
+        )
+    # CommentOp + anything else carrying no slot/bit/expr ref: pass through.
+    if not isinstance(stmt, CommentOp):  # defensive: surface unhandled nodes
+        # Unknown statement types are passed through unchanged, matching the
+        # pre-5e behavior; if a new ref-bearing node is added it must be
+        # wired in here (the iter-5e plan's recurring-risk note).
+        pass
+    return stmt
+
+
+def _sub_expr(expr: Expression, remap: BodyRemap) -> Expression:
+    """Recurse an expression, remapping any BitRef/VarExpr it contains."""
+    if isinstance(expr, LiteralExpr):
+        return expr
+    if isinstance(expr, VarExpr):
+        return VarExpr(
+            name=remap.whole_name(expr.name, context="variable expression"),
+            location=expr.location,
+        )
+    if isinstance(expr, BitExpr):
+        return BitExpr(ref=remap.bit(expr.ref), location=expr.location)
+    if isinstance(expr, BinaryExpr):
+        return BinaryExpr(
+            op=expr.op,
+            left=_sub_expr(expr.left, remap),
+            right=_sub_expr(expr.right, remap),
+            location=expr.location,
+        )
+    if isinstance(expr, UnaryExpr):
+        return UnaryExpr(
+            op=expr.op,
+            operand=_sub_expr(expr.operand, remap),
+            location=expr.location,
+        )
+    return expr
+
+
+def _sub_prepare(stmt: PrepareOp, remap: BodyRemap) -> PrepareOp:
+    """Remap a PrepareOp.
+
+    `slots=None` (prepare_all) is a whole-register op -> name-level rename
+    (reject if partially bound). `slots=(...)` is per-slot: remap each
+    `(allocator, i)`; all must land in the same destination allocator.
+    """
+    if stmt.slots is None:
+        return PrepareOp(
+            allocator=remap.whole_name(stmt.allocator, context="Prepare-all"),
+            slots=None,
+            location=stmt.location,
+        )
+    remapped = [remap.slot(SlotRef(allocator=stmt.allocator, index=i)) for i in stmt.slots]
+    dst_allocs = {r.allocator for r in remapped}
+    if len(dst_allocs) > 1:
+        msg = (
+            f"Prepare on {stmt.allocator!r} maps to multiple destination "
+            f"allocators {sorted(dst_allocs)} under a bundle binding; a single "
+            "Prepare cannot span allocators -- restructure the Block."
+        )
+        raise BodySubstitutionError(msg)
+    (dst_alloc,) = dst_allocs
+    return PrepareOp(
+        allocator=dst_alloc,
+        slots=tuple(r.index for r in remapped),
+        location=stmt.location,
+    )
+
+
+def _sub_permute_ref(ref: str, remap: BodyRemap) -> str:
+    """Remap a PermuteOp `name` or `name[idx]` string.
+
+    `name[idx]` resolves through the per-slot table (works for whole-alloc
+    identity AND bundles). Bare `name` is a whole-register reference ->
+    name-level rename, rejected if partially bound. Unparseable refs that
+    mention a partially-bound name are rejected rather than silently leaked.
+    """
+    match = _PERMUTE_REF_RE.fullmatch(ref)
+    if match is None:
+        for name in remap._partial_names:  # noqa: SLF001 -- same module
+            if name in ref:
+                msg = (
+                    f"Cannot substitute PermuteOp ref {ref!r}: unsupported "
+                    f"ref form mentions partially-bound name {name!r}"
+                )
+                raise BodySubstitutionError(msg)
+        return ref
+    name, idx = match.group(1), match.group(2)
+    if idx is None:
+        return remap.whole_name(name, context="Permute")
+    new = remap.slot(SlotRef(allocator=name, index=int(idx)))
+    return f"{new.allocator}[{new.index}]"
+
+
+def _sub_block_arg(arg: BlockArg, remap: BodyRemap) -> BlockArg:
+    """Remap a nested BlockCall's arg/out BlockArg through the remap."""
+    if isinstance(arg, AllocatorArg):
+        return AllocatorArg(
+            name=remap.whole_name(arg.name, context="nested BlockCall AllocatorArg"),
+            location=arg.location,
+        )
+    if isinstance(arg, SingleQubitArg):
+        return SingleQubitArg(slot=remap.slot(arg.slot), location=arg.location)
+    if isinstance(arg, SingleBitArg):
+        return SingleBitArg(bit=remap.bit(arg.bit), location=arg.location)
+    if isinstance(arg, QubitBundleArg):
+        return QubitBundleArg(
+            slots=tuple(remap.slot(s) for s in arg.slots),
+            location=arg.location,
+        )
+    if isinstance(arg, BitBundleArg):
+        return BitBundleArg(
+            bits=tuple(remap.bit(b) for b in arg.bits),
+            location=arg.location,
+        )
+    return arg
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/_block_flatten.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/_block_flatten.py
index bdae40cdc..1836d9665 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/_block_flatten.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/_block_flatten.py
@@ -24,35 +24,22 @@
 
 from __future__ import annotations
 
-import re
 from typing import TYPE_CHECKING
 
+from pecos.slr.ast._block_substitution import BodyRemap, substitute_stmt
 from pecos.slr.ast.nodes import (
     AllocatorArg,
-    BarrierOp,
-    BitBundleArg,
-    BitRef,
     BlockCall,
     ForStmt,
-    GateOp,
     IfStmt,
-    MeasureOp,
     ParallelBlock,
-    PermuteOp,
-    PrepareOp,
     Program,
-    QubitBundleArg,
     RepeatStmt,
-    SingleBitArg,
-    SingleQubitArg,
-    SlotRef,
     WhileStmt,
 )
 
-_PERMUTE_REF_RE = re.compile(r"([A-Za-z_]\w*)(\[\d+\])?$")
-
 if TYPE_CHECKING:
-    from pecos.slr.ast.nodes import BlockArg, BlockDecl, Statement
+    from pecos.slr.ast.nodes import BlockDecl, Statement
 
 
 def validate_unique_block_decl_names(program: Program) -> None:
@@ -162,162 +149,31 @@ def _inline_call(call: BlockCall, decls: dict[str, BlockDecl]) -> tuple[Statemen
             f"BlockDecl declares {len(decl.inputs)} inputs"
         )
         raise ValueError(msg)
-    # Build a name-level mapping from BlockDecl input parameter names to the outer
-    # binding name. Only AllocatorArg is supported in the iter 5a flatten path;
-    # richer args (single qubit/bit, bundles) need full slot-level rewriting
-    # which lands with their respective flatten support iterations.
-    mapping: dict[str, str] = {}
-    for inp, arg in zip(decl.inputs, call.arg_bindings, strict=True):
-        if isinstance(arg, AllocatorArg):
-            mapping[inp.name] = arg.name
-        else:
-            msg = (
-                f"Flatten pass does not yet support BlockArg {type(arg).__name__} for "
-                f"input {inp.name!r} of {call.callee!r}; only AllocatorArg is supported "
-                "in Phase 3a.3 iter 5a"
-            )
-            raise NotImplementedError(msg)
-    # Symmetric out_bindings validation: silently allowing a deferred BlockArg
-    # subclass here would yield byte-identical flatten output (since
-    # out_bindings don't affect the inlined body in iter 5a) but would mask the
-    # fact that the caller used an unsupported shape -- a silent-fallback class
-    # of bug (Codex 2026-05-15 review of fix-pass-5).
-    for out in call.out_bindings:
-        if not isinstance(out, AllocatorArg):
-            msg = (
-                f"Flatten pass does not yet support BlockArg {type(out).__name__} in "
-                f"out_bindings of {call.callee!r}; only AllocatorArg is supported in "
-                "Phase 3a.3 iter 5a"
-            )
-            raise NotImplementedError(msg)
-    return tuple(_substitute(stmt, mapping) for stmt in decl.body)
-
-
-def _substitute(stmt: Statement, mapping: dict[str, str]) -> Statement:
-    """Rewrite every SlotRef.allocator and PrepareOp/BarrierOp allocator name."""
-    if isinstance(stmt, GateOp):
-        return GateOp(
-            gate=stmt.gate,
-            targets=tuple(_sub_slot(t, mapping) for t in stmt.targets),
-            params=stmt.params,
-            location=stmt.location,
-        )
-    if isinstance(stmt, MeasureOp):
-        return MeasureOp(
-            targets=tuple(_sub_slot(t, mapping) for t in stmt.targets),
-            results=stmt.results,
-            location=stmt.location,
-        )
-    if isinstance(stmt, PrepareOp):
-        return PrepareOp(
-            allocator=mapping.get(stmt.allocator, stmt.allocator),
-            slots=stmt.slots,
-            location=stmt.location,
-        )
-    if isinstance(stmt, BarrierOp):
-        return BarrierOp(
-            allocators=tuple(mapping.get(a, a) for a in stmt.allocators),
-            location=stmt.location,
-        )
-    if isinstance(stmt, IfStmt):
-        return IfStmt(
-            condition=stmt.condition,
-            then_body=tuple(_substitute(s, mapping) for s in stmt.then_body),
-            else_body=tuple(_substitute(s, mapping) for s in stmt.else_body),
-            location=stmt.location,
-        )
-    if isinstance(stmt, RepeatStmt):
-        return RepeatStmt(
-            count=stmt.count,
-            body=tuple(_substitute(s, mapping) for s in stmt.body),
-            location=stmt.location,
-        )
-    if isinstance(stmt, ForStmt):
-        return ForStmt(
-            variable=stmt.variable,
-            start=stmt.start,
-            stop=stmt.stop,
-            step=stmt.step,
-            body=tuple(_substitute(s, mapping) for s in stmt.body),
-            location=stmt.location,
-        )
-    if isinstance(stmt, WhileStmt):
-        return WhileStmt(
-            condition=stmt.condition,
-            body=tuple(_substitute(s, mapping) for s in stmt.body),
-            location=stmt.location,
-        )
-    if isinstance(stmt, ParallelBlock):
-        return ParallelBlock(body=tuple(_substitute(s, mapping) for s in stmt.body), location=stmt.location)
-    if isinstance(stmt, PermuteOp):
-        return PermuteOp(
-            sources=tuple(_sub_permute_ref(r, mapping) for r in stmt.sources),
-            targets=tuple(_sub_permute_ref(r, mapping) for r in stmt.targets),
-            add_comment=stmt.add_comment,
-            location=stmt.location,
-        )
-    if isinstance(stmt, BlockCall):
-        # Nested BlockCall: rewrite arg_bindings/out_bindings from outer names to
-        # input parameter names. Codex 2026-05-15 review #1.
-        return BlockCall(
-            callee=stmt.callee,
-            arg_bindings=tuple(_sub_block_arg(a, mapping) for a in stmt.arg_bindings),
-            out_bindings=tuple(_sub_block_arg(a, mapping) for a in stmt.out_bindings),
-            location=stmt.location,
-        )
-    # Pass through statements that don't reference slot allocators directly.
-    return stmt
-
-
-def _sub_block_arg(arg: BlockArg, mapping: dict[str, str]) -> BlockArg:
-    """Rewrite a BlockArg's referenced names per the mapping (for nested calls)."""
-    if isinstance(arg, AllocatorArg):
-        return AllocatorArg(name=mapping.get(arg.name, arg.name), location=arg.location)
-    if isinstance(arg, SingleQubitArg):
-        return SingleQubitArg(slot=_sub_slot(arg.slot, mapping), location=arg.location)
-    if isinstance(arg, SingleBitArg):
-        return SingleBitArg(bit=_sub_bit_ref(arg.bit, mapping), location=arg.location)
-    if isinstance(arg, QubitBundleArg):
-        return QubitBundleArg(
-            slots=tuple(_sub_slot(s, mapping) for s in arg.slots),
-            location=arg.location,
-        )
-    if isinstance(arg, BitBundleArg):
-        return BitBundleArg(
-            bits=tuple(_sub_bit_ref(b, mapping) for b in arg.bits),
-            location=arg.location,
-        )
-    return arg
-
-
-def _sub_bit_ref(ref: BitRef, mapping: dict[str, str]) -> BitRef:
-    if ref.register not in mapping:
-        return ref
-    return BitRef(register=mapping[ref.register], index=ref.index, location=ref.location)
-
-
-def _sub_permute_ref(ref: str, mapping: dict[str, str]) -> str:
-    """Rewrite PermuteOp source/target strings of the form `name` or `name[idx]`.
-
-    If the ref doesn't match, pass through UNLESS the ref textually mentions a
-    mapped allocator -- in that case raise rather than silently leak the outer
-    name into the flattened body (Codex 2026-05-15 review).
-    """
-    match = _PERMUTE_REF_RE.fullmatch(ref)
-    if match is None:
-        for key in mapping:
-            if key in ref:
+    # Flatten still only supports AllocatorArg (whole-QReg). SingleQubitArg /
+    # SingleBitArg / QubitBundleArg flatten support lands in 5e.2; until then
+    # they must raise (the `test_*_arg_rejected_in_flatten_pass` lock-ins
+    # depend on this). Reject in BOTH arg_bindings and out_bindings -- silently
+    # allowing a deferred shape in out_bindings would be a silent-fallback
+    # (Codex fix-pass-5).
+    for position, args in (("arg", call.arg_bindings), ("out", call.out_bindings)):
+        for arg in args:
+            if not isinstance(arg, AllocatorArg):
                 msg = (
-                    f"Cannot substitute PermuteOp ref {ref!r}: unsupported "
-                    f"ref form mentions mapped allocator {key!r}"
+                    f"Flatten pass does not yet support BlockArg "
+                    f"{type(arg).__name__} in {position}_bindings of "
+                    f"{call.callee!r}; only AllocatorArg is supported until "
+                    "Phase 3a.3 iter 5.2"
                 )
-                raise ValueError(msg)
-        return ref
-    name, suffix = match.group(1), match.group(2) or ""
-    return f"{mapping.get(name, name)}{suffix}"
-
-
-def _sub_slot(ref: SlotRef, mapping: dict[str, str]) -> SlotRef:
-    if ref.allocator not in mapping:
-        return ref
-    return SlotRef(allocator=mapping[ref.allocator], index=ref.index, location=ref.location)
+                raise NotImplementedError(msg)
+    # Build the PARAM -> OUTER BodyRemap (flatten inlines a BlockDecl body --
+    # which references param names -- at the call site, which uses the outer
+    # allocator). converter builds the inverse OUTER -> PARAM remap; both use
+    # the shared `substitute_stmt` (5e.1 unification -- one substitution core,
+    # no fix-one-forget-the-mirror drift).
+    remap = BodyRemap()
+    for inp, arg in zip(decl.inputs, call.arg_bindings, strict=True):
+        # AllocatorArg inputs are always array[qubit, N]; the emitter validates
+        # this, so flatten can trust inp.type_expr.size on this path.
+        size = getattr(inp.type_expr, "size", 0)
+        remap.add_whole_alloc(inp.name, arg.name, size)
+    return tuple(substitute_stmt(stmt, remap) for stmt in decl.body)
diff --git a/python/quantum-pecos/src/pecos/slr/ast/converter.py b/python/quantum-pecos/src/pecos/slr/ast/converter.py
index 15a3b98d6..8ad2d2890 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/converter.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/converter.py
@@ -31,9 +31,9 @@
 
 from __future__ import annotations
 
-import re
 from typing import TYPE_CHECKING, Any
 
+from pecos.slr.ast._block_substitution import BodyRemap, substitute_stmt
 from pecos.slr.ast.nodes import (
     AllocatorArg,
     AllocatorDecl,
@@ -42,7 +42,6 @@
     BarrierOp,
     BinaryExpr,
     BinaryOp,
-    BitBundleArg,
     BitExpr,
     BitRef,
     BitTypeExpr,
@@ -61,14 +60,11 @@
     PrepareOp,
     PrintOp,
     Program,
-    QubitBundleArg,
     QubitTypeExpr,
     RegisterDecl,
     RepeatStmt,
     ResourceEffect,
     ReturnOp,
-    SingleBitArg,
-    SingleQubitArg,
     SlotRef,
     UnaryExpr,
     UnaryOp,
@@ -407,7 +403,11 @@ def _convert_block_call(self, block: Block) -> BlockCall:
         inputs_spec = type(block).block_inputs  # type: ignore[attr-defined]
         # Map input name -> (resource effect enum, outer-scope binding name, size, kind="qubit"|"bit")
         bindings: list[tuple[str, ResourceEffect, str, int]] = []
-        substitution: dict[str, str] = {}  # outer allocator/register name -> input param name
+        # 5e.1: build a BodyRemap (outer -> param). SLR-side detection still
+        # only handles whole-QReg inputs (AllocatorArg); single-qubit /
+        # single-bit / bundle SLR detection is 5e.2. So only the
+        # whole-allocator (identity per-slot) builder is used here today.
+        remap = BodyRemap()
         for input_name, effect_value in inputs_spec.items():
             if not hasattr(block, input_name):
                 msg = (
@@ -429,7 +429,7 @@ def _convert_block_call(self, block: Block) -> BlockCall:
                 raise ValueError(msg)
             effect = _normalize_effect(effect_value, where=f"Block {type(block).__name__!r} input {input_name!r}")
             bindings.append((input_name, effect, outer_name, size))
-            substitution[outer_name] = input_name
+            remap.add_whole_alloc(outer_name, input_name, size)
 
         # Build the BlockDecl body by converting block.ops in a NEW sub-converter, then
         # rewriting allocator names from outer -> input parameter via _substitute.
@@ -440,7 +440,7 @@ def _convert_block_call(self, block: Block) -> BlockCall:
         sub._decl_counter = self._decl_counter  # type: ignore[attr-defined]
         sub_body = sub._convert_statements(block.ops)  # type: ignore[attr-defined]
         self._decl_counter = sub._decl_counter  # type: ignore[attr-defined]
-        rewritten_body = tuple(_substitute_stmt(stmt, substitution) for stmt in sub_body)
+        rewritten_body = tuple(substitute_stmt(stmt, remap) for stmt in sub_body)
 
         # Inputs are array[qubit, N] (Phase 3a.1 only supports quantum arrays).
         block_inputs: list[BlockInput] = []
@@ -905,148 +905,3 @@ def _normalize_effect(value: Any, *, where: str) -> ResourceEffect:
     )
     raise ValueError(msg)
 
-
-def _substitute_stmt(stmt: Any, mapping: dict[str, str]) -> Any:
-    """Rewrite SlotRef allocator + PrepareOp/BarrierOp allocator names per mapping.
-
-    Used to build a BlockDecl body that references parameter names rather than
-    the outer-scope binding names captured during the instance walk.
-    """
-    if isinstance(stmt, GateOp):
-        return GateOp(
-            gate=stmt.gate,
-            targets=tuple(_substitute_slot(t, mapping) for t in stmt.targets),
-            params=stmt.params,
-            location=stmt.location,
-        )
-    if isinstance(stmt, MeasureOp):
-        return MeasureOp(
-            targets=tuple(_substitute_slot(t, mapping) for t in stmt.targets),
-            results=stmt.results,
-            location=stmt.location,
-        )
-    if isinstance(stmt, PrepareOp):
-        return PrepareOp(
-            allocator=mapping.get(stmt.allocator, stmt.allocator),
-            slots=stmt.slots,
-            location=stmt.location,
-        )
-    if isinstance(stmt, BarrierOp):
-        return BarrierOp(
-            allocators=tuple(mapping.get(a, a) for a in stmt.allocators),
-            location=stmt.location,
-        )
-    if isinstance(stmt, IfStmt):
-        return IfStmt(
-            condition=stmt.condition,
-            then_body=tuple(_substitute_stmt(s, mapping) for s in stmt.then_body),
-            else_body=tuple(_substitute_stmt(s, mapping) for s in stmt.else_body),
-            location=stmt.location,
-        )
-    if isinstance(stmt, RepeatStmt):
-        return RepeatStmt(
-            count=stmt.count,
-            body=tuple(_substitute_stmt(s, mapping) for s in stmt.body),
-            location=stmt.location,
-        )
-    if isinstance(stmt, ForStmt):
-        return ForStmt(
-            variable=stmt.variable,
-            start=stmt.start,
-            stop=stmt.stop,
-            step=stmt.step,
-            body=tuple(_substitute_stmt(s, mapping) for s in stmt.body),
-            location=stmt.location,
-        )
-    if isinstance(stmt, WhileStmt):
-        return WhileStmt(
-            condition=stmt.condition,
-            body=tuple(_substitute_stmt(s, mapping) for s in stmt.body),
-            location=stmt.location,
-        )
-    if isinstance(stmt, ParallelBlock):
-        return ParallelBlock(
-            body=tuple(_substitute_stmt(s, mapping) for s in stmt.body),
-            location=stmt.location,
-        )
-    if isinstance(stmt, PermuteOp):
-        return PermuteOp(
-            sources=tuple(_substitute_permute_ref(r, mapping) for r in stmt.sources),
-            targets=tuple(_substitute_permute_ref(r, mapping) for r in stmt.targets),
-            add_comment=stmt.add_comment,
-            location=stmt.location,
-        )
-    if isinstance(stmt, BlockCall):
-        # Nested BlockCall inside a converted Block: arg_bindings/out_bindings were
-        # captured against the OUTER scope when the sub-converter ran. Rewrite them
-        # to use the parent Block's parameter names (Codex 2026-05-15 review #1).
-        return BlockCall(
-            callee=stmt.callee,
-            arg_bindings=tuple(_substitute_block_arg(a, mapping) for a in stmt.arg_bindings),
-            out_bindings=tuple(_substitute_block_arg(a, mapping) for a in stmt.out_bindings),
-            location=stmt.location,
-        )
-    return stmt
-
-
-def _substitute_slot(ref: SlotRef, mapping: dict[str, str]) -> SlotRef:
-    if ref.allocator not in mapping:
-        return ref
-    return SlotRef(allocator=mapping[ref.allocator], index=ref.index, location=ref.location)
-
-
-def _substitute_bit_ref(ref: BitRef, mapping: dict[str, str]) -> BitRef:
-    if ref.register not in mapping:
-        return ref
-    return BitRef(register=mapping[ref.register], index=ref.index, location=ref.location)
-
-
-def _substitute_block_arg(arg: BlockArg, mapping: dict[str, str]) -> BlockArg:
-    """Rewrite a BlockArg through the outer -> parameter-name mapping.
-
-    Used when a parent converted Block's body contains a nested BlockCall;
-    the nested call's arg_bindings/out_bindings reference outer allocator
-    or register names that must be renamed to parent input parameter names.
-    """
-    if isinstance(arg, AllocatorArg):
-        return AllocatorArg(name=mapping.get(arg.name, arg.name), location=arg.location)
-    if isinstance(arg, SingleQubitArg):
-        return SingleQubitArg(slot=_substitute_slot(arg.slot, mapping), location=arg.location)
-    if isinstance(arg, SingleBitArg):
-        return SingleBitArg(bit=_substitute_bit_ref(arg.bit, mapping), location=arg.location)
-    if isinstance(arg, QubitBundleArg):
-        return QubitBundleArg(
-            slots=tuple(_substitute_slot(s, mapping) for s in arg.slots),
-            location=arg.location,
-        )
-    if isinstance(arg, BitBundleArg):
-        return BitBundleArg(
-            bits=tuple(_substitute_bit_ref(b, mapping) for b in arg.bits),
-            location=arg.location,
-        )
-    return arg
-
-
-_PERMUTE_REF_RE = re.compile(r"([A-Za-z_]\w*)(\[\d+\])?$")
-
-
-def _substitute_permute_ref(ref: str, mapping: dict[str, str]) -> str:
-    """Rewrite PermuteOp source/target strings (`name` or `name[idx]`).
-
-    If the ref doesn't match the bare-name / indexed-name regex, pass it
-    through unchanged UNLESS the ref textually mentions a mapped allocator,
-    in which case raise -- silently leaking the outer name into the BlockDecl
-    body would be a fragile failure mode (Codex 2026-05-15 review).
-    """
-    match = _PERMUTE_REF_RE.fullmatch(ref)
-    if match is None:
-        for key in mapping:
-            if key in ref:
-                msg = (
-                    f"Cannot substitute PermuteOp ref {ref!r}: unsupported "
-                    f"ref form mentions mapped allocator {key!r}"
-                )
-                raise ValueError(msg)
-        return ref
-    name, suffix = match.group(1), match.group(2) or ""
-    return f"{mapping.get(name, name)}{suffix}"
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
index c6c656b68..4a26bb2f8 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
@@ -1602,26 +1602,27 @@ def __init__(self, q: QReg) -> None:
         assert permute_stmts[0].sources == ("outer[0]", "outer[1]")
         assert permute_stmts[0].targets == ("outer[1]", "outer[0]")
 
-    def test_unparseable_permute_ref_mentioning_mapped_key_raises(self) -> None:
-        """Defensive raise (Codex 2026-05-15 review question 3): if a PermuteOp ref
-        cannot be parsed by the bare-name / `name[idx]` regex AND the ref textually
-        mentions a mapped allocator, raise instead of silently leaking outer names.
+    def test_unparseable_permute_ref_mentioning_partial_name_raises(self) -> None:
+        """Defensive raise (Codex review q3, 5e.1 shared substitution): if a
+        PermuteOp ref cannot be parsed by the bare-name / `name[idx]` regex AND
+        the ref textually mentions a partially-bound name, raise instead of
+        silently leaking. Unrelated unparseable refs pass through unchanged.
         """
-        from pecos.slr.ast.codegen._block_flatten import _sub_permute_ref
-        from pecos.slr.ast.converter import _substitute_permute_ref
-
-        mapping = {"outer": "q"}
-        # Slice-form ref mentioning a mapped allocator -- not produced by SLR today
-        # but if the codegen layer ever sees one, it must raise rather than pass
-        # the unsubstituted string through.
-        with pytest.raises(ValueError, match=r"mapped allocator 'outer'"):
-            _substitute_permute_ref("outer[0:2]", mapping)
-        with pytest.raises(ValueError, match=r"mapped allocator 'outer'"):
-            _sub_permute_ref("outer[0:2]", mapping)
-
-        # Unrelated unparseable ref (not in mapping) passes through unchanged.
-        assert _substitute_permute_ref("other[0:2]", mapping) == "other[0:2]"
-        assert _sub_permute_ref("other[0:2]", mapping) == "other[0:2]"
+        from pecos.slr.ast._block_substitution import (
+            BodyRemap,
+            BodySubstitutionError,
+            _sub_permute_ref,
+        )
+
+        remap = BodyRemap()
+        # add_slot marks `outer` as partially bound.
+        remap.add_slot(("outer", 0), ("q", 0))
+
+        with pytest.raises(BodySubstitutionError, match=r"partially-bound name 'outer'"):
+            _sub_permute_ref("outer[0:2]", remap)
+
+        # Unrelated unparseable ref (no partial name substring) passes through.
+        assert _sub_permute_ref("other[0:2]", remap) == "other[0:2]"
 
 
 class TestSlrBlockInputsWiring:
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_substitution.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_substitution.py
new file mode 100644
index 000000000..cc53b8f8a
--- /dev/null
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_substitution.py
@@ -0,0 +1,282 @@
+# Copyright 2026 The PECOS Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations under the License.
+
+"""Phase 3a.3 iter 5e.1 -- direct unit tests for the shared body substitution.
+
+The 7 already-converted Steane Blocks only exercise the *whole-allocator
+identity* path (`q[i] -> q[i]`). Per Codex's iter-5e plan review, 5e.1 is
+"dead-code-with-tests" without coverage of the NON-identity slot/bit maps
+(`q[2] -> d[0]`, `c[3] -> out[0]`) and every recursive node kind plus the
+reject-on-partial paths. These tests pin exactly that, asserting the
+rewritten ref (not just "it compiled").
+"""
+
+from __future__ import annotations
+
+import pytest
+from pecos.slr.ast._block_substitution import (
+    BodyRemap,
+    BodySubstitutionError,
+    substitute_stmt,
+)
+from pecos.slr.ast.nodes import (
+    AllocatorArg,
+    AssignOp,
+    BarrierOp,
+    BinaryExpr,
+    BinaryOp,
+    BitExpr,
+    BitRef,
+    BlockCall,
+    CommentOp,
+    ForStmt,
+    GateKind,
+    GateOp,
+    IfStmt,
+    LiteralExpr,
+    MeasureOp,
+    ParallelBlock,
+    PermuteOp,
+    PrepareOp,
+    PrintOp,
+    QubitBundleArg,
+    RepeatStmt,
+    ReturnOp,
+    SingleBitArg,
+    SingleQubitArg,
+    SlotRef,
+    UnaryExpr,
+    UnaryOp,
+    VarExpr,
+    WhileStmt,
+)
+
+
+def _bundle_remap() -> BodyRemap:
+    """A non-identity remap: q[2]->d[0], q[5]->d[1] (qubit bundle) and
+    c[3]->out[0] (single bit). `q` and `c` become partially-bound names.
+    """
+    remap = BodyRemap()
+    remap.add_slot(("q", 2), ("d", 0))
+    remap.add_slot(("q", 5), ("d", 1))
+    remap.add_bit(("c", 3), ("out", 0))
+    return remap
+
+
+class TestSlotAndBitRemap:
+    def test_gate_targets_nonidentity(self) -> None:
+        g = GateOp(
+            gate=GateKind.CX,
+            targets=(SlotRef(allocator="q", index=2), SlotRef(allocator="q", index=5)),
+        )
+        out = substitute_stmt(g, _bundle_remap())
+        assert out.targets == (
+            SlotRef(allocator="d", index=0),
+            SlotRef(allocator="d", index=1),
+        )
+
+    def test_gate_params_expression_remapped(self) -> None:
+        # A parameterized gate whose angle expr references a bit via BitExpr.
+        g = GateOp(
+            gate=GateKind.RZ,
+            targets=(SlotRef(allocator="q", index=2),),
+            params=(BitExpr(ref=BitRef(register="c", index=3)),),
+        )
+        out = substitute_stmt(g, _bundle_remap())
+        assert out.targets == (SlotRef(allocator="d", index=0),)
+        assert out.params == (BitExpr(ref=BitRef(register="out", index=0)),)
+
+    def test_measure_results_remapped(self) -> None:
+        m = MeasureOp(
+            targets=(SlotRef(allocator="q", index=5),),
+            results=(BitRef(register="c", index=3),),
+        )
+        out = substitute_stmt(m, _bundle_remap())
+        assert out.targets == (SlotRef(allocator="d", index=1),)
+        assert out.results == (BitRef(register="out", index=0),)
+
+    def test_assign_target_and_value(self) -> None:
+        a = AssignOp(
+            target=BitRef(register="c", index=3),
+            value=BinaryExpr(
+                op=BinaryOp.XOR,
+                left=BitExpr(ref=BitRef(register="c", index=3)),
+                right=LiteralExpr(value=1),
+            ),
+        )
+        out = substitute_stmt(a, _bundle_remap())
+        assert out.target == BitRef(register="out", index=0)
+        assert out.value.left == BitExpr(ref=BitRef(register="out", index=0))
+        assert out.value.right == LiteralExpr(value=1)
+
+    def test_print_bitref_remapped(self) -> None:
+        p = PrintOp(value=BitRef(register="c", index=3), tag="t", namespace="result")
+        out = substitute_stmt(p, _bundle_remap())
+        assert out.value == BitRef(register="out", index=0)
+        assert (out.tag, out.namespace) == ("t", "result")
+
+    def test_return_expr_values(self) -> None:
+        r = ReturnOp(values=(BitExpr(ref=BitRef(register="c", index=3)),))
+        out = substitute_stmt(r, _bundle_remap())
+        assert out.values == (BitExpr(ref=BitRef(register="out", index=0)),)
+
+    def test_if_condition_nested_binary_unary(self) -> None:
+        cond = BinaryExpr(
+            op=BinaryOp.AND,
+            left=UnaryExpr(op=UnaryOp.NOT, operand=BitExpr(ref=BitRef(register="c", index=3))),
+            right=BitExpr(ref=BitRef(register="c", index=3)),
+        )
+        node = IfStmt(
+            condition=cond,
+            then_body=(GateOp(gate=GateKind.X, targets=(SlotRef(allocator="q", index=2),)),),
+            else_body=(),
+        )
+        out = substitute_stmt(node, _bundle_remap())
+        assert out.condition.left.operand == BitExpr(ref=BitRef(register="out", index=0))
+        assert out.condition.right == BitExpr(ref=BitRef(register="out", index=0))
+        assert out.then_body[0].targets == (SlotRef(allocator="d", index=0),)
+
+    def test_while_condition_and_body(self) -> None:
+        node = WhileStmt(
+            condition=BitExpr(ref=BitRef(register="c", index=3)),
+            body=(MeasureOp(targets=(SlotRef(allocator="q", index=5),), results=()),),
+        )
+        out = substitute_stmt(node, _bundle_remap())
+        assert out.condition == BitExpr(ref=BitRef(register="out", index=0))
+        assert out.body[0].targets == (SlotRef(allocator="d", index=1),)
+
+    def test_for_bounds_and_body(self) -> None:
+        node = ForStmt(
+            variable="i",
+            start=LiteralExpr(value=0),
+            stop=BitExpr(ref=BitRef(register="c", index=3)),
+            step=None,
+            body=(GateOp(gate=GateKind.X, targets=(SlotRef(allocator="q", index=2),)),),
+        )
+        out = substitute_stmt(node, _bundle_remap())
+        assert out.stop == BitExpr(ref=BitRef(register="out", index=0))
+        assert out.body[0].targets == (SlotRef(allocator="d", index=0),)
+
+    def test_repeat_and_parallel_body_recursion(self) -> None:
+        inner = GateOp(gate=GateKind.X, targets=(SlotRef(allocator="q", index=2),))
+        rep = RepeatStmt(count=3, body=(inner,))
+        par = ParallelBlock(body=(inner,))
+        ro = substitute_stmt(rep, _bundle_remap())
+        po = substitute_stmt(par, _bundle_remap())
+        assert ro.body[0].targets == (SlotRef(allocator="d", index=0),)
+        assert po.body[0].targets == (SlotRef(allocator="d", index=0),)
+
+    def test_nested_blockcall_args_remapped(self) -> None:
+        bc = BlockCall(
+            callee="inner",
+            arg_bindings=(
+                SingleQubitArg(slot=SlotRef(allocator="q", index=2)),
+                SingleBitArg(bit=BitRef(register="c", index=3)),
+                QubitBundleArg(
+                    slots=(SlotRef(allocator="q", index=2), SlotRef(allocator="q", index=5)),
+                ),
+            ),
+            out_bindings=(SingleBitArg(bit=BitRef(register="c", index=3)),),
+        )
+        out = substitute_stmt(bc, _bundle_remap())
+        assert out.arg_bindings[0] == SingleQubitArg(slot=SlotRef(allocator="d", index=0))
+        assert out.arg_bindings[1] == SingleBitArg(bit=BitRef(register="out", index=0))
+        assert out.arg_bindings[2] == QubitBundleArg(
+            slots=(SlotRef(allocator="d", index=0), SlotRef(allocator="d", index=1)),
+        )
+        assert out.out_bindings[0] == SingleBitArg(bit=BitRef(register="out", index=0))
+
+    def test_comment_passthrough(self) -> None:
+        c = CommentOp(text="hello")
+        assert substitute_stmt(c, _bundle_remap()) is c
+
+
+class TestPermuteAndPrepare:
+    def test_permute_indexed_ref_via_slot(self) -> None:
+        p = PermuteOp(sources=("q[2]", "q[5]"), targets=("q[5]", "q[2]"), add_comment=False)
+        out = substitute_stmt(p, _bundle_remap())
+        assert out.sources == ("d[0]", "d[1]")
+        assert out.targets == ("d[1]", "d[0]")
+
+    def test_permute_whole_name_renamed(self) -> None:
+        remap = BodyRemap()
+        remap.add_whole_alloc("q1", "qp", 7)
+        p = PermuteOp(sources=("q1",), targets=("q1",), add_comment=False)
+        out = substitute_stmt(p, remap)
+        assert out.sources == ("qp",)
+
+    def test_permute_bare_name_partial_rejected(self) -> None:
+        p = PermuteOp(sources=("q",), targets=("q",), add_comment=False)
+        with pytest.raises(BodySubstitutionError, match=r"partially bound"):
+            substitute_stmt(p, _bundle_remap())
+
+    def test_prepare_all_partial_rejected(self) -> None:
+        prep = PrepareOp(allocator="q", slots=None)
+        with pytest.raises(BodySubstitutionError, match=r"partially bound"):
+            substitute_stmt(prep, _bundle_remap())
+
+    def test_prepare_all_whole_renamed(self) -> None:
+        remap = BodyRemap()
+        remap.add_whole_alloc("q", "p", 3)
+        prep = PrepareOp(allocator="q", slots=None)
+        out = substitute_stmt(prep, remap)
+        assert out.allocator == "p"
+        assert out.slots is None
+
+    def test_prepare_slots_remapped(self) -> None:
+        # Prep(q[2], q[5]) under the bundle -> Prep on d[0], d[1].
+        prep = PrepareOp(allocator="q", slots=(2, 5))
+        out = substitute_stmt(prep, _bundle_remap())
+        assert out.allocator == "d"
+        assert sorted(out.slots) == [0, 1]
+
+    def test_prepare_slots_multi_allocator_rejected(self) -> None:
+        remap = BodyRemap()
+        remap.add_slot(("q", 0), ("d", 0))
+        remap.add_slot(("q", 1), ("e", 0))  # different destination allocator
+        prep = PrepareOp(allocator="q", slots=(0, 1))
+        with pytest.raises(BodySubstitutionError, match=r"multiple destination allocators"):
+            substitute_stmt(prep, remap)
+
+
+class TestRejectOnPartialNameLevel:
+    def test_barrier_partial_name_rejected(self) -> None:
+        b = BarrierOp(allocators=("q",))
+        with pytest.raises(BodySubstitutionError, match=r"Barrier .*partially bound"):
+            substitute_stmt(b, _bundle_remap())
+
+    def test_empty_barrier_passthrough(self) -> None:
+        # Barrier(a, d[i]) lowers TODAY to BarrierOp(allocators=()) -- nothing
+        # partial left to substitute; global barrier passes through.
+        b = BarrierOp(allocators=())
+        out = substitute_stmt(b, _bundle_remap())
+        assert out.allocators == ()
+
+    def test_varexpr_partial_name_rejected(self) -> None:
+        node = AssignOp(
+            target=BitRef(register="c", index=3),
+            value=VarExpr(name="q"),
+        )
+        with pytest.raises(BodySubstitutionError, match=r"variable expression .*partially bound"):
+            substitute_stmt(node, _bundle_remap())
+
+    def test_str_return_partial_name_rejected(self) -> None:
+        r = ReturnOp(values=("q",))
+        with pytest.raises(BodySubstitutionError, match=r"Return value .*partially bound"):
+            substitute_stmt(r, _bundle_remap())
+
+    def test_whole_name_unmapped_passes_through(self) -> None:
+        # A name bound by no input (Block-local) is left unchanged.
+        remap = BodyRemap()
+        remap.add_slot(("q", 0), ("d", 0))
+        b = BarrierOp(allocators=("local_reg",))
+        out = substitute_stmt(b, remap)
+        assert out.allocators == ("local_reg",)

From bcb04eb45727247f661a444561cca04cc109ecf7 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sat, 16 May 2026 00:18:02 -0600
Subject: [PATCH 047/136] Iter-5e.1 Codex early-fixes: token-boundary permute
 reject (no substring false-positive); BodyRemap rejects conflicting
 whole/partial binds at build time; exact prepare-slot-order lock-in +
 reversed-map case + builder-conflict tests.

---
 .../src/pecos/slr/ast/_block_substitution.py  | 48 ++++++++++++++---
 .../ast_guppy/test_block_call_smoke.py        |  6 ++-
 .../ast_guppy/test_block_substitution.py      | 52 +++++++++++++++++--
 3 files changed, 94 insertions(+), 12 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/_block_substitution.py b/python/quantum-pecos/src/pecos/slr/ast/_block_substitution.py
index 369b49c6e..004fd5640 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/_block_substitution.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/_block_substitution.py
@@ -77,6 +77,11 @@
 
 # A PermuteOp source/target string is either a bare name or `name[idx]`.
 _PERMUTE_REF_RE = re.compile(r"([A-Za-z_]\w*)(?:\[(\d+)\])?$")
+# Leading identifier token of an arbitrary (possibly unparseable) ref, used
+# to decide reject-on-partial WITHOUT a loose substring match -- `"q" in
+# "sq[0:2]"` would otherwise falsely reject an unrelated `sq` ref
+# (Codex 5e.1 review #1).
+_LEADING_IDENT_RE = re.compile(r"[A-Za-z_]\w*")
 
 
 class BodySubstitutionError(ValueError):
@@ -104,20 +109,45 @@ def __init__(self) -> None:
         self._partial_names: set[str] = set()
 
     # ---- builders ----
+    #
+    # An outer name may be bound in exactly ONE mode -- whole xor partial --
+    # and a whole binding maps exactly one src. Conflicting builder calls
+    # (same name bound both whole and partial, or whole-bound twice) are an
+    # input-aliasing error: reject at construction time rather than letting
+    # whole silently win at lookup (Codex 5e.1 review #2). This protects the
+    # QASM/flatten path too, where Guppy's own linearity alias check never
+    # runs.
+
+    def _reject_conflict(self, name: str, *, mode: str) -> None:
+        if name in self._whole_alloc:
+            msg = (
+                f"BodyRemap: outer name {name!r} is already bound whole; "
+                f"cannot also bind it {mode} (input aliasing)"
+            )
+            raise BodySubstitutionError(msg)
+        if name in self._partial_names and mode == "whole":
+            msg = (
+                f"BodyRemap: outer name {name!r} is already bound partially; "
+                f"cannot also bind it whole (input aliasing)"
+            )
+            raise BodySubstitutionError(msg)
 
     def add_whole_alloc(self, src: str, dst: str, size: int) -> None:
         """Bind a whole QReg `src` (size N) to `dst`, identity per-slot."""
+        self._reject_conflict(src, mode="whole")
         self._whole_alloc[src] = dst
         for i in range(size):
             self._slot[(src, i)] = (dst, i)
 
     def add_slot(self, src: tuple[str, int], dst: tuple[str, int]) -> None:
         """Bind one outer qubit slot; marks `src` allocator partial."""
+        self._reject_conflict(src[0], mode="partial (per-slot)")
         self._slot[src] = dst
         self._partial_names.add(src[0])
 
     def add_bit(self, src: tuple[str, int], dst: tuple[str, int]) -> None:
         """Bind one outer classical bit; marks `src` register partial."""
+        self._reject_conflict(src[0], mode="partial (per-bit)")
         self._bit[src] = dst
         self._partial_names.add(src[0])
 
@@ -337,13 +367,17 @@ def _sub_permute_ref(ref: str, remap: BodyRemap) -> str:
     """
     match = _PERMUTE_REF_RE.fullmatch(ref)
     if match is None:
-        for name in remap._partial_names:  # noqa: SLF001 -- same module
-            if name in ref:
-                msg = (
-                    f"Cannot substitute PermuteOp ref {ref!r}: unsupported "
-                    f"ref form mentions partially-bound name {name!r}"
-                )
-                raise BodySubstitutionError(msg)
+        # Compare the ref's LEADING identifier token exactly against the
+        # partial-name set (not a substring scan) so `sq[0:2]` is not
+        # falsely rejected when `q` is partially bound.
+        lead = _LEADING_IDENT_RE.match(ref)
+        if lead is not None and lead.group(0) in remap._partial_names:  # noqa: SLF001 -- same module
+            base = lead.group(0)
+            msg = (
+                f"Cannot substitute PermuteOp ref {ref!r}: unsupported "
+                f"ref form whose base name {base!r} is partially bound"
+            )
+            raise BodySubstitutionError(msg)
         return ref
     name, idx = match.group(1), match.group(2)
     if idx is None:
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
index 4a26bb2f8..f3cdc1d27 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
@@ -1618,11 +1618,13 @@ def test_unparseable_permute_ref_mentioning_partial_name_raises(self) -> None:
         # add_slot marks `outer` as partially bound.
         remap.add_slot(("outer", 0), ("q", 0))
 
-        with pytest.raises(BodySubstitutionError, match=r"partially-bound name 'outer'"):
+        with pytest.raises(BodySubstitutionError, match=r"base name 'outer' is partially bound"):
             _sub_permute_ref("outer[0:2]", remap)
 
-        # Unrelated unparseable ref (no partial name substring) passes through.
+        # Unrelated unparseable refs whose BASE name is not partial pass
+        # through -- including the substring-trap `souter` (Codex 5e.1 #1).
         assert _sub_permute_ref("other[0:2]", remap) == "other[0:2]"
+        assert _sub_permute_ref("souter[0:2]", remap) == "souter[0:2]"
 
 
 class TestSlrBlockInputsWiring:
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_substitution.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_substitution.py
index cc53b8f8a..705cc64b8 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_substitution.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_substitution.py
@@ -231,12 +231,25 @@ def test_prepare_all_whole_renamed(self) -> None:
         assert out.allocator == "p"
         assert out.slots is None
 
-    def test_prepare_slots_remapped(self) -> None:
-        # Prep(q[2], q[5]) under the bundle -> Prep on d[0], d[1].
+    def test_prepare_slots_remapped_preserves_source_order(self) -> None:
+        # Prep(q[2], q[5]) under q[2]->d[0], q[5]->d[1] -> Prep(d, (0, 1)).
+        # Exact order asserted (Codex 5e.1 #3): the lowering preserves source
+        # slot order; sorted() would mask an ordering regression.
         prep = PrepareOp(allocator="q", slots=(2, 5))
         out = substitute_stmt(prep, _bundle_remap())
         assert out.allocator == "d"
-        assert sorted(out.slots) == [0, 1]
+        assert out.slots == (0, 1)
+
+    def test_prepare_slots_reversed_map_preserves_source_order(self) -> None:
+        # Reversed map q[2]->d[1], q[5]->d[0]: source order (2, 5) is kept, so
+        # the emitted slots follow the source iteration -> (1, 0), NOT sorted.
+        remap = BodyRemap()
+        remap.add_slot(("q", 2), ("d", 1))
+        remap.add_slot(("q", 5), ("d", 0))
+        prep = PrepareOp(allocator="q", slots=(2, 5))
+        out = substitute_stmt(prep, remap)
+        assert out.allocator == "d"
+        assert out.slots == (1, 0)
 
     def test_prepare_slots_multi_allocator_rejected(self) -> None:
         remap = BodyRemap()
@@ -247,6 +260,39 @@ def test_prepare_slots_multi_allocator_rejected(self) -> None:
             substitute_stmt(prep, remap)
 
 
+class TestBuilderConflictRejection:
+    """Codex 5e.1 review #2: an outer name bound in conflicting modes
+    (whole + partial, or whole twice) is input aliasing -- reject at
+    construction time, not silently let whole win at lookup. Protects the
+    QASM/flatten path where Guppy's own linearity alias check never runs.
+    """
+
+    def test_whole_then_partial_same_name_rejected(self) -> None:
+        remap = BodyRemap()
+        remap.add_whole_alloc("q", "qp", 3)
+        with pytest.raises(BodySubstitutionError, match=r"already bound whole"):
+            remap.add_slot(("q", 0), ("d", 0))
+
+    def test_partial_then_whole_same_name_rejected(self) -> None:
+        remap = BodyRemap()
+        remap.add_slot(("q", 0), ("d", 0))
+        with pytest.raises(BodySubstitutionError, match=r"already bound partially"):
+            remap.add_whole_alloc("q", "qp", 3)
+
+    def test_whole_bound_twice_rejected(self) -> None:
+        remap = BodyRemap()
+        remap.add_whole_alloc("q", "a", 2)
+        with pytest.raises(BodySubstitutionError, match=r"already bound whole"):
+            remap.add_whole_alloc("q", "b", 2)
+
+    def test_partial_then_bit_same_name_ok_distinct_names_ok(self) -> None:
+        # Distinct outer names binding independently is NOT a conflict.
+        remap = BodyRemap()
+        remap.add_slot(("q", 0), ("d", 0))
+        remap.add_bit(("c", 3), ("out", 0))  # different name -- fine
+        remap.add_whole_alloc("r", "rp", 2)  # different name -- fine
+
+
 class TestRejectOnPartialNameLevel:
     def test_barrier_partial_name_rejected(self) -> None:
         b = BarrierOp(allocators=("q",))

From 9c9f7d84c33d7755cff51d5452adee05a2a3b016 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sat, 16 May 2026 04:44:09 -0600
Subject: [PATCH 048/136] Phase 3a.3 iter 5e.2: SLR var->typed BlockArg
 detection (single Qubit/Bit, list[Qubit] bundle) + flatten shape promotion +
 cross-input qubit/bit aliasing guard at both converter and BodyRemap layers;
 strip review-attribution from code comments.

---
 .../src/pecos/slr/ast/_block_substitution.py  |  42 +-
 .../pecos/slr/ast/codegen/_block_flatten.py   |  52 +-
 .../src/pecos/slr/ast/codegen/guppy.py        |   9 +-
 .../src/pecos/slr/ast/converter.py            | 189 +++++--
 .../slr/transforms/parallel_optimizer.py      |   5 +-
 .../tests/slr_tests/ast_guppy/audit_runner.py |   2 +-
 .../slr_tests/ast_guppy/test_ast_hugr.py      |   4 +-
 .../ast_guppy/test_block_call_smoke.py        | 528 +++++++++++++++---
 .../ast_guppy/test_block_substitution.py      |  35 +-
 .../ast_guppy/test_deprecation_warnings.py    |   6 +-
 .../tests/slr_tests/ast_guppy/test_print.py   |  18 +-
 .../slr_tests/ast_guppy/test_v1_acceptance.py |   4 +-
 12 files changed, 707 insertions(+), 187 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/_block_substitution.py b/python/quantum-pecos/src/pecos/slr/ast/_block_substitution.py
index 004fd5640..a55bc8fa5 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/_block_substitution.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/_block_substitution.py
@@ -20,8 +20,8 @@
   inlining a `BlockDecl` body at its call site for non-Guppy codegens.
 
 Unifying both into one `substitute_stmt` eliminates the
-fix-one-forget-the-mirror bug class (Codex caught PermuteOp and BlockCall
-gaps in earlier passes precisely because two parallel copies drifted).
+fix-one-forget-the-mirror bug class: two parallel copies previously
+drifted, leaving PermuteOp and BlockCall substitution gaps.
 
 `substitute_stmt` is **fully recursive** over every node that can carry a
 `SlotRef` / `BitRef` / expression, including the spots the pre-5e
@@ -79,8 +79,7 @@
 _PERMUTE_REF_RE = re.compile(r"([A-Za-z_]\w*)(?:\[(\d+)\])?$")
 # Leading identifier token of an arbitrary (possibly unparseable) ref, used
 # to decide reject-on-partial WITHOUT a loose substring match -- `"q" in
-# "sq[0:2]"` would otherwise falsely reject an unrelated `sq` ref
-# (Codex 5e.1 review #1).
+# "sq[0:2]"` would otherwise falsely reject an unrelated `sq` ref.
 _LEADING_IDENT_RE = re.compile(r"[A-Za-z_]\w*")
 
 
@@ -114,9 +113,8 @@ def __init__(self) -> None:
     # and a whole binding maps exactly one src. Conflicting builder calls
     # (same name bound both whole and partial, or whole-bound twice) are an
     # input-aliasing error: reject at construction time rather than letting
-    # whole silently win at lookup (Codex 5e.1 review #2). This protects the
-    # QASM/flatten path too, where Guppy's own linearity alias check never
-    # runs.
+    # whole silently win at lookup. This protects the QASM/flatten path too,
+    # where Guppy's own linearity alias check never runs.
 
     def _reject_conflict(self, name: str, *, mode: str) -> None:
         if name in self._whole_alloc:
@@ -140,14 +138,40 @@ def add_whole_alloc(self, src: str, dst: str, size: int) -> None:
             self._slot[(src, i)] = (dst, i)
 
     def add_slot(self, src: tuple[str, int], dst: tuple[str, int]) -> None:
-        """Bind one outer qubit slot; marks `src` allocator partial."""
+        """Bind one outer qubit slot; marks `src` allocator partial.
+
+        A repeated exact `src` slot is rejected: silently overwriting it
+        would drop the earlier binding and corrupt the body rewrite -- e.g.
+        a `[q[0], q[0]]` bundle, or two single-qubit inputs aliased to the
+        same outer slot. Qubit aliasing is invalid anyway (no-cloning);
+        fail loudly here so it cannot reach codegen.
+        """
         self._reject_conflict(src[0], mode="partial (per-slot)")
+        if src in self._slot:
+            msg = (
+                f"BodyRemap: outer qubit slot {src!r} is already bound "
+                f"(to {self._slot[src]!r}); a qubit cannot be aliased to "
+                "two block-input positions (no-cloning)"
+            )
+            raise BodySubstitutionError(msg)
         self._slot[src] = dst
         self._partial_names.add(src[0])
 
     def add_bit(self, src: tuple[str, int], dst: tuple[str, int]) -> None:
-        """Bind one outer classical bit; marks `src` register partial."""
+        """Bind one outer classical bit; marks `src` register partial.
+
+        A repeated exact `src` bit is rejected for the same reason as
+        `add_slot`: a second binding would silently overwrite the first
+        and lose body references to it during substitution.
+        """
         self._reject_conflict(src[0], mode="partial (per-bit)")
+        if src in self._bit:
+            msg = (
+                f"BodyRemap: outer bit {src!r} is already bound "
+                f"(to {self._bit[src]!r}); the same outer bit cannot back "
+                "two block-input positions (lossy substitution)"
+            )
+            raise BodySubstitutionError(msg)
         self._bit[src] = dst
         self._partial_names.add(src[0])
 
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/_block_flatten.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/_block_flatten.py
index 1836d9665..41fa55746 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/_block_flatten.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/_block_flatten.py
@@ -29,12 +29,16 @@
 from pecos.slr.ast._block_substitution import BodyRemap, substitute_stmt
 from pecos.slr.ast.nodes import (
     AllocatorArg,
+    BitBundleArg,
     BlockCall,
     ForStmt,
     IfStmt,
     ParallelBlock,
     Program,
+    QubitBundleArg,
     RepeatStmt,
+    SingleBitArg,
+    SingleQubitArg,
     WhileStmt,
 )
 
@@ -45,8 +49,8 @@
 def validate_unique_block_decl_names(program: Program) -> None:
     """Raise ValueError if any BlockDecl name appears more than once.
 
-    Shared precondition check (Codex 2026-05-15 review #3): both the Guppy
-    emitter and the non-Guppy flatten pass require globally-unique BlockDecl
+    Shared precondition check: both the Guppy emitter and the non-Guppy
+    flatten pass require globally-unique BlockDecl
     names. Keeping the check in one place ensures the contract stays in sync
     across codegens.
     """
@@ -149,31 +153,45 @@ def _inline_call(call: BlockCall, decls: dict[str, BlockDecl]) -> tuple[Statemen
             f"BlockDecl declares {len(decl.inputs)} inputs"
         )
         raise ValueError(msg)
-    # Flatten still only supports AllocatorArg (whole-QReg). SingleQubitArg /
-    # SingleBitArg / QubitBundleArg flatten support lands in 5e.2; until then
-    # they must raise (the `test_*_arg_rejected_in_flatten_pass` lock-ins
-    # depend on this). Reject in BOTH arg_bindings and out_bindings -- silently
-    # allowing a deferred shape in out_bindings would be a silent-fallback
-    # (Codex fix-pass-5).
+    # 5e.2: AllocatorArg / SingleQubitArg / SingleBitArg / QubitBundleArg all
+    # inline. BitBundleArg is the only still-deferred shape -- reject it (in
+    # BOTH arg and out bindings; silently allowing it in out_bindings would
+    # be a silent-fallback). The `test_bitbundle_*_rejected` lock-ins depend
+    # on this.
     for position, args in (("arg", call.arg_bindings), ("out", call.out_bindings)):
         for arg in args:
-            if not isinstance(arg, AllocatorArg):
+            if isinstance(arg, BitBundleArg):
                 msg = (
                     f"Flatten pass does not yet support BlockArg "
                     f"{type(arg).__name__} in {position}_bindings of "
-                    f"{call.callee!r}; only AllocatorArg is supported until "
-                    "Phase 3a.3 iter 5.2"
+                    f"{call.callee!r} (BitBundleArg is still deferred)"
                 )
                 raise NotImplementedError(msg)
     # Build the PARAM -> OUTER BodyRemap (flatten inlines a BlockDecl body --
     # which references param names -- at the call site, which uses the outer
-    # allocator). converter builds the inverse OUTER -> PARAM remap; both use
+    # binding). converter builds the inverse OUTER -> PARAM remap; both use
     # the shared `substitute_stmt` (5e.1 unification -- one substitution core,
-    # no fix-one-forget-the-mirror drift).
+    # no fix-one-forget-the-mirror drift). Only arg_bindings drive the body
+    # rewrite; out_bindings do not contribute (the inlined body writes the
+    # outer slots directly -- there is no separate return-unpack in flatten).
     remap = BodyRemap()
     for inp, arg in zip(decl.inputs, call.arg_bindings, strict=True):
-        # AllocatorArg inputs are always array[qubit, N]; the emitter validates
-        # this, so flatten can trust inp.type_expr.size on this path.
-        size = getattr(inp.type_expr, "size", 0)
-        remap.add_whole_alloc(inp.name, arg.name, size)
+        if isinstance(arg, AllocatorArg):
+            # AllocatorArg inputs are always array[qubit, N]; the emitter
+            # validates this, so flatten can trust inp.type_expr.size.
+            size = getattr(inp.type_expr, "size", 0)
+            remap.add_whole_alloc(inp.name, arg.name, size)
+        elif isinstance(arg, SingleQubitArg):
+            remap.add_slot((inp.name, 0), (arg.slot.allocator, arg.slot.index))
+        elif isinstance(arg, SingleBitArg):
+            remap.add_bit((inp.name, 0), (arg.bit.register, arg.bit.index))
+        elif isinstance(arg, QubitBundleArg):
+            for k, slot in enumerate(arg.slots):
+                remap.add_slot((inp.name, k), (slot.allocator, slot.index))
+        else:  # BitBundleArg already rejected above; defensive
+            msg = (
+                f"Flatten pass: unexpected BlockArg {type(arg).__name__} for "
+                f"input {inp.name!r} of {call.callee!r}"
+            )
+            raise NotImplementedError(msg)
     return tuple(substitute_stmt(stmt, remap) for stmt in decl.body)
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
index ba42c183f..6598647e6 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
@@ -977,8 +977,7 @@ def _emit_block_call(self, node: BlockCall) -> list[str]:
             raise GuppyCodegenError(msg)
 
         # Phase 1: validate every arg + out binding BEFORE touching linearity state, so
-        # a late-raised GuppyCodegenError can't leave the tracker half-consumed (Codex
-        # 2026-05-15 review).
+        # a late-raised GuppyCodegenError can't leave the tracker half-consumed.
         # Each validated_args entry is tagged with one of "array",
         # "single_qubit", "single_bit", or "qubit_bundle" so the Phase-2 emit
         # step knows how to pack the call argument.
@@ -1011,8 +1010,7 @@ def _emit_block_call(self, node: BlockCall) -> list[str]:
             # Cross-check: a LIVE_PRESERVED input's out_binding MUST reference the same
             # outer-scope slot/allocator as its arg_binding. Otherwise the emitter would
             # blindly set_live() on a slot that was never consumed, producing invalid
-            # Guppy where the never-consumed slot is overwritten (Codex 2026-05-15
-            # iter-5b review).
+            # Guppy where the never-consumed slot is overwritten.
             arg_kind, arg_info = validated_args[live_arg_index[out_idx]][1:]
             if (kind, info) != (arg_kind, arg_info):
                 msg = (
@@ -1031,8 +1029,7 @@ def _emit_block_call(self, node: BlockCall) -> list[str]:
         # Without this, the overlap would only surface mid-Phase-2 as a
         # LinearityError ("slot consumed") with the tracker half-mutated. Raising
         # here keeps the "all validation before linearity mutation" invariant
-        # strict (Codex 2026-05-15 iter-5d review #3). Bits are copyable so
-        # single_bit args are excluded.
+        # strict. Bits are copyable so single_bit args are excluded.
         seen_slots: dict[tuple[str, int], str] = {}
         for inp, kind, info in validated_args:
             if kind == "array":
diff --git a/python/quantum-pecos/src/pecos/slr/ast/converter.py b/python/quantum-pecos/src/pecos/slr/ast/converter.py
index 8ad2d2890..7a81b01ea 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/converter.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/converter.py
@@ -60,11 +60,14 @@
     PrepareOp,
     PrintOp,
     Program,
+    QubitBundleArg,
     QubitTypeExpr,
     RegisterDecl,
     RepeatStmt,
     ResourceEffect,
     ReturnOp,
+    SingleBitArg,
+    SingleQubitArg,
     SlotRef,
     UnaryExpr,
     UnaryOp,
@@ -400,61 +403,156 @@ def _convert_block_call(self, block: Block) -> BlockCall:
         body is the block's `ops` with allocator names rewritten from the
         outer-scope binding name to the input parameter name.
         """
+        # Concrete-isinstance detection (`.sym`/`.size` duck-typing
+        # misclassifies CReg as QReg). Local import keeps the
+        # SLR var classes off the module-import path (circular-safe, matching
+        # the other lazy `from pecos.slr...` imports in this file).
+        from pecos.slr.vars import (  # noqa: PLC0415
+            Bit as SlrBit,
+        )
+        from pecos.slr.vars import (  # noqa: PLC0415
+            CReg,
+            QReg,
+            Qubit,
+            SymbolicElem,
+        )
+
         inputs_spec = type(block).block_inputs  # type: ignore[attr-defined]
-        # Map input name -> (resource effect enum, outer-scope binding name, size, kind="qubit"|"bit")
-        bindings: list[tuple[str, ResourceEffect, str, int]] = []
-        # 5e.1: build a BodyRemap (outer -> param). SLR-side detection still
-        # only handles whole-QReg inputs (AllocatorArg); single-qubit /
-        # single-bit / bundle SLR detection is 5e.2. So only the
-        # whole-allocator (identity per-slot) builder is used here today.
+        cls_name = type(block).__name__
         remap = BodyRemap()
+        block_inputs: list[BlockInput] = []
+        arg_bindings: list[BlockArg] = []
+        out_bindings: list[BlockArg] = []
+
+        # Cross-input aliasing guard. The same concrete qubit slot (or
+        # classical bit) bound to two block-input positions --
+        # e.g. `[q[0], q[0]]` or two single-qubit inputs both `q[0]` --
+        # silently corrupts body substitution: Guppy rejects it on linearity
+        # while the QASM flatten path emits invalid `cx q[0], q[0];`.
+        # BodyRemap.add_slot/add_bit also reject this (defense-in-depth), but
+        # we check here first to give a Block-context error message.
+        seen_qubit: dict[tuple[str, int], str] = {}
+        seen_bit: dict[tuple[str, int], str] = {}
+
+        def _claim_qubit(reg: str, index: int, *, here: str, owner: str) -> None:
+            prior = seen_qubit.get((reg, index))
+            if prior is not None:
+                msg = (
+                    f"{here}: qubit {reg}[{index}] is also bound by input "
+                    f"{prior!r}; a qubit cannot be aliased to two block-input "
+                    "positions (no-cloning)"
+                )
+                raise ValueError(msg)
+            seen_qubit[(reg, index)] = owner
+
+        def _claim_bit(reg: str, index: int, *, here: str, owner: str) -> None:
+            prior = seen_bit.get((reg, index))
+            if prior is not None:
+                msg = (
+                    f"{here}: bit {reg}[{index}] is also bound by input "
+                    f"{prior!r}; the same outer bit cannot back two "
+                    "block-input positions (lossy substitution)"
+                )
+                raise ValueError(msg)
+            seen_bit[(reg, index)] = owner
+
         for input_name, effect_value in inputs_spec.items():
             if not hasattr(block, input_name):
                 msg = (
-                    f"Block {type(block).__name__!r} declares input {input_name!r} but the "
-                    f"instance does not bind self.{input_name} (set it in __init__ after super().__init__())"
+                    f"Block {cls_name!r} declares input {input_name!r} but the "
+                    f"instance does not bind self.{input_name} (set it in __init__ "
+                    "after super().__init__())"
                 )
                 raise ValueError(msg)
             var = getattr(block, input_name)
-            outer_name = getattr(var, "sym", None) or getattr(var, "name", None)
-            if outer_name is None:
+            where = f"Block {cls_name!r} input {input_name!r}"
+            effect = _normalize_effect(effect_value, where=where)
+
+            type_expr: TypeExpr
+            arg: BlockArg
+            if isinstance(var, QReg):
+                type_expr = ArrayTypeExpr(element=QubitTypeExpr(), size=var.size)
+                arg = AllocatorArg(name=var.sym)
+                remap.add_whole_alloc(var.sym, input_name, var.size)
+            elif isinstance(var, Qubit):
+                type_expr = QubitTypeExpr()
+                _claim_qubit(var.reg.sym, var.index, here=where, owner=input_name)
+                arg = SingleQubitArg(slot=SlotRef(allocator=var.reg.sym, index=var.index))
+                remap.add_slot((var.reg.sym, var.index), (input_name, 0))
+            elif isinstance(var, SlrBit):
+                type_expr = BitTypeExpr()
+                _claim_bit(var.reg.sym, var.index, here=where, owner=input_name)
+                arg = SingleBitArg(bit=BitRef(register=var.reg.sym, index=var.index))
+                remap.add_bit((var.reg.sym, var.index), (input_name, 0))
+            elif isinstance(var, (list, tuple)):
+                if not var:
+                    msg = f"{where}: empty {type(var).__name__} bundle is not supported"
+                    raise ValueError(msg)
+                if all(isinstance(e, Qubit) for e in var):
+                    slots = tuple(
+                        SlotRef(allocator=e.reg.sym, index=e.index) for e in var
+                    )
+                    type_expr = ArrayTypeExpr(element=QubitTypeExpr(), size=len(var))
+                    arg = QubitBundleArg(slots=slots)
+                    for k, e in enumerate(var):
+                        _claim_qubit(e.reg.sym, e.index, here=where, owner=input_name)
+                        remap.add_slot((e.reg.sym, e.index), (input_name, k))
+                elif all(isinstance(e, SlrBit) for e in var):
+                    msg = (
+                        f"{where}: list[Bit] (classical bit bundle / BitBundleArg) "
+                        "is not yet supported in Phase 3a.3"
+                    )
+                    raise ValueError(msg)
+                else:
+                    msg = (
+                        f"{where}: a bundle must be all Qubit (or all Bit, deferred); "
+                        f"got mixed/unsupported element types in {var!r}"
+                    )
+                    raise ValueError(msg)
+            # Every unsupported-input-shape branch raises ValueError uniformly
+            # (the bundle branches above do too): the public rejection surface
+            # is a single exception type so callers catch one thing, and the
+            # rejection tests pin ValueError. TRY004 wants
+            # TypeError for the isinstance-guarded branches, but that would
+            # split the surface across two exception types -- noqa is the
+            # correct call here.
+            elif isinstance(var, SymbolicElem):
                 msg = (
-                    f"Block {type(block).__name__!r} input {input_name!r} bound to "
-                    f"{var!r} which has no .sym/.name attribute"
+                    f"{where}: symbolic (loop-variable-indexed) Qubit/Bit is not "
+                    "supported as a block input; pass a concrete element"
                 )
-                raise ValueError(msg)
-            size = getattr(var, "size", None) or getattr(var, "capacity", None)
-            if size is None:
-                msg = f"Block {type(block).__name__!r} input {input_name!r}: cannot determine size from {var!r}"
-                raise ValueError(msg)
-            effect = _normalize_effect(effect_value, where=f"Block {type(block).__name__!r} input {input_name!r}")
-            bindings.append((input_name, effect, outer_name, size))
-            remap.add_whole_alloc(outer_name, input_name, size)
-
-        # Build the BlockDecl body by converting block.ops in a NEW sub-converter, then
-        # rewriting allocator names from outer -> input parameter via _substitute.
-        # Share `_decl_counter` so nested converted Blocks get globally-unique names
-        # (Codex 2026-05-15 review #2: nested same-class Blocks were colliding on
-        # `inner_0` because each sub-converter restarted its counter at 0).
+                raise ValueError(msg)  # noqa: TRY004
+            elif isinstance(var, CReg):
+                msg = (
+                    f"{where}: whole CReg input is not yet supported in Phase 3a.3 "
+                    "(only single Bit via SingleBitArg); pass a single bit `c[i]`"
+                )
+                raise ValueError(msg)  # noqa: TRY004
+            else:
+                msg = (
+                    f"{where}: unsupported binding type {type(var).__name__} "
+                    f"({var!r}); supported: QReg, Qubit, list[Qubit], Bit"
+                )
+                raise ValueError(msg)  # noqa: TRY004
+
+            block_inputs.append(BlockInput(name=input_name, effect=effect, type_expr=type_expr))
+            arg_bindings.append(arg)
+            # out_bindings mirror the arg BlockArg for each LIVE_PRESERVED input
+            # (the emitter's iter-5b cross-check requires arg == out, by value).
+            if effect is ResourceEffect.LIVE_PRESERVED:
+                out_bindings.append(arg)
+
+        # Build the BlockDecl body by converting block.ops in a NEW sub-converter,
+        # then remapping outer -> param via the shared substitute_stmt. Share
+        # `_decl_counter` so nested converted Blocks get globally-unique names.
         sub = SlrToAst()
         sub._decl_counter = self._decl_counter  # type: ignore[attr-defined]
         sub_body = sub._convert_statements(block.ops)  # type: ignore[attr-defined]
         self._decl_counter = sub._decl_counter  # type: ignore[attr-defined]
         rewritten_body = tuple(substitute_stmt(stmt, remap) for stmt in sub_body)
 
-        # Inputs are array[qubit, N] (Phase 3a.1 only supports quantum arrays).
-        block_inputs: list[BlockInput] = []
-        for input_name, effect, _outer, size in bindings:
-            block_inputs.append(
-                BlockInput(
-                    name=input_name,
-                    effect=effect,
-                    type_expr=ArrayTypeExpr(element=QubitTypeExpr(), size=size),
-                ),
-            )
-
-        # Unique decl name per call site (Phase 3a.1; dedup arrives in Phase 3a.3).
-        decl_name = f"{type(block).__name__.lower()}_{self._decl_counter}"
+        # Unique decl name per call site (dedup is a later optimization).
+        decl_name = f"{cls_name.lower()}_{self._decl_counter}"
         self._decl_counter += 1
 
         decl = BlockDecl(name=decl_name, inputs=tuple(block_inputs), body=rewritten_body)
@@ -462,16 +560,11 @@ def _convert_block_call(self, block: Block) -> BlockCall:
         self._block_decls.extend(sub._block_decls)
         self._block_decls.append(decl)
 
-        # Build the BlockCall referencing the outer-scope names. Whole-allocator
-        # binding is the only shape produced by SLR-side wiring today; other
-        # BlockArg shapes (SingleQubitArg, SingleBitArg, QubitBundleArg,
-        # BitBundleArg) are direct-AST constructions only until later iter 5x
-        # SLR-side support lands.
-        arg_bindings: tuple[BlockArg, ...] = tuple(AllocatorArg(name=outer) for _n, _e, outer, _s in bindings)
-        live_out: tuple[BlockArg, ...] = tuple(
-            AllocatorArg(name=outer) for _n, eff, outer, _s in bindings if eff is ResourceEffect.LIVE_PRESERVED
+        return BlockCall(
+            callee=decl_name,
+            arg_bindings=tuple(arg_bindings),
+            out_bindings=tuple(out_bindings),
         )
-        return BlockCall(callee=decl_name, arg_bindings=arg_bindings, out_bindings=live_out)
 
     def _convert_gate(self, gate: Any) -> Statement:
         """Convert an SLR gate to an AST GateOp, PrepareOp, or MeasureOp."""
diff --git a/python/quantum-pecos/src/pecos/slr/transforms/parallel_optimizer.py b/python/quantum-pecos/src/pecos/slr/transforms/parallel_optimizer.py
index c8a448949..03d4647df 100644
--- a/python/quantum-pecos/src/pecos/slr/transforms/parallel_optimizer.py
+++ b/python/quantum-pecos/src/pecos/slr/transforms/parallel_optimizer.py
@@ -98,7 +98,7 @@ def _transform_block(self, block: Block) -> Block:
             # bound for `block_inputs` lookup) survive the optimization pass.
             # Reconstructing via `Block(*new_ops)` here would erase that state
             # and cause Phase 3a.3 converted Blocks to silently fall back to
-            # the v1 flatten path. (Codex 2026-05-15 review #4.)
+            # the v1 flatten path.
             cls = type(block)
             if cls is Block:
                 new_block = Block(*new_ops)
@@ -169,8 +169,7 @@ def _can_optimize_parallel(self, parallel: Parallel) -> bool:
         converted Block (a Block subclass with class-level `block_inputs`).
         Splatting a converted Block's body into the surrounding Parallel
         would destroy its scope boundary -- the BlockCall lowering needs the
-        Block to remain a single op in the AST. (Codex 2026-05-15 review #1
-        of fix-pass-3.)
+        Block to remain a single op in the AST.
         """
         for op in parallel.ops:
             if isinstance(op, If | Repeat):
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
index 162b79925..1f3e269fe 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
@@ -16,7 +16,7 @@
 Runs each through `SlrConverter.hugr()` (now AST-routed by default
 post-cutover) and captures any failures.
 
-This is NOT a pytest test file. It's an audit tool grug runs
+This is NOT a pytest test file. It's an audit tool run
 during Workstream B and at cutover. Output is the seed for new
 rows in `~/Repos/pecos-docs/design/slr/v1-audit-manifest.md`.
 
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
index e92a650c6..aead3c4aa 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
@@ -98,7 +98,7 @@ def test_hugr_returns_no_arg_entrypoint_runnable_via_hugr_adapter() -> None:
 
 
 def test_hugr_supports_explicit_return_of_root_allocator() -> None:
-    """Regression for Codex finding #1.
+    """Regression: explicit-return wrapper passthrough.
 
     A v1 program with an explicit `Return(q)` (no result CRegs) must compile.
     The wrapper must pass main's return value through, not silently discard it
@@ -116,7 +116,7 @@ def test_hugr_supports_explicit_return_of_root_allocator() -> None:
 
 
 def test_hugr_inline_measure_creg_round_trips_through_selene() -> None:
-    """Regression for Codex finding #2.
+    """Regression: inline-CReg result capture through the entry wrapper.
 
     The AST emitter infers inline `CReg("final", n)` registers from
     `Measure(q) > CReg(...)` and main returns them. The entry wrapper must
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
index f3cdc1d27..3e8538a65 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
@@ -285,8 +285,7 @@ class TestConvertedQeclibBlocksUseBlockCallPath:
 
     Goes through `SlrConverter(prog).guppy()` end-to-end (not just `slr_to_ast`)
     so this catches regressions in any production transform between SLR and
-    AST (e.g., ParallelOptimizer dropping class identity, Codex 2026-05-15
-    review #4).
+    AST (e.g., ParallelOptimizer dropping class identity).
     """
 
     def _assert_uses_block_call(self, prog: object, expected_callee_prefix: str) -> None:
@@ -352,7 +351,7 @@ def test_steane_logical_h_uses_block_call(self) -> None:
 
 
 class TestConsumedEffect:
-    """End-to-end coverage for CONSUMED inputs (Codex 2026-05-15 review caught this gap).
+    """End-to-end coverage for CONSUMED inputs.
 
     The Phase 3a.1 validator allows CONSUMED in BlockDecl.inputs, and the
     `_emit_block_call` code path marks the outer slot CONSUMED post-call. But
@@ -410,7 +409,7 @@ def test_outer_reuse_after_consumed_raises(self) -> None:
 class TestNestedConvertedBlocks:
     """Nested converted Blocks: an Outer Block whose body contains an Inner Block.
 
-    Codex 2026-05-15 review #1+#2 caught two bugs in nested support:
+    Two bugs in nested support were caught:
     - `_substitute_stmt` had no BlockCall branch, so nested calls leaked outer
       allocator names into the parent BlockDecl body.
     - Each sub-converter restarted `_decl_counter` at 0, causing name collisions
@@ -470,7 +469,7 @@ def test_nested_block_call_arg_bindings_substitute_to_parent_param(self) -> None
         assert nested.out_bindings == (AllocatorArg(name="q"),), nested.out_bindings
 
     def test_top_level_inner_plus_outer_containing_inner_have_unique_names(self) -> None:
-        """Codex review #2: same Block class top-level AND nested must not collide."""
+        """Same Block class top-level AND nested must not collide."""
         from pecos.slr import Block, CReg, Main, QReg
         from pecos.slr.ast import slr_to_ast
         from pecos.slr.qeclib import qubit as qb
@@ -522,7 +521,7 @@ def test_nested_block_call_compiles_via_guppy(self) -> None:
 
 
 class TestPrettyPrintHandlesBlockNodes:
-    """Codex 2026-05-15 fix-pass-4 review: `pretty_print` crashed on any program
+    """`pretty_print` crashed on any program
     containing a BlockCall because the visitor inherited `default_result()` which
     raises NotImplementedError. Lock in that pretty_print emits both BlockDecls
     and BlockCalls cleanly.
@@ -563,7 +562,7 @@ def test_pretty_print_emits_block_decl_and_block_call(self) -> None:
 
 
 class TestConvertedBlocksInsideParallel:
-    """Codex 2026-05-15 fix-pass-3 review #1: a converted Block inside Parallel(...)
+    """A converted Block inside Parallel(...)
     used to silently flatten because ParallelOptimizer's `_collect_operations`
     splatted the Block's body into the surrounding Parallel, destroying its
     scope boundary. The fix bails out of `_can_optimize_parallel` when any
@@ -591,7 +590,7 @@ def test_parallel_with_converted_block_preserves_block_call_via_slr_converter(se
 
 
 class TestAstOptimizationPreservesBlockDecls:
-    """Codex 2026-05-15 fix-pass-3 review #2: AST optimization passes were
+    """AST optimization passes were
     reconstructing Program without `block_decls=`, leaving any contained
     BlockCalls dangling. Lock in `block_decls` survival across each pass.
     """
@@ -771,7 +770,7 @@ def test_allocator_arg_with_single_qubit_input_rejected(self) -> None:
             ast_to_guppy(prog)
 
     def test_single_qubit_mismatched_arg_out_slot_rejected(self) -> None:
-        """Codex 2026-05-15 iter-5b review: a LIVE_PRESERVED single-qubit input
+        """A LIVE_PRESERVED single-qubit input
         whose `arg_binding` and `out_binding` reference DIFFERENT outer slots
         used to produce invalid Guppy (set_live() overwriting a never-consumed
         slot). The emitter must reject this with a clean GuppyCodegenError.
@@ -1050,8 +1049,8 @@ def test_qubit_bundle_packs_and_unpacks_arbitrary_slots(self) -> None:
     def test_qubit_bundle_end_to_end_selene_bell_correlation(self) -> None:
         """Compile + run the cross-allocator bundle program through Selene.
 
-        Codex 2026-05-15 iter-5d review #1: the support test was string-shape
-        only; the iter-5b r1 blocker proved a string can look right while the
+        The earlier support test was string-shape only; the iter-5b r1
+        blocker proved a string can look right while the
         Guppy fails its own linearity. This compiles the generated Guppy via
         the entry wrapper and pins the seeded Selene records (the bundled
         slots a[2] and b[0] form a Bell pair, so the two measurements are
@@ -1060,8 +1059,7 @@ def test_qubit_bundle_end_to_end_selene_bell_correlation(self) -> None:
         Note: this is a *compile + behavior* gate, not an unpack-order gate.
         Bell measurements are symmetric, so a swapped bundle unpack order
         would still pass here. `test_qubit_bundle_asymmetric_unpack_order`
-        below pins unpack order with an asymmetric bundle (Codex 2026-05-15
-        iter-5d r2 review #1).
+        below pins unpack order with an asymmetric bundle.
         """
         import importlib.util
         import sys
@@ -1098,7 +1096,7 @@ def test_qubit_bundle_end_to_end_selene_bell_correlation(self) -> None:
             warnings.simplefilter("ignore", DeprecationWarning)
             result = sim(Hugr(hugr_bytes)).classical(selene_engine()).qubits(5).seed(42).run(8)
         raw = result.to_dict() if hasattr(result, "to_dict") else result
-        # Empirical probe 2026-05-15 (matches Codex's independent r1 probe):
+        # Empirical probe 2026-05-15:
         assert raw == {
             "measurement_0": [1, 0, 0, 1, 0, 0, 0, 1],
             "measurement_1": [1, 0, 0, 1, 0, 0, 0, 1],
@@ -1109,8 +1107,8 @@ def test_qubit_bundle_end_to_end_selene_bell_correlation(self) -> None:
     def test_qubit_bundle_asymmetric_unpack_order(self) -> None:
         """Pin bundle unpack ORDER with an asymmetric program.
 
-        Codex 2026-05-15 iter-5d r2 review #1: the Bell-correlation test is
-        symmetric, so a swapped bundle unpack (`b_0, a_2 = ret` instead of
+        The Bell-correlation test is symmetric, so a swapped bundle unpack
+        (`b_0, a_2 = ret` instead of
         `a_2, b_0 = ret`) still passes it. Here the block applies X to q[0]
         ONLY, so the two bundled slots end in DIFFERENT states: a[2] (<- q[0],
         X'd) measures 1, b[0] (<- q[1], untouched) measures 0. A swapped
@@ -1189,7 +1187,7 @@ def test_qubit_bundle_asymmetric_unpack_order(self) -> None:
         }, raw
 
     def test_qubit_bundle_cross_input_alias_rejected_pre_consume(self) -> None:
-        """Codex 2026-05-15 iter-5d review #3: a slot referenced by two distinct
+        """A slot referenced by two distinct
         quantum arg_bindings must raise a clean GuppyCodegenError in Phase 1
         (pre-consume), not a mid-Phase-2 LinearityError with the tracker
         half-mutated.
@@ -1321,21 +1319,21 @@ def test_qubit_bundle_out_of_bounds_slot_rejected(self) -> None:
 
 
 class TestDeferredBlockArgRejection:
-    """Phase 3a.3 iter 5d scope:
-    - `AllocatorArg` is supported in BOTH the Guppy emitter AND the non-Guppy
-      flatten path.
-    - `SingleQubitArg`, `SingleBitArg`, `QubitBundleArg` are supported in the
-      Guppy emitter ONLY; flatten support is deferred (full slot/bit-level
-      body rewriting needed). Each has a dedicated
-      `test_<shape>_arg_rejected_in_flatten_pass` lock-in below.
-    - `BitBundleArg` MUST raise cleanly in BOTH paths -- silently inlining a
-      deferred shape would mask user errors (Codex 2026-05-15 fix-pass-5 +
-      iter-5b reviews caught this family).
+    """Phase 3a.3 iter 5e.2 scope:
+    - `AllocatorArg`, `SingleQubitArg`, `SingleBitArg`, `QubitBundleArg` are
+      now supported in BOTH the Guppy emitter AND the non-Guppy flatten path.
+      The former `test_<shape>_arg_rejected_in_flatten_pass` lock-ins are
+      flipped into `test_<shape>_arg_flatten_inlines` support tests below
+      (they pin that flatten rewrites param refs -> outer refs, no
+      NotImplementedError).
+    - `BitBundleArg` is the ONLY still-deferred shape: it MUST raise cleanly
+      in BOTH paths -- silently inlining a deferred shape would mask user
+      errors (this silent-fallback family was caught repeatedly).
     """
 
-    def test_qubit_bundle_arg_rejected_in_flatten_pass(self) -> None:
-        """QubitBundleArg in flatten path: deferred until non-contiguous
-        slot-level body rewriting lands. Lock-in: clean NotImplementedError.
+    def test_qubit_bundle_arg_flatten_inlines(self) -> None:
+        """5e.2: QubitBundleArg now inlines in flatten -- param `q[0]` rewrites
+        to the bundled outer slot `outer_q[0]`.
         """
         from pecos.slr.ast.codegen._block_flatten import flatten_block_calls
         from pecos.slr.ast.nodes import QubitBundleArg
@@ -1349,50 +1347,46 @@ def test_qubit_bundle_arg_rejected_in_flatten_pass(self) -> None:
                     type_expr=ArrayTypeExpr(element=QubitTypeExpr(), size=2),
                 ),
             ),
-            body=(GateOp(gate=GateKind.H, targets=(SlotRef(allocator="q", index=0),)),),
+            body=(GateOp(gate=GateKind.H, targets=(SlotRef(allocator="q", index=1),)),),
+        )
+        bundle = QubitBundleArg(
+            slots=(
+                SlotRef(allocator="outer_q", index=0),
+                SlotRef(allocator="outer_q", index=2),
+            ),
         )
         prog = Program(
             name="main",
             allocator=AllocatorDecl(name="outer_q", capacity=3),
             block_decls=(decl,),
-            body=(
-                BlockCall(
-                    callee="b",
-                    arg_bindings=(
-                        QubitBundleArg(
-                            slots=(
-                                SlotRef(allocator="outer_q", index=0),
-                                SlotRef(allocator="outer_q", index=2),
-                            ),
-                        ),
-                    ),
-                    out_bindings=(
-                        QubitBundleArg(
-                            slots=(
-                                SlotRef(allocator="outer_q", index=0),
-                                SlotRef(allocator="outer_q", index=2),
-                            ),
-                        ),
-                    ),
-                ),
-            ),
-        )
-        with pytest.raises(NotImplementedError, match=r"QubitBundleArg"):
-            flatten_block_calls(prog)
-
-    def test_single_bit_arg_rejected_in_flatten_pass(self) -> None:
-        """SingleBitArg in flatten path: deferred until bit-level body rewriting
-        lands. Lock-in: clean NotImplementedError, no silent inline.
+            body=(BlockCall(callee="b", arg_bindings=(bundle,), out_bindings=(bundle,)),),
+        )
+        flat = flatten_block_calls(prog)
+        # q[1] (param) -> bundle slot index 1 -> outer_q[2].
+        gates = [s for s in flat.body if isinstance(s, GateOp)]
+        assert len(gates) == 1
+        assert gates[0].targets == (SlotRef(allocator="outer_q", index=2),)
+        assert flat.block_decls == ()
+
+    def test_single_bit_arg_flatten_inlines(self) -> None:
+        """5e.2: SingleBitArg now inlines in flatten -- param bit `out[0]`
+        rewrites to the outer CReg bit `c[0]`.
         """
         from pecos.slr.ast.codegen._block_flatten import flatten_block_calls
-        from pecos.slr.ast.nodes import SingleBitArg
+        from pecos.slr.ast.nodes import SingleBitArg, SingleQubitArg
 
         decl = BlockDecl(
             name="b",
             inputs=(
+                BlockInput(name="a", effect=ResourceEffect.CONSUMED, type_expr=QubitTypeExpr()),
                 BlockInput(name="out", effect=ResourceEffect.LIVE_PRESERVED, type_expr=BitTypeExpr()),
             ),
-            body=(),
+            body=(
+                MeasureOp(
+                    targets=(SlotRef(allocator="a", index=0),),
+                    results=(BitRef(register="out", index=0),),
+                ),
+            ),
         )
         prog = Program(
             name="main",
@@ -1402,17 +1396,24 @@ def test_single_bit_arg_rejected_in_flatten_pass(self) -> None:
             body=(
                 BlockCall(
                     callee="b",
-                    arg_bindings=(SingleBitArg(bit=BitRef(register="c", index=0)),),
+                    arg_bindings=(
+                        SingleQubitArg(slot=SlotRef(allocator="outer_q", index=0)),
+                        SingleBitArg(bit=BitRef(register="c", index=0)),
+                    ),
                     out_bindings=(SingleBitArg(bit=BitRef(register="c", index=0)),),
                 ),
             ),
         )
-        with pytest.raises(NotImplementedError, match=r"SingleBitArg"):
-            flatten_block_calls(prog)
+        flat = flatten_block_calls(prog)
+        meas = [s for s in flat.body if isinstance(s, MeasureOp)]
+        assert len(meas) == 1
+        assert meas[0].targets == (SlotRef(allocator="outer_q", index=0),)
+        assert meas[0].results == (BitRef(register="c", index=0),)
+        assert flat.block_decls == ()
 
-    def test_single_qubit_arg_rejected_in_flatten_pass(self) -> None:
-        """SingleQubitArg in flatten path: deferred until full slot-level body
-        rewriting lands. Lock-in: clean NotImplementedError, no silent inline.
+    def test_single_qubit_arg_flatten_inlines(self) -> None:
+        """5e.2: SingleQubitArg now inlines in flatten -- param `q[0]` rewrites
+        to the outer slot `outer_q[1]`.
         """
         from pecos.slr.ast.codegen._block_flatten import flatten_block_calls
         from pecos.slr.ast.nodes import SingleQubitArg
@@ -1424,20 +1425,18 @@ def test_single_qubit_arg_rejected_in_flatten_pass(self) -> None:
             ),
             body=(GateOp(gate=GateKind.H, targets=(SlotRef(allocator="q", index=0),)),),
         )
+        sq = SingleQubitArg(slot=SlotRef(allocator="outer_q", index=1))
         prog = Program(
             name="main",
             allocator=AllocatorDecl(name="outer_q", capacity=3),
             block_decls=(decl,),
-            body=(
-                BlockCall(
-                    callee="b",
-                    arg_bindings=(SingleQubitArg(slot=SlotRef(allocator="outer_q", index=1)),),
-                    out_bindings=(SingleQubitArg(slot=SlotRef(allocator="outer_q", index=1)),),
-                ),
-            ),
+            body=(BlockCall(callee="b", arg_bindings=(sq,), out_bindings=(sq,)),),
         )
-        with pytest.raises(NotImplementedError, match=r"SingleQubitArg"):
-            flatten_block_calls(prog)
+        flat = flatten_block_calls(prog)
+        gates = [s for s in flat.body if isinstance(s, GateOp)]
+        assert len(gates) == 1
+        assert gates[0].targets == (SlotRef(allocator="outer_q", index=1),)
+        assert flat.block_decls == ()
 
     def _program_with_deferred_arg(self, *, deferred_in_args: bool, arg_subclass: type) -> Program:
         from pecos.slr.ast.nodes import BitBundleArg, BitRef
@@ -1489,7 +1488,7 @@ def test_deferred_arg_bindings_raise_in_flatten(self) -> None:
             flatten_block_calls(prog)
 
     def test_deferred_out_bindings_raise_in_flatten(self) -> None:
-        """Codex 2026-05-15 fix-pass-5 review caught: out_bindings used to be
+        """Regression: out_bindings used to be
         silently accepted by `_inline_call` even when they were a deferred
         BlockArg shape, while Guppy correctly rejected them.
         """
@@ -1516,7 +1515,7 @@ def test_deferred_out_bindings_raise_in_guppy(self) -> None:
 
 
 class TestDuplicateBlockDeclNameValidation:
-    """Shared validate_unique_block_decl_names contract (Codex review #3)."""
+    """Shared validate_unique_block_decl_names contract."""
 
     def _duplicate_decl_program(self) -> Program:
         decl = BlockDecl(
@@ -1553,8 +1552,8 @@ def test_flatten_pass_rejects_duplicate_block_decl_names(self) -> None:
 class TestBlockBodyStatementSubstitution:
     """Phase 3a.1 substitution must cover every SLR statement type that names allocators.
 
-    Codex 2026-05-15 review caught that PermuteOp (which carries source/target
-    register names as strings, not SlotRefs) was silently passed through in
+    PermuteOp (which carries source/target register names as strings, not
+    SlotRefs) was silently passed through in
     both `converter._substitute_stmt` and `_block_flatten._substitute`. Lock
     in coverage with a regression test.
     """
@@ -1603,7 +1602,7 @@ def __init__(self, q: QReg) -> None:
         assert permute_stmts[0].targets == ("outer[1]", "outer[0]")
 
     def test_unparseable_permute_ref_mentioning_partial_name_raises(self) -> None:
-        """Defensive raise (Codex review q3, 5e.1 shared substitution): if a
+        """Defensive raise (5e.1 shared substitution): if a
         PermuteOp ref cannot be parsed by the bare-name / `name[idx]` regex AND
         the ref textually mentions a partially-bound name, raise instead of
         silently leaking. Unrelated unparseable refs pass through unchanged.
@@ -1622,7 +1621,7 @@ def test_unparseable_permute_ref_mentioning_partial_name_raises(self) -> None:
             _sub_permute_ref("outer[0:2]", remap)
 
         # Unrelated unparseable refs whose BASE name is not partial pass
-        # through -- including the substring-trap `souter` (Codex 5e.1 #1).
+        # through -- including the substring-trap `souter`.
         assert _sub_permute_ref("other[0:2]", remap) == "other[0:2]"
         assert _sub_permute_ref("souter[0:2]", remap) == "souter[0:2]"
 
@@ -1762,3 +1761,368 @@ def test_bell_block_call_produces_correlated_outcomes(self) -> None:
             assert a == b, f"Bell correlation violated at shot {shot}: m0={a} m1={b}"
         # And there's at least one 0 and one 1 across 8 shots (sanity: not always 0).
         assert set(m0) == {0, 1}, f"expected both outcomes across 8 shots, got {set(m0)}"
+
+
+class TestSlrBlockArgShapeDetectionViaConverter:
+    """Phase 3a.3 iter 5e.2: an SLR `Block` subclass whose `block_inputs`
+    bind a single `Qubit`, a `list[Qubit]` bundle (same- or cross-QReg), or
+    a single `Bit` must drive the full real pipeline:
+
+      SLR Block -> slr_to_ast (`_convert_block_call` shape detection, 5e.2a)
+                -> SlrConverter.guppy()  (emitter)
+                -> SlrConverter.qasm()   (flatten_block_calls inline, 5e.2b)
+
+    These differ from `TestSingleQubitInputSupport` et al. (which build the
+    AST `Program` directly) by exercising the SLR var -> typed BlockArg
+    detection AND the bidirectional shared substitution through the public
+    `SlrConverter` surface -- the iter-3 "silent flatten" bug class would
+    slip past an AST-only test.
+    """
+
+    def test_single_qubit_input_detected_and_inlined(self) -> None:
+        from pecos.slr import CReg, Main, QReg, SlrConverter
+        from pecos.slr.ast import slr_to_ast
+        from pecos.slr.ast.nodes import SingleQubitArg, SlotRef
+        from pecos.slr.block import Block
+        from pecos.slr.qeclib import qubit as qb
+        from pecos.slr.qeclib.qubit.measures import Measure
+
+        class SqBlock(Block):
+            block_inputs: ClassVar[dict[str, str]] = {"q": "live_preserved"}
+
+            def __init__(self, q) -> None:
+                super().__init__()
+                self.q = q
+                self.extend(qb.H(q))
+
+        prog = Main(
+            outer_q := QReg("outer_q", 1),
+            c := CReg("c", 1),
+            qb.Prep(outer_q),
+            SqBlock(outer_q[0]),
+            Measure(outer_q) > c,
+        )
+
+        ast = slr_to_ast(prog)
+        calls = [s for s in ast.body if isinstance(s, BlockCall)]
+        assert len(calls) == 1
+        assert calls[0].arg_bindings == (
+            SingleQubitArg(slot=SlotRef(allocator="outer_q", index=0)),
+        )
+
+        guppy_src = SlrConverter(prog).guppy()
+        assert re.search(r"def sqblock_\d+\(q: qubit @ owned\) -> qubit:", guppy_src)
+
+        qasm_src = SlrConverter(prog).qasm()
+        # Flatten rewrote the param `q[0]` back to the outer slot.
+        assert "h outer_q[0];" in qasm_src
+        assert "block" not in qasm_src.lower()
+
+    def test_same_qreg_bundle_detected_and_inlined(self) -> None:
+        from pecos.slr import CReg, Main, QReg, SlrConverter
+        from pecos.slr.ast import slr_to_ast
+        from pecos.slr.ast.nodes import QubitBundleArg, SlotRef
+        from pecos.slr.block import Block
+        from pecos.slr.qeclib import qubit as qb
+        from pecos.slr.qeclib.qubit.measures import Measure
+
+        class BundleBlock(Block):
+            block_inputs: ClassVar[dict[str, str]] = {"d": "live_preserved"}
+
+            def __init__(self, d) -> None:
+                super().__init__()
+                self.d = d
+                self.extend(qb.H(d[0]), qb.CX(d[0], d[1]))
+
+        prog = Main(
+            outer_q := QReg("outer_q", 3),
+            c := CReg("c", 3),
+            qb.Prep(outer_q),
+            BundleBlock([outer_q[0], outer_q[2]]),
+            Measure(outer_q) > c,
+        )
+
+        ast = slr_to_ast(prog)
+        calls = [s for s in ast.body if isinstance(s, BlockCall)]
+        assert calls[0].arg_bindings == (
+            QubitBundleArg(
+                slots=(
+                    SlotRef(allocator="outer_q", index=0),
+                    SlotRef(allocator="outer_q", index=2),
+                ),
+            ),
+        )
+
+        qasm_src = SlrConverter(prog).qasm()
+        # Bundle slot 0 -> outer_q[0], slot 1 -> outer_q[2] (non-contiguous).
+        assert "h outer_q[0];" in qasm_src
+        assert "cx outer_q[0], outer_q[2];" in qasm_src
+        assert re.search(r"def bundleblock_\d+\(d: array\[qubit, 2\] @ owned\)", SlrConverter(prog).guppy())
+
+    def test_cross_qreg_bundle_detected_and_inlined(self) -> None:
+        from pecos.slr import CReg, Main, QReg, SlrConverter
+        from pecos.slr.ast import slr_to_ast
+        from pecos.slr.ast.nodes import QubitBundleArg, SlotRef
+        from pecos.slr.block import Block
+        from pecos.slr.qeclib import qubit as qb
+        from pecos.slr.qeclib.qubit.measures import Measure
+
+        class BundleBlock(Block):
+            block_inputs: ClassVar[dict[str, str]] = {"d": "live_preserved"}
+
+            def __init__(self, d) -> None:
+                super().__init__()
+                self.d = d
+                self.extend(qb.H(d[0]), qb.CX(d[0], d[1]))
+
+        prog = Main(
+            qa := QReg("qa", 2),
+            qb_reg := QReg("qb", 2),
+            c := CReg("c", 4),
+            qb.Prep(qa),
+            qb.Prep(qb_reg),
+            BundleBlock([qa[0], qb_reg[1]]),
+            Measure(qa) > c[0:2],
+            Measure(qb_reg) > c[2:4],
+        )
+
+        ast = slr_to_ast(prog)
+        calls = [s for s in ast.body if isinstance(s, BlockCall)]
+        assert calls[0].arg_bindings == (
+            QubitBundleArg(
+                slots=(
+                    SlotRef(allocator="qa", index=0),
+                    SlotRef(allocator="qb", index=1),
+                ),
+            ),
+        )
+
+        qasm_src = SlrConverter(prog).qasm()
+        # Cross-allocator: d[0] -> qa[0], d[1] -> qb[1].
+        assert "h qa[0];" in qasm_src
+        assert "cx qa[0], qb[1];" in qasm_src
+        # Emitter packs the non-contiguous bundle into one array arg.
+        assert "array(qa_0, qb_1)" in SlrConverter(prog).guppy()
+
+    def test_check_shaped_block_all_three_shapes_detected(self) -> None:
+        """The realistic qeclib `Check` shape (5e.3's target): a `list[Qubit]`
+        data bundle (live_preserved), a single ancilla `Qubit` (consumed,
+        measured in-body), and a single `Bit` write-back (live_preserved).
+        """
+        from pecos.slr import CReg, Main, QReg, SlrConverter
+        from pecos.slr.ast import slr_to_ast
+        from pecos.slr.ast.nodes import BitRef as AstBitRef
+        from pecos.slr.ast.nodes import (
+            QubitBundleArg,
+            SingleBitArg,
+            SingleQubitArg,
+            SlotRef,
+        )
+        from pecos.slr.block import Block
+        from pecos.slr.qeclib import qubit as qb
+        from pecos.slr.qeclib.qubit.measures import Measure
+
+        class CheckLike(Block):
+            block_inputs: ClassVar[dict[str, str]] = {
+                "d": "live_preserved",
+                "a": "consumed",
+                "out": "live_preserved",
+            }
+
+            def __init__(self, d, a, out) -> None:
+                super().__init__()
+                self.d = d
+                self.a = a
+                self.out = out
+                self.extend(
+                    qb.H(a),
+                    qb.CX(a, d[0]),
+                    qb.CX(a, d[1]),
+                    qb.H(a),
+                    Measure(a) > out,
+                )
+
+        prog = Main(
+            outer_q := QReg("outer_q", 3),
+            c := CReg("c", 3),
+            qb.Prep(outer_q),
+            CheckLike([outer_q[0], outer_q[1]], outer_q[2], c[0]),
+            Measure(outer_q[0]) > c[1],
+            Measure(outer_q[1]) > c[2],
+        )
+
+        ast = slr_to_ast(prog)
+        call = next(s for s in ast.body if isinstance(s, BlockCall))
+        assert call.arg_bindings == (
+            QubitBundleArg(
+                slots=(
+                    SlotRef(allocator="outer_q", index=0),
+                    SlotRef(allocator="outer_q", index=1),
+                ),
+            ),
+            SingleQubitArg(slot=SlotRef(allocator="outer_q", index=2)),
+            SingleBitArg(bit=AstBitRef(register="c", index=0)),
+        )
+        # CONSUMED `a` must NOT appear in out_bindings (it is gone post-call);
+        # the two LIVE_PRESERVED inputs must.
+        assert call.out_bindings == (
+            QubitBundleArg(
+                slots=(
+                    SlotRef(allocator="outer_q", index=0),
+                    SlotRef(allocator="outer_q", index=1),
+                ),
+            ),
+            SingleBitArg(bit=AstBitRef(register="c", index=0)),
+        )
+
+        qasm_src = SlrConverter(prog).qasm()
+        assert "h outer_q[2];" in qasm_src
+        assert "cx outer_q[2], outer_q[0];" in qasm_src
+        assert "cx outer_q[2], outer_q[1];" in qasm_src
+        assert "measure outer_q[2] -> c[0];" in qasm_src
+
+        guppy_src = SlrConverter(prog).guppy()
+        assert re.search(
+            r"def checklike_\d+\(d: array\[qubit, 2\] @ owned, a: qubit @ owned, "
+            r"out: array\[bool, 1\] @ owned\) -> tuple\[array\[qubit, 2\], array\[bool, 1\]\]:",
+            guppy_src,
+        )
+
+    @pytest.mark.parametrize(
+        ("make_block", "match"),
+        [
+            ("whole_creg", r"whole CReg input is not yet supported"),
+            ("list_bit", r"list\[Bit\] .*is not yet supported"),
+            ("empty_bundle", r"empty list bundle is not supported"),
+            ("mixed_bundle", r"a bundle must be all Qubit"),
+            ("symbolic", r"symbolic .*is not supported as a block input"),
+        ],
+    )
+    def test_unsupported_input_shapes_rejected_via_converter(
+        self,
+        make_block: str,
+        match: str,
+    ) -> None:
+        from pecos.slr import CReg, Main, QReg
+        from pecos.slr.ast import slr_to_ast
+        from pecos.slr.block import Block
+        from pecos.slr.vars import LoopVar
+
+        class WholeCReg(Block):
+            block_inputs: ClassVar[dict[str, str]] = {"out": "live_preserved"}
+
+            def __init__(self, out) -> None:
+                super().__init__()
+                self.out = out
+
+        class ListBit(Block):
+            block_inputs: ClassVar[dict[str, str]] = {"out": "live_preserved"}
+
+            def __init__(self, out) -> None:
+                super().__init__()
+                self.out = out
+
+        class Empty(Block):
+            block_inputs: ClassVar[dict[str, str]] = {"d": "live_preserved"}
+
+            def __init__(self, d) -> None:
+                super().__init__()
+                self.d = d
+
+        class Mixed(Block):
+            block_inputs: ClassVar[dict[str, str]] = {"d": "live_preserved"}
+
+            def __init__(self, d) -> None:
+                super().__init__()
+                self.d = d
+
+        class Sym(Block):
+            block_inputs: ClassVar[dict[str, str]] = {"q": "live_preserved"}
+
+            def __init__(self, q) -> None:
+                super().__init__()
+                self.q = q
+
+        if make_block == "whole_creg":
+            prog = Main(c := CReg("c", 2), WholeCReg(c))
+        elif make_block == "list_bit":
+            prog = Main(c := CReg("c", 2), ListBit([c[0], c[1]]))
+        elif make_block == "empty_bundle":
+            prog = Main(QReg("o", 1), Empty([]))
+        elif make_block == "mixed_bundle":
+            prog = Main(o := QReg("o", 1), c := CReg("c", 1), Mixed([o[0], c[0]]))
+        else:  # symbolic
+            prog = Main(o := QReg("o", 2), Sym(o[LoopVar("i")]))
+
+        with pytest.raises(ValueError, match=match):
+            slr_to_ast(prog)
+
+    def test_duplicate_qubit_in_bundle_rejected(self) -> None:
+        """Regression: `[q[0], q[0]]` corrupted body substitution
+        (Guppy rejected on linearity; QASM flatten emitted `cx q[0], q[0];`).
+        Must reject at SLR -> AST conversion with a clear message.
+        """
+        from pecos.slr import Main, QReg
+        from pecos.slr.ast import slr_to_ast
+        from pecos.slr.block import Block
+        from pecos.slr.qeclib import qubit as qb
+
+        class DupBundle(Block):
+            block_inputs: ClassVar[dict[str, str]] = {"d": "live_preserved"}
+
+            def __init__(self, d) -> None:
+                super().__init__()
+                self.d = d
+                self.extend(qb.H(d[0]), qb.CX(d[0], d[1]))
+
+        prog = Main(q := QReg("q", 2), DupBundle([q[0], q[0]]))
+        with pytest.raises(ValueError, match=r"qubit q\[0\] is also bound .*no-cloning"):
+            slr_to_ast(prog)
+
+    def test_two_single_qubit_inputs_aliased_rejected(self) -> None:
+        """Two distinct single-qubit inputs bound to the SAME outer slot is
+        the same aliasing bug from the cross-input direction.
+        """
+        from pecos.slr import Main, QReg
+        from pecos.slr.ast import slr_to_ast
+        from pecos.slr.block import Block
+        from pecos.slr.qeclib import qubit as qb
+
+        class TwoSq(Block):
+            block_inputs: ClassVar[dict[str, str]] = {
+                "a": "live_preserved",
+                "b": "live_preserved",
+            }
+
+            def __init__(self, a, b) -> None:
+                super().__init__()
+                self.a = a
+                self.b = b
+                self.extend(qb.CX(a, b))
+
+        prog = Main(q := QReg("q", 2), TwoSq(q[0], q[0]))
+        with pytest.raises(ValueError, match=r"qubit q\[0\] is also bound by input 'a'"):
+            slr_to_ast(prog)
+
+    def test_two_bit_inputs_aliased_rejected(self) -> None:
+        """Same outer bit backing two single-bit inputs is lossy during
+        body substitution -- reject it too.
+        """
+        from pecos.slr import CReg, Main
+        from pecos.slr.ast import slr_to_ast
+        from pecos.slr.block import Block
+
+        class TwoBit(Block):
+            block_inputs: ClassVar[dict[str, str]] = {
+                "x": "live_preserved",
+                "y": "live_preserved",
+            }
+
+            def __init__(self, x, y) -> None:
+                super().__init__()
+                self.x = x
+                self.y = y
+
+        prog = Main(c := CReg("c", 2), TwoBit(c[0], c[0]))
+        with pytest.raises(ValueError, match=r"bit c\[0\] is also bound by input 'x'"):
+            slr_to_ast(prog)
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_substitution.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_substitution.py
index 705cc64b8..f48a72514 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_substitution.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_substitution.py
@@ -12,8 +12,8 @@
 """Phase 3a.3 iter 5e.1 -- direct unit tests for the shared body substitution.
 
 The 7 already-converted Steane Blocks only exercise the *whole-allocator
-identity* path (`q[i] -> q[i]`). Per Codex's iter-5e plan review, 5e.1 is
-"dead-code-with-tests" without coverage of the NON-identity slot/bit maps
+identity* path (`q[i] -> q[i]`). 5e.1 is "dead-code-with-tests" without
+coverage of the NON-identity slot/bit maps
 (`q[2] -> d[0]`, `c[3] -> out[0]`) and every recursive node kind plus the
 reject-on-partial paths. These tests pin exactly that, asserting the
 rewritten ref (not just "it compiled").
@@ -233,8 +233,8 @@ def test_prepare_all_whole_renamed(self) -> None:
 
     def test_prepare_slots_remapped_preserves_source_order(self) -> None:
         # Prep(q[2], q[5]) under q[2]->d[0], q[5]->d[1] -> Prep(d, (0, 1)).
-        # Exact order asserted (Codex 5e.1 #3): the lowering preserves source
-        # slot order; sorted() would mask an ordering regression.
+        # Exact order asserted: the lowering preserves source slot order;
+        # sorted() would mask an ordering regression.
         prep = PrepareOp(allocator="q", slots=(2, 5))
         out = substitute_stmt(prep, _bundle_remap())
         assert out.allocator == "d"
@@ -261,7 +261,7 @@ def test_prepare_slots_multi_allocator_rejected(self) -> None:
 
 
 class TestBuilderConflictRejection:
-    """Codex 5e.1 review #2: an outer name bound in conflicting modes
+    """An outer name bound in conflicting modes
     (whole + partial, or whole twice) is input aliasing -- reject at
     construction time, not silently let whole win at lookup. Protects the
     QASM/flatten path where Guppy's own linearity alias check never runs.
@@ -292,6 +292,31 @@ def test_partial_then_bit_same_name_ok_distinct_names_ok(self) -> None:
         remap.add_bit(("c", 3), ("out", 0))  # different name -- fine
         remap.add_whole_alloc("r", "rp", 2)  # different name -- fine
 
+    def test_repeated_exact_slot_source_rejected(self) -> None:
+        """A repeated exact source slot must reject, not
+        silently overwrite (a `[q[0], q[0]]` bundle or two single-qubit
+        inputs aliased to the same outer slot -- corrupts body rewrite;
+        Guppy rejects on linearity while QASM flatten emitted bad code).
+        """
+        remap = BodyRemap()
+        remap.add_slot(("q", 0), ("d", 0))
+        with pytest.raises(BodySubstitutionError, match=r"qubit slot \('q', 0\) is already bound"):
+            remap.add_slot(("q", 0), ("d", 1))
+
+    def test_repeated_exact_bit_source_rejected(self) -> None:
+        remap = BodyRemap()
+        remap.add_bit(("c", 0), ("out", 0))
+        with pytest.raises(BodySubstitutionError, match=r"bit \('c', 0\) is already bound"):
+            remap.add_bit(("c", 0), ("flag", 0))
+
+    def test_distinct_slots_same_dst_register_ok(self) -> None:
+        # Distinct source slots are fine even if they target the same
+        # destination allocator at different indices (the flatten
+        # PARAM->OUTER direction does exactly this for a bundle).
+        remap = BodyRemap()
+        remap.add_slot(("d", 0), ("q", 0))
+        remap.add_slot(("d", 1), ("q", 2))
+
 
 class TestRejectOnPartialNameLevel:
     def test_barrier_partial_name_rejected(self) -> None:
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_deprecation_warnings.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_deprecation_warnings.py
index ff49e29d0..58bf66318 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_deprecation_warnings.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_deprecation_warnings.py
@@ -165,8 +165,8 @@ def test_warning_does_not_block_compilation(self) -> None:
 
     def test_warning_points_at_user_call_site(self) -> None:
         """Stacklevel must attribute to the user's .guppy()/.hugr()/etc. call site,
-        not to internals of slr_converter.py. Empirically verified post-Codex's
-        review (round 2): stacklevel=3 from `_maybe_warn_implicit_return_deprecation`
+        not to internals of slr_converter.py. Empirically verified:
+        stacklevel=3 from `_maybe_warn_implicit_return_deprecation`
         walks past the warn line, past the helper, past the public method,
         landing on the user.
         """
@@ -223,7 +223,7 @@ def test_measure_with_no_result_does_not_warn(self) -> None:
         """`Measure(q[0])` without a `> c[i]` results tuple writes to no CReg,
         so the implicit-return rule is not engaged. Don't warn.
 
-        Codex tracer-bullet review v3: the original walker treated *any*
+        Tracer-bullet regression: the original walker treated *any*
         MeasureOp as evidence of implicit-return reliance, which was a
         false positive for measure-and-discard patterns.
         """
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
index b71d4a172..98182b8c7 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
@@ -468,7 +468,7 @@ class TestInlineCRegDefiniteAssignment:
     """
 
     def test_print_bit_before_measure_on_inline_creg_rejected(self) -> None:
-        """Codex's original tracer-bullet bug case, lifted to bit-level form.
+        """Original tracer-bullet bug case, lifted to bit-level form.
 
         Print(inline[0]) before Measure(...) > inline[0] is rejected because
         bit-level definite-assignment hasn't been established for index 0.
@@ -567,7 +567,7 @@ def test_inline_creg_assigned_in_static_for_propagates(self) -> None:
         SlrConverter(prog).hugr()
 
     def test_print_inline_bit_with_only_other_bit_measured_rejected(self) -> None:
-        """Codex's exact bit-level soundness gap: Measure(inline[0]); Print(inline[1])
+        """Bit-level soundness gap: Measure(inline[0]); Print(inline[1])
         should be rejected, not silently emit a runtime out-of-bounds read.
 
         Before bit-level tracking the validator marked the whole inline CReg as
@@ -606,8 +606,8 @@ def test_whole_inline_creg_print_rejected_outright(self) -> None:
         with pytest.raises(GuppyCodegenError, match=r"Print\(whole-CReg\) of inline CReg"):
             SlrConverter(prog).hugr()
 
-    def test_whole_inline_creg_print_codex_shrink_case_rejected(self) -> None:
-        """Regression for Codex's tracer-bullet review v2: whole-CReg Print of an
+    def test_whole_inline_creg_print_shrink_case_rejected(self) -> None:
+        """Regression for the tracer-bullet shrink case: whole-CReg Print of an
         inline CReg silently emitting a register smaller than the user declared.
 
         Before this fix, `inline = CReg("inline", 2)` with only inline[0]
@@ -641,11 +641,11 @@ def test_whole_declared_creg_print_accepted(self) -> None:
         SlrConverter(prog).hugr()
 
 
-# ── Additional path-signature edge cases per Codex's review ─────────────
+# ── Additional path-signature edge cases ───────────────────────────────
 
 
 class TestPathSignatureEdgeCases:
-    """Coverage Codex called out as missing in f2ebb32c."""
+    """Coverage called out as missing in f2ebb32c."""
 
     def test_while_with_print_rejected(self) -> None:
         """While body with Print is rejected (v1 also rejects While outright)."""
@@ -738,7 +738,7 @@ def test_non_static_for_with_print_via_ast_rejected(self) -> None:
             emitter.generate(prog)
 
 
-# ── Cross-codegen byte-identity (per Codex review v2-blockcall-resource-effects) ─
+# ── Cross-codegen byte-identity (v2-blockcall-resource-effects) ─────────
 
 
 class TestCrossCodegenPrintEmission:
@@ -782,7 +782,7 @@ def _bell_with_print() -> Main:
     def test_qasm_emits_print_as_exactly_one_comment_line(self) -> None:
         """QASM adds exactly one `// Print result.debug c` line; otherwise identical.
 
-        Per Codex round-3 review: "in `added_lines`" is too loose -- a future
+        "in `added_lines`" is too loose -- a future
         regression could add extra lines silently and the test would still pass.
         Assert the added line is exactly `[expected_comment]` (one line, no more).
         """
@@ -816,7 +816,7 @@ def test_quantum_circuit_byte_identical(self) -> None:
 
 
 class TestSeleneShapeEdgeCases:
-    """Pin non-obvious Selene `to_dict()` shapes that grug guessed wrong about.
+    """Pin non-obvious Selene `to_dict()` shapes that were easy to get wrong.
 
     These tests use empirically-probed reference shapes. If Selene's
     representation changes, the test fails loudly and the doc text in
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_acceptance.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_acceptance.py
index bf4a7e602..b8e8dd6bb 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_acceptance.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_acceptance.py
@@ -8,7 +8,7 @@
     ~/Repos/pecos-docs/design/slr/v1-feature-matrix.md
     ~/Repos/pecos-docs/design/slr/stage5-integrity-review.md (findings 5, 6)
 
-Test layout follows Codex's "practical v1 acceptance set" plus the
+Test layout follows the "practical v1 acceptance set" plus the
 coverage gaps surfaced in stage 5 (final-root-return, static For,
 Parallel, Prep-after-measure, mixed Permute, gates beyond CX,
 SZ/SZdg mapping, measurement-without-output, targeted unsupported
@@ -221,7 +221,7 @@ def test_final_root_return_qubit_array(self) -> None:
 
 
 # Rejection tests for divergent control flow + unsupported gates land
-# in a follow-up PR once Codex's emitter has a specific `LinearityError`
+# in a follow-up PR once the emitter has a specific `LinearityError`
 # (or analogous typed error) to assert against. Asserting `Exception`
 # today would silently pass on the AST path's pre-existing breakage --
 # a fallback the design philosophy explicitly disallows. See:

From 45dc0b6c29b364184c3cabd1002c799e7318ab7e Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sat, 16 May 2026 05:38:07 -0600
Subject: [PATCH 049/136] Scratch-ancilla S1: ResourceEffect.SCRATCH +
 converter detection (excluded from out_bindings, kept for O2 alias guard) +
 R4 Prep->Measure segment-lifecycle validator (every Prep closed by Measure) +
 13 lock-in tests.

---
 .../src/pecos/slr/ast/converter.py            | 159 +++++++++
 .../quantum-pecos/src/pecos/slr/ast/nodes.py  |   7 +
 .../ast_guppy/test_block_call_smoke.py        | 325 ++++++++++++++++++
 3 files changed, 491 insertions(+)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/converter.py b/python/quantum-pecos/src/pecos/slr/ast/converter.py
index 7a81b01ea..836d7e7db 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/converter.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/converter.py
@@ -423,6 +423,7 @@ def _convert_block_call(self, block: Block) -> BlockCall:
         block_inputs: list[BlockInput] = []
         arg_bindings: list[BlockArg] = []
         out_bindings: list[BlockArg] = []
+        scratch_inputs: list[str] = []
 
         # Cross-input aliasing guard. The same concrete qubit slot (or
         # classical bit) bound to two block-input positions --
@@ -539,8 +540,13 @@ def _claim_bit(reg: str, index: int, *, here: str, owner: str) -> None:
             arg_bindings.append(arg)
             # out_bindings mirror the arg BlockArg for each LIVE_PRESERVED input
             # (the emitter's iter-5b cross-check requires arg == out, by value).
+            # SCRATCH is NOT live-preserved -> never in out_bindings (same as
+            # CONSUMED); it stays in arg_bindings so the 5e.2 cross-input alias
+            # guard still rejects a scratch slot aliased to another input (O2).
             if effect is ResourceEffect.LIVE_PRESERVED:
                 out_bindings.append(arg)
+            if effect is ResourceEffect.SCRATCH:
+                scratch_inputs.append(input_name)
 
         # Build the BlockDecl body by converting block.ops in a NEW sub-converter,
         # then remapping outer -> param via the shared substitute_stmt. Share
@@ -551,6 +557,15 @@ def _claim_bit(reg: str, index: int, *, here: str, owner: str) -> None:
         self._decl_counter = sub._decl_counter  # type: ignore[attr-defined]
         rewritten_body = tuple(substitute_stmt(stmt, remap) for stmt in sub_body)
 
+        # R4 (scratch design): a SCRATCH input is only sound if the block
+        # resets it before any other use and never touches it after the
+        # terminal measurement without re-Prepping. The Guppy lowering
+        # (S2) allocates the qubit internally on that assumption; validate
+        # it here so a mis-declared scratch input fails loudly at
+        # conversion rather than miscompiling.
+        for scratch_name in scratch_inputs:
+            _validate_scratch_input(rewritten_body, scratch_name, cls_name=cls_name)
+
         # Unique decl name per call site (dedup is a later optimization).
         decl_name = f"{cls_name.lower()}_{self._decl_counter}"
         self._decl_counter += 1
@@ -977,6 +992,7 @@ def slr_to_ast(block: Main | Block) -> Program:
     "consumed": ResourceEffect.CONSUMED,
     "produced": ResourceEffect.PRODUCED,
     "dropped": ResourceEffect.DROPPED,
+    "scratch": ResourceEffect.SCRATCH,
 }
 
 
@@ -998,3 +1014,146 @@ def _normalize_effect(value: Any, *, where: str) -> ResourceEffect:
     )
     raise ValueError(msg)
 
+
+def _ref_base_name(ref: str) -> str:
+    """Leading identifier of a PermuteOp ref string (`q[0]`/`q`/`q.x` -> `q`)."""
+    return ref.split("[", 1)[0].split(".", 1)[0]
+
+
+def _scratch_events(stmt: Statement, name: str) -> list[str]:
+    """Ordered scratch-lifecycle events for allocator `name` in `stmt`.
+
+    Returns a list drawn from PREP / MEASURE / USE in execution order.
+    A reference inside control flow / Parallel / a nested BlockCall /
+    PermuteOp cannot be linearized for the R4 reset-first analysis, so
+    it is reported as the sentinel UNSUPPORTED and the validator rejects
+    (S1 scope: scratch inputs must have a flat Prep -> ... -> Measure
+    lifecycle).
+    """
+    if isinstance(stmt, CommentOp):
+        return []
+    if isinstance(stmt, PrepareOp):
+        return ["PREP"] if stmt.allocator == name else []
+    if isinstance(stmt, MeasureOp):
+        return ["MEASURE"] if any(t.allocator == name for t in stmt.targets) else []
+    if isinstance(stmt, GateOp):
+        return ["USE"] if any(t.allocator == name for t in stmt.targets) else []
+    if isinstance(stmt, BarrierOp):
+        return ["USE"] if name in stmt.allocators else []
+    if isinstance(stmt, PermuteOp):
+        refs = (*stmt.sources, *stmt.targets)
+        return ["UNSUPPORTED"] if any(_ref_base_name(r) == name for r in refs) else []
+    if isinstance(stmt, BlockCall):
+        for arg in (*stmt.arg_bindings, *stmt.out_bindings):
+            if _block_arg_mentions_allocator(arg, name):
+                return ["UNSUPPORTED"]
+        return []
+    if isinstance(stmt, (IfStmt, WhileStmt, ForStmt, RepeatStmt, ParallelBlock)):
+        bodies: list[tuple[Statement, ...]] = (
+            [stmt.then_body, stmt.else_body] if isinstance(stmt, IfStmt) else [stmt.body]
+        )
+        for b in bodies:
+            for inner in b:
+                if _scratch_events(inner, name):
+                    return ["UNSUPPORTED"]
+        return []
+    # Anything else carrying no qubit-slot ref (e.g. AssignOp/PrintOp/
+    # ReturnOp on classical values) is irrelevant to a qubit scratch slot.
+    return []
+
+
+def _block_arg_mentions_allocator(arg: BlockArg, name: str) -> bool:
+    """True if a nested BlockCall arg references qubit allocator `name`."""
+    slot = getattr(arg, "slot", None)
+    if slot is not None and getattr(slot, "allocator", None) == name:
+        return True
+    if getattr(arg, "name", None) == name:  # AllocatorArg(name=...)
+        return True
+    slots = getattr(arg, "slots", None)
+    return bool(slots) and any(getattr(s, "allocator", None) == name for s in slots)
+
+
+def _validate_scratch_input(
+    body: tuple[Statement, ...],
+    name: str,
+    *,
+    cls_name: str,
+) -> None:
+    """Enforce R4 for a SCRATCH input (design v2-scratch-ancilla-effect).
+
+    The block must reset `name` before any other use, and every Prep
+    lifecycle must be closed by a Measure before the next Prep and
+    before the body ends (the S2 Guppy lowering allocates the scratch
+    qubit internally, so an unmeasured trailing Prep/use would diverge
+    from the flatten/QASM path). Anything the
+    S1 analysis cannot linearize (control flow / Parallel / nested
+    BlockCall / Permute over the scratch slot) is rejected loudly --
+    silently allowing it would let the Guppy internal-allocation
+    lowering miscompile.
+    """
+    events: list[str] = []
+    for stmt in body:
+        events.extend(_scratch_events(stmt, name))
+
+    where = f"Block {cls_name!r} scratch input {name!r}"
+    if "UNSUPPORTED" in events:
+        msg = (
+            f"{where}: scratch inputs must have a flat Prep -> ... -> "
+            "Measure lifecycle; referencing the scratch slot inside "
+            "control flow, Parallel, a nested BlockCall, or a Permute "
+            "is not supported"
+        )
+        raise ValueError(msg)
+    if not events:
+        msg = (
+            f"{where}: declared SCRATCH but never used in the block body "
+            "(expected Prep(...) then Measure(...))"
+        )
+        raise ValueError(msg)
+    if events[0] != "PREP":
+        msg = (
+            f"{where}: first use is {events[0]}, but a SCRATCH input must "
+            "be reset (Prep) before any other use (reset-first)"
+        )
+        raise ValueError(msg)
+    # Segment state machine: a PREP opens a lifecycle that MUST close with a
+    # MEASURE before the next PREP and before the body ends. The S2 Guppy
+    # lowering allocates the scratch qubit internally; an unmeasured trailing
+    # Prep/use would leave the flatten/QASM path with a live reset outer slot
+    # while Guppy silently drops it -- a semantic divergence (Codex S1
+    # review). So every Prep must be terminated by a Measure.
+    open_prep = False
+    for ev in events:
+        if ev == "PREP":
+            if open_prep:
+                msg = (
+                    f"{where}: re-Prepped before measuring the previous "
+                    "scratch lifecycle (every Prep must be closed by a "
+                    "Measure)"
+                )
+                raise ValueError(msg)
+            open_prep = True
+        elif ev == "MEASURE":
+            if not open_prep:
+                msg = (
+                    f"{where}: measured without an open Prep (measure "
+                    "before Prep, or measured again without an "
+                    "intervening Prep)"
+                )
+                raise ValueError(msg)
+            open_prep = False
+        else:  # USE
+            if not open_prep:
+                msg = (
+                    f"{where}: used after measurement without re-Prep "
+                    "(scratch lifecycle must be Prep -> use -> Measure)"
+                )
+                raise ValueError(msg)
+    if open_prep:
+        msg = (
+            f"{where}: scratch lifecycle not closed -- a Prep has no "
+            "terminating Measure; the block must measure the scratch "
+            "qubit before returning (S2 allocates it internally)"
+        )
+        raise ValueError(msg)
+
diff --git a/python/quantum-pecos/src/pecos/slr/ast/nodes.py b/python/quantum-pecos/src/pecos/slr/ast/nodes.py
index 562f63c10..12b2e76e8 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/nodes.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/nodes.py
@@ -224,6 +224,13 @@ class ResourceEffect(Enum):
     CONSUMED = auto()  # caller binding is invalidated by the call
     PRODUCED = auto()  # callee writes; caller's binding is rebound from return
     DROPPED = auto()  # callee discards; caller binding is invalidated
+    # Reset-reused scratch ancilla: the block resets the input at entry and
+    # measures it at exit, depending on no incoming state. The caller's slot is
+    # a flatten-path naming vehicle only; in Guppy the block allocates the qubit
+    # internally so the same outer slot can feed a subsequent BlockCall (the
+    # `consumed` model would kill it). See
+    # ~/Repos/pecos-docs/design/slr/v2-scratch-ancilla-effect.md.
+    SCRATCH = auto()
 
 
 # =============================================================================
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
index 3e8538a65..79b5e7652 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
@@ -2126,3 +2126,328 @@ def __init__(self, x, y) -> None:
         prog = Main(c := CReg("c", 2), TwoBit(c[0], c[0]))
         with pytest.raises(ValueError, match=r"bit c\[0\] is also bound by input 'x'"):
             slr_to_ast(prog)
+
+
+class TestScratchEffectS1:
+    """Phase 3a.3 scratch-ancilla effect, stage S1: `ResourceEffect.SCRATCH`
+    + converter detection + the mandatory R4 reset-first validator + O2.
+
+    S1 does NOT lower scratch in Guppy (that is S2); until then Guppy must
+    reject a SCRATCH input loudly (no silent fallback). Flatten/QASM
+    already works because the scratch param substitutes to the outer slot
+    exactly like any per-slot input. Design:
+    ~/Repos/pecos-docs/design/slr/v2-scratch-ancilla-effect.md.
+    """
+
+    @staticmethod
+    def _good_check():
+        from pecos.slr import Block
+        from pecos.slr.qeclib import qubit as qb
+        from pecos.slr.qeclib.qubit.measures import Measure
+
+        class GoodCheck(Block):
+            block_inputs: ClassVar[dict[str, str]] = {
+                "d": "live_preserved",
+                "a": "scratch",
+                "out": "live_preserved",
+            }
+
+            def __init__(self, d, a, out) -> None:
+                super().__init__()
+                self.d = d
+                self.a = a
+                self.out = out
+                self.extend(qb.Prep(a), qb.CX(a, d[0]), qb.CX(a, d[1]), Measure(a) > out)
+
+        return GoodCheck
+
+    def test_scratch_detected_excluded_from_out_bindings(self) -> None:
+        from pecos.slr import CReg, Main, QReg
+        from pecos.slr.ast import slr_to_ast
+        from pecos.slr.ast.nodes import (
+            QubitBundleArg,
+            SingleBitArg,
+            SingleQubitArg,
+        )
+        from pecos.slr.qeclib import qubit as qb
+
+        good_check = self._good_check()
+        prog = Main(
+            q := QReg("q", 3),
+            c := CReg("c", 1),
+            qb.Prep(q),
+            good_check([q[0], q[1]], q[2], c[0]),
+        )
+        ast = slr_to_ast(prog)
+        call = next(s for s in ast.body if isinstance(s, BlockCall))
+        # Scratch `a` is detected as a single-qubit arg and stays in
+        # arg_bindings (O2: the 5e.2 alias guard still applies)...
+        assert any(
+            isinstance(a, SingleQubitArg) for a in call.arg_bindings
+        )
+        # ...but is NOT live-preserved, so it is absent from out_bindings.
+        assert call.out_bindings == (
+            QubitBundleArg(
+                slots=tuple(s for s in call.arg_bindings[0].slots),  # d
+            ),
+            SingleBitArg(bit=call.arg_bindings[2].bit),  # out
+        )
+
+    def test_scratch_flatten_substitutes_to_outer_slot(self) -> None:
+        from pecos.slr import CReg, Main, QReg, SlrConverter
+        from pecos.slr.qeclib import qubit as qb
+
+        good_check = self._good_check()
+        prog = Main(
+            q := QReg("q", 3),
+            c := CReg("c", 1),
+            qb.Prep(q),
+            good_check([q[0], q[1]], q[2], c[0]),
+        )
+        qasm = SlrConverter(prog).qasm()
+        # Param `a` -> outer slot q[2]; data bundle d[0]/d[1] -> q[0]/q[1].
+        assert "reset q[2];" in qasm
+        assert "cx q[2], q[0];" in qasm
+        assert "cx q[2], q[1];" in qasm
+        assert "measure q[2] -> c[0];" in qasm
+
+    def test_scratch_rejected_by_guppy_until_s2(self) -> None:
+        """Lock-in: no silent fallback. Guppy must raise a clean
+        not-yet-supported error for SCRATCH until S2 lands.
+        """
+        from pecos.slr import CReg, Main, QReg, SlrConverter
+        from pecos.slr.ast.codegen.guppy import GuppyCodegenError
+        from pecos.slr.qeclib import qubit as qb
+
+        good_check = self._good_check()
+        prog = Main(
+            q := QReg("q", 3),
+            c := CReg("c", 1),
+            qb.Prep(q),
+            good_check([q[0], q[1]], q[2], c[0]),
+        )
+        with pytest.raises(GuppyCodegenError, match=r"only LIVE_PRESERVED and CONSUMED.*got SCRATCH"):
+            SlrConverter(prog).guppy()
+
+    def test_scratch_use_before_prep_rejected(self) -> None:
+        from pecos.slr import CReg, Main, QReg
+        from pecos.slr.ast import slr_to_ast
+        from pecos.slr.block import Block
+        from pecos.slr.qeclib import qubit as qb
+        from pecos.slr.qeclib.qubit.measures import Measure
+
+        class BadFirst(Block):
+            block_inputs: ClassVar[dict[str, str]] = {"a": "scratch", "out": "live_preserved"}
+
+            def __init__(self, a, out) -> None:
+                super().__init__()
+                self.a = a
+                self.out = out
+                self.extend(qb.H(a), qb.Prep(a), Measure(a) > out)
+
+        prog = Main(q := QReg("q", 1), c := CReg("c", 1), BadFirst(q[0], c[0]))
+        with pytest.raises(ValueError, match=r"first use is USE.*reset \(Prep\) before"):
+            slr_to_ast(prog)
+
+    def test_scratch_use_after_measure_rejected(self) -> None:
+        from pecos.slr import CReg, Main, QReg
+        from pecos.slr.ast import slr_to_ast
+        from pecos.slr.block import Block
+        from pecos.slr.qeclib import qubit as qb
+        from pecos.slr.qeclib.qubit.measures import Measure
+
+        class BadAfter(Block):
+            block_inputs: ClassVar[dict[str, str]] = {"a": "scratch", "out": "live_preserved"}
+
+            def __init__(self, a, out) -> None:
+                super().__init__()
+                self.a = a
+                self.out = out
+                self.extend(qb.Prep(a), Measure(a) > out, qb.H(a))
+
+        prog = Main(q := QReg("q", 1), c := CReg("c", 1), BadAfter(q[0], c[0]))
+        with pytest.raises(ValueError, match=r"used after measurement without re-Prep"):
+            slr_to_ast(prog)
+
+    def test_scratch_unused_rejected(self) -> None:
+        from pecos.slr import Main, QReg
+        from pecos.slr.ast import slr_to_ast
+        from pecos.slr.block import Block
+
+        class BadUnused(Block):
+            block_inputs: ClassVar[dict[str, str]] = {"a": "scratch"}
+
+            def __init__(self, a) -> None:
+                super().__init__()
+                self.a = a
+
+        prog = Main(q := QReg("q", 1), BadUnused(q[0]))
+        with pytest.raises(ValueError, match=r"declared SCRATCH but never used"):
+            slr_to_ast(prog)
+
+    def test_scratch_inside_control_flow_rejected(self) -> None:
+        """S1 conservative scope: a scratch slot touched inside control
+        flow cannot be linearized for the R4 analysis -> reject loudly.
+        """
+        from pecos.slr import CReg, Main, QReg, Repeat
+        from pecos.slr.ast import slr_to_ast
+        from pecos.slr.block import Block
+        from pecos.slr.qeclib import qubit as qb
+        from pecos.slr.qeclib.qubit.measures import Measure
+
+        class LoopScratch(Block):
+            block_inputs: ClassVar[dict[str, str]] = {"a": "scratch", "out": "live_preserved"}
+
+            def __init__(self, a, out) -> None:
+                super().__init__()
+                self.a = a
+                self.out = out
+                self.extend(
+                    qb.Prep(a),
+                    Repeat(2).block(qb.H(a)),
+                    Measure(a) > out,
+                )
+
+        prog = Main(q := QReg("q", 1), c := CReg("c", 1), LoopScratch(q[0], c[0]))
+        with pytest.raises(ValueError, match=r"flat Prep -> \.\.\. -> Measure lifecycle"):
+            slr_to_ast(prog)
+
+    def test_scratch_aliased_to_other_input_rejected(self) -> None:
+        """O2: scratch stays in arg_bindings, so the 5e.2 cross-input
+        aliasing guard still rejects a scratch slot aliased to another
+        qubit input.
+        """
+        from pecos.slr import Main, QReg
+        from pecos.slr.ast import slr_to_ast
+        from pecos.slr.block import Block
+        from pecos.slr.qeclib import qubit as qb
+        from pecos.slr.qeclib.qubit.measures import Measure
+
+        class Alias(Block):
+            block_inputs: ClassVar[dict[str, str]] = {"a": "scratch", "b": "live_preserved"}
+
+            def __init__(self, a, b) -> None:
+                super().__init__()
+                self.a = a
+                self.b = b
+                self.extend(qb.Prep(a), qb.CX(a, b), Measure(a))
+
+        prog = Main(q := QReg("q", 2), Alias(q[0], q[0]))
+        with pytest.raises(ValueError, match=r"qubit q\[0\] is also bound by input 'a'"):
+            slr_to_ast(prog)
+
+    def test_scratch_prep_only_rejected(self) -> None:
+        """Codex S1 review: a Prep with no terminating Measure must be
+        rejected -- S2 allocates the scratch qubit internally, so an
+        unmeasured trailing Prep diverges from the flatten/QASM path.
+        """
+        from pecos.slr import Main, QReg
+        from pecos.slr.ast import slr_to_ast
+        from pecos.slr.block import Block
+        from pecos.slr.qeclib import qubit as qb
+
+        class PrepOnly(Block):
+            block_inputs: ClassVar[dict[str, str]] = {"a": "scratch"}
+
+            def __init__(self, a) -> None:
+                super().__init__()
+                self.a = a
+                self.extend(qb.Prep(a))
+
+        prog = Main(q := QReg("q", 1), PrepOnly(q[0]))
+        with pytest.raises(ValueError, match=r"scratch lifecycle not closed"):
+            slr_to_ast(prog)
+
+    def test_scratch_prep_use_no_measure_rejected(self) -> None:
+        from pecos.slr import Main, QReg
+        from pecos.slr.ast import slr_to_ast
+        from pecos.slr.block import Block
+        from pecos.slr.qeclib import qubit as qb
+
+        class PrepUseNoMeasure(Block):
+            block_inputs: ClassVar[dict[str, str]] = {"a": "scratch"}
+
+            def __init__(self, a) -> None:
+                super().__init__()
+                self.a = a
+                self.extend(qb.Prep(a), qb.H(a))
+
+        prog = Main(q := QReg("q", 1), PrepUseNoMeasure(q[0]))
+        with pytest.raises(ValueError, match=r"scratch lifecycle not closed"):
+            slr_to_ast(prog)
+
+    def test_scratch_prep_measure_prep_unmeasured_rejected(self) -> None:
+        """A second Prep with no closing Measure (trailing open lifecycle)."""
+        from pecos.slr import CReg, Main, QReg
+        from pecos.slr.ast import slr_to_ast
+        from pecos.slr.block import Block
+        from pecos.slr.qeclib import qubit as qb
+        from pecos.slr.qeclib.qubit.measures import Measure
+
+        class PrepMeasurePrep(Block):
+            block_inputs: ClassVar[dict[str, str]] = {"a": "scratch", "out": "live_preserved"}
+
+            def __init__(self, a, out) -> None:
+                super().__init__()
+                self.a = a
+                self.out = out
+                self.extend(qb.Prep(a), Measure(a) > out, qb.Prep(a))
+
+        prog = Main(q := QReg("q", 1), c := CReg("c", 1), PrepMeasurePrep(q[0], c[0]))
+        with pytest.raises(ValueError, match=r"scratch lifecycle not closed"):
+            slr_to_ast(prog)
+
+    def test_scratch_two_prep_no_measure_between_rejected(self) -> None:
+        """Re-Prep before measuring the first lifecycle."""
+        from pecos.slr import Main, QReg
+        from pecos.slr.ast import slr_to_ast
+        from pecos.slr.block import Block
+        from pecos.slr.qeclib import qubit as qb
+
+        class PrepPrep(Block):
+            block_inputs: ClassVar[dict[str, str]] = {"a": "scratch"}
+
+            def __init__(self, a) -> None:
+                super().__init__()
+                self.a = a
+                self.extend(qb.Prep(a), qb.Prep(a))
+
+        prog = Main(q := QReg("q", 1), PrepPrep(q[0]))
+        with pytest.raises(ValueError, match=r"re-Prepped before measuring"):
+            slr_to_ast(prog)
+
+    def test_scratch_prep_measure_prep_measure_accepted(self) -> None:
+        """Two complete Prep -> Measure lifecycles is valid (each closed)."""
+        from pecos.slr import CReg, Main, QReg, SlrConverter
+        from pecos.slr.ast import slr_to_ast
+        from pecos.slr.block import Block
+        from pecos.slr.qeclib import qubit as qb
+        from pecos.slr.qeclib.qubit.measures import Measure
+
+        class TwoLifecycles(Block):
+            block_inputs: ClassVar[dict[str, str]] = {
+                "a": "scratch",
+                "out0": "live_preserved",
+                "out1": "live_preserved",
+            }
+
+            def __init__(self, a, out0, out1) -> None:
+                super().__init__()
+                self.a = a
+                self.out0 = out0
+                self.out1 = out1
+                self.extend(
+                    qb.Prep(a),
+                    Measure(a) > out0,
+                    qb.Prep(a),
+                    Measure(a) > out1,
+                )
+
+        prog = Main(q := QReg("q", 1), c := CReg("c", 2), TwoLifecycles(q[0], c[0], c[1]))
+        ast = slr_to_ast(prog)  # must not raise
+        assert any(isinstance(s, BlockCall) for s in ast.body)
+        # Flatten still substitutes the scratch param to the outer slot.
+        qasm = SlrConverter(prog).qasm()
+        assert qasm.count("reset q[0];") >= 2
+        assert "measure q[0] -> c[0];" in qasm
+        assert "measure q[0] -> c[1];" in qasm

From eb0b9871f9e4b5160e2daf9b850889a528539cd2 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sat, 16 May 2026 05:51:55 -0600
Subject: [PATCH 050/136] Scratch-ancilla S1: reject any ReturnOp in a
 scratch-bearing block (R4 clause 4, Codex S1 r2 -- scratch slot must not be
 handed out); drop dead _expr_mentions_allocator; +return-rejected test.

---
 .../src/pecos/slr/ast/converter.py            | 22 ++++++++--
 .../ast_guppy/test_block_call_smoke.py        | 42 +++++++++++++++++++
 2 files changed, 60 insertions(+), 4 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/converter.py b/python/quantum-pecos/src/pecos/slr/ast/converter.py
index 836d7e7db..ab50aec96 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/converter.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/converter.py
@@ -1057,8 +1057,21 @@ def _scratch_events(stmt: Statement, name: str) -> list[str]:
                 if _scratch_events(inner, name):
                     return ["UNSUPPORTED"]
         return []
-    # Anything else carrying no qubit-slot ref (e.g. AssignOp/PrintOp/
-    # ReturnOp on classical values) is irrelevant to a qubit scratch slot.
+    if isinstance(stmt, ReturnOp):
+        # A scratch input must never be handed back to the caller: S2
+        # allocates it internally and does not thread it through caller
+        # state, so returning it would diverge from the flatten/QASM path
+        # (Codex S1 r2 review). Detection cannot be precise here -- the
+        # substitution leaves Return values as the OUTER name (a partial
+        # VarExpr passes through `whole_name` unchanged), so a returned
+        # scratch slot is indistinguishable from a returned classical
+        # value at this point. Conservatively reject ANY ReturnOp in a
+        # scratch-bearing block (S1 scope: in-scope blocks like `Check`
+        # have no Return; relax deliberately in a later stage if needed).
+        return ["UNSUPPORTED"]
+    # Anything else carries no qubit-slot ref. AssignOp/PrintOp operate on
+    # classical bit/int expressions only -- a qubit scratch slot cannot
+    # appear there -- so they are irrelevant to a qubit scratch lifecycle.
     return []
 
 
@@ -1100,8 +1113,9 @@ def _validate_scratch_input(
         msg = (
             f"{where}: scratch inputs must have a flat Prep -> ... -> "
             "Measure lifecycle; referencing the scratch slot inside "
-            "control flow, Parallel, a nested BlockCall, or a Permute "
-            "is not supported"
+            "control flow, Parallel, a nested BlockCall, or a Permute -- "
+            "or any ReturnOp in a scratch-bearing block -- is not "
+            "supported"
         )
         raise ValueError(msg)
     if not events:
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
index 79b5e7652..564489139 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
@@ -2451,3 +2451,45 @@ def __init__(self, a, out0, out1) -> None:
         assert qasm.count("reset q[0];") >= 2
         assert "measure q[0] -> c[0];" in qasm
         assert "measure q[0] -> c[1];" in qasm
+
+    def test_scratch_return_rejected(self) -> None:
+        """Codex S1 r2: a scratch-bearing block must contain no ReturnOp.
+
+        Post-substitution a returned scratch slot keeps the OUTER name
+        (a partial VarExpr passes `whole_name` through unchanged), so it
+        is indistinguishable from a returned classical value -- S1
+        conservatively rejects ANY Return in a scratch block (in-scope
+        `Check` has none). Covers both returning the scratch qubit and
+        returning an unrelated value.
+        """
+        from pecos.slr import CReg, Main, QReg, Return
+        from pecos.slr.ast import slr_to_ast
+        from pecos.slr.block import Block
+        from pecos.slr.qeclib import qubit as qb
+        from pecos.slr.qeclib.qubit.measures import Measure
+
+        class RetScratch(Block):
+            block_inputs: ClassVar[dict[str, str]] = {"a": "scratch", "out": "live_preserved"}
+
+            def __init__(self, a, out) -> None:
+                super().__init__()
+                self.a = a
+                self.out = out
+                self.extend(qb.Prep(a), Measure(a) > out, Return(a))
+
+        prog = Main(q := QReg("q", 1), c := CReg("c", 1), RetScratch(q[0], c[0]))
+        with pytest.raises(ValueError, match=r"or any ReturnOp in a scratch-bearing block"):
+            slr_to_ast(prog)
+
+        class RetOther(Block):
+            block_inputs: ClassVar[dict[str, str]] = {"a": "scratch", "out": "live_preserved"}
+
+            def __init__(self, a, out) -> None:
+                super().__init__()
+                self.a = a
+                self.out = out
+                self.extend(qb.Prep(a), Measure(a) > out, Return(out))
+
+        prog2 = Main(q := QReg("q", 1), c := CReg("c", 1), RetOther(q[0], c[0]))
+        with pytest.raises(ValueError, match=r"or any ReturnOp in a scratch-bearing block"):
+            slr_to_ast(prog2)

From a2464c0f9217b93cf56f7509ba7a2bd6a91f648b Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sat, 16 May 2026 06:05:21 -0600
Subject: [PATCH 051/136] Scratch-ancilla S2: Guppy emitter lowers SCRATCH as
 an internal qubit() allocation (no param/arg/return, seeded CONSUMED); fix
 live_arg_index to index validated_args; reuse pattern now compiles + runs
 (original blocker dead).

---
 .../src/pecos/slr/ast/codegen/guppy.py        | 51 ++++++++++--
 .../ast_guppy/test_block_call_smoke.py        | 83 +++++++++++++++++--
 2 files changed, 123 insertions(+), 11 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
index 6598647e6..423e7fa4d 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
@@ -254,6 +254,19 @@ def _validate_block_decl(self, decl: BlockDecl) -> None:
                         "bit is copyable so consumed/produced/dropped do not apply"
                     )
                     raise GuppyCodegenError(msg)
+            elif inp.effect is ResourceEffect.SCRATCH:
+                # Scratch ancilla (design v2-scratch-ancilla-effect): the
+                # block resets+measures it internally. Guppy allocates it
+                # internally (no parameter), so it must be a bare qubit --
+                # array/bundle scratch is out of scope (Check's ancilla is a
+                # bare qubit; Check1Flag's flag is too but is deferred via O1).
+                if not is_qubit:
+                    msg = (
+                        f"BlockDecl {decl.name!r} input {inp.name!r}: SCRATCH is "
+                        f"only supported for a bare qubit ancilla (got "
+                        f"{type(inp.type_expr).__name__})"
+                    )
+                    raise GuppyCodegenError(msg)
             elif inp.effect not in {ResourceEffect.LIVE_PRESERVED, ResourceEffect.CONSUMED}:
                 msg = (
                     f"BlockDecl {decl.name!r} input {inp.name!r}: only LIVE_PRESERVED and "
@@ -288,7 +301,10 @@ def _generate_block_decl(self, decl: BlockDecl) -> list[str]:
         # qubit-array length (1 for single qubit, unused for bit).
         input_shapes: list[tuple[str, str, int]] = []  # (name, kind, size)
         for inp in decl.inputs:
-            if isinstance(inp.type_expr, BitTypeExpr):
+            if inp.effect is ResourceEffect.SCRATCH:
+                # Bare-qubit ancilla allocated internally (no parameter).
+                input_shapes.append((inp.name, "scratch_qubit", 1))
+            elif isinstance(inp.type_expr, BitTypeExpr):
                 input_shapes.append((inp.name, "single_bit", 1))
             elif isinstance(inp.type_expr, QubitTypeExpr):
                 input_shapes.append((inp.name, "single_qubit", 1))
@@ -301,8 +317,19 @@ def _generate_block_decl(self, decl: BlockDecl) -> list[str]:
                 # do NOT emit an initializer -- it's a bound parameter.
                 self.context.registers[name] = RegisterDecl(name=name, size=1, is_result=False)
             else:
+                # scratch_qubit is registered too: the body's Prep/gates/Measure
+                # still resolve `Slot(name, i)` through linearity. It just has
+                # no parameter and is seeded CONSUMED below so the first Prep
+                # allocates a fresh internal `qubit()`.
                 self.context.root_allocators[name] = size
         self.context.linearity = GuppyLinearityState.from_allocators(self.context.root_allocators)
+        # Seed scratch slots CONSUMED so the body's first `Prep(scratch)` takes
+        # the fresh-`qubit()` branch in `_emit_prepare` (no entry binding, no
+        # parameter to alias). `from_allocators` starts every slot LIVE.
+        for name, kind, size in input_shapes:
+            if kind == "scratch_qubit":
+                for index in range(size):
+                    self.context.linearity.consume(Slot(name, index))
 
         live_inputs = tuple(
             (inp, shape)
@@ -322,6 +349,8 @@ def _generate_block_decl(self, decl: BlockDecl) -> list[str]:
 
         param_parts: list[str] = []
         for name, kind, size in input_shapes:
+            if kind == "scratch_qubit":
+                continue  # allocated internally -- no parameter
             if kind == "qubit_array":
                 param_parts.append(f"{name}: array[qubit, {size}] @ owned")
             elif kind == "single_qubit":
@@ -984,6 +1013,15 @@ def _emit_block_call(self, node: BlockCall) -> list[str]:
         validated_args: list[tuple[BlockInput, str, tuple]] = []
         live_inputs_out: list[BlockInput] = []
         for inp, arg in zip(decl.inputs, node.arg_bindings, strict=True):
+            if inp.effect is ResourceEffect.SCRATCH:
+                # Scratch is allocated inside the @guppy def: it is neither a
+                # parameter nor a positional call argument, and its outer slot
+                # is NOT consumed by the call (it stays live and is discarded
+                # at end-of-scope, satisfying R1). The S1 converter validator
+                # already proved the body resets+measures it internally and
+                # the cross-input alias guard already rejected a scratch slot
+                # shared with another input, so nothing is checked here.
+                continue
             kind, info = self._validate_block_call_arg(node.callee, inp, arg)
             validated_args.append((inp, kind, info))
             if inp.effect is ResourceEffect.LIVE_PRESERVED:
@@ -998,12 +1036,15 @@ def _emit_block_call(self, node: BlockCall) -> list[str]:
             raise GuppyCodegenError(msg)
 
         validated_outs: list[tuple[str, tuple]] = []
-        # Build a quick lookup of (validated_args index) for each LIVE_PRESERVED input.
+        # Build a quick lookup of (validated_args index) for each LIVE_PRESERVED
+        # input. NOTE: this indexes `validated_args`, which excludes SCRATCH
+        # inputs -- so it must enumerate `validated_args`, not `decl.inputs`
+        # (a scratch input would otherwise shift every later index).
         live_arg_index: dict[int, int] = {}
         live_count = 0
-        for arg_index, inp in enumerate(decl.inputs):
-            if inp.effect is ResourceEffect.LIVE_PRESERVED:
-                live_arg_index[live_count] = arg_index
+        for va_index, (va_inp, _k, _i) in enumerate(validated_args):
+            if va_inp.effect is ResourceEffect.LIVE_PRESERVED:
+                live_arg_index[live_count] = va_index
                 live_count += 1
         for out_idx, (out, inp) in enumerate(zip(node.out_bindings, live_inputs_out, strict=True)):
             kind, info = self._validate_block_call_arg(node.callee, inp, out, is_out=True)
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
index 564489139..eabf6d224 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
@@ -2211,12 +2211,12 @@ def test_scratch_flatten_substitutes_to_outer_slot(self) -> None:
         assert "cx q[2], q[1];" in qasm
         assert "measure q[2] -> c[0];" in qasm
 
-    def test_scratch_rejected_by_guppy_until_s2(self) -> None:
-        """Lock-in: no silent fallback. Guppy must raise a clean
-        not-yet-supported error for SCRATCH until S2 lands.
+    def test_scratch_guppy_internal_alloc_no_param(self) -> None:
+        """S2: a SCRATCH input is allocated INSIDE the @guppy def -- it is
+        neither a function parameter nor a positional call argument; the
+        body's Prep(scratch) lowers to a fresh internal `qubit()`.
         """
         from pecos.slr import CReg, Main, QReg, SlrConverter
-        from pecos.slr.ast.codegen.guppy import GuppyCodegenError
         from pecos.slr.qeclib import qubit as qb
 
         good_check = self._good_check()
@@ -2226,8 +2226,19 @@ def test_scratch_rejected_by_guppy_until_s2(self) -> None:
             qb.Prep(q),
             good_check([q[0], q[1]], q[2], c[0]),
         )
-        with pytest.raises(GuppyCodegenError, match=r"only LIVE_PRESERVED and CONSUMED.*got SCRATCH"):
-            SlrConverter(prog).guppy()
+        guppy_src = SlrConverter(prog).guppy()
+        # No `a` parameter on the generated def (scratch is internal).
+        assert re.search(
+            r"def goodcheck_\d+\(d: array\[qubit, 2\] @ owned, "
+            r"out: array\[bool, 1\] @ owned\) -> ",
+            guppy_src,
+        )
+        assert "a: qubit @ owned" not in guppy_src
+        # Body allocates the scratch internally and measures it.
+        assert "a_0 = qubit()" in guppy_src
+        assert "out[0] = measure(a_0)" in guppy_src
+        # The call passes only the non-scratch args (no scratch positional).
+        assert re.search(r"goodcheck_\d+\(array\(q_0, q_1\), array\(c\[0\]\)\)", guppy_src)
 
     def test_scratch_use_before_prep_rejected(self) -> None:
         from pecos.slr import CReg, Main, QReg
@@ -2493,3 +2504,63 @@ def __init__(self, a, out) -> None:
         prog2 = Main(q := QReg("q", 1), c := CReg("c", 1), RetOther(q[0], c[0]))
         with pytest.raises(ValueError, match=r"or any ReturnOp in a scratch-bearing block"):
             slr_to_ast(prog2)
+
+    def test_scratch_reuse_across_calls_compiles_and_runs(self) -> None:
+        """S2 end-to-end: the original blocker. The SAME outer ancilla slot
+        feeds two sequential scratch BlockCalls (the production
+        `SynExtractBare` reuse pattern). Under `a: consumed` this was a
+        Guppy LinearityError; with `a: scratch` each call allocates its
+        ancilla internally, so it compiles and runs through Selene.
+        """
+        from pecos import Hugr, selene_engine, sim
+        from pecos.slr import Block, CReg, Main, QReg, SlrConverter
+        from pecos.slr.qeclib import qubit as qb
+        from pecos.slr.qeclib.qubit.measures import Measure
+
+        class Chk(Block):
+            block_inputs: ClassVar[dict[str, str]] = {
+                "d": "live_preserved",
+                "a": "scratch",
+                "out": "live_preserved",
+            }
+
+            def __init__(self, d, a, out) -> None:
+                super().__init__()
+                self.d = d
+                self.a = a
+                self.out = out
+                self.extend(
+                    qb.Prep(a),
+                    qb.H(a),
+                    qb.CX(a, d[0]),
+                    qb.CX(a, d[1]),
+                    qb.H(a),
+                    Measure(a) > out,
+                )
+
+        prog = Main(
+            q := QReg("q", 3),
+            c := CReg("c", 2),
+            qb.Prep(q),
+            Chk([q[0], q[1]], q[2], c[0]),
+            Chk([q[0], q[1]], q[2], c[1]),  # reuses q[2] -- the blocker case
+        )
+        guppy_src = SlrConverter(prog).guppy()
+        # Two separate scratch internal allocs, no LinearityError.
+        assert guppy_src.count("def chk") == 2
+        assert guppy_src.count("a_0 = qubit()") == 2
+
+        package = SlrConverter(prog).hugr()
+        result = (
+            sim(Hugr(package.to_str().encode("utf-8")))
+            .classical(selene_engine())
+            .qubits(4)  # 3 outer + 1 internally-allocated scratch
+            .seed(42)
+            .run(4)
+        )
+        raw = result.to_dict() if hasattr(result, "to_dict") else result
+        # Probe-pinned: both Checks see the same |00> data, same seed.
+        assert raw == {
+            "measurement_0": [1, 0, 0, 1],
+            "measurement_1": [1, 0, 0, 1],
+        }, raw

From 2dc9324105d60a8d022e7a918bdb21c4ac285cc7 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sat, 16 May 2026 06:22:05 -0600
Subject: [PATCH 052/136] Scratch-ancilla S2 fixes (Codex r1): whole-program
 guard rejecting non-scratch use of a scratch-bound outer slot (Prep carve-out
 for the corpus, reuse still allowed); validate scratch BlockArgs before
 excluding so malformed bindings fail loudly; 3 lock-in tests.

---
 .../src/pecos/slr/ast/codegen/guppy.py        | 138 ++++++++++++++++--
 .../ast_guppy/test_block_call_smoke.py        |  95 ++++++++++++
 2 files changed, 224 insertions(+), 9 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
index 423e7fa4d..ad5b426ef 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
@@ -34,6 +34,7 @@
     AllocatorArg,
     AllocatorDecl,
     ArrayTypeExpr,
+    BarrierOp,
     BinaryExpr,
     BinaryOp,
     BitExpr,
@@ -67,7 +68,6 @@
 
     from pecos.slr.ast.nodes import (
         AssignOp,
-        BarrierOp,
         BlockDecl,
         BlockInput,
         CommentOp,
@@ -170,6 +170,7 @@ def generate(self, program: Program) -> list[str]:
         self._block_decls = {decl.name: decl for decl in program.block_decls}
         for decl in program.block_decls:
             self._validate_block_decl(decl)
+        self._validate_scratch_outer_slots(program)
 
         lines = self._imports()
 
@@ -467,6 +468,103 @@ def _reject_child_allocators(self) -> None:
             msg = f"AST -> Guppy v1 does not support child allocators: {names}"
             raise GuppyCodegenError(msg)
 
+    def _iter_stmts(self, body: tuple[Statement, ...]) -> Iterator[Statement]:
+        """Yield every statement in `body`, recursing into control flow."""
+        for stmt in body:
+            yield stmt
+            if isinstance(stmt, IfStmt):
+                yield from self._iter_stmts(stmt.then_body)
+                yield from self._iter_stmts(stmt.else_body)
+            elif isinstance(stmt, (WhileStmt, ForStmt, RepeatStmt, ParallelBlock)):
+                yield from self._iter_stmts(stmt.body)
+
+    def _validate_scratch_outer_slots(self, program: Program) -> None:
+        """Reject programs where a scratch-bound outer slot is also used as
+        meaningful caller state (Codex S2 review blocker 1).
+
+        A SCRATCH input lowers asymmetrically: flatten substitutes the
+        scratch param to the outer slot (the block resets+measures THAT
+        slot), while Guppy allocates the ancilla internally and leaves the
+        outer slot untouched. The two paths only agree when the outer slot
+        is pure scratch -- never observed by the caller. If the caller
+        gates/measures/barriers it, or hands it to another block, the
+        codegens diverge. Multiple scratch BlockCalls reusing the slot
+        stay allowed (the intended SynExtractBare pattern).
+
+        `PrepareOp` on a scratch outer slot IS allowed: a reset is
+        unobserved and dead under both lowerings (and the qeclib corpus
+        wholesale-preps the ancilla register, e.g. `Prep(q)` covering
+        `q[3]`, before using `q[3]` as a check ancilla).
+        """
+        scratch: dict[tuple[str, int], str] = {}
+        for stmt in self._iter_stmts(program.body):
+            if not isinstance(stmt, BlockCall):
+                continue
+            decl = self._block_decls.get(stmt.callee)
+            if decl is None:
+                continue
+            for inp, arg in zip(decl.inputs, stmt.arg_bindings, strict=False):
+                if inp.effect is ResourceEffect.SCRATCH and isinstance(arg, SingleQubitArg):
+                    scratch[(arg.slot.allocator, arg.slot.index)] = stmt.callee
+        if not scratch:
+            return
+        scratch_allocs = {alloc for alloc, _ in scratch}
+
+        def _reject(where: str, slot: tuple[str, int]) -> None:
+            callee = scratch[slot]
+            msg = (
+                f"Scratch outer slot {slot[0]}[{slot[1]}] (bound as the "
+                f"scratch ancilla of BlockCall {callee!r}) is also used as "
+                f"meaningful caller state by {where}. A scratch-bound slot "
+                "must be pure scratch -- flatten mutates it while Guppy "
+                "allocates the ancilla internally, so any other use "
+                "diverges. (A bare Prep on it is allowed; reusing it across "
+                "scratch BlockCalls is allowed.)"
+            )
+            raise GuppyCodegenError(msg)
+
+        for stmt in self._iter_stmts(program.body):
+            if isinstance(stmt, GateOp):
+                for t in stmt.targets:
+                    if (t.allocator, t.index) in scratch:
+                        _reject(f"a {stmt.gate.name} gate", (t.allocator, t.index))
+            elif isinstance(stmt, MeasureOp):
+                for t in stmt.targets:
+                    if (t.allocator, t.index) in scratch:
+                        _reject("a Measure", (t.allocator, t.index))
+            elif isinstance(stmt, BarrierOp):
+                for alloc in stmt.allocators:
+                    if alloc in scratch_allocs:
+                        # Barrier is name-level; conservatively reject any
+                        # barrier naming a register that hosts a scratch slot.
+                        slot = next(s for s in scratch if s[0] == alloc)
+                        _reject("a Barrier", slot)
+            elif isinstance(stmt, BlockCall):
+                decl = self._block_decls.get(stmt.callee)
+                if decl is None:
+                    continue
+                for inp, arg in zip(decl.inputs, stmt.arg_bindings, strict=False):
+                    if inp.effect is ResourceEffect.SCRATCH:
+                        continue  # the scratch binding itself -- allowed
+                    if isinstance(arg, AllocatorArg) and arg.name in scratch_allocs:
+                        slot = next(s for s in scratch if s[0] == arg.name)
+                        _reject(f"a non-scratch input of BlockCall {stmt.callee!r}", slot)
+                    elif isinstance(arg, SingleQubitArg) and (
+                        arg.slot.allocator,
+                        arg.slot.index,
+                    ) in scratch:
+                        _reject(
+                            f"a non-scratch input of BlockCall {stmt.callee!r}",
+                            (arg.slot.allocator, arg.slot.index),
+                        )
+                    elif isinstance(arg, QubitBundleArg):
+                        for s in arg.slots:
+                            if (s.allocator, s.index) in scratch:
+                                _reject(
+                                    f"a non-scratch input of BlockCall {stmt.callee!r}",
+                                    (s.allocator, s.index),
+                                )
+
     def _imports(self) -> list[str]:
         return [
             "from guppylang import guppy",
@@ -809,7 +907,7 @@ def _emit_stmt(self, stmt: Statement) -> list[str]:
             msg = "AST -> Guppy v1 supports Return only as the final root-level statement"
             raise GuppyCodegenError(msg)
 
-        from pecos.slr.ast.nodes import AssignOp, BarrierOp, CommentOp, PermuteOp, PrintOp  # noqa: PLC0415
+        from pecos.slr.ast.nodes import AssignOp, CommentOp, PermuteOp, PrintOp  # noqa: PLC0415
 
         if isinstance(stmt, AssignOp):
             return self._emit_assign(stmt)
@@ -1012,15 +1110,25 @@ def _emit_block_call(self, node: BlockCall) -> list[str]:
         # step knows how to pack the call argument.
         validated_args: list[tuple[BlockInput, str, tuple]] = []
         live_inputs_out: list[BlockInput] = []
+        # Scratch slots are still validated (type/presence/bounds) and fed
+        # into the cross-input alias check below, but kept OUT of
+        # `validated_args` so Phase 2 never packs/consumes/returns them and
+        # they are not positional call arguments (the block allocates the
+        # ancilla internally; the outer slot stays live and is discarded at
+        # end-of-scope per R1). Validating-then-excluding -- not skipping
+        # before validation -- so a malformed scratch binding (unknown/OOB
+        # outer slot) still fails loudly (Codex S2 review blocker 2).
+        scratch_slots: list[tuple[str, int]] = []
         for inp, arg in zip(decl.inputs, node.arg_bindings, strict=True):
             if inp.effect is ResourceEffect.SCRATCH:
-                # Scratch is allocated inside the @guppy def: it is neither a
-                # parameter nor a positional call argument, and its outer slot
-                # is NOT consumed by the call (it stays live and is discarded
-                # at end-of-scope, satisfying R1). The S1 converter validator
-                # already proved the body resets+measures it internally and
-                # the cross-input alias guard already rejected a scratch slot
-                # shared with another input, so nothing is checked here.
+                kind, info = self._validate_block_call_arg(node.callee, inp, arg)
+                if kind != "single_qubit":
+                    msg = (
+                        f"BlockCall {node.callee!r}: SCRATCH input {inp.name!r} "
+                        f"must be bound by a SingleQubitArg (got {kind})"
+                    )
+                    raise GuppyCodegenError(msg)
+                scratch_slots.append(info)
                 continue
             kind, info = self._validate_block_call_arg(node.callee, inp, arg)
             validated_args.append((inp, kind, info))
@@ -1092,6 +1200,18 @@ def _emit_block_call(self, node: BlockCall) -> list[str]:
                     )
                     raise GuppyCodegenError(msg)
                 seen_slots[slot] = inp.name
+        # Scratch slots participate in the alias check too: a scratch slot
+        # shared with another (scratch or non-scratch) input slot is invalid.
+        for scratch_slot in scratch_slots:
+            if scratch_slot in seen_slots:
+                msg = (
+                    f"BlockCall {node.callee!r}: scratch qubit slot "
+                    f"{scratch_slot[0]}[{scratch_slot[1]}] is also bound by "
+                    f"input {seen_slots[scratch_slot]!r}; a scratch ancilla "
+                    "cannot be shared with another input"
+                )
+                raise GuppyCodegenError(msg)
+            seen_slots[scratch_slot] = "<scratch>"
 
         # Phase 2: now that every check passed, consume slots and emit code.
         linearity = self._linearity()
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
index eabf6d224..46c6870c5 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
@@ -2564,3 +2564,98 @@ def __init__(self, d, a, out) -> None:
             "measurement_0": [1, 0, 0, 1],
             "measurement_1": [1, 0, 0, 1],
         }, raw
+
+    def test_scratch_outer_slot_misuse_rejected(self) -> None:
+        """Codex S2 r1 blocker 1: a scratch-bound outer slot also used as
+        meaningful caller state (gate + later measure) diverges between
+        flatten (mutates it) and Guppy (allocates internally) -- reject.
+        """
+        from pecos.slr import Block, CReg, Main, QReg, SlrConverter
+        from pecos.slr.ast.codegen.guppy import GuppyCodegenError
+        from pecos.slr.qeclib import qubit as qb
+        from pecos.slr.qeclib.qubit.measures import Measure
+
+        class MS(Block):
+            block_inputs: ClassVar[dict[str, str]] = {"a": "scratch", "out": "live_preserved"}
+
+            def __init__(self, a, out) -> None:
+                super().__init__()
+                self.a = a
+                self.out = out
+                self.extend(qb.Prep(a), qb.H(a), Measure(a) > out)
+
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 2),
+            qb.Prep(q[0]),
+            qb.X(q[0]),  # meaningful caller state on the scratch slot
+            MS(q[0], c[0]),
+            Measure(q[0]) > c[1],  # ...observed after the scratch call
+        )
+        with pytest.raises(GuppyCodegenError, match=r"Scratch outer slot q\[0\].*meaningful caller state"):
+            SlrConverter(prog).guppy()
+
+    def test_scratch_outer_slot_whole_reg_prep_allowed(self) -> None:
+        """Carve-out: a bare/whole-register Prep covering the scratch slot
+        is allowed (the qeclib corpus does `Prep(q)` then uses `q[i]` as a
+        check ancilla -- a reset is unobserved/dead under both lowerings).
+        """
+        from pecos.slr import Block, CReg, Main, QReg, SlrConverter
+        from pecos.slr.qeclib import qubit as qb
+        from pecos.slr.qeclib.qubit.measures import Measure
+
+        class Chk(Block):
+            block_inputs: ClassVar[dict[str, str]] = {
+                "d": "live_preserved",
+                "a": "scratch",
+                "out": "live_preserved",
+            }
+
+            def __init__(self, d, a, out) -> None:
+                super().__init__()
+                self.d = d
+                self.a = a
+                self.out = out
+                self.extend(qb.Prep(a), qb.CX(a, d[0]), qb.CX(a, d[1]), Measure(a) > out)
+
+        prog = Main(
+            q := QReg("q", 3),
+            c := CReg("c", 1),
+            qb.Prep(q),  # covers q[2] (the scratch slot) -- must NOT reject
+            Chk([q[0], q[1]], q[2], c[0]),
+        )
+        guppy_src = SlrConverter(prog).guppy()  # must not raise
+        assert "a_0 = qubit()" in guppy_src
+
+    def test_scratch_malformed_arg_rejected_direct_ast(self) -> None:
+        """Codex S2 r1 blocker 2: a scratch BlockArg referencing an
+        out-of-bounds outer slot must fail loudly -- scratch args are now
+        validated (then excluded), not skipped before validation.
+        """
+        from pecos.slr.ast.codegen.guppy import GuppyCodegenError
+        from pecos.slr.ast.nodes import SingleQubitArg
+
+        decl = BlockDecl(
+            name="b",
+            inputs=(
+                BlockInput(name="a", effect=ResourceEffect.SCRATCH, type_expr=QubitTypeExpr()),
+            ),
+            body=(
+                PrepareOp(allocator="a", slots=(0,)),
+                MeasureOp(targets=(SlotRef(allocator="a", index=0),)),
+            ),
+        )
+        prog = Program(
+            name="main",
+            allocator=AllocatorDecl(name="outer_q", capacity=1),
+            block_decls=(decl,),
+            body=(
+                BlockCall(
+                    callee="b",
+                    arg_bindings=(SingleQubitArg(slot=SlotRef(allocator="outer_q", index=9)),),
+                    out_bindings=(),
+                ),
+            ),
+        )
+        with pytest.raises(GuppyCodegenError, match=r"slot index 9 out of bounds"):
+            ast_to_guppy(prog)

From 6accde4f89f98239533696268da098e3103ee11c Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sat, 16 May 2026 06:34:39 -0600
Subject: [PATCH 053/136] Scratch-ancilla S2 R5-completeness (Codex r2):
 per-scope purity guard (main + every BlockDecl.body) covering PermuteOp +
 ReturnOp observation paths; 3 lock-in tests.

---
 .../src/pecos/slr/ast/codegen/guppy.py        | 58 +++++++++---
 .../ast_guppy/test_block_call_smoke.py        | 93 +++++++++++++++++++
 2 files changed, 137 insertions(+), 14 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
index ad5b426ef..d395ce6c7 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
@@ -48,6 +48,7 @@
     LiteralExpr,
     MeasureOp,
     ParallelBlock,
+    PermuteOp,
     PrepareOp,
     QubitBundleArg,
     QubitTypeExpr,
@@ -72,7 +73,6 @@
         BlockInput,
         CommentOp,
         Expression,
-        PermuteOp,
         PrintOp,
         Program,
         SlotRef,
@@ -480,24 +480,39 @@ def _iter_stmts(self, body: tuple[Statement, ...]) -> Iterator[Statement]:
 
     def _validate_scratch_outer_slots(self, program: Program) -> None:
         """Reject programs where a scratch-bound outer slot is also used as
-        meaningful caller state (Codex S2 review blocker 1).
+        meaningful caller state (Codex S2 review).
 
         A SCRATCH input lowers asymmetrically: flatten substitutes the
         scratch param to the outer slot (the block resets+measures THAT
         slot), while Guppy allocates the ancilla internally and leaves the
         outer slot untouched. The two paths only agree when the outer slot
         is pure scratch -- never observed by the caller. If the caller
-        gates/measures/barriers it, or hands it to another block, the
-        codegens diverge. Multiple scratch BlockCalls reusing the slot
-        stay allowed (the intended SynExtractBare pattern).
+        gates/measures/barriers/permutes/returns it, or hands it to another
+        block, the codegens diverge. Multiple scratch BlockCalls reusing
+        the slot stay allowed (the intended SynExtractBare pattern).
 
         `PrepareOp` on a scratch outer slot IS allowed: a reset is
         unobserved and dead under both lowerings (and the qeclib corpus
         wholesale-preps the ancilla register, e.g. `Prep(q)` covering
         `q[3]`, before using `q[3]` as a check ancilla).
+
+        Runs per scope (Codex S2 r2 blocker 3): `program.body` AND every
+        `BlockDecl.body` -- a nested BlockCall whose scratch arg references
+        the enclosing block's param slot has the same purity requirement
+        within that block's scope.
         """
+        self._validate_scratch_purity_in_scope(program.body)
+        for decl in program.block_decls:
+            self._validate_scratch_purity_in_scope(decl.body)
+
+    @staticmethod
+    def _ref_base(ref: str) -> str:
+        """Leading identifier of a string ref (`q[0]`/`q.x`/`q` -> `q`)."""
+        return ref.split("[", 1)[0].split(".", 1)[0]
+
+    def _validate_scratch_purity_in_scope(self, body: tuple[Statement, ...]) -> None:
         scratch: dict[tuple[str, int], str] = {}
-        for stmt in self._iter_stmts(program.body):
+        for stmt in self._iter_stmts(body):
             if not isinstance(stmt, BlockCall):
                 continue
             decl = self._block_decls.get(stmt.callee)
@@ -523,7 +538,10 @@ def _reject(where: str, slot: tuple[str, int]) -> None:
             )
             raise GuppyCodegenError(msg)
 
-        for stmt in self._iter_stmts(program.body):
+        def _reject_alloc(where: str, alloc: str) -> None:
+            _reject(where, next(s for s in scratch if s[0] == alloc))
+
+        for stmt in self._iter_stmts(body):
             if isinstance(stmt, GateOp):
                 for t in stmt.targets:
                     if (t.allocator, t.index) in scratch:
@@ -535,10 +553,23 @@ def _reject(where: str, slot: tuple[str, int]) -> None:
             elif isinstance(stmt, BarrierOp):
                 for alloc in stmt.allocators:
                     if alloc in scratch_allocs:
-                        # Barrier is name-level; conservatively reject any
-                        # barrier naming a register that hosts a scratch slot.
-                        slot = next(s for s in scratch if s[0] == alloc)
-                        _reject("a Barrier", slot)
+                        # Name-level: conservatively reject any barrier
+                        # naming a register that hosts a scratch slot.
+                        _reject_alloc("a Barrier", alloc)
+            elif isinstance(stmt, PermuteOp):
+                # sources/targets are string refs (`q`, `q[0]`); a permute
+                # touching the scratch register reorders/observes it.
+                for ref in (*stmt.sources, *stmt.targets):
+                    if self._ref_base(ref) in scratch_allocs:
+                        _reject_alloc("a Permute", self._ref_base(ref))
+            elif isinstance(stmt, ReturnOp):
+                # Returning the scratch slot (or its register) exposes the
+                # outer slot the caller would observe -- flatten mutated it,
+                # Guppy did not.
+                for v in stmt.values:
+                    name = v if isinstance(v, str) else getattr(v, "name", "")
+                    if name and self._ref_base(name) in scratch_allocs:
+                        _reject_alloc("a Return", self._ref_base(name))
             elif isinstance(stmt, BlockCall):
                 decl = self._block_decls.get(stmt.callee)
                 if decl is None:
@@ -547,8 +578,7 @@ def _reject(where: str, slot: tuple[str, int]) -> None:
                     if inp.effect is ResourceEffect.SCRATCH:
                         continue  # the scratch binding itself -- allowed
                     if isinstance(arg, AllocatorArg) and arg.name in scratch_allocs:
-                        slot = next(s for s in scratch if s[0] == arg.name)
-                        _reject(f"a non-scratch input of BlockCall {stmt.callee!r}", slot)
+                        _reject_alloc(f"a non-scratch input of BlockCall {stmt.callee!r}", arg.name)
                     elif isinstance(arg, SingleQubitArg) and (
                         arg.slot.allocator,
                         arg.slot.index,
@@ -907,7 +937,7 @@ def _emit_stmt(self, stmt: Statement) -> list[str]:
             msg = "AST -> Guppy v1 supports Return only as the final root-level statement"
             raise GuppyCodegenError(msg)
 
-        from pecos.slr.ast.nodes import AssignOp, CommentOp, PermuteOp, PrintOp  # noqa: PLC0415
+        from pecos.slr.ast.nodes import AssignOp, CommentOp, PrintOp  # noqa: PLC0415
 
         if isinstance(stmt, AssignOp):
             return self._emit_assign(stmt)
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
index 46c6870c5..7e3b6e987 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
@@ -2659,3 +2659,96 @@ def test_scratch_malformed_arg_rejected_direct_ast(self) -> None:
         )
         with pytest.raises(GuppyCodegenError, match=r"slot index 9 out of bounds"):
             ast_to_guppy(prog)
+
+    def test_scratch_outer_slot_permute_rejected(self) -> None:
+        """Codex S2 r2 blocker 1: a Permute touching the scratch register
+        observes/reorders the scratch-bound outer slot -> reject.
+        """
+        from pecos.slr import Block, CReg, Main, Permute, QReg, SlrConverter
+        from pecos.slr.ast.codegen.guppy import GuppyCodegenError
+        from pecos.slr.qeclib import qubit as qb
+        from pecos.slr.qeclib.qubit.measures import Measure
+
+        class MS(Block):
+            block_inputs: ClassVar[dict[str, str]] = {"a": "scratch", "out": "live_preserved"}
+
+            def __init__(self, a, out) -> None:
+                super().__init__()
+                self.a = a
+                self.out = out
+                self.extend(qb.Prep(a), qb.H(a), Measure(a) > out)
+
+        prog = Main(
+            q := QReg("q", 2),
+            c := CReg("c", 2),
+            qb.Prep(q),
+            qb.X(q[0]),
+            MS(q[1], c[0]),
+            Permute([q[0], q[1]], [q[1], q[0]]),
+            Measure(q[0]) > c[1],
+        )
+        with pytest.raises(GuppyCodegenError, match=r"Scratch outer slot q\[1\].*Permute"):
+            SlrConverter(prog).guppy()
+
+    def test_scratch_outer_slot_return_rejected(self) -> None:
+        """Codex S2 r2 blocker 2: returning the register that hosts the
+        scratch-bound slot exposes a slot Guppy left untouched -> reject.
+        """
+        from pecos.slr import Block, CReg, Main, QReg, Return, SlrConverter
+        from pecos.slr.ast.codegen.guppy import GuppyCodegenError
+        from pecos.slr.qeclib import qubit as qb
+        from pecos.slr.qeclib.qubit.measures import Measure
+
+        class MS(Block):
+            block_inputs: ClassVar[dict[str, str]] = {"a": "scratch", "out": "live_preserved"}
+
+            def __init__(self, a, out) -> None:
+                super().__init__()
+                self.a = a
+                self.out = out
+                self.extend(qb.Prep(a), qb.H(a), Measure(a) > out)
+
+        prog = Main(
+            q := QReg("q", 2),
+            c := CReg("c", 1),
+            qb.Prep(q),
+            MS(q[1], c[0]),
+            Return(q),
+        )
+        with pytest.raises(GuppyCodegenError, match=r"Scratch outer slot q\[1\].*Return"):
+            SlrConverter(prog).guppy()
+
+    def test_scratch_misuse_inside_block_body_rejected(self) -> None:
+        """Codex S2 r2 blocker 3: the purity guard runs per scope -- a
+        nested scratch BlockCall + misuse of that slot inside a BlockDecl
+        body (not just main) must be caught.
+        """
+        from pecos.slr import Block, CReg, Main, QReg, SlrConverter
+        from pecos.slr.ast.codegen.guppy import GuppyCodegenError
+        from pecos.slr.qeclib import qubit as qb
+        from pecos.slr.qeclib.qubit.measures import Measure
+
+        class Inner(Block):
+            block_inputs: ClassVar[dict[str, str]] = {"a": "scratch", "out": "live_preserved"}
+
+            def __init__(self, a, out) -> None:
+                super().__init__()
+                self.a = a
+                self.out = out
+                self.extend(qb.Prep(a), qb.H(a), Measure(a) > out)
+
+        class Outer(Block):
+            block_inputs: ClassVar[dict[str, str]] = {
+                "q": "live_preserved",
+                "o": "live_preserved",
+            }
+
+            def __init__(self, q, o) -> None:
+                super().__init__()
+                self.q = q
+                self.o = o
+                self.extend(Inner(q[1], o), qb.X(q[1]))  # misuse within this scope
+
+        prog = Main(qq := QReg("qq", 2), c := CReg("c", 1), qb.Prep(qq), Outer(qq, c[0]))
+        with pytest.raises(GuppyCodegenError, match=r"Scratch outer slot q\[1\].*meaningful caller state"):
+            SlrConverter(prog).guppy()

From f1755c468f177946c1823e81effcc76f30a1d9f5 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sat, 16 May 2026 06:47:28 -0600
Subject: [PATCH 054/136] Scratch-ancilla S4: convert qeclib Check (a:scratch)
 -- SynExtractBare reused-ancilla path now compiles to Guppy (original 5e.3
 blocker dead); Check Selene records byte-identical (qubits 4->5 for internal
 alloc, design R2); Steane production lock-in.

---
 .../src/pecos/slr/qeclib/generic/check.py     | 19 ++++-
 .../ast_guppy/test_block_call_smoke.py        | 74 +++++++++++++++++++
 .../ast_guppy/test_qeclib_selene_corpus.py    | 13 +++-
 3 files changed, 103 insertions(+), 3 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/generic/check.py b/python/quantum-pecos/src/pecos/slr/qeclib/generic/check.py
index 6c747f6ba..2e7e6fcfd 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/generic/check.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/generic/check.py
@@ -18,7 +18,7 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, ClassVar
 
 from pecos.slr import Barrier, Block, Comment
 from pecos.slr.qeclib.qubit import CX, CY, CZ, H, Measure, Prep
@@ -35,6 +35,18 @@ class Check(Block):
     a sequence of Pauli operators to data qubits controlled by an ancilla qubit.
     """
 
+    # Phase 3a.3 (scratch-ancilla effect): emit BlockDecl + BlockCall instead
+    # of inlining. Data qubits pass through unchanged; `a` is a reset-reused
+    # scratch ancilla (prepped + measured inside, allocated internally in
+    # Guppy so callers like SynExtractBare can reuse one physical slot across
+    # sequential Checks); `out` is the live_preserved measurement-result bit.
+    # See ~/Repos/pecos-docs/design/slr/v2-scratch-ancilla-effect.md.
+    block_inputs: ClassVar[dict[str, str]] = {
+        "d": "live_preserved",
+        "a": "scratch",
+        "out": "live_preserved",
+    }
+
     def __init__(
         self,
         d: list[Qubit],
@@ -61,6 +73,11 @@ def __init__(
             Exception: If invalid Pauli operator is specified.
         """
         super().__init__()
+        # SLR -> AST converter reads these to bind block_inputs param names
+        # to outer-scope refs.
+        self.d = d
+        self.a = a
+        self.out = out
 
         n: int = len(d)
 
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
index 7e3b6e987..89d69d565 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
@@ -2752,3 +2752,77 @@ def __init__(self, q, o) -> None:
         prog = Main(qq := QReg("qq", 2), c := CReg("c", 1), qb.Prep(qq), Outer(qq, c[0]))
         with pytest.raises(GuppyCodegenError, match=r"Scratch outer slot q\[1\].*meaningful caller state"):
             SlrConverter(prog).guppy()
+
+
+class TestScratchCheckS4ProductionLockIn:
+    """S4: the real qeclib `Check` is converted (`a: scratch`). The
+    production caller `SynExtractBare` reuses one ancilla register slot
+    across sequential Checks -- under `a: consumed` this was a Guppy
+    LinearityError (the original 5e.3 blocker). With the scratch effect
+    it must route every Check through a BlockCall, compile to Guppy, and
+    run through Selene with stable records, while QASM flatten stays
+    byte-identical to the inlined form.
+    """
+
+    def test_steane_syn_extract_bare_routes_check_through_blockcall(self) -> None:
+        from pecos.slr import CReg, Main, QReg, SlrConverter
+        from pecos.slr.ast import slr_to_ast
+        from pecos.slr.qeclib.steane.syn_extract.bare import SynExtractBare
+
+        checks = [[2, 1, 3, 0], [5, 2, 1, 4], [6, 5, 2, 3]]
+        prog = Main(
+            d := QReg("d", 7),
+            a := QReg("a", 2),
+            syn := CReg("syn", 6),
+            SynExtractBare(d, a, checks, syn),
+        )
+        ast = slr_to_ast(prog)
+        # 6 Checks (3 Z + 3 X) -> 6 BlockCalls, not silently flattened.
+        assert sum(1 for s in ast.body if isinstance(s, BlockCall)) == 6
+        assert len(ast.block_decls) == 6
+
+        guppy_src = SlrConverter(prog).guppy()
+        # Was the original blocker: `a: consumed` -> LinearityError on the
+        # reused ancilla slot. Now each Check def allocates internally.
+        assert guppy_src.count("def check") == 6
+        assert "LinearityError" not in guppy_src
+
+        # QASM flatten still substitutes the scratch param to the outer
+        # ancilla slot (byte-identical inlined form -- a[0]/a[1] reused).
+        qasm = SlrConverter(prog).qasm()
+        assert "reset a[0];" in qasm
+        assert "reset a[1];" in qasm
+        assert "measure a[0] -> syn[0];" in qasm
+
+    def test_steane_syn_extract_bare_selene_records_pinned(self) -> None:
+        from pecos import Hugr, selene_engine, sim
+        from pecos.slr import CReg, Main, QReg, SlrConverter
+        from pecos.slr.qeclib.steane.syn_extract.bare import SynExtractBare
+
+        checks = [[2, 1, 3, 0], [5, 2, 1, 4], [6, 5, 2, 3]]
+        prog = Main(
+            d := QReg("d", 7),
+            a := QReg("a", 2),
+            syn := CReg("syn", 6),
+            SynExtractBare(d, a, checks, syn),
+        )
+        package = SlrConverter(prog).hugr()
+        # d(7) + a(2) declared + 1 internally-allocated scratch ancilla
+        # (design R2: parity is on behavioral records, not qubit count).
+        result = (
+            sim(Hugr(package.to_str().encode("utf-8")))
+            .classical(selene_engine())
+            .qubits(10)
+            .seed(42)
+            .run(4)
+        )
+        raw = result.to_dict() if hasattr(result, "to_dict") else result
+        # Empirical probe 2026-05-16 (post-conversion, scratch internal alloc).
+        assert raw == {
+            "measurement_0": [0, 0, 0, 0],
+            "measurement_1": [0, 0, 0, 0],
+            "measurement_2": [0, 0, 0, 0],
+            "measurement_3": [1, 1, 0, 1],
+            "measurement_4": [0, 0, 1, 0],
+            "measurement_5": [0, 0, 1, 0],
+        }, raw
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qeclib_selene_corpus.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qeclib_selene_corpus.py
index bc0995056..cd117a210 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qeclib_selene_corpus.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qeclib_selene_corpus.py
@@ -99,14 +99,21 @@ def test_check_xyz_on_zero_state_pinned_records(self) -> None:
 
         Ancilla is the only measurement target; data qubits are
         live_preserved through the Check. Probe-pinned 4-shot records.
+
+        `Check` is now converted (`a: scratch`): Guppy allocates the
+        ancilla INTERNALLY, so the run needs one physical qubit beyond
+        the declared 4-qubit QReg (`qubits=5`). The Selene records are
+        byte-identical to the pre-conversion flattened form -- design
+        R2: parity is on behavioral records, not resource counts.
         """
         prog = Main(
             q := QReg("q", 4),
             c := CReg("c", 1),
             Check([q[0], q[1], q[2]], "XYZ", q[3], c[0], with_barriers=True),
         )
-        raw = _run_via_selene(prog, shots=4, seed=42, qubits=4)
+        raw = _run_via_selene(prog, shots=4, seed=42, qubits=5)
         # Empirical probe 2026-05-15: {'measurement_0': [1, 0, 0, 1]}
+        # Unchanged post-conversion (scratch internal alloc).
         assert raw == {"measurement_0": [1, 0, 0, 1]}, raw
 
     def test_check_xyz_on_plus_state_pinned_records(self) -> None:
@@ -123,7 +130,9 @@ def test_check_xyz_on_plus_state_pinned_records(self) -> None:
             qb.H(q[1]),
             Check([q[0], q[1], q[2]], "XYZ", q[3], c[0], with_barriers=True),
         )
-        raw = _run_via_selene(prog, shots=4, seed=42, qubits=4)
+        # qubits=5: converted Check allocates its scratch ancilla
+        # internally (design R2 -- records unchanged, +1 physical qubit).
+        raw = _run_via_selene(prog, shots=4, seed=42, qubits=5)
         # Empirical probe 2026-05-15: {'measurement_0': [1, 0, 0, 1]}
         assert raw == {"measurement_0": [1, 0, 0, 1]}, raw
 

From 4c9d071393ac139d6a3759b40cea03ccdffa7181 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sat, 16 May 2026 06:55:40 -0600
Subject: [PATCH 055/136] Scratch-ancilla S4: add Color488 serial
 SynExtractBare production lock-in (Codex S4 non-blocking finding -- design
 specifies Steane + Color488).

---
 .../ast_guppy/test_block_call_smoke.py        | 45 +++++++++++++++++++
 1 file changed, 45 insertions(+)

diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
index 89d69d565..813d9c08c 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
@@ -2826,3 +2826,48 @@ def test_steane_syn_extract_bare_selene_records_pinned(self) -> None:
             "measurement_4": [0, 0, 1, 0],
             "measurement_5": [0, 0, 1, 0],
         }, raw
+
+    def test_color488_syn_extract_bare_routes_and_runs(self) -> None:
+        """Design says the S4 production lock-in is Steane + Color488
+        (Codex S4 review). Color488's serial `SynExtractBare` uses the
+        identical generic `Check` call shape -- it must also route every
+        Check through a BlockCall, compile, and run.
+        """
+        from pecos import Hugr, selene_engine, sim
+        from pecos.slr import CReg, Main, QReg, SlrConverter
+        from pecos.slr.ast import slr_to_ast
+        from pecos.slr.qeclib.color488.syn_extract.bare import (
+            SynExtractBare as Color488SynExtractBare,
+        )
+
+        checks = [[2, 1, 3, 0], [5, 2, 1, 4], [6, 5, 2, 3]]
+        prog = Main(
+            d := QReg("d", 7),
+            a := QReg("a", 2),
+            syn := CReg("syn", 6),
+            Color488SynExtractBare(d, a, checks, syn),
+        )
+        ast = slr_to_ast(prog)
+        assert sum(1 for s in ast.body if isinstance(s, BlockCall)) == 6
+        guppy_src = SlrConverter(prog).guppy()
+        assert guppy_src.count("def check") == 6
+        assert "LinearityError" not in guppy_src
+
+        package = SlrConverter(prog).hugr()
+        result = (
+            sim(Hugr(package.to_str().encode("utf-8")))
+            .classical(selene_engine())
+            .qubits(10)
+            .seed(42)
+            .run(4)
+        )
+        raw = result.to_dict() if hasattr(result, "to_dict") else result
+        # Same generic-Check mechanism as Steane -> same seed-42 record shape.
+        assert raw == {
+            "measurement_0": [0, 0, 0, 0],
+            "measurement_1": [0, 0, 0, 0],
+            "measurement_2": [0, 0, 0, 0],
+            "measurement_3": [1, 1, 0, 1],
+            "measurement_4": [0, 0, 1, 0],
+            "measurement_5": [0, 0, 1, 0],
+        }, raw

From 89d824c2ead4c3f218fc0a103762e75630921873 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sat, 16 May 2026 07:08:45 -0600
Subject: [PATCH 056/136] Scratch-ancilla S5: convert qeclib Check1Flag
 (a,flag:scratch; Prep(a,flag)->Prep(a),Prep(flag) per O1 option a) --
 SynExtractFlagged reused-ancilla+flag path now compiles; Check1Flag Selene
 records byte-identical (qubits 5->7); SynExtractFlagged + CH-branch lock-ins.

---
 .../pecos/slr/qeclib/generic/check_1flag.py   | 29 +++++-
 .../ast_guppy/test_block_call_smoke.py        | 89 +++++++++++++++++++
 .../ast_guppy/test_qeclib_selene_corpus.py    | 12 ++-
 3 files changed, 124 insertions(+), 6 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/generic/check_1flag.py b/python/quantum-pecos/src/pecos/slr/qeclib/generic/check_1flag.py
index 1118c68cc..ad853516c 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/generic/check_1flag.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/generic/check_1flag.py
@@ -18,7 +18,7 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, ClassVar
 
 from pecos.slr import Barrier, Block, Comment
 from pecos.slr.qeclib.qubit import CH, CX, CY, CZ, H, Measure, Prep
@@ -35,6 +35,23 @@ class Check1Flag(Block):
     to detect errors during the syndrome extraction process.
     """
 
+    # Phase 3a.3 (scratch-ancilla effect, 5e.5): emit BlockDecl + BlockCall.
+    # `a` and `flag` are both reset-reused scratch ancillas (prepped +
+    # measured inside, allocated internally in Guppy so callers can reuse
+    # physical slots across sequential checks); data passes through; the two
+    # out bits are live_preserved measurement-result write-backs. The body's
+    # single `Prep(a, flag)` is split into `Prep(a), Prep(flag)` (O1 option
+    # (a) -- byte-identical in QASM/Guppy/Selene, confirmed Codex 2026-05-16;
+    # one PrepareOp per scratch input avoids multi-destination substitution).
+    # See ~/Repos/pecos-docs/design/slr/v2-scratch-ancilla-effect.md.
+    block_inputs: ClassVar[dict[str, str]] = {
+        "d": "live_preserved",
+        "a": "scratch",
+        "flag": "scratch",
+        "out": "live_preserved",
+        "out_flag": "live_preserved",
+    }
+
     def __init__(
         self,
         d: list[Qubit],
@@ -65,6 +82,13 @@ def __init__(
             Exception: If invalid operator is specified.
         """
         super().__init__()
+        # SLR -> AST converter reads these to bind block_inputs param names
+        # to outer-scope refs.
+        self.d = d
+        self.a = a
+        self.flag = flag
+        self.out = out
+        self.out_flag = out_flag
 
         n: int = len(d)
 
@@ -85,7 +109,8 @@ def __init__(
 
         self.extend(
             Comment(f"Measure check {ops}"),
-            Prep(a, flag),
+            Prep(a),
+            Prep(flag),
             H(a),
         )
         if with_barriers:
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
index 813d9c08c..3abced7c1 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
@@ -2871,3 +2871,92 @@ def test_color488_syn_extract_bare_routes_and_runs(self) -> None:
             "measurement_4": [0, 0, 1, 0],
             "measurement_5": [0, 0, 1, 0],
         }, raw
+
+
+class TestScratchCheck1FlagS5ProductionLockIn:
+    """S5: `Check1Flag` converted (`a`, `flag`: scratch; the body's
+    `Prep(a, flag)` split into `Prep(a); Prep(flag)` per O1 option (a)).
+    Steane `SynExtractFlagged` reuses ancilla+flag slots across 6
+    Check1Flag calls -- it must route every one through a BlockCall,
+    compile (12 internal allocs, no LinearityError), and run.
+    """
+
+    def test_steane_syn_extract_flagged_routes_and_runs(self) -> None:
+        from pecos import Hugr, selene_engine, sim
+        from pecos.slr import CReg, Main, QReg, SlrConverter
+        from pecos.slr.ast import slr_to_ast
+        from pecos.slr.qeclib.steane.syn_extract.flagged import SynExtractFlagged
+
+        checks = [[2, 1, 3, 0], [5, 2, 1, 4], [6, 5, 2, 3]]
+        prog = Main(
+            d := QReg("d", 7),
+            a := QReg("a", 4),
+            sx := CReg("sx", 3),
+            sz := CReg("sz", 3),
+            fx := CReg("fx", 3),
+            fz := CReg("fz", 3),
+            SynExtractFlagged(d, a, checks, sx, sz, fx, fz),
+        )
+        ast = slr_to_ast(prog)
+        assert sum(1 for s in ast.body if isinstance(s, BlockCall)) == 6
+        assert len(ast.block_decls) == 6
+
+        guppy_src = SlrConverter(prog).guppy()
+        assert guppy_src.count("def check1flag") == 6
+        # 2 internal scratch allocs (a + flag) per Check1Flag * 6.
+        assert guppy_src.count("= qubit()") == 12
+        assert "LinearityError" not in guppy_src
+
+        package = SlrConverter(prog).hugr()
+        result = (
+            sim(Hugr(package.to_str().encode("utf-8")))
+            .classical(selene_engine())
+            .qubits(13)  # d(7)+a(4) declared + 2 concurrent internal scratch
+            .seed(42)
+            .run(4)
+        )
+        raw = result.to_dict() if hasattr(result, "to_dict") else result
+        # Empirical probe 2026-05-16 (post-conversion, scratch internal alloc).
+        assert raw == {
+            "measurement_0": [0, 0, 0, 0],
+            "measurement_1": [0, 0, 0, 0],
+            "measurement_2": [0, 0, 0, 0],
+            "measurement_3": [0, 0, 0, 0],
+            "measurement_4": [0, 0, 0, 0],
+            "measurement_5": [0, 0, 0, 0],
+            "measurement_6": [1, 1, 0, 1],
+            "measurement_7": [0, 0, 0, 0],
+            "measurement_8": [0, 0, 1, 0],
+            "measurement_9": [0, 0, 0, 0],
+            "measurement_10": [0, 0, 1, 0],
+            "measurement_11": [0, 0, 0, 0],
+        }, raw
+
+    def test_check1flag_h_branch_compiles_qasm_only(self) -> None:
+        """The CH (`ops="H"`) branch hits a non-Clifford R1XY at runtime
+        (Selene cannot execute it), so lock in compile + QASM parity
+        only: it must still route through a BlockCall and lower cleanly
+        (Codex O1 review -- not a Selene assertion).
+        """
+        from pecos.slr import CReg, Main, QReg, SlrConverter
+        from pecos.slr.ast import slr_to_ast
+        from pecos.slr.qeclib.generic.check_1flag import Check1Flag
+
+        prog = Main(
+            q := QReg("q", 5),
+            c := CReg("c", 2),
+            Check1Flag([q[0], q[1], q[2]], "HHH", q[3], q[4], c[0], c[1], with_barriers=True),
+        )
+        ast = slr_to_ast(prog)
+        assert sum(1 for s in ast.body if isinstance(s, BlockCall)) == 1
+
+        guppy_src = SlrConverter(prog).guppy()
+        assert guppy_src.count("def check1flag") == 1
+        assert "LinearityError" not in guppy_src
+        assert "ch(" in guppy_src  # the CH branch is exercised
+
+        qasm = SlrConverter(prog).qasm()  # flatten must inline cleanly
+        assert "reset q[3];" in qasm
+        assert "reset q[4];" in qasm
+        assert "measure q[3] -> c[0];" in qasm
+        assert "measure q[4] -> c[1];" in qasm
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qeclib_selene_corpus.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qeclib_selene_corpus.py
index cd117a210..2c81c8aa3 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qeclib_selene_corpus.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qeclib_selene_corpus.py
@@ -143,16 +143,20 @@ class TestQeclibCheck1Flag:
     def test_check_1flag_xyz_on_zero_state_pinned_records(self) -> None:
         """Check1Flag with a flag qubit + two classical output bits.
 
-        Both ancilla (q[3]) and flag (q[4]) are consumed; data qubits and
-        the two classical bits are live_preserved.
+        `a` (q[3]) and `flag` (q[4]) are now `scratch` (converted 5e.5):
+        Guppy allocates BOTH internally, so the run needs 2 physical
+        qubits beyond the declared 5-qubit QReg (`qubits=7`). Data
+        qubits and the two classical bits are live_preserved. Selene
+        records are byte-identical to the pre-conversion flattened form
+        -- design R2: parity on behavioral records, not resource counts.
         """
         prog = Main(
             q := QReg("q", 5),
             c := CReg("c", 2),
             Check1Flag([q[0], q[1], q[2]], "XYZ", q[3], q[4], c[0], c[1], with_barriers=True),
         )
-        raw = _run_via_selene(prog, shots=4, seed=42, qubits=5)
-        # Empirical probe 2026-05-15:
+        raw = _run_via_selene(prog, shots=4, seed=42, qubits=7)
+        # Empirical probe 2026-05-15: unchanged post-conversion
         # {'measurement_0': [1, 0, 0, 1], 'measurement_1': [0, 0, 0, 0]}
         assert raw == {
             "measurement_0": [1, 0, 0, 1],

From 208fd95fa581a4d1c6025a03b28624a24eb0c1f3 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sat, 16 May 2026 07:15:40 -0600
Subject: [PATCH 057/136] Scratch-ancilla S5: fix corpus tracked-block table
 doc drift (Check/Check1Flag ancilla now scratch, was consumed) -- Codex S5
 non-blocking finding.

---
 .../tests/slr_tests/ast_guppy/test_qeclib_selene_corpus.py    | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qeclib_selene_corpus.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qeclib_selene_corpus.py
index 2c81c8aa3..d9f8b17b5 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qeclib_selene_corpus.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qeclib_selene_corpus.py
@@ -46,8 +46,8 @@
 
 | Block | qeclib path | Effect classification (tentative) |
 |---|---|---|
-| `Check` | qeclib/generic/check.py | data: live_preserved; ancilla: consumed; out: live_preserved |
-| `Check1Flag` | qeclib/generic/check_1flag.py | live_preserved data; consumed ancilla/flag; live_preserved out/flag |
+| `Check` | qeclib/generic/check.py | data: live_preserved; ancilla: scratch; out: live_preserved |
+| `Check1Flag` | qeclib/generic/check_1flag.py | live_preserved data; scratch ancilla/flag; live_preserved out/flag |
 | `transversal_tq` (CX) | qeclib/generic/transversal.py | both registers: live_preserved (no internal measurements) |
 | Steane CX/CY/CZ | qeclib/steane/gates_tq/transversal_tq.py | both registers: live_preserved (converted iters 1+2) |
 | Steane X/Y/Z | qeclib/steane/gates_sq/paulis.py | single register: live_preserved (converted iter 3) |

From b1308ede7bce445fe8d1cb1a8ff3ab115c82472b Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sat, 16 May 2026 07:40:36 -0600
Subject: [PATCH 058/136] v1 cutover cleanup: port surface_code_slr_exploration
 notebook off the deleted IRGuppyGenerator to SlrConverter.guppy(); drop stale
 deleted-test reference in audit_runner comment.

---
 examples/surface_code_slr_exploration.ipynb   | 71 ++-----------------
 .../tests/slr_tests/ast_guppy/audit_runner.py |  4 +-
 2 files changed, 6 insertions(+), 69 deletions(-)

diff --git a/examples/surface_code_slr_exploration.ipynb b/examples/surface_code_slr_exploration.ipynb
index 4af7f0ec4..de3051c3b 100644
--- a/examples/surface_code_slr_exploration.ipynb
+++ b/examples/surface_code_slr_exploration.ipynb
@@ -26,20 +26,7 @@
    "id": "imports",
    "metadata": {},
    "outputs": [],
-   "source": [
-    "# Our circuit builder for comparison\n",
-    "from pecos.qec.surface import (\n",
-    "    SurfacePatch,\n",
-    "    generate_guppy_from_patch,\n",
-    "    generate_stim_from_patch,\n",
-    "    generate_tick_circuit_from_patch,\n",
-    ")\n",
-    "from pecos.qec.surface.schedule import compute_cnot_schedule\n",
-    "from pecos.slr import Barrier, Main, QReg\n",
-    "from pecos.slr.gen_codes.gen_stim import StimGenerator\n",
-    "from pecos.slr.gen_codes.guppy import IRGuppyGenerator\n",
-    "from pecos.slr.qeclib.qubit import CX, H, Measure, Prep"
-   ]
+   "source": "# Our circuit builder for comparison\nfrom pecos.qec.surface import (\n    SurfacePatch,\n    generate_guppy_from_patch,\n    generate_stim_from_patch,\n    generate_tick_circuit_from_patch,\n)\nfrom pecos.qec.surface.schedule import compute_cnot_schedule\nfrom pecos.slr import Barrier, Main, QReg, SlrConverter\nfrom pecos.slr.gen_codes.gen_stim import StimGenerator\nfrom pecos.slr.qeclib.qubit import CX, H, Measure, Prep"
   },
   {
    "cell_type": "markdown",
@@ -234,7 +221,7 @@
    "id": "slr-to-guppy",
    "metadata": {},
    "outputs": [],
-   "source": "# Try generating Guppy from SLR\ntry:\n    guppy_gen = IRGuppyGenerator()\n    guppy_gen.generate_block(slr_prog)\n    slr_guppy = guppy_gen.get_output()\n    print(\"=== SLR -> Guppy ===\")\n    print(slr_guppy[:2000] if len(slr_guppy) > 2000 else slr_guppy)\n    if len(slr_guppy) > 2000:\n        print(f\"... ({len(slr_guppy) - 2000} more characters)\")\nexcept (ValueError, TypeError, AttributeError) as e:\n    print(f\"Guppy generation failed: {e}\")\n    slr_guppy = None"
+   "source": "# Generate Guppy from SLR via the AST -> Guppy path (SlrConverter.guppy()).\n# (The legacy IRGuppyGenerator was removed in the v1 cutover; SlrConverter\n# is now the supported entrypoint for all codegens.)\ntry:\n    slr_guppy = SlrConverter(slr_prog).guppy()\n    print(\"=== SLR -> Guppy ===\")\n    print(slr_guppy[:2000] if len(slr_guppy) > 2000 else slr_guppy)\n    if len(slr_guppy) > 2000:\n        print(f\"... ({len(slr_guppy) - 2000} more characters)\")\nexcept (ValueError, TypeError, AttributeError) as e:\n    print(f\"Guppy generation failed: {e}\")\n    slr_guppy = None"
   },
   {
    "cell_type": "code",
@@ -312,57 +299,7 @@
    "id": "gap-analysis",
    "metadata": {},
    "outputs": [],
-   "source": [
-    "gaps = [\n",
-    "    {\n",
-    "        \"feature\": \"TickCircuit Generator\",\n",
-    "        \"status\": \"Missing\",\n",
-    "        \"description\": \"SLR has no TickCircuitGenerator. Would need to add one similar to StimGenerator.\",\n",
-    "        \"effort\": \"Medium\",\n",
-    "    },\n",
-    "    {\n",
-    "        \"feature\": \"Detector Annotations\",\n",
-    "        \"status\": \"Missing\",\n",
-    "        \"description\": \"SLR has no concept of detectors/observables for DEM generation. \"\n",
-    "                       \"Would need to add metadata support or a new annotation type.\",\n",
-    "        \"effort\": \"Medium-High\",\n",
-    "    },\n",
-    "    {\n",
-    "        \"feature\": \"Tick/Phase Metadata\",\n",
-    "        \"status\": \"Partial\",\n",
-    "        \"description\": \"SLR has Barrier() which maps to TICK, but no semantic phase annotations \"\n",
-    "                       \"(prep, syndrome, measure). Could add via Comments or new metadata.\",\n",
-    "        \"effort\": \"Low\",\n",
-    "    },\n",
-    "    {\n",
-    "        \"feature\": \"Gate-level Metadata\",\n",
-    "        \"status\": \"Missing\",\n",
-    "        \"description\": \"No way to annotate individual gates with labels (e.g., 'sx0', 'Z2').\",\n",
-    "        \"effort\": \"Low-Medium\",\n",
-    "    },\n",
-    "    {\n",
-    "        \"feature\": \"Stim Generation\",\n",
-    "        \"status\": \"Working\",\n",
-    "        \"description\": \"StimGenerator produces valid Stim circuits. Gate counts match.\",\n",
-    "        \"effort\": \"N/A\",\n",
-    "    },\n",
-    "    {\n",
-    "        \"feature\": \"Guppy Generation\",\n",
-    "        \"status\": \"Needs Testing\",\n",
-    "        \"description\": \"IRGuppyGenerator exists but may need updates for surface code patterns.\",\n",
-    "        \"effort\": \"TBD\",\n",
-    "    },\n",
-    "]\n",
-    "\n",
-    "print(\"=== SLR Enhancement Gap Analysis ===\")\n",
-    "print()\n",
-    "for gap in gaps:\n",
-    "    print(f\"Feature: {gap['feature']}\")\n",
-    "    print(f\"  Status: {gap['status']}\")\n",
-    "    print(f\"  Description: {gap['description']}\")\n",
-    "    print(f\"  Effort: {gap['effort']}\")\n",
-    "    print()"
-   ]
+   "source": "gaps = [\n    {\n        \"feature\": \"TickCircuit Generator\",\n        \"status\": \"Missing\",\n        \"description\": \"SLR has no TickCircuitGenerator. Would need to add one similar to StimGenerator.\",\n        \"effort\": \"Medium\",\n    },\n    {\n        \"feature\": \"Detector Annotations\",\n        \"status\": \"Missing\",\n        \"description\": \"SLR has no concept of detectors/observables for DEM generation. \"\n                       \"Would need to add metadata support or a new annotation type.\",\n        \"effort\": \"Medium-High\",\n    },\n    {\n        \"feature\": \"Tick/Phase Metadata\",\n        \"status\": \"Partial\",\n        \"description\": \"SLR has Barrier() which maps to TICK, but no semantic phase annotations \"\n                       \"(prep, syndrome, measure). Could add via Comments or new metadata.\",\n        \"effort\": \"Low\",\n    },\n    {\n        \"feature\": \"Gate-level Metadata\",\n        \"status\": \"Missing\",\n        \"description\": \"No way to annotate individual gates with labels (e.g., 'sx0', 'Z2').\",\n        \"effort\": \"Low-Medium\",\n    },\n    {\n        \"feature\": \"Stim Generation\",\n        \"status\": \"Working\",\n        \"description\": \"StimGenerator produces valid Stim circuits. Gate counts match.\",\n        \"effort\": \"N/A\",\n    },\n    {\n        \"feature\": \"Guppy Generation\",\n        \"status\": \"Working\",\n        \"description\": \"SlrConverter(prog).guppy() (AST -> Guppy path) is the supported \"\n                       \"route; the legacy IRGuppyGenerator was removed in the v1 cutover.\",\n        \"effort\": \"N/A\",\n    },\n]\n\nprint(\"=== SLR Enhancement Gap Analysis ===\")\nprint()\nfor gap in gaps:\n    print(f\"Feature: {gap['feature']}\")\n    print(f\"  Status: {gap['status']}\")\n    print(f\"  Description: {gap['description']}\")\n    print(f\"  Effort: {gap['effort']}\")\n    print()"
   },
   {
    "cell_type": "markdown",
@@ -656,4 +593,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
+}
\ No newline at end of file
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
index 1f3e269fe..d79be25cb 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
@@ -507,8 +507,8 @@ def _qeclib_color488_syn_extract_bare_preexisting() -> Block:
 def _docs_for_static_indexing() -> Block:
     """v1-shaped For loop: string iteration variable, integer bounds, fixed-slot body.
 
-    From `test_unified_resource_planner.py` shape per v1-feature-matrix:
-    v1 supports For("i", 0, 3) over fixed slots, no symbolic indexing.
+    Shape per v1-feature-matrix: v1 supports For("i", 0, 3) over fixed
+    slots, no symbolic indexing.
     """
     return Main(
         q := QReg("q", 3),

From 4cfe2e684cb3f6b8ef0717d7365a7e5bbed3640c Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sat, 16 May 2026 07:59:03 -0600
Subject: [PATCH 059/136] Centralize AST visitor dispatch: replace 37 per-node
 accept() double-dispatch stubs with one BaseVisitor _DISPATCH map; drop
 vacuous ABC from base nodes; nodes.py now visitor-decoupled; +completeness
 safety-net test (byte-identity + public API unchanged).

---
 .../quantum-pecos/src/pecos/slr/ast/nodes.py  | 130 +-----------------
 .../src/pecos/slr/ast/pretty_print.py         |   8 +-
 .../src/pecos/slr/ast/visitor.py              |  63 ++++++++-
 .../pecos/slr/ast_tests/test_ast_visitor.py   |  49 +++++++
 4 files changed, 121 insertions(+), 129 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/nodes.py b/python/quantum-pecos/src/pecos/slr/ast/nodes.py
index 12b2e76e8..e7c8303c1 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/nodes.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/nodes.py
@@ -24,7 +24,6 @@
 
 from __future__ import annotations
 
-from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
 from enum import Enum, auto
 from typing import TYPE_CHECKING
@@ -32,8 +31,6 @@
 if TYPE_CHECKING:
     from collections.abc import Sequence
 
-    from pecos.slr.ast.visitor import AstVisitor, T
-
 
 # =============================================================================
 # Source Location
@@ -63,22 +60,17 @@ def __str__(self) -> str:
 
 
 @dataclass(frozen=True, kw_only=True)
-class AstNode(ABC):
+class AstNode:
     """Base class for all AST nodes.
 
     All AST nodes are immutable frozen dataclasses that support:
-    - Visitor pattern via accept()
+    - Visitor traversal via `BaseVisitor` (centralized dispatch)
     - Child traversal via children()
     - Optional source location tracking
     """
 
     location: SourceLocation | None = field(default=None, compare=False, repr=False)
 
-    @abstractmethod
-    def accept(self, visitor: AstVisitor[T]) -> T:
-        """Accept a visitor for traversal."""
-        ...
-
     def children(self) -> Sequence[AstNode]:
         """Return child nodes for traversal. Override in subclasses."""
         return ()
@@ -249,9 +241,6 @@ class SlotRef(AstNode):
     allocator: str
     index: int
 
-    def accept(self, visitor: AstVisitor[T]) -> T:
-        return visitor.visit_slot_ref(self)
-
     def __str__(self) -> str:
         return f"{self.allocator}[{self.index}]"
 
@@ -263,9 +252,6 @@ class BitRef(AstNode):
     register: str
     index: int
 
-    def accept(self, visitor: AstVisitor[T]) -> T:
-        return visitor.visit_bit_ref(self)
-
     def __str__(self) -> str:
         return f"{self.register}[{self.index}]"
 
@@ -276,7 +262,7 @@ def __str__(self) -> str:
 
 
 @dataclass(frozen=True, kw_only=True)
-class Expression(AstNode, ABC):
+class Expression(AstNode):
     """Base class for all expressions."""
 
 
@@ -286,9 +272,6 @@ class LiteralExpr(Expression):
 
     value: int | float | bool
 
-    def accept(self, visitor: AstVisitor[T]) -> T:
-        return visitor.visit_literal(self)
-
 
 @dataclass(frozen=True, kw_only=True)
 class VarExpr(Expression):
@@ -296,9 +279,6 @@ class VarExpr(Expression):
 
     name: str
 
-    def accept(self, visitor: AstVisitor[T]) -> T:
-        return visitor.visit_var(self)
-
 
 @dataclass(frozen=True, kw_only=True)
 class BitExpr(Expression):
@@ -306,9 +286,6 @@ class BitExpr(Expression):
 
     ref: BitRef
 
-    def accept(self, visitor: AstVisitor[T]) -> T:
-        return visitor.visit_bit_expr(self)
-
     def children(self) -> Sequence[AstNode]:
         return (self.ref,)
 
@@ -321,9 +298,6 @@ class BinaryExpr(Expression):
     left: Expression
     right: Expression
 
-    def accept(self, visitor: AstVisitor[T]) -> T:
-        return visitor.visit_binary(self)
-
     def children(self) -> Sequence[AstNode]:
         return (self.left, self.right)
 
@@ -335,9 +309,6 @@ class UnaryExpr(Expression):
     op: UnaryOp
     operand: Expression
 
-    def accept(self, visitor: AstVisitor[T]) -> T:
-        return visitor.visit_unary(self)
-
     def children(self) -> Sequence[AstNode]:
         return (self.operand,)
 
@@ -348,7 +319,7 @@ def children(self) -> Sequence[AstNode]:
 
 
 @dataclass(frozen=True, kw_only=True)
-class TypeExpr(AstNode, ABC):
+class TypeExpr(AstNode):
     """Base class for type expressions."""
 
 
@@ -356,17 +327,11 @@ class TypeExpr(AstNode, ABC):
 class QubitTypeExpr(TypeExpr):
     """Single qubit type."""
 
-    def accept(self, visitor: AstVisitor[T]) -> T:
-        return visitor.visit_qubit_type(self)
-
 
 @dataclass(frozen=True, kw_only=True)
 class BitTypeExpr(TypeExpr):
     """Single classical bit type."""
 
-    def accept(self, visitor: AstVisitor[T]) -> T:
-        return visitor.visit_bit_type(self)
-
 
 @dataclass(frozen=True, kw_only=True)
 class ArrayTypeExpr(TypeExpr):
@@ -375,9 +340,6 @@ class ArrayTypeExpr(TypeExpr):
     element: TypeExpr
     size: int
 
-    def accept(self, visitor: AstVisitor[T]) -> T:
-        return visitor.visit_array_type(self)
-
     def children(self) -> Sequence[AstNode]:
         return (self.element,)
 
@@ -388,9 +350,6 @@ class AllocatorTypeExpr(TypeExpr):
 
     capacity: int
 
-    def accept(self, visitor: AstVisitor[T]) -> T:
-        return visitor.visit_allocator_type(self)
-
 
 # =============================================================================
 # Declarations
@@ -398,7 +357,7 @@ def accept(self, visitor: AstVisitor[T]) -> T:
 
 
 @dataclass(frozen=True, kw_only=True)
-class Declaration(AstNode, ABC):
+class Declaration(AstNode):
     """Base class for all declarations."""
 
 
@@ -414,9 +373,6 @@ class AllocatorDecl(Declaration):
     capacity: int
     parent: str | None = None  # Name of parent allocator
 
-    def accept(self, visitor: AstVisitor[T]) -> T:
-        return visitor.visit_allocator_decl(self)
-
 
 @dataclass(frozen=True, kw_only=True)
 class RegisterDecl(Declaration):
@@ -426,9 +382,6 @@ class RegisterDecl(Declaration):
     size: int
     is_result: bool = True
 
-    def accept(self, visitor: AstVisitor[T]) -> T:
-        return visitor.visit_register_decl(self)
-
 
 # =============================================================================
 # Statements
@@ -436,7 +389,7 @@ def accept(self, visitor: AstVisitor[T]) -> T:
 
 
 @dataclass(frozen=True, kw_only=True)
-class Statement(AstNode, ABC):
+class Statement(AstNode):
     """Base class for all statements."""
 
 
@@ -448,9 +401,6 @@ class GateOp(Statement):
     targets: tuple[SlotRef, ...]
     params: tuple[Expression, ...] = ()
 
-    def accept(self, visitor: AstVisitor[T]) -> T:
-        return visitor.visit_gate(self)
-
     def children(self) -> Sequence[AstNode]:
         return (*self.targets, *self.params)
 
@@ -466,9 +416,6 @@ class PrepareOp(Statement):
     allocator: str
     slots: tuple[int, ...] | None = None  # None means prepare_all
 
-    def accept(self, visitor: AstVisitor[T]) -> T:
-        return visitor.visit_prepare(self)
-
 
 @dataclass(frozen=True, kw_only=True)
 class MeasureOp(Statement):
@@ -480,9 +427,6 @@ class MeasureOp(Statement):
     targets: tuple[SlotRef, ...]
     results: tuple[BitRef, ...] = ()
 
-    def accept(self, visitor: AstVisitor[T]) -> T:
-        return visitor.visit_measure(self)
-
     def children(self) -> Sequence[AstNode]:
         return (*self.targets, *self.results)
 
@@ -494,9 +438,6 @@ class AssignOp(Statement):
     target: BitRef | str  # Variable name or bit reference
     value: Expression
 
-    def accept(self, visitor: AstVisitor[T]) -> T:
-        return visitor.visit_assign(self)
-
     def children(self) -> Sequence[AstNode]:
         nodes: list[AstNode] = []
         if isinstance(self.target, BitRef):
@@ -511,9 +452,6 @@ class BarrierOp(Statement):
 
     allocators: tuple[str, ...] = ()
 
-    def accept(self, visitor: AstVisitor[T]) -> T:
-        return visitor.visit_barrier(self)
-
 
 @dataclass(frozen=True, kw_only=True)
 class CommentOp(Statement):
@@ -521,9 +459,6 @@ class CommentOp(Statement):
 
     text: str
 
-    def accept(self, visitor: AstVisitor[T]) -> T:
-        return visitor.visit_comment(self)
-
 
 @dataclass(frozen=True, kw_only=True)
 class ReturnOp(Statement):
@@ -531,9 +466,6 @@ class ReturnOp(Statement):
 
     values: tuple[Expression | str, ...] = ()  # Can be variable names
 
-    def accept(self, visitor: AstVisitor[T]) -> T:
-        return visitor.visit_return(self)
-
     def children(self) -> Sequence[AstNode]:
         return tuple(v for v in self.values if isinstance(v, AstNode))
 
@@ -557,9 +489,6 @@ class PrintOp(Statement):
     tag: str
     namespace: str = "result"
 
-    def accept(self, visitor: AstVisitor[T]) -> T:
-        return visitor.visit_print(self)
-
     def children(self) -> Sequence[AstNode]:
         if isinstance(self.value, AstNode):
             return (self.value,)
@@ -581,9 +510,6 @@ class PermuteOp(Statement):
     targets: tuple[str, ...]  # Final register/allocator names
     add_comment: bool = True  # Whether to add a comment in generated code
 
-    def accept(self, visitor: AstVisitor[T]) -> T:
-        return visitor.visit_permute(self)
-
 
 # =============================================================================
 # Control Flow
@@ -598,9 +524,6 @@ class IfStmt(Statement):
     then_body: tuple[Statement, ...]
     else_body: tuple[Statement, ...] = ()
 
-    def accept(self, visitor: AstVisitor[T]) -> T:
-        return visitor.visit_if(self)
-
     def children(self) -> Sequence[AstNode]:
         return (self.condition, *self.then_body, *self.else_body)
 
@@ -612,9 +535,6 @@ class WhileStmt(Statement):
     condition: Expression
     body: tuple[Statement, ...]
 
-    def accept(self, visitor: AstVisitor[T]) -> T:
-        return visitor.visit_while(self)
-
     def children(self) -> Sequence[AstNode]:
         return (self.condition, *self.body)
 
@@ -629,9 +549,6 @@ class ForStmt(Statement):
     step: Expression | None = None
     body: tuple[Statement, ...] = ()
 
-    def accept(self, visitor: AstVisitor[T]) -> T:
-        return visitor.visit_for(self)
-
     def children(self) -> Sequence[AstNode]:
         nodes: list[AstNode] = [self.start, self.stop]
         if self.step:
@@ -647,9 +564,6 @@ class RepeatStmt(Statement):
     count: int
     body: tuple[Statement, ...]
 
-    def accept(self, visitor: AstVisitor[T]) -> T:
-        return visitor.visit_repeat(self)
-
     def children(self) -> Sequence[AstNode]:
         return self.body
 
@@ -660,9 +574,6 @@ class ParallelBlock(Statement):
 
     body: tuple[Statement, ...]
 
-    def accept(self, visitor: AstVisitor[T]) -> T:
-        return visitor.visit_parallel(self)
-
     def children(self) -> Sequence[AstNode]:
         return self.body
 
@@ -683,9 +594,6 @@ class BlockInput(AstNode):
     effect: ResourceEffect
     type_expr: TypeExpr
 
-    def accept(self, visitor: AstVisitor[T]) -> T:
-        return visitor.visit_block_input(self)
-
     def children(self) -> Sequence[AstNode]:
         return (self.type_expr,)
 
@@ -702,9 +610,6 @@ class BlockDecl(AstNode):
     body: tuple[Statement, ...]
     return_op: ReturnOp | None = None
 
-    def accept(self, visitor: AstVisitor[T]) -> T:
-        return visitor.visit_block_decl(self)
-
     def children(self) -> Sequence[AstNode]:
         nodes: list[AstNode] = list(self.inputs)
         nodes.extend(self.body)
@@ -717,7 +622,7 @@ def children(self) -> Sequence[AstNode]:
 
 
 @dataclass(frozen=True, kw_only=True)
-class BlockArg(AstNode, ABC):
+class BlockArg(AstNode):
     """Base class for `BlockCall` argument bindings.
 
     Each BlockInput on the callee is bound to exactly one BlockArg at the
@@ -731,9 +636,6 @@ class AllocatorArg(BlockArg):
 
     name: str
 
-    def accept(self, visitor: AstVisitor[T]) -> T:
-        return visitor.visit_allocator_arg(self)
-
 
 @dataclass(frozen=True, kw_only=True)
 class SingleQubitArg(BlockArg):
@@ -741,9 +643,6 @@ class SingleQubitArg(BlockArg):
 
     slot: SlotRef
 
-    def accept(self, visitor: AstVisitor[T]) -> T:
-        return visitor.visit_single_qubit_arg(self)
-
     def children(self) -> Sequence[AstNode]:
         return (self.slot,)
 
@@ -754,9 +653,6 @@ class SingleBitArg(BlockArg):
 
     bit: BitRef
 
-    def accept(self, visitor: AstVisitor[T]) -> T:
-        return visitor.visit_single_bit_arg(self)
-
     def children(self) -> Sequence[AstNode]:
         return (self.bit,)
 
@@ -767,9 +663,6 @@ class QubitBundleArg(BlockArg):
 
     slots: tuple[SlotRef, ...]
 
-    def accept(self, visitor: AstVisitor[T]) -> T:
-        return visitor.visit_qubit_bundle_arg(self)
-
     def children(self) -> Sequence[AstNode]:
         return self.slots
 
@@ -780,9 +673,6 @@ class BitBundleArg(BlockArg):
 
     bits: tuple[BitRef, ...]
 
-    def accept(self, visitor: AstVisitor[T]) -> T:
-        return visitor.visit_bit_bundle_arg(self)
-
     def children(self) -> Sequence[AstNode]:
         return self.bits
 
@@ -803,9 +693,6 @@ class BlockCall(Statement):
     arg_bindings: tuple[BlockArg, ...]
     out_bindings: tuple[BlockArg, ...] = ()
 
-    def accept(self, visitor: AstVisitor[T]) -> T:
-        return visitor.visit_block_call(self)
-
     def children(self) -> Sequence[AstNode]:
         return (*self.arg_bindings, *self.out_bindings)
 
@@ -833,9 +720,6 @@ class Program(AstNode):
     allocator: AllocatorDecl | None = None  # Base allocator
     block_decls: tuple[BlockDecl, ...] = ()
 
-    def accept(self, visitor: AstVisitor[T]) -> T:
-        return visitor.visit_program(self)
-
     def children(self) -> Sequence[AstNode]:
         nodes: list[AstNode] = []
         if self.allocator:
diff --git a/python/quantum-pecos/src/pecos/slr/ast/pretty_print.py b/python/quantum-pecos/src/pecos/slr/ast/pretty_print.py
index 6d7cf9c8e..25667044c 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/pretty_print.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/pretty_print.py
@@ -202,7 +202,7 @@ def visit_register_decl(self, node: RegisterDecl) -> str:
 
     def format_statement(self, stmt: Statement) -> str:
         """Format a statement."""
-        return stmt.accept(self)
+        return self.visit(stmt)
 
     def visit_gate(self, node: GateOp) -> str:
         """Visit gate operation."""
@@ -398,7 +398,7 @@ def _format_type_expr(self, type_expr: TypeExpr) -> str:
             return "qubit"
         if isinstance(type_expr, BitTypeExpr):
             return "bit"
-        return type_expr.accept(self)
+        return self.visit(type_expr)
 
     # References
 
@@ -414,7 +414,7 @@ def visit_bit_ref(self, node: BitRef) -> str:
 
     def format_expression(self, expr: Expression) -> str:
         """Format an expression."""
-        return expr.accept(self)
+        return self.visit(expr)
 
     def visit_literal(self, node: LiteralExpr) -> str:
         """Visit literal expression."""
@@ -460,7 +460,7 @@ def visit_bit_type(self, _node: object) -> str:
 
     def visit_array_type(self, node) -> str:
         """Visit array type."""
-        element = node.element.accept(self)
+        element = self.visit(node.element)
         return f"Array[{element}, {node.size}]"
 
     def visit_allocator_type(self, node) -> str:
diff --git a/python/quantum-pecos/src/pecos/slr/ast/visitor.py b/python/quantum-pecos/src/pecos/slr/ast/visitor.py
index b5776008a..adbdb8d8a 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/visitor.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/visitor.py
@@ -65,6 +65,51 @@
 T = TypeVar("T")
 T_co = TypeVar("T_co", covariant=True)
 
+# Node-class-name -> BaseVisitor method name. This is the single source of
+# truth for visitor dispatch (replaces the per-node `accept()` double
+# dispatch). Keyed by `type(node).__name__` so no runtime import of the
+# node classes is needed (avoids an import cycle with nodes.py).
+# `test_ast_visitor` asserts every concrete AstNode subclass is registered
+# here, so a new node without an entry fails loudly in tests.
+_DISPATCH: dict[str, str] = {
+    "Program": "visit_program",
+    "AllocatorDecl": "visit_allocator_decl",
+    "RegisterDecl": "visit_register_decl",
+    "GateOp": "visit_gate",
+    "PrepareOp": "visit_prepare",
+    "MeasureOp": "visit_measure",
+    "AssignOp": "visit_assign",
+    "BarrierOp": "visit_barrier",
+    "CommentOp": "visit_comment",
+    "ReturnOp": "visit_return",
+    "PrintOp": "visit_print",
+    "PermuteOp": "visit_permute",
+    "IfStmt": "visit_if",
+    "WhileStmt": "visit_while",
+    "ForStmt": "visit_for",
+    "RepeatStmt": "visit_repeat",
+    "ParallelBlock": "visit_parallel",
+    "BlockInput": "visit_block_input",
+    "BlockDecl": "visit_block_decl",
+    "BlockCall": "visit_block_call",
+    "AllocatorArg": "visit_allocator_arg",
+    "SingleQubitArg": "visit_single_qubit_arg",
+    "SingleBitArg": "visit_single_bit_arg",
+    "QubitBundleArg": "visit_qubit_bundle_arg",
+    "BitBundleArg": "visit_bit_bundle_arg",
+    "SlotRef": "visit_slot_ref",
+    "BitRef": "visit_bit_ref",
+    "LiteralExpr": "visit_literal",
+    "VarExpr": "visit_var",
+    "BitExpr": "visit_bit_expr",
+    "BinaryExpr": "visit_binary",
+    "UnaryExpr": "visit_unary",
+    "QubitTypeExpr": "visit_qubit_type",
+    "BitTypeExpr": "visit_bit_type",
+    "ArrayTypeExpr": "visit_array_type",
+    "AllocatorTypeExpr": "visit_allocator_type",
+}
+
 
 class AstVisitor(Protocol[T_co]):
     """Protocol defining the visitor interface for AST nodes.
@@ -173,8 +218,22 @@ def combine_results(self, results: list[str]) -> str:
     """
 
     def visit(self, node) -> T:
-        """Dispatch to the appropriate visit method."""
-        return node.accept(self)
+        """Dispatch to the appropriate visit method by node type.
+
+        Centralized dispatch (replaces per-node `accept()` double
+        dispatch): nodes carry no visitor coupling. `_DISPATCH` maps a
+        node class name to its `visit_*` method; the lookup is
+        late-bound via `getattr` so subclass overrides still apply.
+        """
+        method = _DISPATCH.get(type(node).__name__)
+        if method is None:
+            msg = (
+                f"BaseVisitor: no visit method registered for AST node "
+                f"{type(node).__name__!r} (add it to _DISPATCH in "
+                f"pecos.slr.ast.visitor)"
+            )
+            raise TypeError(msg)
+        return getattr(self, method)(node)
 
     def visit_children(self, node) -> list[T]:
         """Visit all children and collect results."""
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_visitor.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_visitor.py
index 0ac53494f..e0fe31714 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_visitor.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_visitor.py
@@ -273,3 +273,52 @@ def visit_gate(self, node: GateOp) -> None:
 
         assert "H" in visitor.visited
         assert "X" in visitor.visited
+
+
+class TestVisitorDispatchCompleteness:
+    """Safety net for the centralized `_DISPATCH` (replaced per-node
+    `accept()`): a new concrete AST node without a dispatch entry must
+    fail loudly here -- this is what catching a missing `accept()`
+    used to do implicitly.
+    """
+
+    @staticmethod
+    def _concrete_node_names() -> set[str]:
+        import pecos.slr.ast.nodes as nodes_mod
+
+        def all_subclasses(cls: type) -> set[type]:
+            out: set[type] = set()
+            for sub in cls.__subclasses__():
+                out.add(sub)
+                out |= all_subclasses(sub)
+            return out
+
+        nodes = all_subclasses(nodes_mod.AstNode)
+        # Intermediate/abstract bases (AstNode, Expression, Statement,
+        # TypeExpr, Declaration, BlockArg) are never instantiated directly
+        # and are correctly absent from _DISPATCH.
+        bases = {
+            base
+            for cls in nodes
+            for base in cls.__bases__
+            if base in nodes or base is nodes_mod.AstNode
+        }
+        return {cls.__name__ for cls in nodes if cls not in bases}
+
+    def test_every_concrete_node_has_a_dispatch_entry(self) -> None:
+        from pecos.slr.ast.visitor import _DISPATCH
+
+        missing = sorted(self._concrete_node_names() - set(_DISPATCH))
+        assert not missing, (
+            f"concrete AST nodes with no _DISPATCH entry: {missing} "
+            "(add them to pecos.slr.ast.visitor._DISPATCH)"
+        )
+
+    def test_no_stale_or_invalid_dispatch_entries(self) -> None:
+        from pecos.slr.ast.visitor import _DISPATCH, BaseVisitor
+
+        concrete = self._concrete_node_names()
+        stale = sorted(set(_DISPATCH) - concrete)
+        assert not stale, f"_DISPATCH keys that are not concrete nodes: {stale}"
+        bad = sorted(v for v in _DISPATCH.values() if not callable(getattr(BaseVisitor, v, None)))
+        assert not bad, f"_DISPATCH values not methods on BaseVisitor: {bad}"

From 163b29f116cab46e7e58adfc8d79a6695a065c8d Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sat, 16 May 2026 08:11:49 -0600
Subject: [PATCH 060/136] Visitor dispatch: walk type(node).__mro__ so
 subclasses of concrete AST nodes resolve to the base node's visit_*
 (preserves old inherited-accept() semantics, Codex review); scope
 completeness test to the nodes module + add MRO-subclass regression test.

---
 .../src/pecos/slr/ast/visitor.py              | 25 ++++++++++------
 .../pecos/slr/ast_tests/test_ast_visitor.py   | 29 ++++++++++++++++++-
 2 files changed, 44 insertions(+), 10 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/visitor.py b/python/quantum-pecos/src/pecos/slr/ast/visitor.py
index adbdb8d8a..8dad652c8 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/visitor.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/visitor.py
@@ -224,16 +224,23 @@ def visit(self, node) -> T:
         dispatch): nodes carry no visitor coupling. `_DISPATCH` maps a
         node class name to its `visit_*` method; the lookup is
         late-bound via `getattr` so subclass overrides still apply.
+
+        Resolution walks `type(node).__mro__` and uses the first
+        registered ancestor. This preserves the old inherited-`accept()`
+        semantics: a user subclass of a concrete node (e.g.
+        `class MyGate(GateOp)`) inherited `GateOp.accept` and dispatched
+        to `visit_gate`; MRO lookup reproduces that exactly.
         """
-        method = _DISPATCH.get(type(node).__name__)
-        if method is None:
-            msg = (
-                f"BaseVisitor: no visit method registered for AST node "
-                f"{type(node).__name__!r} (add it to _DISPATCH in "
-                f"pecos.slr.ast.visitor)"
-            )
-            raise TypeError(msg)
-        return getattr(self, method)(node)
+        for cls in type(node).__mro__:
+            method = _DISPATCH.get(cls.__name__)
+            if method is not None:
+                return getattr(self, method)(node)
+        msg = (
+            f"BaseVisitor: no visit method registered for AST node "
+            f"{type(node).__name__!r} (add it to _DISPATCH in "
+            f"pecos.slr.ast.visitor)"
+        )
+        raise TypeError(msg)
 
     def visit_children(self, node) -> list[T]:
         """Visit all children and collect results."""
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_visitor.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_visitor.py
index e0fe31714..fecfc5c5d 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_visitor.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_visitor.py
@@ -293,7 +293,13 @@ def all_subclasses(cls: type) -> set[type]:
                 out |= all_subclasses(sub)
             return out
 
-        nodes = all_subclasses(nodes_mod.AstNode)
+        # Only nodes shipped in `pecos.slr.ast.nodes` -- user/test
+        # subclasses (e.g. `MyGate(GateOp)`) are intentionally resolved
+        # by MRO in BaseVisitor.visit and must NOT be required in
+        # _DISPATCH, so scope the enumeration to the nodes module.
+        nodes = {
+            c for c in all_subclasses(nodes_mod.AstNode) if c.__module__ == nodes_mod.__name__
+        }
         # Intermediate/abstract bases (AstNode, Expression, Statement,
         # TypeExpr, Declaration, BlockArg) are never instantiated directly
         # and are correctly absent from _DISPATCH.
@@ -322,3 +328,24 @@ def test_no_stale_or_invalid_dispatch_entries(self) -> None:
         assert not stale, f"_DISPATCH keys that are not concrete nodes: {stale}"
         bad = sorted(v for v in _DISPATCH.values() if not callable(getattr(BaseVisitor, v, None)))
         assert not bad, f"_DISPATCH values not methods on BaseVisitor: {bad}"
+
+    def test_subclass_of_concrete_node_dispatches_via_mro(self) -> None:
+        """Codex visitor-refactor review: the old `node.accept(self)`
+        double-dispatch was inherited, so a user subclass of a concrete
+        node dispatched to the base node's `visit_*`. MRO lookup in
+        `BaseVisitor.visit` must preserve that (a bare class-name match
+        would wrongly raise).
+        """
+
+        class MyGate(GateOp):
+            pass
+
+        class Recorder(BaseVisitor[str]):
+            def visit_gate(self, node: GateOp) -> str:
+                return f"gate:{node.gate.name}"
+
+            def default_result(self) -> str:
+                return ""
+
+        node = MyGate(gate=GateKind.H, targets=(SlotRef(allocator="q", index=0),))
+        assert Recorder().visit(node) == "gate:H"

From 25ffeaa9a87a7b7682650efb8865c4cd3419d4b9 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sat, 16 May 2026 10:37:02 -0600
Subject: [PATCH 061/136] Fix two pre-existing qeclib construction bugs (audit
 XFAIL->accepted, 8->6 XFAIL): PrepProjectZ now preps its list[Qubit] via the
 Q.pz primitive (dead/broken (QReg,indices) PrepZ removed); Color488
 SynExtractBareParallel uses int math.ceil for the range() count instead of
 the f64 numpy-drop-in pecos_rslib.num.ceil.

---
 .../slr/qeclib/color488/syn_extract/bare.py   |  4 +--
 .../surface/macrolibs/preps/project_pauli.py  | 28 ++++---------------
 .../tests/slr_tests/ast_guppy/audit_runner.py | 24 ++++------------
 3 files changed, 14 insertions(+), 42 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/color488/syn_extract/bare.py b/python/quantum-pecos/src/pecos/slr/qeclib/color488/syn_extract/bare.py
index 35f9ecce7..ef3ebe035 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/color488/syn_extract/bare.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/color488/syn_extract/bare.py
@@ -1,9 +1,9 @@
 """Bare syndrome extraction implementations for Color488 codes."""
 
+import math
 from itertools import chain, cycle, repeat
 from typing import Any
 
-import pecos as pc
 from pecos.slr import Block, Comment, CReg, Parallel, QReg
 from pecos.slr.qeclib.generic.check import Check
 
@@ -89,7 +89,7 @@ def __init__(self, data: QReg, ancillas: QReg, checks: list, syn: CReg) -> None:
         super().__init__()
 
         annotations = Block()
-        num_parallel_blocks = 2 * pc.ceil(len(checks) / len(ancillas))
+        num_parallel_blocks = 2 * math.ceil(len(checks) / len(ancillas))
         par_blocks = [Parallel() for _ in range(num_parallel_blocks)]
 
         # iterator for parallelizing circuits for one round of ancilla use
diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/surface/macrolibs/preps/project_pauli.py b/python/quantum-pecos/src/pecos/slr/qeclib/surface/macrolibs/preps/project_pauli.py
index debe63dca..5a476bba5 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/surface/macrolibs/preps/project_pauli.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/surface/macrolibs/preps/project_pauli.py
@@ -11,28 +11,10 @@
 
 """Pauli projection preparation blocks for surface code operations."""
 
-from pecos.slr import Block, QReg, Qubit
+from pecos.slr import Block, Qubit
 from pecos.slr.qeclib.qubit.qubit import PhysicalQubit as Q
 
 
-class PrepZ(Block):
-    """Prepare the +Z operator."""
-
-    def __init__(self, q: QReg, data_indices: list[int]) -> None:
-        """Initialize the +Z state preparation block.
-
-        Args:
-            q: Quantum register containing the qubits.
-            data_indices: List of indices for data qubits to prepare in +Z state.
-        """
-        super().__init__()
-
-        for i in data_indices:
-            self.extend(
-                Q.pz(q[i]),
-            )
-
-
 class PrepProjectZ(Block):
     """Prepare the +Z operator."""
 
@@ -44,7 +26,9 @@ def __init__(self, qs: list[Qubit]) -> None:
         """
         super().__init__()
 
-        self.extend(
-            PrepZ(*qs),
-        )
+        # Prepare each data qubit in |0> with the qubit-level primitive.
+        # (`qs` is a list[Qubit]; the register-indexed PrepZ block this
+        # used to call had a `(QReg, list[int])` API that did not match
+        # the qubit-list shape -- it was dead/broken and was removed.)
+        self.extend(*(Q.pz(q) for q in qs))
         # TODO: Measure the X checks
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
index d79be25cb..649723bd6 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
@@ -478,8 +478,8 @@ def _qeclib_steane_pz_v2_defer() -> Block:
     )
 
 
-def _qeclib_surface_std_pz_preexisting() -> Block:
-    """Deliberate red-light: surface std pz() currently fails during construction."""
+def _qeclib_surface_std_pz() -> Block:
+    """SurfaceStdGates.pz(): builds + lowers (PrepProjectZ bug fixed)."""
     patch = (
         SurfacePatchBuilder()
         .set_name("s")
@@ -494,8 +494,8 @@ def _qeclib_surface_std_pz_preexisting() -> Block:
     )
 
 
-def _qeclib_color488_syn_extract_bare_preexisting() -> Block:
-    """Deliberate red-light: color488 bare extraction currently fails during construction."""
+def _qeclib_color488_syn_extract_bare() -> Block:
+    """Color488 bare extraction: builds + lowers (ceil float->int bug fixed)."""
     patch = Color488Patch("c", 5, num_ancillas=4)
     return Main(
         patch,
@@ -705,23 +705,11 @@ def _curated_cases() -> list[AuditCase]:
         ),
         AuditCase(
             "qeclib.surface_std_pz",
-            _qeclib_surface_std_pz_preexisting,
-            expected_failure=ExpectedFailure(
-                exception_type="TypeError",
-                message_contains="PrepZ.__init__()",
-                classification="pre-existing",
-                reason="SurfaceStdGates.pz() fails while building the SLR program",
-            ),
+            _qeclib_surface_std_pz,
         ),
         AuditCase(
             "qeclib.color488_syn_extract_bare",
-            _qeclib_color488_syn_extract_bare_preexisting,
-            expected_failure=ExpectedFailure(
-                exception_type="TypeError",
-                message_contains="'float' object cannot be interpreted as an integer",
-                classification="pre-existing",
-                reason="Color488 bare extraction fails while building the SLR program",
-            ),
+            _qeclib_color488_syn_extract_bare,
         ),
         # docs/ corpus (pass 4)
         AuditCase("docs.for_static_indexing", _docs_for_static_indexing),

From 9bb2a7a8af5826fbba665a57e393b6eeeea94474 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sat, 16 May 2026 11:18:41 -0600
Subject: [PATCH 062/136] Add Phase 3b S1 codemod (libcst): append explicit
 Return(<result CRegs>) to implicit-return Main() calls,
 trailing-comma-preserving so the formatter keeps multi-line shape; validated
 byte-identical on test_v1_behavioral. Not yet rolled out (harness-first +
 chunked-black-gated plan pending Codex review).

---
 scripts/migrate_implicit_return.py | 158 +++++++++++++++++++++++++++++
 1 file changed, 158 insertions(+)
 create mode 100644 scripts/migrate_implicit_return.py

diff --git a/scripts/migrate_implicit_return.py b/scripts/migrate_implicit_return.py
new file mode 100644
index 000000000..81b3b7981
--- /dev/null
+++ b/scripts/migrate_implicit_return.py
@@ -0,0 +1,158 @@
+"""Phase 3b S1 codemod: make implicit-return `Main(...)` explicit.
+
+For every `Main(...)` call that does NOT already contain a `Return(...)`
+argument, append `Return(<result CRegs>)` listing the CRegs that were
+implicitly returned -- i.e. CRegs bound by a walrus assignment directly
+in the `Main(...)` arguments via `name := CReg(...)` whose `CReg(...)`
+call does NOT pass `result=False`, in order of appearance (mirrors the
+v1 implicit-return tuple order).
+
+This is behavior-preserving under the *current* implementation (proven:
+explicit `Return(c)` is QASM-SHA + Selene-record identical to the
+implicit path and suppresses the deprecation warning). It does NOT
+touch `result=` kwargs (that is S3) -- so byte-identity is exact.
+
+Sites whose result-CReg set is not statically determinable from
+walrus-in-`Main` args (e.g. `Main(*ops, ...)`, CRegs declared outside
+the call) are left untouched and reported; they are hand-migrated and
+the byte-identity + `-W error::DeprecationWarning` gate is the
+authoritative verifier.
+
+Run: `uv run --with libcst python scripts/migrate_implicit_return.py PATH...`
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import libcst as cst
+import libcst.matchers as m
+
+
+class _MainReturnTransformer(cst.CSTTransformer):
+    def __init__(self) -> None:
+        self.migrated = 0
+        self.skipped_existing_return = 0
+        self.residual: list[str] = []
+        self._needs_return_import = False
+
+    @staticmethod
+    def _is_result_creg_call(call: cst.Call) -> bool:
+        """A `CReg(...)` call counts as a result CReg unless it explicitly
+        passes `result=False`."""
+        for arg in call.args:
+            if (
+                arg.keyword is not None
+                and arg.keyword.value == "result"
+                and m.matches(arg.value, m.Name("False"))
+            ):
+                return False
+        return True
+
+    def leave_Call(self, original: cst.Call, updated: cst.Call) -> cst.BaseExpression:
+        if not m.matches(updated.func, m.Name("Main")):
+            return updated
+
+        has_return = any(
+            m.matches(a.value, m.Call(func=m.Name("Return"))) for a in updated.args
+        )
+        if has_return:
+            self.skipped_existing_return += 1
+            return updated
+
+        result_cregs: list[str] = []
+        saw_unresolvable = False
+        for a in updated.args:
+            if a.star:  # `Main(*ops, ...)` -- can't see the CRegs
+                saw_unresolvable = True
+                continue
+            v = a.value
+            if m.matches(v, m.NamedExpr()) and m.matches(
+                v.value, m.Call(func=m.Name("CReg"))
+            ):
+                target = v.target
+                if isinstance(target, cst.Name) and self._is_result_creg_call(v.value):
+                    result_cregs.append(target.value)
+
+        if not result_cregs:
+            if saw_unresolvable:
+                self.residual.append("Main(*...) / non-walrus CRegs")
+            return updated
+
+        self._needs_return_import = True
+        self.migrated += 1
+        # Trailing comma on the appended arg preserves the "magic trailing
+        # comma" so the formatter keeps the call's original multi-line vs
+        # single-line shape (minimal diff -- no whole-call reflow).
+        ret = cst.Arg(
+            value=cst.Call(
+                func=cst.Name("Return"),
+                args=[cst.Arg(value=cst.Name(n)) for n in result_cregs],
+            ),
+            comma=cst.Comma(),
+        )
+        return updated.with_changes(args=[*updated.args, ret])
+
+
+def _ensure_return_import(module: cst.Module) -> cst.Module:
+    """Add `Return` to an existing `from pecos.slr import ...` if absent."""
+
+    class _ImportFixer(cst.CSTTransformer):
+        def leave_ImportFrom(
+            self, original: cst.ImportFrom, updated: cst.ImportFrom
+        ) -> cst.ImportFrom:
+            mod = updated.module
+            if not (
+                m.matches(mod, m.Attribute())
+                and cst.Module([]).code_for_node(mod) == "pecos.slr"
+            ):
+                return updated
+            if isinstance(updated.names, cst.ImportStar):
+                return updated
+            names = list(updated.names)
+            present = {n.name.value for n in names if isinstance(n.name, cst.Name)}
+            if "Return" in present or "Main" not in present:
+                return updated
+            names.append(cst.ImportAlias(name=cst.Name("Return")))
+            names.sort(key=lambda n: n.name.value if isinstance(n.name, cst.Name) else "")
+            # Re-add commas (sort drops them); libcst normalizes.
+            fixed = [
+                a.with_changes(comma=cst.MaybeSentinel.DEFAULT) for a in names
+            ]
+            return updated.with_changes(names=fixed)
+
+    return module.visit(_ImportFixer())
+
+
+def main(paths: list[str]) -> int:
+    total_migrated = 0
+    total_residual: list[str] = []
+    for p in paths:
+        path = Path(p)
+        src = path.read_text()
+        mod = cst.parse_module(src)
+        tx = _MainReturnTransformer()
+        new = mod.visit(tx)
+        if tx.migrated:
+            new = _ensure_return_import(new)
+        if new.code != src:
+            path.write_text(new.code)
+        if tx.migrated or tx.residual:
+            print(
+                f"{p}: migrated={tx.migrated} "
+                f"skipped_existing_return={tx.skipped_existing_return} "
+                f"residual={len(tx.residual)}"
+            )
+        total_migrated += tx.migrated
+        total_residual += [f"{p}: {r}" for r in tx.residual]
+    print(f"\nTOTAL migrated Main() sites: {total_migrated}")
+    if total_residual:
+        print(f"RESIDUAL (hand-migrate, gate will flag): {len(total_residual)}")
+        for r in total_residual:
+            print(f"  {r}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))

From db9cff34305d2256bf7237463f79569b99e398cd Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sat, 16 May 2026 11:30:14 -0600
Subject: [PATCH 063/136] Phase 3b S1a: generalize _selene_harness to accept
 explicit Return (derive measurement_N keys from returned CRegs OR -- pre-3b
 -- implicit result CRegs; strict on non-CReg returns); codemod now also
 matches qualified pecos.slr.Main + mirrors its qualifier for Return. No-op
 for current tree (1129 pass, audit 31/31).

---
 .../slr_tests/ast_guppy/_selene_harness.py    | 34 +++++++++++++++----
 scripts/migrate_implicit_return.py            | 21 ++++++++++--
 2 files changed, 46 insertions(+), 9 deletions(-)

diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py
index 2dbf2d5ac..2491bfa92 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py
@@ -34,13 +34,12 @@
 
 from pecos import Guppy, selene_engine, sim
 from pecos.slr import SlrConverter
-from pecos.slr.ast import slr_to_ast
+from pecos.slr.ast import RegisterDecl, slr_to_ast
 from pecos.slr.ast.codegen.entry_wrapper import build_no_arg_entry_wrapper
 
 if TYPE_CHECKING:
     import pecos_rslib
     from pecos.slr import Block
-    from pecos.slr.ast import RegisterDecl
 
 
 _DEFAULT_SHOTS = 100
@@ -68,10 +67,33 @@ def run_ast_guppy_via_selene(
     program = slr_to_ast(slr_program)
 
     wrapper, info = build_no_arg_entry_wrapper(program)
-    if not info.result_cregs or info.explicit_return is not None:
+    # The entry tuple's bit order is the source of truth for the
+    # `measurement_N` keys. It comes from EITHER an explicit `Return(...)`
+    # (Phase 3b: the returned CRegs, in listed order) OR -- still
+    # supported until 3b removes it -- the v1 implicit result-CReg set
+    # (declaration order). Returning the same CRegs in the same order is
+    # byte-identical to the implicit path (proven), so migrated and
+    # not-yet-migrated programs both produce identical records.
+    if info.explicit_return is not None:
+        record_cregs: list[RegisterDecl] = []
+        for value in info.explicit_return.values:
+            name = value if isinstance(value, str) else getattr(value, "name", None)
+            if name in info.all_creg_sizes:
+                record_cregs.append(
+                    RegisterDecl(name=name, size=info.all_creg_sizes[name], is_result=True),
+                )
+    else:
+        record_cregs = info.result_cregs
+    if not record_cregs:
+        # Strict (Codex S1-approach review): an explicit `Return(...)`
+        # with no CRegs (e.g. `Return(q)`) has no measurement record --
+        # fail loudly rather than silently mis-shape the result table.
         msg = (
-            "Selene behavioral test requires at least one result CReg and no explicit Return. "
-            "v1 acceptance Selene tests should declare CRegs and write measurement bits into them."
+            "Selene behavioral test requires at least one returned CReg "
+            "(explicit `Return(<creg>...)`, or -- pre-3b -- an implicit "
+            "result CReg). Returning only QRegs/values yields no "
+            "measurement record. Declare CRegs and write measurement "
+            "bits into them."
         )
         raise ValueError(msg)
 
@@ -82,7 +104,7 @@ def run_ast_guppy_via_selene(
 
     result = sim(Guppy(entry_func)).classical(selene_engine()).qubits(max(total_qubits, 1)).seed(seed).run(shots)
 
-    return _shot_records(result, _result_keys(info.result_cregs))
+    return _shot_records(result, _result_keys(record_cregs))
 
 
 def _result_keys(cregs: list[RegisterDecl]) -> list[str]:
diff --git a/scripts/migrate_implicit_return.py b/scripts/migrate_implicit_return.py
index 81b3b7981..817b60899 100644
--- a/scripts/migrate_implicit_return.py
+++ b/scripts/migrate_implicit_return.py
@@ -51,7 +51,13 @@ def _is_result_creg_call(call: cst.Call) -> bool:
         return True
 
     def leave_Call(self, original: cst.Call, updated: cst.Call) -> cst.BaseExpression:
-        if not m.matches(updated.func, m.Name("Main")):
+        # Match bare `Main(...)` AND any qualified form (`pecos.slr.Main(...)`,
+        # `slr.Main(...)`) -- the func is then an Attribute whose final attr
+        # is `Main` (Codex S1-approach review: qualified calls were missed).
+        if not m.matches(
+            updated.func,
+            m.Name("Main") | m.Attribute(attr=m.Name("Main")),
+        ):
             return updated
 
         has_return = any(
@@ -80,14 +86,23 @@ def leave_Call(self, original: cst.Call, updated: cst.Call) -> cst.BaseExpressio
                 self.residual.append("Main(*...) / non-walrus CRegs")
             return updated
 
-        self._needs_return_import = True
         self.migrated += 1
+        # Mirror the qualifier of the matched `Main` call: `pecos.slr.Main`
+        # -> `pecos.slr.Return` (no import needed); bare `Main` -> bare
+        # `Return` (+ ensure `from pecos.slr import Return`).
+        if isinstance(updated.func, cst.Attribute):
+            return_func: cst.BaseExpression = updated.func.with_changes(
+                attr=cst.Name("Return"),
+            )
+        else:
+            return_func = cst.Name("Return")
+            self._needs_return_import = True
         # Trailing comma on the appended arg preserves the "magic trailing
         # comma" so the formatter keeps the call's original multi-line vs
         # single-line shape (minimal diff -- no whole-call reflow).
         ret = cst.Arg(
             value=cst.Call(
-                func=cst.Name("Return"),
+                func=return_func,
                 args=[cst.Arg(value=cst.Name(n)) for n in result_cregs],
             ),
             comma=cst.Comma(),

From 5c0fe73cd608a3dec25429342b8c9e5988e98c6c Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sat, 16 May 2026 11:51:59 -0600
Subject: [PATCH 064/136] Phase 3b gate-hardening: implicit-return warning
 detector now also catches whole-register inline CRegs (Measure(q) >
 CReg('c',n) stores the CReg itself in cout, not a Bit) -- was
 under-detecting; suite green (1129), warnings non-fatal.

---
 .../quantum-pecos/src/pecos/slr/slr_converter.py   | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/slr_converter.py b/python/quantum-pecos/src/pecos/slr/slr_converter.py
index beb808360..eb94591b9 100644
--- a/python/quantum-pecos/src/pecos/slr/slr_converter.py
+++ b/python/quantum-pecos/src/pecos/slr/slr_converter.py
@@ -400,11 +400,17 @@ def _slr_walk_for_inline_measure_target(ops, declared_creg_names: set[str]) -> b
         if type_name == "Measure":
             cout = getattr(op, "cout", None)
             if cout is not None:
-                for bit in cout:
-                    reg = getattr(bit, "reg", None)
-                    reg_name = getattr(reg, "sym", None) if reg is not None else None
+                for target in cout:
+                    # `Measure(q[i]) > c[j]` puts a Bit in cout (its CReg is
+                    # `bit.reg`); whole-register `Measure(q) > CReg("c", n)`
+                    # puts the CReg itself in cout (no `.reg`). Both forms
+                    # define an inline result CReg when `c` is not declared
+                    # in `Main(...)` -- the v1 emitter infers it
+                    # `is_result=True` and implicitly returns it.
+                    reg = getattr(target, "reg", None)
+                    reg_name = getattr(reg, "sym", None) if reg is not None else getattr(target, "sym", None)
                     if reg_name is not None and reg_name not in declared_creg_names:
-                        return True  # Inline target -- inferred is_result=True.
+                        return True
         elif type_name == "If":
             # If has `.ops` (Then-branch) and `.else_block` (an Else Block or None).
             if _slr_walk_for_inline_measure_target(getattr(op, "ops", ()), declared_creg_names):

From 7fef59d64f98baa2ea7e4a5e80cdb9cac66f37d4 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sat, 16 May 2026 12:37:42 -0600
Subject: [PATCH 065/136] Phase 3b S1b: harden implicit-return detector
 (recursive cout -- whole-register + slice inline CRegs); re-apply per-case
 audit warning enforcement; migrate implicit-return programs to explicit
 Return across ast_guppy/QASM-regression/legacy-guppy/unit-slr/test_partial
 (+scoped block.extend(Return) for qeclib QASM-byte-identity, +Stim/QC helper
 returns). Audit 31/31; strict gate 1131 pass; QASM byte-identical; ruff+black
 clean.

---
 .../src/pecos/slr/slr_converter.py            |  35 ++-
 .../test_logical_steane_code_program.py       |   4 +-
 .../steane/meas/test_destructive_meas.py      |   6 +-
 .../qeclib/steane/meas/test_measure_x.py      |   3 +-
 .../qeclib/steane/meas/test_measure_z.py      |   3 +-
 .../qeclib/steane/preps/test_pauli_states.py  |   4 +-
 .../qeclib/steane/qec/test_qec_3parallel.py   |  16 +-
 .../syn_extract/test_six_check_nonflagging.py |   3 +-
 .../test_three_parallel_flagging.py           |   4 +-
 .../random_cases/test_control_flow.py         |  11 +-
 .../test_qasm/random_cases/test_permute.py    |   6 +-
 .../test_qasm/random_cases/test_slr_phys.py   |  25 +-
 .../tests/slr_tests/ast_guppy/audit_runner.py |  52 ++--
 .../slr_tests/ast_guppy/test_ast_hugr.py      |  15 +-
 .../ast_guppy/test_block_call_smoke.py        | 265 +++++++++++-------
 .../ast_guppy/test_deprecation_warnings.py    |  19 ++
 .../tests/slr_tests/ast_guppy/test_print.py   |  42 ++-
 .../ast_guppy/test_qeclib_selene_corpus.py    |   9 +-
 .../slr_tests/ast_guppy/test_v1_acceptance.py |  14 +-
 .../slr_tests/ast_guppy/test_v1_behavioral.py |  18 +-
 .../slr_tests/guppy/test_array_patterns.py    |   6 +-
 .../guppy/test_conditional_resources.py       |   3 +-
 .../slr_tests/guppy/test_hugr_compilation.py  |  13 +-
 .../guppy/test_linearity_patterns.py          |   7 +-
 .../slr_tests/guppy/test_loop_generation.py   |   8 +-
 .../guppy/test_measurement_optimization.py    |   3 +-
 .../guppy/test_multi_qubit_measurements.py    |   7 +-
 .../guppy/test_partial_array_returns.py       |   6 +-
 .../guppy/test_partial_consumption.py         |   8 +-
 .../guppy/test_simple_slr_to_guppy.py         |   4 +-
 .../regression/random_cases/test_slr_phys.py  |  25 +-
 .../slr_tests/pecos/unit/slr/conftest.py      |   7 +-
 .../pecos/unit/slr/test_basic_permutation.py  |   5 +-
 .../unit/slr/test_complex_permutation.py      |   3 +-
 .../unit/slr/test_conversion_with_qasm.py     |  21 +-
 .../pecos/unit/slr/test_creg_permutation.py   |   1 +
 .../pecos/unit/slr/test_guppy_generation.py   |   6 +-
 .../test_guppy_generation_comprehensive.py    |   6 +-
 .../unit/slr/test_measurement_unrolling.py    |   7 +-
 .../unit/slr/test_pythonic_syntax_example.py  |   3 +-
 .../slr/test_quantum_circuit_conversion.py    |  19 +-
 .../unit/slr/test_register_permutation.py     |   3 +-
 .../pecos/unit/slr/test_stim_conversion.py    |  22 +-
 .../tests/slr_tests/test_partial.py           |   3 +-
 44 files changed, 532 insertions(+), 218 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/slr_converter.py b/python/quantum-pecos/src/pecos/slr/slr_converter.py
index eb94591b9..065c451b8 100644
--- a/python/quantum-pecos/src/pecos/slr/slr_converter.py
+++ b/python/quantum-pecos/src/pecos/slr/slr_converter.py
@@ -363,7 +363,7 @@ def _slr_block_relies_on_implicit_return(block) -> bool:
        return tuple:
        a. A declared CReg in `block.vars` with `result=True` (the default) --
           exposed even if never measured (auto-init to all-False).
-       b. A CReg referenced as a `Measure(...) > c[i]` target where `c` is
+       b. A CReg referenced as a `Measure(...) > ...` target where `c` is
           NOT in `block.vars` -- inline CRegs inferred at AST time get
           `is_result=True` automatically.
 
@@ -399,18 +399,8 @@ def _slr_walk_for_inline_measure_target(ops, declared_creg_names: set[str]) -> b
         type_name = type(op).__name__
         if type_name == "Measure":
             cout = getattr(op, "cout", None)
-            if cout is not None:
-                for target in cout:
-                    # `Measure(q[i]) > c[j]` puts a Bit in cout (its CReg is
-                    # `bit.reg`); whole-register `Measure(q) > CReg("c", n)`
-                    # puts the CReg itself in cout (no `.reg`). Both forms
-                    # define an inline result CReg when `c` is not declared
-                    # in `Main(...)` -- the v1 emitter infers it
-                    # `is_result=True` and implicitly returns it.
-                    reg = getattr(target, "reg", None)
-                    reg_name = getattr(reg, "sym", None) if reg is not None else getattr(target, "sym", None)
-                    if reg_name is not None and reg_name not in declared_creg_names:
-                        return True
+            if cout is not None and _slr_measure_target_has_inline_creg(cout, declared_creg_names):
+                return True
         elif type_name == "If":
             # If has `.ops` (Then-branch) and `.else_block` (an Else Block or None).
             if _slr_walk_for_inline_measure_target(getattr(op, "ops", ()), declared_creg_names):
@@ -428,6 +418,25 @@ def _slr_walk_for_inline_measure_target(ops, declared_creg_names: set[str]) -> b
     return False
 
 
+def _slr_measure_target_has_inline_creg(target, declared_creg_names: set[str]) -> bool:
+    """True if a Measure cout target tree references an undeclared CReg.
+
+    SLR Measure cout shapes vary by target:
+    - `Measure(q[i]) > c[j]` stores a Bit (`bit.reg` names the CReg).
+    - `Measure(q) > CReg("c", n)` stores the CReg itself.
+    - `Measure(q) > c[i:j]` stores a list of Bit objects inside the cout tuple.
+
+    All three are implicit-return sources when the CReg is not declared in
+    `Main(...)`.
+    """
+    if isinstance(target, (list, tuple)):
+        return any(_slr_measure_target_has_inline_creg(item, declared_creg_names) for item in target)
+
+    reg = getattr(target, "reg", None)
+    reg_name = getattr(reg, "sym", None) if reg is not None else getattr(target, "sym", None)
+    return reg_name is not None and reg_name not in declared_creg_names
+
+
 _IMPLICIT_RETURN_WARNING_MSG = (
     "Implicit return of result-flagged CRegs from `Main(...)` is deprecated "
     "and will be removed in the SLR v2 breaking transition (Phase 3b). Add "
diff --git a/python/quantum-pecos/tests/pecos/regression/test_qasm/examples/test_logical_steane_code_program.py b/python/quantum-pecos/tests/pecos/regression/test_qasm/examples/test_logical_steane_code_program.py
index 87fb61868..34bb09c6f 100644
--- a/python/quantum-pecos/tests/pecos/regression/test_qasm/examples/test_logical_steane_code_program.py
+++ b/python/quantum-pecos/tests/pecos/regression/test_qasm/examples/test_logical_steane_code_program.py
@@ -13,7 +13,7 @@
 
 from collections.abc import Callable
 
-from pecos.slr import Barrier, CReg, If, Main
+from pecos.slr import Barrier, CReg, If, Main, Return
 from pecos.slr.qeclib.steane.steane_class import Steane
 
 
@@ -48,6 +48,7 @@ def telep(prep_basis: str, meas_basis: str) -> Main:
         If(m_bell[0] == 0).Then(sout.z()),
         # Final output stored in `m_out[0]`
         sout.m(meas_basis, m_out[0]),
+        Return(m_bell, m_out),
     )
 
 
@@ -100,6 +101,7 @@ def t_gate(prep_basis: str, meas_basis: str) -> Main:
         If(sin.t_meas == 1).Then(sin.sz()),
         # Final output stored in `m_out[1]`
         sin.m(meas_basis, m_out[1]),
+        Return(m_reject, m_t, m_out),
     )
 
 
diff --git a/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/steane/meas/test_destructive_meas.py b/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/steane/meas/test_destructive_meas.py
index e202da4ef..41e911e17 100644
--- a/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/steane/meas/test_destructive_meas.py
+++ b/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/steane/meas/test_destructive_meas.py
@@ -13,7 +13,7 @@
 
 from collections.abc import Callable
 
-from pecos.slr import CReg, QReg
+from pecos.slr import CReg, QReg, Return
 from pecos.slr.qeclib.steane.meas.destructive_meas import (
     MeasDecode,
     Measure,
@@ -32,6 +32,7 @@ def test_MeasureX(compare_qasm: Callable[..., None]) -> None:
 
     for barrier in [True, False]:
         block = MeasureX(q, meas_creg, log_raw, barrier=barrier)
+        block.extend(Return(meas_creg, log_raw))
         compare_qasm(block, barrier)
 
 
@@ -43,6 +44,7 @@ def test_MeasureY(compare_qasm: Callable[..., None]) -> None:
 
     for barrier in [True, False]:
         block = MeasureY(q, meas_creg, log_raw, barrier=barrier)
+        block.extend(Return(meas_creg, log_raw))
         compare_qasm(block, barrier)
 
 
@@ -54,6 +56,7 @@ def test_MeasureZ(compare_qasm: Callable[..., None]) -> None:
 
     for barrier in [True, False]:
         block = MeasureZ(q, meas_creg, log_raw, barrier=barrier)
+        block.extend(Return(meas_creg, log_raw))
         compare_qasm(block, barrier)
 
 
@@ -65,6 +68,7 @@ def test_Measure(compare_qasm: Callable[..., None]) -> None:
 
     for meas_basis in ["X", "Y", "Z"]:
         block = Measure(q, meas_creg, log_raw, meas_basis=meas_basis)
+        block.extend(Return(meas_creg, log_raw))
         compare_qasm(block, meas_basis)
 
 
diff --git a/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/steane/meas/test_measure_x.py b/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/steane/meas/test_measure_x.py
index c7f611ccc..6ad397dde 100644
--- a/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/steane/meas/test_measure_x.py
+++ b/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/steane/meas/test_measure_x.py
@@ -13,7 +13,7 @@
 
 from collections.abc import Callable
 
-from pecos.slr import CReg, QReg
+from pecos.slr import CReg, QReg, Return
 from pecos.slr.qeclib.steane.meas.measure_x import NoFlagMeasureX
 
 
@@ -24,4 +24,5 @@ def test_MeasureX(compare_qasm: Callable[..., None]) -> None:
     out = CReg("out_test", 1)
 
     block = NoFlagMeasureX(q, a, out)
+    block.extend(Return(out))
     compare_qasm(block)
diff --git a/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/steane/meas/test_measure_z.py b/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/steane/meas/test_measure_z.py
index 768fdd30f..53f78b8a4 100644
--- a/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/steane/meas/test_measure_z.py
+++ b/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/steane/meas/test_measure_z.py
@@ -13,7 +13,7 @@
 
 from collections.abc import Callable
 
-from pecos.slr import CReg, QReg
+from pecos.slr import CReg, QReg, Return
 from pecos.slr.qeclib.steane.meas.measure_z import NoFlagMeasureZ
 
 
@@ -24,4 +24,5 @@ def test_MeasureX(compare_qasm: Callable[..., None]) -> None:
     out = CReg("out_test", 1)
 
     block = NoFlagMeasureZ(q, a, out)
+    block.extend(Return(out))
     compare_qasm(block)
diff --git a/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/steane/preps/test_pauli_states.py b/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/steane/preps/test_pauli_states.py
index b51375fb0..39d460af0 100644
--- a/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/steane/preps/test_pauli_states.py
+++ b/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/steane/preps/test_pauli_states.py
@@ -13,7 +13,7 @@
 
 from collections.abc import Callable
 
-from pecos.slr import CReg, QReg
+from pecos.slr import CReg, QReg, Return
 from pecos.slr.qeclib.steane.preps.pauli_states import (
     LogZeroRot,
     PrepEncodingFTZero,
@@ -37,6 +37,7 @@ def test_PrepZeroVerify(compare_qasm: Callable[..., None]) -> None:
     init_bit = CReg("init_bit", 1)
     for reset_ancilla in [True, False]:
         block = PrepZeroVerify(q, a[0], init_bit[0], reset_ancilla=reset_ancilla)
+        block.extend(Return(init_bit))
         compare_qasm(block, reset_ancilla)
 
 
@@ -68,6 +69,7 @@ def test_PrepRUS(compare_qasm: Callable[..., None]) -> None:
                     state,
                     first_round_reset=first_round_reset,
                 )
+                block.extend(Return(init))
                 compare_qasm(block, limit, state, first_round_reset)
 
 
diff --git a/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/steane/qec/test_qec_3parallel.py b/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/steane/qec/test_qec_3parallel.py
index 4102f5d34..cf1826259 100644
--- a/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/steane/qec/test_qec_3parallel.py
+++ b/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/steane/qec/test_qec_3parallel.py
@@ -13,7 +13,7 @@
 
 from collections.abc import Callable
 
-from pecos.slr import CReg, QReg
+from pecos.slr import CReg, QReg, Return
 from pecos.slr.qeclib.steane.qec.qec_3parallel import ParallelFlagQECActiveCorrection
 
 
@@ -47,4 +47,18 @@ def test_ParallelFlagQECActiveCorrection(compare_qasm: Callable[..., None]) -> N
         pf[1],
         scratch,
     )
+    block.extend(
+        Return(
+            flag_x,
+            flag_z,
+            flags,
+            syn_x,
+            syn_z,
+            last_raw_syn_x,
+            last_raw_syn_z,
+            syndromes,
+            pf,
+            scratch,
+        ),
+    )
     compare_qasm(block)
diff --git a/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/steane/syn_extract/test_six_check_nonflagging.py b/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/steane/syn_extract/test_six_check_nonflagging.py
index a07004242..fb8b8424f 100644
--- a/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/steane/syn_extract/test_six_check_nonflagging.py
+++ b/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/steane/syn_extract/test_six_check_nonflagging.py
@@ -13,7 +13,7 @@
 
 from collections.abc import Callable
 
-from pecos.slr import CReg, QReg
+from pecos.slr import CReg, QReg, Return
 from pecos.slr.qeclib.steane.syn_extract.six_check_nonflagging import SixUnflaggedSyn
 
 
@@ -25,4 +25,5 @@ def test_SixUnflaggedSyn(compare_qasm: Callable[..., None]) -> None:
     syn_z = CReg("syn_z_test", 3)
 
     block = SixUnflaggedSyn(q, a, syn_x, syn_z)
+    block.extend(Return(syn_x, syn_z))
     compare_qasm(block)
diff --git a/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/steane/syn_extract/test_three_parallel_flagging.py b/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/steane/syn_extract/test_three_parallel_flagging.py
index 9f7b9c951..9a8d3465f 100644
--- a/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/steane/syn_extract/test_three_parallel_flagging.py
+++ b/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/steane/syn_extract/test_three_parallel_flagging.py
@@ -13,7 +13,7 @@
 
 from collections.abc import Callable
 
-from pecos.slr import CReg, QReg
+from pecos.slr import CReg, QReg, Return
 from pecos.slr.qeclib.steane.syn_extract.three_parallel_flagging import (
     ThreeParallelFlaggingXZZ,
     ThreeParallelFlaggingZXX,
@@ -39,6 +39,7 @@ def test_ThreeParallelFlaggingXZZ(compare_qasm: Callable[..., None]) -> None:
         last_raw_syn_x,
         last_raw_syn_z,
     )
+    block.extend(Return(flag_x, flag_z, flags, last_raw_syn_x, last_raw_syn_z))
     compare_qasm(block)
 
 
@@ -61,4 +62,5 @@ def test_ThreeParallelFlaggingZXX(compare_qasm: Callable[..., None]) -> None:
         last_raw_syn_x,
         last_raw_syn_z,
     )
+    block.extend(Return(flag_x, flag_z, flags, last_raw_syn_x, last_raw_syn_z))
     compare_qasm(block)
diff --git a/python/quantum-pecos/tests/pecos/regression/test_qasm/random_cases/test_control_flow.py b/python/quantum-pecos/tests/pecos/regression/test_qasm/random_cases/test_control_flow.py
index e6037aab7..6e99209e7 100644
--- a/python/quantum-pecos/tests/pecos/regression/test_qasm/random_cases/test_control_flow.py
+++ b/python/quantum-pecos/tests/pecos/regression/test_qasm/random_cases/test_control_flow.py
@@ -13,7 +13,7 @@
 
 from collections.abc import Callable
 
-from pecos.slr import Block, CReg, If, Main, Parallel, QReg, Repeat
+from pecos.slr import Block, CReg, If, Main, Parallel, QReg, Repeat, Return
 from pecos.slr.qeclib import qubit as qb
 
 
@@ -25,6 +25,7 @@ def test_phys_teleport(compare_qasm: Callable[..., None]) -> None:
         qb.H(q[0]),
         qb.CX(q[0], q[1]),
         qb.Measure(q) > c,
+        Return(c),
     )
 
     compare_qasm(prog, filename="phys.teleport")
@@ -44,6 +45,7 @@ def test_phys_tele_block_block(compare_qasm: Callable[..., None]) -> None:
                 qb.H(q[1]),
             ),
         ),
+        Return(c),
     )
 
     compare_qasm(prog, filename="phys.tele_block_block")
@@ -60,6 +62,7 @@ def test_phys_tele_if(compare_qasm: Callable[..., None]) -> None:
         If(c == 0).Then(
             qb.H(q[0]),
         ),
+        Return(c),
     )
 
     compare_qasm(prog, filename="phys.tele_if")
@@ -79,6 +82,7 @@ def test_phys_tele_if_block_block(compare_qasm: Callable[..., None]) -> None:
                 qb.H(q[1]),
             ),
         ),
+        Return(c),
     )
 
     compare_qasm(prog, filename="phys.tele_if_block_block")
@@ -102,6 +106,7 @@ def test_phys_tele_block_telep_block(compare_qasm: Callable[..., None]) -> None:
                 qb.H(q[0]),
             ),
         ),
+        Return(c, c2),
     )
 
     compare_qasm(prog, filename="phys.tele_block_telep_block")
@@ -117,6 +122,7 @@ def test_phys_repeat(compare_qasm: Callable[..., None]) -> None:
             qb.CX(q[0], q[1]),
             qb.Measure(q) > c,
         ),
+        Return(c),
     )
 
     compare_qasm(prog, filename="phys.tele_repeat")
@@ -136,6 +142,7 @@ def test_phys_parallel() -> None:
             qb.Y(q[3]),
         ),
         qb.Measure(q) > c,
+        Return(c),
     )
 
     qasm = SlrConverter(prog).qasm()
@@ -168,6 +175,7 @@ def test_phys_nested_parallel() -> None:
             qb.Z(q[3]),
         ),
         qb.Measure(q) > c,
+        Return(c),
     )
 
     qasm = SlrConverter(prog).qasm()
@@ -198,6 +206,7 @@ def test_phys_parallel_in_if() -> None:
             ),
         ),
         qb.Measure(q[1:4]) > c[1:4],
+        Return(c),
     )
 
     qasm = SlrConverter(prog).qasm()
diff --git a/python/quantum-pecos/tests/pecos/regression/test_qasm/random_cases/test_permute.py b/python/quantum-pecos/tests/pecos/regression/test_qasm/random_cases/test_permute.py
index 8df835e7d..bf42ad276 100644
--- a/python/quantum-pecos/tests/pecos/regression/test_qasm/random_cases/test_permute.py
+++ b/python/quantum-pecos/tests/pecos/regression/test_qasm/random_cases/test_permute.py
@@ -11,7 +11,7 @@
 
 """Testing SLR->QASM permute cases."""
 
-from pecos.slr import Block, CReg, Main, Permute, SlrConverter
+from pecos.slr import Block, CReg, Main, Permute, Return, SlrConverter
 from pecos.slr.qeclib.steane.steane_class import Steane
 
 
@@ -25,6 +25,7 @@ def test_permute1() -> None:
         Permute(a.a, b.a),
         a.mx(meas[0]),
         b.my(meas[1]),
+        Return(meas),
     )
 
     qasm = SlrConverter(prog).qasm()
@@ -54,6 +55,7 @@ def my_permute(a: Steane, b: Steane) -> Block:
         my_permute(a, b),
         a.mx(meas[0]),
         b.my(meas[1]),
+        Return(meas),
     )
 
     qasm = SlrConverter(prog).qasm()
@@ -74,6 +76,7 @@ def test_permute3() -> None:
         b := Steane("b"),
         meas := CReg("meas", 1),
         a.px(),
+        Return(meas),
     )
     for _i in range(1):
         prog.extend(
@@ -106,6 +109,7 @@ def test_permute4() -> None:
         b := Steane("b"),
         meas := CReg("meas", 1),
         a.px(),
+        Return(meas),
     )
     for _i in range(1):
         prog.extend(
diff --git a/python/quantum-pecos/tests/pecos/regression/test_qasm/random_cases/test_slr_phys.py b/python/quantum-pecos/tests/pecos/regression/test_qasm/random_cases/test_slr_phys.py
index 1a6d81387..4ca583ca9 100644
--- a/python/quantum-pecos/tests/pecos/regression/test_qasm/random_cases/test_slr_phys.py
+++ b/python/quantum-pecos/tests/pecos/regression/test_qasm/random_cases/test_slr_phys.py
@@ -1,20 +1,7 @@
 """Test SLR to physical quantum circuit compilation for various cases."""
 
 import pytest
-from pecos.slr import (
-    Barrier,
-    Bit,
-    Block,
-    Comment,
-    CReg,
-    If,
-    Main,
-    Permute,
-    QReg,
-    Qubit,
-    Repeat,
-    SlrConverter,
-)
+from pecos.slr import Barrier, Bit, Block, Comment, CReg, If, Main, Permute, QReg, Qubit, Repeat, Return, SlrConverter
 from pecos.slr.qeclib import qubit as p
 from pecos.slr.qeclib.steane.steane_class import Steane
 
@@ -62,6 +49,7 @@ def telep(prep_basis: str, meas_basis: str) -> str:
         If(m_bell[0] == 0).Then(sout.z()),
         # Final output stored in `m_out[0]`
         sout.m(meas_basis, m_out[0]),
+        Return(m_bell, m_out),
     )
 
 
@@ -73,6 +61,7 @@ def test_bell() -> None:
         p.H(q[0]),
         p.CX(q[0], q[1]),
         p.Measure(q) > m,
+        Return(m),
     )
 
     qasm = (
@@ -98,6 +87,7 @@ def test_bell_qir() -> None:
         p.H(q[0]),
         p.CX(q[0], q[1]),
         p.Measure(q) > m,
+        Return(m),
     )
 
     qir = SlrConverter(prog).qir()
@@ -113,6 +103,7 @@ def test_bell_qreg_qir() -> None:
         p.H(q),
         p.CX(q[0], q[1]),
         p.Measure(q) > m,
+        Return(m),
     )
 
     qir = SlrConverter(prog).qir()
@@ -139,6 +130,7 @@ def __init__(self, q0: Qubit, q1: Qubit, m0: Bit, m1: Bit) -> None:
         m := CReg("m", 2),
         c := CReg("c", 4),
         If(c == 1).Then(Bell(q0=q[0], q1=q[1], m0=m[0], m1=m[1])),
+        Return(m, c),
     )
 
     qasm = (
@@ -171,6 +163,7 @@ def test_strange_program() -> None:
         c.set(b & 1),
         Permute([q[0], q[1]], [q[1], q[0]]),
         p.H(q[0]),
+        Return(c, b),
     )
 
     qasm = (
@@ -225,6 +218,7 @@ def test_control_flow_qir() -> None:
         Barrier(q[1], q[0]),
         p.RX[0.3](q[0]),
         p.Measure(q) > m,
+        Return(m),
     )
     qir = SlrConverter(prog).qir()
     assert "__quantum__qis__h__body" in qir
@@ -241,6 +235,7 @@ def test_plus_qir() -> None:
         m.set(2),
         n.set(2),
         o.set(m + n),
+        Return(m, n, o),
     )
     qir = SlrConverter(prog).qir()
     assert "add" in qir
@@ -259,6 +254,7 @@ def test_nested_xor_qir() -> None:
         n.set(2),
         o.set(2),
         p[0].set((m[0] ^ n[0]) ^ o[0]),
+        Return(m, n, o, p),
     )
     qir = SlrConverter(prog).qir()
     assert "xor" in qir
@@ -275,6 +271,7 @@ def test_minus_qir() -> None:
         m.set(2),
         n.set(2),
         o.set(m - n),
+        Return(m, n, o),
     )
     qir = SlrConverter(prog).qir()
     assert "sub" in qir
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
index 649723bd6..cc3d665ba 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
@@ -37,25 +37,13 @@
 
 import sys
 import traceback
+import warnings
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
 from pecos.qec.surface import SurfacePatch
 from pecos.qec.surface.schedule import compute_cnot_schedule
-from pecos.slr import (
-    Barrier,
-    Block,
-    CReg,
-    For,
-    If,
-    LoopVar,
-    Main,
-    Parallel,
-    QReg,
-    Repeat,
-    SlrConverter,
-    While,
-)
+from pecos.slr import Barrier, Block, CReg, For, If, LoopVar, Main, Parallel, QReg, Repeat, Return, SlrConverter, While
 from pecos.slr.qeclib import qubit as qb
 from pecos.slr.qeclib.color488 import Color488Patch
 from pecos.slr.qeclib.generic.check import Check
@@ -112,6 +100,7 @@ def _bell() -> Block:
         qb.H(q[0]),
         qb.CX(q[0], q[1]),
         Measure(q) > c,
+        Return(c),
     )
 
 
@@ -123,6 +112,7 @@ def _ghz_three() -> Block:
         qb.CX(q[0], q[1]),
         qb.CX(q[1], q[2]),
         Measure(q) > c,
+        Return(c),
     )
 
 
@@ -133,6 +123,7 @@ def _conditional_correction() -> Block:
         Measure(q[0]) > c[0],
         If(c[0]).Then(qb.X(q[1])),
         Measure(q[1]) > c[1],
+        Return(c),
     )
 
 
@@ -153,6 +144,7 @@ def _legacy_individual_measurements() -> Block:
         Measure(q[1]) > c[1],
         Measure(q[2]) > c[2],
         Measure(q[3]) > c[3],
+        Return(c),
     )
 
 
@@ -168,6 +160,7 @@ def _legacy_multiple_qregs() -> Block:
         qb.CX(q1[0], q2[0]),
         Measure(q1) > c1,
         Measure(q2) > c2,
+        Return(c1, c2),
     )
 
 
@@ -213,6 +206,7 @@ def __init__(self, data: QReg, ancilla: QReg, syndrome: CReg) -> None:
         MeasureAncillas(data, ancilla, syndrome),
         qb.H(data[0]),
         Measure(data) > result,
+        Return(syndrome, result),
     )
 
 
@@ -238,6 +232,7 @@ def __init__(self, q: QReg) -> None:
         c := CReg("c", 2),
         ProcessQubits(q),
         Measure(q) > c,
+        Return(c),
     )
 
 
@@ -274,6 +269,7 @@ def __init__(self, q: QReg, c: CReg) -> None:
         q := QReg("q", 2),
         c := CReg("c", 2),
         OuterBlock(q, c),
+        Return(c),
     )
 
 
@@ -402,6 +398,7 @@ def _examples_parallel_bell_pairs() -> Block:
             ),
         ),
         Measure(q) > c,
+        Return(c),
     )
 
 
@@ -420,6 +417,7 @@ def _examples_measure_register_to_creg() -> Block:
         qb.H(q[2]),
         qb.CX(q[2], q[3]),
         Measure(q) > c,
+        Return(c),
     )
 
 
@@ -429,6 +427,7 @@ def _qeclib_generic_check_xyz() -> Block:
         q := QReg("q", 4),
         c := CReg("c", 1),
         Check([q[0], q[1], q[2]], "XYZ", q[3], c[0], with_barriers=True),
+        Return(c),
     )
 
 
@@ -438,6 +437,7 @@ def _qeclib_generic_check_1flag_ch() -> Block:
         q := QReg("q", 5),
         c := CReg("c", 2),
         Check1Flag([q[0], q[1], q[2]], "XYZ", q[3], q[4], c[0], c[1], with_barriers=True),
+        Return(c),
     )
 
 
@@ -450,6 +450,7 @@ def _qeclib_generic_transversal_cx() -> Block:
         transversal_tq(qb.CX, a, b),
         Measure(a) > c[0:3],
         Measure(b) > c[3:6],
+        Return(c),
     )
 
 
@@ -501,6 +502,7 @@ def _qeclib_color488_syn_extract_bare() -> Block:
         patch,
         syn := CReg("syn", patch.num_data - 1),
         patch.syn_extract_bare(syn),
+        Return(syn),
     )
 
 
@@ -517,6 +519,7 @@ def _docs_for_static_indexing() -> Block:
             qb.H(q[0]),
         ),
         Measure(q) > c,
+        Return(c),
     )
 
 
@@ -533,6 +536,7 @@ def _docs_flat_parallel_h_gates() -> Block:
             qb.H(q[3]),
         ),
         Measure(q) > c,
+        Return(c),
     )
 
 
@@ -548,6 +552,7 @@ def _docs_repeat_state_preserving() -> Block:
             qb.H(q[0]),
         ),
         Measure(q) > c,
+        Return(c),
     )
 
 
@@ -565,6 +570,7 @@ def _docs_while_loop_v2_defer() -> Block:
             qb.H(q[0]),
             Measure(q[0]) > c[0],
         ),
+        Return(c),
     )
 
 
@@ -582,6 +588,7 @@ def _docs_for_loopvar_symbolic_v2_defer() -> Block:
             qb.H(q[i]),
         ),
         Measure(q) > c,
+        Return(c),
     )
 
 
@@ -596,6 +603,7 @@ def _docs_prep_basis_x_v2_defer() -> Block:
         c := CReg("c", 1),
         qb.Prep(q[0], "X"),
         Measure(q) > c,
+        Return(c),
     )
 
 
@@ -610,14 +618,17 @@ def _docs_rotation_rx_probe() -> Block:
         c := CReg("c", 1),
         qb.RX(q[0], 0.5),
         Measure(q) > c,
+        Return(c),
     )
 
 
 def _docs_inline_measure_creg() -> Block:
     """Inline measurement result CReg without a root declaration."""
+    final = CReg("final", 2)
     return Main(
         q := QReg("q", 2),
-        Measure(q) > CReg("final", 2),
+        Measure(q) > final,
+        Return(final),
     )
 
 
@@ -651,6 +662,7 @@ def _docs_surface_syndrome_block18_probe() -> Block:
             Measure(ancilla[1]) > syn[1],
         ),
         Measure(data) > CReg("final", num_data),
+        Return(syn),
     )
 
 
@@ -813,7 +825,15 @@ def _run_case(case: AuditCase) -> AuditResult:
         )
 
     try:
-        SlrConverter(prog).hugr()
+        with warnings.catch_warnings():
+            warnings.simplefilter("default", DeprecationWarning)
+            if case.expected_failure is None:
+                warnings.filterwarnings(
+                    "error",
+                    message=r"Implicit return of result-flagged CRegs",
+                    category=DeprecationWarning,
+                )
+            SlrConverter(prog).hugr()
     except BaseException as exc:
         expected = _expected_result(case, exc)
         if expected is not None:
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
index aead3c4aa..3e71e7099 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
@@ -16,6 +16,7 @@ def test_hugr_compiles_via_ast_guppy_path() -> None:
         qb.H(q[0]),
         qb.CX(q[0], q[1]),
         Measure(q) > c,
+        Return(c),
     )
 
     hugr = SlrConverter(prog).hugr()
@@ -31,6 +32,7 @@ def test_hugr_rejects_while_before_parallel_optimizer_erases_it() -> None:
             qb.H(q[0]),
             Measure(q[0]) > c[0],
         ),
+        Return(c),
     )
 
     with pytest.raises(GuppyCodegenError, match="does not support While loops"):
@@ -59,9 +61,11 @@ def test_hugr_rejects_symbolic_loopvar_indexing_cleanly() -> None:
 
 
 def test_hugr_accepts_inline_measure_creg_result() -> None:
+    final = CReg("final", 2)
     prog = Main(
         q := QReg("q", 2),
-        Measure(q) > CReg("final", 2),
+        Measure(q) > final,
+        Return(final),
     )
 
     hugr = SlrConverter(prog).hugr()
@@ -86,6 +90,7 @@ def test_hugr_returns_no_arg_entrypoint_runnable_via_hugr_adapter() -> None:
         qb.H(q[0]),
         qb.CX(q[0], q[1]),
         Measure(q) > c,
+        Return(c),
     )
 
     package = SlrConverter(prog).hugr()
@@ -125,11 +130,13 @@ def test_hugr_inline_measure_creg_round_trips_through_selene() -> None:
     """
     from pecos import Hugr, selene_engine, sim
 
+    final = CReg("final", 2)
     prog = Main(
         q := QReg("qi", 2),
         qb.H(q[0]),
         qb.CX(q[0], q[1]),
-        Measure(q) > CReg("final", 2),
+        Measure(q) > final,
+        Return(final),
     )
 
     package = SlrConverter(prog).hugr()
@@ -151,13 +158,15 @@ def test_hugr_inline_measure_creg_inside_nested_repeat() -> None:
     """
     from pecos import Hugr, selene_engine, sim
 
+    flag = CReg("flag", 1)
     prog = Main(
         q := QReg("q", 1),
         Repeat(2).block(
             qb.X(q[0]),
-            Measure(q[0]) > CReg("flag", 1),
+            Measure(q[0]) > flag[0],
             qb.Prep(q[0]),
         ),
+        Return(flag),
     )
 
     package = SlrConverter(prog).hugr()
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
index 3abced7c1..ab6d8b9ef 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
@@ -301,52 +301,52 @@ def _assert_uses_block_call(self, prog: object, expected_callee_prefix: str) ->
         ), f"expected '@guppy def {expected_callee_prefix}...' in source, got:\n{guppy_src}"
 
     def test_steane_cx_uses_block_call(self) -> None:
-        from pecos.slr import CReg, Main, QReg
+        from pecos.slr import Main, QReg
         from pecos.slr.qeclib.steane.gates_tq import transversal_tq as steane_tq
 
-        prog = Main(a := QReg("a", 7), b := QReg("b", 7), CReg("c", 14), steane_tq.CX(a, b))
+        prog = Main(a := QReg("a", 7), b := QReg("b", 7), steane_tq.CX(a, b))
         self._assert_uses_block_call(prog, "cx_")
 
     def test_steane_cy_uses_block_call(self) -> None:
-        from pecos.slr import CReg, Main, QReg
+        from pecos.slr import Main, QReg
         from pecos.slr.qeclib.steane.gates_tq import transversal_tq as steane_tq
 
-        prog = Main(a := QReg("a", 7), b := QReg("b", 7), CReg("c", 14), steane_tq.CY(a, b))
+        prog = Main(a := QReg("a", 7), b := QReg("b", 7), steane_tq.CY(a, b))
         self._assert_uses_block_call(prog, "cy_")
 
     def test_steane_cz_uses_block_call(self) -> None:
-        from pecos.slr import CReg, Main, QReg
+        from pecos.slr import Main, QReg
         from pecos.slr.qeclib.steane.gates_tq import transversal_tq as steane_tq
 
-        prog = Main(a := QReg("a", 7), b := QReg("b", 7), CReg("c", 14), steane_tq.CZ(a, b))
+        prog = Main(a := QReg("a", 7), b := QReg("b", 7), steane_tq.CZ(a, b))
         self._assert_uses_block_call(prog, "cz_")
 
     def test_steane_logical_x_uses_block_call(self) -> None:
-        from pecos.slr import CReg, Main, QReg
+        from pecos.slr import Main, QReg
         from pecos.slr.qeclib.steane.gates_sq import paulis as steane_paulis
 
-        prog = Main(q := QReg("q", 7), CReg("c", 7), steane_paulis.X(q))
+        prog = Main(q := QReg("q", 7), steane_paulis.X(q))
         self._assert_uses_block_call(prog, "x_")
 
     def test_steane_logical_y_uses_block_call(self) -> None:
-        from pecos.slr import CReg, Main, QReg
+        from pecos.slr import Main, QReg
         from pecos.slr.qeclib.steane.gates_sq import paulis as steane_paulis
 
-        prog = Main(q := QReg("q", 7), CReg("c", 7), steane_paulis.Y(q))
+        prog = Main(q := QReg("q", 7), steane_paulis.Y(q))
         self._assert_uses_block_call(prog, "y_")
 
     def test_steane_logical_z_uses_block_call(self) -> None:
-        from pecos.slr import CReg, Main, QReg
+        from pecos.slr import Main, QReg
         from pecos.slr.qeclib.steane.gates_sq import paulis as steane_paulis
 
-        prog = Main(q := QReg("q", 7), CReg("c", 7), steane_paulis.Z(q))
+        prog = Main(q := QReg("q", 7), steane_paulis.Z(q))
         self._assert_uses_block_call(prog, "z_")
 
     def test_steane_logical_h_uses_block_call(self) -> None:
-        from pecos.slr import CReg, Main, QReg
+        from pecos.slr import Main, QReg
         from pecos.slr.qeclib.steane.gates_sq import hadamards as steane_h
 
-        prog = Main(q := QReg("q", 7), CReg("c", 7), steane_h.H(q))
+        prog = Main(q := QReg("q", 7), steane_h.H(q))
         self._assert_uses_block_call(prog, "h_")
 
 
@@ -417,7 +417,7 @@ class TestNestedConvertedBlocks:
     """
 
     def _build_nested_program(self) -> object:
-        from pecos.slr import Block, CReg, Main, QReg
+        from pecos.slr import Block, CReg, Main, QReg, Return
         from pecos.slr.qeclib import qubit as qb
         from pecos.slr.qeclib.qubit.measures import Measure
 
@@ -443,6 +443,7 @@ def __init__(self, q: QReg) -> None:
             qb.Prep(outer),
             OuterBlock(outer),
             Measure(outer) > c,
+            Return(c),
         )
 
     def test_nested_block_call_arg_bindings_substitute_to_parent_param(self) -> None:
@@ -470,7 +471,7 @@ def test_nested_block_call_arg_bindings_substitute_to_parent_param(self) -> None
 
     def test_top_level_inner_plus_outer_containing_inner_have_unique_names(self) -> None:
         """Same Block class top-level AND nested must not collide."""
-        from pecos.slr import Block, CReg, Main, QReg
+        from pecos.slr import Block, CReg, Main, QReg, Return
         from pecos.slr.ast import slr_to_ast
         from pecos.slr.qeclib import qubit as qb
         from pecos.slr.qeclib.qubit.measures import Measure
@@ -498,6 +499,7 @@ def __init__(self, q: QReg) -> None:
             InnerBlock(outer),
             OuterBlock(outer),
             Measure(outer) > c,
+            Return(c),
         )
         ast = slr_to_ast(prog)
         decl_names = [d.name for d in ast.block_decls]
@@ -570,7 +572,7 @@ class TestConvertedBlocksInsideParallel:
     """
 
     def test_parallel_with_converted_block_preserves_block_call_via_slr_converter(self) -> None:
-        from pecos.slr import CReg, Main, QReg, SlrConverter
+        from pecos.slr import CReg, Main, QReg, Return, SlrConverter
         from pecos.slr.misc import Parallel
         from pecos.slr.qeclib.qubit.measures import Measure
         from pecos.slr.qeclib.steane.gates_sq.hadamards import H as SteaneH
@@ -580,6 +582,7 @@ def test_parallel_with_converted_block_preserves_block_call_via_slr_converter(se
             c := CReg("c", 7),
             Parallel(SteaneH(q)),
             Measure(q) > c,
+            Return(c),
         )
         guppy_src = SlrConverter(prog).guppy()
         # Pre-fix, Parallel splatted the Steane H body into 7 individual h() calls
@@ -660,14 +663,10 @@ def _build_single_qubit_program(self, *, consumed: bool) -> Program:
             body = (*body, MeasureOp(targets=(SlotRef(allocator="q", index=0),)))
         decl = BlockDecl(
             name="b",
-            inputs=(
-                BlockInput(name="q", effect=effect, type_expr=QubitTypeExpr()),
-            ),
+            inputs=(BlockInput(name="q", effect=effect, type_expr=QubitTypeExpr()),),
             body=body,
         )
-        out_bindings = (
-            () if consumed else (SingleQubitArg(slot=SlotRef(allocator="outer_q", index=1)),)
-        )
+        out_bindings = () if consumed else (SingleQubitArg(slot=SlotRef(allocator="outer_q", index=1)),)
         # For LIVE_PRESERVED, measure outer_q[1] after the call (it's still live).
         # For CONSUMED, outer_q[1] is consumed by the call; measure a different
         # slot (outer_q[0]) so the linearity tracker stays sound.
@@ -779,9 +778,7 @@ def test_single_qubit_mismatched_arg_out_slot_rejected(self) -> None:
 
         decl = BlockDecl(
             name="b",
-            inputs=(
-                BlockInput(name="q", effect=ResourceEffect.LIVE_PRESERVED, type_expr=QubitTypeExpr()),
-            ),
+            inputs=(BlockInput(name="q", effect=ResourceEffect.LIVE_PRESERVED, type_expr=QubitTypeExpr()),),
             body=(),
         )
         prog = Program(
@@ -835,9 +832,7 @@ def test_single_qubit_slot_index_out_of_bounds_rejected(self) -> None:
 
         decl = BlockDecl(
             name="b",
-            inputs=(
-                BlockInput(name="q", effect=ResourceEffect.LIVE_PRESERVED, type_expr=QubitTypeExpr()),
-            ),
+            inputs=(BlockInput(name="q", effect=ResourceEffect.LIVE_PRESERVED, type_expr=QubitTypeExpr()),),
             body=(),
         )
         prog = Program(
@@ -917,9 +912,7 @@ def test_single_bit_renders_array_bool_proxy(self) -> None:
     def test_single_bit_must_be_live_preserved(self) -> None:
         decl = BlockDecl(
             name="b",
-            inputs=(
-                BlockInput(name="out", effect=ResourceEffect.CONSUMED, type_expr=BitTypeExpr()),
-            ),
+            inputs=(BlockInput(name="out", effect=ResourceEffect.CONSUMED, type_expr=BitTypeExpr()),),
             body=(),
         )
         prog = Program(
@@ -966,9 +959,7 @@ def test_single_bit_index_out_of_bounds_rejected(self) -> None:
 
         decl = BlockDecl(
             name="b",
-            inputs=(
-                BlockInput(name="out", effect=ResourceEffect.LIVE_PRESERVED, type_expr=BitTypeExpr()),
-            ),
+            inputs=(BlockInput(name="out", effect=ResourceEffect.LIVE_PRESERVED, type_expr=BitTypeExpr()),),
             body=(),
         )
         prog = Program(
@@ -1420,9 +1411,7 @@ def test_single_qubit_arg_flatten_inlines(self) -> None:
 
         decl = BlockDecl(
             name="b",
-            inputs=(
-                BlockInput(name="q", effect=ResourceEffect.LIVE_PRESERVED, type_expr=QubitTypeExpr()),
-            ),
+            inputs=(BlockInput(name="q", effect=ResourceEffect.LIVE_PRESERVED, type_expr=QubitTypeExpr()),),
             body=(GateOp(gate=GateKind.H, targets=(SlotRef(allocator="q", index=0),)),),
         )
         sq = SingleQubitArg(slot=SlotRef(allocator="outer_q", index=1))
@@ -1559,7 +1548,7 @@ class TestBlockBodyStatementSubstitution:
     """
 
     def test_permute_inside_block_inputs_substitutes_in_both_paths(self) -> None:
-        from pecos.slr import Block, CReg, Main, QReg
+        from pecos.slr import Block, CReg, Main, QReg, Return
         from pecos.slr.ast import slr_to_ast
         from pecos.slr.ast.codegen._block_flatten import flatten_block_calls
         from pecos.slr.ast.nodes import PermuteOp
@@ -1581,6 +1570,7 @@ def __init__(self, q: QReg) -> None:
             qb.Prep(outer),
             SwapBlock(outer),
             Measure(outer) > c,
+            Return(c),
         )
         ast = slr_to_ast(prog)
 
@@ -1631,7 +1621,7 @@ class TestSlrBlockInputsWiring:
 
     def test_slr_block_with_inputs_emits_block_decl_and_call(self) -> None:
         """slr_to_ast on a Main containing a Block with `block_inputs` produces a BlockDecl + BlockCall."""
-        from pecos.slr import CReg, Main, QReg
+        from pecos.slr import CReg, Main, QReg, Return
         from pecos.slr.ast import slr_to_ast
         from pecos.slr.block import Block
         from pecos.slr.qeclib import qubit as qb
@@ -1651,6 +1641,7 @@ def __init__(self, q: QReg) -> None:
             qb.Prep(outer_q),
             BellBlock(outer_q),
             Measure(outer_q) > c,
+            Return(c),
         )
         ast = slr_to_ast(prog)
 
@@ -1676,7 +1667,7 @@ def test_slr_block_inputs_end_to_end_selene_bell_correlation(self) -> None:
         import warnings
 
         from pecos import Hugr, selene_engine, sim
-        from pecos.slr import CReg, Main, QReg, SlrConverter
+        from pecos.slr import CReg, Main, QReg, Return, SlrConverter
         from pecos.slr.block import Block
         from pecos.slr.qeclib import qubit as qb
         from pecos.slr.qeclib.qubit.measures import Measure
@@ -1695,6 +1686,7 @@ def __init__(self, q: QReg) -> None:
             qb.Prep(outer_q),
             BellBlock(outer_q),
             Measure(outer_q) > c,
+            Return(c),
         )
 
         with warnings.catch_warnings():
@@ -1780,7 +1772,7 @@ class TestSlrBlockArgShapeDetectionViaConverter:
     """
 
     def test_single_qubit_input_detected_and_inlined(self) -> None:
-        from pecos.slr import CReg, Main, QReg, SlrConverter
+        from pecos.slr import CReg, Main, QReg, Return, SlrConverter
         from pecos.slr.ast import slr_to_ast
         from pecos.slr.ast.nodes import SingleQubitArg, SlotRef
         from pecos.slr.block import Block
@@ -1801,14 +1793,13 @@ def __init__(self, q) -> None:
             qb.Prep(outer_q),
             SqBlock(outer_q[0]),
             Measure(outer_q) > c,
+            Return(c),
         )
 
         ast = slr_to_ast(prog)
         calls = [s for s in ast.body if isinstance(s, BlockCall)]
         assert len(calls) == 1
-        assert calls[0].arg_bindings == (
-            SingleQubitArg(slot=SlotRef(allocator="outer_q", index=0)),
-        )
+        assert calls[0].arg_bindings == (SingleQubitArg(slot=SlotRef(allocator="outer_q", index=0)),)
 
         guppy_src = SlrConverter(prog).guppy()
         assert re.search(r"def sqblock_\d+\(q: qubit @ owned\) -> qubit:", guppy_src)
@@ -1819,7 +1810,7 @@ def __init__(self, q) -> None:
         assert "block" not in qasm_src.lower()
 
     def test_same_qreg_bundle_detected_and_inlined(self) -> None:
-        from pecos.slr import CReg, Main, QReg, SlrConverter
+        from pecos.slr import CReg, Main, QReg, Return, SlrConverter
         from pecos.slr.ast import slr_to_ast
         from pecos.slr.ast.nodes import QubitBundleArg, SlotRef
         from pecos.slr.block import Block
@@ -1840,6 +1831,7 @@ def __init__(self, d) -> None:
             qb.Prep(outer_q),
             BundleBlock([outer_q[0], outer_q[2]]),
             Measure(outer_q) > c,
+            Return(c),
         )
 
         ast = slr_to_ast(prog)
@@ -1860,7 +1852,7 @@ def __init__(self, d) -> None:
         assert re.search(r"def bundleblock_\d+\(d: array\[qubit, 2\] @ owned\)", SlrConverter(prog).guppy())
 
     def test_cross_qreg_bundle_detected_and_inlined(self) -> None:
-        from pecos.slr import CReg, Main, QReg, SlrConverter
+        from pecos.slr import CReg, Main, QReg, Return, SlrConverter
         from pecos.slr.ast import slr_to_ast
         from pecos.slr.ast.nodes import QubitBundleArg, SlotRef
         from pecos.slr.block import Block
@@ -1884,6 +1876,7 @@ def __init__(self, d) -> None:
             BundleBlock([qa[0], qb_reg[1]]),
             Measure(qa) > c[0:2],
             Measure(qb_reg) > c[2:4],
+            Return(c),
         )
 
         ast = slr_to_ast(prog)
@@ -1909,7 +1902,7 @@ def test_check_shaped_block_all_three_shapes_detected(self) -> None:
         data bundle (live_preserved), a single ancilla `Qubit` (consumed,
         measured in-body), and a single `Bit` write-back (live_preserved).
         """
-        from pecos.slr import CReg, Main, QReg, SlrConverter
+        from pecos.slr import CReg, Main, QReg, Return, SlrConverter
         from pecos.slr.ast import slr_to_ast
         from pecos.slr.ast.nodes import BitRef as AstBitRef
         from pecos.slr.ast.nodes import (
@@ -1949,6 +1942,7 @@ def __init__(self, d, a, out) -> None:
             CheckLike([outer_q[0], outer_q[1]], outer_q[2], c[0]),
             Measure(outer_q[0]) > c[1],
             Measure(outer_q[1]) > c[2],
+            Return(c),
         )
 
         ast = slr_to_ast(prog)
@@ -2003,7 +1997,7 @@ def test_unsupported_input_shapes_rejected_via_converter(
         make_block: str,
         match: str,
     ) -> None:
-        from pecos.slr import CReg, Main, QReg
+        from pecos.slr import CReg, Main, QReg, Return
         from pecos.slr.ast import slr_to_ast
         from pecos.slr.block import Block
         from pecos.slr.vars import LoopVar
@@ -2044,13 +2038,26 @@ def __init__(self, q) -> None:
                 self.q = q
 
         if make_block == "whole_creg":
-            prog = Main(c := CReg("c", 2), WholeCReg(c))
+            prog = Main(
+                c := CReg("c", 2),
+                WholeCReg(c),
+                Return(c),
+            )
         elif make_block == "list_bit":
-            prog = Main(c := CReg("c", 2), ListBit([c[0], c[1]]))
+            prog = Main(
+                c := CReg("c", 2),
+                ListBit([c[0], c[1]]),
+                Return(c),
+            )
         elif make_block == "empty_bundle":
             prog = Main(QReg("o", 1), Empty([]))
         elif make_block == "mixed_bundle":
-            prog = Main(o := QReg("o", 1), c := CReg("c", 1), Mixed([o[0], c[0]]))
+            prog = Main(
+                o := QReg("o", 1),
+                c := CReg("c", 1),
+                Mixed([o[0], c[0]]),
+                Return(c),
+            )
         else:  # symbolic
             prog = Main(o := QReg("o", 2), Sym(o[LoopVar("i")]))
 
@@ -2062,7 +2069,7 @@ def test_duplicate_qubit_in_bundle_rejected(self) -> None:
         (Guppy rejected on linearity; QASM flatten emitted `cx q[0], q[0];`).
         Must reject at SLR -> AST conversion with a clear message.
         """
-        from pecos.slr import Main, QReg
+        from pecos.slr import Main, QReg, Return
         from pecos.slr.ast import slr_to_ast
         from pecos.slr.block import Block
         from pecos.slr.qeclib import qubit as qb
@@ -2083,7 +2090,7 @@ def test_two_single_qubit_inputs_aliased_rejected(self) -> None:
         """Two distinct single-qubit inputs bound to the SAME outer slot is
         the same aliasing bug from the cross-input direction.
         """
-        from pecos.slr import Main, QReg
+        from pecos.slr import Main, QReg, Return
         from pecos.slr.ast import slr_to_ast
         from pecos.slr.block import Block
         from pecos.slr.qeclib import qubit as qb
@@ -2108,7 +2115,7 @@ def test_two_bit_inputs_aliased_rejected(self) -> None:
         """Same outer bit backing two single-bit inputs is lossy during
         body substitution -- reject it too.
         """
-        from pecos.slr import CReg, Main
+        from pecos.slr import CReg, Main, Return
         from pecos.slr.ast import slr_to_ast
         from pecos.slr.block import Block
 
@@ -2123,7 +2130,11 @@ def __init__(self, x, y) -> None:
                 self.x = x
                 self.y = y
 
-        prog = Main(c := CReg("c", 2), TwoBit(c[0], c[0]))
+        prog = Main(
+            c := CReg("c", 2),
+            TwoBit(c[0], c[0]),
+            Return(c),
+        )
         with pytest.raises(ValueError, match=r"bit c\[0\] is also bound by input 'x'"):
             slr_to_ast(prog)
 
@@ -2162,7 +2173,7 @@ def __init__(self, d, a, out) -> None:
         return GoodCheck
 
     def test_scratch_detected_excluded_from_out_bindings(self) -> None:
-        from pecos.slr import CReg, Main, QReg
+        from pecos.slr import CReg, Main, QReg, Return
         from pecos.slr.ast import slr_to_ast
         from pecos.slr.ast.nodes import (
             QubitBundleArg,
@@ -2177,14 +2188,13 @@ def test_scratch_detected_excluded_from_out_bindings(self) -> None:
             c := CReg("c", 1),
             qb.Prep(q),
             good_check([q[0], q[1]], q[2], c[0]),
+            Return(c),
         )
         ast = slr_to_ast(prog)
         call = next(s for s in ast.body if isinstance(s, BlockCall))
         # Scratch `a` is detected as a single-qubit arg and stays in
         # arg_bindings (O2: the 5e.2 alias guard still applies)...
-        assert any(
-            isinstance(a, SingleQubitArg) for a in call.arg_bindings
-        )
+        assert any(isinstance(a, SingleQubitArg) for a in call.arg_bindings)
         # ...but is NOT live-preserved, so it is absent from out_bindings.
         assert call.out_bindings == (
             QubitBundleArg(
@@ -2194,7 +2204,7 @@ def test_scratch_detected_excluded_from_out_bindings(self) -> None:
         )
 
     def test_scratch_flatten_substitutes_to_outer_slot(self) -> None:
-        from pecos.slr import CReg, Main, QReg, SlrConverter
+        from pecos.slr import CReg, Main, QReg, Return, SlrConverter
         from pecos.slr.qeclib import qubit as qb
 
         good_check = self._good_check()
@@ -2203,6 +2213,7 @@ def test_scratch_flatten_substitutes_to_outer_slot(self) -> None:
             c := CReg("c", 1),
             qb.Prep(q),
             good_check([q[0], q[1]], q[2], c[0]),
+            Return(c),
         )
         qasm = SlrConverter(prog).qasm()
         # Param `a` -> outer slot q[2]; data bundle d[0]/d[1] -> q[0]/q[1].
@@ -2216,7 +2227,7 @@ def test_scratch_guppy_internal_alloc_no_param(self) -> None:
         neither a function parameter nor a positional call argument; the
         body's Prep(scratch) lowers to a fresh internal `qubit()`.
         """
-        from pecos.slr import CReg, Main, QReg, SlrConverter
+        from pecos.slr import CReg, Main, QReg, Return, SlrConverter
         from pecos.slr.qeclib import qubit as qb
 
         good_check = self._good_check()
@@ -2225,12 +2236,12 @@ def test_scratch_guppy_internal_alloc_no_param(self) -> None:
             c := CReg("c", 1),
             qb.Prep(q),
             good_check([q[0], q[1]], q[2], c[0]),
+            Return(c),
         )
         guppy_src = SlrConverter(prog).guppy()
         # No `a` parameter on the generated def (scratch is internal).
         assert re.search(
-            r"def goodcheck_\d+\(d: array\[qubit, 2\] @ owned, "
-            r"out: array\[bool, 1\] @ owned\) -> ",
+            r"def goodcheck_\d+\(d: array\[qubit, 2\] @ owned, out: array\[bool, 1\] @ owned\) -> ",
             guppy_src,
         )
         assert "a: qubit @ owned" not in guppy_src
@@ -2241,7 +2252,7 @@ def test_scratch_guppy_internal_alloc_no_param(self) -> None:
         assert re.search(r"goodcheck_\d+\(array\(q_0, q_1\), array\(c\[0\]\)\)", guppy_src)
 
     def test_scratch_use_before_prep_rejected(self) -> None:
-        from pecos.slr import CReg, Main, QReg
+        from pecos.slr import CReg, Main, QReg, Return
         from pecos.slr.ast import slr_to_ast
         from pecos.slr.block import Block
         from pecos.slr.qeclib import qubit as qb
@@ -2256,12 +2267,17 @@ def __init__(self, a, out) -> None:
                 self.out = out
                 self.extend(qb.H(a), qb.Prep(a), Measure(a) > out)
 
-        prog = Main(q := QReg("q", 1), c := CReg("c", 1), BadFirst(q[0], c[0]))
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            BadFirst(q[0], c[0]),
+            Return(c),
+        )
         with pytest.raises(ValueError, match=r"first use is USE.*reset \(Prep\) before"):
             slr_to_ast(prog)
 
     def test_scratch_use_after_measure_rejected(self) -> None:
-        from pecos.slr import CReg, Main, QReg
+        from pecos.slr import CReg, Main, QReg, Return
         from pecos.slr.ast import slr_to_ast
         from pecos.slr.block import Block
         from pecos.slr.qeclib import qubit as qb
@@ -2276,12 +2292,17 @@ def __init__(self, a, out) -> None:
                 self.out = out
                 self.extend(qb.Prep(a), Measure(a) > out, qb.H(a))
 
-        prog = Main(q := QReg("q", 1), c := CReg("c", 1), BadAfter(q[0], c[0]))
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            BadAfter(q[0], c[0]),
+            Return(c),
+        )
         with pytest.raises(ValueError, match=r"used after measurement without re-Prep"):
             slr_to_ast(prog)
 
     def test_scratch_unused_rejected(self) -> None:
-        from pecos.slr import Main, QReg
+        from pecos.slr import Main, QReg, Return
         from pecos.slr.ast import slr_to_ast
         from pecos.slr.block import Block
 
@@ -2300,7 +2321,7 @@ def test_scratch_inside_control_flow_rejected(self) -> None:
         """S1 conservative scope: a scratch slot touched inside control
         flow cannot be linearized for the R4 analysis -> reject loudly.
         """
-        from pecos.slr import CReg, Main, QReg, Repeat
+        from pecos.slr import CReg, Main, QReg, Repeat, Return
         from pecos.slr.ast import slr_to_ast
         from pecos.slr.block import Block
         from pecos.slr.qeclib import qubit as qb
@@ -2319,7 +2340,12 @@ def __init__(self, a, out) -> None:
                     Measure(a) > out,
                 )
 
-        prog = Main(q := QReg("q", 1), c := CReg("c", 1), LoopScratch(q[0], c[0]))
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            LoopScratch(q[0], c[0]),
+            Return(c),
+        )
         with pytest.raises(ValueError, match=r"flat Prep -> \.\.\. -> Measure lifecycle"):
             slr_to_ast(prog)
 
@@ -2328,7 +2354,7 @@ def test_scratch_aliased_to_other_input_rejected(self) -> None:
         aliasing guard still rejects a scratch slot aliased to another
         qubit input.
         """
-        from pecos.slr import Main, QReg
+        from pecos.slr import Main, QReg, Return
         from pecos.slr.ast import slr_to_ast
         from pecos.slr.block import Block
         from pecos.slr.qeclib import qubit as qb
@@ -2352,7 +2378,7 @@ def test_scratch_prep_only_rejected(self) -> None:
         rejected -- S2 allocates the scratch qubit internally, so an
         unmeasured trailing Prep diverges from the flatten/QASM path.
         """
-        from pecos.slr import Main, QReg
+        from pecos.slr import Main, QReg, Return
         from pecos.slr.ast import slr_to_ast
         from pecos.slr.block import Block
         from pecos.slr.qeclib import qubit as qb
@@ -2370,7 +2396,7 @@ def __init__(self, a) -> None:
             slr_to_ast(prog)
 
     def test_scratch_prep_use_no_measure_rejected(self) -> None:
-        from pecos.slr import Main, QReg
+        from pecos.slr import Main, QReg, Return
         from pecos.slr.ast import slr_to_ast
         from pecos.slr.block import Block
         from pecos.slr.qeclib import qubit as qb
@@ -2389,7 +2415,7 @@ def __init__(self, a) -> None:
 
     def test_scratch_prep_measure_prep_unmeasured_rejected(self) -> None:
         """A second Prep with no closing Measure (trailing open lifecycle)."""
-        from pecos.slr import CReg, Main, QReg
+        from pecos.slr import CReg, Main, QReg, Return
         from pecos.slr.ast import slr_to_ast
         from pecos.slr.block import Block
         from pecos.slr.qeclib import qubit as qb
@@ -2404,13 +2430,18 @@ def __init__(self, a, out) -> None:
                 self.out = out
                 self.extend(qb.Prep(a), Measure(a) > out, qb.Prep(a))
 
-        prog = Main(q := QReg("q", 1), c := CReg("c", 1), PrepMeasurePrep(q[0], c[0]))
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            PrepMeasurePrep(q[0], c[0]),
+            Return(c),
+        )
         with pytest.raises(ValueError, match=r"scratch lifecycle not closed"):
             slr_to_ast(prog)
 
     def test_scratch_two_prep_no_measure_between_rejected(self) -> None:
         """Re-Prep before measuring the first lifecycle."""
-        from pecos.slr import Main, QReg
+        from pecos.slr import Main, QReg, Return
         from pecos.slr.ast import slr_to_ast
         from pecos.slr.block import Block
         from pecos.slr.qeclib import qubit as qb
@@ -2429,7 +2460,7 @@ def __init__(self, a) -> None:
 
     def test_scratch_prep_measure_prep_measure_accepted(self) -> None:
         """Two complete Prep -> Measure lifecycles is valid (each closed)."""
-        from pecos.slr import CReg, Main, QReg, SlrConverter
+        from pecos.slr import CReg, Main, QReg, Return, SlrConverter
         from pecos.slr.ast import slr_to_ast
         from pecos.slr.block import Block
         from pecos.slr.qeclib import qubit as qb
@@ -2454,7 +2485,12 @@ def __init__(self, a, out0, out1) -> None:
                     Measure(a) > out1,
                 )
 
-        prog = Main(q := QReg("q", 1), c := CReg("c", 2), TwoLifecycles(q[0], c[0], c[1]))
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 2),
+            TwoLifecycles(q[0], c[0], c[1]),
+            Return(c),
+        )
         ast = slr_to_ast(prog)  # must not raise
         assert any(isinstance(s, BlockCall) for s in ast.body)
         # Flatten still substitutes the scratch param to the outer slot.
@@ -2488,7 +2524,12 @@ def __init__(self, a, out) -> None:
                 self.out = out
                 self.extend(qb.Prep(a), Measure(a) > out, Return(a))
 
-        prog = Main(q := QReg("q", 1), c := CReg("c", 1), RetScratch(q[0], c[0]))
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            RetScratch(q[0], c[0]),
+            Return(c),
+        )
         with pytest.raises(ValueError, match=r"or any ReturnOp in a scratch-bearing block"):
             slr_to_ast(prog)
 
@@ -2501,7 +2542,12 @@ def __init__(self, a, out) -> None:
                 self.out = out
                 self.extend(qb.Prep(a), Measure(a) > out, Return(out))
 
-        prog2 = Main(q := QReg("q", 1), c := CReg("c", 1), RetOther(q[0], c[0]))
+        prog2 = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            RetOther(q[0], c[0]),
+            Return(c),
+        )
         with pytest.raises(ValueError, match=r"or any ReturnOp in a scratch-bearing block"):
             slr_to_ast(prog2)
 
@@ -2513,7 +2559,7 @@ def test_scratch_reuse_across_calls_compiles_and_runs(self) -> None:
         ancilla internally, so it compiles and runs through Selene.
         """
         from pecos import Hugr, selene_engine, sim
-        from pecos.slr import Block, CReg, Main, QReg, SlrConverter
+        from pecos.slr import Block, CReg, Main, QReg, Return, SlrConverter
         from pecos.slr.qeclib import qubit as qb
         from pecos.slr.qeclib.qubit.measures import Measure
 
@@ -2544,6 +2590,7 @@ def __init__(self, d, a, out) -> None:
             qb.Prep(q),
             Chk([q[0], q[1]], q[2], c[0]),
             Chk([q[0], q[1]], q[2], c[1]),  # reuses q[2] -- the blocker case
+            Return(c),
         )
         guppy_src = SlrConverter(prog).guppy()
         # Two separate scratch internal allocs, no LinearityError.
@@ -2570,7 +2617,7 @@ def test_scratch_outer_slot_misuse_rejected(self) -> None:
         meaningful caller state (gate + later measure) diverges between
         flatten (mutates it) and Guppy (allocates internally) -- reject.
         """
-        from pecos.slr import Block, CReg, Main, QReg, SlrConverter
+        from pecos.slr import Block, CReg, Main, QReg, Return, SlrConverter
         from pecos.slr.ast.codegen.guppy import GuppyCodegenError
         from pecos.slr.qeclib import qubit as qb
         from pecos.slr.qeclib.qubit.measures import Measure
@@ -2591,6 +2638,7 @@ def __init__(self, a, out) -> None:
             qb.X(q[0]),  # meaningful caller state on the scratch slot
             MS(q[0], c[0]),
             Measure(q[0]) > c[1],  # ...observed after the scratch call
+            Return(c),
         )
         with pytest.raises(GuppyCodegenError, match=r"Scratch outer slot q\[0\].*meaningful caller state"):
             SlrConverter(prog).guppy()
@@ -2600,7 +2648,7 @@ def test_scratch_outer_slot_whole_reg_prep_allowed(self) -> None:
         is allowed (the qeclib corpus does `Prep(q)` then uses `q[i]` as a
         check ancilla -- a reset is unobserved/dead under both lowerings).
         """
-        from pecos.slr import Block, CReg, Main, QReg, SlrConverter
+        from pecos.slr import Block, CReg, Main, QReg, Return, SlrConverter
         from pecos.slr.qeclib import qubit as qb
         from pecos.slr.qeclib.qubit.measures import Measure
 
@@ -2623,6 +2671,7 @@ def __init__(self, d, a, out) -> None:
             c := CReg("c", 1),
             qb.Prep(q),  # covers q[2] (the scratch slot) -- must NOT reject
             Chk([q[0], q[1]], q[2], c[0]),
+            Return(c),
         )
         guppy_src = SlrConverter(prog).guppy()  # must not raise
         assert "a_0 = qubit()" in guppy_src
@@ -2637,9 +2686,7 @@ def test_scratch_malformed_arg_rejected_direct_ast(self) -> None:
 
         decl = BlockDecl(
             name="b",
-            inputs=(
-                BlockInput(name="a", effect=ResourceEffect.SCRATCH, type_expr=QubitTypeExpr()),
-            ),
+            inputs=(BlockInput(name="a", effect=ResourceEffect.SCRATCH, type_expr=QubitTypeExpr()),),
             body=(
                 PrepareOp(allocator="a", slots=(0,)),
                 MeasureOp(targets=(SlotRef(allocator="a", index=0),)),
@@ -2664,7 +2711,7 @@ def test_scratch_outer_slot_permute_rejected(self) -> None:
         """Codex S2 r2 blocker 1: a Permute touching the scratch register
         observes/reorders the scratch-bound outer slot -> reject.
         """
-        from pecos.slr import Block, CReg, Main, Permute, QReg, SlrConverter
+        from pecos.slr import Block, CReg, Main, Permute, QReg, Return, SlrConverter
         from pecos.slr.ast.codegen.guppy import GuppyCodegenError
         from pecos.slr.qeclib import qubit as qb
         from pecos.slr.qeclib.qubit.measures import Measure
@@ -2686,6 +2733,7 @@ def __init__(self, a, out) -> None:
             MS(q[1], c[0]),
             Permute([q[0], q[1]], [q[1], q[0]]),
             Measure(q[0]) > c[1],
+            Return(c),
         )
         with pytest.raises(GuppyCodegenError, match=r"Scratch outer slot q\[1\].*Permute"):
             SlrConverter(prog).guppy()
@@ -2723,7 +2771,7 @@ def test_scratch_misuse_inside_block_body_rejected(self) -> None:
         nested scratch BlockCall + misuse of that slot inside a BlockDecl
         body (not just main) must be caught.
         """
-        from pecos.slr import Block, CReg, Main, QReg, SlrConverter
+        from pecos.slr import Block, CReg, Main, QReg, Return, SlrConverter
         from pecos.slr.ast.codegen.guppy import GuppyCodegenError
         from pecos.slr.qeclib import qubit as qb
         from pecos.slr.qeclib.qubit.measures import Measure
@@ -2749,7 +2797,13 @@ def __init__(self, q, o) -> None:
                 self.o = o
                 self.extend(Inner(q[1], o), qb.X(q[1]))  # misuse within this scope
 
-        prog = Main(qq := QReg("qq", 2), c := CReg("c", 1), qb.Prep(qq), Outer(qq, c[0]))
+        prog = Main(
+            qq := QReg("qq", 2),
+            c := CReg("c", 1),
+            qb.Prep(qq),
+            Outer(qq, c[0]),
+            Return(c),
+        )
         with pytest.raises(GuppyCodegenError, match=r"Scratch outer slot q\[1\].*meaningful caller state"):
             SlrConverter(prog).guppy()
 
@@ -2765,7 +2819,7 @@ class TestScratchCheckS4ProductionLockIn:
     """
 
     def test_steane_syn_extract_bare_routes_check_through_blockcall(self) -> None:
-        from pecos.slr import CReg, Main, QReg, SlrConverter
+        from pecos.slr import CReg, Main, QReg, Return, SlrConverter
         from pecos.slr.ast import slr_to_ast
         from pecos.slr.qeclib.steane.syn_extract.bare import SynExtractBare
 
@@ -2775,6 +2829,7 @@ def test_steane_syn_extract_bare_routes_check_through_blockcall(self) -> None:
             a := QReg("a", 2),
             syn := CReg("syn", 6),
             SynExtractBare(d, a, checks, syn),
+            Return(syn),
         )
         ast = slr_to_ast(prog)
         # 6 Checks (3 Z + 3 X) -> 6 BlockCalls, not silently flattened.
@@ -2796,7 +2851,7 @@ def test_steane_syn_extract_bare_routes_check_through_blockcall(self) -> None:
 
     def test_steane_syn_extract_bare_selene_records_pinned(self) -> None:
         from pecos import Hugr, selene_engine, sim
-        from pecos.slr import CReg, Main, QReg, SlrConverter
+        from pecos.slr import CReg, Main, QReg, Return, SlrConverter
         from pecos.slr.qeclib.steane.syn_extract.bare import SynExtractBare
 
         checks = [[2, 1, 3, 0], [5, 2, 1, 4], [6, 5, 2, 3]]
@@ -2805,17 +2860,12 @@ def test_steane_syn_extract_bare_selene_records_pinned(self) -> None:
             a := QReg("a", 2),
             syn := CReg("syn", 6),
             SynExtractBare(d, a, checks, syn),
+            Return(syn),
         )
         package = SlrConverter(prog).hugr()
         # d(7) + a(2) declared + 1 internally-allocated scratch ancilla
         # (design R2: parity is on behavioral records, not qubit count).
-        result = (
-            sim(Hugr(package.to_str().encode("utf-8")))
-            .classical(selene_engine())
-            .qubits(10)
-            .seed(42)
-            .run(4)
-        )
+        result = sim(Hugr(package.to_str().encode("utf-8"))).classical(selene_engine()).qubits(10).seed(42).run(4)
         raw = result.to_dict() if hasattr(result, "to_dict") else result
         # Empirical probe 2026-05-16 (post-conversion, scratch internal alloc).
         assert raw == {
@@ -2834,7 +2884,7 @@ def test_color488_syn_extract_bare_routes_and_runs(self) -> None:
         Check through a BlockCall, compile, and run.
         """
         from pecos import Hugr, selene_engine, sim
-        from pecos.slr import CReg, Main, QReg, SlrConverter
+        from pecos.slr import CReg, Main, QReg, Return, SlrConverter
         from pecos.slr.ast import slr_to_ast
         from pecos.slr.qeclib.color488.syn_extract.bare import (
             SynExtractBare as Color488SynExtractBare,
@@ -2846,6 +2896,7 @@ def test_color488_syn_extract_bare_routes_and_runs(self) -> None:
             a := QReg("a", 2),
             syn := CReg("syn", 6),
             Color488SynExtractBare(d, a, checks, syn),
+            Return(syn),
         )
         ast = slr_to_ast(prog)
         assert sum(1 for s in ast.body if isinstance(s, BlockCall)) == 6
@@ -2854,13 +2905,7 @@ def test_color488_syn_extract_bare_routes_and_runs(self) -> None:
         assert "LinearityError" not in guppy_src
 
         package = SlrConverter(prog).hugr()
-        result = (
-            sim(Hugr(package.to_str().encode("utf-8")))
-            .classical(selene_engine())
-            .qubits(10)
-            .seed(42)
-            .run(4)
-        )
+        result = sim(Hugr(package.to_str().encode("utf-8"))).classical(selene_engine()).qubits(10).seed(42).run(4)
         raw = result.to_dict() if hasattr(result, "to_dict") else result
         # Same generic-Check mechanism as Steane -> same seed-42 record shape.
         assert raw == {
@@ -2883,7 +2928,7 @@ class TestScratchCheck1FlagS5ProductionLockIn:
 
     def test_steane_syn_extract_flagged_routes_and_runs(self) -> None:
         from pecos import Hugr, selene_engine, sim
-        from pecos.slr import CReg, Main, QReg, SlrConverter
+        from pecos.slr import CReg, Main, QReg, Return, SlrConverter
         from pecos.slr.ast import slr_to_ast
         from pecos.slr.qeclib.steane.syn_extract.flagged import SynExtractFlagged
 
@@ -2896,6 +2941,7 @@ def test_steane_syn_extract_flagged_routes_and_runs(self) -> None:
             fx := CReg("fx", 3),
             fz := CReg("fz", 3),
             SynExtractFlagged(d, a, checks, sx, sz, fx, fz),
+            Return(sx, sz, fx, fz),
         )
         ast = slr_to_ast(prog)
         assert sum(1 for s in ast.body if isinstance(s, BlockCall)) == 6
@@ -2938,7 +2984,7 @@ def test_check1flag_h_branch_compiles_qasm_only(self) -> None:
         only: it must still route through a BlockCall and lower cleanly
         (Codex O1 review -- not a Selene assertion).
         """
-        from pecos.slr import CReg, Main, QReg, SlrConverter
+        from pecos.slr import CReg, Main, QReg, Return, SlrConverter
         from pecos.slr.ast import slr_to_ast
         from pecos.slr.qeclib.generic.check_1flag import Check1Flag
 
@@ -2946,6 +2992,7 @@ def test_check1flag_h_branch_compiles_qasm_only(self) -> None:
             q := QReg("q", 5),
             c := CReg("c", 2),
             Check1Flag([q[0], q[1], q[2]], "HHH", q[3], q[4], c[0], c[1], with_barriers=True),
+            Return(c),
         )
         ast = slr_to_ast(prog)
         assert sum(1 for s in ast.body if isinstance(s, BlockCall)) == 1
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_deprecation_warnings.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_deprecation_warnings.py
index 58bf66318..ecabe8ea0 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_deprecation_warnings.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_deprecation_warnings.py
@@ -146,6 +146,25 @@ def test_measure_inside_if_triggers_warning(self) -> None:
         with pytest.warns(DeprecationWarning, match=r"Implicit return"):
             SlrConverter(prog).guppy()
 
+    def test_inline_whole_register_measure_triggers_warning(self) -> None:
+        """Whole-register inline CReg targets store the CReg itself in Measure.cout."""
+        prog = Main(
+            q := QReg("q", 2),
+            Measure(q) > CReg("inline", 2),
+        )
+        with pytest.warns(DeprecationWarning, match=r"Implicit return"):
+            SlrConverter(prog).guppy()
+
+    def test_inline_slice_measure_triggers_warning(self) -> None:
+        """Slice targets store a list of Bits inside Measure.cout; recurse into it."""
+        inline = CReg("inline", 2)
+        prog = Main(
+            q := QReg("q", 2),
+            Measure(q) > inline[0:2],
+        )
+        with pytest.warns(DeprecationWarning, match=r"Implicit return"):
+            SlrConverter(prog).guppy()
+
     def test_warning_does_not_block_compilation(self) -> None:
         """The deprecation warning is non-blocking; .guppy() and .hugr() still
         succeed. Only Phase 3b makes the breaking change.
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
index 98182b8c7..aae08f23b 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
@@ -25,7 +25,7 @@
 
 import pytest
 from pecos import Hugr, selene_engine, sim
-from pecos.slr import CReg, For, If, Main, Print, QReg, Repeat, SlrConverter
+from pecos.slr import CReg, For, If, Main, Print, QReg, Repeat, Return, SlrConverter
 from pecos.slr.ast.codegen.guppy import GuppyCodegenError
 from pecos.slr.qeclib import qubit as qb
 from pecos.slr.qeclib.qubit.measures import Measure
@@ -55,6 +55,7 @@ def test_print_whole_creg_derives_register_name(self) -> None:
             qb.X(q[0]),
             Measure(q) > c,
             Print(c),
+            Return(c),
         )
         raw = _run_and_get_result_dict(prog, qubits=2)
         assert "result.c" in raw, f"expected 'result.c' tag in {list(raw.keys())}"
@@ -67,6 +68,7 @@ def test_print_bit_ref_derives_register_index_name(self) -> None:
             qb.X(q[0]),
             Measure(q[0]) > c[0],
             Print(c[0]),
+            Return(c),
         )
         raw = _run_and_get_result_dict(prog)
         assert "result.c_0" in raw, f"expected 'result.c_0' tag in {list(raw.keys())}"
@@ -85,6 +87,7 @@ def test_namespace_debug_emits_under_debug_prefix(self) -> None:
             qb.X(q[0]),
             Measure(q[0]) > c[0],
             Print(c, namespace="debug"),
+            Return(c),
         )
         raw = _run_and_get_result_dict(prog)
         assert "debug.c" in raw
@@ -96,6 +99,7 @@ def test_explicit_tag_overrides_derived(self) -> None:
             qb.X(q[0]),
             Measure(q[0]) > c[0],
             Print(c, tag="step_1"),
+            Return(c),
         )
         raw = _run_and_get_result_dict(prog)
         assert "result.step_1" in raw
@@ -107,6 +111,7 @@ def test_namespace_and_tag_together(self) -> None:
             qb.X(q[0]),
             Measure(q[0]) > c[0],
             Print(c, tag="r1", namespace="debug"),
+            Return(c),
         )
         raw = _run_and_get_result_dict(prog)
         assert "debug.r1" in raw
@@ -136,6 +141,7 @@ def test_print_in_repeat_emits_event_per_iteration(self) -> None:
                 qb.Prep(q[0]),
                 Print(c, tag="iter"),
             ),
+            Return(c),
         )
         raw = _run_and_get_result_dict(prog, shots=shots)
         assert "result.iter" in raw, f"expected 'result.iter' in {list(raw.keys())}"
@@ -158,6 +164,7 @@ def test_print_in_static_for_emits_event_per_iteration(self) -> None:
                 qb.Prep(q[0]),
                 Print(c, tag="loop"),
             ),
+            Return(c),
         )
         raw = _run_and_get_result_dict(prog, shots=shots)
         assert "result.loop" in raw
@@ -245,6 +252,7 @@ def test_no_print_yields_implicit_measurement_records(self) -> None:
             c := CReg("c", 1),
             qb.X(q[0]),
             Measure(q[0]) > c[0],
+            Return(c),
         )
         raw = _run_and_get_result_dict(prog, shots=2)
         assert "measurement_0" in raw
@@ -265,6 +273,7 @@ def test_print_switches_selene_to_tag_mode_and_hides_measurement_records(self) -
             qb.X(q[0]),
             Measure(q[0]) > c[0],
             Print(c, tag="p"),
+            Return(c),
         )
         raw = _run_and_get_result_dict(prog, shots=2)
         assert "result.p" in raw
@@ -282,6 +291,7 @@ def test_multiple_prints_distinct_tags_each_appear(self) -> None:
             qb.X(q[0]),
             Measure(q[0]) > c[0],
             Print(c, tag="late"),
+            Return(c),
         )
         raw = _run_and_get_result_dict(prog, shots=2)
         assert "result.early" in raw
@@ -303,6 +313,7 @@ def test_two_prints_same_tag_become_event_list(self) -> None:
             qb.X(q[0]),
             Measure(q[0]) > c[0],
             Print(c, tag="same"),  # same tag, second emission
+            Return(c),
         )
         raw = _run_and_get_result_dict(prog, shots=shots)
         assert "result.same" in raw
@@ -333,6 +344,7 @@ def test_then_only_print_rejected(self) -> None:
             qb.X(q[0]),
             Measure(q[0]) > c[0],
             If(c[0]).Then(Print(c, tag="only_then")),
+            Return(c),
         )
         with pytest.raises(GuppyCodegenError, match="path-signature mismatch"):
             SlrConverter(prog).hugr()
@@ -345,6 +357,7 @@ def test_symmetric_if_then_else_accepted(self) -> None:
             qb.X(q[0]),
             Measure(q[0]) > c[0],
             If(c[0]).Then(Print(c, tag="branch_taken")).Else(Print(c, tag="branch_taken")),
+            Return(c),
         )
         SlrConverter(prog).hugr()
 
@@ -356,6 +369,7 @@ def test_asymmetric_tag_rejected(self) -> None:
             qb.X(q[0]),
             Measure(q[0]) > c[0],
             If(c[0]).Then(Print(c, tag="branch_a")).Else(Print(c, tag="branch_b")),
+            Return(c),
         )
         with pytest.raises(GuppyCodegenError, match="path-signature mismatch"):
             SlrConverter(prog).hugr()
@@ -373,6 +387,7 @@ def test_asymmetric_multiplicity_rejected(self) -> None:
                 Print(c, tag="event"),
             )
             .Else(Print(c, tag="event")),
+            Return(c),
         )
         with pytest.raises(GuppyCodegenError, match="path-signature mismatch"):
             SlrConverter(prog).hugr()
@@ -385,6 +400,7 @@ def test_asymmetric_namespace_rejected(self) -> None:
             qb.X(q[0]),
             Measure(q[0]) > c[0],
             If(c[0]).Then(Print(c, tag="x")).Else(Print(c, namespace="debug", tag="x")),
+            Return(c),
         )
         with pytest.raises(GuppyCodegenError, match="path-signature mismatch"):
             SlrConverter(prog).hugr()
@@ -400,6 +416,7 @@ def test_static_repeat_with_print_compiles(self) -> None:
                 qb.Prep(q[0]),
                 Print(c, tag="iter"),
             ),
+            Return(c),
         )
         SlrConverter(prog).hugr()
 
@@ -414,6 +431,7 @@ def test_static_for_with_print_compiles(self) -> None:
                 qb.Prep(q[0]),
                 Print(c, tag="loop"),
             ),
+            Return(c),
         )
         SlrConverter(prog).hugr()
 
@@ -434,6 +452,7 @@ def test_nested_if_with_symmetric_prints_accepted(self) -> None:
                 If(c[1]).Then(Print(c, tag="inner")).Else(Print(c, tag="inner")),
                 Print(c, tag="outer"),
             ),
+            Return(c),
         )
         SlrConverter(prog).hugr()
 
@@ -446,6 +465,7 @@ def test_nested_if_with_asymmetric_inner_rejected(self) -> None:
             Measure(q[0]) > c[0],
             Measure(q[1]) > c[1],
             If(c[0]).Then(If(c[1]).Then(Print(c, tag="leak"))),  # Else missing on inner
+            Return(c),
         )
         with pytest.raises(GuppyCodegenError, match="path-signature mismatch"):
             SlrConverter(prog).hugr()
@@ -479,6 +499,7 @@ def test_print_bit_before_measure_on_inline_creg_rejected(self) -> None:
             qb.X(q[0]),
             Print(inline[0], tag="before_measure"),
             Measure(q[0]) > inline[0],
+            Return(inline),
         )
         with pytest.raises(GuppyCodegenError, match=r"references inline CReg"):
             SlrConverter(prog).hugr()
@@ -491,6 +512,7 @@ def test_print_bit_after_measure_on_inline_creg_accepted(self) -> None:
             qb.X(q[0]),
             Measure(q[0]) > inline[0],
             Print(inline[0], tag="after_measure"),
+            Return(inline),
         )
         SlrConverter(prog).hugr()
 
@@ -503,6 +525,7 @@ def test_print_of_declared_creg_before_measure_accepted(self) -> None:
             qb.X(q[0]),
             Measure(q[0]) > c[0],
             Print(c, tag="after"),
+            Return(c),
         )
         SlrConverter(prog).hugr()
 
@@ -515,6 +538,7 @@ def test_print_bit_ref_before_measure_on_inline_creg_rejected(self) -> None:
             Print(inline[0], tag="early"),
             Measure(q[0]) > inline[0],
             Measure(q[1]) > inline[1],
+            Return(inline),
         )
         with pytest.raises(GuppyCodegenError, match=r"references inline CReg"):
             SlrConverter(prog).hugr()
@@ -529,6 +553,7 @@ def test_inline_creg_assigned_in_both_if_branches_propagates(self) -> None:
             Measure(q[0]) > c[0],
             If(c[0]).Then(qb.X(q[1]), Measure(q[1]) > inline[0]).Else(Measure(q[1]) > inline[0]),
             Print(inline[0], tag="post_if"),
+            Return(c),
         )
         SlrConverter(prog).hugr()
 
@@ -542,6 +567,7 @@ def test_inline_creg_assigned_only_in_then_does_not_propagate(self) -> None:
             Measure(q[0]) > c[0],
             If(c[0]).Then(Measure(q[0]) > inline[0]),
             Print(inline[0], tag="maybe"),
+            Return(c),
         )
         with pytest.raises(GuppyCodegenError, match=r"references inline CReg"):
             SlrConverter(prog).hugr()
@@ -553,6 +579,7 @@ def test_inline_creg_assigned_in_repeat_body_propagates(self) -> None:
             q := QReg("q", 1),
             Repeat(3).block(qb.X(q[0]), Measure(q[0]) > inline[0], qb.Prep(q[0])),
             Print(inline[0], tag="post_repeat"),
+            Return(inline),
         )
         SlrConverter(prog).hugr()
 
@@ -563,6 +590,7 @@ def test_inline_creg_assigned_in_static_for_propagates(self) -> None:
             q := QReg("q", 1),
             For("i", 0, 2).Do(qb.X(q[0]), Measure(q[0]) > inline[0], qb.Prep(q[0])),
             Print(inline[0], tag="post_for"),
+            Return(inline),
         )
         SlrConverter(prog).hugr()
 
@@ -581,6 +609,7 @@ def test_print_inline_bit_with_only_other_bit_measured_rejected(self) -> None:
             qb.X(q[0]),
             Measure(q[0]) > inline[0],
             Print(inline[1], tag="bit1"),
+            Return(inline),
         )
         with pytest.raises(GuppyCodegenError, match=r"references inline CReg"):
             SlrConverter(prog).hugr()
@@ -602,6 +631,7 @@ def test_whole_inline_creg_print_rejected_outright(self) -> None:
             Measure(q[0]) > inline[0],
             Measure(q[1]) > inline[1],
             Print(inline, tag="full"),
+            Return(inline),
         )
         with pytest.raises(GuppyCodegenError, match=r"Print\(whole-CReg\) of inline CReg"):
             SlrConverter(prog).hugr()
@@ -621,6 +651,7 @@ def test_whole_inline_creg_print_shrink_case_rejected(self) -> None:
             qb.X(q[0]),
             Measure(q[0]) > inline[0],
             Print(inline, tag="whole"),
+            Return(inline),
         )
         with pytest.raises(GuppyCodegenError, match=r"Print\(whole-CReg\) of inline CReg"):
             SlrConverter(prog).hugr()
@@ -637,6 +668,7 @@ def test_whole_declared_creg_print_accepted(self) -> None:
             Measure(q[0]) > c[0],
             Measure(q[1]) > c[1],
             Print(c, tag="whole"),
+            Return(c),
         )
         SlrConverter(prog).hugr()
 
@@ -661,6 +693,7 @@ def test_while_with_print_rejected(self) -> None:
                 qb.Prep(q[0]),
                 Measure(q[0]) > c[0],
             ),
+            Return(c),
         )
         with pytest.raises(GuppyCodegenError):
             SlrConverter(prog).hugr()
@@ -680,6 +713,7 @@ def test_parallel_block_with_print_compiles(self) -> None:
                 Print(c[0], tag="bit0"),
                 Print(c[1], tag="bit1"),
             ),
+            Return(c),
         )
         SlrConverter(prog).hugr()
 
@@ -695,6 +729,7 @@ def test_repeat_zero_with_print_walks_body_for_validation(self) -> None:
                 Print(inline[0], tag="never_runs"),  # inline[0] never written anywhere
             ),
             Measure(q[0]) > inline[0],
+            Return(inline),
         )
         with pytest.raises(GuppyCodegenError, match=r"references inline CReg"):
             SlrConverter(prog).hugr()
@@ -766,6 +801,7 @@ def _bell_no_print() -> Main:
             qb.H(q[0]),
             qb.CX(q[0], q[1]),
             Measure(q) > c,
+            Return(c),
         )
 
     @staticmethod
@@ -777,6 +813,7 @@ def _bell_with_print() -> Main:
             qb.CX(q[0], q[1]),
             Measure(q) > c,
             Print(c, tag="debug"),
+            Return(c),
         )
 
     def test_qasm_emits_print_as_exactly_one_comment_line(self) -> None:
@@ -842,6 +879,7 @@ def test_multibit_creg_print_in_repeat_flattens_iterations_into_inner_list(self)
                 qb.Prep(q[0]),
                 Print(c, tag="iter"),
             ),
+            Return(c),
         )
         raw = _run_and_get_result_dict(prog, shots=3, qubits=2)
         assert "result.iter" in raw
@@ -879,6 +917,7 @@ def test_single_print_single_bit_creg_flat_per_shot_list(self) -> None:
             c := CReg("c", 1),
             Print(c, tag="zero_init"),  # before Measure: bit is the False init
             Measure(q[0]) > c[0],
+            Return(c),
         )
         raw = _run_and_get_result_dict(prog, shots=2)
         assert "result.zero_init" in raw
@@ -902,6 +941,7 @@ def test_single_print_multibit_creg_list_per_shot(self) -> None:
             Measure(q[0]) > c[0],
             Measure(q[1]) > c[1],
             Print(c, tag="pair"),
+            Return(c),
         )
         raw = _run_and_get_result_dict(prog, shots=2, qubits=2)
         assert "result.pair" in raw
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qeclib_selene_corpus.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qeclib_selene_corpus.py
index d9f8b17b5..f0c3b5b91 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qeclib_selene_corpus.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qeclib_selene_corpus.py
@@ -62,7 +62,7 @@
 import warnings
 
 from pecos import Hugr, selene_engine, sim
-from pecos.slr import CReg, Main, QReg, SlrConverter
+from pecos.slr import CReg, Main, QReg, Return, SlrConverter
 from pecos.slr.qeclib import qubit as qb
 from pecos.slr.qeclib.generic.check import Check
 from pecos.slr.qeclib.generic.check_1flag import Check1Flag
@@ -110,6 +110,7 @@ def test_check_xyz_on_zero_state_pinned_records(self) -> None:
             q := QReg("q", 4),
             c := CReg("c", 1),
             Check([q[0], q[1], q[2]], "XYZ", q[3], c[0], with_barriers=True),
+            Return(c),
         )
         raw = _run_via_selene(prog, shots=4, seed=42, qubits=5)
         # Empirical probe 2026-05-15: {'measurement_0': [1, 0, 0, 1]}
@@ -129,6 +130,7 @@ def test_check_xyz_on_plus_state_pinned_records(self) -> None:
             qb.H(q[0]),
             qb.H(q[1]),
             Check([q[0], q[1], q[2]], "XYZ", q[3], c[0], with_barriers=True),
+            Return(c),
         )
         # qubits=5: converted Check allocates its scratch ancilla
         # internally (design R2 -- records unchanged, +1 physical qubit).
@@ -154,6 +156,7 @@ def test_check_1flag_xyz_on_zero_state_pinned_records(self) -> None:
             q := QReg("q", 5),
             c := CReg("c", 2),
             Check1Flag([q[0], q[1], q[2]], "XYZ", q[3], q[4], c[0], c[1], with_barriers=True),
+            Return(c),
         )
         raw = _run_via_selene(prog, shots=4, seed=42, qubits=7)
         # Empirical probe 2026-05-15: unchanged post-conversion
@@ -184,6 +187,7 @@ def test_transversal_cx_propagates_x_pinned_records(self) -> None:
             transversal_tq(qb.CX, a, b),
             Measure(a) > c[0:3],
             Measure(b) > c[3:6],
+            Return(c),
         )
         raw = _run_via_selene(prog, shots=4, seed=42, qubits=6)
         # Empirical probe 2026-05-15: each measurement_N has 4 identical shots
@@ -206,6 +210,7 @@ def test_transversal_cx_pure_zero_pinned_records(self) -> None:
             transversal_tq(qb.CX, a, b),
             Measure(a) > c[0:3],
             Measure(b) > c[3:6],
+            Return(c),
         )
         raw = _run_via_selene(prog, shots=4, seed=42, qubits=6)
         # Empirical probe 2026-05-15: |000>|000> through CX stays |000>|000>;
@@ -238,6 +243,7 @@ def _x_all_then_gate_then_measure(self, gate_class: type) -> Main:
             gate_class(a, b),
             Measure(a) > c[0:7],
             Measure(b) > c[7:14],
+            Return(c),
         )
 
     def test_steane_cx_all_ones_to_zero_propagates_pinned_records(self) -> None:
@@ -276,6 +282,7 @@ def _gate_then_measure(self, gate_class: type) -> Main:
             c := CReg("c", 7),
             gate_class(q),
             Measure(q) > c,
+            Return(c),
         )
 
     def test_steane_logical_x_on_zero_pinned_records(self) -> None:
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_acceptance.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_acceptance.py
index b8e8dd6bb..f27fe8cf4 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_acceptance.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_acceptance.py
@@ -17,7 +17,7 @@
 
 from __future__ import annotations
 
-from pecos.slr import Block, CReg, If, Main, QReg, Repeat
+from pecos.slr import Block, CReg, If, Main, QReg, Repeat, Return
 from pecos.slr.qeclib import qubit as qb
 from pecos.slr.qeclib.qubit.measures import Measure
 
@@ -34,6 +34,7 @@ def test_bell(self) -> None:
             qb.H(q[0]),
             qb.CX(q[0], q[1]),
             Measure(q) > c,
+            Return(c),
         )
         assert_ast_guppy_compiles(prog)
 
@@ -45,6 +46,7 @@ def test_ghz_three(self) -> None:
             qb.CX(q[0], q[1]),
             qb.CX(q[1], q[2]),
             Measure(q) > c,
+            Return(c),
         )
         assert_ast_guppy_compiles(prog)
 
@@ -60,6 +62,7 @@ def test_multi_register(self) -> None:
             qb.CX(b[0], b[1]),
             Measure(a) > ca,
             Measure(b) > cb,
+            Return(ca, cb),
         )
         assert_ast_guppy_compiles(prog)
 
@@ -74,6 +77,7 @@ def test_partial_measurement_lives_discarded(self) -> None:
             c := CReg("c", 1),
             qb.H(q[0]),
             Measure(q[0]) > c[0],
+            Return(c),
         )
         assert_ast_guppy_compiles(prog)
 
@@ -86,6 +90,7 @@ def test_full_register_measurement(self) -> None:
             qb.H(q[2]),
             qb.H(q[3]),
             Measure(q) > c,
+            Return(c),
         )
         assert_ast_guppy_compiles(prog)
 
@@ -98,6 +103,7 @@ def test_individual_measurements(self) -> None:
             qb.X(q[1]),
             Measure(q[1]) > c[1],
             Measure(q[2]) > c[2],
+            Return(c),
         )
         assert_ast_guppy_compiles(prog)
 
@@ -120,6 +126,7 @@ def test_creg_bit_set_int_literal(self) -> None:
             c := CReg("c", 2),
             c[0].set(1),
             c[1].set(0),
+            Return(c),
         )
         assert_ast_guppy_compiles(prog)
 
@@ -135,6 +142,7 @@ def test_prep_resets_live_slot(self) -> None:
             Measure(q[0]) > c[0],
             qb.Prep(q[0]),  # consumed -> fresh qubit()
             Measure(q[0]) > c[1],
+            Return(c),
         )
         assert_ast_guppy_compiles(prog)
 
@@ -150,6 +158,7 @@ def test_conditional_x_state_preserving(self) -> None:
             Measure(q[0]) > c[0],
             If(c[0]).Then(qb.X(q[1])),
             Measure(q[1]) > c[1],
+            Return(c),
         )
         assert_ast_guppy_compiles(prog)
 
@@ -175,6 +184,7 @@ def test_pauli_set(self) -> None:
             qb.Z(q[2]),
             qb.H(q[3]),
             Measure(q) > c,
+            Return(c),
         )
         assert_ast_guppy_compiles(prog)
 
@@ -190,6 +200,7 @@ def test_szdg_t_tdg(self) -> None:
             qb.SZdg(q[0]),
             qb.H(q[0]),
             Measure(q[0]) > c[0],
+            Return(c),
         )
         assert_ast_guppy_compiles(prog)
 
@@ -201,6 +212,7 @@ def test_cy_cz(self) -> None:
             qb.CY(q[0], q[1]),
             qb.CZ(q[0], q[1]),
             Measure(q) > c,
+            Return(c),
         )
         assert_ast_guppy_compiles(prog)
 
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py
index b4c9be7da..08499f77f 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py
@@ -26,7 +26,7 @@
 
 from __future__ import annotations
 
-from pecos.slr import CReg, If, Main, Permute, QReg
+from pecos.slr import CReg, If, Main, Permute, QReg, Return
 from pecos.slr.qeclib import qubit as qb
 from pecos.slr.qeclib.qubit.measures import Measure
 
@@ -45,6 +45,7 @@ def test_x_then_measure_is_one(self) -> None:
             c := CReg("c", 1),
             qb.X(q[0]),
             Measure(q[0]) > c[0],
+            Return(c),
         )
         records = run_ast_guppy_via_selene(prog, shots=10)
         assert all(r["measurement_0"] == 1 for r in records)
@@ -55,6 +56,7 @@ def test_no_op_then_measure_is_zero(self) -> None:
             q := QReg("q", 1),
             c := CReg("c", 1),
             Measure(q[0]) > c[0],
+            Return(c),
         )
         records = run_ast_guppy_via_selene(prog, shots=10)
         assert all(r["measurement_0"] == 0 for r in records)
@@ -67,6 +69,7 @@ def test_x_then_x_then_measure_is_zero(self) -> None:
             qb.X(q[0]),
             qb.X(q[0]),
             Measure(q[0]) > c[0],
+            Return(c),
         )
         records = run_ast_guppy_via_selene(prog, shots=10)
         assert all(r["measurement_0"] == 0 for r in records)
@@ -80,6 +83,7 @@ def test_measure_prep_remeasure_is_zero(self) -> None:
             Measure(q[0]) > c[0],
             qb.Prep(q[0]),
             Measure(q[0]) > c[1],
+            Return(c),
         )
         records = run_ast_guppy_via_selene(prog, shots=10)
         assert all(r["measurement_0"] == 1 for r in records)
@@ -95,6 +99,7 @@ def test_measure_prep_x_remeasure_is_one(self) -> None:
             qb.Prep(q[0]),
             qb.X(q[0]),
             Measure(q[0]) > c[1],
+            Return(c),
         )
         records = run_ast_guppy_via_selene(prog, shots=10)
         assert all(r["measurement_0"] == 1 for r in records)
@@ -109,6 +114,7 @@ def test_h_z_h_then_measure_is_one(self) -> None:
             qb.Z(q[0]),
             qb.H(q[0]),
             Measure(q[0]) > c[0],
+            Return(c),
         )
         records = run_ast_guppy_via_selene(prog, shots=10)
         assert all(r["measurement_0"] == 1 for r in records)
@@ -122,6 +128,7 @@ def test_quantum_permute_is_observed_by_later_measurements(self) -> None:
             Permute([q[0], q[1]], [q[1], q[0]]),
             Measure(q[0]) > c[0],
             Measure(q[1]) > c[1],
+            Return(c),
         )
         records = run_ast_guppy_via_selene(prog, shots=10)
         assert all(r["measurement_0"] == 0 for r in records)
@@ -142,6 +149,7 @@ def test_quantum_permute_three_cycle(self) -> None:
             Measure(q[0]) > c[0],
             Measure(q[1]) > c[1],
             Measure(q[2]) > c[2],
+            Return(c),
         )
         records = run_ast_guppy_via_selene(prog, shots=10)
         assert all(r["measurement_0"] == 0 for r in records)
@@ -161,6 +169,7 @@ def test_quantum_permute_cross_register(self) -> None:
             Measure(a[1]) > c[1],
             Measure(b[0]) > c[2],
             Measure(b[1]) > c[3],
+            Return(c),
         )
         records = run_ast_guppy_via_selene(prog, shots=10)
         assert all(r["measurement_0"] == 1 for r in records)
@@ -183,6 +192,7 @@ def test_bell_correlation_every_shot(self) -> None:
             qb.H(q[0]),
             qb.CX(q[0], q[1]),
             Measure(q) > c,
+            Return(c),
         )
         records = run_ast_guppy_via_selene(prog, shots=100)
         assert all(r["measurement_0"] == r["measurement_1"] for r in records)
@@ -196,6 +206,7 @@ def test_ghz_three_correlation_every_shot(self) -> None:
             qb.CX(q[0], q[1]),
             qb.CX(q[1], q[2]),
             Measure(q) > c,
+            Return(c),
         )
         records = run_ast_guppy_via_selene(prog, shots=100)
         for r in records:
@@ -216,6 +227,7 @@ def test_bell_marginal_frequency_in_range(self) -> None:
             qb.H(q[0]),
             qb.CX(q[0], q[1]),
             Measure(q) > c,
+            Return(c),
         )
         records = run_ast_guppy_via_selene(prog, shots=1000, seed=42)
         ones_0 = sum(r["measurement_0"] for r in records)
@@ -245,6 +257,7 @@ def test_conditional_x_flips_remapped_branch(self) -> None:
             Measure(q[0]) > c[0],
             If(c[0]).Then(qb.X(q[1])),
             Measure(q[1]) > c[1],
+            Return(c),
         )
         records = run_ast_guppy_via_selene(prog_zero, shots=10)
         assert all(r["measurement_0"] == 0 for r in records)
@@ -258,6 +271,7 @@ def test_conditional_x_flips_remapped_branch(self) -> None:
             Measure(q[0]) > c[0],
             If(c[0]).Then(qb.X(q[1])),
             Measure(q[1]) > c[1],
+            Return(c),
         )
         records = run_ast_guppy_via_selene(prog_one, shots=10)
         assert all(r["measurement_0"] == 1 for r in records)
@@ -273,6 +287,7 @@ def test_creg_permute_remaps_condition_bit(self) -> None:
             flag[1].set(0),
             If(flag[1]).Then(qb.X(q[0])),
             Measure(q[0]) > out[0],
+            Return(out),
         )
         records = run_ast_guppy_via_selene(prog_without_permute, shots=10)
         assert all(r["measurement_0"] == 0 for r in records)
@@ -286,6 +301,7 @@ def test_creg_permute_remaps_condition_bit(self) -> None:
             Permute([flag[0], flag[1]], [flag[1], flag[0]]),
             If(flag[1]).Then(qb.X(q[0])),
             Measure(q[0]) > out[0],
+            Return(out),
         )
         records = run_ast_guppy_via_selene(prog_with_permute, shots=10)
         assert all(r["measurement_0"] == 1 for r in records)
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_array_patterns.py b/python/quantum-pecos/tests/slr_tests/guppy/test_array_patterns.py
index 542765a00..237e355fa 100644
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_array_patterns.py
+++ b/python/quantum-pecos/tests/slr_tests/guppy/test_array_patterns.py
@@ -9,7 +9,7 @@
 """
 
 import pytest
-from pecos.slr import Block, CReg, Main, Permute, QReg, SlrConverter
+from pecos.slr import Block, CReg, Main, Permute, QReg, Return, SlrConverter
 from pecos.slr.qeclib import qubit
 from pecos.slr.qeclib.qubit.measures import Measure
 
@@ -29,6 +29,7 @@ def test_unique_unpacked_names(self) -> None:
             Measure(q[0]) > c[0],
             Measure(q[1]) > c[1],
             Measure(q_0[0]) > c[2],
+            Return(c),
         )
 
         guppy_code = SlrConverter(prog).guppy()
@@ -59,6 +60,7 @@ def test_permute_operation(self) -> None:
             Permute(q1, q2),
             Measure(q1) > c[0:2],
             Measure(q2) > c[2:4],
+            Return(c),
         )
         assert_ast_guppy_compiles(prog)
 
@@ -87,6 +89,7 @@ def __init__(self, q: QReg) -> None:
             ProcessPair(q[4:6]),
             # Measure all
             Measure(q) > c,
+            Return(c),
         )
 
         # Note: Slicing syntax q[0:2] might not be fully supported yet
@@ -110,6 +113,7 @@ def test_dynamic_sized_arrays(self) -> None:
             c := CReg("c", 4),
             # All current operations use fixed indices
             Measure(q) > c,
+            Return(c),
         )
 
         guppy_code = SlrConverter(prog).guppy()
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_conditional_resources.py b/python/quantum-pecos/tests/slr_tests/guppy/test_conditional_resources.py
index 4d35f9625..6657d3540 100644
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_conditional_resources.py
+++ b/python/quantum-pecos/tests/slr_tests/guppy/test_conditional_resources.py
@@ -12,7 +12,7 @@
 """
 
 import pytest
-from pecos.slr import CReg, If, Main, QReg, SlrConverter
+from pecos.slr import CReg, If, Main, QReg, Return, SlrConverter
 from pecos.slr.qeclib.qubit.measures import Measure
 
 
@@ -31,6 +31,7 @@ def test_hugr_compilation_simple() -> None:
         .Else(
             Measure(q[1]) > c[1],
         ),
+        Return(c),
     )
 
     # This might still fail due to other HUGR issues, but the conditional
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_hugr_compilation.py b/python/quantum-pecos/tests/slr_tests/guppy/test_hugr_compilation.py
index 7a52b10b7..f89376100 100644
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_hugr_compilation.py
+++ b/python/quantum-pecos/tests/slr_tests/guppy/test_hugr_compilation.py
@@ -5,7 +5,7 @@
 """
 
 import pytest
-from pecos.slr import Block, CReg, If, Main, QReg, SlrConverter
+from pecos.slr import Block, CReg, If, Main, QReg, Return, SlrConverter
 from pecos.slr.qeclib import qubit
 from pecos.slr.qeclib.qubit.measures import Measure
 
@@ -22,6 +22,7 @@ def test_basic_measurement_compiles(self) -> None:
             qubit.H(q[0]),
             qubit.CX(q[0], q[1]),
             Measure(q) > c,
+            Return(c),
         )
 
         # Should compile without errors
@@ -52,6 +53,7 @@ def __init__(self, data: QReg, ancilla: QReg, syndrome: CReg) -> None:
             MeasureAncillas(data, ancilla, syndrome),
             qubit.H(data[0]),
             Measure(data) > result,
+            Return(syndrome, result),
         )
 
         hugr = SlrConverter(prog).hugr()
@@ -67,6 +69,7 @@ def test_individual_measurements_compile(self) -> None:
             Measure(q[1]) > c[1],
             Measure(q[2]) > c[2],
             Measure(q[3]) > c[3],
+            Return(c),
         )
 
         hugr = SlrConverter(prog).hugr()
@@ -90,6 +93,7 @@ def __init__(self, q: QReg) -> None:
             c := CReg("c", 2),
             ProcessQubits(q),
             Measure(q) > c,
+            Return(c),
         )
 
         hugr = SlrConverter(prog).hugr()
@@ -105,6 +109,7 @@ def test_conditional_measurements_compile(self) -> None:
                 qubit.X(q[1]),
             ),
             Measure(q[1]) > c[1],
+            Return(c),
         )
 
         hugr = SlrConverter(prog).hugr()
@@ -138,6 +143,7 @@ def __init__(self, q: QReg, c: CReg) -> None:
             q := QReg("q", 2),
             c := CReg("c", 2),
             OuterBlock(q, c),
+            Return(c),
         )
 
         hugr = SlrConverter(prog).hugr()
@@ -155,6 +161,7 @@ def test_multiple_qregs_compile(self) -> None:
             qubit.CX(q1[0], q2[0]),
             Measure(q1) > c1,
             Measure(q2) > c2,
+            Return(c1, c2),
         )
 
         hugr = SlrConverter(prog).hugr()
@@ -193,6 +200,7 @@ def test_double_measurement_fails(self) -> None:
             c := CReg("c", 2),
             Measure(q[0]) > c[0],
             Measure(q[0]) > c[1],  # Error: q[0] already consumed
+            Return(c),
         )
 
         # This should raise an error
@@ -220,6 +228,7 @@ def __init__(self, q: QReg) -> None:
             UseButDontReturn(q),
             # Try to use q after function that didn't return it
             Measure(q[0]) > c[0],
+            Return(c),
         )
 
         with pytest.raises(RuntimeError) as exc_info:
@@ -276,6 +285,7 @@ def __init__(self, data: QReg, ancilla: QReg, syndrome: CReg) -> None:
             # For now just measure data
             result := CReg("result", 7),
             Measure(data) > result,
+            Return(syndrome, result),
         )
 
         hugr = SlrConverter(prog).hugr()
@@ -316,6 +326,7 @@ def __init__(self, data: QReg, ancilla: QReg, syndrome: CReg) -> None:
             # Final measurement
             result := CReg("result", 3),
             Measure(data) > result,
+            Return(syndrome, syndrome2, result),
         )
 
         hugr = SlrConverter(prog).hugr()
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_linearity_patterns.py b/python/quantum-pecos/tests/slr_tests/guppy/test_linearity_patterns.py
index 5023bf7cc..d74a56a5a 100644
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_linearity_patterns.py
+++ b/python/quantum-pecos/tests/slr_tests/guppy/test_linearity_patterns.py
@@ -9,7 +9,7 @@
 """
 
 import pytest
-from pecos.slr import Block, CReg, Main, QReg, SlrConverter
+from pecos.slr import Block, CReg, Main, QReg, Return, SlrConverter
 from pecos.slr.qeclib import qubit
 from pecos.slr.qeclib.qubit.measures import Measure
 
@@ -39,6 +39,7 @@ def __init__(self, q: QReg) -> None:
             c := CReg("c", 3),
             PrepareGHZ(q),
             Measure(q) > c,
+            Return(c),
         )
         assert_ast_guppy_compiles(prog)
 
@@ -63,6 +64,7 @@ def __init__(self, q: QReg) -> None:
             ApplyH(q),
             ApplyCNOT(q),
             Measure(q) > c,
+            Return(c),
         )
         assert_ast_guppy_compiles(prog)
 
@@ -86,6 +88,7 @@ def __init__(self, q: QReg, c: CReg) -> None:
             MeasureHalf(q, partial),
             Measure(q[2]) > rest[0],
             Measure(q[3]) > rest[1],
+            Return(partial, rest),
         )
         assert_ast_guppy_compiles(prog)
 
@@ -133,6 +136,7 @@ def __init__(self, q: QReg, c: CReg) -> None:
             c := CReg("c", 2),
             Outer(q, c),
             Measure(q[1]) > c[1],
+            Return(c),
         )
         assert_ast_guppy_compiles(prog)
 
@@ -161,5 +165,6 @@ def __init__(self, data: QReg, ancilla: QReg, result: CReg) -> None:
             final := CReg("final", 1),
             UseAncilla(data, ancilla, result),
             Measure(data[0]) > final[0],
+            Return(result, final),
         )
         assert_ast_guppy_compiles(prog)
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_loop_generation.py b/python/quantum-pecos/tests/slr_tests/guppy/test_loop_generation.py
index c4ce31b92..fff026cbf 100644
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_loop_generation.py
+++ b/python/quantum-pecos/tests/slr_tests/guppy/test_loop_generation.py
@@ -7,7 +7,7 @@
 buggy form and have been deleted.
 """
 
-from pecos.slr import Block, CReg, Main, QReg
+from pecos.slr import Block, CReg, Main, QReg, Return
 from pecos.slr.qeclib import qubit
 from pecos.slr.qeclib.qubit.measures import Measure
 
@@ -25,6 +25,7 @@ def test_consecutive_gate_applications() -> None:
         qubit.H(q[3]),
         qubit.H(q[4]),
         Measure(q) > c,
+        Return(c),
     )
     assert_ast_guppy_compiles(prog)
 
@@ -36,6 +37,7 @@ def test_register_wide_generates_loop() -> None:
         c := CReg("c", 5),
         qubit.H(q),
         Measure(q) > c,
+        Return(c),
     )
     assert_ast_guppy_compiles(prog)
 
@@ -50,6 +52,7 @@ def test_mixed_individual_and_register_wide() -> None:
         qubit.X(q[2]),
         qubit.Z(q),
         Measure(q) > c,
+        Return(c),
     )
     assert_ast_guppy_compiles(prog)
 
@@ -70,6 +73,7 @@ def __init__(self, q: QReg) -> None:
         c := CReg("c", 4),
         ApplyHadamards(q),
         Measure(q) > c,
+        Return(c),
     )
     assert_ast_guppy_compiles(prog)
 
@@ -84,6 +88,7 @@ def test_different_gates_separate_loops() -> None:
         qubit.Y(q),
         qubit.Z(q),
         Measure(q) > c,
+        Return(c),
     )
     assert_ast_guppy_compiles(prog)
 
@@ -98,5 +103,6 @@ def test_multiple_registers() -> None:
         qubit.X(q2),
         Measure(q1) > c[0:3],
         Measure(q2) > c[3:6],
+        Return(c),
     )
     assert_ast_guppy_compiles(prog)
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_measurement_optimization.py b/python/quantum-pecos/tests/slr_tests/guppy/test_measurement_optimization.py
index a3aa1d061..b9e0abb35 100644
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_measurement_optimization.py
+++ b/python/quantum-pecos/tests/slr_tests/guppy/test_measurement_optimization.py
@@ -8,7 +8,7 @@
 realistic shape.
 """
 
-from pecos.slr import Block, CReg, If, Main, QReg
+from pecos.slr import Block, CReg, If, Main, QReg, Return
 from pecos.slr.qeclib import qubit
 from pecos.slr.qeclib.qubit.measures import Measure
 
@@ -52,5 +52,6 @@ def __init__(self, data: QReg, ancilla: QReg, syndrome: CReg) -> None:
             If(syndrome[1]).Then(
                 qubit.X(data[3]),
             ),
+            Return(syndrome),
         )
         assert_ast_guppy_compiles(prog)
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_multi_qubit_measurements.py b/python/quantum-pecos/tests/slr_tests/guppy/test_multi_qubit_measurements.py
index 773a3af6b..a86ecfa6d 100644
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_multi_qubit_measurements.py
+++ b/python/quantum-pecos/tests/slr_tests/guppy/test_multi_qubit_measurements.py
@@ -7,7 +7,7 @@
 verify the generated Guppy compiles via the v1 harness.
 """
 
-from pecos.slr import CReg, Main, QReg
+from pecos.slr import CReg, Main, QReg, Return
 from pecos.slr.qeclib import qubit
 
 from ..ast_guppy._harness import assert_ast_guppy_compiles  # noqa: TID252
@@ -21,6 +21,7 @@ def test_multi_qubit_with_outputs(self) -> None:
             q := QReg("q", 3),
             c := CReg("c", 3),
             qubit.Measure(q[0], q[1], q[2]) > (c[0], c[1], c[2]),
+            Return(c),
         )
         assert_ast_guppy_compiles(prog)
 
@@ -38,6 +39,7 @@ def test_mixed_measurements(self) -> None:
             qubit.Measure(q[0]) > c[0],
             qubit.Measure(q[1], q[2], q[3]) > (c[1], c[2], c[3]),
             qubit.Measure(q[4]) > c[4],
+            Return(c),
         )
         assert_ast_guppy_compiles(prog)
 
@@ -50,6 +52,7 @@ def test_two_qubit_measurement(self) -> None:
             q := QReg("q", 2),
             c := CReg("c", 2),
             qubit.Measure(q[0], q[1]) > (c[0], c[1]),
+            Return(c),
         )
         assert_ast_guppy_compiles(prog)
 
@@ -58,6 +61,7 @@ def test_many_qubit_measurement(self) -> None:
             q := QReg("q", 7),
             c := CReg("c", 7),
             qubit.Measure(q[0], q[1], q[2], q[3], q[4], q[5], q[6]) > (c[0], c[1], c[2], c[3], c[4], c[5], c[6]),
+            Return(c),
         )
         assert_ast_guppy_compiles(prog)
 
@@ -70,6 +74,7 @@ def test_single_qubit_with_output(self) -> None:
             q := QReg("q", 1),
             c := CReg("c", 1),
             qubit.Measure(q[0]) > c[0],
+            Return(c),
         )
         assert_ast_guppy_compiles(prog)
 
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_partial_array_returns.py b/python/quantum-pecos/tests/slr_tests/guppy/test_partial_array_returns.py
index f2c51a869..76a48fcec 100644
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_partial_array_returns.py
+++ b/python/quantum-pecos/tests/slr_tests/guppy/test_partial_array_returns.py
@@ -8,7 +8,7 @@
 acceptance set in ``tests/slr_tests/ast_guppy/test_v1_acceptance.py``.
 """
 
-from pecos.slr import Block, CReg, Main, QReg
+from pecos.slr import Block, CReg, Main, QReg, Return
 from pecos.slr.qeclib import qubit
 from pecos.slr.qeclib.qubit.measures import Measure
 
@@ -38,6 +38,7 @@ def __init__(self, data: QReg, ancilla: QReg, syndrome: CReg) -> None:
         final := CReg("final", 2),
         MeasureAncillas(data, ancilla, syndrome),
         Measure(data) > final,
+        Return(syndrome, final),
     )
     assert_ast_guppy_compiles(prog)
 
@@ -64,6 +65,7 @@ def __init__(self, q: QReg) -> None:
         SelectEvenQubits(q),
         Measure(q[0]) > result[0],
         Measure(q[2]) > result[1],
+        Return(result),
     )
     assert_ast_guppy_compiles(prog)
 
@@ -89,6 +91,7 @@ def __init__(self, a: QReg, b: QReg, results: CReg) -> None:
         SplitAndMeasure(a, b, results[0:2]),
         Measure(a[1]) > results[2],
         Measure(b[1]) > results[3],
+        Return(results),
     )
     assert_ast_guppy_compiles(prog)
 
@@ -110,5 +113,6 @@ def __init__(self, q: QReg, c: CReg) -> None:
         q := QReg("q", 2),
         c := CReg("c", 2),
         MeasureAll(q, c),
+        Return(c),
     )
     assert_ast_guppy_compiles(prog)
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_partial_consumption.py b/python/quantum-pecos/tests/slr_tests/guppy/test_partial_consumption.py
index ccad3ddda..df29e878f 100644
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_partial_consumption.py
+++ b/python/quantum-pecos/tests/slr_tests/guppy/test_partial_consumption.py
@@ -8,7 +8,7 @@
 """
 
 import pytest
-from pecos.slr import Block, CReg, Main, QReg, SlrConverter
+from pecos.slr import Block, CReg, Main, QReg, Return, SlrConverter
 from pecos.slr.qeclib import qubit
 from pecos.slr.qeclib.qubit.measures import Measure
 
@@ -44,6 +44,7 @@ def __init__(self, data: QReg, ancilla: QReg, syndrome: CReg) -> None:
             MeasureAncillas(data, ancilla, syndrome),
             qubit.X(data[0]),
             Measure(data) > data_result,
+            Return(syndrome, data_result),
         )
         assert_ast_guppy_compiles(prog)
 
@@ -72,6 +73,7 @@ def __init__(self, qubits: QReg, results: CReg) -> None:
             Measure(q[3]) > c_second[0],
             Measure(q[4]) > c_second[1],
             Measure(q[5]) > c_second[2],
+            Return(c_first, c_second),
         )
         assert_ast_guppy_compiles(prog)
 
@@ -100,6 +102,7 @@ def __init__(self, data: QReg, ancilla: QReg, syndrome: CReg) -> None:
             StabilizerMeasurement(data, ancilla, syndrome),
             qubit.Z(data[0]),
             Measure(data) > final,
+            Return(syndrome, final),
         )
         assert_ast_guppy_compiles(prog)
 
@@ -119,6 +122,7 @@ def __init__(self, q: QReg, c: CReg) -> None:
             single := QReg("single", 1),
             result := CReg("result", 1),
             MeasureSingle(single, result),
+            Return(result),
         )
         assert_ast_guppy_compiles(prog)
 
@@ -132,6 +136,7 @@ def test_hugr_compilation(self) -> None:
             Measure(q[0]) > c[0],
             Measure(q[1]) > c[1],
             Measure(q[2]) > c[2],
+            Return(c),
         )
 
         # This should compile without errors
@@ -159,6 +164,7 @@ def __init__(self, q: QReg) -> None:
             c := CReg("c", 2),
             DoNothing(q),
             Measure(q) > c,
+            Return(c),
         )
         assert_ast_guppy_compiles(prog)
 
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_simple_slr_to_guppy.py b/python/quantum-pecos/tests/slr_tests/guppy/test_simple_slr_to_guppy.py
index af78b1bfb..c58c8aef3 100644
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_simple_slr_to_guppy.py
+++ b/python/quantum-pecos/tests/slr_tests/guppy/test_simple_slr_to_guppy.py
@@ -8,7 +8,7 @@
 set.
 """
 
-from pecos.slr import Block, CReg, Main, QReg
+from pecos.slr import Block, CReg, Main, QReg, Return
 from pecos.slr.qeclib import qubit as qb
 from pecos.slr.qeclib.qubit.measures import Measure
 from pecos.slr.qeclib.qubit.preps import Prep
@@ -35,6 +35,7 @@ def __init__(self, q: QReg, c: CReg) -> None:
         ResetQubit(q, c[0:1]),
         ResetQubit(q, c[1:2]),
         ResetQubit(q, c[2:3]),
+        Return(c),
     )
     assert_ast_guppy_compiles(prog)
 
@@ -57,5 +58,6 @@ def __init__(self, q: QReg, c: CReg) -> None:
         c := CReg("c", 1),
         MeasureAndReset(q, c),
         qb.X(q[0]),
+        Return(c),
     )
     assert_ast_guppy_compiles(prog)
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py b/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py
index 9b6d0f9f5..c7b93a75b 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py
@@ -3,18 +3,7 @@
 import re
 
 import pytest
-from pecos.slr import (
-    Barrier,
-    Block,
-    Comment,
-    CReg,
-    If,
-    Main,
-    Parallel,
-    QReg,
-    Repeat,
-    SlrConverter,
-)
+from pecos.slr import Barrier, Block, Comment, CReg, If, Main, Parallel, QReg, Repeat, Return, SlrConverter
 from pecos.slr.qeclib import qubit as p
 from pecos.slr.qeclib.steane.steane_class import Steane
 
@@ -62,6 +51,7 @@ def telep(prep_basis: str, meas_basis: str) -> str:
         If(m_bell[0] == 0).Then(sout.z()),
         # Final output stored in `m_out[0]`
         sout.m(meas_basis, m_out[0]),
+        Return(m_bell, m_out),
     )
 
 
@@ -74,6 +64,7 @@ def test_bell_qir() -> None:
         p.H(q[0]),
         p.CX(q[0], q[1]),
         p.Measure(q) > m,
+        Return(m),
     )
 
     qir = SlrConverter(prog).qir()
@@ -89,6 +80,7 @@ def test_bell_qreg_qir() -> None:
         p.H(q),
         p.CX(q[0], q[1]),
         p.Measure(q) > m,
+        Return(m),
     )
 
     qir = SlrConverter(prog).qir()
@@ -104,6 +96,7 @@ def test_qir_creg_size_too_large() -> None:
         p.H(q[0]),
         p.CX(q[0], q[1]),
         p.Measure(q) > m,
+        Return(m),
     )
 
     with pytest.raises(
@@ -146,6 +139,7 @@ def test_control_flow_qir() -> None:
         Barrier(q[1], q[0]),
         p.RX[0.3](q[0]),
         p.Measure(q) > m,
+        Return(m),
     )
     qir = SlrConverter(prog).qir()
     assert "__quantum__qis__h__body" in qir
@@ -162,6 +156,7 @@ def test_plus_qir() -> None:
         m.set(2),
         n.set(2),
         o.set(m + n),
+        Return(m, n, o),
     )
     qir = SlrConverter(prog).qir()
     assert "add" in qir
@@ -180,6 +175,7 @@ def test_nested_xor_qir() -> None:
         n.set(2),
         o.set(2),
         p[0].set((m[0] ^ n[0]) ^ o[0]),
+        Return(m, n, o, p),
     )
     qir = SlrConverter(prog).qir()
     assert "xor" in qir
@@ -196,6 +192,7 @@ def test_minus_qir() -> None:
         m.set(2),
         n.set(2),
         o.set(m - n),
+        Return(m, n, o),
     )
     qir = SlrConverter(prog).qir()
     assert "sub" in qir
@@ -225,6 +222,7 @@ def test_sx_sxdg() -> None:
         p.SX(q[0]),
         p.SXdg(q[1]),
         p.Measure(q) > m,
+        Return(m),
     )
 
     qir = SlrConverter(prog).qir()
@@ -244,6 +242,7 @@ def test_parallel_qir() -> None:
             p.Z(q[3]),
         ),
         p.Measure(q) > m,
+        Return(m),
     )
     qir = SlrConverter(prog).qir()
     assert "__quantum__qis__h__body" in qir
@@ -268,6 +267,7 @@ def test_nested_parallel_qir() -> None:
         ),
         Barrier(q),
         p.Measure(q) > m,
+        Return(m),
     )
     qir = SlrConverter(prog).qir()
     assert "__quantum__qis__h__body" in qir
@@ -299,6 +299,7 @@ def test_parallel_in_control_flow_qir() -> None:
             ),
         ),
         p.Measure(q) > m,
+        Return(m),
     )
     qir = SlrConverter(prog).qir()
     assert "__quantum__qis__h__body" in qir
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/conftest.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/conftest.py
index 480179312..d5397f9d7 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/conftest.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/conftest.py
@@ -1,7 +1,7 @@
 """Pytest fixtures for SLR tests."""
 
 import pytest
-from pecos.slr import CReg, Main, Permute, QReg
+from pecos.slr import CReg, Main, Permute, QReg, Return
 from pecos.slr.qeclib import qubit
 
 
@@ -19,6 +19,7 @@ def basic_permutation_program() -> tuple:
             [b[1], a[0]],
         ),
         a[0].set(1),  # Should become b[1] = 1 after permutation
+        Return(a, b),
     )
 
     return prog, a, b
@@ -38,6 +39,7 @@ def same_register_permutation_program() -> tuple:
         a[0].set(1),  # Should become a[2] = 1
         a[1].set(0),  # Should become a[0] = 0
         a[2].set(1),  # Should become a[1] = 1
+        Return(a),
     )
 
     return prog, a
@@ -88,6 +90,7 @@ def measurement_program() -> tuple:
         # Apply quantum operations
         qubit.H(a[0]),
         qubit.CX(a[0], b[0]),
+        Return(m, n),
     )
 
     return prog, a, b, m, n
@@ -121,6 +124,7 @@ def individual_measurement_program() -> tuple:
         # Add individual measurements
         qubit.Measure(a[0]) > m[0],
         qubit.Measure(a[1]) > m[1],
+        Return(m, n),
     )
 
     return prog, a, b, m, n
@@ -153,6 +157,7 @@ def register_measurement_program() -> tuple:
         qubit.CX(a[0], b[0]),
         # Add register-wide measurement
         qubit.Measure(a) > m,
+        Return(m, n),
     )
 
     return prog, a, b, m, n
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_basic_permutation.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_basic_permutation.py
index 8f5adb9ee..7728f8ef2 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_basic_permutation.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_basic_permutation.py
@@ -3,7 +3,7 @@
 import re
 
 import pytest
-from pecos.slr import CReg, Main, Permute, SlrConverter
+from pecos.slr import CReg, Main, Permute, Return, SlrConverter
 
 # Test fixtures
 
@@ -21,6 +21,7 @@ def create_basic_permutation_program() -> tuple:
             [b[1], a[0]],
         ),
         a[0].set(1),  # Should become b[1] = 1 after permutation
+        Return(a, b),
     )
 
     return prog, a, b
@@ -39,6 +40,7 @@ def create_same_register_permutation_program() -> tuple:
         a[0].set(1),  # Should become a[2] = 1
         a[1].set(0),  # Should become a[0] = 0
         a[2].set(1),  # Should become a[1] = 1
+        Return(a),
     )
 
     return prog, a
@@ -57,6 +59,7 @@ def test_permutation_consistency_for_bits_in_qasm() -> None:
             [b[1], a[0]],
         ),
         a[0].set(1),
+        Return(a, b),
     )
 
     qasm1 = SlrConverter(prog).qasm()
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_complex_permutation.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_complex_permutation.py
index 8b821c401..b2dbdcc67 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_complex_permutation.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_complex_permutation.py
@@ -3,7 +3,7 @@
 import re
 
 import pytest
-from pecos.slr import CReg, If, Main, Permute, QReg, SlrConverter
+from pecos.slr import CReg, If, Main, Permute, QReg, Return, SlrConverter
 from pecos.slr.qeclib import qubit
 
 # QASM Tests
@@ -103,6 +103,7 @@ def test_permutation_with_conditional_qasm() -> None:
         # After permutation: b[0] -> b[1], a[0] -> a[1]
         # So the condition should be on b[1] and the operation should be on a[1]
         If(b[0] == 1).Then(qubit.X(a[0])),
+        Return(b),
     )
 
     qasm = SlrConverter(prog).qasm()
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_conversion_with_qasm.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_conversion_with_qasm.py
index 1e0bbdf42..ea3f94a1d 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_conversion_with_qasm.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_conversion_with_qasm.py
@@ -9,7 +9,7 @@
 )
 
 import pytest
-from pecos.slr import CReg, Main, Parallel, QReg, Repeat, SlrConverter
+from pecos.slr import CReg, Main, Parallel, QReg, Repeat, Return, SlrConverter
 from pecos.slr.gen_codes.gen_quantum_circuit import QuantumCircuitGenerator
 from pecos.slr.qeclib import qubit
 
@@ -23,6 +23,13 @@
     stim = None
 
 
+def _return_declared_cregs(prog: Main) -> Main:
+    cregs = [var for var in prog.vars if isinstance(var, CReg)]
+    if cregs:
+        prog.extend(Return(*cregs))
+    return prog
+
+
 class TestConversionConsistency:
     """Test that different conversion paths produce consistent QASM output."""
 
@@ -38,6 +45,7 @@ def test_bell_state_consistency(self) -> None:
             qubit.CX(q[0], q[1]),
             qubit.Measure(q[0]) > c[0],
             qubit.Measure(q[1]) > c[1],
+            Return(c),
         )
 
         # Get QASM from SLR
@@ -48,7 +56,7 @@ def test_bell_state_consistency(self) -> None:
         generator.generate_block(slr_prog)
         qc = generator.get_circuit()
 
-        reconstructed_slr = SlrConverter.from_quantum_circuit(qc)
+        reconstructed_slr = _return_declared_cregs(SlrConverter.from_quantum_circuit(qc))
         qc_qasm = SlrConverter(reconstructed_slr).qasm(skip_headers=True)
 
         # Check that both QASM outputs contain the same essential operations
@@ -79,13 +87,13 @@ def test_stim_slr_qasm_consistency(self) -> None:
         )
 
         # Convert Stim -> SLR -> QASM
-        slr_prog = SlrConverter.from_stim(stim_circuit)
+        slr_prog = _return_declared_cregs(SlrConverter.from_stim(stim_circuit))
         slr_qasm = SlrConverter(slr_prog).qasm(skip_headers=True)
 
         # Convert SLR -> Stim -> SLR -> QASM
         converter = SlrConverter(slr_prog)
         reconstructed_stim = converter.stim()
-        reconstructed_slr = SlrConverter.from_stim(reconstructed_stim)
+        reconstructed_slr = _return_declared_cregs(SlrConverter.from_stim(reconstructed_stim))
         roundtrip_qasm = SlrConverter(reconstructed_slr).qasm(skip_headers=True)
 
         # Both should contain the same operations
@@ -248,6 +256,7 @@ def test_measurement_consistency(self) -> None:
             qubit.Measure(q[0]) > c[0],
             qubit.Measure(q[1]) > c[1],
             qubit.Measure(q[2]) > c[2],
+            Return(c),
         )
 
         qasm = SlrConverter(prog).qasm(skip_headers=True)
@@ -285,7 +294,7 @@ def test_noise_instruction_handling(self) -> None:
         )
 
         # Convert to SLR (noise should become comments)
-        slr_prog = SlrConverter.from_stim(stim_circuit)
+        slr_prog = _return_declared_cregs(SlrConverter.from_stim(stim_circuit))
         qasm = SlrConverter(slr_prog).qasm(skip_headers=True)
 
         # Quantum operations should be preserved
@@ -312,6 +321,7 @@ def test_qasm_syntax_validity(self) -> None:
             qubit.Measure(q[0]) > c[0],
             qubit.Measure(q[1]) > c[1],
             qubit.Measure(q[2]) > c[2],
+            Return(c),
         )
 
         qasm = SlrConverter(prog).qasm()
@@ -348,6 +358,7 @@ def test_register_declaration_consistency(self) -> None:
             qubit.CX(q1[0], q2[0]),
             qubit.Measure(q1[0]) > c1[0],
             qubit.Measure(q2[0]) > c2[0],
+            Return(c1, c2),
         )
 
         qasm = SlrConverter(prog).qasm()
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_creg_permutation.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_creg_permutation.py
index c90128d0c..43b20af2c 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_creg_permutation.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_creg_permutation.py
@@ -18,6 +18,7 @@ def create_creg_permutation_program() -> tuple:
         pecos.slr.Permute(a, b),
         a[0].set(1),  # Bit-level operation
         a.set(1),  # Register-level operation
+        pecos.slr.Return(a, b),
     )
 
 
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_guppy_generation.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_guppy_generation.py
index feeb9928a..b5489d9e4 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_guppy_generation.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_guppy_generation.py
@@ -26,7 +26,7 @@
     sys.path.insert(0, str(_SLR_TESTS_ROOT))
 
 from ast_guppy._harness import assert_ast_guppy_compiles  # noqa: E402
-from pecos.slr import CReg, Main, QReg, Repeat  # noqa: E402
+from pecos.slr import CReg, Main, QReg, Repeat, Return  # noqa: E402
 from pecos.slr.misc import Permute  # noqa: E402
 from pecos.slr.qeclib import qubit as qb  # noqa: E402
 
@@ -48,6 +48,7 @@ def test_bitwise_operations() -> None:
         # Test NOT operation
         c[6].set(~c[0]),
         c[7].set((c[0] | c[1]) & ~c[2]),
+        Return(c),
     )
 
     guppy_code = SlrConverter(prog).guppy()
@@ -91,6 +92,7 @@ def test_register_operations() -> None:
         qb.X(q[2]),
         qb.CX(q[0], q[1]),
         qb.CX(q[2], q[3]),
+        Return(_c),
     )
     assert_ast_guppy_compiles(prog)
 
@@ -136,6 +138,7 @@ def test_reset_operations() -> None:
         qb.X(q[0]),
         qb.Y(q[1]),
         qb.Z(q[2]),
+        Return(_c),
     )
     assert_ast_guppy_compiles(prog)
 
@@ -152,5 +155,6 @@ def test_permute_operations() -> None:
         Permute(c, d),
         qb.H(a[0]),
         qb.X(b[1]),
+        Return(c, d),
     )
     assert_ast_guppy_compiles(prog)
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_guppy_generation_comprehensive.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_guppy_generation_comprehensive.py
index 2a47c8bff..fbb394b01 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_guppy_generation_comprehensive.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_guppy_generation_comprehensive.py
@@ -33,7 +33,7 @@
     sys.path.insert(0, str(_SLR_TESTS_ROOT))
 
 from ast_guppy._harness import assert_ast_guppy_compiles  # noqa: E402
-from pecos.slr import CReg, If, Main, QReg, SlrConverter  # noqa: E402
+from pecos.slr import CReg, If, Main, QReg, Return, SlrConverter  # noqa: E402
 from pecos.slr.qeclib import qubit as qb  # noqa: E402
 
 
@@ -60,6 +60,7 @@ def test_quantum_teleportation() -> None:
         If(c[0]).Then(
             qb.Z(bob[0]),
         ),
+        Return(c),
     )
     assert_ast_guppy_compiles(prog)
 
@@ -81,6 +82,7 @@ def test_complex_boolean_expressions() -> None:
             c[6].set(~(c[0] & c[1]) | (c[2] ^ c[3])),
             c[7].set(~((c[5] & c[6]) ^ (c[0] | c[3]))),
         ),
+        Return(c),
     )
 
     guppy_code = SlrConverter(prog).guppy()
@@ -120,6 +122,7 @@ def test_empty_blocks_and_edge_cases() -> None:
         qb.Measure(q[0]),
         # Apply gate to register
         qb.Prep(q),
+        Return(c),
     )
 
     guppy_code = SlrConverter(prog).guppy()
@@ -158,6 +161,7 @@ def test_grover_decomposition() -> None:
         # Measure
         qb.Measure(q) > [c[0], c[1]],
         qb.Measure(ancilla[0]) > c[2],
+        Return(c),
     )
     assert_ast_guppy_compiles(prog)
 
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_measurement_unrolling.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_measurement_unrolling.py
index 780449e54..01f17f1ba 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_measurement_unrolling.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_measurement_unrolling.py
@@ -1,7 +1,7 @@
 """Tests for measurement unrolling with permutations in both QASM and QIR generation."""
 
 import pytest
-from pecos.slr import CReg, Main, Permute, QReg, SlrConverter
+from pecos.slr import CReg, Main, Permute, QReg, Return, SlrConverter
 from pecos.slr.qeclib import qubit
 
 
@@ -35,6 +35,7 @@ def create_measurement_unrolling_program() -> tuple:
         qubit.CX(c[0], b[2]),  # Should be CX(a[0], b[2])
         # Register-wide measurement - should be unrolled correctly
         qubit.Measure(a) > m,
+        Return(m),
     )
 
 
@@ -46,8 +47,8 @@ def test_measurement_unrolling_qasm() -> None:
     print("\nProgram structure:")
     print(f"Operations: {[type(op).__name__ for op in prog.ops]}")
 
-    # Get the last operation (should be the Measure operation)
-    measure_op = prog.ops[-1]
+    # Get the last non-Return operation (should be the Measure operation)
+    measure_op = prog.ops[-2]
     print(f"\nMeasure operation: {type(measure_op).__name__}")
     print(f"qargs: {measure_op.qargs}")
     print(f"cout: {measure_op.cout}")
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_pythonic_syntax_example.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_pythonic_syntax_example.py
index c0bc37541..b762b56f4 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_pythonic_syntax_example.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_pythonic_syntax_example.py
@@ -1,6 +1,6 @@
 """Example showing the Pythonic SLR syntax for bitwise operations."""
 
-from pecos.slr import CReg, If, Main, SlrConverter
+from pecos.slr import CReg, If, Main, Return, SlrConverter
 
 
 def test_pythonic_syntax_example() -> None:
@@ -21,6 +21,7 @@ def test_pythonic_syntax_example() -> None:
         # Complex expressions with proper precedence:
         c[5].set((c[0] | c[1]) & (c[2] ^ c[3])),
         c[6].set(~((c[4] & c[5]) ^ (c[0] | c[3]))),
+        Return(c),
     )
 
     guppy_code = SlrConverter(prog).guppy()
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_circuit_conversion.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_circuit_conversion.py
index aa4313644..dee429fb4 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_circuit_conversion.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_circuit_conversion.py
@@ -10,11 +10,18 @@
 
 import pytest
 from pecos.circuits.quantum_circuit import QuantumCircuit
-from pecos.slr import CReg, For, Main, Parallel, QReg, Repeat, SlrConverter
+from pecos.slr import CReg, For, Main, Parallel, QReg, Repeat, Return, SlrConverter
 from pecos.slr.gen_codes.gen_quantum_circuit import QuantumCircuitGenerator
 from pecos.slr.qeclib import qubit
 
 
+def _return_declared_cregs(prog: Main) -> Main:
+    cregs = [var for var in prog.vars if isinstance(var, CReg)]
+    if cregs:
+        prog.extend(Return(*cregs))
+    return prog
+
+
 class TestQuantumCircuitToSLR:
     """Test conversion from QuantumCircuit to SLR format."""
 
@@ -25,7 +32,7 @@ def test_basic_gates(self) -> None:
         qc.append({"X": {0}, "Y": {1}, "Z": {2}})  # Different gates
         qc.append({"S": {0}, "SDG": {1}, "T": {2}})  # Phase gates
 
-        slr_prog = SlrConverter.from_quantum_circuit(qc)
+        slr_prog = _return_declared_cregs(SlrConverter.from_quantum_circuit(qc))
 
         # Convert to QASM to verify structure
         qasm = SlrConverter(slr_prog).qasm(skip_headers=True)
@@ -52,7 +59,7 @@ def test_two_qubit_gates(self) -> None:
         qc.append({"CY": {(1, 2)}})
         qc.append({"CZ": {(0, 3)}})
 
-        slr_prog = SlrConverter.from_quantum_circuit(qc)
+        slr_prog = _return_declared_cregs(SlrConverter.from_quantum_circuit(qc))
         qasm = SlrConverter(slr_prog).qasm(skip_headers=True)
 
         assert "cx q[0],q[1]" in qasm or "cx q[0], q[1]" in qasm
@@ -68,7 +75,7 @@ def test_measurements(self) -> None:
         qc.append({"CX": {(0, 1)}})
         qc.append({"Measure": {0, 1}})
 
-        slr_prog = SlrConverter.from_quantum_circuit(qc)
+        slr_prog = _return_declared_cregs(SlrConverter.from_quantum_circuit(qc))
         qasm = SlrConverter(slr_prog).qasm(skip_headers=True)
 
         assert "reset q[0]" in qasm
@@ -165,6 +172,7 @@ def test_measurements_to_qc(self) -> None:
             qubit.CX(q[0], q[1]),
             qubit.Measure(q[0]) > c[0],
             qubit.Measure(q[1]) > c[1],
+            Return(c),
         )
 
         generator = QuantumCircuitGenerator(_internal=True)
@@ -355,6 +363,7 @@ def test_complex_circuit_preservation(self) -> None:
             qubit.Measure(q[1]) > c[1],
             qubit.Measure(q[2]) > c[2],
             qubit.Measure(q[3]) > c[3],
+            Return(c),
         )
 
         # Convert to QuantumCircuit and back
@@ -362,7 +371,7 @@ def test_complex_circuit_preservation(self) -> None:
         generator.generate_block(prog)
         qc = generator.get_circuit()
 
-        reconstructed = SlrConverter.from_quantum_circuit(qc)
+        reconstructed = _return_declared_cregs(SlrConverter.from_quantum_circuit(qc))
 
         # Both should produce similar QASM
         orig_qasm = SlrConverter(prog).qasm(skip_headers=True)
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_register_permutation.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_register_permutation.py
index 177486356..def6d8c0b 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_register_permutation.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_register_permutation.py
@@ -3,7 +3,7 @@
 import re
 
 import pytest
-from pecos.slr import CReg, Main, Permute, QReg, SlrConverter
+from pecos.slr import CReg, Main, Permute, QReg, Return, SlrConverter
 from pecos.slr.qeclib import qubit
 
 # Test fixtures
@@ -23,6 +23,7 @@ def create_whole_register_permutation_program() -> tuple:
         ),
         b[2].set(1),  # After permutation, this still refers to b[2]
         a[3].set(0),  # After permutation, this still refers to a[3]
+        Return(a, b),
     )
 
 
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_stim_conversion.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_stim_conversion.py
index bc8f0c54f..60abbe3e7 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_stim_conversion.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_stim_conversion.py
@@ -1,9 +1,17 @@
 """Tests for Stim circuit to/from SLR conversion."""
 
 import pytest
-from pecos.slr import CReg, Main, Parallel, QReg, Repeat, SlrConverter
+from pecos.slr import CReg, Main, Parallel, QReg, Repeat, Return, SlrConverter
 from pecos.slr.qeclib import qubit
 
+
+def _return_declared_cregs(prog: Main) -> Main:
+    cregs = [var for var in prog.vars if isinstance(var, CReg)]
+    if cregs:
+        prog.extend(Return(*cregs))
+    return prog
+
+
 # Check if stim is available
 try:
     import stim
@@ -31,7 +39,7 @@ def test_basic_gates(self) -> None:
         """,
         )
 
-        slr_prog = SlrConverter.from_stim(circuit)
+        slr_prog = _return_declared_cregs(SlrConverter.from_stim(circuit))
 
         # Convert back to QASM to verify structure
         qasm = SlrConverter(slr_prog).qasm(skip_headers=True)
@@ -52,7 +60,7 @@ def test_two_qubit_gates(self) -> None:
         """,
         )
 
-        slr_prog = SlrConverter.from_stim(circuit)
+        slr_prog = _return_declared_cregs(SlrConverter.from_stim(circuit))
         qasm = SlrConverter(slr_prog).qasm(skip_headers=True)
 
         assert "cx q[0],q[1]" in qasm or "cx q[0], q[1]" in qasm
@@ -70,7 +78,7 @@ def test_measurements_and_reset(self) -> None:
         """,
         )
 
-        slr_prog = SlrConverter.from_stim(circuit)
+        slr_prog = _return_declared_cregs(SlrConverter.from_stim(circuit))
         qasm = SlrConverter(slr_prog).qasm(skip_headers=True)
 
         assert "reset q[0]" in qasm
@@ -164,6 +172,7 @@ def test_measurements_to_stim(self) -> None:
             qubit.CX(q[0], q[1]),
             qubit.Measure(q[0]) > c[0],
             qubit.Measure(q[1]) > c[1],
+            Return(c),
         )
 
         converter = SlrConverter(prog)
@@ -250,7 +259,7 @@ def test_basic_circuit_round_trip(self) -> None:
         )
 
         # Convert to SLR and back
-        slr_prog = SlrConverter.from_stim(original)
+        slr_prog = _return_declared_cregs(SlrConverter.from_stim(original))
         converter = SlrConverter(slr_prog)
         reconstructed = converter.stim()
 
@@ -272,12 +281,13 @@ def test_slr_round_trip(self) -> None:
             qubit.CX(q[0], q[1]),
             qubit.Measure(q[0]) > c[0],
             qubit.Measure(q[1]) > c[1],
+            Return(c),
         )
 
         # Convert to Stim and back
         converter = SlrConverter(original)
         stim_circuit = converter.stim()
-        reconstructed = SlrConverter.from_stim(stim_circuit)
+        reconstructed = _return_declared_cregs(SlrConverter.from_stim(stim_circuit))
 
         # Convert both to QASM for comparison
         orig_qasm = SlrConverter(original).qasm(skip_headers=True)
diff --git a/python/quantum-pecos/tests/slr_tests/test_partial.py b/python/quantum-pecos/tests/slr_tests/test_partial.py
index 96493636f..9e8786833 100644
--- a/python/quantum-pecos/tests/slr_tests/test_partial.py
+++ b/python/quantum-pecos/tests/slr_tests/test_partial.py
@@ -1,6 +1,6 @@
 """Test partial array consumption in SLR."""
 
-from pecos.slr import Block, CReg, Main, QReg, SlrConverter
+from pecos.slr import Block, CReg, Main, QReg, Return, SlrConverter
 from pecos.slr.qeclib import qubit
 from pecos.slr.qeclib.qubit.measures import Measure
 
@@ -34,6 +34,7 @@ def __init__(self, data: QReg, ancilla: QReg, syndrome: CReg) -> None:
     MeasureAncillas(data, ancilla, syndrome),
     qubit.H(data[0]),
     Measure(data) > result,
+    Return(syndrome, result),
 )
 
 print("Generated Guppy code:")

From 0c0df3d12e8e9102639ff509ef870d11fb7d17a7 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sat, 16 May 2026 13:14:18 -0600
Subject: [PATCH 066/136] Phase 3b S1c: fix logical_steane_code_program example
 -- stale pecos.qeclib import -> pecos.slr.qeclib, prog.qasm() ->
 SlrConverter(prog).qasm() (was doubly-broken/non-runnable), + explicit
 Return(m_bell,m_out)/(m_reject,m_t,m_out) so it is S3-safe. Now runs
 end-to-end; wrapped regression test (own copies) still green.

---
 .../python_examples/logical_steane_code_program.py | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/examples/python_examples/logical_steane_code_program.py b/examples/python_examples/logical_steane_code_program.py
index a9c6520c8..bb1a758da 100644
--- a/examples/python_examples/logical_steane_code_program.py
+++ b/examples/python_examples/logical_steane_code_program.py
@@ -16,8 +16,8 @@
 computation with error correction circuits.
 """
 
-from pecos.qeclib.steane.steane_class import Steane
-from pecos.slr import Barrier, CReg, If, Main
+from pecos.slr import Barrier, CReg, If, Main, Return, SlrConverter
+from pecos.slr.qeclib.steane.steane_class import Steane
 
 # Turn of Black's formatting to allow for newline spacing below:
 # fmt: off
@@ -73,9 +73,12 @@ def telep(prep_basis: str, meas_basis: str) -> str:
 
         # Final output stored in `m_out[0]`
         sout.m(meas_basis, m_out[0]),
+
+        # Expose classical results explicitly (Phase 3b: no implicit return).
+        Return(m_bell, m_out),
     )
 
-    return prog.qasm()  # Convert the program to extended OpenQASM 2.0
+    return SlrConverter(prog).qasm()  # Convert the program to extended OpenQASM 2.0
 
 
 def t_gate(prep_basis: str, meas_basis: str) -> str:
@@ -121,8 +124,11 @@ def t_gate(prep_basis: str, meas_basis: str) -> str:
 
         # Final output stored in `m_out[1]`
         sin.m(meas_basis, m_out[1]),
+
+        # Expose classical results explicitly (Phase 3b: no implicit return).
+        Return(m_reject, m_t, m_out),
     )
 
-    return prog.qasm()
+    return SlrConverter(prog).qasm()
 
 # fmt: on

From 4c9f53de7ede5dbd049c1ef422c2db535b57d167 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sat, 16 May 2026 13:27:49 -0600
Subject: [PATCH 067/136] Phase 3b S2: remove Phase-2 implicit-return warning
 machinery (slr_converter) + CReg(result=False) warning (vars.py, kwarg kept
 for S3); revert now-moot per-case audit enforcement to plain hugr() (option
 5a); rewrite test_deprecation_warnings into post-S2 no-warning contract
 tests. gen_codes legacy deprecations untouched. Independently verified: audit
 31/31, suite 1121 pass byte-identical, ruff/black clean.

---
 .../src/pecos/slr/slr_converter.py            | 138 --------
 python/quantum-pecos/src/pecos/slr/vars.py    |  12 -
 .../tests/slr_tests/ast_guppy/audit_runner.py |  11 +-
 .../ast_guppy/test_deprecation_warnings.py    | 294 ++++--------------
 4 files changed, 67 insertions(+), 388 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/slr_converter.py b/python/quantum-pecos/src/pecos/slr/slr_converter.py
index 065c451b8..9609231d7 100644
--- a/python/quantum-pecos/src/pecos/slr/slr_converter.py
+++ b/python/quantum-pecos/src/pecos/slr/slr_converter.py
@@ -46,44 +46,12 @@ def __init__(self, block: Main | None = None, *, optimize_parallel: bool = True)
         self._original_block = block
         self._block = block
         self._optimize_parallel = optimize_parallel
-        # Phase 2: fire deprecation warning once per SlrConverter for any
-        # program that relies on the implicit-return rule. Cached so multiple
-        # codegen calls on the same converter do not spam the user.
-        self._implicit_return_warned = False
 
         # Apply transformations if requested and block is provided
         if block is not None and optimize_parallel:
             optimizer = ParallelOptimizer()
             self._block = optimizer.transform(self._block)
 
-    def _maybe_warn_implicit_return_deprecation(self) -> None:
-        """Phase 2 deprecation: warn once per converter when implicit return is in use.
-
-        Fires from every user-facing codegen entry point (`.qasm()`,
-        `.qir()`, `.qir_bc()`, `.guppy()`, `.hugr()`, `.stim()`,
-        `.quantum_circuit()`, `.generate(...)`). SLR-wide rather than
-        Guppy/HUGR-only -- the v2 Phase 3b breaking change is an SLR-API
-        change (drop `result=` kwarg + mandatory Return) that affects every
-        downstream codegen consumer.
-
-        Walks the SLR block directly (not the AST) so we don't trip the
-        slr-to-ast converter on programs the Guppy v1 preflight is supposed
-        to reject (e.g. symbolic LoopVar indexing). Means we read SLR-level
-        Measure.cout and CReg.result, not AST MeasureOp.results / RegisterDecl.is_result.
-
-        Stacklevel attribution: this method is called directly from the
-        public entry point, so `warnings.warn(..., stacklevel=3)` walks
-        past the warn site, past this method, past the public method, and
-        attributes the warning to the user's call site.
-        """
-        if self._implicit_return_warned or self._original_block is None:
-            return
-        self._implicit_return_warned = True  # Cache early to avoid re-walk on cycle.
-        import warnings
-
-        if _slr_block_relies_on_implicit_return(self._original_block):
-            warnings.warn(_IMPLICIT_RETURN_WARNING_MSG, DeprecationWarning, stacklevel=3)
-
     def _to_ast(self):
         """Convert the SLR block to AST."""
         if self._block is None:
@@ -112,7 +80,6 @@ def generate(
             Generated code as a string
         """
         del add_versions  # Deprecated parameter, kept for backwards compatibility
-        self._maybe_warn_implicit_return_deprecation()
         if target == Language.QASM:
             return self._generate_qasm(include_header=not skip_headers)
         if target in [Language.QIR, Language.QIRBC]:
@@ -179,7 +146,6 @@ def qasm(self, *, skip_headers: bool = False, add_versions: bool = False) -> str
             Generated QASM code as a string
         """
         del add_versions  # Deprecated parameter, kept for backwards compatibility
-        self._maybe_warn_implicit_return_deprecation()
         return self._generate_qasm(include_header=not skip_headers)
 
     def qir(self) -> str:
@@ -188,7 +154,6 @@ def qir(self) -> str:
         Returns:
             Generated QIR code as a string
         """
-        self._maybe_warn_implicit_return_deprecation()
         return self._generate_qir()
 
     def qir_bc(self) -> bytes:
@@ -197,7 +162,6 @@ def qir_bc(self) -> bytes:
         Returns:
             Generated QIR bytecode
         """
-        self._maybe_warn_implicit_return_deprecation()
         return self._generate_qir(bytecode=True)
 
     def guppy(self) -> str:
@@ -206,7 +170,6 @@ def guppy(self) -> str:
         Returns:
             Generated Guppy code as a string
         """
-        self._maybe_warn_implicit_return_deprecation()
         return self._generate_guppy()
 
     def hugr(self):
@@ -219,7 +182,6 @@ def hugr(self):
             ImportError: If guppylang is not available
             RuntimeError: If compilation fails
         """
-        self._maybe_warn_implicit_return_deprecation()
         return self._compile_hugr()
 
     def _compile_hugr(self):
@@ -274,7 +236,6 @@ def stim(self) -> stim.Circuit:
         """
         from pecos.slr.ast.codegen.stim import ast_to_stim
 
-        self._maybe_warn_implicit_return_deprecation()
         ast = self._to_ast()
         return ast_to_stim(ast)
 
@@ -286,7 +247,6 @@ def quantum_circuit(self) -> QuantumCircuit:
         """
         from pecos.slr.ast.codegen.quantum_circuit import ast_to_quantum_circuit
 
-        self._maybe_warn_implicit_return_deprecation()
         ast = self._to_ast()
         return ast_to_quantum_circuit(ast)
 
@@ -348,104 +308,6 @@ def from_quantum_circuit(cls, qc, *, optimize_parallel: bool = True):
         return slr_block
 
 
-def _slr_block_relies_on_implicit_return(block) -> bool:
-    """True if the v1 emitter would expose any CReg via the implicit-return rule.
-
-    Walks the SLR-level Main block (`block.vars`, `block.ops`) rather than the
-    AST so we don't trigger slr-to-ast conversion on programs the Guppy v1
-    preflight should reject (e.g. symbolic LoopVar indexing in `For(i,
-    range(n))` where `i` is a `LoopVar`).
-
-    Implicit return fires when both:
-
-    1. The block has no top-level `Return(...)` (no explicit Return).
-    2. There exists at least one CReg the emitter would include in `main`'s
-       return tuple:
-       a. A declared CReg in `block.vars` with `result=True` (the default) --
-          exposed even if never measured (auto-init to all-False).
-       b. A CReg referenced as a `Measure(...) > ...` target where `c` is
-          NOT in `block.vars` -- inline CRegs inferred at AST time get
-          `is_result=True` automatically.
-
-    Programs with `Measure(q[0])` (no `> c[i]`) or measuring exclusively
-    into declared `result=False` CRegs do NOT trigger.
-    """
-    # Class names used for SLR-level type matching. Avoids cyclic imports
-    # at module load time.
-    if _slr_block_has_explicit_return(block):
-        return False
-
-    declared_creg_names: set[str] = set()
-    has_declared_result_creg = False
-    for var in getattr(block, "vars", ()):
-        if type(var).__name__ == "CReg":
-            declared_creg_names.add(getattr(var, "sym", ""))
-            if getattr(var, "result", True):
-                has_declared_result_creg = True
-    if has_declared_result_creg:
-        return True
-
-    return _slr_walk_for_inline_measure_target(getattr(block, "ops", ()), declared_creg_names)
-
-
-def _slr_block_has_explicit_return(block) -> bool:
-    """True if `block` has a top-level Return statement."""
-    return any(type(op).__name__ == "Return" for op in getattr(block, "ops", ()))
-
-
-def _slr_walk_for_inline_measure_target(ops, declared_creg_names: set[str]) -> bool:
-    """Recurse SLR ops for any Measure-into-inline-CReg target."""
-    for op in ops:
-        type_name = type(op).__name__
-        if type_name == "Measure":
-            cout = getattr(op, "cout", None)
-            if cout is not None and _slr_measure_target_has_inline_creg(cout, declared_creg_names):
-                return True
-        elif type_name == "If":
-            # If has `.ops` (Then-branch) and `.else_block` (an Else Block or None).
-            if _slr_walk_for_inline_measure_target(getattr(op, "ops", ()), declared_creg_names):
-                return True
-            else_block = getattr(op, "else_block", None)
-            if else_block is not None and _slr_walk_for_inline_measure_target(
-                getattr(else_block, "ops", ()),
-                declared_creg_names,
-            ):
-                return True
-        elif hasattr(op, "ops"):
-            # Any other Block subclass (Repeat, For, While, Parallel, plain Block) has `.ops`.
-            if _slr_walk_for_inline_measure_target(op.ops, declared_creg_names):
-                return True
-    return False
-
-
-def _slr_measure_target_has_inline_creg(target, declared_creg_names: set[str]) -> bool:
-    """True if a Measure cout target tree references an undeclared CReg.
-
-    SLR Measure cout shapes vary by target:
-    - `Measure(q[i]) > c[j]` stores a Bit (`bit.reg` names the CReg).
-    - `Measure(q) > CReg("c", n)` stores the CReg itself.
-    - `Measure(q) > c[i:j]` stores a list of Bit objects inside the cout tuple.
-
-    All three are implicit-return sources when the CReg is not declared in
-    `Main(...)`.
-    """
-    if isinstance(target, (list, tuple)):
-        return any(_slr_measure_target_has_inline_creg(item, declared_creg_names) for item in target)
-
-    reg = getattr(target, "reg", None)
-    reg_name = getattr(reg, "sym", None) if reg is not None else getattr(target, "sym", None)
-    return reg_name is not None and reg_name not in declared_creg_names
-
-
-_IMPLICIT_RETURN_WARNING_MSG = (
-    "Implicit return of result-flagged CRegs from `Main(...)` is deprecated "
-    "and will be removed in the SLR v2 breaking transition (Phase 3b). Add "
-    "an explicit `Return(...)` listing the CRegs (or values) you want exposed; "
-    "mid-program measurement output can use `Print(...)`. See pecos-docs "
-    "design/slr/v2-breaking-migration.md for migration guidance."
-)
-
-
 def _load_and_compile_entry(temp_file, module_name: str):
     """Import the AST-generated module from `temp_file` and compile its `entry()`.
 
diff --git a/python/quantum-pecos/src/pecos/slr/vars.py b/python/quantum-pecos/src/pecos/slr/vars.py
index 6b4455e78..4cc5f8f23 100644
--- a/python/quantum-pecos/src/pecos/slr/vars.py
+++ b/python/quantum-pecos/src/pecos/slr/vars.py
@@ -12,8 +12,6 @@
 
 from __future__ import annotations
 
-import warnings
-
 from pecos.slr.cops import SET, PyCOp
 
 # TODO: Make it a VarDef
@@ -232,16 +230,6 @@ def __init__(self, sym: str, size: int, *, result: bool = True) -> None:
         """
         super().__init__(sym, size, elem_type=Bit)
         self.result = result
-        if result is False:
-            warnings.warn(
-                "`CReg(..., result=False)` is deprecated and will be removed in "
-                "the SLR v2 breaking transition (Phase 3b). Use explicit "
-                "`Return(...)` and `Print(...)` to control which registers are "
-                "exposed to the runtime. See pecos-docs "
-                "design/slr/v2-breaking-migration.md for migration guidance.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
 
     @property
     def _symbolic_elem_type(self) -> type[SymbolicBit]:
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
index cc3d665ba..a8bd1b1af 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
@@ -37,7 +37,6 @@
 
 import sys
 import traceback
-import warnings
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
@@ -825,15 +824,7 @@ def _run_case(case: AuditCase) -> AuditResult:
         )
 
     try:
-        with warnings.catch_warnings():
-            warnings.simplefilter("default", DeprecationWarning)
-            if case.expected_failure is None:
-                warnings.filterwarnings(
-                    "error",
-                    message=r"Implicit return of result-flagged CRegs",
-                    category=DeprecationWarning,
-                )
-            SlrConverter(prog).hugr()
+        SlrConverter(prog).hugr()
     except BaseException as exc:
         expected = _expected_result(case, exc)
         if expected is not None:
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_deprecation_warnings.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_deprecation_warnings.py
index ecabe8ea0..33f0e4120 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_deprecation_warnings.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_deprecation_warnings.py
@@ -9,290 +9,128 @@
 # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 # specific language governing permissions and limitations under the License.
 
-"""Phase 2 deprecation warnings for v2 SLR output-model redesign.
+"""Post-S2 contracts for the Phase 3b output-model migration.
 
-v2's breaking transition (Phase 3b in
-`~/Repos/pecos-docs/design/slr/v2-breaking-migration.md`) will:
-
-- Remove the `result=` kwarg from `CReg`.
-- Make `Return(...)` mandatory for any exposed output; drop the implicit
-  return-of-all-result-CRegs rule.
-
-Phase 2 (this commit) gives users one release of warning before the breaking
-flip. Both warnings are `DeprecationWarning` so CI surfaces them under
-`-W error::DeprecationWarning` without breaking default usage.
+S2 removes the Phase-2 deprecation warnings only. It intentionally does not
+remove the `CReg(result=...)` kwarg and does not yet remove the implicit-return
+code path; those hard breaking changes are S3. These tests pin the S2 boundary:
+old warning-producing programs still work, but no Phase-2 DeprecationWarning is
+emitted.
 """
 
 from __future__ import annotations
 
 import warnings
+from typing import TYPE_CHECKING, TypeVar
 
-import pytest
 from pecos.slr import CReg, Main, QReg, Return, SlrConverter
 from pecos.slr.qeclib import qubit as qb
 from pecos.slr.qeclib.qubit.measures import Measure
 
+from ._selene_harness import run_ast_guppy_via_selene  # noqa: TID252
 
-class TestCRegResultKwargDeprecation:
-    """`CReg(..., result=False)` warns at construction time."""
+if TYPE_CHECKING:
+    from collections.abc import Callable
 
-    def test_creg_with_result_false_emits_deprecation_warning(self) -> None:
-        with pytest.warns(DeprecationWarning, match=r"`CReg\(\.\.\., result=False\)`"):
-            CReg("c", 1, result=False)
+T = TypeVar("T")
 
-    def test_creg_with_default_result_does_not_warn(self) -> None:
-        """The default (result=True) is the legacy behavior; don't warn on it.
 
-        That avoids spamming every existing SLR program with deprecation
-        noise. Programs that explicitly opt into result=False get the warning.
-        """
-        with warnings.catch_warnings():
-            warnings.simplefilter("error")  # turn any warning into a test failure
-            CReg("c", 1)
+def _run_without_deprecation_warning(func: Callable[[], T]) -> T:
+    """Run `func` and fail if any DeprecationWarning is emitted."""
+    with warnings.catch_warnings(record=True) as caught:
+        warnings.simplefilter("always", DeprecationWarning)
+        result = func()
+
+    deprecations = [warning for warning in caught if issubclass(warning.category, DeprecationWarning)]
+    assert deprecations == [], f"expected no DeprecationWarning, got {[str(w.message) for w in deprecations]}"
+    return result
+
+
+class TestCRegResultKwargPostS2:
+    """`result=` is still accepted in S2, but no longer warns."""
+
+    def test_creg_with_result_false_does_not_warn(self) -> None:
+        c = _run_without_deprecation_warning(lambda: CReg("c", 1, result=False))
+        assert c.result is False
 
     def test_creg_with_explicit_result_true_does_not_warn(self) -> None:
-        """Explicit result=True is also the default behavior; not deprecated."""
-        with warnings.catch_warnings():
-            warnings.simplefilter("error")
-            CReg("c", 1, result=True)
+        c = _run_without_deprecation_warning(lambda: CReg("c", 1, result=True))
+        assert c.result is True
 
-    def test_warning_points_at_user_call_site(self) -> None:
-        """The DeprecationWarning's stacklevel should attribute to the user code,
-        not to CReg.__init__ itself. Use stacklevel=2 so the warning's filename
-        matches this test file.
-        """
-        with pytest.warns(DeprecationWarning, match=r"`CReg\(\.\.\., result=False\)`") as record:
-            CReg("c", 1, result=False)
-        assert len(record) == 1
-        # The recorded warning's filename should be this test file.
-        assert "test_deprecation_warnings.py" in record[0].filename
+    def test_creg_with_default_result_does_not_warn(self) -> None:
+        c = _run_without_deprecation_warning(lambda: CReg("c", 1))
+        assert c.result is True
 
 
-class TestImplicitReturnDeprecation:
-    """Programs with measurements but no explicit `Return(...)` warn at
-    `.guppy()` / `.hugr()` time.
-    """
+class TestImplicitReturnPostS2:
+    """Implicit-return programs still work in S2, but no longer warn."""
 
-    def test_implicit_return_warns_on_program_with_measure_no_return(self) -> None:
-        """Classic v1 pattern: Measure into result CReg, no explicit Return.
-        v2 will require Return; warn now.
-        """
+    def test_implicit_return_program_still_compiles_without_warning(self) -> None:
         prog = Main(
             q := QReg("q", 1),
             c := CReg("c", 1),
             qb.X(q[0]),
             Measure(q[0]) > c[0],
         )
-        with pytest.warns(DeprecationWarning, match=r"Implicit return"):
-            SlrConverter(prog).guppy()
 
-    def test_explicit_return_silences_warning(self) -> None:
-        """With explicit Return, no deprecation warning fires."""
+        source = _run_without_deprecation_warning(lambda: SlrConverter(prog).guppy())
+        assert "result.c" not in source
+
+    def test_implicit_return_hugr_still_compiles_without_warning(self) -> None:
         prog = Main(
             q := QReg("q", 1),
             c := CReg("c", 1),
             qb.X(q[0]),
             Measure(q[0]) > c[0],
-            Return(c),
-        )
-        with warnings.catch_warnings():
-            # Promote DeprecationWarning to error so any fire = test failure.
-            warnings.simplefilter("error", DeprecationWarning)
-            SlrConverter(prog).guppy()
-
-    def test_no_measurement_does_not_warn(self) -> None:
-        """A program with no Measure has nothing to implicitly return.
-
-        Don't pester users with the implicit-return warning when there's
-        no implicit-return behavior to deprecate.
-        """
-        prog = Main(
-            q := QReg("q", 1),
-            qb.H(q[0]),
         )
-        with warnings.catch_warnings():
-            warnings.simplefilter("error", DeprecationWarning)
-            SlrConverter(prog).guppy()
 
-    def test_empty_main_does_not_warn(self) -> None:
-        prog = Main()
-        with warnings.catch_warnings():
-            warnings.simplefilter("error", DeprecationWarning)
-            SlrConverter(prog).guppy()
-
-    def test_measure_inside_repeat_triggers_warning(self) -> None:
-        """The walker descends into Repeat / For / While / Parallel / If bodies."""
-        from pecos.slr import Repeat
+        package = _run_without_deprecation_warning(lambda: SlrConverter(prog).hugr())
+        assert package is not None
 
+    def test_explicit_return_program_still_runs_through_selene(self) -> None:
         prog = Main(
             q := QReg("q", 1),
             c := CReg("c", 1),
-            Repeat(2).block(qb.X(q[0]), Measure(q[0]) > c[0], qb.Prep(q[0])),
-        )
-        with pytest.warns(DeprecationWarning, match=r"Implicit return"):
-            SlrConverter(prog).guppy()
-
-    def test_measure_inside_if_triggers_warning(self) -> None:
-        from pecos.slr import If
-
-        prog = Main(
-            q := QReg("q", 2),
-            c := CReg("c", 1),
-            d := CReg("d", 1),
             qb.X(q[0]),
             Measure(q[0]) > c[0],
-            If(c[0]).Then(Measure(q[1]) > d[0]).Else(Measure(q[1]) > d[0]),
+            Return(c),
         )
-        with pytest.warns(DeprecationWarning, match=r"Implicit return"):
-            SlrConverter(prog).guppy()
 
-    def test_inline_whole_register_measure_triggers_warning(self) -> None:
-        """Whole-register inline CReg targets store the CReg itself in Measure.cout."""
+        records = _run_without_deprecation_warning(lambda: run_ast_guppy_via_selene(prog, shots=10))
+        assert all(record["measurement_0"] == 1 for record in records)
+
+    def test_inline_whole_register_measure_still_compiles_without_warning(self) -> None:
+        """S1b's whole-register cout shape no longer has a warning detector."""
         prog = Main(
             q := QReg("q", 2),
             Measure(q) > CReg("inline", 2),
         )
-        with pytest.warns(DeprecationWarning, match=r"Implicit return"):
-            SlrConverter(prog).guppy()
 
-    def test_inline_slice_measure_triggers_warning(self) -> None:
-        """Slice targets store a list of Bits inside Measure.cout; recurse into it."""
+        source = _run_without_deprecation_warning(lambda: SlrConverter(prog).guppy())
+        assert "inline" in source
+
+    def test_inline_slice_measure_still_compiles_without_warning(self) -> None:
+        """S1b's slice cout shape no longer has a warning detector."""
         inline = CReg("inline", 2)
         prog = Main(
             q := QReg("q", 2),
             Measure(q) > inline[0:2],
         )
-        with pytest.warns(DeprecationWarning, match=r"Implicit return"):
-            SlrConverter(prog).guppy()
 
-    def test_warning_does_not_block_compilation(self) -> None:
-        """The deprecation warning is non-blocking; .guppy() and .hugr() still
-        succeed. Only Phase 3b makes the breaking change.
-        """
-        prog = Main(
-            q := QReg("q", 1),
-            c := CReg("c", 1),
-            qb.X(q[0]),
-            Measure(q[0]) > c[0],
-        )
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore", DeprecationWarning)
-            source = SlrConverter(prog).guppy()
-            assert "result.c" not in source  # no Print emitted; only return
-            package = SlrConverter(prog).hugr()
-            assert package is not None
+        source = _run_without_deprecation_warning(lambda: SlrConverter(prog).guppy())
+        assert "inline" in source
 
-    def test_warning_points_at_user_call_site(self) -> None:
-        """Stacklevel must attribute to the user's .guppy()/.hugr()/etc. call site,
-        not to internals of slr_converter.py. Empirically verified:
-        stacklevel=3 from `_maybe_warn_implicit_return_deprecation`
-        walks past the warn line, past the helper, past the public method,
-        landing on the user.
-        """
-        prog = Main(
-            q := QReg("q", 1),
-            c := CReg("c", 1),
-            qb.X(q[0]),
-            Measure(q[0]) > c[0],
-        )
-        with pytest.warns(DeprecationWarning, match=r"Implicit return") as record:
-            SlrConverter(prog).guppy()
-        assert len(record) == 1
-        assert (
-            "test_deprecation_warnings.py" in record[0].filename
-        ), f"expected warning attributed to this test file; got {record[0].filename}"
-
-    def test_warning_fires_only_once_per_converter(self) -> None:
-        """Cached on the SlrConverter instance: multiple codegen calls share one warning."""
-        prog = Main(
-            q := QReg("q", 1),
-            c := CReg("c", 1),
-            qb.X(q[0]),
-            Measure(q[0]) > c[0],
-        )
-        converter = SlrConverter(prog)
-        with warnings.catch_warnings(record=True) as caught:
-            warnings.simplefilter("always", DeprecationWarning)
-            converter.guppy()
-            converter.qasm()
-            converter.hugr()
-        deprecation = [w for w in caught if issubclass(w.category, DeprecationWarning)]
-        # Exactly one implicit-return warning across the three codegen calls.
-        implicit_return_warnings = [w for w in deprecation if "Implicit return" in str(w.message)]
-        assert (
-            len(implicit_return_warnings) == 1
-        ), f"expected 1 implicit-return warning across 3 codegen calls, got {len(implicit_return_warnings)}"
-
-    def test_warning_fires_for_qasm_qir_stim_quantum_circuit_too(self) -> None:
-        """Phase 2 deprecation is SLR-wide (not Guppy/HUGR-only): every public
-        codegen entry point on SlrConverter fires the warning, because the
-        v2 breaking change is an SLR-API change downstream consumers all see.
-        """
-        for entry in ("qasm", "guppy", "hugr", "qir", "stim", "quantum_circuit"):
+    def test_result_false_only_measure_still_compiles_without_warning(self) -> None:
+        def build_and_compile() -> str:
+            q = QReg("q", 1)
+            scratch = CReg("scratch", 1, result=False)
             prog = Main(
-                q := QReg("q", 1),
-                c := CReg("c", 1),
+                q,
+                scratch,
                 qb.X(q[0]),
-                Measure(q[0]) > c[0],
+                Measure(q[0]) > scratch[0],
             )
-            with pytest.warns(DeprecationWarning, match=r"Implicit return"):
-                getattr(SlrConverter(prog), entry)()
-
-    def test_measure_with_no_result_does_not_warn(self) -> None:
-        """`Measure(q[0])` without a `> c[i]` results tuple writes to no CReg,
-        so the implicit-return rule is not engaged. Don't warn.
-
-        Tracer-bullet regression: the original walker treated *any*
-        MeasureOp as evidence of implicit-return reliance, which was a
-        false positive for measure-and-discard patterns.
-        """
-        prog = Main(
-            q := QReg("q", 1),
-            qb.X(q[0]),
-            Measure(q[0]),  # discard the result
-        )
-        with warnings.catch_warnings():
-            warnings.simplefilter("error", DeprecationWarning)
-            SlrConverter(prog).guppy()
-
-    def test_measure_into_only_result_false_creg_does_not_warn(self) -> None:
-        """When the only Measure target is a declared `result=False` CReg,
-        nothing flows through the implicit-return rule. Don't warn.
-
-        (The CReg(result=False) construction itself emits its own deprecation;
-        we suppress that here so the test focuses on the implicit-return check.)
-        """
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore", DeprecationWarning)
-            scratch = CReg("scratch", 1, result=False)
-
-        prog = Main(
-            q := QReg("q", 1),
-            scratch,  # declared positional, result=False -> opt-out
-            qb.X(q[0]),
-            Measure(q[0]) > scratch[0],
-        )
-        with warnings.catch_warnings(record=True) as caught:
-            warnings.simplefilter("always", DeprecationWarning)
-            SlrConverter(prog).guppy()
-        # No implicit-return warning should fire.
-        implicit_return_warnings = [w for w in caught if "Implicit return" in str(w.message)]
-        assert len(implicit_return_warnings) == 0, (
-            "result=False-only Measure should not trigger implicit-return warning; "
-            f"got {[str(w.message) for w in implicit_return_warnings]}"
-        )
+            return SlrConverter(prog).guppy()
 
-    def test_declared_result_creg_without_measure_still_warns(self) -> None:
-        """Declared `is_result=True` CRegs are implicitly returned even if never
-        measured (they auto-init to all-False). v2 will require Return; warn.
-
-        This is a positive case where the *Measure-presence* alone is not the
-        trigger -- the trigger is "any is_result=True CReg + no explicit Return".
-        """
-        prog = Main(
-            q := QReg("q", 1),
-            CReg("c", 1),  # declared, default is_result=True; not bound (just registered in Main.vars)
-            qb.X(q[0]),  # no Measure
-        )
-        with pytest.warns(DeprecationWarning, match=r"Implicit return"):
-            SlrConverter(prog).guppy()
+        source = _run_without_deprecation_warning(build_and_compile)
+        assert "scratch" in source

From d03fd9134c827039247ac89eb5542e9650f2c61a Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sat, 16 May 2026 14:04:44 -0600
Subject: [PATCH 068/136] Phase 3b S4: port qir_bc() to AST path
 (binding.parse_assembly bitcode + split diagnostics), fix invalid // builder
 comment so qir() emits parseable LLVM IR, sever legacy gen_qir creg.result
 (S3 blocker; QIRGenerator symbol kept).

---
 .../src/pecos/slr/ast/codegen/qir.py          |  4 --
 .../src/pecos/slr/gen_codes/gen_qir.py        |  4 +-
 .../src/pecos/slr/slr_converter.py            | 37 +++++++++++--------
 3 files changed, 24 insertions(+), 21 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
index 3e87f946a..ed66ab932 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
@@ -29,7 +29,6 @@
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any
 
-import pecos as pc
 from pecos.slr.ast.codegen._block_flatten import flatten_block_calls
 from pecos.slr.ast.nodes import (
     AllocatorDecl,
@@ -226,9 +225,6 @@ def generate(self, program: Program) -> str:
         self._main_func = llvm_ir.Function(self._module, main_fnty, name="main")
         entry_block = self._main_func.append_basic_block(name="entry")
         self._builder = llvm_ir.IRBuilder(entry_block)
-        self._builder.comment(
-            f"// Generated from AST using: PECOS version {pc.__version__}",
-        )
 
         # Setup operator map
         self._setup_op_map()
diff --git a/python/quantum-pecos/src/pecos/slr/gen_codes/gen_qir.py b/python/quantum-pecos/src/pecos/slr/gen_codes/gen_qir.py
index 8fa30eca0..28c287940 100644
--- a/python/quantum-pecos/src/pecos/slr/gen_codes/gen_qir.py
+++ b/python/quantum-pecos/src/pecos/slr/gen_codes/gen_qir.py
@@ -299,7 +299,9 @@ def create_creg(self, creg: CReg):
                 [ir.Constant(ir.IntType(64), creg.size)],
                 f"{creg.sym}",
             ),
-            creg.result,
+            # Phase 3b removed the per-register result flag; all user cregs
+            # are recorded (internal scratch temps still pass False below).
+            True,
         )
 
     def create_qreg(self, qreg: QReg):
diff --git a/python/quantum-pecos/src/pecos/slr/slr_converter.py b/python/quantum-pecos/src/pecos/slr/slr_converter.py
index 9609231d7..d290a37ef 100644
--- a/python/quantum-pecos/src/pecos/slr/slr_converter.py
+++ b/python/quantum-pecos/src/pecos/slr/slr_converter.py
@@ -115,25 +115,30 @@ def _generate_guppy(self) -> str:
 
     def _generate_qir(self, *, bytecode: bool = False) -> str | bytes:
         """Generate QIR code using AST-based codegen."""
-        if bytecode:
-            # QIR bytecode requires the old generator
-            from pecos.slr.gen_codes.gen_qir import QIRGenerator
-
-            if QIRGenerator is None:
-                msg = (
-                    "Trying to compile QIR without the appropriate optional dependencies install. "
-                    "Use optional dependency group `qir` or `all`"
-                )
-                raise ImportError(msg)
-
-            generator = QIRGenerator(_internal=True)
-            generator.generate_block(self._block)
-            return generator.get_bc()
-
         from pecos.slr.ast.codegen.qir import ast_to_qir
 
         ast = self._to_ast()
-        return ast_to_qir(ast)
+        ir_text = ast_to_qir(ast)
+        if not bytecode:
+            return ir_text
+
+        try:
+            from pecos_rslib_llvm import binding
+        except ImportError as exc:
+            msg = (
+                "Trying to compile QIR without the appropriate optional dependencies install. "
+                "Use optional dependency group `qir` or `all`"
+            )
+            raise ImportError(msg) from exc
+
+        try:
+            parsed = binding.parse_assembly(ir_text)
+        except RuntimeError as exc:
+            msg = f"Failed to compile QIR to bitcode: {exc}"
+            raise RuntimeError(msg) from exc
+        bc = parsed.as_bitcode()
+        binding.shutdown()
+        return bc
 
     def qasm(self, *, skip_headers: bool = False, add_versions: bool = False) -> str:
         """Generate QASM code.

From 86d7ef3148730c842f4fab48cab8d569c9009c87 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sat, 16 May 2026 14:50:46 -0600
Subject: [PATCH 069/136] Phase 3b S4 fix: wrap
 binding.parse_assembly().as_bitcode() in the diagnostics try so malformed IR
 raises the wrapped 'Failed to compile QIR to bitcode' error (Codex
 post-review blocker).

---
 python/quantum-pecos/src/pecos/slr/slr_converter.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/slr_converter.py b/python/quantum-pecos/src/pecos/slr/slr_converter.py
index d290a37ef..86e40e543 100644
--- a/python/quantum-pecos/src/pecos/slr/slr_converter.py
+++ b/python/quantum-pecos/src/pecos/slr/slr_converter.py
@@ -132,11 +132,10 @@ def _generate_qir(self, *, bytecode: bool = False) -> str | bytes:
             raise ImportError(msg) from exc
 
         try:
-            parsed = binding.parse_assembly(ir_text)
+            bc = binding.parse_assembly(ir_text).as_bitcode()
         except RuntimeError as exc:
             msg = f"Failed to compile QIR to bitcode: {exc}"
             raise RuntimeError(msg) from exc
-        bc = parsed.as_bitcode()
         binding.shutdown()
         return bc
 

From 43a7835bd375ae5ecbf104bbaf97693aa9a25a3a Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sat, 16 May 2026 15:24:46 -0600
Subject: [PATCH 070/136] Phase 3b S3: remove CReg(result=) kwarg +
 RegisterDecl.is_result field + the v1 implicit-return code path (D-S3-1 b:
 drop EntryWrapperInfo.result_cregs, explicit-Return-only); no-Return ->
 main()->None; rewrite test surface to hard contracts; Codex post-review fixes
 (ISC001 x2 + 4 stale-doc/dead-code).

---
 .../pecos/circuit_converters/hugr_to_ast.py   |   4 +-
 .../pecos/slr/ast/codegen/entry_wrapper.py    |  42 ++----
 .../src/pecos/slr/ast/codegen/guppy.py        |  44 +++----
 .../src/pecos/slr/ast/converter.py            |  11 +-
 .../quantum-pecos/src/pecos/slr/ast/nodes.py  |   1 -
 .../src/pecos/slr/gen_codes/gen_qir.py        |   2 +-
 python/quantum-pecos/src/pecos/slr/vars.py    |   9 +-
 .../test_qasm/random_cases/test_slr_phys.py   |   2 +-
 .../slr/ast_tests/test_ast_codegen_guppy.py   |   5 +-
 .../slr/ast_tests/test_ast_codegen_qir.py     |   2 +-
 .../pecos/slr/ast_tests/test_ast_converter.py |   1 -
 .../pecos/slr/ast_tests/test_ast_nodes.py     |  10 +-
 .../pecos/slr/ast_tests/test_ast_serialize.py |  10 +-
 .../slr_tests/ast_guppy/_selene_harness.py    |  41 +++---
 .../slr_tests/ast_guppy/test_ast_hugr.py      |  20 +--
 .../ast_guppy/test_deprecation_warnings.py    | 124 +++++++-----------
 .../tests/slr_tests/ast_guppy/test_print.py   |  10 +-
 .../ast_guppy/test_qeclib_selene_corpus.py    |  16 +--
 .../slr_tests/ast_guppy/test_v1_behavioral.py |   4 +-
 .../regression/random_cases/test_slr_phys.py  |   2 +-
 20 files changed, 135 insertions(+), 225 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/circuit_converters/hugr_to_ast.py b/python/quantum-pecos/src/pecos/circuit_converters/hugr_to_ast.py
index b8605af81..5c4947f93 100644
--- a/python/quantum-pecos/src/pecos/circuit_converters/hugr_to_ast.py
+++ b/python/quantum-pecos/src/pecos/circuit_converters/hugr_to_ast.py
@@ -276,9 +276,7 @@ def convert(self) -> Program:
             )
 
         # Add classical register declarations for measurement results
-        decl_list.extend(
-            RegisterDecl(name=result_var, size=1, is_result=True) for result_var in self.measurement_results.values()
-        )
+        decl_list.extend(RegisterDecl(name=result_var, size=1) for result_var in self.measurement_results.values())
 
         declarations = tuple(decl_list)
 
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/entry_wrapper.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/entry_wrapper.py
index c36b3c580..3b1bd5c9f 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/entry_wrapper.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/entry_wrapper.py
@@ -17,11 +17,10 @@
 shape. This module builds that wrapper by mirroring the same return-shape
 logic the emitter uses, so the wrapper signature matches main's exactly.
 
-Three modes match `AstToGuppy._return_type`:
+Two modes match `AstToGuppy._return_type`:
 - Explicit `Return(...)` -> pass through main's return value unchanged.
-- One or more result CRegs (declared or inline-from-Measure) -> flatten to
-  `tuple[bool, ...]` for Selene's measurement-record model.
-- Neither -> `entry() -> None` and discard.
+- No `Return(...)` -> `entry() -> None` and discard (Phase 3b removed the
+  implicit return of result-flagged CRegs).
 """
 
 from __future__ import annotations
@@ -54,14 +53,13 @@ class EntryWrapperInfo:
     """Metadata extracted from the AST program for building the wrapper.
 
     `all_creg_sizes` mirrors the emitter's `context.registers` lookup view
-    used by `AstToGuppy._return_value_type`: every declared CReg (regardless
-    of `is_result`) plus every inline-Measure-introduced result CReg. Needed
-    so an explicit `Return(...)` referencing a non-result-flagged declared
-    CReg resolves the same way the emitter does (not as `ValueError`).
+    used by `AstToGuppy._return_value_type`: every declared CReg plus every
+    inline-Measure-introduced CReg. Needed so an explicit `Return(...)`
+    referencing a declared or inline CReg resolves the same way the emitter
+    does (not as `ValueError`).
     """
 
     allocator_sizes: dict[str, int]
-    result_cregs: list[RegisterDecl]
     explicit_return: ReturnOp | None
     all_creg_sizes: dict[str, int]
 
@@ -72,8 +70,8 @@ def build_no_arg_entry_wrapper(program: Program) -> tuple[str, EntryWrapperInfo]
     Returns:
         A `(source, info)` tuple. `source` is the Guppy snippet defining
         `entry()`; concatenate it after the main source. `info` exposes the
-        allocator sizes, result CRegs, and explicit Return (if any) that the
-        caller may need (e.g., Selene's measurement-key generation).
+        allocator sizes and explicit Return (if any) that the caller may
+        need (e.g., Selene's measurement-key generation).
     """
     info = _collect_info(program)
     source = _render_wrapper(info)
@@ -98,10 +96,6 @@ def _collect_info(program: Program) -> EntryWrapperInfo:
     inline_max: dict[str, int] = {}
     _walk_for_measure_results(body, declared, inline_max)
 
-    result_cregs: list[RegisterDecl] = [decl for decl in declared.values() if decl.is_result]
-    for name, max_index in inline_max.items():
-        result_cregs.append(RegisterDecl(name=name, size=max_index + 1, is_result=True))
-
     all_creg_sizes: dict[str, int] = {name: decl.size for name, decl in declared.items()}
     for name, max_index in inline_max.items():
         all_creg_sizes[name] = max_index + 1
@@ -110,7 +104,6 @@ def _collect_info(program: Program) -> EntryWrapperInfo:
 
     return EntryWrapperInfo(
         allocator_sizes=allocator_sizes,
-        result_cregs=result_cregs,
         explicit_return=explicit_return,
         all_creg_sizes=all_creg_sizes,
     )
@@ -143,23 +136,6 @@ def _render_wrapper(info: EntryWrapperInfo) -> str:
     if info.explicit_return is not None:
         body_lines.append(f"    return {call_expr}")
         return_ann = _explicit_return_type(info)
-    elif info.result_cregs:
-        if len(info.result_cregs) == 1:
-            body_lines.append(f"    {info.result_cregs[0].name} = {call_expr}")
-        else:
-            names = ", ".join(decl.name for decl in info.result_cregs)
-            body_lines.append(f"    {names} = {call_expr}")
-
-        flat: list[str] = []
-        for decl in info.result_cregs:
-            flat.extend(f"{decl.name}[{i}]" for i in range(decl.size))
-        return_expr = ", ".join(flat)
-        if len(flat) == 1:
-            return_expr += ","
-        body_lines.append(f"    return {return_expr}")
-
-        bool_count = sum(decl.size for decl in info.result_cregs)
-        return_ann = "tuple[bool]" if bool_count == 1 else "tuple[" + ", ".join(["bool"] * bool_count) + "]"
     else:
         body_lines.append(f"    {call_expr}")
         return_ann = "None"
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
index d395ce6c7..ab6160a0c 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
@@ -214,9 +214,6 @@ def _generate_main(self, program: Program) -> list[str]:
             body_lines.extend(self._emit_explicit_return(explicit_return))
         else:
             body_lines.extend(self._emit_end_cleanup())
-            auto_return = self._auto_return_expr()
-            if auto_return is not None:
-                body_lines.append(f"{self.context.indent()}return {auto_return}")
 
         if body_lines:
             lines.extend(body_lines)
@@ -235,7 +232,8 @@ def _validate_block_decl(self, decl: BlockDecl) -> None:
             # Later iters add qubit/bit bundles.
             is_qubit = isinstance(inp.type_expr, QubitTypeExpr)
             is_qubit_array = isinstance(inp.type_expr, ArrayTypeExpr) and isinstance(
-                inp.type_expr.element, QubitTypeExpr,
+                inp.type_expr.element,
+                QubitTypeExpr,
             )
             is_bit = isinstance(inp.type_expr, BitTypeExpr)
             if not (is_qubit or is_qubit_array or is_bit):
@@ -316,7 +314,7 @@ def _generate_block_decl(self, decl: BlockDecl) -> list[str]:
             if kind == "single_bit":
                 # Register the bit-input name so body BitRefs (`name[0]`) render;
                 # do NOT emit an initializer -- it's a bound parameter.
-                self.context.registers[name] = RegisterDecl(name=name, size=1, is_result=False)
+                self.context.registers[name] = RegisterDecl(name=name, size=1)
             else:
                 # scratch_qubit is registered too: the body's Prep/gates/Measure
                 # still resolve `Slot(name, i)` through linearity. It just has
@@ -437,7 +435,7 @@ def _collect_implicit_measure_registers(self, body: tuple[Statement, ...]) -> No
 
         for register, max_index in max_indices.items():
             if register not in self.context.registers:
-                self.context.registers[register] = RegisterDecl(name=register, size=max_index + 1, is_result=True)
+                self.context.registers[register] = RegisterDecl(name=register, size=max_index + 1)
 
     def _collect_implicit_measure_register_refs(self, stmt: Statement, max_indices: dict[str, int]) -> None:
         if isinstance(stmt, MeasureOp):
@@ -579,10 +577,14 @@ def _reject_alloc(where: str, alloc: str) -> None:
                         continue  # the scratch binding itself -- allowed
                     if isinstance(arg, AllocatorArg) and arg.name in scratch_allocs:
                         _reject_alloc(f"a non-scratch input of BlockCall {stmt.callee!r}", arg.name)
-                    elif isinstance(arg, SingleQubitArg) and (
-                        arg.slot.allocator,
-                        arg.slot.index,
-                    ) in scratch:
+                    elif (
+                        isinstance(arg, SingleQubitArg)
+                        and (
+                            arg.slot.allocator,
+                            arg.slot.index,
+                        )
+                        in scratch
+                    ):
                         _reject(
                             f"a non-scratch input of BlockCall {stmt.callee!r}",
                             (arg.slot.allocator, arg.slot.index),
@@ -608,11 +610,9 @@ def _render_params(self) -> str:
         return ", ".join(f"{name}: array[qubit, {size}] @ owned" for name, size in self.context.root_allocators.items())
 
     def _return_type(self, explicit_return: ReturnOp | None) -> str:
-        if explicit_return is not None:
-            types = [self._return_value_type(value) for value in explicit_return.values]
-            return self._tuple_type(types)
-
-        types = [f"array[bool, {decl.size}]" for decl in self.context.registers.values() if decl.is_result]
+        if explicit_return is None:
+            return "None"
+        types = [self._return_value_type(value) for value in explicit_return.values]
         return self._tuple_type(types)
 
     def _return_value_type(self, value: Expression | str) -> str:
@@ -1313,10 +1313,7 @@ def _validate_block_call_arg(
                 raise GuppyCodegenError(msg)
             input_size = inp.type_expr.size
             if arg.name not in self.context.root_allocators:
-                msg = (
-                    f"BlockCall {callee!r} {position} {arg.name!r} must be an outer root "
-                    "allocator name"
-                )
+                msg = f"BlockCall {callee!r} {position} {arg.name!r} must be an outer root allocator name"
                 raise GuppyCodegenError(msg)
             outer_size = self.context.root_allocators[arg.name]
             if outer_size != input_size:
@@ -1379,7 +1376,8 @@ def _validate_block_call_arg(
 
         if isinstance(arg, QubitBundleArg):
             if not isinstance(inp.type_expr, ArrayTypeExpr) or not isinstance(
-                inp.type_expr.element, QubitTypeExpr,
+                inp.type_expr.element,
+                QubitTypeExpr,
             ):
                 msg = (
                     f"BlockCall {callee!r} {position} for input {inp.name!r}: "
@@ -1619,12 +1617,6 @@ def _emit_classical_permute(self, mapping: dict[BitRef, BitRef]) -> list[str]:
     def _emit_end_cleanup(self) -> list[str]:
         return [f"{self.context.indent()}discard({local})" for _slot, local in self._linearity().discard_live()]
 
-    def _auto_return_expr(self) -> str | None:
-        values = [decl.name for decl in self.context.registers.values() if decl.is_result]
-        if not values:
-            return None
-        return ", ".join(values)
-
     def _emit_explicit_return(self, node: ReturnOp) -> list[str]:
         values = [self._return_value_expr(value) for value in node.values]
         lines = self._emit_end_cleanup()
diff --git a/python/quantum-pecos/src/pecos/slr/ast/converter.py b/python/quantum-pecos/src/pecos/slr/ast/converter.py
index ab50aec96..858c6d3d1 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/converter.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/converter.py
@@ -310,7 +310,6 @@ def _convert_var_to_declaration(self, var: Any):
             return RegisterDecl(
                 name=var.sym,
                 size=var.size,
-                is_result=getattr(var, "result", True),
             )
 
         if var_class == "QAlloc":
@@ -490,9 +489,7 @@ def _claim_bit(reg: str, index: int, *, here: str, owner: str) -> None:
                     msg = f"{where}: empty {type(var).__name__} bundle is not supported"
                     raise ValueError(msg)
                 if all(isinstance(e, Qubit) for e in var):
-                    slots = tuple(
-                        SlotRef(allocator=e.reg.sym, index=e.index) for e in var
-                    )
+                    slots = tuple(SlotRef(allocator=e.reg.sym, index=e.index) for e in var)
                     type_expr = ArrayTypeExpr(element=QubitTypeExpr(), size=len(var))
                     arg = QubitBundleArg(slots=slots)
                     for k, e in enumerate(var):
@@ -1119,10 +1116,7 @@ def _validate_scratch_input(
         )
         raise ValueError(msg)
     if not events:
-        msg = (
-            f"{where}: declared SCRATCH but never used in the block body "
-            "(expected Prep(...) then Measure(...))"
-        )
+        msg = f"{where}: declared SCRATCH but never used in the block body (expected Prep(...) then Measure(...))"
         raise ValueError(msg)
     if events[0] != "PREP":
         msg = (
@@ -1170,4 +1164,3 @@ def _validate_scratch_input(
             "qubit before returning (S2 allocates it internally)"
         )
         raise ValueError(msg)
-
diff --git a/python/quantum-pecos/src/pecos/slr/ast/nodes.py b/python/quantum-pecos/src/pecos/slr/ast/nodes.py
index e7c8303c1..1528379c9 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/nodes.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/nodes.py
@@ -380,7 +380,6 @@ class RegisterDecl(Declaration):
 
     name: str
     size: int
-    is_result: bool = True
 
 
 # =============================================================================
diff --git a/python/quantum-pecos/src/pecos/slr/gen_codes/gen_qir.py b/python/quantum-pecos/src/pecos/slr/gen_codes/gen_qir.py
index 28c287940..83be6d714 100644
--- a/python/quantum-pecos/src/pecos/slr/gen_codes/gen_qir.py
+++ b/python/quantum-pecos/src/pecos/slr/gen_codes/gen_qir.py
@@ -322,7 +322,7 @@ def _generate_results(self) -> None:
         """Generates the proper results calls at the end of the SLR program,
         according to all the classical registers that were defined."""
         for reg_name, (reg_inst, result) in self._creg_dict.items():
-            if not result:  # ignore non-result cregs
+            if not result:  # skip internal scratch temps (all user cregs are recorded post-3b)
                 continue
             # add global tag for each CReg
             reg_name_bytes = bytearray(reg_name.encode("utf-8"))
diff --git a/python/quantum-pecos/src/pecos/slr/vars.py b/python/quantum-pecos/src/pecos/slr/vars.py
index 4cc5f8f23..6d2d11990 100644
--- a/python/quantum-pecos/src/pecos/slr/vars.py
+++ b/python/quantum-pecos/src/pecos/slr/vars.py
@@ -215,21 +215,14 @@ def resolve(self, value: int) -> Qubit:
 
 
 class CReg(Reg, PyCOp):
-    def __init__(self, sym: str, size: int, *, result: bool = True) -> None:
+    def __init__(self, sym: str, size: int) -> None:
         """Representation for a collection of bits.
 
         Args:
             sym: Register name.
             size: Number of bits.
-            result: **Deprecated.** Whether this register is a result register
-                (default True). Phase 2 of the v2 output-model redesign
-                deprecates this kwarg; Phase 3b removes it. Use explicit
-                `Return(...)` and `Print(...)` to control output instead. See
-                `~/Repos/pecos-docs/design/slr/v2-breaking-migration.md` for
-                the migration path.
         """
         super().__init__(sym, size, elem_type=Bit)
-        self.result = result
 
     @property
     def _symbolic_elem_type(self) -> type[SymbolicBit]:
diff --git a/python/quantum-pecos/tests/pecos/regression/test_qasm/random_cases/test_slr_phys.py b/python/quantum-pecos/tests/pecos/regression/test_qasm/random_cases/test_slr_phys.py
index 4ca583ca9..b812ca9c2 100644
--- a/python/quantum-pecos/tests/pecos/regression/test_qasm/random_cases/test_slr_phys.py
+++ b/python/quantum-pecos/tests/pecos/regression/test_qasm/random_cases/test_slr_phys.py
@@ -193,7 +193,7 @@ def test_control_flow_qir() -> None:
     prog = Main(
         q := QReg("q", 2),
         m := CReg("m", 2),
-        m_hidden := CReg("m_hidden", 2, result=False),
+        m_hidden := CReg("m_hidden", 2),
         Repeat(3).block(
             p.H(q[0]),
         ),
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_codegen_guppy.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_codegen_guppy.py
index 97ae82f89..58fbde2dd 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_codegen_guppy.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_codegen_guppy.py
@@ -12,7 +12,7 @@
 """Tests for AST to Guppy code generator."""
 
 import pytest
-from pecos.slr import CReg, If, Main, QReg, Repeat
+from pecos.slr import CReg, If, Main, QReg, Repeat, Return
 from pecos.slr.ast import AstToGuppy, ast_to_guppy, slr_to_ast
 from pecos.slr.qeclib import qubit as qb
 
@@ -110,11 +110,12 @@ class TestAstToGuppyPrepMeasure:
     """Prep and measure code generation tests."""
 
     def test_measure_with_result(self) -> None:
-        """Measure with result generates variable and return."""
+        """Measure with explicit Return generates variable and return."""
         prog = Main(
             q := QReg("q", 1),
             c := CReg("c", 1),
             qb.Measure(q[0]) > c[0],
+            Return(c),
         )
         ast = slr_to_ast(prog)
 
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_codegen_qir.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_codegen_qir.py
index fae4f5305..c871947d4 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_codegen_qir.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_codegen_qir.py
@@ -232,7 +232,7 @@ def test_results_output(self) -> None:
         """Result CReg generates int_record_output call."""
         prog = Main(
             q := QReg("q", 1),
-            c := CReg("c", 1, result=True),
+            c := CReg("c", 1),
             qb.Measure(q[0]) > c[0],
         )
         ast = slr_to_ast(prog)
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_converter.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_converter.py
index 948164a1d..91d0a699a 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_converter.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_converter.py
@@ -71,7 +71,6 @@ def test_program_with_creg(self) -> None:
         assert isinstance(decl, RegisterDecl)
         assert decl.name == "c"
         assert decl.size == 3
-        assert decl.is_result is True
 
     def test_program_with_both_regs(self) -> None:
         """Program with QReg and CReg has both declarations."""
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_nodes.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_nodes.py
index 2a9644c78..3a71e0c81 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_nodes.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_nodes.py
@@ -350,16 +350,12 @@ def test_allocator_decl_with_parent(self) -> None:
         assert decl.parent == "base"
 
     def test_register_decl(self) -> None:
-        """RegisterDecl stores name and size."""
+        """RegisterDecl stores name and size (no is_result field post-3b)."""
         decl = RegisterDecl(name="c", size=5)
         assert decl.name == "c"
         assert decl.size == 5
-        assert decl.is_result is True
-
-    def test_register_decl_not_result(self) -> None:
-        """RegisterDecl can mark register as not a result."""
-        decl = RegisterDecl(name="scratch", size=3, is_result=False)
-        assert decl.is_result is False
+        with pytest.raises(AttributeError):
+            _ = decl.is_result
 
 
 class TestProgram:
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_serialize.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_serialize.py
index 1cf2a427b..71e5111c0 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_serialize.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_serialize.py
@@ -448,15 +448,17 @@ def test_empty_program(self) -> None:
         assert len(restored.declarations) == 0
         assert len(restored.body) == 0
 
-    def test_register_with_is_result_false(self) -> None:
-        """Test RegisterDecl with is_result=False."""
-        decl = RegisterDecl(name="scratch", size=4, is_result=False)
+    def test_register_decl_roundtrip(self) -> None:
+        """RegisterDecl round-trips through dict (no is_result field post-3b)."""
+        decl = RegisterDecl(name="scratch", size=4)
 
         data = ast_to_dict(decl)
         restored = dict_to_ast(data)
 
         assert isinstance(restored, RegisterDecl)
-        assert restored.is_result is False
+        assert restored.name == "scratch"
+        assert restored.size == 4
+        assert "is_result" not in data
 
     def test_allocator_without_parent(self) -> None:
         """Test AllocatorDecl without parent."""
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py
index 2491bfa92..0a17a31d7 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py
@@ -68,32 +68,33 @@ def run_ast_guppy_via_selene(
 
     wrapper, info = build_no_arg_entry_wrapper(program)
     # The entry tuple's bit order is the source of truth for the
-    # `measurement_N` keys. It comes from EITHER an explicit `Return(...)`
-    # (Phase 3b: the returned CRegs, in listed order) OR -- still
-    # supported until 3b removes it -- the v1 implicit result-CReg set
-    # (declaration order). Returning the same CRegs in the same order is
-    # byte-identical to the implicit path (proven), so migrated and
-    # not-yet-migrated programs both produce identical records.
-    if info.explicit_return is not None:
-        record_cregs: list[RegisterDecl] = []
-        for value in info.explicit_return.values:
-            name = value if isinstance(value, str) else getattr(value, "name", None)
-            if name in info.all_creg_sizes:
-                record_cregs.append(
-                    RegisterDecl(name=name, size=info.all_creg_sizes[name], is_result=True),
-                )
-    else:
-        record_cregs = info.result_cregs
+    # `measurement_N` keys: the CRegs in the explicit `Return(...)`, in
+    # listed order. Phase 3b removed the v1 implicit result-CReg path, so
+    # a program with no `Return` has no measurement record at all.
+    if info.explicit_return is None:
+        msg = (
+            "Selene behavioral test requires an explicit `Return(<creg>...)`. "
+            "Phase 3b removed the implicit result-CReg return; a program with "
+            "no `Return` compiles to `entry() -> None` and has no measurement "
+            "record."
+        )
+        raise ValueError(msg)
+    record_cregs: list[RegisterDecl] = []
+    for value in info.explicit_return.values:
+        name = value if isinstance(value, str) else getattr(value, "name", None)
+        if name in info.all_creg_sizes:
+            record_cregs.append(
+                RegisterDecl(name=name, size=info.all_creg_sizes[name]),
+            )
     if not record_cregs:
         # Strict (Codex S1-approach review): an explicit `Return(...)`
         # with no CRegs (e.g. `Return(q)`) has no measurement record --
         # fail loudly rather than silently mis-shape the result table.
         msg = (
             "Selene behavioral test requires at least one returned CReg "
-            "(explicit `Return(<creg>...)`, or -- pre-3b -- an implicit "
-            "result CReg). Returning only QRegs/values yields no "
-            "measurement record. Declare CRegs and write measurement "
-            "bits into them."
+            "(explicit `Return(<creg>...)`). Returning only QRegs/values "
+            "yields no measurement record. Declare CRegs and write "
+            "measurement bits into them."
         )
         raise ValueError(msg)
 
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
index 3e71e7099..af7ce2ee4 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
@@ -178,25 +178,17 @@ def test_hugr_inline_measure_creg_inside_nested_repeat() -> None:
     assert raw, "Nested inline-CReg .hugr() output produced no measurement records"
 
 
-def test_hugr_explicit_return_of_non_result_creg() -> None:
-    """Pin entry_wrapper / emitter parity on declared non-result CRegs.
+def test_hugr_explicit_return_of_declared_creg() -> None:
+    """Pin entry_wrapper / emitter parity on declared CRegs in `Return(...)`.
 
     The emitter's `_return_value_type` resolves any declared CReg name in
-    `Return(...)` -- `is_result` is not consulted. The wrapper must mirror
-    this exactly so it can't silently diverge. Without this fix the wrapper's
-    `_explicit_return_type` looked up only `info.result_cregs` (filtered to
-    `is_result=True`), so `Return(c)` for `c = CReg(..., result=False)` would
-    raise `ValueError` while the emitter happily compiled.
-
-    Note: the combo `result=False` + `Return(c)` is itself a design quirk
-    (the two flags say opposite things). Whether v1 should reject this in
-    preflight, or whether SLR should adopt a `result()` / explicit-output
-    mechanism instead, is a separate v1-followup question. This test only
-    pins wrapper/emitter parity for the current semantics.
+    `Return(...)`. The no-arg `entry()` wrapper's `_explicit_return_type`
+    must mirror this exactly (resolving via `info.all_creg_sizes`) so the
+    wrapper signature can't silently diverge from `main(...)`.
     """
     prog = Main(
         q := QReg("q", 1),
-        c := CReg("c", 1, result=False),
+        c := CReg("c", 1),
         qb.Prep(q[0]),
         Measure(q[0]) > c[0],
         Return(c),
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_deprecation_warnings.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_deprecation_warnings.py
index 33f0e4120..e85e25ae4 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_deprecation_warnings.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_deprecation_warnings.py
@@ -9,63 +9,59 @@
 # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 # specific language governing permissions and limitations under the License.
 
-"""Post-S2 contracts for the Phase 3b output-model migration.
+"""Phase 3b hard-contract tests for the v2 output model.
 
-S2 removes the Phase-2 deprecation warnings only. It intentionally does not
-remove the `CReg(result=...)` kwarg and does not yet remove the implicit-return
-code path; those hard breaking changes are S3. These tests pin the S2 boundary:
-old warning-producing programs still work, but no Phase-2 DeprecationWarning is
-emitted.
+S3 removed the `CReg(result=...)` kwarg, the `RegisterDecl.is_result`
+field, and the v1 implicit return of result-flagged CRegs. These tests
+pin those removals as hard contracts: the old knobs now raise, and a
+program must use an explicit `Return(...)` to produce any output.
 """
 
 from __future__ import annotations
 
-import warnings
-from typing import TYPE_CHECKING, TypeVar
-
+import pytest
 from pecos.slr import CReg, Main, QReg, Return, SlrConverter
+from pecos.slr.ast.nodes import RegisterDecl
 from pecos.slr.qeclib import qubit as qb
 from pecos.slr.qeclib.qubit.measures import Measure
 
 from ._selene_harness import run_ast_guppy_via_selene  # noqa: TID252
 
-if TYPE_CHECKING:
-    from collections.abc import Callable
-
-T = TypeVar("T")
 
+class TestCRegResultKwargRemoved:
+    """S3: the `CReg(result=...)` kwarg is gone -> hard `TypeError`."""
 
-def _run_without_deprecation_warning(func: Callable[[], T]) -> T:
-    """Run `func` and fail if any DeprecationWarning is emitted."""
-    with warnings.catch_warnings(record=True) as caught:
-        warnings.simplefilter("always", DeprecationWarning)
-        result = func()
+    def test_creg_result_false_raises_type_error(self) -> None:
+        with pytest.raises(TypeError):
+            CReg("c", 1, result=False)
 
-    deprecations = [warning for warning in caught if issubclass(warning.category, DeprecationWarning)]
-    assert deprecations == [], f"expected no DeprecationWarning, got {[str(w.message) for w in deprecations]}"
-    return result
+    def test_creg_result_true_raises_type_error(self) -> None:
+        with pytest.raises(TypeError):
+            CReg("c", 1, result=True)
 
+    def test_creg_without_result_still_constructs(self) -> None:
+        c = CReg("c", 1)
+        assert c.sym == "c"
 
-class TestCRegResultKwargPostS2:
-    """`result=` is still accepted in S2, but no longer warns."""
 
-    def test_creg_with_result_false_does_not_warn(self) -> None:
-        c = _run_without_deprecation_warning(lambda: CReg("c", 1, result=False))
-        assert c.result is False
+class TestRegisterDeclIsResultRemoved:
+    """S3: the `RegisterDecl.is_result` field is gone -> hard `TypeError`."""
 
-    def test_creg_with_explicit_result_true_does_not_warn(self) -> None:
-        c = _run_without_deprecation_warning(lambda: CReg("c", 1, result=True))
-        assert c.result is True
+    def test_register_decl_is_result_raises_type_error(self) -> None:
+        with pytest.raises(TypeError):
+            RegisterDecl(name="scratch", size=2, is_result=False)
 
-    def test_creg_with_default_result_does_not_warn(self) -> None:
-        c = _run_without_deprecation_warning(lambda: CReg("c", 1))
-        assert c.result is True
+    def test_register_decl_without_is_result_still_constructs(self) -> None:
+        decl = RegisterDecl(name="c", size=2)
+        assert decl.name == "c"
+        with pytest.raises(AttributeError):
+            _ = decl.is_result
 
 
-class TestImplicitReturnPostS2:
-    """Implicit-return programs still work in S2, but no longer warn."""
+class TestNoImplicitReturn:
+    """S3: no `Return(...)` means no output (the v1 implicit path is gone)."""
 
-    def test_implicit_return_program_still_compiles_without_warning(self) -> None:
+    def test_no_return_compiles_to_main_returning_none(self) -> None:
         prog = Main(
             q := QReg("q", 1),
             c := CReg("c", 1),
@@ -73,10 +69,12 @@ def test_implicit_return_program_still_compiles_without_warning(self) -> None:
             Measure(q[0]) > c[0],
         )
 
-        source = _run_without_deprecation_warning(lambda: SlrConverter(prog).guppy())
-        assert "result.c" not in source
+        source = SlrConverter(prog).guppy()
+        assert "-> None:" in source
+        # No implicit `return <result cregs>` was emitted.
+        assert "\n    return " not in source
 
-    def test_implicit_return_hugr_still_compiles_without_warning(self) -> None:
+    def test_no_return_hugr_compiles(self) -> None:
         prog = Main(
             q := QReg("q", 1),
             c := CReg("c", 1),
@@ -84,53 +82,29 @@ def test_implicit_return_hugr_still_compiles_without_warning(self) -> None:
             Measure(q[0]) > c[0],
         )
 
-        package = _run_without_deprecation_warning(lambda: SlrConverter(prog).hugr())
+        package = SlrConverter(prog).hugr()
         assert package is not None
 
-    def test_explicit_return_program_still_runs_through_selene(self) -> None:
+    def test_no_return_selene_fails_fast(self) -> None:
+        """No `Return` -> no measurement record -> harness raises clearly."""
         prog = Main(
             q := QReg("q", 1),
             c := CReg("c", 1),
             qb.X(q[0]),
             Measure(q[0]) > c[0],
-            Return(c),
-        )
-
-        records = _run_without_deprecation_warning(lambda: run_ast_guppy_via_selene(prog, shots=10))
-        assert all(record["measurement_0"] == 1 for record in records)
-
-    def test_inline_whole_register_measure_still_compiles_without_warning(self) -> None:
-        """S1b's whole-register cout shape no longer has a warning detector."""
-        prog = Main(
-            q := QReg("q", 2),
-            Measure(q) > CReg("inline", 2),
         )
 
-        source = _run_without_deprecation_warning(lambda: SlrConverter(prog).guppy())
-        assert "inline" in source
+        with pytest.raises(ValueError, match="requires an explicit"):
+            run_ast_guppy_via_selene(prog, shots=1)
 
-    def test_inline_slice_measure_still_compiles_without_warning(self) -> None:
-        """S1b's slice cout shape no longer has a warning detector."""
-        inline = CReg("inline", 2)
+    def test_explicit_return_runs_through_selene(self) -> None:
         prog = Main(
-            q := QReg("q", 2),
-            Measure(q) > inline[0:2],
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            qb.X(q[0]),
+            Measure(q[0]) > c[0],
+            Return(c),
         )
 
-        source = _run_without_deprecation_warning(lambda: SlrConverter(prog).guppy())
-        assert "inline" in source
-
-    def test_result_false_only_measure_still_compiles_without_warning(self) -> None:
-        def build_and_compile() -> str:
-            q = QReg("q", 1)
-            scratch = CReg("scratch", 1, result=False)
-            prog = Main(
-                q,
-                scratch,
-                qb.X(q[0]),
-                Measure(q[0]) > scratch[0],
-            )
-            return SlrConverter(prog).guppy()
-
-        source = _run_without_deprecation_warning(build_and_compile)
-        assert "scratch" in source
+        records = run_ast_guppy_via_selene(prog, shots=10)
+        assert all(record["measurement_0"] == 1 for record in records)
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
index aae08f23b..205907738 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
@@ -233,11 +233,11 @@ class TestPrintAndSeleneOutput:
 
     Empirically (verified 2026-05-14):
 
-    - No Print, implicit return: Selene exposes return-tuple positionally as
-      `measurement_N` keys.
-    - Any Print, implicit return still present in Guppy `return ...`: Selene
-      switches to result-tag mode and the `measurement_N` keys are NOT
-      exposed; only `result()` tags appear in `to_dict()`.
+    - No Print, explicit `Return`: Selene exposes the return-tuple
+      positionally as `measurement_N` keys.
+    - Any Print, explicit `Return` still present in Guppy `return ...`:
+      Selene switches to result-tag mode and the `measurement_N` keys are
+      NOT exposed; only `result()` tags appear in `to_dict()`.
 
     So Print is **AST-scope-orthogonal** (no AST/Guppy return shape change)
     but **Selene-runtime-mode-flipping** (presence of any `result()` switches
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qeclib_selene_corpus.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qeclib_selene_corpus.py
index f0c3b5b91..578a81a4e 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qeclib_selene_corpus.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qeclib_selene_corpus.py
@@ -59,8 +59,6 @@
 
 from __future__ import annotations
 
-import warnings
-
 from pecos import Hugr, selene_engine, sim
 from pecos.slr import CReg, Main, QReg, Return, SlrConverter
 from pecos.slr.qeclib import qubit as qb
@@ -76,16 +74,12 @@
 def _run_via_selene(prog: Main, *, shots: int = 4, seed: int = 42, qubits: int) -> dict:
     """Compile prog through SlrConverter.hugr() and run through Selene.
 
-    Suppresses Phase 2 implicit-return DeprecationWarning during the
-    roundtrip; the corpus targets the current v1 implicit-return behavior
-    deliberately. When Phase 3b makes the breaking change, this helper
-    plus the assertions below will be updated together.
+    The corpus programs use explicit `Return(...)` (Phase 3b removed the
+    v1 implicit-return path).
     """
-    with warnings.catch_warnings():
-        warnings.simplefilter("ignore", DeprecationWarning)
-        package = SlrConverter(prog).hugr()
-        hugr_bytes = package.to_str().encode("utf-8")
-        result = sim(Hugr(hugr_bytes)).classical(selene_engine()).qubits(qubits).seed(seed).run(shots)
+    package = SlrConverter(prog).hugr()
+    hugr_bytes = package.to_str().encode("utf-8")
+    result = sim(Hugr(hugr_bytes)).classical(selene_engine()).qubits(qubits).seed(seed).run(shots)
     raw = result.to_dict() if hasattr(result, "to_dict") else result
     assert isinstance(raw, dict)
     return raw
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py
index 08499f77f..302449025 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py
@@ -281,7 +281,7 @@ def test_creg_permute_remaps_condition_bit(self) -> None:
         """CReg Permute must affect a later If condition."""
         prog_without_permute = Main(
             q := QReg("q", 1),
-            flag := CReg("flag", 2, result=False),
+            flag := CReg("flag", 2),
             out := CReg("out", 1),
             flag[0].set(1),
             flag[1].set(0),
@@ -294,7 +294,7 @@ def test_creg_permute_remaps_condition_bit(self) -> None:
 
         prog_with_permute = Main(
             q := QReg("q", 1),
-            flag := CReg("flag", 2, result=False),
+            flag := CReg("flag", 2),
             out := CReg("out", 1),
             flag[0].set(1),
             flag[1].set(0),
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py b/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py
index c7b93a75b..74ad65272 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py
@@ -114,7 +114,7 @@ def test_control_flow_qir() -> None:
     prog = Main(
         q := QReg("q", 2),
         m := CReg("m", 2),
-        m_hidden := CReg("m_hidden", 2, result=False),
+        m_hidden := CReg("m_hidden", 2),
         Repeat(3).block(
             p.H(q[0]),
         ),

From 93deecb5b6b195c346c03fef728bb49b67c641a1 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sat, 16 May 2026 17:27:25 -0600
Subject: [PATCH 071/136] Phase 3b S5: M2 converter-time elision of flattened
 composite block-boundary Returns (provenance flag, not position/count);
 steane_pz compiles (audit accepted, compile-scope); behavioral lock-in is
 strict-xfail pinning the orthogonal pre-existing v1 FT-RUS pz() non-codeword
 defect (tracked post-3b, task #72); EncodingCircuit provenance guard.

---
 .../src/pecos/slr/ast/converter.py            | 24 +++++++++-
 .../slr/ast_tests/test_ast_codegen_guppy.py   | 19 ++++++++
 .../tests/slr_tests/ast_guppy/audit_runner.py | 20 +++++----
 .../slr_tests/ast_guppy/test_v1_behavioral.py | 44 +++++++++++++++++++
 4 files changed, 96 insertions(+), 11 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/converter.py b/python/quantum-pecos/src/pecos/slr/ast/converter.py
index 858c6d3d1..788a44863 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/converter.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/converter.py
@@ -172,6 +172,13 @@ def __init__(self) -> None:
         self._position = 0  # Track position for source locations
         self._block_decls: list[BlockDecl] = []  # Hoisted BlockDecls accumulated during convert()
         self._decl_counter = 0
+        # S5/M2: True while converting the ops of a legacy-flattened composite
+        # Block. A `Return` inside such a block is a block-boundary qubit
+        # handoff (the qubits are already in linear scope by allocator name),
+        # NOT the root Main return -- elide it. Provenance-based, not
+        # position/count (a single final root ReturnOp can come from a qeclib
+        # block, e.g. `Main(q, EncodingCircuit(q))`).
+        self._in_flattened_block = False
 
     def convert(self, block: Main | Block) -> Program:
         """Convert an SLR Main/Block to an AST Program.
@@ -369,6 +376,9 @@ def _convert_statement(self, op: Any) -> Statement | None:
             return CommentOp(text=op.txt)
 
         if op_class == "Return":
+            if self._in_flattened_block:
+                # S5/M2: elide block-boundary Return from a flattened composite.
+                return None
             return self._convert_return(op)
 
         if op_class == "Permute":
@@ -389,8 +399,18 @@ def _convert_statement(self, op: Any) -> Statement | None:
             if _has_block_inputs(op):
                 return self._convert_block_call(op)
 
-            # Legacy flatten path.
-            return ("__FLATTEN__", self._convert_statements(op.ops))
+            # Legacy flatten path. Returns inside the flattened composite are
+            # block-boundary handoffs, not the root Main return (S5/M2):
+            # elide them via the in_flattened_block provenance flag, including
+            # inside nested If/Repeat/For/While/Parallel. Save/restore so
+            # nested composites and the root scope are handled correctly.
+            prev_in_flattened = self._in_flattened_block
+            self._in_flattened_block = True
+            try:
+                flattened = self._convert_statements(op.ops)
+            finally:
+                self._in_flattened_block = prev_in_flattened
+            return ("__FLATTEN__", flattened)
 
         return None
 
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_codegen_guppy.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_codegen_guppy.py
index 58fbde2dd..b47ffba3e 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_codegen_guppy.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_codegen_guppy.py
@@ -15,6 +15,7 @@
 from pecos.slr import CReg, If, Main, QReg, Repeat, Return
 from pecos.slr.ast import AstToGuppy, ast_to_guppy, slr_to_ast
 from pecos.slr.qeclib import qubit as qb
+from pecos.slr.qeclib.steane.preps.encoding_circ import EncodingCircuit
 
 
 class TestAstToGuppyBasic:
@@ -211,6 +212,24 @@ def test_syndrome_extraction(self) -> None:
         assert "data_1, ancilla_0 = cx(data_1, ancilla_0)" in code
         assert "c[0] = measure(ancilla_0)" in code
 
+    def test_qeclib_block_internal_return_does_not_leak_as_main_return(self) -> None:
+        """S5/M2 provenance guard.
+
+        A qeclib composite block's internal `Return` is a flattened
+        block-boundary handoff, NOT the Main return -- it is elided at
+        convert time. `EncodingCircuit` emits a single final root
+        `ReturnOp(values=('q',))`; a position/count detector would wrongly
+        make it `return q`. Post-S5 it must be `main(...) -> None` with no
+        return line.
+        """
+        prog = Main(
+            q := QReg("q", 7),
+            EncodingCircuit(q),
+        )
+        code = ast_to_guppy(slr_to_ast(prog))
+        assert "-> None:" in code
+        assert "\n    return " not in code
+
 
 class TestAstToGuppyGenerator:
     """Tests for AstToGuppy generator class."""
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
index a8bd1b1af..0d813a8c1 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
@@ -470,8 +470,16 @@ def _qeclib_surface_patch_builder_empty() -> Block:
     )
 
 
-def _qeclib_steane_pz_v2_defer() -> Block:
-    """Deliberate red-light: Steane pz() is v2 per stage3-synthesis Q B."""
+def _qeclib_steane_pz() -> Block:
+    """Steane pz(): lowers under S5 (M2 converter-time elision of flattened
+    composite block-boundary Returns); Main has no user Return -> main()->None.
+
+    Audit scope is build+lower (compile) only -- steane_pz genuinely
+    compiles post-S5. Behavioral correctness is a SEPARATE concern: the v1
+    AST->Guppy FT-RUS pz() prepares a non-codeword state (pre-existing,
+    S5-independent). That defect is tracked post-3b and pinned by a strict
+    xfail in test_v1_behavioral.TestS5SteanePzBehavioral -- it is NOT
+    asserted correct here."""
     return Main(
         c := Steane("c"),
         c.pz(),
@@ -706,13 +714,7 @@ def _curated_cases() -> list[AuditCase]:
         AuditCase("qeclib.surface_patch_builder_empty", _qeclib_surface_patch_builder_empty),
         AuditCase(
             "qeclib.steane_pz",
-            _qeclib_steane_pz_v2_defer,
-            expected_failure=ExpectedFailure(
-                exception_type="GuppyCodegenError",
-                message_contains="supports only one final root-level Return",
-                classification="v2-defer",
-                reason="Steane pz() requires nested Return / BlockCall semantics",
-            ),
+            _qeclib_steane_pz,
         ),
         AuditCase(
             "qeclib.surface_std_pz",
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py
index 302449025..f8319414e 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py
@@ -26,9 +26,11 @@
 
 from __future__ import annotations
 
+import pytest
 from pecos.slr import CReg, If, Main, Permute, QReg, Return
 from pecos.slr.qeclib import qubit as qb
 from pecos.slr.qeclib.qubit.measures import Measure
+from pecos.slr.qeclib.steane.steane_class import Steane
 
 from ._selene_harness import run_ast_guppy_via_selene  # noqa: TID252
 
@@ -305,3 +307,45 @@ def test_creg_permute_remaps_condition_bit(self) -> None:
         )
         records = run_ast_guppy_via_selene(prog_with_permute, shots=10)
         assert all(r["measurement_0"] == 1 for r in records)
+
+
+class TestS5SteanePzBehavioral:
+    """S5 behavioral lock-in: Steane pz() must prepare a valid logical |0>.
+
+    `Main(c := Steane("c"), c.pz())` has no user Return -> main() -> None;
+    the flattened PrepRUS block-boundary Returns are elided at convert time
+    (S5/M2 -- mechanism Codex-verified sound). The companion adds an
+    explicit Measure(c.d)+Return so Selene yields the 7-bit data record;
+    every shot must satisfy the Steane Z-check syndrome == (0, 0, 0)
+    (codespace membership = a real logical-|0> lock-in, not "deterministic
+    bits").
+
+    KNOWN DEFECT (strict xfail): the v1 AST->Guppy lowering of the FT-RUS
+    `pz()` (PrepEncodingFTZero / PrepZeroVerify / RUS-reject path) prepares
+    a NON-codeword state (seed-42 shot 0 = [0,1,0,0,1,1,1], syndrome
+    (1,1,0)). Pre-existing and S5-independent: steane_pz was XFAIL before
+    S5 so it never ran; S5 only let it run and this gate exposed the bug.
+    Tracked post-3b -- NOT a Phase 3b cutover concern. `strict=True` so an
+    eventual pz() fix surfaces as XPASS and prompts removing this marker.
+    """
+
+    # Steane Z-stabilizer check supports (steane_class.py: check_indices).
+    _CHECKS = ((2, 1, 3, 0), (5, 2, 1, 4), (6, 5, 2, 3))
+
+    @pytest.mark.xfail(
+        strict=True,
+        reason="v1 AST->Guppy FT-RUS Steane pz() prepares a non-codeword state; S5-independent, tracked post-3b",
+    )
+    def test_steane_pz_prepares_logical_zero(self) -> None:
+        prog = Main(
+            c := Steane("c"),
+            c.pz(),
+            m := CReg("m", 7),
+            Measure(c.d) > m,
+            Return(m),
+        )
+        records = run_ast_guppy_via_selene(prog, shots=4, seed=42)
+        for rec in records:
+            bits = [rec[f"measurement_{i}"] for i in range(7)]
+            syndrome = tuple(bits[a] ^ bits[b] ^ bits[c] ^ bits[d] for (a, b, c, d) in self._CHECKS)
+            assert syndrome == (0, 0, 0), (rec, syndrome)

From 756cd8fa533ddea3f89cca2bac38389b79b9f219 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sat, 16 May 2026 18:26:40 -0600
Subject: [PATCH 072/136] #72: fix _selene_harness measurement-mapping via
 opt-in named return tags (D-72-B). entry_wrapper gains keyword-only
 emit_return_result_tags (default False -> production wrapper byte-identical);
 harness emits result('__pecos_return.<creg>',..) and _shot_records reads tags
 by name, re-exporting the historical measurement_N shape (immune to internal
 RUS measurements). Remove the wrong S5 strict-xfail (steane pz now genuinely
 passes; stim-verified); add internal-measurement regression guard.

---
 .../pecos/slr/ast/codegen/entry_wrapper.py    | 45 ++++++++++-
 .../slr_tests/ast_guppy/_selene_harness.py    | 80 ++++++++++++-------
 .../slr_tests/ast_guppy/test_v1_behavioral.py | 55 ++++++++-----
 3 files changed, 129 insertions(+), 51 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/entry_wrapper.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/entry_wrapper.py
index 3b1bd5c9f..55f52a805 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/entry_wrapper.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/entry_wrapper.py
@@ -64,9 +64,32 @@ class EntryWrapperInfo:
     all_creg_sizes: dict[str, int]
 
 
-def build_no_arg_entry_wrapper(program: Program) -> tuple[str, EntryWrapperInfo]:
+# Reserved namespace for the opt-in returned-CReg result tags (#72). Private
+# (double-underscore) so it cannot collide with user `Print(..., namespace=
+# "result")` -> `result.<tag>` outputs. Single source of truth shared with
+# `_selene_harness` so the emit/read sides never drift.
+RETURN_TAG_NAMESPACE = "__pecos_return"
+
+
+def build_no_arg_entry_wrapper(
+    program: Program,
+    *,
+    emit_return_result_tags: bool = False,
+) -> tuple[str, EntryWrapperInfo]:
     """Generate the wrapper source and return the metadata used to build it.
 
+    Args:
+        program: The AST program to wrap.
+        emit_return_result_tags: **Opt-in, test-harness only.** When True and
+            the program has an explicit `Return(...)`, the wrapper
+            destructures main's return and emits
+            `result("__pecos_return.<creg>", <creg>)` per returned CReg
+            instead of `return <tuple>`, and is typed `-> None`. This makes
+            Selene key the outputs by CReg name (immune to internal,
+            non-returned measurements -- e.g. RUS verify). Default False
+            keeps the production wrapper byte-identical (the `.hugr()` /
+            raw-`measurement_N` consumers must not change -- #72).
+
     Returns:
         A `(source, info)` tuple. `source` is the Guppy snippet defining
         `entry()`; concatenate it after the main source. `info` exposes the
@@ -74,7 +97,7 @@ def build_no_arg_entry_wrapper(program: Program) -> tuple[str, EntryWrapperInfo]
         need (e.g., Selene's measurement-key generation).
     """
     info = _collect_info(program)
-    source = _render_wrapper(info)
+    source = _render_wrapper(info, emit_return_result_tags=emit_return_result_tags)
     return source, info
 
 
@@ -126,14 +149,28 @@ def _walk_for_measure_results(
             _walk_for_measure_results(stmt.body, declared, inline_max)
 
 
-def _render_wrapper(info: EntryWrapperInfo) -> str:
+def _render_wrapper(info: EntryWrapperInfo, *, emit_return_result_tags: bool = False) -> str:
     body_lines: list[str] = [
         f"    {name} = array(qubit() for _ in range({size}))" for name, size in info.allocator_sizes.items()
     ]
     call_args = ", ".join(info.allocator_sizes.keys())
     call_expr = f"main({call_args})"
 
-    if info.explicit_return is not None:
+    if emit_return_result_tags and info.explicit_return is not None:
+        # Opt-in (#72): destructure main's return and tag each returned CReg
+        # by name so Selene keys outputs by name, not positional
+        # measurement_N (which counts internal measurements too).
+        targets = [v if isinstance(v, str) else getattr(v, "name", None) for v in info.explicit_return.values]
+        if any(t is None for t in targets):
+            msg = f"emit_return_result_tags supports only named return values, got {info.explicit_return.values!r}"
+            raise ValueError(msg)
+        lhs = targets[0] if len(targets) == 1 else ", ".join(targets)
+        body_lines.append(f"    {lhs} = {call_expr}")
+        body_lines.extend(
+            f'    result("{RETURN_TAG_NAMESPACE}.{name}", {name})' for name in targets if name in info.all_creg_sizes
+        )
+        return_ann = "None"
+    elif info.explicit_return is not None:
         body_lines.append(f"    return {call_expr}")
         return_ann = _explicit_return_type(info)
     else:
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py
index 0a17a31d7..6fda1e9b8 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py
@@ -35,7 +35,7 @@
 from pecos import Guppy, selene_engine, sim
 from pecos.slr import SlrConverter
 from pecos.slr.ast import RegisterDecl, slr_to_ast
-from pecos.slr.ast.codegen.entry_wrapper import build_no_arg_entry_wrapper
+from pecos.slr.ast.codegen.entry_wrapper import RETURN_TAG_NAMESPACE, build_no_arg_entry_wrapper
 
 if TYPE_CHECKING:
     import pecos_rslib
@@ -66,11 +66,18 @@ def run_ast_guppy_via_selene(
     ast_source = SlrConverter(slr_program).guppy()
     program = slr_to_ast(slr_program)
 
-    wrapper, info = build_no_arg_entry_wrapper(program)
-    # The entry tuple's bit order is the source of truth for the
-    # `measurement_N` keys: the CRegs in the explicit `Return(...)`, in
-    # listed order. Phase 3b removed the v1 implicit result-CReg path, so
-    # a program with no `Return` has no measurement record at all.
+    # #72: opt-in named return tags. The wrapper emits
+    # `result("__pecos_return.<creg>", <creg>)` per returned CReg, so Selene
+    # keys outputs by CReg NAME -- immune to internal (non-returned)
+    # measurements like the Steane RUS verify. `_shot_records` reads those
+    # tags and re-exports the existing public `measurement_N` shape, so all
+    # `run_ast_guppy_via_selene` consumers stay unchanged. The production
+    # wrapper (default `emit_return_result_tags=False`) is untouched.
+    wrapper, info = build_no_arg_entry_wrapper(program, emit_return_result_tags=True)
+    # The returned CRegs (explicit `Return(...)`, in listed order) are the
+    # source of truth for the public `measurement_N` order. Phase 3b removed
+    # the v1 implicit result-CReg path, so a program with no `Return` has no
+    # measurement record at all.
     if info.explicit_return is None:
         msg = (
             "Selene behavioral test requires an explicit `Return(<creg>...)`. "
@@ -105,23 +112,7 @@ def run_ast_guppy_via_selene(
 
     result = sim(Guppy(entry_func)).classical(selene_engine()).qubits(max(total_qubits, 1)).seed(seed).run(shots)
 
-    return _shot_records(result, _result_keys(record_cregs))
-
-
-def _result_keys(cregs: list[RegisterDecl]) -> list[str]:
-    """Names the Selene runtime uses for each bit in the entry tuple.
-
-    Selene emits "measurement_0", "measurement_1", ... in tuple-position order.
-    The wrapper returns CReg bits in declaration order, so we generate the keys
-    in that same order.
-    """
-    keys: list[str] = []
-    counter = 0
-    for decl in cregs:
-        for _ in range(decl.size):
-            keys.append(f"measurement_{counter}")
-            counter += 1
-    return keys
+    return _shot_records(result, record_cregs)
 
 
 def _import_entry_function(source: str) -> object:
@@ -146,18 +137,51 @@ def _import_entry_function(source: str) -> object:
     return entry
 
 
-def _shot_records(result: pecos_rslib.ShotVec, keys: list[str]) -> list[dict[str, int]]:
-    """Convert ShotVec to a list of per-shot measurement records."""
+def _shot_records(result: pecos_rslib.ShotVec, record_cregs: list[RegisterDecl]) -> list[dict[str, int]]:
+    """Re-export the named `__pecos_return.<creg>` tags as the public shape.
+
+    The wrapper emits `result("__pecos_return.<creg>", <creg>)` per returned
+    CReg (#72), so Selene's `to_dict()` keys outputs by CReg name and each
+    shot value is a list of that CReg's bits in declaration order. We flatten
+    the returned CRegs (in `Return(...)` order) into the historical public
+    shape `{"measurement_0": .., "measurement_1": .., ...}` so existing
+    `run_ast_guppy_via_selene` consumers are unchanged -- but now reading the
+    correct bits (immune to internal, non-returned measurements).
+    """
     raw = result.to_dict() if hasattr(result, "to_dict") else result
     if not isinstance(raw, dict):
         msg = f"Unexpected Selene result shape: {type(raw).__name__}"
         raise TypeError(msg)
 
-    shot_count = len(next(iter(raw.values()))) if raw else 0
+    tag_keys = [f"{RETURN_TAG_NAMESPACE}.{decl.name}" for decl in record_cregs]
+    missing = [k for k in tag_keys if k not in raw]
+    if missing:
+        msg = (
+            f"Selene result is missing return tags {missing}; got keys "
+            f"{sorted(raw)}. Expected the opt-in wrapper to emit "
+            f'`result("{RETURN_TAG_NAMESPACE}.<creg>", <creg>)` per '
+            "returned CReg."
+        )
+        raise KeyError(msg)
+
+    shot_count = len(raw[tag_keys[0]]) if tag_keys else 0
     records: list[dict[str, int]] = []
     for shot_idx in range(shot_count):
         record: dict[str, int] = {}
-        for key in keys:
-            record[key] = int(raw[key][shot_idx])
+        counter = 0
+        for decl, key in zip(record_cregs, tag_keys, strict=True):
+            shot_val = raw[key][shot_idx]
+            # Selene shapes a size-1 CReg result tag as a scalar int per
+            # shot, and a size>1 CReg as a list of `size` ints per shot.
+            bits = list(shot_val) if isinstance(shot_val, (list, tuple)) else [shot_val]
+            if len(bits) != decl.size:
+                msg = (
+                    f"Return tag {key!r} shot {shot_idx} has {len(bits)} bits, "
+                    f"expected {decl.size} (CReg {decl.name!r})."
+                )
+                raise ValueError(msg)
+            for bit in bits:
+                record[f"measurement_{counter}"] = int(bit)
+                counter += 1
         records.append(record)
     return records
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py
index f8319414e..df1cc0268 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py
@@ -26,7 +26,6 @@
 
 from __future__ import annotations
 
-import pytest
 from pecos.slr import CReg, If, Main, Permute, QReg, Return
 from pecos.slr.qeclib import qubit as qb
 from pecos.slr.qeclib.qubit.measures import Measure
@@ -310,32 +309,26 @@ def test_creg_permute_remaps_condition_bit(self) -> None:
 
 
 class TestS5SteanePzBehavioral:
-    """S5 behavioral lock-in: Steane pz() must prepare a valid logical |0>.
+    """Steane pz() prepares a valid logical |0> (S5 + #72 lock-in).
 
     `Main(c := Steane("c"), c.pz())` has no user Return -> main() -> None;
     the flattened PrepRUS block-boundary Returns are elided at convert time
-    (S5/M2 -- mechanism Codex-verified sound). The companion adds an
-    explicit Measure(c.d)+Return so Selene yields the 7-bit data record;
-    every shot must satisfy the Steane Z-check syndrome == (0, 0, 0)
-    (codespace membership = a real logical-|0> lock-in, not "deterministic
-    bits").
-
-    KNOWN DEFECT (strict xfail): the v1 AST->Guppy lowering of the FT-RUS
-    `pz()` (PrepEncodingFTZero / PrepZeroVerify / RUS-reject path) prepares
-    a NON-codeword state (seed-42 shot 0 = [0,1,0,0,1,1,1], syndrome
-    (1,1,0)). Pre-existing and S5-independent: steane_pz was XFAIL before
-    S5 so it never ran; S5 only let it run and this gate exposed the bug.
-    Tracked post-3b -- NOT a Phase 3b cutover concern. `strict=True` so an
-    eventual pz() fix surfaces as XPASS and prompts removing this marker.
+    (S5/M2). The companion adds an explicit Measure(c.d)+Return so Selene
+    yields the 7-bit data record; every shot must satisfy the Steane Z-check
+    syndrome == (0, 0, 0) (codespace membership = a real logical-|0>
+    lock-in, not "deterministic bits").
+
+    Previously a strict xfail under a wrong diagnosis ("v1 FT-RUS pz()
+    non-codeword"). #72 re-diagnosed: pz() is correct (stim-verified); the
+    failure was `_selene_harness` mis-mapping `measurement_N` because the
+    Steane RUS performs an internal (non-returned) verify measurement. With
+    #72's named return-tag mapping the harness reads the returned data CReg
+    by name, so this now passes.
     """
 
     # Steane Z-stabilizer check supports (steane_class.py: check_indices).
     _CHECKS = ((2, 1, 3, 0), (5, 2, 1, 4), (6, 5, 2, 3))
 
-    @pytest.mark.xfail(
-        strict=True,
-        reason="v1 AST->Guppy FT-RUS Steane pz() prepares a non-codeword state; S5-independent, tracked post-3b",
-    )
     def test_steane_pz_prepares_logical_zero(self) -> None:
         prog = Main(
             c := Steane("c"),
@@ -349,3 +342,27 @@ def test_steane_pz_prepares_logical_zero(self) -> None:
             bits = [rec[f"measurement_{i}"] for i in range(7)]
             syndrome = tuple(bits[a] ^ bits[b] ^ bits[c] ^ bits[d] for (a, b, c, d) in self._CHECKS)
             assert syndrome == (0, 0, 0), (rec, syndrome)
+
+
+class TestHarnessInternalMeasurementMapping:
+    """#72 regression: an internal (non-returned) measurement before the
+    returned data must not shift the public `measurement_N` mapping.
+
+    `internal` is measured (q[0], forced to 1) but NOT returned; `out`
+    (q[1], stays 0) IS returned. Pre-#72 the harness counted positionally
+    and read `measurement_0` = the internal measurement (=1) -> wrong.
+    With named return tags it reads `out` by name -> 0 every shot.
+    """
+
+    def test_internal_measurement_does_not_shift_mapping(self) -> None:
+        prog = Main(
+            q := QReg("q", 2),
+            internal := CReg("internal", 1),
+            out := CReg("out", 1),
+            qb.X(q[0]),
+            Measure(q[0]) > internal[0],
+            Measure(q[1]) > out[0],
+            Return(out),
+        )
+        records = run_ast_guppy_via_selene(prog, shots=10)
+        assert all(r["measurement_0"] == 0 for r in records), records

From 030b9d1e4ca7e235da49b84ed4be49e75c944379 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sat, 16 May 2026 19:01:50 -0600
Subject: [PATCH 073/136] #72 close-out: fail-loud on unexpected Selene
 result-tag shape in _shot_records (Pickle non-blocking) -- explicit list/int
 dispatch, TypeError on any other type instead of silent single-bit wrap;
 behaviour-preserving (1123 passed, audit unchanged).

---
 .../slr_tests/ast_guppy/_selene_harness.py     | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py
index 6fda1e9b8..1da098ff4 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py
@@ -173,7 +173,23 @@ def _shot_records(result: pecos_rslib.ShotVec, record_cregs: list[RegisterDecl])
             shot_val = raw[key][shot_idx]
             # Selene shapes a size-1 CReg result tag as a scalar int per
             # shot, and a size>1 CReg as a list of `size` ints per shot.
-            bits = list(shot_val) if isinstance(shot_val, (list, tuple)) else [shot_val]
+            # Be explicit and fail LOUD on any other shape -- a silent
+            # mis-count is the exact bug class #72 fixed (do not let an
+            # unexpected Selene type, e.g. a numpy array/generator, be
+            # silently wrapped as one bit).
+            if isinstance(shot_val, (list, tuple)):
+                bits = list(shot_val)
+            elif isinstance(shot_val, int):  # bool is an int subclass
+                bits = [shot_val]
+            else:
+                msg = (
+                    f"Return tag {key!r} shot {shot_idx}: unexpected Selene "
+                    f"value shape {type(shot_val).__name__} ({shot_val!r}); "
+                    "expected a scalar int (size-1 CReg) or a list of ints "
+                    "(size>1 CReg). Selene's result-tag output shape may "
+                    "have changed -- update _shot_records deliberately."
+                )
+                raise TypeError(msg)
             if len(bits) != decl.size:
                 msg = (
                     f"Return tag {key!r} shot {shot_idx} has {len(bits)} bits, "

From 1301f73b212a814bcfe6896b74f60ec2f62526e1 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sat, 16 May 2026 19:30:00 -0600
Subject: [PATCH 074/136] #71 Stage A: add qir-qis test-group dep + QIR
 spec-compliance baseline gate over the audit corpus. Honest non-faked
 baseline (0 compliant; uniform missing-output_labeling_schema cause;
 build-failure set pinned so a new qir_bc regression trips it); trips
 deliberately on Stage-B progress. Codex blocker folded + re-confirmed; Pickle
 signed off. Test-only, production byte-identical.

---
 pyproject.toml                                |   1 +
 .../ast_guppy/test_qir_spec_compliance.py     | 130 ++++++++++++++++++
 uv.lock                                       |  14 ++
 3 files changed, 145 insertions(+)
 create mode 100644 python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py

diff --git a/pyproject.toml b/pyproject.toml
index 3bde0ac88..645228ceb 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -57,6 +57,7 @@ test = [ # exact pins so workspace tests run against a reproducible environment
   "hypothesis==6.152.1",
   "stim==1.15.0",        # Stim-comparison and decomposition-invariant tests
   "matplotlib>=2.2.0",   # Surface-patch render tests import matplotlib directly
+  "qir-qis==0.1.8",      # QIR spec-compliance validation gate over the audit corpus (#71 Stage A)
 ]
 examples = [ # extras used by the examples/ tree and notebook walkthroughs
   "jupyter>=1.1.1",
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
new file mode 100644
index 000000000..01e8b5c5c
--- /dev/null
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
@@ -0,0 +1,130 @@
+# Copyright 2026 The PECOS Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations under the License.
+
+"""#71 Stage A: QIR spec-compliance gate over the audit corpus.
+
+Runs Quantinuum's `qir-qis` `validate_qir()` over `SlrConverter(prog)
+.qir_bc()` for every audit-corpus program and pins the *current*
+spec-compliance state as an explicit, honest baseline:
+
+- **0** programs are spec-compliant today.
+- Every program whose `qir_bc()` builds fails `validate_qir` with the
+  SAME single root cause: a missing standard QIR module
+  attribute/flags (`output_labeling_schema`, `qir_major_version`, ...).
+- A few programs fail at `qir_bc()` build time -- those are
+  pre-existing AST-QIR feature gaps (symbolic loopvar, parameterized
+  RX, the Steane RUS path) tracked separately (the audit v2-defer
+  XFAILs / the `optional_dependency` `*_qir` failures), NOT a #71
+  concern. Their identity IS pinned (`_EXPECTED_BUILD_FAILED`) so a
+  NEW build regression in a currently-buildable program trips this
+  gate instead of being silently absorbed as "out of #71 scope".
+
+This is the Stage A deliverable: a precise, regression-detecting
+spec-noncompliance punch list. It is GREEN because it asserts the
+*known* non-compliance -- it does NOT fake compliance. When Stage B
+adds the missing QIR module metadata to `ast/codegen/qir.py`,
+programs will start passing `validate_qir`, this baseline assertion
+will trip, and it must be updated deliberately -- that is the
+intended visible-progress signal.
+
+`qir-qis` is a `[dependency-groups].test` dependency (installed in
+the workspace dev/CI test env), so this runs in the default sweep.
+"""
+
+from __future__ import annotations
+
+import qir_qis
+from pecos.slr import SlrConverter
+
+from .audit_runner import _curated_cases  # noqa: TID252
+
+# Single uniform Stage-A non-compliance cause across all buildable QIR.
+_KNOWN_GAP = "output_labeling_schema"
+
+# Pinned pre-existing `qir_bc()` build failures: NOT #71 metadata
+# concerns (tracked separately as audit v2-defer XFAILs / the
+# `optional_dependency` `*_qir` failures). Pinned by (exc type, stable
+# message fragment) -- NOT full messages, which embed `/tmp/...:line`
+# paths. The point (Codex review blocker): a NEW qir_bc() build
+# regression in a currently-buildable program must TRIP this gate, not
+# be silently absorbed into "excluded from #71 scope".
+# Fragments are deliberately quote-free + identifier/head-only: LLVM
+# error text backslash-escapes embedded quotes (e.g. `function
+# \'__quantum__qis__rx__body\'`), so a quote-bearing fragment would not
+# match. The bare identifier / message head is the stable part.
+_EXPECTED_BUILD_FAILED: dict[str, tuple[str, str]] = {
+    "docs.for_loopvar_symbolic": ("AttributeError", "SymbolicQubit"),
+    "docs.rotation_rx": ("RuntimeError", "__quantum__qis__rx__body"),
+    "qeclib.steane_pz": ("RuntimeError", "Failed to compile QIR to bitcode"),
+}
+
+
+def _qir_compliance_state() -> tuple[list[str], list[tuple[str, str]], list[tuple[str, str, str]]]:
+    """Categorize the audit corpus.
+
+    Returns `(accepted, valerr[(label,msg)], build_failed[(label,exc_type,exc_msg)])`.
+    """
+    accepted: list[str] = []
+    valerr: list[tuple[str, str]] = []
+    build_failed: list[tuple[str, str, str]] = []
+    for case in _curated_cases():
+        try:
+            bc = SlrConverter(case.factory()).qir_bc()
+        except Exception as exc:  # pre-existing AST-QIR build gaps; identity pinned in the test
+            build_failed.append((case.label, type(exc).__name__, str(exc)))
+            continue
+        try:
+            qir_qis.validate_qir(bc)
+            accepted.append(case.label)
+        except qir_qis.ValidationError as exc:
+            valerr.append((case.label, str(exc)))
+    return accepted, valerr, build_failed
+
+
+def test_audit_corpus_qir_spec_noncompliance_baseline() -> None:
+    """Pin the Stage-A spec-compliance baseline (see module docstring)."""
+    accepted, valerr, build_failed = _qir_compliance_state()
+    build_labels = sorted(label for label, _, _ in build_failed)
+
+    # Sanity: validate_qir actually ran on built QIR. `accepted` also
+    # counts as proof so that full Stage-B progress trips the intended
+    # `accepted == []` baseline assertion below (with its clear message),
+    # not this guard.
+    assert valerr or accepted, f"validate_qir never ran on built QIR; build_failed={build_labels}"
+
+    # Stage A reality: nothing is spec-compliant yet. When Stage B adds
+    # the QIR module metadata this will (intentionally) fail -> update
+    # this baseline as the visible-progress signal.
+    assert accepted == [], (
+        f"{len(accepted)} program(s) now pass qir-qis validate_qir "
+        f"({sorted(accepted)}). If this is Stage B progress, update this "
+        "baseline deliberately."
+    )
+
+    # The non-compliance is uniform: a single missing-module-metadata
+    # root cause. A NEW kind of ValidationError must surface deliberately.
+    non_uniform = [(label, msg[:160]) for label, msg in valerr if _KNOWN_GAP not in msg]
+    assert not non_uniform, f"new/unexpected QIR ValidationError kinds (not the {_KNOWN_GAP!r} gap): {non_uniform}"
+
+    # Pin the build-failure set + its (exc type, message fragment). A new
+    # build regression -- or a fixed one -- must be triaged deliberately
+    # rather than silently scoped out of #71 (Codex review blocker).
+    got = {label: (etype, emsg) for label, etype, emsg in build_failed}
+    assert set(got) == set(_EXPECTED_BUILD_FAILED), (
+        f"qir_bc() build-failure set changed: got {sorted(got)}, "
+        f"expected {sorted(_EXPECTED_BUILD_FAILED)}. Triage any new build "
+        "regression (pre-existing AST-QIR gap vs real regression) before "
+        "updating this pin."
+    )
+    for label, (exp_type, exp_frag) in _EXPECTED_BUILD_FAILED.items():
+        got_type, got_msg = got[label]
+        assert got_type == exp_type, f"{label}: build-fail exc type {got_type!r}, expected {exp_type!r}"
+        assert exp_frag in got_msg, f"{label}: build-fail message lacks {exp_frag!r}: {got_msg[:200]}"
diff --git a/uv.lock b/uv.lock
index dac8bd4a5..5fdd480ba 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2951,6 +2951,7 @@ test = [
     { name = "pytest" },
     { name = "pytest-cov" },
     { name = "pytest-timeout" },
+    { name = "qir-qis" },
     { name = "stim" },
 ]
 
@@ -2987,6 +2988,7 @@ test = [
     { name = "pytest", specifier = "==9.0.3" },
     { name = "pytest-cov", specifier = "==7.1.0" },
     { name = "pytest-timeout", specifier = "==2.4.0" },
+    { name = "qir-qis", specifier = "==0.1.8" },
     { name = "stim", specifier = "==1.15.0" },
 ]
 
@@ -3906,6 +3908,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/49/88/53d1ec8c639305fb96944b3a1e7f60b6e6af80781d970036c3cf2d6d2316/pyzstd-0.18.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:b32184013f33dba2fabcdda89f2a83289f5b717a0c2477cda764e53fdafec7ee", size = 244902, upload-time = "2025-10-05T08:19:40.607Z" },
 ]
 
+[[package]]
+name = "qir-qis"
+version = "0.1.8"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ce/ac/11711f962921cb87044401be994bdf69a0b5cfad7af355f81bbe28d6a56d/qir_qis-0.1.8-cp310-abi3-macosx_10_9_x86_64.whl", hash = "sha256:eb5614319504815b93a551c4a9f9485ff70efd4c05414b4ce8cc933368e0f5e3", size = 21856530, upload-time = "2026-05-04T14:27:04.865Z" },
+    { url = "https://files.pythonhosted.org/packages/97/1e/7d2d1a2d8e2955b3e3c491f67aead4205e7a17dcd2ed18b9d999ba337fbd/qir_qis-0.1.8-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:2baabc01a6538906d4b7be37f5169237419aac2933e193ef82909b82c525dac1", size = 20954363, upload-time = "2026-05-04T14:27:07.301Z" },
+    { url = "https://files.pythonhosted.org/packages/45/61/d70e18facc6c919e01e5ca7dca50b2a0b41a0ee44a0cc18569cf1c7686a6/qir_qis-0.1.8-cp310-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:9c27f5e32e0ec26b2cfe61b81022775aa0c7c9ce371c75fdd4d8fdacdc2a59c6", size = 29332077, upload-time = "2026-05-04T14:27:09.795Z" },
+    { url = "https://files.pythonhosted.org/packages/47/0e/3b4de5f64a600f49df99129703b819bbc3b51bd570d06bdbec15305ebfa1/qir_qis-0.1.8-cp310-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:8ff56f0f16e5ace37828a3b398017a4915c55fcb0479361281b9ec13628e2be5", size = 30264567, upload-time = "2026-05-04T14:27:12.779Z" },
+    { url = "https://files.pythonhosted.org/packages/24/31/fc4bbe9157a5dcbaa3a28d3cc28ec29711c20f621f00a6302a0cb627a0c1/qir_qis-0.1.8-cp310-abi3-win_amd64.whl", hash = "sha256:f0b132d582fb110a18147eb16db2a5ae6a716b4a014b0618f471011c40a12fc1", size = 4205354, upload-time = "2026-05-04T14:27:15.316Z" },
+]
+
 [[package]]
 name = "quantum-pecos"
 version = "0.8.0.dev8"

From 08b901c027b166f08fd207123faec503502c9426 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sat, 16 May 2026 20:20:32 -0600
Subject: [PATCH 075/136] #71 Stage B1: emit required QIR module metadata in
 _finalize_module (output_labeling_schema=labeled,
 qir_profiles=adaptive_profile, !llvm.module.flags qir_*_version +
 dynamic_*/arrays=false). validate_qir 0->27/28; honest two-tier gate (Tier-1
 validate, Tier-1b exact entry-attr value pins, Tier-2 qir_to_qis still
 create_creg until B2; build-fails pinned). Dual post-review: Pickle YES;
 Codex blocker (presence-only value pin) folded+re-confirmed. QASM/Stim/QC
 byte-identical; audit/optional_dep unchanged.

---
 .../src/pecos/slr/ast/codegen/qir.py          |  18 +-
 .../ast_guppy/test_qir_spec_compliance.py     | 267 ++++++++++++------
 2 files changed, 196 insertions(+), 89 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
index ed66ab932..3ea54ec64 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
@@ -692,9 +692,25 @@ def _finalize_module(self) -> str:
         mod_w_attr = ll_text.replace("@main()", "@main() #0")
 
         mod_w_attr += '\nattributes #0 = { "entry_point"'
-        mod_w_attr += ' "qir_profiles"="custom"'
+        # adaptive_profile: PECOS emits measurement-conditioned `If` ->
+        # adaptive, not base profile (#71 Stage B1, dual-review pinned).
+        mod_w_attr += ' "qir_profiles"="adaptive_profile"'
+        mod_w_attr += ' "output_labeling_schema"="labeled"'
         mod_w_attr += f' "required_num_qubits"="{self.context.qubit_count}"'
         mod_w_attr += f' "required_num_results"="{self.context.measurement_count}" }}'
+
+        # QIR module flags (Adaptive Profile). pecos_rslib_llvm.ir.Module has
+        # no named-metadata API, so append as raw IR text -- same approach as
+        # the entry attributes above. The emitted module carries no `!`
+        # metadata, so !0..!4 are collision-free. Static classical model
+        # (#71 Stage B): dynamic_*/arrays = false (B2 keeps the static
+        # %Result + mutable local-buffer model; flags must match).
+        mod_w_attr += "\n!llvm.module.flags = !{!0, !1, !2, !3, !4}"
+        mod_w_attr += '\n!0 = !{i32 1, !"qir_major_version", i32 1}'
+        mod_w_attr += '\n!1 = !{i32 7, !"qir_minor_version", i32 0}'
+        mod_w_attr += '\n!2 = !{i32 1, !"dynamic_qubit_management", i1 false}'
+        mod_w_attr += '\n!3 = !{i32 1, !"dynamic_result_management", i1 false}'
+        mod_w_attr += '\n!4 = !{i32 1, !"arrays", i1 false}'
         return mod_w_attr
 
     def _fix_internal_consts(self, llvm_ir: str) -> str:
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
index 01e8b5c5c..fc2a7c67e 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
@@ -9,34 +9,51 @@
 # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 # specific language governing permissions and limitations under the License.
 
-"""#71 Stage A: QIR spec-compliance gate over the audit corpus.
-
-Runs Quantinuum's `qir-qis` `validate_qir()` over `SlrConverter(prog)
-.qir_bc()` for every audit-corpus program and pins the *current*
-spec-compliance state as an explicit, honest baseline:
-
-- **0** programs are spec-compliant today.
-- Every program whose `qir_bc()` builds fails `validate_qir` with the
-  SAME single root cause: a missing standard QIR module
-  attribute/flags (`output_labeling_schema`, `qir_major_version`, ...).
-- A few programs fail at `qir_bc()` build time -- those are
-  pre-existing AST-QIR feature gaps (symbolic loopvar, parameterized
-  RX, the Steane RUS path) tracked separately (the audit v2-defer
-  XFAILs / the `optional_dependency` `*_qir` failures), NOT a #71
-  concern. Their identity IS pinned (`_EXPECTED_BUILD_FAILED`) so a
-  NEW build regression in a currently-buildable program trips this
-  gate instead of being silently absorbed as "out of #71 scope".
-
-This is the Stage A deliverable: a precise, regression-detecting
-spec-noncompliance punch list. It is GREEN because it asserts the
-*known* non-compliance -- it does NOT fake compliance. When Stage B
-adds the missing QIR module metadata to `ast/codegen/qir.py`,
-programs will start passing `validate_qir`, this baseline assertion
-will trip, and it must be updated deliberately -- that is the
-intended visible-progress signal.
-
-`qir-qis` is a `[dependency-groups].test` dependency (installed in
-the workspace dev/CI test env), so this runs in the default sweep.
+"""#71 QIR spec-compliance gate over the audit corpus -- post-B1 baseline.
+
+Runs Quantinuum's `qir-qis` over `SlrConverter(prog).qir_bc()` for
+every audit-corpus program and pins the *current* two-tier state as
+an explicit, honest baseline. NOT faked-green: it asserts exactly
+what is and is not compliant, so any regression OR Stage-B progress
+trips it deliberately.
+
+**Tier 1 -- `validate_qir` (QIR spec metadata): Stage B1 DONE.**
+27/28 buildable programs now PASS `validate_qir` (B1 added the
+required QIR module metadata: `output_labeling_schema`,
+`qir_profiles=adaptive_profile`, and the `qir_*_version` /
+`dynamic_*` / `arrays` module flags). The single remaining
+`validate_qir` failure is `legacy.empty_main` -- NOT a metadata
+gap: qir-qis structurally requires the entry function to have >=1
+qubit, and that program has none. Pinned (`_EXPECTED_VALIDATE_FAILED`)
+as a known non-metadata structural limitation so a NEW validate
+failure trips this gate. Tier-1b additionally pins the exact entry
+attr *values* (qir-qis only checks presence). `adaptive_profile`
+is a deliberate forward-looking choice for B2 (it introduces
+`__quantum__rt__read_result`); it is NOT yet exercised by the
+corpus (`base_profile` also validates today).
+
+**Tier 2 -- `qir_to_qis` (ingestible): Stage B2 NOT done.**
+Of the 27 validate-passing programs, 7 already lower via
+`qir_to_qis` (`_EXPECTED_QIS_OK` -- the no-CReg programs); the other
+20 fail uniformly with `Unsupported function: create_creg` -- the
+PECOS-bespoke CReg helpers Stage B2 will replace with the standard
+static `%Result` + mutable-local-buffer model. B1 is **metadata
+compliance only, NOT qir-qis ingestibility** (proven: B1-alone is
+validate_qir-green but qir_to_qis still rejects `create_creg`).
+When B2 lands, the 20 flip to OK -> `_EXPECTED_QIS_OK` trips ->
+update this baseline deliberately (the intended progress signal).
+
+**Pre-existing build failures** (3): `qir_bc()` itself raises for
+`docs.for_loopvar_symbolic` / `docs.rotation_rx` / `qeclib.steane_pz`
+-- pre-existing AST-QIR feature gaps tracked separately (audit
+v2-defer XFAILs / `optional_dependency` `*_qir`; the semantic-bug
+split is task #74), NOT a #71 metadata concern. Identity pinned
+(`_EXPECTED_BUILD_FAILED`) so a NEW build regression in a
+currently-buildable program trips here instead of being silently
+absorbed.
+
+`qir-qis` is a `[dependency-groups].test` dep (default-groups
+includes `test`), so this runs in the default sweep.
 """
 
 from __future__ import annotations
@@ -46,85 +63,159 @@
 
 from .audit_runner import _curated_cases  # noqa: TID252
 
-# Single uniform Stage-A non-compliance cause across all buildable QIR.
-_KNOWN_GAP = "output_labeling_schema"
-
-# Pinned pre-existing `qir_bc()` build failures: NOT #71 metadata
-# concerns (tracked separately as audit v2-defer XFAILs / the
-# `optional_dependency` `*_qir` failures). Pinned by (exc type, stable
-# message fragment) -- NOT full messages, which embed `/tmp/...:line`
-# paths. The point (Codex review blocker): a NEW qir_bc() build
-# regression in a currently-buildable program must TRIP this gate, not
-# be silently absorbed into "excluded from #71 scope".
-# Fragments are deliberately quote-free + identifier/head-only: LLVM
-# error text backslash-escapes embedded quotes (e.g. `function
-# \'__quantum__qis__rx__body\'`), so a quote-bearing fragment would not
-# match. The bare identifier / message head is the stable part.
+# Pinned pre-existing `qir_bc()` build failures (NOT #71 metadata;
+# task #74 / audit v2-defer). (exc type, quote-free stable fragment) --
+# LLVM text backslash-escapes embedded quotes, so a quote-bearing
+# fragment would not match; the bare identifier/head is stable.
 _EXPECTED_BUILD_FAILED: dict[str, tuple[str, str]] = {
     "docs.for_loopvar_symbolic": ("AttributeError", "SymbolicQubit"),
     "docs.rotation_rx": ("RuntimeError", "__quantum__qis__rx__body"),
     "qeclib.steane_pz": ("RuntimeError", "Failed to compile QIR to bitcode"),
 }
 
+# Tier 1: the ONLY non-metadata `validate_qir` failure post-B1 --
+# qir-qis requires the entry function to have >=1 qubit; this program
+# has none. Pinned (label -> stable message fragment) so a NEW
+# validate failure (e.g. a B1 metadata regression) trips deliberately.
+_EXPECTED_VALIDATE_FAILED: dict[str, str] = {
+    "legacy.empty_main": "at least one qubit",
+}
+
+# Tier 2: programs that already lower via `qir_to_qis` post-B1 (no
+# bespoke CReg helpers). The remaining validate-passing programs fail
+# uniformly with `_QIS_B2_GAP` until Stage B2. When B2 lands they flip
+# into this set -> this pin trips -> update the baseline deliberately.
+_EXPECTED_QIS_OK: frozenset[str] = frozenset(
+    {
+        "docs.inline_measure_creg",
+        "examples.surface_d3_x_1round",
+        "examples.surface_d3_z_1round",
+        "legacy.gates_only_no_measurement",
+        "qeclib.surface_patch_builder_empty",
+        "qeclib.surface_std_pz",
+        "v1.repeat_idle",
+    },
+)
+_QIS_B2_GAP = "create_creg"
+
+# Codex B1 post-review blocker: qir-qis validates the PRESENCE of these
+# entry attributes but NOT their values, so a value regression (e.g.
+# silently reverting `qir_profiles` to "custom"/"base_profile", or
+# `output_labeling_schema` to something else) would pass both qir-qis
+# AND this gate. Pin the exact values via `get_entry_attributes()`.
+# (`qir_profiles="adaptive_profile"` is a deliberate forward-looking
+# choice for B2 -- which introduces `__quantum__rt__read_result` for
+# mid-circuit measurement feedback -- NOT a current-corpus requirement:
+# `base_profile` also passes `validate_qir` today, since the corpus's
+# `If(creg_bit)` lowers to a plain LLVM `br` on a loaded buffer value.)
+_EXPECTED_ENTRY_ATTRS: dict[str, str] = {
+    "qir_profiles": "adaptive_profile",
+    "output_labeling_schema": "labeled",
+}
 
-def _qir_compliance_state() -> tuple[list[str], list[tuple[str, str]], list[tuple[str, str, str]]]:
-    """Categorize the audit corpus.
 
-    Returns `(accepted, valerr[(label,msg)], build_failed[(label,exc_type,exc_msg)])`.
+def _qir_state() -> tuple[
+    list[tuple[str, str, str]],
+    list[tuple[str, str]],
+    list[str],
+    list[tuple[str, str]],
+    list[tuple[str, dict[str, str | None]]],
+]:
+    """Categorize the corpus.
+
+    Returns `(build_failed[(label,exc_type,exc_msg)],
+    validate_failed[(label,msg)], qis_ok[label],
+    qis_failed[(label,msg)],
+    entry_attrs[(label, get_entry_attributes(bc))])` -- the last only
+    for validate-passing cases (so the pinned attr *values* are
+    checked, since qir-qis only enforces their presence).
     """
-    accepted: list[str] = []
-    valerr: list[tuple[str, str]] = []
     build_failed: list[tuple[str, str, str]] = []
+    validate_failed: list[tuple[str, str]] = []
+    qis_ok: list[str] = []
+    qis_failed: list[tuple[str, str]] = []
+    entry_attrs: list[tuple[str, dict[str, str | None]]] = []
     for case in _curated_cases():
         try:
             bc = SlrConverter(case.factory()).qir_bc()
-        except Exception as exc:  # pre-existing AST-QIR build gaps; identity pinned in the test
+        except Exception as exc:  # pre-existing AST-QIR build gaps; identity pinned below
             build_failed.append((case.label, type(exc).__name__, str(exc)))
             continue
         try:
             qir_qis.validate_qir(bc)
-            accepted.append(case.label)
         except qir_qis.ValidationError as exc:
-            valerr.append((case.label, str(exc)))
-    return accepted, valerr, build_failed
-
-
-def test_audit_corpus_qir_spec_noncompliance_baseline() -> None:
-    """Pin the Stage-A spec-compliance baseline (see module docstring)."""
-    accepted, valerr, build_failed = _qir_compliance_state()
-    build_labels = sorted(label for label, _, _ in build_failed)
-
-    # Sanity: validate_qir actually ran on built QIR. `accepted` also
-    # counts as proof so that full Stage-B progress trips the intended
-    # `accepted == []` baseline assertion below (with its clear message),
-    # not this guard.
-    assert valerr or accepted, f"validate_qir never ran on built QIR; build_failed={build_labels}"
-
-    # Stage A reality: nothing is spec-compliant yet. When Stage B adds
-    # the QIR module metadata this will (intentionally) fail -> update
-    # this baseline as the visible-progress signal.
-    assert accepted == [], (
-        f"{len(accepted)} program(s) now pass qir-qis validate_qir "
-        f"({sorted(accepted)}). If this is Stage B progress, update this "
-        "baseline deliberately."
-    )
-
-    # The non-compliance is uniform: a single missing-module-metadata
-    # root cause. A NEW kind of ValidationError must surface deliberately.
-    non_uniform = [(label, msg[:160]) for label, msg in valerr if _KNOWN_GAP not in msg]
-    assert not non_uniform, f"new/unexpected QIR ValidationError kinds (not the {_KNOWN_GAP!r} gap): {non_uniform}"
-
-    # Pin the build-failure set + its (exc type, message fragment). A new
-    # build regression -- or a fixed one -- must be triaged deliberately
-    # rather than silently scoped out of #71 (Codex review blocker).
-    got = {label: (etype, emsg) for label, etype, emsg in build_failed}
-    assert set(got) == set(_EXPECTED_BUILD_FAILED), (
-        f"qir_bc() build-failure set changed: got {sorted(got)}, "
-        f"expected {sorted(_EXPECTED_BUILD_FAILED)}. Triage any new build "
-        "regression (pre-existing AST-QIR gap vs real regression) before "
-        "updating this pin."
+            validate_failed.append((case.label, str(exc)))
+            continue
+        entry_attrs.append((case.label, qir_qis.get_entry_attributes(bc)))
+        try:
+            qir_qis.qir_to_qis(bc)
+            qis_ok.append(case.label)
+        except qir_qis.CompilerError as exc:
+            qis_failed.append((case.label, str(exc)))
+    return build_failed, validate_failed, qis_ok, qis_failed, entry_attrs
+
+
+def test_audit_corpus_qir_compliance_baseline() -> None:
+    """Pin the post-B1 two-tier QIR-compliance baseline (see module docstring)."""
+    build_failed, validate_failed, qis_ok, qis_failed, entry_attrs = _qir_state()
+
+    # Sanity: validate_qir actually ran on built QIR (not vacuous).
+    assert (
+        qis_ok or qis_failed or validate_failed
+    ), f"validate_qir never ran on built QIR; build_failed={sorted(label for label, _, _ in build_failed)}"
+
+    # Pre-existing build-failure set pinned (Codex Stage-A blocker): a
+    # new build regression -- or a fixed one -- must be triaged
+    # deliberately, not silently scoped out.
+    got_bf = {label: (etype, emsg) for label, etype, emsg in build_failed}
+    assert set(got_bf) == set(_EXPECTED_BUILD_FAILED), (
+        f"qir_bc() build-failure set changed: got {sorted(got_bf)}, expected "
+        f"{sorted(_EXPECTED_BUILD_FAILED)}. Triage (pre-existing AST-QIR gap "
+        "vs real regression) before updating this pin."
     )
     for label, (exp_type, exp_frag) in _EXPECTED_BUILD_FAILED.items():
-        got_type, got_msg = got[label]
+        got_type, got_msg = got_bf[label]
         assert got_type == exp_type, f"{label}: build-fail exc type {got_type!r}, expected {exp_type!r}"
         assert exp_frag in got_msg, f"{label}: build-fail message lacks {exp_frag!r}: {got_msg[:200]}"
+
+    # Tier 1 -- validate_qir: B1 metadata done. ONLY the pinned
+    # non-metadata structural failure(s) may fail validate_qir; a new
+    # one (e.g. a B1 metadata regression) trips here.
+    got_vf = dict(validate_failed)
+    assert set(got_vf) == set(_EXPECTED_VALIDATE_FAILED), (
+        f"validate_qir failure set changed: got {sorted(got_vf)}, expected "
+        f"{sorted(_EXPECTED_VALIDATE_FAILED)}. A new validate failure likely "
+        "means a B1 metadata regression -- triage before re-pinning."
+    )
+    for label, frag in _EXPECTED_VALIDATE_FAILED.items():
+        assert frag in got_vf[label], f"{label}: validate msg lacks {frag!r}: {got_vf[label][:200]}"
+
+    # Tier 1b -- pin the exact entry-attr VALUES (Codex B1 blocker).
+    # qir-qis only enforces presence, so a value regression would pass
+    # both qir-qis and the presence-only tier-1 check above.
+    assert entry_attrs, "no validate-passing cases to check entry-attr values"
+    for label, attrs in entry_attrs:
+        for key, want in _EXPECTED_ENTRY_ATTRS.items():
+            assert attrs.get(key) == want, (
+                f"{label}: entry attr {key!r} = {attrs.get(key)!r}, expected {want!r}. "
+                "B1 metadata value regression -- qir-qis does not catch this; "
+                "this pin is the only guard."
+            )
+
+    # Tier 2 -- qir_to_qis: B2 NOT done. The already-ingestible set is
+    # pinned; when B2 replaces the bespoke CReg helpers the currently
+    # failing programs flip into it and THIS assertion trips -> update
+    # the baseline deliberately (the intended progress signal).
+    assert set(qis_ok) == set(_EXPECTED_QIS_OK), (
+        f"qir_to_qis-OK set changed: got {sorted(qis_ok)}, expected "
+        f"{sorted(_EXPECTED_QIS_OK)}. If this is Stage B2 progress, update "
+        "this baseline deliberately."
+    )
+    # Every other validate-passing program must still fail qir_to_qis
+    # for the single uniform B2 reason (the bespoke CReg helpers).
+    assert qis_failed, "expected the non-OK validate-passing programs to fail qir_to_qis until B2"
+    non_uniform = [(label, msg[:160]) for label, msg in qis_failed if _QIS_B2_GAP not in msg]
+    assert not non_uniform, (
+        f"qir_to_qis failures not uniformly the {_QIS_B2_GAP!r} (B2) gap: {non_uniform}. "
+        "A new qir_to_qis failure kind must be triaged deliberately."
+    )

From 29fa4b40e1c1d6666cbc3bc7265ced558bbc5acd Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sat, 16 May 2026 20:47:46 -0600
Subject: [PATCH 076/136] #71 B2a: declare standard QIR classical-model
 functions (__quantum__qis__mz__body, __quantum__rt__read_result) for B2b to
 wire. Decls-only, zero behavior/gate change; verified inert
 (validate/qir_to_qis split, gate, broad 1124, audit all unchanged). Helper
 methods deferred to B2b (no dead code).

---
 .../src/pecos/slr/ast/codegen/qir.py             | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
index 3ea54ec64..5a4b45382 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
@@ -220,6 +220,22 @@ def generate(self, program: Program) -> str:
             ],
         )
 
+        # B2a: declare the standard QIR classical-model functions. Declared
+        # here so B2b can wire the per-op lowering (static %Result slot ->
+        # mz__body -> read_result -> mutable [N x i1] CReg buffer); the
+        # bespoke model above stays the active path until B2b (no behavior
+        # / gate change in B2a). `%Result*` is the existing result_ptr type.
+        self._mz_body = self._declare_function(
+            "__quantum__qis__mz__body",
+            self._types["void"],
+            [self._types["qubit_ptr"], self._types["result_ptr"]],
+        )
+        self._read_result = self._declare_function(
+            "__quantum__rt__read_result",
+            self._types["bool"],
+            [self._types["result_ptr"]],
+        )
+
         # Setup main function
         main_fnty = llvm_ir.FunctionType(self._types["void"], [])
         self._main_func = llvm_ir.Function(self._module, main_fnty, name="main")

From 9c2ca828c1cb46b07c1b30754e4cbc842a580e1c Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sat, 16 May 2026 21:46:00 -0600
Subject: [PATCH 077/136] #75: extend pecos_rslib_llvm with LLVM memory ops to
 unblock #71 B2 -- LLIRBuilder::{alloca,load,store,zext,trunc,icmp_unsigned} +
 LLConstant::zero (Array->zeroinitializer, Pointer->null) in
 crates/pecos-llvm; LLType PartialEq/Eq + manual Hash consistent with
 inkwell's LLVMTypeRef Eq (inkwell 0.8.0 derives Hash only for IntType); 6
 pyo3 #[pymethods] + Constant(ty,value=None)->zero + PyLLValue.type getter +
 structural __richcmp__/__hash__ on Py*Type (PyAnyType gains IntoPyObject so
 the getter is returnable). Additive only: end-to-end B2-shaped module via the
 new ops round-trips binding.parse_assembly + qir_qis.validate_qir +
 qir_to_qis; #71 gate 1 passed unchanged, slr_tests 368 passed, broad
 qir/qasm/codegen sweep 1785 passed 0 fail; cargo fmt/clippy clean.

---
 crates/pecos-llvm/src/llvm_compat.rs         | 148 ++++++++++++-
 python/pecos-rslib-llvm/src/llvm_bindings.rs | 212 ++++++++++++++++++-
 2 files changed, 357 insertions(+), 3 deletions(-)

diff --git a/crates/pecos-llvm/src/llvm_compat.rs b/crates/pecos-llvm/src/llvm_compat.rs
index 483a2469d..ae7214518 100644
--- a/crates/pecos-llvm/src/llvm_compat.rs
+++ b/crates/pecos-llvm/src/llvm_compat.rs
@@ -226,7 +226,7 @@ impl<'ctx> LLFunctionType<'ctx> {
 }
 
 /// Wrapper for LLVM types that mirrors llvmlite's type hierarchy
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, PartialEq, Eq)]
 pub enum LLType<'ctx> {
     Void,
     Int(IntType<'ctx>),
@@ -236,6 +236,38 @@ pub enum LLType<'ctx> {
     Array(ArrayType<'ctx>),
 }
 
+// inkwell 0.8.0 only derives `Hash` for `IntType`; the other type wrappers
+// are `Eq` (LLVM type-ref pointer equality) but not `Hash`. Hash the same
+// `LLVMTypeRef` pointer so `Hash` stays consistent with that `Eq`.
+impl std::hash::Hash for LLType<'_> {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        use inkwell::types::AsTypeRef;
+        match self {
+            LLType::Void => 0u8.hash(state),
+            LLType::Int(t) => {
+                1u8.hash(state);
+                (t.as_type_ref() as usize).hash(state);
+            }
+            LLType::Float(t) => {
+                2u8.hash(state);
+                (t.as_type_ref() as usize).hash(state);
+            }
+            LLType::Pointer(t) => {
+                3u8.hash(state);
+                (t.as_type_ref() as usize).hash(state);
+            }
+            LLType::Struct(t) => {
+                4u8.hash(state);
+                (t.as_type_ref() as usize).hash(state);
+            }
+            LLType::Array(t) => {
+                5u8.hash(state);
+                (t.as_type_ref() as usize).hash(state);
+            }
+        }
+    }
+}
+
 impl<'ctx> LLType<'ctx> {
     /// Create void type
     #[must_use]
@@ -717,6 +749,106 @@ impl<'ctx> LLIRBuilder<'ctx> {
             Ok(LLValue::Pointer(result))
         }
     }
+
+    // ========================================================================
+    // Memory ops + casts (#75 -- unblocks #71 B2 standard CReg model)
+    // ========================================================================
+
+    /// `alloca <ty>` -- stack slot. Caller positions the builder (B2
+    /// places `CReg` buffers in the entry block via `position_at_end`).
+    pub fn alloca(&self, ll_type: LLType<'ctx>, name: &str) -> LLResult<LLValue<'ctx>> {
+        let basic_ty = ll_type
+            .to_basic_metadata_type()
+            .ok_or_else(|| PecosError::Generic("Cannot alloca a void type".into()))?;
+        let result = self
+            .builder
+            .build_alloca(basic_ty, name)
+            .map_err(|e| PecosError::Generic(format!("Failed to build alloca: {e}")))?;
+        Ok(LLValue::Pointer(result))
+    }
+
+    /// `load` (LLVM-14 typed pointer: pointee inferred from `ptr`).
+    pub fn load(&self, ptr: LLValue<'ctx>, name: &str) -> LLResult<LLValue<'ctx>> {
+        let result = self
+            .builder
+            .build_load(ptr.as_pointer_value(), name)
+            .map_err(|e| PecosError::Generic(format!("Failed to build load: {e}")))?;
+        Ok(match result {
+            BasicValueEnum::IntValue(v) => LLValue::Int(v),
+            BasicValueEnum::FloatValue(v) => LLValue::Float(v),
+            BasicValueEnum::PointerValue(v) => LLValue::Pointer(v),
+            BasicValueEnum::ArrayValue(v) => LLValue::Array(v),
+            other => {
+                return Err(PecosError::Generic(format!(
+                    "load: unsupported loaded value type: {other:?}"
+                )));
+            }
+        })
+    }
+
+    /// `store` -- discards inkwell's returned pointer (Python `-> None`).
+    pub fn store(&self, ptr: LLValue<'ctx>, value: LLValue<'ctx>) -> LLResult<()> {
+        self.builder
+            .build_store(ptr.as_pointer_value(), value.to_basic_value())
+            .map_err(|e| PecosError::Generic(format!("Failed to build store: {e}")))?;
+        Ok(())
+    }
+
+    /// `zext` int value to a wider int type.
+    pub fn zext(
+        &self,
+        value: LLValue<'ctx>,
+        dest_type: LLType<'ctx>,
+        name: &str,
+    ) -> LLResult<LLValue<'ctx>> {
+        let result = self
+            .builder
+            .build_int_z_extend(value.as_int_value(), dest_type.as_int_type(), name)
+            .map_err(|e| PecosError::Generic(format!("Failed to build zext: {e}")))?;
+        Ok(LLValue::Int(result))
+    }
+
+    /// `trunc` int value to a narrower int type.
+    pub fn trunc(
+        &self,
+        value: LLValue<'ctx>,
+        dest_type: LLType<'ctx>,
+        name: &str,
+    ) -> LLResult<LLValue<'ctx>> {
+        let result = self
+            .builder
+            .build_int_truncate(value.as_int_value(), dest_type.as_int_type(), name)
+            .map_err(|e| PecosError::Generic(format!("Failed to build trunc: {e}")))?;
+        Ok(LLValue::Int(result))
+    }
+
+    /// Unsigned integer comparison (mirrors `icmp_signed` with U-predicates).
+    pub fn icmp_unsigned(
+        &self,
+        op: &str,
+        lhs: LLValue<'ctx>,
+        rhs: LLValue<'ctx>,
+        name: &str,
+    ) -> LLResult<LLValue<'ctx>> {
+        let predicate = match op {
+            "==" => IntPredicate::EQ,
+            "!=" => IntPredicate::NE,
+            "<" => IntPredicate::ULT,
+            ">" => IntPredicate::UGT,
+            "<=" => IntPredicate::ULE,
+            ">=" => IntPredicate::UGE,
+            _ => {
+                return Err(PecosError::Generic(format!(
+                    "Unknown comparison operator: {op}"
+                )));
+            }
+        };
+        let result = self
+            .builder
+            .build_int_compare(predicate, lhs.as_int_value(), rhs.as_int_value(), name)
+            .map_err(|e| PecosError::Generic(format!("Failed to build icmp: {e}")))?;
+        Ok(LLValue::Int(result))
+    }
 }
 
 // ============================================================================
@@ -766,4 +898,18 @@ impl LLConstant {
             )),
         }
     }
+
+    /// Zero/`zeroinitializer` constant of `ll_type` (#75 -- backs
+    /// `Constant(ty, None)`; Array -> `zeroinitializer`, Int -> `iN 0`).
+    pub fn zero(ll_type: LLType<'_>) -> LLResult<LLValue<'_>> {
+        match ll_type {
+            LLType::Int(t) => Ok(LLValue::Int(t.const_zero())),
+            LLType::Float(t) => Ok(LLValue::Float(t.const_zero())),
+            LLType::Pointer(t) => Ok(LLValue::Pointer(t.const_zero())),
+            LLType::Array(t) => Ok(LLValue::Array(t.const_zero())),
+            LLType::Void | LLType::Struct(_) => Err(PecosError::Generic(
+                "Cannot create a zero constant for void/struct type".to_string(),
+            )),
+        }
+    }
 }
diff --git a/python/pecos-rslib-llvm/src/llvm_bindings.rs b/python/pecos-rslib-llvm/src/llvm_bindings.rs
index f295e1ad8..ef6fc2d20 100644
--- a/python/pecos-rslib-llvm/src/llvm_bindings.rs
+++ b/python/pecos-rslib-llvm/src/llvm_bindings.rs
@@ -31,6 +31,7 @@
 use pecos_llvm::prelude::*;
 use pyo3::exceptions::PyRuntimeError;
 use pyo3::prelude::*;
+use pyo3::pyclass::CompareOp;
 use regex::Regex;
 use std::collections::HashMap;
 use std::sync::{Mutex, OnceLock};
@@ -394,7 +395,7 @@ impl PyModuleContext {
 // --- Type Classes ---
 
 /// Enum to handle any type for function parameters
-#[derive(Copy, Clone, FromPyObject)]
+#[derive(Copy, Clone, FromPyObject, IntoPyObject)]
 pub enum PyAnyType {
     Int(PyIntType),
     Double(PyDoubleType),
@@ -415,6 +416,40 @@ impl PyAnyType {
             PyAnyType::Array(t) => t.ll_type,
         }
     }
+
+    /// Underlying `LLType` (context-free; `to_ll_type` ignores its arg).
+    fn ll_type(&self) -> LLType<'static> {
+        match self {
+            PyAnyType::Int(t) => t.ll_type,
+            PyAnyType::Double(t) => t.ll_type,
+            PyAnyType::Void(_) => LLType::Void,
+            PyAnyType::Pointer(t) => t.ll_type,
+            PyAnyType::Struct(t) => LLType::Struct(t.struct_type),
+            PyAnyType::Array(t) => t.ll_type,
+        }
+    }
+}
+
+/// Structural type equality (llvmlite parity: `int_type(1) == int_type(1)`,
+/// `!= int_type(64)`). Non-type `other` -> not-equal (so `==` is `False`,
+/// `!=` is `True`); ordering comparisons are unsupported -> `false`.
+fn lltype_richcmp(a: LLType<'static>, other: &Bound<'_, PyAny>, op: CompareOp) -> bool {
+    let Ok(other) = other.extract::<PyAnyType>() else {
+        return matches!(op, CompareOp::Ne);
+    };
+    let eq = a == other.ll_type();
+    match op {
+        CompareOp::Eq => eq,
+        CompareOp::Ne => !eq,
+        _ => false,
+    }
+}
+
+/// Hash consistent with `lltype_richcmp` (equal types hash equal).
+fn lltype_hash(a: LLType<'static>) -> u64 {
+    let mut h = std::collections::hash_map::DefaultHasher::new();
+    std::hash::Hash::hash(&a, &mut h);
+    std::hash::Hasher::finish(&h)
 }
 
 /// Python wrapper for struct types
@@ -455,6 +490,13 @@ unsafe impl Sync for PyPointerType {}
 
 #[pymethods]
 impl PyPointerType {
+    fn __richcmp__(&self, other: &Bound<'_, PyAny>, op: CompareOp) -> bool {
+        lltype_richcmp(self.ll_type, other, op)
+    }
+    fn __hash__(&self) -> u64 {
+        lltype_hash(self.ll_type)
+    }
+
     fn as_pointer(&self) -> PyPointerType {
         let context = unsafe { &*self.context_ptr };
         let ptr_type = self.ll_type.as_pointer(context);
@@ -478,6 +520,13 @@ unsafe impl Sync for PyIntType {}
 
 #[pymethods]
 impl PyIntType {
+    fn __richcmp__(&self, other: &Bound<'_, PyAny>, op: CompareOp) -> bool {
+        lltype_richcmp(self.ll_type, other, op)
+    }
+    fn __hash__(&self) -> u64 {
+        lltype_hash(self.ll_type)
+    }
+
     fn as_pointer(&self) -> PyPointerType {
         let context = unsafe { &*self.context_ptr };
         let ptr_type = self.ll_type.as_pointer(context);
@@ -510,6 +559,13 @@ unsafe impl Sync for PyDoubleType {}
 
 #[pymethods]
 impl PyDoubleType {
+    fn __richcmp__(&self, other: &Bound<'_, PyAny>, op: CompareOp) -> bool {
+        lltype_richcmp(self.ll_type, other, op)
+    }
+    fn __hash__(&self) -> u64 {
+        lltype_hash(self.ll_type)
+    }
+
     fn as_pointer(&self) -> PyPointerType {
         let context = unsafe { &*self.context_ptr };
         let ptr_type = self.ll_type.as_pointer(context);
@@ -542,6 +598,13 @@ unsafe impl Sync for PyArrayType {}
 
 #[pymethods]
 impl PyArrayType {
+    fn __richcmp__(&self, other: &Bound<'_, PyAny>, op: CompareOp) -> bool {
+        lltype_richcmp(self.ll_type, other, op)
+    }
+    fn __hash__(&self) -> u64 {
+        lltype_hash(self.ll_type)
+    }
+
     #[new]
     fn new(element_type: PyAnyType, count: u32) -> Self {
         // Extract context pointer from element type
@@ -584,6 +647,20 @@ pub struct PyVoidType {
 unsafe impl Send for PyVoidType {}
 unsafe impl Sync for PyVoidType {}
 
+#[pymethods]
+impl PyVoidType {
+    // `&self` is mandated by pyo3 `#[pymethods]` dunders; the void type
+    // carries no per-instance state, so `self` is unused here by design.
+    #[allow(clippy::unused_self, clippy::trivially_copy_pass_by_ref)]
+    fn __richcmp__(&self, other: &Bound<'_, PyAny>, op: CompareOp) -> bool {
+        lltype_richcmp(LLType::Void, other, op)
+    }
+    #[allow(clippy::unused_self, clippy::trivially_copy_pass_by_ref)]
+    fn __hash__(&self) -> u64 {
+        lltype_hash(LLType::Void)
+    }
+}
+
 // --- IRBuilder - Instruction builder ---
 
 /// Python wrapper for LLVM IR instruction builder
@@ -843,6 +920,92 @@ impl PyIRBuilder {
         })
     }
 
+    /// Allocate a stack slot (`alloca <ty>`); caller positions the builder.
+    #[pyo3(signature = (ty, name=""))]
+    fn alloca(&mut self, ty: PyAnyType, name: &str) -> PyResult<PyLLValue> {
+        let builder = unsafe { &mut *self.builder_ptr };
+        let context = unsafe { &*self.context_ptr };
+        let ll_type = ty.to_ll_type(context);
+        let result = builder
+            .alloca(ll_type, name)
+            .map_err(|e| PyRuntimeError::new_err(format!("alloca failed: {e}")))?;
+        Ok(PyLLValue {
+            value: result,
+            context_ptr: self.context_ptr,
+        })
+    }
+
+    /// Load from a pointer (`load`; LLVM-14 typed-pointer pointee).
+    #[pyo3(signature = (ptr, name=""))]
+    fn load(&mut self, ptr: PyLLValue, name: &str) -> PyResult<PyLLValue> {
+        let builder = unsafe { &mut *self.builder_ptr };
+        let result = builder
+            .load(ptr.value, name)
+            .map_err(|e| PyRuntimeError::new_err(format!("load failed: {e}")))?;
+        Ok(PyLLValue {
+            value: result,
+            context_ptr: self.context_ptr,
+        })
+    }
+
+    /// Store a value to a pointer (`store`).
+    fn store(&mut self, ptr: PyLLValue, value: PyLLValue) -> PyResult<()> {
+        let builder = unsafe { &mut *self.builder_ptr };
+        builder
+            .store(ptr.value, value.value)
+            .map_err(|e| PyRuntimeError::new_err(format!("store failed: {e}")))?;
+        Ok(())
+    }
+
+    /// Zero-extend an integer value to a wider int type (`zext`).
+    #[pyo3(signature = (value, ty, name=""))]
+    fn zext(&mut self, value: PyLLValue, ty: PyAnyType, name: &str) -> PyResult<PyLLValue> {
+        let builder = unsafe { &mut *self.builder_ptr };
+        let context = unsafe { &*self.context_ptr };
+        let dest = ty.to_ll_type(context);
+        let result = builder
+            .zext(value.value, dest, name)
+            .map_err(|e| PyRuntimeError::new_err(format!("zext failed: {e}")))?;
+        Ok(PyLLValue {
+            value: result,
+            context_ptr: self.context_ptr,
+        })
+    }
+
+    /// Truncate an integer value to a narrower int type (`trunc`).
+    #[pyo3(signature = (value, ty, name=""))]
+    fn trunc(&mut self, value: PyLLValue, ty: PyAnyType, name: &str) -> PyResult<PyLLValue> {
+        let builder = unsafe { &mut *self.builder_ptr };
+        let context = unsafe { &*self.context_ptr };
+        let dest = ty.to_ll_type(context);
+        let result = builder
+            .trunc(value.value, dest, name)
+            .map_err(|e| PyRuntimeError::new_err(format!("trunc failed: {e}")))?;
+        Ok(PyLLValue {
+            value: result,
+            context_ptr: self.context_ptr,
+        })
+    }
+
+    /// Unsigned integer comparison (`icmp` with U-predicates).
+    #[pyo3(signature = (cmp_op, lhs, rhs, name=""))]
+    fn icmp_unsigned(
+        &mut self,
+        cmp_op: &str,
+        lhs: PyLLValue,
+        rhs: PyLLValue,
+        name: &str,
+    ) -> PyResult<PyLLValue> {
+        let builder = unsafe { &mut *self.builder_ptr };
+        let result = builder
+            .icmp_unsigned(cmp_op, lhs.value, rhs.value, name)
+            .map_err(|e| PyRuntimeError::new_err(format!("icmp_unsigned failed: {e}")))?;
+        Ok(PyLLValue {
+            value: result,
+            context_ptr: self.context_ptr,
+        })
+    }
+
     /// Position builder at end of block
     fn position_at_end(&mut self, block: PyBasicBlock) {
         let builder = unsafe { &mut *self.builder_ptr };
@@ -1241,6 +1404,30 @@ impl PyLLValue {
             context_ptr: self.context_ptr,
         })
     }
+
+    /// The LLVM type of this value (llvmlite parity: `value.type`).
+    #[getter]
+    #[pyo3(name = "type")]
+    fn type_(&self) -> PyAnyType {
+        match &self.value {
+            LLValue::Int(v) => PyAnyType::Int(PyIntType {
+                ll_type: LLType::Int(v.get_type()),
+                context_ptr: self.context_ptr,
+            }),
+            LLValue::Float(v) => PyAnyType::Double(PyDoubleType {
+                ll_type: LLType::Float(v.get_type()),
+                context_ptr: self.context_ptr,
+            }),
+            LLValue::Pointer(v) => PyAnyType::Pointer(PyPointerType {
+                ll_type: LLType::Pointer(v.get_type()),
+                context_ptr: self.context_ptr,
+            }),
+            LLValue::Array(v) => PyAnyType::Array(PyArrayType {
+                ll_type: LLType::Array(v.get_type()),
+                context_ptr: self.context_ptr,
+            }),
+        }
+    }
 }
 
 // --- GlobalVariable - Global variable support ---
@@ -1348,12 +1535,33 @@ impl PyGlobalVariable {
 /// ```
 #[pyfunction]
 #[allow(non_snake_case)]
-fn Constant(_py: Python, ty: PyAnyType, value: &Bound<'_, PyAny>) -> PyResult<PyLLValue> {
+#[pyo3(signature = (ty, value=None))]
+fn Constant(_py: Python, ty: PyAnyType, value: Option<&Bound<'_, PyAny>>) -> PyResult<PyLLValue> {
     // Check type isn't void (llvmlite doesn't allow void constants)
     if matches!(ty, PyAnyType::Void(_)) {
         return Err(PyRuntimeError::new_err("Cannot create void constant"));
     }
 
+    // `Constant(ty)` / `Constant(ty, None)` -> the type's zeroinitializer
+    // (Array -> `zeroinitializer`, Int -> `iN 0`); backs B2's zero-init buffer.
+    let Some(value) = value else {
+        let context_ptr = match &ty {
+            PyAnyType::Int(t) => t.context_ptr,
+            PyAnyType::Double(t) => t.context_ptr,
+            PyAnyType::Void(t) => t.context_ptr,
+            PyAnyType::Pointer(t) => t.context_ptr,
+            PyAnyType::Struct(t) => t.context_ptr,
+            PyAnyType::Array(t) => t.context_ptr,
+        };
+        let context = unsafe { &*context_ptr };
+        let zero = LLConstant::zero(ty.to_ll_type(context))
+            .map_err(|e| PyRuntimeError::new_err(format!("Constant(zero) failed: {e}")))?;
+        return Ok(PyLLValue {
+            value: zero,
+            context_ptr,
+        });
+    };
+
     // Handle different type/value combinations
     match &ty {
         PyAnyType::Int(int_ty) => {

From b396d39cc31f59ef8717566bb7ee9838037f25d3 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sat, 16 May 2026 22:04:03 -0600
Subject: [PATCH 078/136] #75 post-review nit #1 (Pickle): type __richcmp__
 ordering ops (Lt/Le/Gt/Ge) now return NotImplemented so Python raises
 TypeError instead of a silently-wrong False; Eq/Ne unchanged (lltype_richcmp
 -> Py<PyAny>). Verified i1<i64 raises, eq/hash/dedup intact, #75 e2e + #71
 gate + slr_tests 368 + broad sweep 1785 all green; clippy/fmt clean.

---
 python/pecos-rslib-llvm/src/llvm_bindings.rs | 52 ++++++++++++--------
 1 file changed, 31 insertions(+), 21 deletions(-)

diff --git a/python/pecos-rslib-llvm/src/llvm_bindings.rs b/python/pecos-rslib-llvm/src/llvm_bindings.rs
index ef6fc2d20..4cf3cefbf 100644
--- a/python/pecos-rslib-llvm/src/llvm_bindings.rs
+++ b/python/pecos-rslib-llvm/src/llvm_bindings.rs
@@ -430,18 +430,28 @@ impl PyAnyType {
     }
 }
 
-/// Structural type equality (llvmlite parity: `int_type(1) == int_type(1)`,
-/// `!= int_type(64)`). Non-type `other` -> not-equal (so `==` is `False`,
-/// `!=` is `True`); ordering comparisons are unsupported -> `false`.
-fn lltype_richcmp(a: LLType<'static>, other: &Bound<'_, PyAny>, op: CompareOp) -> bool {
-    let Ok(other) = other.extract::<PyAnyType>() else {
-        return matches!(op, CompareOp::Ne);
-    };
-    let eq = a == other.ll_type();
+/// Type equality by LLVM `LLVMTypeRef` identity within one `Context`
+/// (sufficient for #71 B2: every type check happens inside one module).
+/// `Eq`/`Ne` only; non-type `other` -> not-equal (`==` False, `!=` True).
+/// Ordering ops are unsupported -> `NotImplemented` so Python raises
+/// `TypeError` rather than returning a silently-wrong `False`.
+fn lltype_richcmp(
+    py: Python<'_>,
+    a: LLType<'static>,
+    other: &Bound<'_, PyAny>,
+    op: CompareOp,
+) -> Py<PyAny> {
     match op {
-        CompareOp::Eq => eq,
-        CompareOp::Ne => !eq,
-        _ => false,
+        CompareOp::Eq | CompareOp::Ne => {
+            let eq = other.extract::<PyAnyType>().is_ok_and(|o| a == o.ll_type());
+            let val = if matches!(op, CompareOp::Eq) { eq } else { !eq };
+            val.into_pyobject(py)
+                .expect("bool -> PyBool is infallible")
+                .to_owned()
+                .into_any()
+                .unbind()
+        }
+        _ => py.NotImplemented(),
     }
 }
 
@@ -490,8 +500,8 @@ unsafe impl Sync for PyPointerType {}
 
 #[pymethods]
 impl PyPointerType {
-    fn __richcmp__(&self, other: &Bound<'_, PyAny>, op: CompareOp) -> bool {
-        lltype_richcmp(self.ll_type, other, op)
+    fn __richcmp__(&self, py: Python<'_>, other: &Bound<'_, PyAny>, op: CompareOp) -> Py<PyAny> {
+        lltype_richcmp(py, self.ll_type, other, op)
     }
     fn __hash__(&self) -> u64 {
         lltype_hash(self.ll_type)
@@ -520,8 +530,8 @@ unsafe impl Sync for PyIntType {}
 
 #[pymethods]
 impl PyIntType {
-    fn __richcmp__(&self, other: &Bound<'_, PyAny>, op: CompareOp) -> bool {
-        lltype_richcmp(self.ll_type, other, op)
+    fn __richcmp__(&self, py: Python<'_>, other: &Bound<'_, PyAny>, op: CompareOp) -> Py<PyAny> {
+        lltype_richcmp(py, self.ll_type, other, op)
     }
     fn __hash__(&self) -> u64 {
         lltype_hash(self.ll_type)
@@ -559,8 +569,8 @@ unsafe impl Sync for PyDoubleType {}
 
 #[pymethods]
 impl PyDoubleType {
-    fn __richcmp__(&self, other: &Bound<'_, PyAny>, op: CompareOp) -> bool {
-        lltype_richcmp(self.ll_type, other, op)
+    fn __richcmp__(&self, py: Python<'_>, other: &Bound<'_, PyAny>, op: CompareOp) -> Py<PyAny> {
+        lltype_richcmp(py, self.ll_type, other, op)
     }
     fn __hash__(&self) -> u64 {
         lltype_hash(self.ll_type)
@@ -598,8 +608,8 @@ unsafe impl Sync for PyArrayType {}
 
 #[pymethods]
 impl PyArrayType {
-    fn __richcmp__(&self, other: &Bound<'_, PyAny>, op: CompareOp) -> bool {
-        lltype_richcmp(self.ll_type, other, op)
+    fn __richcmp__(&self, py: Python<'_>, other: &Bound<'_, PyAny>, op: CompareOp) -> Py<PyAny> {
+        lltype_richcmp(py, self.ll_type, other, op)
     }
     fn __hash__(&self) -> u64 {
         lltype_hash(self.ll_type)
@@ -652,8 +662,8 @@ impl PyVoidType {
     // `&self` is mandated by pyo3 `#[pymethods]` dunders; the void type
     // carries no per-instance state, so `self` is unused here by design.
     #[allow(clippy::unused_self, clippy::trivially_copy_pass_by_ref)]
-    fn __richcmp__(&self, other: &Bound<'_, PyAny>, op: CompareOp) -> bool {
-        lltype_richcmp(LLType::Void, other, op)
+    fn __richcmp__(&self, py: Python<'_>, other: &Bound<'_, PyAny>, op: CompareOp) -> Py<PyAny> {
+        lltype_richcmp(py, LLType::Void, other, op)
     }
     #[allow(clippy::unused_self, clippy::trivially_copy_pass_by_ref)]
     fn __hash__(&self) -> u64 {

From bf89b7fb70fcd872ce63dc864a53364b00774e37 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sat, 16 May 2026 23:40:40 -0600
Subject: [PATCH 079/136] #71 B2 (B2b+B2c) on the #75-extended binding: replace
 bespoke CReg runtime helpers with the standard M-B2-static model. CReg ->
 entry-block alloca [N x i1] + zeroinitializer; measure ->
 __quantum__qis__mz__body + static %Result* + read_result + store (no-result
 mz; slot=measurement_count-1); BitRef/whole-CReg c.set(int) -> store/per-bit
 lshr+trunc unpack; BitExpr -> load+zext (i64-canonical); _as_i1/_as_i64 via
 #75 value.type; record pack load/zext/shl/or -> int_record_output (kept);
 point-of-use GEP. B2c removes the now-uncalled
 create_creg/get_creg_bit/set_creg_bit/get_int_from_creg/set_creg_to_int/mz_to_creg_bit
 decls. #71 structural gate honestly rebaselined: _EXPECTED_QIS_OK 7->27,
 qis_failed empty, BUILD_FAILED 3->2, qeclib.steane_pz triaged
 build->validate-fail (B2 makes it build; then hits qir-qis allowlist on
 PECOS's non-standard __quantum__qis__barrierN__body -- pre-existing barrier
 gap, out of B2 scope). New tier2_semantic.py: real qir-qis-compiler
 acceptance + emitted-QIR structural invariants + deterministic
 AST->Guppy->selene cross-anchor (set_int/zero_init A+B-only; Guppy can't
 return a set(int) CReg). Executable qir_to_qis->selene differential blocked
 by LLVM 14<->21 / opaque-vs-typed gap -> tracked separately. slr_tests 368,
 broad sweep 1785/0-fail, ruff/format clean.

---
 .../src/pecos/slr/ast/codegen/qir.py          | 201 +++++++-----
 .../ast_guppy/test_qir_spec_compliance.py     | 157 +++++----
 .../slr_tests/ast_guppy/tier2_semantic.py     | 309 ++++++++++++++++++
 3 files changed, 521 insertions(+), 146 deletions(-)
 create mode 100644 python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
index 5a4b45382..2b4df434a 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
@@ -209,22 +209,11 @@ def generate(self, program: Program) -> str:
         # Setup creg helper functions
         self._setup_creg_funcs()
 
-        # Setup measurement function
-        self._mz_to_bit = self._declare_function(
-            "mz_to_creg_bit",
-            self._types["void"],
-            [
-                self._types["qubit_ptr"],
-                self._types["bool"].as_pointer(),
-                self._types["int"],
-            ],
-        )
-
-        # B2a: declare the standard QIR classical-model functions. Declared
-        # here so B2b can wire the per-op lowering (static %Result slot ->
-        # mz__body -> read_result -> mutable [N x i1] CReg buffer); the
-        # bespoke model above stays the active path until B2b (no behavior
-        # / gate change in B2a). `%Result*` is the existing result_ptr type.
+        # B2: standard QIR classical model. A measurement lowers to a
+        # static `%Result*` slot -> `__quantum__qis__mz__body` ->
+        # `__quantum__rt__read_result` -> `store` into a per-CReg mutable
+        # `[N x i1]` entry-block `alloca` buffer (M-B2-static). `%Result*`
+        # is the existing `result_ptr` type.
         self._mz_body = self._declare_function(
             "__quantum__qis__mz__body",
             self._types["void"],
@@ -262,38 +251,14 @@ def generate(self, program: Program) -> str:
         return self._finalize_module()
 
     def _setup_creg_funcs(self) -> None:
-        """Setup classical register helper functions."""
+        """Declare the standard classical-output runtime function.
 
+        B2 (M-B2-static) replaced the bespoke `create_creg`/`get_creg_bit`/
+        `set_creg_bit`/`get_int_from_creg`/`set_creg_to_int`/`mz_to_creg_bit`
+        runtime helpers with native `alloca`/`store`/`load`/`gep`/`zext`,
+        so only the standard `__quantum__rt__int_record_output` remains.
+        """
         self._creg_funcs = {
-            "create_creg": self._declare_function(
-                "create_creg",
-                self._types["bool"].as_pointer(),
-                [self._types["int"]],
-            ),
-            "creg_to_int": self._declare_function(
-                "get_int_from_creg",
-                self._types["int"],
-                [self._types["bool"].as_pointer()],
-            ),
-            "get_creg_bit": self._declare_function(
-                "get_creg_bit",
-                self._types["bool"],
-                [self._types["bool"].as_pointer(), self._types["int"]],
-            ),
-            "set_creg_bit": self._declare_function(
-                "set_creg_bit",
-                self._types["void"],
-                [
-                    self._types["bool"].as_pointer(),
-                    self._types["int"],
-                    self._types["bool"],
-                ],
-            ),
-            "set_creg": self._declare_function(
-                "set_creg_to_int",
-                self._types["void"],
-                [self._types["bool"].as_pointer(), self._types["int"]],
-            ),
             "int_result": self._declare_function(
                 "__quantum__rt__int_record_output",
                 self._types["void"],
@@ -347,13 +312,17 @@ def _process_declarations(self, program: Program) -> None:
                         self.context.get_qubit_index(decl.name, i)
             elif isinstance(decl, RegisterDecl):
                 self.context.creg_map[decl.name] = decl.size
-                # Create classical register
-                if decl.size < 64:
-                    self._creg_ptrs[decl.name] = self._builder.call(
-                        self._creg_funcs["create_creg"],
-                        [llvm_ir.Constant(self._types["int"], decl.size)],
-                        name=decl.name,
-                    )
+                # M-B2-static: a CReg is a mutable `[N x i1]` buffer in the
+                # entry block (declarations are processed at entry, before
+                # any control flow, so the builder is positioned there),
+                # zero-initialised so unmeasured/unset bits read 0. Pack is
+                # one `i64` for `int_record_output` -> the same <=64 cap as
+                # the old `create_creg` model (intentionally not lifted).
+                if decl.size <= 64:
+                    arr_ty = llvm_ir.ArrayType(self._types["bool"], decl.size)
+                    creg_ptr = self._builder.alloca(arr_ty, decl.name)
+                    self._builder.store(creg_ptr, llvm_ir.Constant(arr_ty))
+                    self._creg_ptrs[decl.name] = creg_ptr
 
         if program.allocator and program.allocator.parent is None:
             for i in range(program.allocator.capacity):
@@ -496,22 +465,66 @@ def _get_qubit_ptr(self, target: SlotRef) -> Any:
             self._types["qubit_ptr"],
         )
 
+    def _creg_bit_ptr(self, reg_name: str, index: int) -> Any:
+        """`getelementptr [N x i1], [N x i1]* %creg, i64 0, i64 index`.
+
+        Emitted at point-of-use (not cached across blocks) so the pointer
+        always dominates its uses under control flow.
+        """
+        return self._builder.gep(
+            self._creg_ptrs[reg_name],
+            [
+                llvm_ir.Constant(self._types["int"], 0),
+                llvm_ir.Constant(self._types["int"], index),
+            ],
+            name="",
+        )
+
+    def _as_i1(self, value: Any) -> Any:
+        """Coerce an evaluated expression to `i1` (bit-store / predicate)."""
+        if value.type == self._types["bool"]:
+            return value
+        return self._builder.icmp_signed(
+            "!=",
+            value,
+            llvm_ir.Constant(self._types["int"], 0),
+        )
+
+    def _as_i64(self, value: Any) -> Any:
+        """Coerce an evaluated expression to `i64` (the canonical width)."""
+        if value.type == self._types["bool"]:
+            return self._builder.zext(value, self._types["int"])
+        return value
+
     def _process_measure(self, node: MeasureOp) -> None:
-        """Process a measurement operation."""
+        """Process a measurement operation.
+
+        Every measured target emits `__quantum__qis__mz__body(q, %Result*)`
+        against a static result slot; `read_result` + `store` into the CReg
+        buffer only when a classical result target exists (qir-qis accepts
+        `mz` without `read_result`, but rejects `read_result` before `mz`).
+        """
         for i, target in enumerate(node.targets):
             self.context.measurement_count += 1
+            slot = self.context.measurement_count - 1
             qubit_ptr = self._get_qubit_ptr(target)
+            result_ptr = llvm_ir.Constant(self._types["int"], slot).inttoptr(
+                self._types["result_ptr"],
+            )
+            self._builder.call(self._mz_body, [qubit_ptr, result_ptr], name="")
 
             if i < len(node.results):
                 result = node.results[i]
                 if result.register in self._creg_ptrs:
-                    creg_ptr = self._creg_ptrs[result.register]
-                    bit_index = llvm_ir.Constant(self._types["int"], result.index)
-                    self._builder.call(
-                        self._mz_to_bit,
-                        [qubit_ptr, creg_ptr, bit_index],
+                    bit = self._builder.call(
+                        self._read_result,
+                        [result_ptr],
                         name="",
                     )
+                    self._builder.store(
+                        self._creg_bit_ptr(result.register, result.index),
+                        bit,
+                    )
 
     def _process_prepare(self, node: PrepareOp) -> None:
         """Process a prepare/reset operation."""
@@ -556,24 +569,34 @@ def _process_assign(self, node: AssignOp) -> None:
             reg_name = node.target.register
             if reg_name not in self._creg_ptrs:
                 return
-
-            creg_ptr = self._creg_ptrs[reg_name]
-            bit_index = llvm_ir.Constant(self._types["int"], node.target.index)
-
-            # Evaluate RHS
-            rhs = self._eval_expression(node.value)
-
-            self._builder.call(
-                self._creg_funcs["set_creg_bit"],
-                [creg_ptr, bit_index, rhs],
-                name="",
+            rhs = self._as_i1(self._eval_expression(node.value))
+            self._builder.store(
+                self._creg_bit_ptr(reg_name, node.target.index),
+                rhs,
             )
+        elif isinstance(node.target, str):
+            # Whole-CReg `c.set(int)` (converter.py:928/930 -> target=str).
+            # Unpack the i64 value bit-by-bit into the buffer.
+            reg_name = node.target
+            if reg_name not in self._creg_ptrs:
+                return
+            size = self.context.creg_map.get(reg_name, 0)
+            val = self._as_i64(self._eval_expression(node.value))
+            for i in range(size):
+                shifted = self._builder.lshr(
+                    val,
+                    llvm_ir.Constant(self._types["int"], i),
+                )
+                self._builder.store(
+                    self._creg_bit_ptr(reg_name, i),
+                    self._builder.trunc(shifted, self._types["bool"]),
+                )
 
     def _eval_expression(self, expr: Expression) -> Any:
         """Evaluate an expression to an LLVM value."""
         if isinstance(expr, LiteralExpr):
             if isinstance(expr.value, bool):
-                return llvm_ir.Constant(self._types["bool"], 1 if expr.value else 0)
+                return llvm_ir.Constant(self._types["int"], 1 if expr.value else 0)
             if isinstance(expr.value, int):
                 return llvm_ir.Constant(self._types["int"], expr.value)
             if isinstance(expr.value, float):
@@ -583,14 +606,13 @@ def _eval_expression(self, expr: Expression) -> Any:
         if isinstance(expr, BitExpr):
             reg_name = expr.ref.register
             if reg_name not in self._creg_ptrs:
-                return llvm_ir.Constant(self._types["bool"], 0)
-            creg_ptr = self._creg_ptrs[reg_name]
-            bit_index = llvm_ir.Constant(self._types["int"], expr.ref.index)
-            return self._builder.call(
-                self._creg_funcs["get_creg_bit"],
-                [creg_ptr, bit_index],
+                return llvm_ir.Constant(self._types["int"], 0)
+            # `load i1, gep c[i]` then `zext -> i64` (canonical width).
+            bit = self._builder.load(
+                self._creg_bit_ptr(reg_name, expr.ref.index),
                 name="",
             )
+            return self._builder.zext(bit, self._types["int"])
 
         if isinstance(expr, VarExpr):
             # Variable lookup - for now just return 0
@@ -615,7 +637,7 @@ def _eval_expression(self, expr: Expression) -> Any:
 
     def _process_if(self, node: IfStmt) -> None:
         """Process an if statement."""
-        pred = self._eval_expression(node.condition)
+        pred = self._as_i1(self._eval_expression(node.condition))
 
         if node.else_body:
             with self._builder.if_else(pred) as (then, otherwise):
@@ -675,7 +697,7 @@ def _process_permute(self, node: PermuteOp) -> None:
 
     def _generate_results(self) -> None:
         """Generate result output calls."""
-        for reg_name, creg_ptr in self._creg_ptrs.items():
+        for reg_name in self._creg_ptrs:
             # Create tag for the register name
             reg_name_bytes = bytearray(reg_name.encode("utf-8"))
             tag_type = llvm_ir.ArrayType(llvm_ir.IntType(8), len(reg_name))
@@ -684,12 +706,21 @@ def _generate_results(self) -> None:
             reg_tag.global_constant = True
             reg_tag.linkage = "private"
 
-            # Convert creg to int and output
-            c_int = self._builder.call(
-                self._creg_funcs["creg_to_int"],
-                [creg_ptr],
-                name="",
-            )
+            # Pack the [N x i1] buffer into one i64: OR_i (zext c[i] << i).
+            c_int = llvm_ir.Constant(self._types["int"], 0)
+            for i in range(self.context.creg_map.get(reg_name, 0)):
+                bit = self._builder.load(
+                    self._creg_bit_ptr(reg_name, i),
+                    name="",
+                )
+                widened = self._builder.zext(bit, self._types["int"])
+                if i:
+                    widened = self._builder.shl(
+                        widened,
+                        llvm_ir.Constant(self._types["int"], i),
+                    )
+                c_int = self._builder.or_(c_int, widened)
+
             reg_tag_gep = reg_tag.gep(
                 (
                     llvm_ir.Constant(llvm_ir.IntType(32), 0),
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
index fc2a7c67e..796d073a2 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
@@ -9,48 +9,57 @@
 # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 # specific language governing permissions and limitations under the License.
 
-"""#71 QIR spec-compliance gate over the audit corpus -- post-B1 baseline.
+"""#71 QIR spec-compliance gate over the audit corpus -- post-B2 baseline.
 
 Runs Quantinuum's `qir-qis` over `SlrConverter(prog).qir_bc()` for
 every audit-corpus program and pins the *current* two-tier state as
 an explicit, honest baseline. NOT faked-green: it asserts exactly
-what is and is not compliant, so any regression OR Stage-B progress
+what is and is not compliant, so any regression OR further progress
 trips it deliberately.
 
 **Tier 1 -- `validate_qir` (QIR spec metadata): Stage B1 DONE.**
-27/28 buildable programs now PASS `validate_qir` (B1 added the
-required QIR module metadata: `output_labeling_schema`,
-`qir_profiles=adaptive_profile`, and the `qir_*_version` /
-`dynamic_*` / `arrays` module flags). The single remaining
-`validate_qir` failure is `legacy.empty_main` -- NOT a metadata
-gap: qir-qis structurally requires the entry function to have >=1
-qubit, and that program has none. Pinned (`_EXPECTED_VALIDATE_FAILED`)
-as a known non-metadata structural limitation so a NEW validate
-failure trips this gate. Tier-1b additionally pins the exact entry
-attr *values* (qir-qis only checks presence). `adaptive_profile`
-is a deliberate forward-looking choice for B2 (it introduces
-`__quantum__rt__read_result`); it is NOT yet exercised by the
-corpus (`base_profile` also validates today).
-
-**Tier 2 -- `qir_to_qis` (ingestible): Stage B2 NOT done.**
-Of the 27 validate-passing programs, 7 already lower via
-`qir_to_qis` (`_EXPECTED_QIS_OK` -- the no-CReg programs); the other
-20 fail uniformly with `Unsupported function: create_creg` -- the
-PECOS-bespoke CReg helpers Stage B2 will replace with the standard
-static `%Result` + mutable-local-buffer model. B1 is **metadata
-compliance only, NOT qir-qis ingestibility** (proven: B1-alone is
-validate_qir-green but qir_to_qis still rejects `create_creg`).
-When B2 lands, the 20 flip to OK -> `_EXPECTED_QIS_OK` trips ->
-update this baseline deliberately (the intended progress signal).
-
-**Pre-existing build failures** (3): `qir_bc()` itself raises for
-`docs.for_loopvar_symbolic` / `docs.rotation_rx` / `qeclib.steane_pz`
--- pre-existing AST-QIR feature gaps tracked separately (audit
-v2-defer XFAILs / `optional_dependency` `*_qir`; the semantic-bug
-split is task #74), NOT a #71 metadata concern. Identity pinned
-(`_EXPECTED_BUILD_FAILED`) so a NEW build regression in a
-currently-buildable program trips here instead of being silently
-absorbed.
+B1 added the required QIR module metadata (`output_labeling_schema`,
+`qir_profiles=adaptive_profile`, the `qir_*_version` / `dynamic_*` /
+`arrays` module flags). Two `validate_qir` failures are pinned
+(`_EXPECTED_VALIDATE_FAILED`), neither a metadata gap:
+`legacy.empty_main` (qir-qis structurally requires the entry
+function to have >=1 qubit; that program has none) and
+`qeclib.steane_pz` (B2 made it *build* -- see below -- and it now
+reaches the qir-qis call allowlist, which rejects PECOS's
+non-standard `__quantum__qis__barrierN__body`; the barrier-naming
+gap is pre-existing, orthogonal to the CReg model, and intentionally
+out of B2 scope). Tier-1b additionally pins the exact entry attr
+*values* (qir-qis only checks presence).
+
+**Tier 2 -- `qir_to_qis` (ingestible): Stage B2 DONE.**
+Stage B2 replaced the PECOS-bespoke CReg runtime helpers
+(`create_creg`/`get_creg_bit`/`set_creg_bit`/`get_int_from_creg`/
+`set_creg_to_int`/`mz_to_creg_bit`) with the standard M-B2-static
+model (per-CReg entry-block `alloca [N x i1]` + zeroinitializer;
+`mz__body` -> static `%Result*` -> `read_result` -> `store`;
+point-of-use `gep`+`load`/`store`; `zext`/`shl`/`or` pack ->
+`__quantum__rt__int_record_output`). Every validate-passing program
+(`_EXPECTED_QIS_OK`, n=27) now lowers via `qir_to_qis`; `qis_failed`
+is empty. A NEW qir_to_qis failure -- or a dropped program -- trips
+this deliberately. (`adaptive_profile` is now genuinely exercised:
+B2 emits `__quantum__rt__read_result` for measurement feedback.)
+The deeper *semantic* proof for the load-bearing CReg shapes is
+`tier2_semantic.py` (real-compiler acceptance + emitted-QIR
+structural invariants + a deterministic AST->Guppy->Selene
+cross-anchor). A direct `qir_to_qis`->Selene differential is
+blocked by an LLVM-version/dialect gap (qir-qis emits LLVM-21
+opaque-pointer QIS bitcode; PECOS's Selene QIS runtime is LLVM-14
+typed-pointer) -- tracked as a separate blocked task; this gate
+stays structural.
+
+**Pre-existing build failures** (2): `qir_bc()` itself raises for
+`docs.for_loopvar_symbolic` / `docs.rotation_rx` -- pre-existing
+AST-QIR feature gaps tracked separately (task #74), NOT a #71
+metadata concern. Identity pinned (`_EXPECTED_BUILD_FAILED`) so a
+NEW build regression trips here. (`qeclib.steane_pz` was a pinned
+build failure pre-B2 -- the bespoke model emitted invalid bitcode
+for it; B2 produces valid bitcode so it now builds and moves to
+the pinned validate set above. A deliberate, triaged improvement.)
 
 `qir-qis` is a `[dependency-groups].test` dep (default-groups
 includes `test`), so this runs in the default sweep.
@@ -70,33 +79,60 @@
 _EXPECTED_BUILD_FAILED: dict[str, tuple[str, str]] = {
     "docs.for_loopvar_symbolic": ("AttributeError", "SymbolicQubit"),
     "docs.rotation_rx": ("RuntimeError", "__quantum__qis__rx__body"),
-    "qeclib.steane_pz": ("RuntimeError", "Failed to compile QIR to bitcode"),
 }
 
-# Tier 1: the ONLY non-metadata `validate_qir` failure post-B1 --
-# qir-qis requires the entry function to have >=1 qubit; this program
-# has none. Pinned (label -> stable message fragment) so a NEW
-# validate failure (e.g. a B1 metadata regression) trips deliberately.
+# Tier 1: the non-metadata `validate_qir` failures (label -> stable,
+# quote-free message fragment) so a NEW validate failure (e.g. a B1
+# metadata regression) trips deliberately. Neither is a metadata gap:
+#  - legacy.empty_main: qir-qis requires the entry fn to have >=1
+#    qubit; this program has none (structural limitation).
+#  - qeclib.steane_pz: B2 made it *build* (the bespoke model emitted
+#    invalid bitcode pre-B2); it now reaches the qir-qis call
+#    allowlist, which rejects PECOS's non-standard
+#    `__quantum__qis__barrierN__body`. The barrier-naming gap is
+#    pre-existing and orthogonal to the CReg model -- intentionally
+#    out of B2 scope (bounded; barrier lowering is a separate task).
 _EXPECTED_VALIDATE_FAILED: dict[str, str] = {
     "legacy.empty_main": "at least one qubit",
+    "qeclib.steane_pz": "Unsupported QIR QIS function",
 }
 
-# Tier 2: programs that already lower via `qir_to_qis` post-B1 (no
-# bespoke CReg helpers). The remaining validate-passing programs fail
-# uniformly with `_QIS_B2_GAP` until Stage B2. When B2 lands they flip
-# into this set -> this pin trips -> update the baseline deliberately.
+# Tier 2: post-B2, EVERY validate-passing program lowers via
+# `qir_to_qis` (M-B2-static replaced the bespoke CReg helpers).
+# This is the full set (n=27); `qis_failed` must be empty. A new
+# qir_to_qis failure -- or a dropped/added program -- trips the
+# Tier-2 assertions and must be triaged deliberately.
 _EXPECTED_QIS_OK: frozenset[str] = frozenset(
     {
+        "docs.flat_parallel_h_gates",
+        "docs.for_static_indexing",
         "docs.inline_measure_creg",
+        "docs.prep_basis_x",
+        "docs.repeat_state_preserving",
+        "docs.surface_syndrome_block18",
+        "docs.while_loop",
+        "examples.measure_register_to_creg",
+        "examples.parallel_bell_pairs",
         "examples.surface_d3_x_1round",
         "examples.surface_d3_z_1round",
+        "legacy.function_with_returns",
         "legacy.gates_only_no_measurement",
+        "legacy.individual_measurements",
+        "legacy.multiple_qregs",
+        "legacy.nested_blocks",
+        "legacy.partial_consumption_with_block",
+        "qeclib.color488_syn_extract_bare",
+        "qeclib.generic_check_1flag_ch",
+        "qeclib.generic_check_xyz",
+        "qeclib.generic_transversal_cx",
         "qeclib.surface_patch_builder_empty",
         "qeclib.surface_std_pz",
+        "v1.bell",
+        "v1.conditional_correction",
+        "v1.ghz_three",
         "v1.repeat_idle",
     },
 )
-_QIS_B2_GAP = "create_creg"
 
 # Codex B1 post-review blocker: qir-qis validates the PRESENCE of these
 # entry attributes but NOT their values, so a value regression (e.g.
@@ -160,9 +196,9 @@ def test_audit_corpus_qir_compliance_baseline() -> None:
     build_failed, validate_failed, qis_ok, qis_failed, entry_attrs = _qir_state()
 
     # Sanity: validate_qir actually ran on built QIR (not vacuous).
-    assert (
-        qis_ok or qis_failed or validate_failed
-    ), f"validate_qir never ran on built QIR; build_failed={sorted(label for label, _, _ in build_failed)}"
+    assert qis_ok or qis_failed or validate_failed, (
+        f"validate_qir never ran on built QIR; build_failed={sorted(label for label, _, _ in build_failed)}"
+    )
 
     # Pre-existing build-failure set pinned (Codex Stage-A blocker): a
     # new build regression -- or a fixed one -- must be triaged
@@ -202,20 +238,19 @@ def test_audit_corpus_qir_compliance_baseline() -> None:
                 "this pin is the only guard."
             )
 
-    # Tier 2 -- qir_to_qis: B2 NOT done. The already-ingestible set is
-    # pinned; when B2 replaces the bespoke CReg helpers the currently
-    # failing programs flip into it and THIS assertion trips -> update
-    # the baseline deliberately (the intended progress signal).
+    # Tier 2 -- qir_to_qis: Stage B2 DONE. Every validate-passing
+    # program now lowers via qir_to_qis (M-B2-static replaced the
+    # bespoke CReg helpers). The OK set is pinned and `qis_failed`
+    # must be empty -- a new qir_to_qis failure (B2 regression) or a
+    # dropped/added program trips this and must be triaged.
     assert set(qis_ok) == set(_EXPECTED_QIS_OK), (
         f"qir_to_qis-OK set changed: got {sorted(qis_ok)}, expected "
-        f"{sorted(_EXPECTED_QIS_OK)}. If this is Stage B2 progress, update "
-        "this baseline deliberately."
+        f"{sorted(_EXPECTED_QIS_OK)}. Triage (B2 regression vs further "
+        "progress) before updating this baseline."
     )
-    # Every other validate-passing program must still fail qir_to_qis
-    # for the single uniform B2 reason (the bespoke CReg helpers).
-    assert qis_failed, "expected the non-OK validate-passing programs to fail qir_to_qis until B2"
-    non_uniform = [(label, msg[:160]) for label, msg in qis_failed if _QIS_B2_GAP not in msg]
-    assert not non_uniform, (
-        f"qir_to_qis failures not uniformly the {_QIS_B2_GAP!r} (B2) gap: {non_uniform}. "
-        "A new qir_to_qis failure kind must be triaged deliberately."
+    assert not qis_failed, (
+        "unexpected qir_to_qis failure(s) post-B2: "
+        f"{[(label, msg[:160]) for label, msg in qis_failed]}. After "
+        "Stage B2 every validate-passing program must lower via "
+        "qir_to_qis -- triage before re-pinning."
     )
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
new file mode 100644
index 000000000..ca078a4a3
--- /dev/null
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
@@ -0,0 +1,309 @@
+# Copyright 2026 The PECOS Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations under the License.
+
+"""#71 Stage B2 -- semantic assurance for the M-B2-static CReg lowering.
+
+Three independent layers per representative program (the structural
+`test_qir_spec_compliance.py` gate covers the whole corpus; this is the
+deeper *semantic* proof for the load-bearing CReg shapes):
+
+  A. **Real-compiler acceptance.** Quantinuum's `qir-qis` (a real
+     ~10k-LOC QIR->QIS compiler: type-checking, call allowlist,
+     profile + result-slot validation, full QIS lowering) must
+     `validate_qir` AND `qir_to_qis` the B2 QIR. Acceptance by an
+     independent production compiler is strong evidence the emitted
+     QIR is well-formed and semantically valid.
+
+  B. **Emitted-QIR structural invariants.** The M-B2-static classical
+     model is deterministic bit-shuffling; its correctness is exactly
+     checkable on the emitted IR: per-CReg entry-block `alloca [N x
+     i1]` + `zeroinitializer` store; measurements use monotonic
+     0-based `%Result*` slots; `read_result` reuses the measurement's
+     own slot; result bits `store`d at the `gep` matching the CReg
+     bit index; record pack is LSB-first `zext`/`shl`/`or`;
+     whole-CReg `c.set(int)` unpacks `lshr`+`trunc` per bit; and NO
+     bespoke `create_creg`/`*_creg_bit`/... runtime helpers remain.
+
+  C. **Independent executable cross-anchor.** The SAME SLR programs
+     run through the dual-reviewed AST->Guppy->Selene path
+     (`run_ast_guppy_via_selene`); for the deterministic programs the
+     exact classical outcome is asserted. The B2 QIR is a
+     deterministic sibling lowering (proven structurally in B) of the
+     same AST whose classical semantics C executes.
+
+**Why not a direct qir_to_qis->Selene differential:** `qir_to_qis`
+emits **LLVM-21 opaque-pointer** QIS bitcode; PECOS's Selene QIS
+runtime (`crates/pecos-qis`) is **LLVM-14 typed-pointer** with the
+`___`-prefixed Selene QIS intrinsic convention. The two "QIS" forms
+are incompatible LLVM versions/dialects; no LLVM-21 disassembler is
+available and bridging LLVM-21 opaque -> LLVM-14 typed is a separate
+infra project, out of B2 scope (tracked as a blocked task). A+B+C
+together bound B2 correctness without that bridge.
+
+Run standalone: `uv run python -m pytest <thisfile> -q` or
+`uv run python .../tier2_semantic.py`. The pytest entry is marked
+`slow` (it builds the Selene runtime) so the default fast lane skips
+it; it still runs in the full sweep.
+"""
+
+from __future__ import annotations
+
+import re
+import sys
+
+import pytest
+import qir_qis
+from pecos.slr import CReg, If, Main, QReg, Return, SlrConverter
+from pecos.slr.qeclib import qubit as qb
+from pecos.slr.qeclib.qubit.measures import Measure
+
+from ._selene_harness import run_ast_guppy_via_selene  # noqa: TID252
+from .audit_runner import _curated_cases  # noqa: TID252
+
+_SHOTS = 8
+_SEED = 42
+_BESPOKE = re.compile(
+    r"create_creg|get_creg_bit|set_creg_bit|get_int_from_creg"
+    r"|set_creg_to_int|mz_to_creg_bit",
+)
+_MZ_SLOT = re.compile(
+    r"@__quantum__qis__mz__body\(%Qubit\* [^,]+, "
+    r"%Result\* inttoptr \(i64 (\d+) to %Result\*\)\)",
+)
+_RR_SLOT = re.compile(
+    r"@__quantum__rt__read_result\(%Result\* inttoptr \(i64 (\d+) to %Result\*\)\)",
+)
+
+
+def _case(label: str) -> Main:
+    for c in _curated_cases():
+        if c.label == label:
+            return c.factory()
+    msg = f"audit case {label!r} not found"
+    raise KeyError(msg)
+
+
+# --- extra programs not in the corpus (plan amendment 8 coverage) ---
+
+
+def _set_int() -> Main:
+    """Whole-CReg `c.set(int)` -> per-bit lshr/trunc unpack."""
+    return Main(
+        q := QReg("q", 1),
+        c := CReg("c", 4),
+        qb.X(q[0]),
+        c.set(0b1011),
+        Return(c),
+    )
+
+
+def _zero_init_safety() -> Main:
+    """`If(c[0])` BEFORE any write -- must read the zeroinit 0, so the
+    Then-branch is never taken (undef would be nondeterministic)."""
+    return Main(
+        q := QReg("q", 1),
+        c := CReg("c", 1),
+        d := CReg("d", 1),
+        If(c[0]).Then(qb.X(q[0])),
+        Measure(q[0]) > d[0],
+        Return(d),
+    )
+
+
+def _multi_creg() -> Main:
+    """Two CRegs: one set classically, one filled by measurement."""
+    return Main(
+        q := QReg("q", 2),
+        a := CReg("a", 2),
+        b := CReg("b", 2),
+        qb.X(q[0]),
+        a.set(0b10),
+        Measure(q[0]) > b[0],
+        Measure(q[1]) > b[1],
+        Return(a, b),
+    )
+
+
+def _creg_int(rec: dict[str, int], n: int) -> int:
+    """Pack a `measurement_N`-keyed shot record LSB-first into an int."""
+    return sum((rec.get(f"measurement_{i}", 0) & 1) << i for i in range(n))
+
+
+# --- the three semantic layers -------------------------------------
+
+
+def _layer_a_compiler_accepts(prog: Main, label: str) -> None:
+    bc = SlrConverter(prog).qir_bc()
+    qir_qis.validate_qir(bc)
+    qis = qir_qis.qir_to_qis(bc)
+    assert isinstance(qis, (bytes, bytearray)), f"{label}: qir_to_qis returned {type(qis).__name__}, not bytes"
+    assert qis[:4] == b"BC\xc0\xde", f"{label}: qir_to_qis output is not QIS LLVM bitcode (bad magic)"
+
+
+def _layer_b_structural(prog: Main, label: str, *, creg_sizes: dict[str, int]) -> None:
+    ir = SlrConverter(prog).qir()
+
+    assert not _BESPOKE.search(ir), f"{label}: bespoke CReg helper still emitted"
+
+    for name, size in creg_sizes.items():
+        assert f"%{name} = alloca [{size} x i1]" in ir, f"{label}: missing entry-block alloca for CReg {name!r}"
+        assert f"store [{size} x i1] zeroinitializer, [{size} x i1]* %{name}" in ir, (
+            f"{label}: missing zeroinitializer for CReg {name!r} (unset bits must read 0, not undef)"
+        )
+
+    mz = [int(m) for m in _MZ_SLOT.findall(ir)]
+    assert mz == list(range(len(mz))), f"{label}: mz %Result* slots not monotonic 0..n-1: {mz}"
+    rr = [int(m) for m in _RR_SLOT.findall(ir)]
+    assert set(rr).issubset(set(mz)), (
+        f"{label}: read_result slots {rr} not a subset of mz slots {mz} "
+        "(read_result must reuse its measurement's own static slot)"
+    )
+
+
+def _assert_set_int_unpack(label: str, ir: str, *, name: str, size: int, value: int) -> None:
+    """`c.set(<const int>)` lowers, after LLVM constant-folds the
+    per-bit `lshr`/`trunc`, to a direct `store i1 <bit_i>` at `gep
+    c[i]` for each bit (LSB-first). Assert the EXACT stored bits --
+    stronger than checking for the (folded-away) shift instructions.
+
+    (`extra.set_int` is verified here + by `qir_to_qis` acceptance,
+    NOT by the Guppy oracle: the AST->Guppy return wrapper cannot
+    return a `set(int)`-assigned CReg -- it models the CReg as `int`
+    while the wrapper expects `array[bool, N]`. That is a Guppy-path
+    limitation orthogonal to the B2 QIR, whose lowering is exact and
+    checked structurally here.)
+    """
+    for i in range(size):
+        bit = (value >> i) & 1
+        pat = (
+            rf"getelementptr \[{size} x i1\], \[{size} x i1\]\* %{name}, "
+            rf"i64 0, i64 {i}\n\s*store i1 {bit}, i1\* %[.\w]+"
+        )
+        assert re.search(pat, ir), (
+            f"{label}: c.set({value:#b}) bit {i} not stored as `i1 {bit}` at gep {name}[{i}] (LSB-first)"
+        )
+    # Record pack: per-bit load/zext, `shl i64 _, i` for i>0, or-chain.
+    assert ir.count("load i1") >= size, f"{label}: record pack missing per-bit `load i1`"
+    assert ir.count("zext i1") >= size, f"{label}: record pack missing per-bit `zext i1`"
+    for i in range(1, size):
+        assert re.search(rf"shl i64 %[.\w]+, {i}\b", ir), f"{label}: record pack missing `shl i64 _, {i}`"
+    assert ir.count("or i64") >= size, f"{label}: record pack missing or-chain"
+
+
+def _assert_zero_init_predicate(label: str, ir: str, *, name: str) -> None:
+    """`If(c[i])` before any write must branch on a `load` of the
+    zero-initialised buffer (so the predicate is deterministically 0,
+    never `undef`)."""
+    assert f"store [1 x i1] zeroinitializer, [1 x i1]* %{name}" in ir, (
+        f"{label}: missing zeroinitializer for the pre-read CReg {name!r}"
+    )
+    assert re.search(
+        rf"getelementptr \[1 x i1\], \[1 x i1\]\* %{name}, i64 0, i64 0\n"
+        rf"\s*%[.\w]+ = load i1",
+        ir,
+    ), f"{label}: If(c[0]) predicate is not a load of the zero-inited buffer"
+
+
+def _layer_c_oracle(prog: Main, label: str) -> list[dict[str, int]]:
+    recs = run_ast_guppy_via_selene(prog, shots=_SHOTS, seed=_SEED)
+    assert len(recs) == _SHOTS, f"{label}: expected {_SHOTS} shots, got {len(recs)}"
+    return recs
+
+
+# --- representative programs + their deterministic expectations ----
+
+
+def _programs() -> list[tuple[str, Main, dict[str, int]]]:
+    return [
+        ("v1.bell", _case("v1.bell"), {"c": 2}),
+        ("v1.conditional_correction", _case("v1.conditional_correction"), {"c": 2}),
+        ("v1.repeat_idle", _case("v1.repeat_idle"), {}),
+        (
+            "legacy.partial_consumption_with_block",
+            _case("legacy.partial_consumption_with_block"),
+            {},
+        ),
+        ("examples.surface_d3_z_1round", _case("examples.surface_d3_z_1round"), {}),
+        ("extra.set_int", _set_int(), {"c": 4}),
+        ("extra.zero_init_safety", _zero_init_safety(), {"c": 1, "d": 1}),
+        ("extra.multi_creg", _multi_creg(), {"a": 2, "b": 2}),
+    ]
+
+
+def run() -> int:
+    """Standalone driver: returns process exit code."""
+    failures: list[str] = []
+    for label, prog, creg_sizes in _programs():
+        try:
+            _layer_a_compiler_accepts(prog, label)
+            ir = SlrConverter(prog).qir()
+            assert not _BESPOKE.search(ir), f"{label}: bespoke helper emitted"
+            mz = [int(m) for m in _MZ_SLOT.findall(ir)]
+            assert mz == list(range(len(mz))), f"{label}: non-monotonic slots {mz}"
+            if creg_sizes:
+                _layer_b_structural(prog, label, creg_sizes=creg_sizes)
+            if label == "extra.set_int":
+                _assert_set_int_unpack(label, ir, name="c", size=4, value=0b1011)
+            if label == "extra.zero_init_safety":
+                _assert_zero_init_predicate(label, ir, name="c")
+            print(f"[A/B OK] {label}")
+        except AssertionError as exc:  # noqa: PERF203
+            failures.append(f"{label}: {exc}")
+            print(f"[A/B FAIL] {label}: {exc}")
+
+    # Layer C -- executable deterministic cross-anchor via the
+    # dual-reviewed AST->Guppy->Selene oracle. Restricted to programs
+    # that path supports; `extra.set_int` / `extra.zero_init_safety`
+    # are fully covered by Layer A (real qir-qis compiler acceptance)
+    # + Layer B (exact emitted-QIR structure: zeroinitializer and
+    # per-bit lshr/trunc unpack). The AST->Guppy return wrapper
+    # cannot return a `set(int)`-assigned CReg (it models the CReg as
+    # `int`, the wrapper expects `array[bool, N]`) -- a Guppy-path
+    # limitation orthogonal to the B2 QIR, so Guppy is not the right
+    # oracle for those two shapes.
+    det_checks: list[tuple[str, Main, str]] = [
+        ("v1.bell", _case("v1.bell"), "bell"),
+        ("v1.conditional_correction", _case("v1.conditional_correction"), "all_zero"),
+    ]
+    for label, prog, expect in det_checks:
+        try:
+            recs = _layer_c_oracle(prog, label)
+            if expect == "bell":
+                for r in recs:
+                    assert r.get("measurement_0") == r.get("measurement_1"), f"{label}: Bell pair not correlated: {r}"
+            else:  # all_zero
+                for r in recs:
+                    assert set(r.values()) <= {0}, f"{label}: expected all-zero, got {r}"
+            print(f"[C OK]   {label}")
+        # Per-program isolation is required in this reporting harness
+        # (one Guppy/Selene failure must not abort the others); the
+        # loop is ~2 items so the PERF203 try/except cost is irrelevant.
+        except Exception as exc:  # noqa: PERF203
+            failures.append(f"{label} (oracle): {type(exc).__name__}: {exc}")
+            print(f"[C FAIL] {label}: {type(exc).__name__}: {exc}")
+
+    if failures:
+        print(f"\nTIER-2 SEMANTIC: {len(failures)} FAILURE(S)")
+        for f in failures:
+            print("  -", f)
+        return 1
+    print("\nTIER-2 SEMANTIC: PASS")
+    return 0
+
+
+@pytest.mark.slow
+def test_tier2_semantic_b2() -> None:
+    """Pytest entry (slow: builds the Selene runtime)."""
+    assert run() == 0, "Stage B2 semantic assurance failed (see stdout)"
+
+
+if __name__ == "__main__":
+    sys.exit(run())

From b4c3a9c2e21efd7bc67edaa3b44e2ac3ef8cdab3 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sun, 17 May 2026 11:19:02 -0600
Subject: [PATCH 080/136] #71 B2 post-review fold: fix Codex blocker + 2
 non-blocking. BLOCKER: >64-bit CReg silently miscompiled (creg_map recorded
 size but alloca/output only when <=64, so CReg(65)
 built+validated+qir_to_qis-lowered with storage/output silently dropped) ->
 _process_declarations now raises NotImplementedError for size>64 (single-i64
 pack cap; fail-loud, not a silent fallback) + regression test
 test_oversize_creg_raises_loud (CReg(64) builds, CReg(65) raises).
 Non-blocking: register `slow` marker in tests/conftest.py::pytest_configure
 (invocation-independent; canonical sweep 0 warnings; residual single-file
 pytest-path warning is a conftest-discovery quirk, cosmetic); tighten
 tier2_semantic Layer B from read_result-subset-of-mz to per-measurement
 adjacency (_assert_mz_rr_pairing: each read_result immediately preceded by
 its own same-slot mz), drop dead _MZ_SLOT/_RR_SLOT. Gates: tier2 PASS (8 A/B
 + tightened pairing + 2 C), oversize regression passes, #71 gate green,
 slr_tests 368, broad sweep 1785/0-fail, ruff/format clean. Pickle YES; Codex
 re-confirm pending (blocker fix + regression test were its exact sign-off
 condition).

---
 .../src/pecos/slr/ast/codegen/qir.py          | 26 ++++++---
 python/quantum-pecos/tests/conftest.py        | 12 ++++
 .../slr_tests/ast_guppy/tier2_semantic.py     | 57 ++++++++++++++-----
 3 files changed, 73 insertions(+), 22 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
index 2b4df434a..b54675245 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
@@ -315,14 +315,24 @@ def _process_declarations(self, program: Program) -> None:
                 # M-B2-static: a CReg is a mutable `[N x i1]` buffer in the
                 # entry block (declarations are processed at entry, before
                 # any control flow, so the builder is positioned there),
-                # zero-initialised so unmeasured/unset bits read 0. Pack is
-                # one `i64` for `int_record_output` -> the same <=64 cap as
-                # the old `create_creg` model (intentionally not lifted).
-                if decl.size <= 64:
-                    arr_ty = llvm_ir.ArrayType(self._types["bool"], decl.size)
-                    creg_ptr = self._builder.alloca(arr_ty, decl.name)
-                    self._builder.store(creg_ptr, llvm_ir.Constant(arr_ty))
-                    self._creg_ptrs[decl.name] = creg_ptr
+                # zero-initialised so unmeasured/unset bits read 0. The
+                # record pack is a single `i64` for `int_record_output`, so
+                # the model caps at 64 bits. A >64-bit CReg must fail LOUD
+                # here -- silently dropping its storage/output (the old
+                # `create_creg` `size < 64` behaviour) is a miscompile.
+                if decl.size > 64:
+                    msg = (
+                        f"QIR codegen: CReg {decl.name!r} has {decl.size} bits, "
+                        "but the M-B2-static classical model packs each CReg "
+                        "into a single i64 for "
+                        "`__quantum__rt__int_record_output` (64-bit cap). "
+                        ">64-bit CRegs are not supported by the QIR backend."
+                    )
+                    raise NotImplementedError(msg)
+                arr_ty = llvm_ir.ArrayType(self._types["bool"], decl.size)
+                creg_ptr = self._builder.alloca(arr_ty, decl.name)
+                self._builder.store(creg_ptr, llvm_ir.Constant(arr_ty))
+                self._creg_ptrs[decl.name] = creg_ptr
 
         if program.allocator and program.allocator.parent is None:
             for i in range(program.allocator.capacity):
diff --git a/python/quantum-pecos/tests/conftest.py b/python/quantum-pecos/tests/conftest.py
index 7076b0d55..62d2c1a37 100644
--- a/python/quantum-pecos/tests/conftest.py
+++ b/python/quantum-pecos/tests/conftest.py
@@ -5,3 +5,15 @@
 # in isolation. Import the installed/source package first so later
 # ``import pecos`` statements resolve to the public PECOS package.
 import pecos
+
+
+def pytest_configure(config):
+    """Register markers at the test-tree root so they are known for ANY
+    invocation (e.g. running a single file directly), not only when
+    pytest happens to pick a ``pyproject.toml`` whose
+    ``[tool.pytest.ini_options].markers`` lists them."""
+    config.addinivalue_line(
+        "markers",
+        "slow: mark tests that provide extra integration coverage but are "
+        "excluded from the default fast Python test lane",
+    )
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
index ca078a4a3..921862beb 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
@@ -74,15 +74,39 @@
     r"create_creg|get_creg_bit|set_creg_bit|get_int_from_creg"
     r"|set_creg_to_int|mz_to_creg_bit",
 )
-_MZ_SLOT = re.compile(
+# Ordered mz/read_result events (slot in g1 for mz, g2 for read_result) so
+# we can pin per-measurement slot correspondence, not just set membership.
+_MZ_RR_EVENT = re.compile(
     r"@__quantum__qis__mz__body\(%Qubit\* [^,]+, "
-    r"%Result\* inttoptr \(i64 (\d+) to %Result\*\)\)",
-)
-_RR_SLOT = re.compile(
-    r"@__quantum__rt__read_result\(%Result\* inttoptr \(i64 (\d+) to %Result\*\)\)",
+    r"%Result\* inttoptr \(i64 (\d+) to %Result\*\)\)"
+    r"|@__quantum__rt__read_result\(%Result\* inttoptr \(i64 (\d+) to %Result\*\)\)",
 )
 
 
+def _assert_mz_rr_pairing(label: str, ir: str) -> None:
+    """Per-measurement slot correspondence: mz `%Result*` slots are
+    monotonic 0..n-1, and EVERY `read_result` is immediately preceded
+    (in emission order) by the `mz__body` of the SAME slot -- i.e. a
+    read_result reuses *its own* measurement's static slot, not merely
+    some slot in the mz set (stronger than a subset check)."""
+    events: list[tuple[str, int]] = []
+    for m in _MZ_RR_EVENT.finditer(ir):
+        if m.group(1) is not None:
+            events.append(("mz", int(m.group(1))))
+        else:
+            events.append(("rr", int(m.group(2))))
+    mz_slots = [s for kind, s in events if kind == "mz"]
+    assert mz_slots == list(range(len(mz_slots))), f"{label}: mz %Result* slots not monotonic 0..n-1: {mz_slots}"
+    for i, (kind, slot) in enumerate(events):
+        if kind != "rr":
+            continue
+        assert i > 0, f"{label}: read_result(slot {slot}) emitted before any mz; events={events}"
+        assert events[i - 1] == ("mz", slot), (
+            f"{label}: read_result(slot {slot}) is not immediately preceded "
+            f"by its own mz(slot {slot}); event sequence={events}"
+        )
+
+
 def _case(label: str) -> Main:
     for c in _curated_cases():
         if c.label == label:
@@ -159,13 +183,7 @@ def _layer_b_structural(prog: Main, label: str, *, creg_sizes: dict[str, int]) -
             f"{label}: missing zeroinitializer for CReg {name!r} (unset bits must read 0, not undef)"
         )
 
-    mz = [int(m) for m in _MZ_SLOT.findall(ir)]
-    assert mz == list(range(len(mz))), f"{label}: mz %Result* slots not monotonic 0..n-1: {mz}"
-    rr = [int(m) for m in _RR_SLOT.findall(ir)]
-    assert set(rr).issubset(set(mz)), (
-        f"{label}: read_result slots {rr} not a subset of mz slots {mz} "
-        "(read_result must reuse its measurement's own static slot)"
-    )
+    _assert_mz_rr_pairing(label, ir)
 
 
 def _assert_set_int_unpack(label: str, ir: str, *, name: str, size: int, value: int) -> None:
@@ -246,8 +264,7 @@ def run() -> int:
             _layer_a_compiler_accepts(prog, label)
             ir = SlrConverter(prog).qir()
             assert not _BESPOKE.search(ir), f"{label}: bespoke helper emitted"
-            mz = [int(m) for m in _MZ_SLOT.findall(ir)]
-            assert mz == list(range(len(mz))), f"{label}: non-monotonic slots {mz}"
+            _assert_mz_rr_pairing(label, ir)
             if creg_sizes:
                 _layer_b_structural(prog, label, creg_sizes=creg_sizes)
             if label == "extra.set_int":
@@ -299,6 +316,18 @@ def run() -> int:
     return 0
 
 
+def test_oversize_creg_raises_loud() -> None:
+    """A >64-bit CReg must FAIL LOUD at QIR codegen, not silently drop
+    its storage/output (Codex B2 post-review blocker). 64 is the cap
+    (single-i64 record pack); 65 must raise a clear error."""
+    ok = Main(q := QReg("q", 1), c := CReg("c", 64), Measure(q[0]) > c[0], Return(c))
+    SlrConverter(ok).qir_bc()  # 64 is allowed (boundary)
+
+    over = Main(q := QReg("q", 1), c := CReg("c", 65), Measure(q[0]) > c[0], Return(c))
+    with pytest.raises(NotImplementedError, match=r"CReg 'c' has 65 bits.*64-bit cap"):
+        SlrConverter(over).qir_bc()
+
+
 @pytest.mark.slow
 def test_tier2_semantic_b2() -> None:
     """Pytest entry (slow: builds the Selene runtime)."""

From eb163eab5d5d131bfe73825a04a7a5d7ab083ab0 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sun, 17 May 2026 11:42:34 -0600
Subject: [PATCH 081/136] #71 B2 Codex re-confirm fold (cosmetic): raise the
 >64-bit CReg NotImplementedError BEFORE writing context.creg_map (fail before
 any partial state). Behaviour-equivalent (size>64 raises regardless; size<=64
 unchanged); Codex minor note from codex-71-stageB2-postreview-reconfirm.md.
 Codex re-confirm: YES (0 blockers); both reviewers now YES -> B2
 dual-signed-off.

---
 python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
index b54675245..918a1545a 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
@@ -311,7 +311,6 @@ def _process_declarations(self, program: Program) -> None:
                     for i in range(decl.capacity):
                         self.context.get_qubit_index(decl.name, i)
             elif isinstance(decl, RegisterDecl):
-                self.context.creg_map[decl.name] = decl.size
                 # M-B2-static: a CReg is a mutable `[N x i1]` buffer in the
                 # entry block (declarations are processed at entry, before
                 # any control flow, so the builder is positioned there),
@@ -320,6 +319,7 @@ def _process_declarations(self, program: Program) -> None:
                 # the model caps at 64 bits. A >64-bit CReg must fail LOUD
                 # here -- silently dropping its storage/output (the old
                 # `create_creg` `size < 64` behaviour) is a miscompile.
+                # Fail BEFORE recording any state (no partial creg_map).
                 if decl.size > 64:
                     msg = (
                         f"QIR codegen: CReg {decl.name!r} has {decl.size} bits, "
@@ -329,6 +329,7 @@ def _process_declarations(self, program: Program) -> None:
                         ">64-bit CRegs are not supported by the QIR backend."
                     )
                     raise NotImplementedError(msg)
+                self.context.creg_map[decl.name] = decl.size
                 arr_ty = llvm_ir.ArrayType(self._types["bool"], decl.size)
                 creg_ptr = self._builder.alloca(arr_ty, decl.name)
                 self._builder.store(creg_ptr, llvm_ir.Constant(arr_ty))

From 1c67c3ac3338f72e1cadb5b50106e6fa6cea845b Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sun, 17 May 2026 12:01:06 -0600
Subject: [PATCH 082/136] #74: fail loud on the 3 silent AST->QIR miscompiles
 (B3). VarExpr (was ->constant 0), While (was silent one-pass dropping
 condition+iteration), Print (was silent drop losing observable output) now
 raise NotImplementedError with clear messages -- each was
 valid-QIR-but-wrong-semantics that qir-qis cannot catch. Bounded scope: real
 While/scalar-SSA/Print->record are explicitly deferred (v1-feature-matrix:
 real While "too large for first sound emitter"); min bar = fail-fast not
 silently wrong (same pattern as B2 >64 cap). qir_bc() does not wrap them
 (only parse_assembly RuntimeError caught) -> surface at QIR-gen. Deliberate
 #71 gate rebaseline (triaged like steane_pz): only docs.while_loop exercises
 a B3 site -> _EXPECTED_QIS_OK 27->26, _EXPECTED_BUILD_FAILED 2->3
 (NotImplementedError, "does not support While loops"); aligns QIR path with
 the Guppy path which already rejects While; 0 corpus Print, VarExpr only via
 for_loopvar_symbolic (build-fails earlier). Fixed enshrined-bug test:
 test_print.py test_qir_byte_identical asserted the old silent drop ->
 test_qir_raises_loud_on_print (Stim/QC byte-identical siblings left,
 documented out-of-scope). 4 fast regression tests in tier2_semantic.py.
 Gates: 5 fast + #71 gate green, cross-codegen Print 4 passed, slr_tests 368,
 ruff/format clean; broad sweep in-flight.

---
 .../src/pecos/slr/ast/codegen/qir.py          | 44 ++++++++++++++-----
 .../tests/slr_tests/ast_guppy/test_print.py   | 33 +++++++++-----
 .../ast_guppy/test_qir_spec_compliance.py     | 33 ++++++++++----
 .../slr_tests/ast_guppy/tier2_semantic.py     | 43 +++++++++++++++++-
 4 files changed, 123 insertions(+), 30 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
index 918a1545a..8cd9c6ee6 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
@@ -387,9 +387,15 @@ def _process_statement(self, stmt: Statement) -> None:
         elif isinstance(stmt, PermuteOp):
             self._process_permute(stmt)
         elif isinstance(stmt, PrintOp):
-            # Phase 1: Print is Guppy-only. Other codegens drop the streamed
-            # value silently. Revisit per-codegen if a user need surfaces.
-            return
+            # Classical-output streaming (`Print` -> Guppy `result(...)`)
+            # is unimplemented in the QIR backend. Silently dropping it
+            # loses observable program output -- fail LOUD instead.
+            msg = (
+                "QIR codegen does not support Print (classical output "
+                "streaming is unimplemented; silently dropping it would "
+                "lose observable program output)."
+            )
+            raise NotImplementedError(msg)
 
     def _process_gate(self, node: GateOp) -> None:
         """Process a gate operation."""
@@ -626,8 +632,15 @@ def _eval_expression(self, expr: Expression) -> Any:
             return self._builder.zext(bit, self._types["int"])
 
         if isinstance(expr, VarExpr):
-            # Variable lookup - for now just return 0
-            return llvm_ir.Constant(self._types["int"], 0)
+            # Classical scalar-variable lowering is unimplemented in the
+            # QIR backend. Silently evaluating every VarExpr as constant
+            # 0 is a miscompile -- fail LOUD instead.
+            msg = (
+                f"QIR codegen: classical variable {expr.name!r} is not "
+                "supported by the QIR backend (scalar-variable lowering is "
+                "unimplemented; it must not be silently evaluated as 0)."
+            )
+            raise NotImplementedError(msg)
 
         if isinstance(expr, BinaryExpr):
             left = self._eval_expression(expr.left)
@@ -664,11 +677,22 @@ def _process_if(self, node: IfStmt) -> None:
                     self._process_statement(stmt)
 
     def _process_while(self, node: WhileStmt) -> None:
-        """Process a while loop."""
-        # QIR supports loops through LLVM branch instructions
-        # For simplicity, we process the body once (approximation)
-        for stmt in node.body:
-            self._process_statement(stmt)
+        """`While` is not supported by the QIR backend.
+
+        Unbounded iteration / fixed-point linear state through an
+        unknown iteration count is out of scope for the sound emitter
+        (v1-feature-matrix); the AST->Guppy path also rejects `While`.
+        Fail LOUD here -- the previous single-pass approximation
+        silently dropped the loop condition and all iterations (a
+        miscompile qir-qis cannot catch, since one pass is valid QIR).
+        """
+        msg = (
+            "QIR codegen does not support While loops (unbounded "
+            "iteration / fixed-point linear state is out of scope for "
+            "the QIR backend; a single-pass approximation would be a "
+            "silent miscompile)."
+        )
+        raise NotImplementedError(msg)
 
     def _process_for(self, node: ForStmt) -> None:
         """Process a for loop by unrolling."""
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
index 205907738..6a53464cb 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
@@ -785,12 +785,18 @@ class TestCrossCodegenPrintEmission:
     - **QASM**: emits `// Print result.debug c` as a comment line; output is
       *not* byte-identical (intentional, per the doc's "comment-only across
       non-Guppy" plan).
-    - **QIR**, **Stim**, **QuantumCircuit**: silently skip PrintOp via their
-      isinstance-dispatch fallback (no else clause). Output is byte-identical.
-
-    These tests pin both behaviors. If a future change starts emitting in
-    QIR/Stim/QC, this catches it. If QASM stops emitting the comment, this
-    catches it.
+    - **QIR**: #74 -- the QIR backend now **fails loud** on `Print`
+      (`NotImplementedError`) instead of silently dropping it. Silently
+      losing observable output is a miscompile qir-qis cannot catch; the
+      bounded fix is to raise, not emit. (Real `Print`->record_output is
+      deferred, like real `While`.)
+    - **Stim**, **QuantumCircuit**: still silently skip PrintOp via their
+      isinstance-dispatch fallback. Output is byte-identical. (Sibling
+      silent-drop, out of #74's AST->QIR scope -- a separate task if a
+      user need surfaces.)
+
+    These tests pin all three behaviors. If QIR stops raising, or Stim/QC
+    start/stop emitting, or QASM stops the comment, this catches it.
     """
 
     @staticmethod
@@ -832,11 +838,16 @@ def test_qasm_emits_print_as_exactly_one_comment_line(self) -> None:
         added_lines = [line for line in b.splitlines() if line not in a.splitlines()]
         assert added_lines == [expected_added], f"expected exactly [{expected_added!r}] added lines, got {added_lines}"
 
-    def test_qir_byte_identical(self) -> None:
-        """QIR silently drops Print; pre/post output is byte-identical."""
-        a = SlrConverter(self._bell_no_print()).qir()
-        b = SlrConverter(self._bell_with_print()).qir()
-        assert a == b, "QIR Print emission must be a silent skip (Phase 1 policy)"
+    def test_qir_raises_loud_on_print(self) -> None:
+        """#74: QIR must FAIL LOUD on Print, not silently drop it.
+
+        The no-Print program still builds; adding Print makes `.qir()`
+        raise `NotImplementedError` (a silent drop would lose observable
+        output -- a miscompile qir-qis cannot catch).
+        """
+        SlrConverter(self._bell_no_print()).qir()  # no Print: builds fine
+        with pytest.raises(NotImplementedError, match=r"does not support Print"):
+            SlrConverter(self._bell_with_print()).qir()
 
     def test_stim_byte_identical(self) -> None:
         a = str(SlrConverter(self._bell_no_print()).stim())
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
index 796d073a2..928ff08d9 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
@@ -39,9 +39,11 @@
 `mz__body` -> static `%Result*` -> `read_result` -> `store`;
 point-of-use `gep`+`load`/`store`; `zext`/`shl`/`or` pack ->
 `__quantum__rt__int_record_output`). Every validate-passing program
-(`_EXPECTED_QIS_OK`, n=27) now lowers via `qir_to_qis`; `qis_failed`
+(`_EXPECTED_QIS_OK`, n=26) now lowers via `qir_to_qis`; `qis_failed`
 is empty. A NEW qir_to_qis failure -- or a dropped program -- trips
-this deliberately. (`adaptive_profile` is now genuinely exercised:
+this deliberately. (`docs.while_loop` was in this set pre-#74 on a
+silently-wrong single-pass approximation; #74 makes the QIR backend
+fail loud on `While`, moving it to the build-failure set below.) (`adaptive_profile` is now genuinely exercised:
 B2 emits `__quantum__rt__read_result` for measurement feedback.)
 The deeper *semantic* proof for the load-bearing CReg shapes is
 `tier2_semantic.py` (real-compiler acceptance + emitted-QIR
@@ -52,14 +54,23 @@
 typed-pointer) -- tracked as a separate blocked task; this gate
 stays structural.
 
-**Pre-existing build failures** (2): `qir_bc()` itself raises for
-`docs.for_loopvar_symbolic` / `docs.rotation_rx` -- pre-existing
-AST-QIR feature gaps tracked separately (task #74), NOT a #71
-metadata concern. Identity pinned (`_EXPECTED_BUILD_FAILED`) so a
-NEW build regression trips here. (`qeclib.steane_pz` was a pinned
+**Build failures** (3): `qir_bc()` raises for
+`docs.for_loopvar_symbolic` (symbolic `LoopVar` indexing) /
+`docs.rotation_rx` (`rx` gate) -- pre-existing AST-QIR feature
+gaps -- and `docs.while_loop` (#74: the QIR backend now fails
+LOUD on `While` instead of silently emitting a one-pass
+approximation that qir-qis cannot catch; this aligns the QIR
+path with the Guppy path, which already rejects `While` per
+v1-feature-matrix "real While is out of scope for the sound
+emitter"). Identity pinned (`_EXPECTED_BUILD_FAILED`) so a NEW
+build regression trips here. (`qeclib.steane_pz` was a pinned
 build failure pre-B2 -- the bespoke model emitted invalid bitcode
 for it; B2 produces valid bitcode so it now builds and moves to
 the pinned validate set above. A deliberate, triaged improvement.)
+#74 also fails loud on `VarExpr` (was silently 0) and `Print`
+(was silently dropped); no corpus program exercises those, so
+they add no build-failure pin -- but they are no longer silent
+miscompiles.
 
 `qir-qis` is a `[dependency-groups].test` dep (default-groups
 includes `test`), so this runs in the default sweep.
@@ -79,6 +90,13 @@
 _EXPECTED_BUILD_FAILED: dict[str, tuple[str, str]] = {
     "docs.for_loopvar_symbolic": ("AttributeError", "SymbolicQubit"),
     "docs.rotation_rx": ("RuntimeError", "__quantum__qis__rx__body"),
+    # #74: the QIR backend now fails LOUD on `While` (was a silent
+    # single-pass approximation that qir-qis could not catch -- valid
+    # QIR, wrong semantics). `docs.while_loop` moved QIS_OK -> here
+    # deliberately; this aligns the QIR path with the Guppy path,
+    # which already rejects `While` (v1-feature-matrix: real While is
+    # out of scope for the sound emitter).
+    "docs.while_loop": ("NotImplementedError", "does not support While loops"),
 }
 
 # Tier 1: the non-metadata `validate_qir` failures (label -> stable,
@@ -110,7 +128,6 @@
         "docs.prep_basis_x",
         "docs.repeat_state_preserving",
         "docs.surface_syndrome_block18",
-        "docs.while_loop",
         "examples.measure_register_to_creg",
         "examples.parallel_bell_pairs",
         "examples.surface_d3_x_1round",
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
index 921862beb..8d64445f7 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
@@ -61,7 +61,9 @@
 
 import pytest
 import qir_qis
-from pecos.slr import CReg, If, Main, QReg, Return, SlrConverter
+from pecos.slr import CReg, If, Main, Print, QReg, Return, SlrConverter, While
+from pecos.slr.ast.codegen.qir import AstToQir
+from pecos.slr.ast.nodes import VarExpr
 from pecos.slr.qeclib import qubit as qb
 from pecos.slr.qeclib.qubit.measures import Measure
 
@@ -328,6 +330,45 @@ def test_oversize_creg_raises_loud() -> None:
         SlrConverter(over).qir_bc()
 
 
+def test_while_raises_loud() -> None:
+    """#74: the QIR backend must FAIL LOUD on `While`, not silently
+    emit a one-pass approximation (qir-qis cannot catch that -- one
+    pass is valid QIR, wrong semantics). Aligns with the Guppy path,
+    which already rejects `While` (v1-feature-matrix: real While is
+    out of scope for the sound emitter)."""
+    prog = Main(
+        q := QReg("q", 1),
+        c := CReg("c", 1),
+        While(c[0] == 0).Do(qb.H(q[0]), Measure(q[0]) > c[0]),
+        Return(c),
+    )
+    with pytest.raises(NotImplementedError, match=r"does not support While loops"):
+        SlrConverter(prog).qir_bc()
+
+
+def test_print_raises_loud() -> None:
+    """#74: the QIR backend must FAIL LOUD on `Print`, not silently
+    drop it (silently losing observable program output)."""
+    prog = Main(
+        q := QReg("q", 1),
+        c := CReg("c", 1),
+        Measure(q[0]) > c[0],
+        Print(c),
+        Return(c),
+    )
+    with pytest.raises(NotImplementedError, match=r"does not support Print"):
+        SlrConverter(prog).qir_bc()
+
+
+def test_varexpr_raises_loud() -> None:
+    """#74: a classical `VarExpr` must FAIL LOUD, not silently
+    evaluate to constant 0 (a value miscompile qir-qis cannot catch).
+    Unit-level: the `VarExpr` arm is reached before any `self._types`
+    use, so a bare generator suffices."""
+    with pytest.raises(NotImplementedError, match=r"classical variable 'x'"):
+        AstToQir()._eval_expression(VarExpr(name="x"))  # noqa: SLF001
+
+
 @pytest.mark.slow
 def test_tier2_semantic_b2() -> None:
     """Pytest entry (slow: builds the Selene runtime)."""

From 177ab70c063da819fafdf93d52833e2eb0c9436d Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sun, 17 May 2026 12:35:20 -0600
Subject: [PATCH 083/136] #74 dual-review fold (Codex blocker): fix the 4th
 silent AST->QIR miscompile -- static `For` body dropped. `_process_for`'s
 `isinstance(node.start, int)` guard was always false (converter wraps For
 range bounds in LiteralExpr), so every static-For body was silently dropped:
 valid QIR, wrong semantics, qir-qis-uncatchable -- and
 docs.for_static_indexing sat in _EXPECTED_QIS_OK on body-dropped QIR (gate
 dishonest). Proper fix (static fixed-bound For is v1-supported + small,
 unlike deferred While/SSA): _static_int_bound resolves LiteralExpr(int)
 start/stop/step; _process_for unrolls range(start,stop,step) exclusive
 (matches canonical gen_quantum_circuit); symbolic/non-static bound ->
 NotImplementedError (never silent-drop). _process_repeat left as-is
 (RepeatStmt.count SLR-enforced int -- never the same bug; bounded fix to
 _process_for only). Honest resolution, NO baseline shuffle:
 docs.for_static_indexing stays in _EXPECTED_QIS_OK (26) but its QIR is now
 correct (body unrolled) -- gate honest by fixing code not the pin. New
 regression test_static_for_unrolls_body_not_dropped (3 call sites, not the
 declare; unrolled QIR still qir-qis-lowered). Gates: 6 fast tests + #71 gate
 green, broad sweep 1785/0-fail, ruff/format clean. Pickle YES; Codex
 re-confirm pending (its exact sign-off condition).

---
 .../src/pecos/slr/ast/codegen/qir.py          | 37 ++++++++++++++++---
 .../slr_tests/ast_guppy/tier2_semantic.py     | 25 ++++++++++++-
 2 files changed, 55 insertions(+), 7 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
index 8cd9c6ee6..be4cac5df 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
@@ -694,13 +694,38 @@ def _process_while(self, node: WhileStmt) -> None:
         )
         raise NotImplementedError(msg)
 
+    def _static_int_bound(self, expr: Any, which: str) -> int:
+        """Resolve a static integer `For` bound.
+
+        The converter wraps integer range bounds in `LiteralExpr`
+        (`converter.py` `_convert_for`), so the bound is never a raw
+        `int`. A non-literal / non-int bound is a symbolic/dynamic
+        `For`, which is unsupported -- fail LOUD rather than silently
+        drop the loop body (the previous `isinstance(int)` guard was
+        always false, so EVERY `For` body was silently dropped).
+        """
+        if (
+            isinstance(expr, LiteralExpr)
+            and isinstance(expr.value, int)
+            and not isinstance(expr.value, bool)
+        ):
+            return expr.value
+        msg = (
+            f"QIR codegen: For loop {which} bound is not a static integer "
+            f"({type(expr).__name__}); only fixed-bound `For(i, <int>, "
+            "<int>)` is supported (symbolic/dynamic For is out of scope -- "
+            "and must not silently drop the loop body)."
+        )
+        raise NotImplementedError(msg)
+
     def _process_for(self, node: ForStmt) -> None:
-        """Process a for loop by unrolling."""
-        if isinstance(node.start, int) and isinstance(node.stop, int):
-            step = node.step if isinstance(node.step, int) else 1
-            for _ in range(node.start, node.stop, step):
-                for stmt in node.body:
-                    self._process_statement(stmt)
+        """Unroll a static fixed-bound `For` (v1-supported)."""
+        start = self._static_int_bound(node.start, "start")
+        stop = self._static_int_bound(node.stop, "stop")
+        step = 1 if node.step is None else self._static_int_bound(node.step, "step")
+        for _ in range(start, stop, step):
+            for stmt in node.body:
+                self._process_statement(stmt)
 
     def _process_repeat(self, node: RepeatStmt) -> None:
         """Process a repeat loop by unrolling."""
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
index 8d64445f7..cd6a55268 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
@@ -61,7 +61,7 @@
 
 import pytest
 import qir_qis
-from pecos.slr import CReg, If, Main, Print, QReg, Return, SlrConverter, While
+from pecos.slr import CReg, For, If, Main, Print, QReg, Return, SlrConverter, While
 from pecos.slr.ast.codegen.qir import AstToQir
 from pecos.slr.ast.nodes import VarExpr
 from pecos.slr.qeclib import qubit as qb
@@ -360,6 +360,29 @@ def test_print_raises_loud() -> None:
         SlrConverter(prog).qir_bc()
 
 
+def test_static_for_unrolls_body_not_dropped() -> None:
+    """#74 (Codex): a static `For` must UNROLL its body, not silently
+    drop it. The old `_process_for` guard `isinstance(node.start, int)`
+    was always false (the converter wraps bounds in `LiteralExpr`), so
+    every `For` body was silently dropped -- valid QIR, wrong
+    semantics, qir-qis-uncatchable (the exact bug class #74 targets)."""
+    prog = Main(
+        q := QReg("q", 1),
+        c := CReg("c", 1),
+        For("i", 0, 3).Do(qb.X(q[0])),
+        Measure(q[0]) > c[0],
+        Return(c),
+    )
+    ir = SlrConverter(prog).qir()
+    # Count CALL sites only -- `@__quantum__qis__x__body(` also matches
+    # the one `declare` line. `For("i", 0, 3)` -> range(0, 3) -> 3 (the
+    # canonical exclusive semantics, matching gen_quantum_circuit).
+    n = ir.count("call void @__quantum__qis__x__body(")
+    assert n == 3, f"static For body must unroll 3x; got {n} X call(s) (0 == silently dropped)"
+    # and the unrolled QIR still lowers via the real qir-qis compiler
+    qir_qis.qir_to_qis(SlrConverter(prog).qir_bc())
+
+
 def test_varexpr_raises_loud() -> None:
     """#74: a classical `VarExpr` must FAIL LOUD, not silently
     evaluate to constant 0 (a value miscompile qir-qis cannot catch).

From 643add5e1b2d5467ada339e0951830da4be506ed Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sun, 17 May 2026 13:34:07 -0600
Subject: [PATCH 084/136] #74 Codex re-confirm fold: satisfy the project
 formatter gate (the only re-confirm blocker -- semantically the static-For
 fix was already verified) + non-blocking step==0. Canonical chain is
 ruff-check --fix -> black 25.9.0 -> blackdoc (NO ruff format; ruff-format was
 a spurious self-introduced conflict). Collapsed two black-joined split
 regexes into single literals (behaviour-identical: r"a" r"b" == r"ab") to
 kill the black<->ISC001 conflict at the source; converged ruff/black (COM812
 auto-fixed, black-stable). ruff check + black --check now clean, matching
 pre-commit. Non-blocking #1 (Codex): For(step=0) now raises a clear QIR
 NotImplementedError instead of a bare Python ValueError. Behaviour-preserving
 vs 177ab70c (formatting no-op; regex equiv; step==0 only changes an
 infinite-loop error message no test exercises). Pickle YES; Codex re-confirm
 pending (formatting was its sole remaining condition).

---
 .../src/pecos/slr/ast/codegen/qir.py          |  9 +++----
 .../ast_guppy/test_qir_spec_compliance.py     |  6 ++---
 .../slr_tests/ast_guppy/tier2_semantic.py     | 27 +++++++++----------
 3 files changed, 19 insertions(+), 23 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
index be4cac5df..9eb1c8dd3 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
@@ -704,11 +704,7 @@ def _static_int_bound(self, expr: Any, which: str) -> int:
         drop the loop body (the previous `isinstance(int)` guard was
         always false, so EVERY `For` body was silently dropped).
         """
-        if (
-            isinstance(expr, LiteralExpr)
-            and isinstance(expr.value, int)
-            and not isinstance(expr.value, bool)
-        ):
+        if isinstance(expr, LiteralExpr) and isinstance(expr.value, int) and not isinstance(expr.value, bool):
             return expr.value
         msg = (
             f"QIR codegen: For loop {which} bound is not a static integer "
@@ -723,6 +719,9 @@ def _process_for(self, node: ForStmt) -> None:
         start = self._static_int_bound(node.start, "start")
         stop = self._static_int_bound(node.stop, "stop")
         step = 1 if node.step is None else self._static_int_bound(node.step, "step")
+        if step == 0:
+            msg = "QIR codegen: For loop step is 0 (infinite loop); only a non-zero static step is supported."
+            raise NotImplementedError(msg)
         for _ in range(start, stop, step):
             for stmt in node.body:
                 self._process_statement(stmt)
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
index 928ff08d9..6db53a7f4 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
@@ -213,9 +213,9 @@ def test_audit_corpus_qir_compliance_baseline() -> None:
     build_failed, validate_failed, qis_ok, qis_failed, entry_attrs = _qir_state()
 
     # Sanity: validate_qir actually ran on built QIR (not vacuous).
-    assert qis_ok or qis_failed or validate_failed, (
-        f"validate_qir never ran on built QIR; build_failed={sorted(label for label, _, _ in build_failed)}"
-    )
+    assert (
+        qis_ok or qis_failed or validate_failed
+    ), f"validate_qir never ran on built QIR; build_failed={sorted(label for label, _, _ in build_failed)}"
 
     # Pre-existing build-failure set pinned (Codex Stage-A blocker): a
     # new build regression -- or a fixed one -- must be triaged
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
index cd6a55268..3b4b7ee69 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
@@ -72,10 +72,7 @@
 
 _SHOTS = 8
 _SEED = 42
-_BESPOKE = re.compile(
-    r"create_creg|get_creg_bit|set_creg_bit|get_int_from_creg"
-    r"|set_creg_to_int|mz_to_creg_bit",
-)
+_BESPOKE = re.compile(r"create_creg|get_creg_bit|set_creg_bit|get_int_from_creg|set_creg_to_int|mz_to_creg_bit")
 # Ordered mz/read_result events (slot in g1 for mz, g2 for read_result) so
 # we can pin per-measurement slot correspondence, not just set membership.
 _MZ_RR_EVENT = re.compile(
@@ -181,9 +178,9 @@ def _layer_b_structural(prog: Main, label: str, *, creg_sizes: dict[str, int]) -
 
     for name, size in creg_sizes.items():
         assert f"%{name} = alloca [{size} x i1]" in ir, f"{label}: missing entry-block alloca for CReg {name!r}"
-        assert f"store [{size} x i1] zeroinitializer, [{size} x i1]* %{name}" in ir, (
-            f"{label}: missing zeroinitializer for CReg {name!r} (unset bits must read 0, not undef)"
-        )
+        assert (
+            f"store [{size} x i1] zeroinitializer, [{size} x i1]* %{name}" in ir
+        ), f"{label}: missing zeroinitializer for CReg {name!r} (unset bits must read 0, not undef)"
 
     _assert_mz_rr_pairing(label, ir)
 
@@ -207,9 +204,10 @@ def _assert_set_int_unpack(label: str, ir: str, *, name: str, size: int, value:
             rf"getelementptr \[{size} x i1\], \[{size} x i1\]\* %{name}, "
             rf"i64 0, i64 {i}\n\s*store i1 {bit}, i1\* %[.\w]+"
         )
-        assert re.search(pat, ir), (
-            f"{label}: c.set({value:#b}) bit {i} not stored as `i1 {bit}` at gep {name}[{i}] (LSB-first)"
-        )
+        assert re.search(
+            pat,
+            ir,
+        ), f"{label}: c.set({value:#b}) bit {i} not stored as `i1 {bit}` at gep {name}[{i}] (LSB-first)"
     # Record pack: per-bit load/zext, `shl i64 _, i` for i>0, or-chain.
     assert ir.count("load i1") >= size, f"{label}: record pack missing per-bit `load i1`"
     assert ir.count("zext i1") >= size, f"{label}: record pack missing per-bit `zext i1`"
@@ -222,12 +220,11 @@ def _assert_zero_init_predicate(label: str, ir: str, *, name: str) -> None:
     """`If(c[i])` before any write must branch on a `load` of the
     zero-initialised buffer (so the predicate is deterministically 0,
     never `undef`)."""
-    assert f"store [1 x i1] zeroinitializer, [1 x i1]* %{name}" in ir, (
-        f"{label}: missing zeroinitializer for the pre-read CReg {name!r}"
-    )
+    assert (
+        f"store [1 x i1] zeroinitializer, [1 x i1]* %{name}" in ir
+    ), f"{label}: missing zeroinitializer for the pre-read CReg {name!r}"
     assert re.search(
-        rf"getelementptr \[1 x i1\], \[1 x i1\]\* %{name}, i64 0, i64 0\n"
-        rf"\s*%[.\w]+ = load i1",
+        rf"getelementptr \[1 x i1\], \[1 x i1\]\* %{name}, i64 0, i64 0\n\s*%[.\w]+ = load i1",
         ir,
     ), f"{label}: If(c[0]) predicate is not a load of the zero-inited buffer"
 

From 41cd9eadeb43e294356937b5843deba4bdff08bd Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sun, 17 May 2026 14:02:01 -0600
Subject: [PATCH 085/136] #73 pre-PR hygiene: resolve branch-wide ruff/black
 debt -> repo fully green. 6 files (4 branch-touched + 2 pre-existing
 examples/surface, user-chose whole-repo-green). No logic change.
 migrate_implicit_return.py (libcst CSTTransformer): N802 x2 -> scoped `#
 noqa: N802` with rationale (libcst dispatches by the exact
 `leave_<CSTNodeClassName>` name -- API contract, renaming breaks dispatch);
 ARG002 x2 -> rename unused `original` -> `_original` (libcst calls
 positionally; no suppression needed). COM812 x7 -> ruff --fix (black-stable).
 2x ISC001 from black-joined split strings (_block_flatten error msg,
 test_ast_visitor assert msg) -> collapsed to single literals at source
 (behaviour-identical). All 6 black-formatted (line-length 120). Canonical
 chain ruff-check --fix -> black 25.9.0. Verified: repo-wide `ruff check` All
 passed + `black --check` clean (760 unchanged); broad sweep 1785 passed / 15
 skipped / 0 fail (behaviour-preserving: formatting / equivalent-string /
 unused-param-rename / comment-only).

---
 examples/surface/build_report.py              | 12 ++++--
 examples/surface/decoder_comparison.py        | 12 ++++--
 .../src/pecos/slr/ast/_block_substitution.py  | 18 ++-------
 .../pecos/slr/ast/codegen/_block_flatten.py   |  5 +--
 .../pecos/slr/ast_tests/test_ast_visitor.py   | 18 +++------
 scripts/migrate_implicit_return.py            | 40 +++++++++----------
 6 files changed, 46 insertions(+), 59 deletions(-)

diff --git a/examples/surface/build_report.py b/examples/surface/build_report.py
index ea392b7b6..71b71fae2 100644
--- a/examples/surface/build_report.py
+++ b/examples/surface/build_report.py
@@ -661,7 +661,8 @@ def _build_html(analysis: dict) -> str:
     tables = analysis.get("comparison_tables", [])
     curves = analysis.get("threshold_curves", [])
 
-    style = dedent("""
+    style = dedent(
+        """
         :root {
           color-scheme: light dark;
           --bg: #f8fafc; --fg: #0f172a;
@@ -762,7 +763,8 @@ def _build_html(analysis: dict) -> str:
         details.collapsible > summary::before { content: "\\25B6  "; font-size: 0.8em; }
         details.collapsible[open] > summary::before { content: "\\25BC  "; }
         details.collapsible > .section { margin-top: 8px; }
-    """).strip()
+    """,
+    ).strip()
 
     def meta_card(label: str, value: str, *, raw: bool = False) -> str:
         val = value if raw else html_mod.escape(value)
@@ -1051,7 +1053,8 @@ def _violin_plots_for_p(p_val: float) -> list[str]:
     parts.extend(
         [
             "</main>",
-            dedent("""
+            dedent(
+                """
         <script>
         (function() {
           var html = document.documentElement;
@@ -1067,7 +1070,8 @@ def _violin_plots_for_p(p_val: float) -> list[str]:
           });
         })();
         </script>
-        """).strip(),
+        """,
+            ).strip(),
             "</body>",
             "</html>",
         ],
diff --git a/examples/surface/decoder_comparison.py b/examples/surface/decoder_comparison.py
index d1b9ea91d..926b5de7b 100644
--- a/examples/surface/decoder_comparison.py
+++ b/examples/surface/decoder_comparison.py
@@ -268,7 +268,8 @@ def write_json(path: Path, points: list[ComparisonPoint], config: dict) -> None:
 
 def write_html(path: Path, points: list[ComparisonPoint], config: dict) -> None:
     """Write an HTML report with comparison tables."""
-    style = dedent("""
+    style = dedent(
+        """
         :root {
           color-scheme: light dark;
           --bg: #f8fafc; --fg: #0f172a;
@@ -351,7 +352,8 @@ def write_html(path: Path, points: list[ComparisonPoint], config: dict) -> None:
         td:first-child, th:first-child { text-align: left; }
         tr:nth-child(even) td { background: var(--table-stripe); }
         code { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; }
-    """).strip()
+    """,
+    ).strip()
 
     def meta_card(label: str, value: str) -> str:
         return f'      <div class="meta-card"><strong>{html.escape(label)}</strong>{html.escape(value)}</div>'
@@ -435,7 +437,8 @@ def meta_card(label: str, value: str) -> str:
     parts.extend(
         [
             "</main>",
-            dedent("""
+            dedent(
+                """
         <script>
         (function() {
           var html = document.documentElement;
@@ -451,7 +454,8 @@ def meta_card(label: str, value: str) -> str:
           });
         })();
         </script>
-        """).strip(),
+        """,
+            ).strip(),
             "</body>",
             "</html>",
         ],
diff --git a/python/quantum-pecos/src/pecos/slr/ast/_block_substitution.py b/python/quantum-pecos/src/pecos/slr/ast/_block_substitution.py
index a55bc8fa5..9bb198f69 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/_block_substitution.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/_block_substitution.py
@@ -228,17 +228,13 @@ def substitute_stmt(stmt: Statement, remap: BodyRemap) -> Statement:
         return _sub_prepare(stmt, remap)
     if isinstance(stmt, BarrierOp):
         return BarrierOp(
-            allocators=tuple(
-                remap.whole_name(a, context="Barrier") for a in stmt.allocators
-            ),
+            allocators=tuple(remap.whole_name(a, context="Barrier") for a in stmt.allocators),
             location=stmt.location,
         )
     if isinstance(stmt, AssignOp):
         target = stmt.target
         new_target = (
-            remap.bit(target)
-            if isinstance(target, BitRef)
-            else remap.whole_name(target, context="assignment target")
+            remap.bit(target) if isinstance(target, BitRef) else remap.whole_name(target, context="assignment target")
         )
         return AssignOp(
             target=new_target,
@@ -248,20 +244,14 @@ def substitute_stmt(stmt: Statement, remap: BodyRemap) -> Statement:
     if isinstance(stmt, ReturnOp):
         return ReturnOp(
             values=tuple(
-                _sub_expr(v, remap)
-                if not isinstance(v, str)
-                else remap.whole_name(v, context="Return value")
+                _sub_expr(v, remap) if not isinstance(v, str) else remap.whole_name(v, context="Return value")
                 for v in stmt.values
             ),
             location=stmt.location,
         )
     if isinstance(stmt, PrintOp):
         value = stmt.value
-        new_value = (
-            remap.bit(value)
-            if isinstance(value, BitRef)
-            else remap.whole_name(value, context="Print value")
-        )
+        new_value = remap.bit(value) if isinstance(value, BitRef) else remap.whole_name(value, context="Print value")
         return PrintOp(
             value=new_value,
             tag=stmt.tag,
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/_block_flatten.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/_block_flatten.py
index 41fa55746..225199884 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/_block_flatten.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/_block_flatten.py
@@ -189,9 +189,6 @@ def _inline_call(call: BlockCall, decls: dict[str, BlockDecl]) -> tuple[Statemen
             for k, slot in enumerate(arg.slots):
                 remap.add_slot((inp.name, k), (slot.allocator, slot.index))
         else:  # BitBundleArg already rejected above; defensive
-            msg = (
-                f"Flatten pass: unexpected BlockArg {type(arg).__name__} for "
-                f"input {inp.name!r} of {call.callee!r}"
-            )
+            msg = f"Flatten pass: unexpected BlockArg {type(arg).__name__} for input {inp.name!r} of {call.callee!r}"
             raise NotImplementedError(msg)
     return tuple(substitute_stmt(stmt, remap) for stmt in decl.body)
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_visitor.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_visitor.py
index fecfc5c5d..0d1b838b9 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_visitor.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_visitor.py
@@ -297,28 +297,20 @@ def all_subclasses(cls: type) -> set[type]:
         # subclasses (e.g. `MyGate(GateOp)`) are intentionally resolved
         # by MRO in BaseVisitor.visit and must NOT be required in
         # _DISPATCH, so scope the enumeration to the nodes module.
-        nodes = {
-            c for c in all_subclasses(nodes_mod.AstNode) if c.__module__ == nodes_mod.__name__
-        }
+        nodes = {c for c in all_subclasses(nodes_mod.AstNode) if c.__module__ == nodes_mod.__name__}
         # Intermediate/abstract bases (AstNode, Expression, Statement,
         # TypeExpr, Declaration, BlockArg) are never instantiated directly
         # and are correctly absent from _DISPATCH.
-        bases = {
-            base
-            for cls in nodes
-            for base in cls.__bases__
-            if base in nodes or base is nodes_mod.AstNode
-        }
+        bases = {base for cls in nodes for base in cls.__bases__ if base in nodes or base is nodes_mod.AstNode}
         return {cls.__name__ for cls in nodes if cls not in bases}
 
     def test_every_concrete_node_has_a_dispatch_entry(self) -> None:
         from pecos.slr.ast.visitor import _DISPATCH
 
         missing = sorted(self._concrete_node_names() - set(_DISPATCH))
-        assert not missing, (
-            f"concrete AST nodes with no _DISPATCH entry: {missing} "
-            "(add them to pecos.slr.ast.visitor._DISPATCH)"
-        )
+        assert (
+            not missing
+        ), f"concrete AST nodes with no _DISPATCH entry: {missing} (add them to pecos.slr.ast.visitor._DISPATCH)"
 
     def test_no_stale_or_invalid_dispatch_entries(self) -> None:
         from pecos.slr.ast.visitor import _DISPATCH, BaseVisitor
diff --git a/scripts/migrate_implicit_return.py b/scripts/migrate_implicit_return.py
index 817b60899..44a677138 100644
--- a/scripts/migrate_implicit_return.py
+++ b/scripts/migrate_implicit_return.py
@@ -42,15 +42,16 @@ def _is_result_creg_call(call: cst.Call) -> bool:
         """A `CReg(...)` call counts as a result CReg unless it explicitly
         passes `result=False`."""
         for arg in call.args:
-            if (
-                arg.keyword is not None
-                and arg.keyword.value == "result"
-                and m.matches(arg.value, m.Name("False"))
-            ):
+            if arg.keyword is not None and arg.keyword.value == "result" and m.matches(arg.value, m.Name("False")):
                 return False
         return True
 
-    def leave_Call(self, original: cst.Call, updated: cst.Call) -> cst.BaseExpression:
+    # libcst dispatches transformer hooks by the exact method name
+    # `leave_<CSTNodeClassName>` and calls them positionally; the
+    # CamelCase name is the libcst API contract, not ours -- renaming
+    # it breaks dispatch (hence the scoped N802 allow). `original` is
+    # unused, so `_original` silences ARG002 without a suppression.
+    def leave_Call(self, _original: cst.Call, updated: cst.Call) -> cst.BaseExpression:  # noqa: N802
         # Match bare `Main(...)` AND any qualified form (`pecos.slr.Main(...)`,
         # `slr.Main(...)`) -- the func is then an Attribute whose final attr
         # is `Main` (Codex S1-approach review: qualified calls were missed).
@@ -60,9 +61,7 @@ def leave_Call(self, original: cst.Call, updated: cst.Call) -> cst.BaseExpressio
         ):
             return updated
 
-        has_return = any(
-            m.matches(a.value, m.Call(func=m.Name("Return"))) for a in updated.args
-        )
+        has_return = any(m.matches(a.value, m.Call(func=m.Name("Return"))) for a in updated.args)
         if has_return:
             self.skipped_existing_return += 1
             return updated
@@ -75,7 +74,8 @@ def leave_Call(self, original: cst.Call, updated: cst.Call) -> cst.BaseExpressio
                 continue
             v = a.value
             if m.matches(v, m.NamedExpr()) and m.matches(
-                v.value, m.Call(func=m.Name("CReg"))
+                v.value,
+                m.Call(func=m.Name("CReg")),
             ):
                 target = v.target
                 if isinstance(target, cst.Name) and self._is_result_creg_call(v.value):
@@ -114,14 +114,16 @@ def _ensure_return_import(module: cst.Module) -> cst.Module:
     """Add `Return` to an existing `from pecos.slr import ...` if absent."""
 
     class _ImportFixer(cst.CSTTransformer):
-        def leave_ImportFrom(
-            self, original: cst.ImportFrom, updated: cst.ImportFrom
+        # See `leave_Call` above: libcst mandates the `leave_<Node>`
+        # name (scoped N802) and positional call; `_original` silences
+        # ARG002 without a suppression.
+        def leave_ImportFrom(  # noqa: N802
+            self,
+            _original: cst.ImportFrom,
+            updated: cst.ImportFrom,
         ) -> cst.ImportFrom:
             mod = updated.module
-            if not (
-                m.matches(mod, m.Attribute())
-                and cst.Module([]).code_for_node(mod) == "pecos.slr"
-            ):
+            if not (m.matches(mod, m.Attribute()) and cst.Module([]).code_for_node(mod) == "pecos.slr"):
                 return updated
             if isinstance(updated.names, cst.ImportStar):
                 return updated
@@ -132,9 +134,7 @@ def leave_ImportFrom(
             names.append(cst.ImportAlias(name=cst.Name("Return")))
             names.sort(key=lambda n: n.name.value if isinstance(n.name, cst.Name) else "")
             # Re-add commas (sort drops them); libcst normalizes.
-            fixed = [
-                a.with_changes(comma=cst.MaybeSentinel.DEFAULT) for a in names
-            ]
+            fixed = [a.with_changes(comma=cst.MaybeSentinel.DEFAULT) for a in names]
             return updated.with_changes(names=fixed)
 
     return module.visit(_ImportFixer())
@@ -157,7 +157,7 @@ def main(paths: list[str]) -> int:
             print(
                 f"{p}: migrated={tx.migrated} "
                 f"skipped_existing_return={tx.skipped_existing_return} "
-                f"residual={len(tx.residual)}"
+                f"residual={len(tx.residual)}",
             )
         total_migrated += tx.migrated
         total_residual += [f"{p}: {r}" for r in tx.residual]

From a3e9124d7ce8740efa26571cdc6337dffd3de76e Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sun, 17 May 2026 14:47:15 -0600
Subject: [PATCH 086/136] #78: fix the silent AST->QIR-sibling miscompiles in
 the Stim + QuantumCircuit AST codegens (same class as #74, applied per the
 explicit-over-implicit / fail-fast rule). _process_for: the
 isinstance(node.start, int) guard was always false (converter wraps For range
 bounds in LiteralExpr) -> Stim silently dropped every For body;
 QuantumCircuit's else *rejected every* static For (even valid For(i,0,3)).
 Now both resolve LiteralExpr(int) start/stop/step via _static_int_bound and
 unroll range(start,stop,step) exclusive (matches canonical
 gen_quantum_circuit); symbolic/non-static bound or step==0 -> clear
 NotImplementedError, never silent-drop. stim _process_while: was silent
 one-pass + stray TICK -> NotImplementedError (Stim has no runtime loop; same
 decision as #74's While; QC While already loud). Print -> fail loud in both
 (was a deliberately-pinned silent skip): Stim "does not support Print"
 (fundamental -- no classical-output stream); QuantumCircuit "does not yet
 support Print" (PECOS owns this format, may be added later). _process_repeat
 untouched (RepeatStmt.count SLR-enforced int -- never the bug; bounded to
 _process_for). Flipped test_print.py::TestCrossCodegenPrintEmission
 test_{stim,quantum_circuit}_byte_identical -> _raises_loud_on_print +
 docstring (same enshrined-bug-test correction #74 did for
 test_qir_byte_identical). New regression:
 TestStim/QuantumCircuitStaticForAndWhile (For unrolls 3x not dropped; While
 raises). Out of scope (surfaced, not changed): Stim silently skips
 unsupported gates / has no classical-Assign model -- long-standing,
 fundamental, broad reliance. Gates: ruff+black canonical clean; slr_tests
 372/0-fail; broad 1923/0-fail.

---
 .../pecos/slr/ast/codegen/quantum_circuit.py  | 60 ++++++++++++----
 .../src/pecos/slr/ast/codegen/stim.py         | 68 ++++++++++++++-----
 .../tests/slr_tests/ast_guppy/test_print.py   | 42 +++++++-----
 .../slr/test_quantum_circuit_conversion.py    | 37 +++++++++-
 .../pecos/unit/slr/test_stim_conversion.py    | 38 ++++++++++-
 5 files changed, 197 insertions(+), 48 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py
index c8426d9e4..e6670390c 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py
@@ -36,6 +36,7 @@
     GateKind,
     GateOp,
     IfStmt,
+    LiteralExpr,
     MeasureOp,
     ParallelBlock,
     PermuteOp,
@@ -264,9 +265,19 @@ def _process_statement(self, stmt: Statement) -> None:
         elif isinstance(stmt, PermuteOp):
             self._process_permute(stmt)
         elif isinstance(stmt, PrintOp):
-            # Phase 1: Print is Guppy-only. Other codegens drop the streamed
-            # value silently. Revisit per-codegen if a user need surfaces.
-            return
+            # Print is not yet implemented for the QuantumCircuit
+            # backend. Fail LOUD rather than silently drop observable
+            # program output (#74 principle). Unlike Stim, PECOS owns
+            # the QuantumCircuit format, so a `Print` representation
+            # could be added later -- this is "not yet", not "cannot".
+            msg = (
+                "QuantumCircuit codegen does not yet support Print "
+                "(classical output streaming is not implemented for this "
+                "backend; it is silently-drop-free by design -- fail "
+                "loud. PECOS controls this format, so Print support may "
+                "be added in future)."
+            )
+            raise NotImplementedError(msg)
 
     def _process_gate(self, node: GateOp) -> None:
         """Process a gate operation."""
@@ -357,17 +368,40 @@ def _process_while(self, node: WhileStmt) -> None:
         )
         raise NotImplementedError(msg)
 
+    def _static_int_bound(self, expr: object, which: str) -> int:
+        """Resolve a static integer `For` bound.
+
+        The AST converter wraps integer range bounds in `LiteralExpr`
+        (`converter.py` `_convert_for`), so the bound is never a raw
+        `int` -- the old `isinstance(int)` guard was always false, so
+        the `else` branch *rejected every* static `For` (even valid
+        `For(i, 0, 3)`). Resolve the literal; a non-literal / non-int
+        bound is a symbolic/dynamic `For`: fail LOUD.
+        """
+        if isinstance(expr, LiteralExpr) and isinstance(expr.value, int) and not isinstance(expr.value, bool):
+            return expr.value
+        msg = (
+            f"QuantumCircuit codegen: For loop {which} bound is not a "
+            f"static integer ({type(expr).__name__}); only fixed-bound "
+            "`For(i, <int>, <int>)` is supported (symbolic/dynamic For "
+            "is out of scope)."
+        )
+        raise NotImplementedError(msg)
+
     def _process_for(self, node: ForStmt) -> None:
-        """Process a for loop by unrolling."""
-        # Unroll if bounds are static
-        if isinstance(node.start, int) and isinstance(node.stop, int):
-            step = node.step if isinstance(node.step, int) else 1
-            for _ in range(node.start, node.stop, step):
-                for stmt in node.body:
-                    self._process_statement(stmt)
-        else:
-            msg = f"Cannot unroll For loop with non-integer bounds: start={node.start}, stop={node.stop}"
-            raise TypeError(msg)
+        """Unroll a static fixed-bound `For` (v1-supported)."""
+        start = self._static_int_bound(node.start, "start")
+        stop = self._static_int_bound(node.stop, "stop")
+        step = 1 if node.step is None else self._static_int_bound(node.step, "step")
+        if step == 0:
+            msg = (
+                "QuantumCircuit codegen: For loop step is 0 (infinite "
+                "loop); only a non-zero static step is supported."
+            )
+            raise NotImplementedError(msg)
+        for _ in range(start, stop, step):
+            for stmt in node.body:
+                self._process_statement(stmt)
 
     def _process_repeat(self, node: RepeatStmt) -> None:
         """Process a repeat loop by unrolling."""
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/stim.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/stim.py
index 0f215747a..8c37fe9d7 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/stim.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/stim.py
@@ -36,6 +36,7 @@
     GateKind,
     GateOp,
     IfStmt,
+    LiteralExpr,
     MeasureOp,
     ParallelBlock,
     PermuteOp,
@@ -254,9 +255,15 @@ def _process_statement(self, stmt: Statement) -> None:
         elif isinstance(stmt, PermuteOp):
             self._process_permute(stmt)
         elif isinstance(stmt, PrintOp):
-            # Phase 1: Print is Guppy-only. Other codegens drop the streamed
-            # value silently. Revisit per-codegen if a user need surfaces.
-            return
+            # Classical-output streaming is unimplemented in the Stim
+            # backend. Silently dropping it loses observable program
+            # output -- fail LOUD (same decision as the QIR backend, #74).
+            msg = (
+                "Stim codegen does not support Print (classical output "
+                "streaming is unimplemented; silently dropping it would "
+                "lose observable program output)."
+            )
+            raise NotImplementedError(msg)
         # Other statement types (Comment, Assign, Return) don't generate Stim output
 
     def _process_gate(self, node: GateOp) -> None:
@@ -334,22 +341,49 @@ def _process_if(self, node: IfStmt) -> None:
                 self._process_statement(stmt)
 
     def _process_while(self, node: WhileStmt) -> None:
-        """Process a while loop."""
-        # Stim doesn't support runtime loops - process body once
-        self.circuit.append("TICK")
-        for stmt in node.body:
-            self._process_statement(stmt)
+        """`While` is not supported by the Stim backend.
+
+        Stim has no runtime loop. The previous "process body once + TICK"
+        silently dropped the loop condition and all iterations -- a
+        miscompile. Fail LOUD instead (same decision as the QIR backend,
+        #74; real While is out of scope per v1-feature-matrix).
+        """
+        _ = node
+        msg = (
+            "Stim codegen does not support While loops (Stim has no "
+            "runtime loop; a single-pass approximation would be a silent "
+            "miscompile)."
+        )
+        raise NotImplementedError(msg)
+
+    def _static_int_bound(self, expr: object, which: str) -> int:
+        """Resolve a static integer `For` bound.
+
+        The AST converter wraps integer range bounds in `LiteralExpr`
+        (`converter.py` `_convert_for`), so the bound is never a raw
+        `int` -- the old `isinstance(int)` guard was always false and
+        silently dropped every `For` body. A non-literal / non-int
+        bound is a symbolic/dynamic `For`: fail LOUD, never drop.
+        """
+        if isinstance(expr, LiteralExpr) and isinstance(expr.value, int) and not isinstance(expr.value, bool):
+            return expr.value
+        msg = (
+            f"Stim codegen: For loop {which} bound is not a static integer "
+            f"({type(expr).__name__}); only fixed-bound `For(i, <int>, "
+            "<int>)` is supported (symbolic/dynamic For is out of scope -- "
+            "and must not silently drop the loop body)."
+        )
+        raise NotImplementedError(msg)
 
     def _process_for(self, node: ForStmt) -> None:
-        """Process a for loop."""
-        # Try to unroll if bounds are static
-        if isinstance(node.start, int) and isinstance(node.stop, int):
-            step = node.step if isinstance(node.step, int) else 1
-            for _ in range(node.start, node.stop, step):
-                for stmt in node.body:
-                    self._process_statement(stmt)
-        else:
-            # Can't unroll - process body once
+        """Unroll a static fixed-bound `For` (v1-supported)."""
+        start = self._static_int_bound(node.start, "start")
+        stop = self._static_int_bound(node.stop, "stop")
+        step = 1 if node.step is None else self._static_int_bound(node.step, "step")
+        if step == 0:
+            msg = "Stim codegen: For loop step is 0 (infinite loop); only a non-zero static step is supported."
+            raise NotImplementedError(msg)
+        for _ in range(start, stop, step):
             for stmt in node.body:
                 self._process_statement(stmt)
 
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
index 6a53464cb..ad0d072a3 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
@@ -790,13 +790,18 @@ class TestCrossCodegenPrintEmission:
       losing observable output is a miscompile qir-qis cannot catch; the
       bounded fix is to raise, not emit. (Real `Print`->record_output is
       deferred, like real `While`.)
-    - **Stim**, **QuantumCircuit**: still silently skip PrintOp via their
-      isinstance-dispatch fallback. Output is byte-identical. (Sibling
-      silent-drop, out of #74's AST->QIR scope -- a separate task if a
-      user need surfaces.)
-
-    These tests pin all three behaviors. If QIR stops raising, or Stim/QC
-    start/stop emitting, or QASM stops the comment, this catches it.
+    - **Stim**, **QuantumCircuit**: #78 -- now also **fail loud** on
+      `Print` (`NotImplementedError`), the same silent-drop class as
+      #74's QIR Print, applied per the explicit-over-implicit rule.
+      Stim's is fundamental ("does not support" -- Stim has no
+      classical-output stream); QuantumCircuit's is "does not yet
+      support" (PECOS owns that format, so it may be added later).
+      Was a deliberately-pinned silent skip; flipped here exactly as
+      #74 flipped `test_qir_byte_identical` -> `..._raises_loud`.
+
+    These tests pin all four behaviors. If any backend stops
+    raising / starts emitting, or QASM stops the comment, this catches
+    it.
     """
 
     @staticmethod
@@ -849,15 +854,20 @@ def test_qir_raises_loud_on_print(self) -> None:
         with pytest.raises(NotImplementedError, match=r"does not support Print"):
             SlrConverter(self._bell_with_print()).qir()
 
-    def test_stim_byte_identical(self) -> None:
-        a = str(SlrConverter(self._bell_no_print()).stim())
-        b = str(SlrConverter(self._bell_with_print()).stim())
-        assert a == b, "Stim Print emission must be a silent skip (Phase 1 policy)"
-
-    def test_quantum_circuit_byte_identical(self) -> None:
-        a = str(SlrConverter(self._bell_no_print()).quantum_circuit())
-        b = str(SlrConverter(self._bell_with_print()).quantum_circuit())
-        assert a == b, "QuantumCircuit Print emission must be a silent skip (Phase 1 policy)"
+    def test_stim_raises_loud_on_print(self) -> None:
+        """#78: Stim must FAIL LOUD on Print (no classical-output
+        stream), not silently drop it. No-Print still converts."""
+        SlrConverter(self._bell_no_print()).stim()  # no Print: fine
+        with pytest.raises(NotImplementedError, match=r"does not support Print"):
+            SlrConverter(self._bell_with_print()).stim()
+
+    def test_quantum_circuit_raises_loud_on_print(self) -> None:
+        """#78: QuantumCircuit must FAIL LOUD on Print (not yet
+        implemented -- may be added since PECOS owns this format), not
+        silently drop it. No-Print still converts."""
+        SlrConverter(self._bell_no_print()).quantum_circuit()  # no Print: fine
+        with pytest.raises(NotImplementedError, match=r"does not yet support Print"):
+            SlrConverter(self._bell_with_print()).quantum_circuit()
 
 
 # ── Selene shape edge cases (probed 2026-05-14) ──────────────────────────
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_circuit_conversion.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_circuit_conversion.py
index dee429fb4..972b08a2c 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_circuit_conversion.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_circuit_conversion.py
@@ -10,9 +10,10 @@
 
 import pytest
 from pecos.circuits.quantum_circuit import QuantumCircuit
-from pecos.slr import CReg, For, Main, Parallel, QReg, Repeat, Return, SlrConverter
+from pecos.slr import CReg, For, Main, Parallel, QReg, Repeat, Return, SlrConverter, While
 from pecos.slr.gen_codes.gen_quantum_circuit import QuantumCircuitGenerator
 from pecos.slr.qeclib import qubit
+from pecos.slr.qeclib.qubit.measures import Measure
 
 
 def _return_declared_cregs(prog: Main) -> Main:
@@ -393,5 +394,39 @@ def test_complex_circuit_preservation(self) -> None:
             assert op_nospace in recon_qasm.lower() or op_space in recon_qasm.lower()
 
 
+class TestQuantumCircuitStaticForAndWhile:
+    """#78: same silent-miscompile class as #74, in the AST
+    QuantumCircuit codegen.
+
+    The AST converter wraps `For` range bounds in `LiteralExpr`, so the
+    old `isinstance(node.start, int)` guard was always false -- the
+    `else` *rejected every* static `For` (even valid `For(i, 0, 3)`)
+    with a `TypeError`. Now: static `For` unrolls; symbolic bound fails
+    loud with a clear message. (`While` already failed loud here.)
+    """
+
+    def test_static_for_unrolls_body_not_dropped(self) -> None:
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            For("i", 0, 3).Do(qubit.X(q[0])),
+            Measure(q[0]) > c[0],
+            Return(c),
+        )
+        qc = SlrConverter(prog).quantum_circuit()
+        # 3 unrolled X on qubit 0 in the QuantumCircuit op list.
+        assert str(qc).count("{'X': {0}}") == 3, f"static For not unrolled 3x: {qc}"
+
+    def test_while_raises_loud(self) -> None:
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            While(c[0] == 0).Do(qubit.X(q[0]), Measure(q[0]) > c[0]),
+            Return(c),
+        )
+        with pytest.raises(NotImplementedError, match=r"While loops cannot be converted"):
+            SlrConverter(prog).quantum_circuit()
+
+
 if __name__ == "__main__":
     pytest.main([__file__, "-v"])
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_stim_conversion.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_stim_conversion.py
index 60abbe3e7..97259603a 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_stim_conversion.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_stim_conversion.py
@@ -1,8 +1,9 @@
 """Tests for Stim circuit to/from SLR conversion."""
 
 import pytest
-from pecos.slr import CReg, Main, Parallel, QReg, Repeat, Return, SlrConverter
+from pecos.slr import CReg, For, Main, Parallel, QReg, Repeat, Return, SlrConverter, While
 from pecos.slr.qeclib import qubit
+from pecos.slr.qeclib.qubit.measures import Measure
 
 
 def _return_declared_cregs(prog: Main) -> Main:
@@ -303,5 +304,40 @@ def test_slr_round_trip(self) -> None:
         assert "cx q[0],q[1]" in recon_qasm or "cx q[0], q[1]" in recon_qasm
 
 
+@pytest.mark.skipif(not STIM_AVAILABLE, reason="Stim not installed")
+class TestStimStaticForAndWhile:
+    """#78: same silent-miscompile class as #74, in the AST Stim codegen.
+
+    The AST converter wraps `For` range bounds in `LiteralExpr`, so the
+    old `isinstance(node.start, int)` guard was always false -- Stim
+    silently dropped every `For` body, and `While` was silently
+    processed once (+ a stray TICK). Both are valid-output / wrong-
+    semantics. Now: static `For` unrolls; `While` fails loud.
+    """
+
+    def test_static_for_unrolls_body_not_dropped(self) -> None:
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            For("i", 0, 3).Do(qubit.X(q[0])),
+            Measure(q[0]) > c[0],
+            Return(c),
+        )
+        circ = SlrConverter(prog).stim()
+        # 3 X applications on qubit 0 (Stim coalesces to `X 0 0 0`);
+        # 0 == the old silent drop.
+        assert "X 0 0 0" in str(circ), f"static For body not unrolled 3x:\n{circ}"
+
+    def test_while_raises_loud(self) -> None:
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            While(c[0] == 0).Do(qubit.X(q[0]), Measure(q[0]) > c[0]),
+            Return(c),
+        )
+        with pytest.raises(NotImplementedError, match=r"does not support While loops"):
+            SlrConverter(prog).stim()
+
+
 if __name__ == "__main__":
     pytest.main([__file__, "-v"])

From abfc8c0ca8214813ee1940e44e5e40d6d4b601c6 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sun, 17 May 2026 16:08:32 -0600
Subject: [PATCH 087/136] #77 DONE: real executable QIR->QIS->selene Tier-2
 differential (A+B+C -> A+B+C+D). selene_sim (already a PECOS dep) natively
 executes qir_qis.qir_to_qis's LLVM-21 opaque-pointer QIS via the bundled
 selene_helios_qis_plugin (+ Helios QIR runtime) -- the long-claimed "blocked
 on an LLVM 14<->21 bridge" / "bounded post-PR infra (LLVM-21 JIT + runtime
 shim)" were BOTH wrong; no PECOS LLVM bump, PECOS-Rust stays LLVM-14.
 tier2_semantic.py Layer D: _qis_exec_records (qir_bc -> qir_to_qis ->
 selene_sim.build(BitcodeString) -> run_shots(Stim)) +
 test_tier2_executable_differential. Deterministic representatives execute to
 EXACT known classical records (empirically pinned; B2 _generate_results
 records ALL declared CRegs, declaration order, packed LSB-first): set_int
 [11], zero_init_safety [0,0], multi_creg [2,1], conditional_correction [0].
 bell preserves entanglement correlation (every shot record in {0b00,0b11},
 verified across seeds 1/2/7/42/123 -- only 0/3, never 1/2; H/CX present).
 Clean cross-path differential vs the dual-reviewed AST->Guppy->Selene oracle
 for conditional_correction (set_int/multi_creg excluded -- Guppy wrapper
 can't return a set(int) CReg, the documented Layer-C limit; zero_init
 declared!=returned). Slow-marked; slr_tests 372/0-fail; ruff/black canonical
 clean. Pending #77 dual review.

---
 .../slr_tests/ast_guppy/tier2_semantic.py     | 85 +++++++++++++++++++
 1 file changed, 85 insertions(+)

diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
index 3b4b7ee69..e57d33ef5 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
@@ -61,6 +61,7 @@
 
 import pytest
 import qir_qis
+import selene_sim
 from pecos.slr import CReg, For, If, Main, Print, QReg, Return, SlrConverter, While
 from pecos.slr.ast.codegen.qir import AstToQir
 from pecos.slr.ast.nodes import VarExpr
@@ -389,6 +390,90 @@ def test_varexpr_raises_loud() -> None:
         AstToQir()._eval_expression(VarExpr(name="x"))  # noqa: SLF001
 
 
+def _qis_exec_records(prog: Main, n_qubits: int, *, shots: int = _SHOTS, seed: int = _SEED) -> list[list[int]]:
+    """#77 Layer D -- the real EXECUTABLE differential.
+
+    `AST QIR -> qir_qis.qir_to_qis` (LLVM-21 QIS bitcode) ->
+    `selene_sim.build` (selene ingests it natively via
+    `selene_helios_qis_plugin`; the long-claimed "blocked on an LLVM
+    14<->21 bridge" was false) -> run on Stim. Returns per-shot lists
+    of the recorded `__quantum__rt__int_record_output` *values*, in
+    call order == CReg *declaration* order (B2 `_generate_results`
+    records every declared CReg; the QIS tag is empty post-qir_to_qis
+    so order is the key). This is the executable proof that the B2
+    QIR, lowered by the real Quantinuum compiler and run, computes
+    the correct classical results -- upgrading A+B+C to A+B+C+D.
+    """
+    qis = qir_qis.qir_to_qis(SlrConverter(prog).qir_bc())
+    inst = selene_sim.build(selene_sim.BitcodeString(qis))
+    shots_out = inst.run_shots(selene_sim.Stim(random_seed=seed), n_qubits=n_qubits, n_shots=shots)
+    return [[value for (_tag, value) in shot] for shot in shots_out]
+
+
+@pytest.mark.slow
+def test_tier2_executable_differential() -> None:
+    """#77: deterministic representative programs must EXECUTE through
+    QIR -> qir_to_qis -> QIS -> selene to the exact known classical
+    record (records are all declared CRegs, declaration order, packed
+    LSB-first -- empirically pinned). Oracle-independent: this is the
+    real executable equivalence the #71/B2 saga substituted A+B+C for.
+    """
+    cases: list[tuple[str, Main, int, list[int]]] = [
+        # c.set(0b1011); Return(c) -> [11] every shot
+        ("extra.set_int", _set_int(), 1, [0b1011]),
+        # decl(c,d); If(c[0]) before any write reads zero-init 0 -> X
+        # not applied; Measure |0> -> d=0. Records [c, d] = [0, 0].
+        ("extra.zero_init_safety", _zero_init_safety(), 1, [0, 0]),
+        # a.set(0b10)=2; X q0 -> b0=1,b1=0 -> b=0b01=1. Decl order
+        # [a, b] -> [2, 1].
+        ("extra.multi_creg", _multi_creg(), 2, [2, 1]),
+        # |0> measured -> c0=0; If(c0) not taken; |0> -> c1=0 -> [0]
+        ("v1.conditional_correction", _case("v1.conditional_correction"), 2, [0]),
+    ]
+    failures: list[str] = []
+    for label, prog, n_qubits, expected in cases:
+        recs = _qis_exec_records(prog, n_qubits)
+        if all(shot == expected for shot in recs):
+            print(f"[D OK]   {label} -> {expected} x{len(recs)}")
+        else:
+            failures.append(f"{label}: QIS-exec {recs} != expected {expected} (all shots)")
+            print(f"[D FAIL] {failures[-1]}")
+
+    # Bell: genuinely quantum -> not a fixed value, but the QIS
+    # execution must preserve the entanglement correlation: every shot
+    # records c[0]==c[1], i.e. packed in {0b00, 0b11}. Verified across
+    # seeds (only 0/3 ever appear -- never 1/2). Property assertion,
+    # not shot-equality (selene-QIS-Stim and the Guppy oracle use
+    # different RNG plumbing; both independently satisfy this).
+    bell = _case("v1.bell")
+    bell_recs = _qis_exec_records(bell, 2)
+    if all(len(s) == 1 and s[0] in (0b00, 0b11) for s in bell_recs):
+        print(f"[D OK]   v1.bell (correlation: all shots in {{0,3}}) {bell_recs}")
+    else:
+        failures.append(f"v1.bell: not Bell-correlated (expect each shot in {{0,3}}): {bell_recs}")
+        print(f"[D FAIL] {failures[-1]}")
+
+    # Cross-path executable differential vs the dual-reviewed
+    # AST->Guppy->Selene oracle. Only `v1.conditional_correction`
+    # qualifies cleanly: single declared CReg that is also the
+    # returned one (QIS-records-all-declared == oracle-records-returned)
+    # AND Guppy-supported. (`set_int`/`multi_creg` use `c.set(int)`,
+    # which the AST->Guppy return wrapper cannot return -- the same
+    # Layer-C limitation; `zero_init` declares != returns. Those are
+    # covered by the exact known-record checks above, which are
+    # themselves the executable proof for those shapes.)
+    cc = _case("v1.conditional_correction")
+    qis_vals = [shot[0] for shot in _qis_exec_records(cc, 2)]
+    oracle_vals = [_creg_int(rec, 2) for rec in run_ast_guppy_via_selene(cc, shots=_SHOTS, seed=_SEED)]
+    if qis_vals == oracle_vals:
+        print(f"[D~oracle OK] v1.conditional_correction: QIS-exec == Guppy-oracle == {qis_vals}")
+    else:
+        failures.append(f"v1.conditional_correction: QIS-exec {qis_vals} != Guppy-oracle {oracle_vals}")
+        print(f"[D~oracle FAIL] {failures[-1]}")
+
+    assert not failures, "#77 executable differential failures:\n" + "\n".join(failures)
+
+
 @pytest.mark.slow
 def test_tier2_semantic_b2() -> None:
     """Pytest entry (slow: builds the Selene runtime)."""

From 92961d740f1d916b0f617481f5be651d8c4e5edc Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sun, 17 May 2026 17:54:58 -0600
Subject: [PATCH 088/136] #77 dual-review fold (Codex blocker + 2 non-blocking;
 Pickle YES). BLOCKER: the Bell executable check `all shots in {0,3}` was
 necessary-not-sufficient -- a dropped-H/dropped-CX/no-op Bell yields all-0
 (subset of {0,3}) and would have passed, so the test could not catch the
 miscompile it guards. Fix: aggregate over fixed seeds (1,2,7,42) and require
 observed set == {0b00,0b11} (BOTH 00 and 11 must occur -> entanglement
 actually executed; 1/2 still rejected -> correlation) + single-record
 well-formedness. Non-blocking: (a) flipped the now-self-contradictory module
 docstring ("qir_to_qis->Selene blocked by LLVM 14<->21") to the truth --
 Layer D selene_helios_qis_plugin runs LLVM-21 QIS, no PECOS LLVM work; framed
 as a *representative* (not exhaustive) differential; (b) registered the
 `slow` marker in slr_tests/pytest.ini (was commented under --strict-markers
 -> PytestUnknownMarkWarning; now clean). Verified: test 1 passed (4
 deterministic exact + bell both-00/11-over-4-seeds + cond_corr cross-path),
 no marker warning, slr_tests 372/0-fail, ruff/black canonical clean. Pickle
 already YES; Codex re-confirm pending (blocker fix + docstring were its exact
 sign-off conditions).

---
 .../slr_tests/ast_guppy/tier2_semantic.py     | 52 ++++++++++++-------
 .../quantum-pecos/tests/slr_tests/pytest.ini  |  2 +-
 2 files changed, 35 insertions(+), 19 deletions(-)

diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
index e57d33ef5..3c82e1719 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
@@ -39,14 +39,21 @@
      deterministic sibling lowering (proven structurally in B) of the
      same AST whose classical semantics C executes.
 
-**Why not a direct qir_to_qis->Selene differential:** `qir_to_qis`
-emits **LLVM-21 opaque-pointer** QIS bitcode; PECOS's Selene QIS
-runtime (`crates/pecos-qis`) is **LLVM-14 typed-pointer** with the
-`___`-prefixed Selene QIS intrinsic convention. The two "QIS" forms
-are incompatible LLVM versions/dialects; no LLVM-21 disassembler is
-available and bridging LLVM-21 opaque -> LLVM-14 typed is a separate
-infra project, out of B2 scope (tracked as a blocked task). A+B+C
-together bound B2 correctness without that bridge.
+  D. **Executable differential (#77).** `selene_sim` natively
+     executes `qir_qis.qir_to_qis`'s LLVM-21 opaque-pointer QIS
+     bitcode via the bundled `selene_helios_qis_plugin` (+ Helios
+     QIR runtime) -- `selene_sim.build(BitcodeString(...)) ->
+     run_shots(Stim)`. So the direct `qir_to_qis -> Selene`
+     differential the #71/B2 saga long claimed "blocked" (an
+     alleged LLVM 14<->21 / opaque-vs-typed bridge) is in fact
+     available with zero PECOS LLVM work: PECOS-Rust stays LLVM-14;
+     the LLVM-21 capability lives entirely in the qir-qis +
+     selene_sim *Python* deps. Layer D
+     (`test_tier2_executable_differential`) lands the
+     **representative** executable differential (deterministic
+     programs to exact records; Bell by entanglement-correlation
+     property; one clean cross-path vs the AST->Guppy->Selene
+     oracle) -- not an exhaustive proof, the representative shapes.
 
 Run standalone: `uv run python -m pytest <thisfile> -q` or
 `uv run python .../tier2_semantic.py`. The pytest entry is marked
@@ -439,18 +446,27 @@ def test_tier2_executable_differential() -> None:
             failures.append(f"{label}: QIS-exec {recs} != expected {expected} (all shots)")
             print(f"[D FAIL] {failures[-1]}")
 
-    # Bell: genuinely quantum -> not a fixed value, but the QIS
-    # execution must preserve the entanglement correlation: every shot
-    # records c[0]==c[1], i.e. packed in {0b00, 0b11}. Verified across
-    # seeds (only 0/3 ever appear -- never 1/2). Property assertion,
-    # not shot-equality (selene-QIS-Stim and the Guppy oracle use
-    # different RNG plumbing; both independently satisfy this).
+    # Bell: genuinely quantum -> property check, not a fixed value.
+    # NECESSARY: every shot records c[0]==c[1] (single record, packed
+    # in {0b00, 0b11}, never 1/2) -- a broken/decorrelating CX trips
+    # this. SUFFICIENT (Codex #77 blocker): the aggregate over fixed
+    # seeds must contain BOTH 0b00 AND 0b11 -- a dropped H / dropped
+    # CX / no-op Bell lowering yields all-0, which a subset-only check
+    # (`in {0,3}`) would wrongly pass. Fixed seeds -> deterministic;
+    # 1/2/7/42 were verified to jointly span both outcomes.
     bell = _case("v1.bell")
-    bell_recs = _qis_exec_records(bell, 2)
-    if all(len(s) == 1 and s[0] in (0b00, 0b11) for s in bell_recs):
-        print(f"[D OK]   v1.bell (correlation: all shots in {{0,3}}) {bell_recs}")
+    bell_seeds = (1, 2, 7, 42)
+    bell_recs = {seed: _qis_exec_records(bell, 2, seed=seed) for seed in bell_seeds}
+    well_formed = all(len(shot) == 1 for recs in bell_recs.values() for shot in recs)
+    observed = {shot[0] for recs in bell_recs.values() for shot in recs if len(shot) == 1}
+    if well_formed and observed == {0b00, 0b11}:
+        print(f"[D OK]   v1.bell (c[0]==c[1] always; both 00 & 11 occur over seeds {bell_seeds})")
     else:
-        failures.append(f"v1.bell: not Bell-correlated (expect each shot in {{0,3}}): {bell_recs}")
+        failures.append(
+            f"v1.bell: require each shot a single record in {{0,3}} AND both 0 & 3 "
+            f"to occur across seeds {bell_seeds} (catches dropped H/CX -> all-0); "
+            f"observed={sorted(observed)} well_formed={well_formed} recs={bell_recs}",
+        )
         print(f"[D FAIL] {failures[-1]}")
 
     # Cross-path executable differential vs the dual-reviewed
diff --git a/python/quantum-pecos/tests/slr_tests/pytest.ini b/python/quantum-pecos/tests/slr_tests/pytest.ini
index 854bc91f0..313109a4d 100644
--- a/python/quantum-pecos/tests/slr_tests/pytest.ini
+++ b/python/quantum-pecos/tests/slr_tests/pytest.ini
@@ -9,7 +9,7 @@ addopts =
 
 testpaths = .
 markers =
-    # slow: mark test as slow.
+    slow: mark tests that provide extra integration coverage but are excluded from the default fast Python test lane
     optional_dependency: mark a test as using one or more optional dependencies.
     optional_unix: mark tests as using an optional dependency that only work with Unix-based systems.
 

From 10cf23e1a6dcc4031556c7ded91fa5385af3c22f Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sun, 17 May 2026 19:18:19 -0600
Subject: [PATCH 089/136] #80: fail loud on the 2 QIR silent-miscompile bugs
 #79 pre-review surfaced (inline/Return-only CReg lost its record; non-Z Prep
 basis dropped), re-pin #71 gate from actual _qir_state (3 programs
 QIS_OK->BUILD_FAILED)

qir.py: _require_creg() helper raises NotImplementedError at the 4 unknown-CReg silent-skip sites (_process_measure, _process_assign x2, _eval_expression BitExpr -- the last a #74-class silent Constant(0)). converter.py::_convert_prep: non-Z Prep basis raises at the shared root so QIR/Stim/QC/QASM all reject it (mirrors the Guppy Z/+Z preflight; Guppy/HUGR route unchanged -- its SLR-preflight runs pre-conversion). test_qir_spec_compliance.py: pins + docstring counts (build-fail 3->6, QIS_OK n->23) + resolved-#77 narrative. tier2_semantic.py: 2 regression tests. Verified: focused 3/0, broad 258/0, ruff/black clean.
---
 .../src/pecos/slr/ast/codegen/qir.py          | 54 ++++++++++++------
 .../src/pecos/slr/ast/converter.py            | 17 ++++++
 .../ast_guppy/test_qir_spec_compliance.py     | 55 ++++++++++++++-----
 .../slr_tests/ast_guppy/tier2_semantic.py     | 32 +++++++++++
 4 files changed, 127 insertions(+), 31 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
index 9eb1c8dd3..3bdb391a3 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
@@ -482,6 +482,31 @@ def _get_qubit_ptr(self, target: SlotRef) -> Any:
             self._types["qubit_ptr"],
         )
 
+    def _require_creg(self, reg_name: str) -> None:
+        """Fail LOUD if `reg_name` has no entry-block CReg storage.
+
+        Only CRegs declared at Main scope (`program.declarations`)
+        get an `alloca [N x i1]` in `_process_declarations`. An
+        inline / local-scope CReg -- e.g. one created in a block and
+        only surfaced via `Return(creg)` -- has no storage, so every
+        measure/assign/read against it used to be SILENTLY skipped
+        (the store dropped, a read folded to constant 0) and the
+        explicit returned value vanished from the QIS records (the
+        `docs.inline_measure_creg` defect #79 surfaced). Mirror the
+        #74/#78 doctrine: a silent miscompile must become a loud
+        `NotImplementedError`, not a buried wrong answer.
+        """
+        if reg_name not in self._creg_ptrs:
+            msg = (
+                f"QIR codegen: classical register {reg_name!r} is "
+                "used/measured/returned but was not declared at Main "
+                "scope, so it has no QIR storage. Inline / local-scope "
+                "CRegs are not supported by the QIR backend (their "
+                "values would be silently dropped from the recorded "
+                f"output). Declare {reg_name!r} in Main(...)."
+            )
+            raise NotImplementedError(msg)
+
     def _creg_bit_ptr(self, reg_name: str, index: int) -> Any:
         """`getelementptr [N x i1], [N x i1]* %creg, i64 0, i64 index`.
 
@@ -532,16 +557,16 @@ def _process_measure(self, node: MeasureOp) -> None:
 
             if i < len(node.results):
                 result = node.results[i]
-                if result.register in self._creg_ptrs:
-                    bit = self._builder.call(
-                        self._read_result,
-                        [result_ptr],
-                        name="",
-                    )
-                    self._builder.store(
-                        self._creg_bit_ptr(result.register, result.index),
-                        bit,
-                    )
+                self._require_creg(result.register)
+                bit = self._builder.call(
+                    self._read_result,
+                    [result_ptr],
+                    name="",
+                )
+                self._builder.store(
+                    self._creg_bit_ptr(result.register, result.index),
+                    bit,
+                )
 
     def _process_prepare(self, node: PrepareOp) -> None:
         """Process a prepare/reset operation."""
@@ -584,8 +609,7 @@ def _process_assign(self, node: AssignOp) -> None:
         """Process an assignment operation."""
         if isinstance(node.target, BitRef):
             reg_name = node.target.register
-            if reg_name not in self._creg_ptrs:
-                return
+            self._require_creg(reg_name)
             rhs = self._as_i1(self._eval_expression(node.value))
             self._builder.store(
                 self._creg_bit_ptr(reg_name, node.target.index),
@@ -595,8 +619,7 @@ def _process_assign(self, node: AssignOp) -> None:
             # Whole-CReg `c.set(int)` (converter.py:928/930 -> target=str).
             # Unpack the i64 value bit-by-bit into the buffer.
             reg_name = node.target
-            if reg_name not in self._creg_ptrs:
-                return
+            self._require_creg(reg_name)
             size = self.context.creg_map.get(reg_name, 0)
             val = self._as_i64(self._eval_expression(node.value))
             for i in range(size):
@@ -622,8 +645,7 @@ def _eval_expression(self, expr: Expression) -> Any:
 
         if isinstance(expr, BitExpr):
             reg_name = expr.ref.register
-            if reg_name not in self._creg_ptrs:
-                return llvm_ir.Constant(self._types["int"], 0)
+            self._require_creg(reg_name)
             # `load i1, gep c[i]` then `zext -> i64` (canonical width).
             bit = self._builder.load(
                 self._creg_bit_ptr(reg_name, expr.ref.index),
diff --git a/python/quantum-pecos/src/pecos/slr/ast/converter.py b/python/quantum-pecos/src/pecos/slr/ast/converter.py
index 788a44863..e9fc77962 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/converter.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/converter.py
@@ -663,6 +663,23 @@ def _convert_prep(self, gate: Any) -> Statement:
             msg = "Prep gate has no qubit arguments"
             raise ValueError(msg)
 
+        # Non-Z Prep basis is silently dropped by `_expand_qubit_args`
+        # (it skips string args), which made every AST codegen
+        # (QIR/Stim/QC/QASM) silently lower `Prep(q, "X")` as a plain
+        # Z-reset -- a miscompile. Fail LOUD at the shared converter
+        # root (the AST->Guppy path already rejects this at preflight
+        # with the same Z/+Z rule; #80 / #79 pre-review). The AST
+        # represents only Z-basis Prep; non-Z basis prep is v2-defer.
+        for arg in gate.qargs:
+            if isinstance(arg, str) and arg.strip().upper() not in {"Z", "+Z"}:
+                msg = (
+                    f"AST conversion: non-Z Prep basis {arg!r} is not supported "
+                    "(the AST codegens represent only Z-basis Prep; a non-Z "
+                    "basis would be silently lowered as a Z reset -- a "
+                    "miscompile). Use `Prep(q); H(q)` for X-basis prep."
+                )
+                raise NotImplementedError(msg)
+
         # Expand full registers into individual qubits
         expanded_qargs = self._expand_qubit_args(gate.qargs)
 
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
index 6db53a7f4..9b76a0707 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
@@ -39,7 +39,7 @@
 `mz__body` -> static `%Result*` -> `read_result` -> `store`;
 point-of-use `gep`+`load`/`store`; `zext`/`shl`/`or` pack ->
 `__quantum__rt__int_record_output`). Every validate-passing program
-(`_EXPECTED_QIS_OK`, n=26) now lowers via `qir_to_qis`; `qis_failed`
+(`_EXPECTED_QIS_OK`, n=23) now lowers via `qir_to_qis`; `qis_failed`
 is empty. A NEW qir_to_qis failure -- or a dropped program -- trips
 this deliberately. (`docs.while_loop` was in this set pre-#74 on a
 silently-wrong single-pass approximation; #74 makes the QIR backend
@@ -48,22 +48,31 @@
 The deeper *semantic* proof for the load-bearing CReg shapes is
 `tier2_semantic.py` (real-compiler acceptance + emitted-QIR
 structural invariants + a deterministic AST->Guppy->Selene
-cross-anchor). A direct `qir_to_qis`->Selene differential is
-blocked by an LLVM-version/dialect gap (qir-qis emits LLVM-21
-opaque-pointer QIS bitcode; PECOS's Selene QIS runtime is LLVM-14
-typed-pointer) -- tracked as a separate blocked task; this gate
-stays structural.
+cross-anchor). The direct `qir_to_qis`->Selene EXECUTABLE
+differential is delivered (#77 Layer D `_qis_exec_records` in
+`tier2_semantic.py`): `selene_sim` natively runs the LLVM-21
+opaque-pointer QIS bitcode `qir_to_qis` emits, via
+`selene_helios_qis_plugin` -- there is no LLVM-version blocker.
+#79 generalises it corpus-wide; this structural gate provides
+that suite's authoritative QIS_OK set.
 
-**Build failures** (3): `qir_bc()` raises for
+**Build failures** (6): `qir_bc()` raises for
 `docs.for_loopvar_symbolic` (symbolic `LoopVar` indexing) /
 `docs.rotation_rx` (`rx` gate) -- pre-existing AST-QIR feature
-gaps -- and `docs.while_loop` (#74: the QIR backend now fails
-LOUD on `While` instead of silently emitting a one-pass
+gaps; `docs.while_loop` (#74: the QIR backend now fails LOUD
+on `While` instead of silently emitting a one-pass
 approximation that qir-qis cannot catch; this aligns the QIR
 path with the Guppy path, which already rejects `While` per
 v1-feature-matrix "real While is out of scope for the sound
-emitter"). Identity pinned (`_EXPECTED_BUILD_FAILED`) so a NEW
-build regression trips here. (`qeclib.steane_pz` was a pinned
+emitter"); and `docs.inline_measure_creg` /
+`docs.prep_basis_x` / `docs.surface_syndrome_block18` (#80:
+the two QIR silent-miscompile defects #79's dual pre-review
+surfaced -- an inline/`Return`-only CReg that got no storage
+so its value vanished from the records, and a non-Z `Prep`
+basis the converter silently dropped so it lowered as a plain
+Z reset -- are now FAIL-LOUD, mirroring #74/#78). Identity
+pinned (`_EXPECTED_BUILD_FAILED`) so a NEW build regression
+trips here. (`qeclib.steane_pz` was a pinned
 build failure pre-B2 -- the bespoke model emitted invalid bitcode
 for it; B2 produces valid bitcode so it now builds and moves to
 the pinned validate set above. A deliberate, triaged improvement.)
@@ -97,6 +106,25 @@
     # which already rejects `While` (v1-feature-matrix: real While is
     # out of scope for the sound emitter).
     "docs.while_loop": ("NotImplementedError", "does not support While loops"),
+    # #80: the two QIR silent-miscompile defects #79's dual pre-review
+    # surfaced are now FAIL-LOUD; the 3 affected corpus programs moved
+    # QIS_OK -> here DELIBERATELY (the #74/#78 doctrine: a silent
+    # miscompile qir-qis cannot catch must raise, not bury a wrong
+    # answer). Was previously "QIS_OK" but the emitted QIS was a
+    # miscompile, not a validation -- exactly what #79 must not call
+    # validated.
+    #  - inline_measure_creg: `final` is only `Return`ed, never
+    #    declared at Main scope, so it got no `alloca [N x i1]`; the
+    #    measure-store was silently skipped and the explicit returned
+    #    value vanished from the QIS records (QIS recorded `[]`).
+    #  - prep_basis_x / surface_syndrome_block18: contain
+    #    `Prep(q, "X")`; the converter dropped the basis string and
+    #    every AST codegen lowered it as a plain Z reset. Fixed at the
+    #    shared converter root, matching the AST->Guppy path which
+    #    already rejects non-Z Prep at preflight.
+    "docs.inline_measure_creg": ("NotImplementedError", "was not declared at Main scope"),
+    "docs.prep_basis_x": ("NotImplementedError", "non-Z Prep basis"),
+    "docs.surface_syndrome_block18": ("NotImplementedError", "non-Z Prep basis"),
 }
 
 # Tier 1: the non-metadata `validate_qir` failures (label -> stable,
@@ -117,17 +145,14 @@
 
 # Tier 2: post-B2, EVERY validate-passing program lowers via
 # `qir_to_qis` (M-B2-static replaced the bespoke CReg helpers).
-# This is the full set (n=27); `qis_failed` must be empty. A new
+# This is the full set (n=23); `qis_failed` must be empty. A new
 # qir_to_qis failure -- or a dropped/added program -- trips the
 # Tier-2 assertions and must be triaged deliberately.
 _EXPECTED_QIS_OK: frozenset[str] = frozenset(
     {
         "docs.flat_parallel_h_gates",
         "docs.for_static_indexing",
-        "docs.inline_measure_creg",
-        "docs.prep_basis_x",
         "docs.repeat_state_preserving",
-        "docs.surface_syndrome_block18",
         "examples.measure_register_to_creg",
         "examples.parallel_bell_pairs",
         "examples.surface_d3_x_1round",
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
index 3c82e1719..af5bf07a5 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
@@ -397,6 +397,38 @@ def test_varexpr_raises_loud() -> None:
         AstToQir()._eval_expression(VarExpr(name="x"))  # noqa: SLF001
 
 
+def test_inline_returned_creg_raises_loud() -> None:
+    """#80: a CReg that is measured/returned but NOT declared at Main
+    scope must FAIL LOUD. Only Main-scope CRegs get an entry-block
+    `alloca [N x i1]`; an inline/local CReg surfaced only via
+    `Return(creg)` had no storage, so the measure-store was SILENTLY
+    skipped and the explicit returned value vanished from the QIS
+    records (the `docs.inline_measure_creg` defect #79 surfaced --
+    QIS recorded `[]` for an explicit `Return(final)`). Mirrors the
+    #74/#78 doctrine: silent miscompile -> loud NotImplementedError."""
+    final = CReg("final", 2)
+    prog = Main(q := QReg("q", 2), Measure(q) > final, Return(final))
+    with pytest.raises(NotImplementedError, match=r"classical register 'final'.*not.*declared at Main scope"):
+        SlrConverter(prog).qir_bc()
+
+
+def test_non_z_prep_basis_raises_loud() -> None:
+    """#80: a non-Z `Prep` basis must FAIL LOUD at AST conversion.
+    `_expand_qubit_args` silently dropped the basis string, so every
+    AST codegen (QIR/Stim/QC/QASM) lowered `Prep(q, "X")` as a plain
+    Z reset -- a miscompile (#79 surfaced `docs.prep_basis_x` /
+    `docs.surface_syndrome_block18` recording a deterministic 0). The
+    AST->Guppy path already rejects this at preflight with the same
+    Z/+Z rule; fix at the shared converter root so all AST codegens
+    agree. Z / +Z (case-insensitive) stays allowed."""
+    ok = Main(q := QReg("q", 1), c := CReg("c", 1), qb.Prep(q[0], "Z"), Measure(q) > c, Return(c))
+    SlrConverter(ok).qir_bc()  # explicit Z is fine (boundary)
+
+    over = Main(q := QReg("q", 1), c := CReg("c", 1), qb.Prep(q[0], "X"), Measure(q) > c, Return(c))
+    with pytest.raises(NotImplementedError, match=r"non-Z Prep basis 'X' is not supported"):
+        SlrConverter(over).qir_bc()
+
+
 def _qis_exec_records(prog: Main, n_qubits: int, *, shots: int = _SHOTS, seed: int = _SEED) -> list[list[int]]:
     """#77 Layer D -- the real EXECUTABLE differential.
 

From 259e06661ab0db15c4c01afc4b6610a7ed0deacc Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sun, 17 May 2026 19:57:28 -0600
Subject: [PATCH 090/136] #80 dual-review fold: fix Codex blocker (Return-only
 inline CReg silently emitted no record -- _process_return now validates
 returned classical regs, qubit returns not false-rejected) + make the
 _eval_expression unknown-type default fail loud (same #74/#80 class, Codex
 non-blocking) + regression test; fix Pickle's surfaced doc-test by rewriting
 the 3 slr-qeclib.md Prep(q,"X") sites to the v1 Prep;H idiom (generated/ is
 gitignored). Verified: focused 5/0, doc-tests 22/0, ast_guppy 258/0,
 ruff/black/blackdoc clean

---
 docs/development/slr-qeclib.md                | 13 +++---
 .../src/pecos/slr/ast/codegen/qir.py          | 41 ++++++++++++++++++-
 .../slr_tests/ast_guppy/tier2_semantic.py     | 25 +++++++++++
 3 files changed, 73 insertions(+), 6 deletions(-)

diff --git a/docs/development/slr-qeclib.md b/docs/development/slr-qeclib.md
index 6e4603e3f..5c090931b 100644
--- a/docs/development/slr-qeclib.md
+++ b/docs/development/slr-qeclib.md
@@ -99,8 +99,10 @@ prog = Main(
     Block(
         qb.Prep(q[0], "Z"),
         qb.Prep(q[1], "Z"),
-        qb.Prep(q[2], "X"),
-        qb.Prep(q[3], "X"),
+        qb.Prep(q[2]),
+        qb.H(q[2]),  # |+> (X-basis prep = Prep then H)
+        qb.Prep(q[3]),
+        qb.H(q[3]),  # |+>
     ),
     # Entanglement block
     Block(
@@ -251,7 +253,8 @@ prog = Main(
     # Measurements and preparations
     qb.Measure(q[0]) > c[0],
     qb.Prep(q[0], "Z"),  # Prepare |0>
-    qb.Prep(q[0], "X"),  # Prepare |+>
+    qb.Prep(q[0]),
+    qb.H(q[0]),  # Prepare |+> (X-basis prep = Prep then H)
 )
 ```
 
@@ -432,8 +435,8 @@ def surface_code_syndrome(d: int):
         Block(*[qb.Prep(data[i], "Z") for i in range(num_data)]),
         # X stabilizer measurement (simplified)
         Block(
-            qb.Prep(ancilla[0], "X"),  # Prepare |+>
-            qb.H(ancilla[0]),
+            qb.Prep(ancilla[0]),
+            qb.H(ancilla[0]),  # Prepare |+> (X-basis prep = Prep then H)
             qb.CX(ancilla[0], data[0]),
             qb.CX(ancilla[0], data[1]),
             qb.H(ancilla[0]),
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
index 3bdb391a3..6bbae0146 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
@@ -50,6 +50,7 @@
     PrintOp,
     RegisterDecl,
     RepeatStmt,
+    ReturnOp,
     SlotRef,
     UnaryExpr,
     UnaryOp,
@@ -386,6 +387,8 @@ def _process_statement(self, stmt: Statement) -> None:
             self._process_parallel(stmt)
         elif isinstance(stmt, PermuteOp):
             self._process_permute(stmt)
+        elif isinstance(stmt, ReturnOp):
+            self._process_return(stmt)
         elif isinstance(stmt, PrintOp):
             # Classical-output streaming (`Print` -> Guppy `result(...)`)
             # is unimplemented in the QIR backend. Silently dropping it
@@ -397,6 +400,32 @@ def _process_statement(self, stmt: Statement) -> None:
             )
             raise NotImplementedError(msg)
 
+    def _process_return(self, node: ReturnOp) -> None:
+        """Validate that returned CLASSICAL registers have QIR storage.
+
+        `_generate_results` records every Main-declared CReg, but a
+        CReg surfaced ONLY via `Return(creg)` (never measured /
+        assigned / read) reaches no other `_require_creg` site, so
+        an inline / local-scope returned CReg produced ZERO recorded
+        output for an explicit `Return` -- the build succeeded and
+        validated, the program just silently returned nothing
+        (Codex #80 post-review blocker; same silent-output-loss
+        class as the four point-of-use sites). Qubit returns are
+        intentionally ignored by the QIR backend (it records no
+        classical output for them) -- only classical returns are
+        validated, so a `Return(qreg)` is not false-rejected.
+        """
+        qreg_names = {name for name, _ in self.context.qubit_map}
+        for value in node.values:
+            if isinstance(value, str):
+                if value in qreg_names:
+                    continue
+                self._require_creg(value)
+            elif isinstance(value, BitRef):
+                self._require_creg(value.register)
+            elif isinstance(value, BitExpr):
+                self._require_creg(value.ref.register)
+
     def _process_gate(self, node: GateOp) -> None:
         """Process a gate operation."""
         qir_name = GATE_TO_QIR.get(node.gate)
@@ -679,7 +708,17 @@ def _eval_expression(self, expr: Expression) -> Any:
                 return self._builder.not_(operand)
             return operand
 
-        return llvm_ir.Constant(self._types["int"], 0)
+        # Any unhandled expression type silently evaluating to constant
+        # 0 is a value miscompile qir-qis cannot catch (the #74 / #80
+        # fail-loud class -- same smell as the VarExpr arm above). Every
+        # currently-reachable type is handled above; a new/unhandled one
+        # must fail LOUD, not lower as 0.
+        msg = (
+            f"QIR codegen: unsupported classical expression "
+            f"{type(expr).__name__} (it must not be silently evaluated "
+            "as 0 -- that would be a value miscompile)."
+        )
+        raise NotImplementedError(msg)
 
     def _process_if(self, node: IfStmt) -> None:
         """Process an if statement."""
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
index af5bf07a5..1117e9d06 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
@@ -429,6 +429,31 @@ def test_non_z_prep_basis_raises_loud() -> None:
         SlrConverter(over).qir_bc()
 
 
+def test_return_only_inline_creg_raises_loud() -> None:
+    """#80 (Codex post-review blocker): a CReg surfaced ONLY via
+    `Return(creg)` -- never measured/assigned/read -- reached no
+    point-of-use `_require_creg` site, so `_generate_results` (which
+    records only Main-declared CRegs) emitted ZERO recorded output
+    for an explicit `Return`. The build succeeded and validated; the
+    program silently returned nothing. `_process_return` now
+    validates returned classical registers too. (The
+    measure-then-return case is `test_inline_returned_creg_raises_loud`;
+    this is the no-other-use bypass it did not cover.) A qubit return
+    must NOT be false-rejected (QIR records no classical output for
+    it)."""
+    ret_only = CReg("ret_only", 1)
+    prog = Main(q := QReg("q", 1), Return(ret_only))
+    with pytest.raises(NotImplementedError, match=r"classical register 'ret_only'.*not.*declared at Main scope"):
+        SlrConverter(prog).qir_bc()
+
+    # A declared CReg returned (no other use) is fine; a bare qubit
+    # return must not trip the classical-storage check.
+    ok = Main(q := QReg("q", 1), c := CReg("c", 1), Return(c))
+    SlrConverter(ok).qir_bc()
+    ok_q = Main(q := QReg("q", 1), Return(q))
+    SlrConverter(ok_q).qir_bc()
+
+
 def _qis_exec_records(prog: Main, n_qubits: int, *, shots: int = _SHOTS, seed: int = _SEED) -> list[list[int]]:
     """#77 Layer D -- the real EXECUTABLE differential.
 

From 62ac7609fbd45cbed5bf79a3ad26ff6dacdc7be0 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sun, 17 May 2026 22:14:03 -0600
Subject: [PATCH 091/136] #80 Codex re-confirm-1 fold: fix the Return-only
 inline-CReg name-collision bypass at the root (provenance, not
 name-guessing). _process_return skipped qubit returns by qubit_map
 name-membership, but _convert_return had erased QReg/CReg provenance (var.sym
 flatten), so an inline CReg colliding with a declared QReg name was silently
 dropped (same silent-output-loss class, public-SLR-reachable). Fix: additive
 ReturnOp.value_kinds populated from the real QReg/CReg object in
 _convert_return, preserved through _block_substitution, consumed by
 qir._process_return; unsound qubit_map name-skip removed. Guppy unaffected
 (reads .values). Collision regression test added. Verified: focused 5/0 (incl
 NAME_COLLISION raises, qreg_return builds), broad 258/0, doc-tests 22/0,
 ruff/black clean

---
 .../src/pecos/slr/ast/_block_substitution.py  |  6 +++++
 .../src/pecos/slr/ast/codegen/qir.py          | 27 +++++++++++++------
 .../src/pecos/slr/ast/converter.py            | 23 +++++++++++++---
 .../quantum-pecos/src/pecos/slr/ast/nodes.py  | 10 +++++++
 .../slr_tests/ast_guppy/tier2_semantic.py     | 10 +++++++
 5 files changed, 65 insertions(+), 11 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/_block_substitution.py b/python/quantum-pecos/src/pecos/slr/ast/_block_substitution.py
index 9bb198f69..a3b5e88c8 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/_block_substitution.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/_block_substitution.py
@@ -242,11 +242,17 @@ def substitute_stmt(stmt: Statement, remap: BodyRemap) -> Statement:
             location=stmt.location,
         )
     if isinstance(stmt, ReturnOp):
+        # Substitution remaps names in place (1:1, order/count
+        # preserved), so the parallel `value_kinds` provenance still
+        # aligns and MUST be carried (dropping it would re-introduce
+        # the #80 CReg/QReg name-collision miscompile inside a
+        # substituted BlockCall body).
         return ReturnOp(
             values=tuple(
                 _sub_expr(v, remap) if not isinstance(v, str) else remap.whole_name(v, context="Return value")
                 for v in stmt.values
             ),
+            value_kinds=stmt.value_kinds,
             location=stmt.location,
         )
     if isinstance(stmt, PrintOp):
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
index 6bbae0146..aa24eb051 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
@@ -410,16 +410,27 @@ def _process_return(self, node: ReturnOp) -> None:
         output for an explicit `Return` -- the build succeeded and
         validated, the program just silently returned nothing
         (Codex #80 post-review blocker; same silent-output-loss
-        class as the four point-of-use sites). Qubit returns are
-        intentionally ignored by the QIR backend (it records no
-        classical output for them) -- only classical returns are
-        validated, so a `Return(qreg)` is not false-rejected.
+        class as the four point-of-use sites). Qubit returns record
+        no classical output and are skipped via per-value provenance
+        (`ReturnOp.value_kinds` from `_convert_return`), so a
+        `Return(qreg)` is not false-rejected AND a returned inline
+        CReg whose name collides with a declared QReg is still
+        validated (the Codex #80 re-confirm blocker -- a
+        name-membership skip was unsound).
         """
-        qreg_names = {name for name, _ in self.context.qubit_map}
-        for value in node.values:
+        # Provenance comes from `_convert_return` (it knows the real
+        # QReg/CReg object), NOT from a name-membership guess: a
+        # returned inline CReg can share a declared QReg's name, which
+        # a `qubit_map`-name skip silently mistook for a qubit return
+        # and dropped (Codex #80 re-confirm blocker). Unknown kind
+        # ("" -- e.g. a directly-constructed ReturnOp) falls back to
+        # "classical", the fail-loud-safe default.
+        kinds = node.value_kinds
+        for i, value in enumerate(node.values):
+            kind = kinds[i] if i < len(kinds) else "classical"
             if isinstance(value, str):
-                if value in qreg_names:
-                    continue
+                if kind == "quantum":
+                    continue  # qubit-register return: no classical record
                 self._require_creg(value)
             elif isinstance(value, BitRef):
                 self._require_creg(value.register)
diff --git a/python/quantum-pecos/src/pecos/slr/ast/converter.py b/python/quantum-pecos/src/pecos/slr/ast/converter.py
index e9fc77962..b899b6b3c 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/converter.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/converter.py
@@ -838,18 +838,35 @@ def _convert_barrier(self, op: Any) -> BarrierOp:
         return BarrierOp(allocators=allocators)
 
     def _convert_return(self, op: Any) -> ReturnOp:
-        """Convert an SLR Return to an AST ReturnOp."""
+        """Convert an SLR Return to an AST ReturnOp.
+
+        Carries per-value provenance (`value_kinds`) derived from the
+        SLR object's type. A whole-register return flattens to its
+        bare `sym` name; a returned inline CReg can collide with a
+        declared QReg of the same name, which is undecidable
+        downstream by name alone (the #80 re-confirm bug). The
+        QReg/CReg distinction is known HERE (the real object), so it
+        is preserved instead of guessed in codegen.
+        """
+        from pecos.slr.vars import QReg  # noqa: PLC0415
+
         values: list = []
+        kinds: list[str] = []
         for var in op.return_vars:
             if isinstance(var, str):
+                # Raw user-supplied name (provenance unknown); the
+                # fail-loud-safe default is "classical" so a backend
+                # validates it as a declared classical register.
                 values.append(var)
+                kinds.append("classical")
             elif hasattr(var, "sym"):
                 values.append(var.sym)
+                kinds.append("quantum" if isinstance(var, QReg) else "classical")
             else:
-                # Try to convert as expression
                 values.append(self._convert_expression(var))
+                kinds.append("expr")
 
-        return ReturnOp(values=tuple(values))
+        return ReturnOp(values=tuple(values), value_kinds=tuple(kinds))
 
     def _convert_permute(self, op: Any) -> PermuteOp:
         """Convert an SLR Permute to an AST PermuteOp."""
diff --git a/python/quantum-pecos/src/pecos/slr/ast/nodes.py b/python/quantum-pecos/src/pecos/slr/ast/nodes.py
index 1528379c9..17047e078 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/nodes.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/nodes.py
@@ -464,6 +464,16 @@ class ReturnOp(Statement):
     """Return statement."""
 
     values: tuple[Expression | str, ...] = ()  # Can be variable names
+    # Per-value provenance, parallel to `values`: "quantum" (a QReg --
+    # no classical record), "classical" (a CReg -- must be recorded),
+    # or "expr". Set by `_convert_return` from the SLR object type;
+    # `()` means unknown (e.g. a directly-constructed ReturnOp), in
+    # which case a backend treats a bare-name value as classical
+    # (the fail-loud-safe default). A bare `values` string cannot be
+    # disambiguated CReg-vs-QReg by name alone (a returned inline
+    # CReg can collide with a declared QReg name -- the #80
+    # re-confirm bug), so provenance is carried here, not guessed.
+    value_kinds: tuple[str, ...] = ()
 
     def children(self) -> Sequence[AstNode]:
         return tuple(v for v in self.values if isinstance(v, AstNode))
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
index 1117e9d06..a6eb643bb 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
@@ -453,6 +453,16 @@ def test_return_only_inline_creg_raises_loud() -> None:
     ok_q = Main(q := QReg("q", 1), Return(q))
     SlrConverter(ok_q).qir_bc()
 
+    # #80 Codex RE-CONFIRM blocker: an inline CReg whose name
+    # collides with a declared QReg was misclassified as a qubit
+    # return by the old name-membership skip and silently dropped
+    # (same silent-output-loss class, reachable via public SLR).
+    # Provenance from `_convert_return` (real QReg/CReg object) now
+    # disambiguates -> the inline CReg still fails loud.
+    collide = Main(q := QReg("q", 1), Return(CReg("q", 1)))
+    with pytest.raises(NotImplementedError, match=r"classical register 'q'.*not.*declared at Main scope"):
+        SlrConverter(collide).qir_bc()
+
 
 def _qis_exec_records(prog: Main, n_qubits: int, *, shots: int = _SHOTS, seed: int = _SEED) -> list[list[int]]:
     """#77 Layer D -- the real EXECUTABLE differential.

From f85f2ed15f92379d8ca7fa2696d7f636c6fd66f9 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sun, 17 May 2026 22:43:38 -0600
Subject: [PATCH 092/136] #81 Stage A: PrepareOp.basis discriminant + 6
 dedicated prep classes (PZ/PNZ/PX/PNX/PY/PNY) + converter _PREP_BASIS routing
 + recast stray-string guard (basis is the gate identity -- any string qarg on
 any prep gate fails loud, generalizes/supersedes #80 non-Z guard) + block-sub
 & pretty-print basis preserve + qb exports. Prep retained as PZ alias so the
 ~223 sites stay green (no churn until Stage C). #71 pins fragment -> 'stray
 string argument'. Verified: focused 4/0 (#71 gate green -- recast broke no
 QIS_OK program), broad ast_guppy 258/0, ast_tests 664/0, ruff/black clean

---
 .../src/pecos/slr/ast/_block_substitution.py  |  2 +
 .../src/pecos/slr/ast/converter.py            | 55 +++++++++++++------
 .../quantum-pecos/src/pecos/slr/ast/nodes.py  |  8 +++
 .../src/pecos/slr/ast/pretty_print.py         |  9 ++-
 .../src/pecos/slr/qeclib/qubit/__init__.py    |  8 ++-
 .../src/pecos/slr/qeclib/qubit/preps.py       | 31 ++++++++++-
 .../ast_guppy/test_qir_spec_compliance.py     | 10 +++-
 .../slr_tests/ast_guppy/tier2_semantic.py     | 35 +++++++-----
 8 files changed, 118 insertions(+), 40 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/_block_substitution.py b/python/quantum-pecos/src/pecos/slr/ast/_block_substitution.py
index a3b5e88c8..3f9066b0c 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/_block_substitution.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/_block_substitution.py
@@ -358,6 +358,7 @@ def _sub_prepare(stmt: PrepareOp, remap: BodyRemap) -> PrepareOp:
         return PrepareOp(
             allocator=remap.whole_name(stmt.allocator, context="Prepare-all"),
             slots=None,
+            basis=stmt.basis,
             location=stmt.location,
         )
     remapped = [remap.slot(SlotRef(allocator=stmt.allocator, index=i)) for i in stmt.slots]
@@ -373,6 +374,7 @@ def _sub_prepare(stmt: PrepareOp, remap: BodyRemap) -> PrepareOp:
     return PrepareOp(
         allocator=dst_alloc,
         slots=tuple(r.index for r in remapped),
+        basis=stmt.basis,
         location=stmt.location,
     )
 
diff --git a/python/quantum-pecos/src/pecos/slr/ast/converter.py b/python/quantum-pecos/src/pecos/slr/ast/converter.py
index b899b6b3c..e8552c25d 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/converter.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/converter.py
@@ -86,6 +86,19 @@
     from pecos.slr.main import Main
 
 
+# SLR prep-gate symbol -> canonical AST prep basis (#81). The basis
+# is the gate identity, not a string argument. `Prep` is the
+# deprecated |0> alias of `PZ` (hard-replaced repo-wide in Stage C).
+_PREP_BASIS: dict[str, str] = {
+    "Prep": "PZ",
+    "PZ": "PZ",
+    "PNZ": "PNZ",
+    "PX": "PX",
+    "PNX": "PNX",
+    "PY": "PY",
+    "PNY": "PNY",
+}
+
 # Mapping from SLR gate class names to AST GateKind
 GATE_KIND_MAP: dict[str, GateKind] = {
     # Single-qubit Paulis
@@ -602,9 +615,11 @@ def _convert_gate(self, gate: Any) -> Statement:
         """Convert an SLR gate to an AST GateOp, PrepareOp, or MeasureOp."""
         gate_name = gate.sym
 
-        # Handle special operations
-        if gate_name == "Prep":
-            return self._convert_prep(gate)
+        # Handle special operations. All prep gates route through one
+        # path; the basis is the GATE IDENTITY (#81), not a string
+        # arg. `Prep` is the deprecated |0> alias (== PZ).
+        if gate_name in _PREP_BASIS:
+            return self._convert_prep(gate, basis=_PREP_BASIS[gate_name])
 
         if gate_name == "Measure":
             return self._convert_measure(gate)
@@ -657,26 +672,30 @@ def _convert_gate(self, gate: Any) -> Statement:
 
         return GateOp(gate=gate_kind, targets=targets, params=params)
 
-    def _convert_prep(self, gate: Any) -> Statement:
-        """Convert an SLR Prep gate to an AST PrepareOp or flattened list."""
+    def _convert_prep(self, gate: Any, basis: str = "PZ") -> Statement:
+        """Convert an SLR prep gate to an AST PrepareOp.
+
+        `basis` is the canonical eigenstate from the gate IDENTITY
+        (#81: `PZ`/`PNZ`/`PX`/`PNX`/`PY`/`PNY`; `Prep` -> `PZ`), NOT
+        a string argument.
+        """
         if not gate.qargs:
             msg = "Prep gate has no qubit arguments"
             raise ValueError(msg)
 
-        # Non-Z Prep basis is silently dropped by `_expand_qubit_args`
-        # (it skips string args), which made every AST codegen
-        # (QIR/Stim/QC/QASM) silently lower `Prep(q, "X")` as a plain
-        # Z-reset -- a miscompile. Fail LOUD at the shared converter
-        # root (the AST->Guppy path already rejects this at preflight
-        # with the same Z/+Z rule; #80 / #79 pre-review). The AST
-        # represents only Z-basis Prep; non-Z basis prep is v2-defer.
+        # A stray STRING qarg on ANY prep gate is rejected loudly.
+        # `_expand_qubit_args` silently drops strings, so a basis
+        # string (`PZ(q, "X")`, the legacy `Prep(q, "X")`, etc.)
+        # would otherwise be silently dropped and the gate lowered as
+        # its plain basis -- a miscompile (#80 recast / #81 Codex sym
+        # rule). The prep basis is the gate identity; pass NO string.
         for arg in gate.qargs:
-            if isinstance(arg, str) and arg.strip().upper() not in {"Z", "+Z"}:
+            if isinstance(arg, str):
                 msg = (
-                    f"AST conversion: non-Z Prep basis {arg!r} is not supported "
-                    "(the AST codegens represent only Z-basis Prep; a non-Z "
-                    "basis would be silently lowered as a Z reset -- a "
-                    "miscompile). Use `Prep(q); H(q)` for X-basis prep."
+                    f"AST conversion: prep gate {gate.sym!r} got a stray "
+                    f"string argument {arg!r}. The prep basis is the gate "
+                    "identity, not an argument -- use PZ/PNZ/PX/PNX/PY/PNY "
+                    "(a string would be silently dropped -- a miscompile)."
                 )
                 raise NotImplementedError(msg)
 
@@ -697,7 +716,7 @@ def _convert_prep(self, gate: Any) -> Statement:
 
         slots = tuple(q.index for q in expanded_qargs)
 
-        return PrepareOp(allocator=allocator, slots=slots)
+        return PrepareOp(allocator=allocator, slots=slots, basis=basis)
 
     def _convert_measure(self, gate: Any) -> MeasureOp:
         """Convert an SLR Measure gate to an AST MeasureOp."""
diff --git a/python/quantum-pecos/src/pecos/slr/ast/nodes.py b/python/quantum-pecos/src/pecos/slr/ast/nodes.py
index 17047e078..d9baf19ac 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/nodes.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/nodes.py
@@ -414,6 +414,14 @@ class PrepareOp(Statement):
 
     allocator: str
     slots: tuple[int, ...] | None = None  # None means prepare_all
+    # Canonical prep basis / target eigenstate, one of
+    # {PZ,PNZ,PX,PNX,PY,PNY} (|0>,|1>,|+>,|->,|+i>,|-i>). Set by
+    # `_convert_prep` from the SLR gate symbol (PZ default). Carried
+    # on the AST so codegens lower the correct reset+Clifford tail;
+    # MUST be preserved through block substitution (else a non-PZ
+    # prep inside a BlockCall body silently reverts to PZ -- the
+    # #81-B1 soundness-critical case).
+    basis: str = "PZ"
 
 
 @dataclass(frozen=True, kw_only=True)
diff --git a/python/quantum-pecos/src/pecos/slr/ast/pretty_print.py b/python/quantum-pecos/src/pecos/slr/ast/pretty_print.py
index 25667044c..4e88af1d9 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/pretty_print.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/pretty_print.py
@@ -216,12 +216,15 @@ def visit_gate(self, node: GateOp) -> str:
 
     def visit_prepare(self, node: PrepareOp) -> str:
         """Visit prepare operation."""
+        # Default `PZ` stays byte-identical (no churn for the existing
+        # corpus); a non-PZ basis is shown so the dump is faithful.
+        b = "" if node.basis == "PZ" else f", basis={node.basis!r}"
         if node.slots is None:
-            return f"{node.allocator}.prepare_all()"
+            return f"{node.allocator}.prepare_all({node.basis!r})" if b else f"{node.allocator}.prepare_all()"
         if len(node.slots) == 1:
-            return f"{node.allocator}.prepare({node.slots[0]})"
+            return f"{node.allocator}.prepare({node.slots[0]}{b})"
         slots = ", ".join(str(s) for s in node.slots)
-        return f"{node.allocator}.prepare({slots})"
+        return f"{node.allocator}.prepare({slots}{b})"
 
     def visit_measure(self, node: MeasureOp) -> str:
         """Visit measure operation."""
diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/qubit/__init__.py b/python/quantum-pecos/src/pecos/slr/qeclib/qubit/__init__.py
index 5c5f4343d..4cc1f8628 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/qubit/__init__.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/qubit/__init__.py
@@ -16,7 +16,7 @@
 # specific language governing permissions and limitations under the License.
 
 from pecos.slr.qeclib.qubit.measures import Measure
-from pecos.slr.qeclib.qubit.preps import Prep
+from pecos.slr.qeclib.qubit.preps import PNX, PNY, PNZ, PX, PY, PZ, Prep
 from pecos.slr.qeclib.qubit.rots import CRZ, RX, RY, RZ, RZZ
 from pecos.slr.qeclib.qubit.sq_face_rots import F4, F, F4dg, Fdg
 from pecos.slr.qeclib.qubit.sq_hadamards import H
@@ -43,6 +43,12 @@
     "CY",
     "CZ",
     "F4",
+    "PNX",
+    "PNY",
+    "PNZ",
+    "PX",
+    "PY",
+    "PZ",
     "RX",
     "RY",
     "RZ",
diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/qubit/preps.py b/python/quantum-pecos/src/pecos/slr/qeclib/qubit/preps.py
index 614173775..1cdb4c11c 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/qubit/preps.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/qubit/preps.py
@@ -20,4 +20,33 @@
 
 
 class Prep(QGate):
-    """Preparing/resetting a qubit to the zero state."""
+    """Preparing/resetting a qubit to the zero state.
+
+    Deprecated alias of `PZ` (hard-replaced repo-wide in #81
+    Stage C). The prep basis is the gate identity, not a string
+    argument -- use `PZ`/`PNZ`/`PX`/`PNX`/`PY`/`PNY`.
+    """
+
+
+class PZ(QGate):
+    """Prepare/reset a qubit to |0> (+Z eigenstate)."""
+
+
+class PNZ(QGate):
+    """Prepare/reset a qubit to |1> (-Z eigenstate)."""
+
+
+class PX(QGate):
+    """Prepare/reset a qubit to |+> (+X eigenstate)."""
+
+
+class PNX(QGate):
+    """Prepare/reset a qubit to |-> (-X eigenstate)."""
+
+
+class PY(QGate):
+    """Prepare/reset a qubit to |+i> (+Y eigenstate)."""
+
+
+class PNY(QGate):
+    """Prepare/reset a qubit to |-i> (-Y eigenstate)."""
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
index 9b76a0707..e54cf2b92 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
@@ -123,8 +123,14 @@
     #    shared converter root, matching the AST->Guppy path which
     #    already rejects non-Z Prep at preflight.
     "docs.inline_measure_creg": ("NotImplementedError", "was not declared at Main scope"),
-    "docs.prep_basis_x": ("NotImplementedError", "non-Z Prep basis"),
-    "docs.surface_syndrome_block18": ("NotImplementedError", "non-Z Prep basis"),
+    # #81 Stage A recast the guard: the prep basis is the gate
+    # identity, so ANY stray string qarg (incl. these factories'
+    # `Prep(q, "X")`) fails loud. Still BUILD_FAILED; only the
+    # message fragment changed. Stage D rewrites the factories to
+    # dedicated gates -> these move BUILD_FAILED -> QIS_OK (re-pin
+    # then via `_qir_state()`).
+    "docs.prep_basis_x": ("NotImplementedError", "stray string argument"),
+    "docs.surface_syndrome_block18": ("NotImplementedError", "stray string argument"),
 }
 
 # Tier 1: the non-metadata `validate_qir` failures (label -> stable,
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
index a6eb643bb..fa24daa4f 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
@@ -412,21 +412,26 @@ def test_inline_returned_creg_raises_loud() -> None:
         SlrConverter(prog).qir_bc()
 
 
-def test_non_z_prep_basis_raises_loud() -> None:
-    """#80: a non-Z `Prep` basis must FAIL LOUD at AST conversion.
-    `_expand_qubit_args` silently dropped the basis string, so every
-    AST codegen (QIR/Stim/QC/QASM) lowered `Prep(q, "X")` as a plain
-    Z reset -- a miscompile (#79 surfaced `docs.prep_basis_x` /
-    `docs.surface_syndrome_block18` recording a deterministic 0). The
-    AST->Guppy path already rejects this at preflight with the same
-    Z/+Z rule; fix at the shared converter root so all AST codegens
-    agree. Z / +Z (case-insensitive) stays allowed."""
-    ok = Main(q := QReg("q", 1), c := CReg("c", 1), qb.Prep(q[0], "Z"), Measure(q) > c, Return(c))
-    SlrConverter(ok).qir_bc()  # explicit Z is fine (boundary)
-
-    over = Main(q := QReg("q", 1), c := CReg("c", 1), qb.Prep(q[0], "X"), Measure(q) > c, Return(c))
-    with pytest.raises(NotImplementedError, match=r"non-Z Prep basis 'X' is not supported"):
-        SlrConverter(over).qir_bc()
+def test_prep_stray_string_arg_raises_loud() -> None:
+    """#80 recast under #81: the prep basis is the GATE IDENTITY
+    (`PZ`/`PNZ`/`PX`/`PNX`/`PY`/`PNY`), not a string argument.
+    `_expand_qubit_args` silently drops a string qarg, so a basis
+    string on ANY prep gate -- the legacy `Prep(q, "X")`, or
+    `PZ(q, "X")`, even `Prep(q, "Z")` -- would be silently dropped
+    and lowered as the plain basis (a miscompile, #80/#79). The
+    converter rejects ANY stray string qarg on EVERY prep gate
+    (Codex #81 sym rule). A bare prep gate (no string) is fine."""
+    # No-string preps build (PZ default; dedicated gate identity).
+    ok = Main(q := QReg("q", 1), c := CReg("c", 1), qb.PZ(q[0]), Measure(q) > c, Return(c))
+    SlrConverter(ok).qir_bc()
+    ok_prep = Main(q := QReg("q", 1), c := CReg("c", 1), qb.Prep(q[0]), Measure(q) > c, Return(c))
+    SlrConverter(ok_prep).qir_bc()
+
+    # ANY string qarg on ANY prep gate fails loud (incl. "Z").
+    for prep, s in ((qb.Prep, "X"), (qb.Prep, "Z"), (qb.PZ, "X"), (qb.PX, "ignored")):
+        bad = Main(q := QReg("q", 1), c := CReg("c", 1), prep(q[0], s), Measure(q) > c, Return(c))
+        with pytest.raises(NotImplementedError, match=r"stray string argument"):
+            SlrConverter(bad).qir_bc()
 
 
 def test_return_only_inline_creg_raises_loud() -> None:

From 8a2a55c38aa3f64002857929999c6e5479a6e2f6 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Sun, 17 May 2026 23:06:50 -0600
Subject: [PATCH 093/136] #81 Stage B: single shared canonical basis->tail map
 (_prep_tail.py) wired into all 5 codegens (QIR/Stim/QASM/QC/Guppy) -- reset +
 Clifford tail per pinned 6-row table (PZ id/PNZ X/PX H/PNX H;Z/PY H;S/PNY
 H;Sdg); non-PZ prepare_all fails loud where the backend no-ops it; PZ
 byte-identical (zero corpus churn); QC sequences reset/tail as separate
 ticks; Guppy functional tail. Verified: Stim peek_bloch all-6 PASS, broad
 ast_guppy 258/0, ast_tests 664/0, ruff/black clean

---
 .../src/pecos/slr/ast/codegen/_prep_tail.py   | 48 +++++++++++++++++++
 .../src/pecos/slr/ast/codegen/guppy.py        | 17 +++++--
 .../src/pecos/slr/ast/codegen/qasm.py         | 20 ++++----
 .../src/pecos/slr/ast/codegen/qir.py          | 13 ++++-
 .../pecos/slr/ast/codegen/quantum_circuit.py  | 20 ++++++--
 .../src/pecos/slr/ast/codegen/stim.py         |  9 +++-
 6 files changed, 109 insertions(+), 18 deletions(-)
 create mode 100644 python/quantum-pecos/src/pecos/slr/ast/codegen/_prep_tail.py

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/_prep_tail.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/_prep_tail.py
new file mode 100644
index 000000000..cb0758d17
--- /dev/null
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/_prep_tail.py
@@ -0,0 +1,48 @@
+# Copyright 2026 The PECOS Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+# the License.You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations under the License.
+
+"""Canonical prep-basis lowering (#81), single source for every codegen.
+
+A prep gate is a Z-reset (|0>) followed by a fixed Clifford tail. The
+tail is expressed as `GateKind`s so each backend reuses its existing
+`GateKind -> name` map (`GATE_TO_QIR/STIM/QC/QASM`, guppy
+`FUNCTIONAL_GATES`); there is exactly ONE tail table, not six. Pinned
+by the #81 round-1 review (states experimentally verified;
+S = diag(1, i)): the uniform symmetric model X-basis = H,
+phase-flip via trailing Z; Y-basis = H then S(+)/Sdg(-).
+"""
+
+from __future__ import annotations
+
+from pecos.slr.ast.nodes import GateKind
+
+# basis -> Clifford tail applied AFTER a |0> reset.
+PREP_TAIL: dict[str, tuple[GateKind, ...]] = {
+    "PZ": (),  # |0>
+    "PNZ": (GateKind.X,),  # |1>
+    "PX": (GateKind.H,),  # |+>
+    "PNX": (GateKind.H, GateKind.Z),  # |->
+    "PY": (GateKind.H, GateKind.S),  # |+i>
+    "PNY": (GateKind.H, GateKind.Sdg),  # |-i>
+}
+
+
+def prep_tail(basis: str) -> tuple[GateKind, ...]:
+    """Tail for `basis`, or fail LOUD on an unknown basis.
+
+    An unknown basis silently lowering as a bare |0> reset would be
+    exactly the silent-miscompile class #80/#81 exist to kill.
+    """
+    try:
+        return PREP_TAIL[basis]
+    except KeyError:
+        msg = f"codegen: unknown prep basis {basis!r} (expected one of {sorted(PREP_TAIL)})."
+        raise NotImplementedError(msg) from None
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
index ab6160a0c..05ce861fc 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
@@ -24,6 +24,7 @@
 from typing import TYPE_CHECKING, cast
 
 from pecos.slr.ast.codegen._block_flatten import validate_unique_block_decl_names
+from pecos.slr.ast.codegen._prep_tail import prep_tail
 from pecos.slr.ast.codegen.guppy_linearity import (
     GuppyLinearityState,
     LinearityError,
@@ -995,6 +996,11 @@ def _raise_unsupported_gate(self, gate: GateKind) -> None:
         raise GuppyCodegenError(msg)
 
     def _emit_prepare(self, node: PrepareOp) -> list[str]:
+        # Z-reset/alloc to |0>, then the #81 canonical Clifford tail
+        # (functional, linearity-preserving -- same FUNCTIONAL_GATES
+        # path as ordinary 1q gates; the qubit primitive yields |0>
+        # so this is exactly `PZ(q); H(q); ...`).
+        tail = prep_tail(node.basis)
         lines: list[str] = []
         slots = range(self.context.root_allocators[node.allocator]) if node.slots is None else node.slots
         linearity = self._linearity()
@@ -1002,12 +1008,13 @@ def _emit_prepare(self, node: PrepareOp) -> list[str]:
             slot = Slot(node.allocator, index)
             local = self._local_name(slot)
             if linearity.status(slot) is SlotState.LIVE:
-                old_local = linearity.live(slot)
-                lines.append(f"{self.context.indent()}{old_local} = reset({old_local})")
-                linearity.set_live(slot, old_local)
+                cur = linearity.live(slot)
+                lines.append(f"{self.context.indent()}{cur} = reset({cur})")
             else:
-                lines.append(f"{self.context.indent()}{local} = qubit()")
-                linearity.set_live(slot, local)
+                cur = local
+                lines.append(f"{self.context.indent()}{cur} = qubit()")
+            lines.extend(f"{self.context.indent()}{cur} = {FUNCTIONAL_GATES[gk]}({cur})" for gk in tail)
+            linearity.set_live(slot, cur)
         return lines
 
     def _emit_measure(self, node: MeasureOp) -> list[str]:
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qasm.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qasm.py
index 5eaa6bce4..c508d8118 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qasm.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qasm.py
@@ -33,6 +33,7 @@
 from typing import TYPE_CHECKING
 
 from pecos.slr.ast.codegen._block_flatten import flatten_block_calls
+from pecos.slr.ast.codegen._prep_tail import prep_tail
 from pecos.slr.ast.nodes import (
     AllocatorDecl,
     BinaryExpr,
@@ -372,22 +373,25 @@ def visit_gate(self, node: GateOp) -> list[str]:
         return lines
 
     def visit_prepare(self, node: PrepareOp) -> list[str]:
-        """Generate reset/prep operation."""
+        """Generate reset/prep operation (Z-reset + #81 basis tail)."""
         lines = []
+        tail = prep_tail(node.basis)
 
         # Get root allocator for this allocator
         root = self.context.get_root_allocator(node.allocator)
 
         if node.slots is None:
-            # Reset all qubits in the allocator
+            if tail:
+                msg = f"QASM codegen: prepare_all with non-PZ basis {node.basis!r} is not supported"
+                raise NotImplementedError(msg)
             capacity = self.context.allocators.get(node.allocator, 1)
-            for i in range(capacity):
-                abs_index = self.context.get_absolute_index(node.allocator, i)
-                lines.append(self._maybe_conditional(f"reset {root}[{abs_index}];"))
+            indices = [self.context.get_absolute_index(node.allocator, i) for i in range(capacity)]
         else:
-            for slot in node.slots:
-                abs_index = self.context.get_absolute_index(node.allocator, slot)
-                lines.append(self._maybe_conditional(f"reset {root}[{abs_index}];"))
+            indices = [self.context.get_absolute_index(node.allocator, slot) for slot in node.slots]
+
+        for abs_index in indices:
+            lines.append(self._maybe_conditional(f"reset {root}[{abs_index}];"))
+            lines.extend(self._maybe_conditional(f"{GATE_TO_QASM[gk]} {root}[{abs_index}];") for gk in tail)
 
         return lines
 
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
index aa24eb051..f196b12e0 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
@@ -30,6 +30,7 @@
 from typing import TYPE_CHECKING, Any
 
 from pecos.slr.ast.codegen._block_flatten import flatten_block_calls
+from pecos.slr.ast.codegen._prep_tail import prep_tail
 from pecos.slr.ast.nodes import (
     AllocatorDecl,
     AssignOp,
@@ -609,17 +610,27 @@ def _process_measure(self, node: MeasureOp) -> None:
                 )
 
     def _process_prepare(self, node: PrepareOp) -> None:
-        """Process a prepare/reset operation."""
+        """Process a prepare/reset operation (Z-reset + #81 basis tail)."""
+        tail = prep_tail(node.basis)
         if node.slots is None:
+            # prepare_all is a pre-existing no-op gap; a NON-PZ
+            # prepare_all silently doing nothing would be a basis
+            # miscompile -- fail loud rather than extend the gap.
+            if tail:
+                msg = f"QIR codegen: prepare_all with non-PZ basis {node.basis!r} is not supported"
+                raise NotImplementedError(msg)
             return
 
         reset_func = self._get_or_create_gate("reset", has_params=False, num_qubits=1)
+        tail_funcs = [(self._get_or_create_gate(GATE_TO_QIR[gk], has_params=False, num_qubits=1)) for gk in tail]
 
         for slot in node.slots:
             qubit_ptr = self._get_qubit_ptr(
                 SlotRef(allocator=node.allocator, index=slot),
             )
             self._builder.call(reset_func, [qubit_ptr], name="")
+            for func in tail_funcs:
+                self._builder.call(func, [qubit_ptr], name="")
 
     def _process_barrier(self, node: BarrierOp) -> None:
         """Process a barrier operation."""
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py
index e6670390c..8223ece0d 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py
@@ -29,6 +29,7 @@
 from typing import TYPE_CHECKING
 
 from pecos.slr.ast.codegen._block_flatten import flatten_block_calls
+from pecos.slr.ast.codegen._prep_tail import prep_tail
 from pecos.slr.ast.nodes import (
     AllocatorDecl,
     BarrierOp,
@@ -326,13 +327,26 @@ def _process_measure(self, node: MeasureOp) -> None:
             self._add_to_tick("Measure", qubit)
 
     def _process_prepare(self, node: PrepareOp) -> None:
-        """Process a prepare/reset operation."""
+        """Process a prepare/reset operation (Z-reset + #81 basis tail).
+
+        QC ticks are parallel sets; reset and the Clifford tail MUST
+        be sequential, so each is its own flushed tick (PZ has no
+        tail -> byte-identical to the prior behaviour).
+        """
+        tail = prep_tail(node.basis)
         if node.slots is None:
+            if tail:
+                msg = f"QuantumCircuit codegen: prepare_all with non-PZ basis {node.basis!r} is not supported"
+                raise NotImplementedError(msg)
             return
 
-        for slot in node.slots:
-            qubit = self.context.get_qubit(node.allocator, slot)
+        qubits = [self.context.get_qubit(node.allocator, slot) for slot in node.slots]
+        for qubit in qubits:
             self._add_to_tick("RESET", qubit)
+        for gk in tail:
+            self._flush_tick()  # sequence reset/prev-tail before this gate
+            for qubit in qubits:
+                self._add_to_tick(GATE_TO_QC[gk], qubit)
 
     def _add_to_tick(self, gate_name: str, target: int | tuple[int, int]) -> None:
         """Add a gate to the current tick."""
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/stim.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/stim.py
index 8c37fe9d7..16ed18498 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/stim.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/stim.py
@@ -29,6 +29,7 @@
 from typing import TYPE_CHECKING
 
 from pecos.slr.ast.codegen._block_flatten import flatten_block_calls
+from pecos.slr.ast.codegen._prep_tail import prep_tail
 from pecos.slr.ast.nodes import (
     AllocatorDecl,
     BarrierOp,
@@ -315,12 +316,18 @@ def _process_measure(self, node: MeasureOp) -> None:
         self.context.measurement_count += len(qubits)
 
     def _process_prepare(self, node: PrepareOp) -> None:
-        """Process a prepare/reset operation."""
+        """Process a prepare/reset operation (Z-reset + #81 basis tail)."""
+        tail = prep_tail(node.basis)
         if node.slots is None:
+            if tail:
+                msg = f"Stim codegen: prepare_all with non-PZ basis {node.basis!r} is not supported"
+                raise NotImplementedError(msg)
             return
 
         qubits = [self.context.get_qubit(node.allocator, slot) for slot in node.slots]
         self.circuit.append_operation("R", qubits)
+        for gk in tail:
+            self.circuit.append_operation(GATE_TO_STIM[gk], qubits)
 
     def _process_barrier(self) -> None:
         """Process a barrier as TICK."""

From 02d152d8158b86c9b12e45aba9abb384df3c35e4 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Mon, 18 May 2026 00:18:53 -0600
Subject: [PATCH 094/136] #81 Stage C: hard-replace Prep->PZ repo-wide (63
 files, all 3 subsystems: SLR gate+call sites + legacy gen_codes op_class +
 circuits gate-vocab); removed class Prep + _PREP_BASIS Prep entry + qeclib
 __init__ Prep + dead Guppy non-Z preflight reject + dead _string_args;
 PhysicalQubit.pz->preps.PZ; converter scratch-lifecycle messages Prep->PZ.
 Public SLR API break (accepted). Verified: full slr_tests 387 passed +
 behavioral all-6 PASS + ruff/black clean. The 27 *_qir
 permutation/measurement failures are PRE-EXISTING (legacy gen_codes QIR
 comment assertions the AST codegen never emitted; git -S Permutation empty on
 ast qir.py; #81 introduced 0 new failures) -- tracked task #87, out of #81
 scope

---
 .../pecos/circuit_converters/hugr_to_ast.py   |   2 +-
 .../src/pecos/circuits/quantum_circuit.py     |   2 +-
 .../src/pecos/qec/surface/circuit_builder.py  |   4 +-
 .../src/pecos/slr/ast/analysis/data_flow.py   |   2 +-
 .../slr/ast/analysis/qubit_state_validator.py |   4 +-
 .../slr/ast/analysis/resource_counter.py      |   2 +-
 .../src/pecos/slr/ast/codegen/guppy.py        |  15 +--
 .../src/pecos/slr/ast/converter.py            |  15 ++-
 .../slr/converters/from_quantum_circuit.py    |   8 +-
 .../src/pecos/slr/converters/from_stim.py     |   4 +-
 .../src/pecos/slr/gen_codes/gen_qasm.py       |   2 +-
 .../slr/gen_codes/gen_quantum_circuit.py      |   2 +-
 .../src/pecos/slr/gen_codes/gen_stim.py       |   2 +-
 .../pecos/slr/gen_codes/qir_gate_mapping.py   |   2 +-
 .../slr/qeclib/color488/color488_class.py     |   2 +-
 .../src/pecos/slr/qeclib/generic/check.py     |   4 +-
 .../pecos/slr/qeclib/generic/check_1flag.py   |   8 +-
 .../src/pecos/slr/qeclib/qubit/__init__.py    |   3 +-
 .../src/pecos/slr/qeclib/qubit/preps.py       |   9 --
 .../src/pecos/slr/qeclib/qubit/qubit.py       |   4 +-
 .../pecos/slr/qeclib/steane/meas/measure_x.py |   2 +-
 .../pecos/slr/qeclib/steane/meas/measure_z.py |   2 +-
 .../slr/qeclib/steane/preps/encoding_circ.py  |   2 +-
 .../slr/qeclib/steane/preps/pauli_states.py   |   8 +-
 .../slr/qeclib/steane/preps/plus_h_state.py   |   2 +-
 .../slr/qeclib/steane/preps/t_plus_state.py   |   4 +-
 .../syn_extract/six_check_nonflagging.py      |   4 +-
 .../syn_extract/three_parallel_flagging.py    |   4 +-
 .../pecos/qeclib/qubit/test_preps.py          |   4 +-
 .../random_cases/test_control_flow.py         |   2 +-
 .../test_qasm/random_cases/test_slr_phys.py   |   4 +-
 .../ast_tests/analysis/test_depth_analyzer.py |  60 +++++------
 .../analysis/test_qubit_state_validator.py    |  52 ++++-----
 .../analysis/test_resource_counter.py         |  34 +++---
 .../slr/ast_tests/test_ast_codegen_guppy.py   |   2 +-
 .../slr/ast_tests/test_ast_codegen_qasm.py    |   6 +-
 .../slr/ast_tests/test_ast_codegen_qir.py     |   6 +-
 .../test_ast_codegen_quantum_circuit.py       |   8 +-
 .../slr/ast_tests/test_ast_codegen_stim.py    |   8 +-
 .../pecos/slr/ast_tests/test_ast_converter.py |  18 ++--
 .../pecos/slr/ast_tests/test_ast_roundtrip.py |   2 +-
 .../pecos/slr/ast_tests/test_ast_visitor.py   |   6 +-
 .../tests/qec/surface/test_circuit_fuzz.py    |   4 +-
 .../tests/qec/test_dem_sampler_vs_stim.py     |   2 +-
 .../tests/qec/test_fault_catalog.py           |   2 +-
 .../qec/test_meas_sampling_generality.py      |   8 +-
 .../tests/selene/test_hugr_to_ast.py          |   4 +-
 .../tests/slr_tests/ast_guppy/audit_runner.py |  40 +++----
 .../slr_tests/ast_guppy/test_ast_hugr.py      |   8 +-
 .../ast_guppy/test_block_call_smoke.py        | 100 +++++++++---------
 .../ast_guppy/test_block_substitution.py      |   2 +-
 .../tests/slr_tests/ast_guppy/test_print.py   |  20 ++--
 .../ast_guppy/test_qir_spec_compliance.py     |   8 +-
 .../slr_tests/ast_guppy/test_v1_acceptance.py |   6 +-
 .../slr_tests/ast_guppy/test_v1_behavioral.py |   8 +-
 .../slr_tests/ast_guppy/tier2_semantic.py     |   8 +-
 .../guppy/test_partial_array_returns.py       |   2 +-
 .../guppy/test_simple_slr_to_guppy.py         |  10 +-
 .../unit/slr/test_conversion_with_qasm.py     |  10 +-
 .../pecos/unit/slr/test_guppy_generation.py   |  12 +--
 .../test_guppy_generation_comprehensive.py    |   4 +-
 .../slr/test_quantum_circuit_conversion.py    |  14 +--
 .../pecos/unit/slr/test_stim_conversion.py    |   4 +-
 63 files changed, 297 insertions(+), 315 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/circuit_converters/hugr_to_ast.py b/python/quantum-pecos/src/pecos/circuit_converters/hugr_to_ast.py
index 5c4947f93..96bc86c80 100644
--- a/python/quantum-pecos/src/pecos/circuit_converters/hugr_to_ast.py
+++ b/python/quantum-pecos/src/pecos/circuit_converters/hugr_to_ast.py
@@ -1247,7 +1247,7 @@ def hugr_to_ast(
         ...
         >>> package = simple.compile()
         >>> ast = hugr_to_ast(package.modules[0])
-        >>> len(ast.body)  # Prep + H + Measure
+        >>> len(ast.body)  # PZ + H + Measure
         3
     """
     converter = HugrToAstConverter(hugr)
diff --git a/python/quantum-pecos/src/pecos/circuits/quantum_circuit.py b/python/quantum-pecos/src/pecos/circuits/quantum_circuit.py
index ae03fb7bf..9119ea8d1 100644
--- a/python/quantum-pecos/src/pecos/circuits/quantum_circuit.py
+++ b/python/quantum-pecos/src/pecos/circuits/quantum_circuit.py
@@ -87,7 +87,7 @@
     "SWAP": "SWAP",
     "RXXRYYRZZ": "RXXRYYRZZ",
     "R2XXYYZZ": "RXXRYYRZZ",
-    "Prep": "init |0>",
+    "PZ": "init |0>",
     "Measure": "measure",
     "MeasureFree": "measure",
     "QAlloc": "QAlloc",
diff --git a/python/quantum-pecos/src/pecos/qec/surface/circuit_builder.py b/python/quantum-pecos/src/pecos/qec/surface/circuit_builder.py
index 14ce63767..e7adc8aee 100644
--- a/python/quantum-pecos/src/pecos/qec/surface/circuit_builder.py
+++ b/python/quantum-pecos/src/pecos/qec/surface/circuit_builder.py
@@ -844,10 +844,10 @@ def render(
         """Render to PECOS TickCircuit.
 
         The tick structure follows Stim's pattern:
-        - Tick: Prep data qubits
+        - Tick: PZ data qubits
         - Tick: H for X-basis prep (if X-basis)
         - For each syndrome round:
-            - Tick: Prep ancillas
+            - Tick: PZ ancillas
             - Tick: H on X ancillas
             - Tick: CX round 1
             - Tick: CX round 2
diff --git a/python/quantum-pecos/src/pecos/slr/ast/analysis/data_flow.py b/python/quantum-pecos/src/pecos/slr/ast/analysis/data_flow.py
index d9da3b80e..1372be80c 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/analysis/data_flow.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/analysis/data_flow.py
@@ -104,7 +104,7 @@ def add_use(
             self.consumed_at.append(position)
 
     def add_replacement(self, position: int) -> None:
-        """Mark that this value is replaced at a position (e.g., Prep)."""
+        """Mark that this value is replaced at a position (e.g., PZ)."""
         self.replaced_at.append(position)
 
     def has_use_after_consumption(self) -> bool:
diff --git a/python/quantum-pecos/src/pecos/slr/ast/analysis/qubit_state_validator.py b/python/quantum-pecos/src/pecos/slr/ast/analysis/qubit_state_validator.py
index 4c663ba6e..75f8e3066 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/analysis/qubit_state_validator.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/analysis/qubit_state_validator.py
@@ -78,7 +78,7 @@ def message(self) -> str:
         """Human-readable error message."""
         return (
             f"Gate '{self.gate.name}' applied to unprepared qubit "
-            f"{self.allocator}[{self.index}]. Call Prep() before applying gates."
+            f"{self.allocator}[{self.index}]. Call PZ() before applying gates."
         )
 
     def __str__(self) -> str:
@@ -106,7 +106,7 @@ def get_state(self, allocator: str, index: int) -> ValidationSlotState:
         return self.slot_states.get((allocator, index), ValidationSlotState.UNPREPARED)
 
     def mark_prepared(self, allocator: str, index: int) -> None:
-        """Mark a slot as prepared (after Prep operation)."""
+        """Mark a slot as prepared (after PZ operation)."""
         self.slot_states[(allocator, index)] = ValidationSlotState.PREPARED
 
     def mark_unprepared(self, allocator: str, index: int) -> None:
diff --git a/python/quantum-pecos/src/pecos/slr/ast/analysis/resource_counter.py b/python/quantum-pecos/src/pecos/slr/ast/analysis/resource_counter.py
index d22ae9e29..9ef9ce045 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/analysis/resource_counter.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/analysis/resource_counter.py
@@ -183,7 +183,7 @@ def _count_prepare(self, node: PrepareOp) -> None:
         if node.slots is not None:
             self.result.preparation_count += len(node.slots)
         else:
-            # Prep all - would need allocator info to count exactly
+            # PZ all - would need allocator info to count exactly
             self.result.preparation_count += 1
 
     def _count_if(self, node: IfStmt) -> None:
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
index 05ce861fc..1459ec421 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
@@ -1800,13 +1800,10 @@ def _validate_slr_gate_for_guppy_v1(gate: object) -> None:
         msg = "AST -> Guppy v1 does not support symbolic LoopVar indexing"
         raise GuppyCodegenError(msg)
 
-    if getattr(gate, "sym", None) != "Prep":
-        return
-
-    for basis in _string_args(qargs):
-        if basis.strip().upper() not in {"Z", "+Z"}:
-            msg = "AST -> Guppy v1 supports only Z-basis Prep; use Prep(q); H(q) for X-basis prep"
-            raise GuppyCodegenError(msg)
+    # (#81: the non-Z `Prep` string-basis preflight reject was
+    # removed -- prep basis is the gate identity now; the dedicated
+    # gates carry it through `PrepareOp.basis` and the converter
+    # already fails loud on any stray prep string arg.)
 
 
 def _contains_symbolic_index(value: object) -> bool:
@@ -1816,10 +1813,6 @@ def _contains_symbolic_index(value: object) -> bool:
     return False
 
 
-def _string_args(value: object) -> list[str]:
-    return [item for item in _nested_items(value) if isinstance(item, str)]
-
-
 def _nested_items(value: object) -> Iterator[object]:
     if isinstance(value, str):
         yield value
diff --git a/python/quantum-pecos/src/pecos/slr/ast/converter.py b/python/quantum-pecos/src/pecos/slr/ast/converter.py
index e8552c25d..faf460884 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/converter.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/converter.py
@@ -21,7 +21,7 @@
 
     prog = Main(
         q := QReg("q", 2),
-        qb.Prep(q[0]),
+        qb.PZ(q[0]),
         qb.H(q[0]),
     )
 
@@ -87,10 +87,9 @@
 
 
 # SLR prep-gate symbol -> canonical AST prep basis (#81). The basis
-# is the gate identity, not a string argument. `Prep` is the
-# deprecated |0> alias of `PZ` (hard-replaced repo-wide in Stage C).
+# is the gate identity, not a string argument. (`Prep` was removed
+# in Stage C -- hard-replaced repo-wide by `PZ`.)
 _PREP_BASIS: dict[str, str] = {
-    "Prep": "PZ",
     "PZ": "PZ",
     "PNZ": "PNZ",
     "PX": "PX",
@@ -1189,7 +1188,7 @@ def _validate_scratch_input(
         )
         raise ValueError(msg)
     if not events:
-        msg = f"{where}: declared SCRATCH but never used in the block body (expected Prep(...) then Measure(...))"
+        msg = f"{where}: declared SCRATCH but never used in the block body (expected PZ(...) then Measure(...))"
         raise ValueError(msg)
     if events[0] != "PREP":
         msg = (
@@ -1217,9 +1216,9 @@ def _validate_scratch_input(
         elif ev == "MEASURE":
             if not open_prep:
                 msg = (
-                    f"{where}: measured without an open Prep (measure "
-                    "before Prep, or measured again without an "
-                    "intervening Prep)"
+                    f"{where}: measured without an open PZ (measure "
+                    "before PZ, or measured again without an "
+                    "intervening PZ)"
                 )
                 raise ValueError(msg)
             open_prep = False
diff --git a/python/quantum-pecos/src/pecos/slr/converters/from_quantum_circuit.py b/python/quantum-pecos/src/pecos/slr/converters/from_quantum_circuit.py
index 0c8512808..4a44e89c3 100644
--- a/python/quantum-pecos/src/pecos/slr/converters/from_quantum_circuit.py
+++ b/python/quantum-pecos/src/pecos/slr/converters/from_quantum_circuit.py
@@ -277,18 +277,18 @@ def _convert_gate_set(gate_symbol, locations, q, c, measurement_offset):
     elif gate_upper in ["R", "RZ", "RESET"]:
         for loc in locations:
             if isinstance(loc, int):
-                ops.append(qubit.Prep(q[loc]))
+                ops.append(qubit.PZ(q[loc]))
             elif isinstance(loc, tuple) and len(loc) == 1:
-                ops.append(qubit.Prep(q[loc[0]]))
+                ops.append(qubit.PZ(q[loc[0]]))
     elif gate_upper == "RX":
         for loc in locations:
             if isinstance(loc, int):
-                ops.append(qubit.Prep(q[loc]))
+                ops.append(qubit.PZ(q[loc]))
                 ops.append(qubit.H(q[loc]))
     elif gate_upper == "RY":
         for loc in locations:
             if isinstance(loc, int):
-                ops.append(qubit.Prep(q[loc]))
+                ops.append(qubit.PZ(q[loc]))
                 ops.append(qubit.H(q[loc]))
                 ops.append(qubit.SZ(q[loc]))
     else:
diff --git a/python/quantum-pecos/src/pecos/slr/converters/from_stim.py b/python/quantum-pecos/src/pecos/slr/converters/from_stim.py
index edc1127ff..8ecac2a32 100644
--- a/python/quantum-pecos/src/pecos/slr/converters/from_stim.py
+++ b/python/quantum-pecos/src/pecos/slr/converters/from_stim.py
@@ -217,11 +217,11 @@ def _map_gate(gate_name, targets, args, q, c, measurement_offset):
                     ops.append(qubit.Measure(q[idx]) > c[measurement_offset + i])
     elif gate_name in ["R", "RZ"]:
         # Reset
-        ops.extend(qubit.Prep(q[idx]) for idx in qubit_targets)
+        ops.extend(qubit.PZ(q[idx]) for idx in qubit_targets)
     elif gate_name in ["RX", "RY"]:
         # Reset in X or Y basis
         for idx in qubit_targets:
-            ops.append(qubit.Prep(q[idx]))
+            ops.append(qubit.PZ(q[idx]))
             if gate_name == "RX":
                 ops.append(qubit.H(q[idx]))
             else:  # RY
diff --git a/python/quantum-pecos/src/pecos/slr/gen_codes/gen_qasm.py b/python/quantum-pecos/src/pecos/slr/gen_codes/gen_qasm.py
index fdb295297..147ae5f18 100644
--- a/python/quantum-pecos/src/pecos/slr/gen_codes/gen_qasm.py
+++ b/python/quantum-pecos/src/pecos/slr/gen_codes/gen_qasm.py
@@ -645,7 +645,7 @@ def process_qgate(self, op):
                         ],
                     )
 
-                case "Prep":
+                case "PZ":
                     op_str = self.qgate_sq_qasm(op, "reset")
 
                 case "T":
diff --git a/python/quantum-pecos/src/pecos/slr/gen_codes/gen_quantum_circuit.py b/python/quantum-pecos/src/pecos/slr/gen_codes/gen_quantum_circuit.py
index e5deb6e60..5cbdb1961 100644
--- a/python/quantum-pecos/src/pecos/slr/gen_codes/gen_quantum_circuit.py
+++ b/python/quantum-pecos/src/pecos/slr/gen_codes/gen_quantum_circuit.py
@@ -322,7 +322,7 @@ def _handle_quantum_op(self, op):
             "CY": "CY",
             "CZ": "CZ",
             "Measure": "Measure",
-            "Prep": "RESET",
+            "PZ": "RESET",
             "RX": "RX",
             "RY": "RY",
             "RZ": "RZ",
diff --git a/python/quantum-pecos/src/pecos/slr/gen_codes/gen_stim.py b/python/quantum-pecos/src/pecos/slr/gen_codes/gen_stim.py
index bded9112b..98d6d759a 100644
--- a/python/quantum-pecos/src/pecos/slr/gen_codes/gen_stim.py
+++ b/python/quantum-pecos/src/pecos/slr/gen_codes/gen_stim.py
@@ -250,7 +250,7 @@ def _handle_quantum_op(self, op):
         elif op_class == "Measure":
             self.circuit.append_operation("M", qubits)
             self.measurement_count += len(qubits)
-        elif op_class == "Prep":
+        elif op_class == "PZ":
             self.circuit.append_operation("R", qubits)
         elif op_class in ["RX", "RY", "RZ"]:
             # Rotation gates - add as parameterized gates if supported
diff --git a/python/quantum-pecos/src/pecos/slr/gen_codes/qir_gate_mapping.py b/python/quantum-pecos/src/pecos/slr/gen_codes/qir_gate_mapping.py
index f0fbfd9c0..d7e770bcc 100644
--- a/python/quantum-pecos/src/pecos/slr/gen_codes/qir_gate_mapping.py
+++ b/python/quantum-pecos/src/pecos/slr/gen_codes/qir_gate_mapping.py
@@ -55,7 +55,7 @@ def __init__(self, gate: QG):
     R1XY = QG("u1q")
     RZZ = QG("rzz")
     SZZ = QG("zz")
-    Prep = QG("reset")
+    PZ = QG("reset")
 
     # These dagger/adjoint gates are generated with slightly different names
     Sdg = QG("s__adj")
diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/color488/color488_class.py b/python/quantum-pecos/src/pecos/slr/qeclib/color488/color488_class.py
index b89ffe09b..4086bc7fb 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/color488/color488_class.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/color488/color488_class.py
@@ -102,7 +102,7 @@ def prep_z_bare(self, syndromes: list[CReg]) -> Block:
         """
         block = Block()
         block.extend(
-            qb.Prep(self.d),
+            qb.PZ(self.d),
         )
         for s in syndromes:
             block.extend(
diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/generic/check.py b/python/quantum-pecos/src/pecos/slr/qeclib/generic/check.py
index 2e7e6fcfd..033241399 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/generic/check.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/generic/check.py
@@ -21,7 +21,7 @@
 from typing import TYPE_CHECKING, ClassVar
 
 from pecos.slr import Barrier, Block, Comment
-from pecos.slr.qeclib.qubit import CX, CY, CZ, H, Measure, Prep
+from pecos.slr.qeclib.qubit import CX, CY, CZ, PZ, H, Measure
 
 if TYPE_CHECKING:
     from pecos.slr import Bit, Qubit
@@ -100,7 +100,7 @@ def __init__(
 
         self.extend(
             Comment(f"Measure check {ps}"),
-            Prep(a),
+            PZ(a),
             H(a),
         )
 
diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/generic/check_1flag.py b/python/quantum-pecos/src/pecos/slr/qeclib/generic/check_1flag.py
index ad853516c..8a5e53ea4 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/generic/check_1flag.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/generic/check_1flag.py
@@ -21,7 +21,7 @@
 from typing import TYPE_CHECKING, ClassVar
 
 from pecos.slr import Barrier, Block, Comment
-from pecos.slr.qeclib.qubit import CH, CX, CY, CZ, H, Measure, Prep
+from pecos.slr.qeclib.qubit import CH, CX, CY, CZ, PZ, H, Measure
 
 if TYPE_CHECKING:
     from pecos.slr import Bit, Qubit
@@ -40,7 +40,7 @@ class Check1Flag(Block):
     # measured inside, allocated internally in Guppy so callers can reuse
     # physical slots across sequential checks); data passes through; the two
     # out bits are live_preserved measurement-result write-backs. The body's
-    # single `Prep(a, flag)` is split into `Prep(a), Prep(flag)` (O1 option
+    # single `PZ(a, flag)` is split into `PZ(a), PZ(flag)` (O1 option
     # (a) -- byte-identical in QASM/Guppy/Selene, confirmed Codex 2026-05-16;
     # one PrepareOp per scratch input avoids multi-destination substitution).
     # See ~/Repos/pecos-docs/design/slr/v2-scratch-ancilla-effect.md.
@@ -109,8 +109,8 @@ def __init__(
 
         self.extend(
             Comment(f"Measure check {ops}"),
-            Prep(a),
-            Prep(flag),
+            PZ(a),
+            PZ(flag),
             H(a),
         )
         if with_barriers:
diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/qubit/__init__.py b/python/quantum-pecos/src/pecos/slr/qeclib/qubit/__init__.py
index 4cc1f8628..ee373c8a6 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/qubit/__init__.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/qubit/__init__.py
@@ -16,7 +16,7 @@
 # specific language governing permissions and limitations under the License.
 
 from pecos.slr.qeclib.qubit.measures import Measure
-from pecos.slr.qeclib.qubit.preps import PNX, PNY, PNZ, PX, PY, PZ, Prep
+from pecos.slr.qeclib.qubit.preps import PNX, PNY, PNZ, PX, PY, PZ
 from pecos.slr.qeclib.qubit.rots import CRZ, RX, RY, RZ, RZZ
 from pecos.slr.qeclib.qubit.sq_face_rots import F4, F, F4dg, Fdg
 from pecos.slr.qeclib.qubit.sq_hadamards import H
@@ -64,7 +64,6 @@
     "Fdg",
     "H",
     "Measure",
-    "Prep",
     "SXXdg",
     "SXdg",
     "SYYdg",
diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/qubit/preps.py b/python/quantum-pecos/src/pecos/slr/qeclib/qubit/preps.py
index 1cdb4c11c..ac42dcbf9 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/qubit/preps.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/qubit/preps.py
@@ -19,15 +19,6 @@
 from pecos.slr.qeclib.qubit.qgate_base import QGate
 
 
-class Prep(QGate):
-    """Preparing/resetting a qubit to the zero state.
-
-    Deprecated alias of `PZ` (hard-replaced repo-wide in #81
-    Stage C). The prep basis is the gate identity, not a string
-    argument -- use `PZ`/`PNZ`/`PX`/`PNX`/`PY`/`PNY`.
-    """
-
-
 class PZ(QGate):
     """Prepare/reset a qubit to |0> (+Z eigenstate)."""
 
diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/qubit/qubit.py b/python/quantum-pecos/src/pecos/slr/qeclib/qubit/qubit.py
index 75faad679..81955f5a3 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/qubit/qubit.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/qubit/qubit.py
@@ -63,9 +63,9 @@ def cz(*qargs: Qubit) -> tq_cliffords.CZ:
         return tq_cliffords.CZ(*qargs)
 
     @staticmethod
-    def pz(*qargs: Qubit) -> preps.Prep:
+    def pz(*qargs: Qubit) -> preps.PZ:
         """Measurement gate."""
-        return preps.Prep(*qargs)
+        return preps.PZ(*qargs)
 
     @staticmethod
     def mz(
diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/steane/meas/measure_x.py b/python/quantum-pecos/src/pecos/slr/qeclib/steane/meas/measure_x.py
index 58e5013b4..3b0b75993 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/steane/meas/measure_x.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/steane/meas/measure_x.py
@@ -38,7 +38,7 @@ def __init__(self, d: list[Qubit], a: QReg, out: CReg) -> None:
 
         self.extend(
             Comment("Measure logical X with no flagging"),
-            qubit.Prep(a[0]),
+            qubit.PZ(a[0]),
             qubit.H(a[0]),
             qubit.CX(
                 (d[0], a[0]),
diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/steane/meas/measure_z.py b/python/quantum-pecos/src/pecos/slr/qeclib/steane/meas/measure_z.py
index 95de90d03..40e48d038 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/steane/meas/measure_z.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/steane/meas/measure_z.py
@@ -38,7 +38,7 @@ def __init__(self, d: list[Qubit], a: QReg, out: CReg) -> None:
 
         self.extend(
             Comment("Measure logical Z with no flagging"),
-            qubit.Prep(a[0]),
+            qubit.PZ(a[0]),
             qubit.H(a[0]),
             qubit.CZ(
                 (d[0], a[0]),
diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/steane/preps/encoding_circ.py b/python/quantum-pecos/src/pecos/slr/qeclib/steane/preps/encoding_circ.py
index e7e222212..68d866c00 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/steane/preps/encoding_circ.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/steane/preps/encoding_circ.py
@@ -46,7 +46,7 @@ def __init__(self, q: QReg) -> None:
         self.extend(
             Comment("\nEncoding circuit"),
             Comment("---------------"),
-            qubit.Prep(
+            qubit.PZ(
                 q[0],
                 q[1],
                 q[2],
diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/steane/preps/pauli_states.py b/python/quantum-pecos/src/pecos/slr/qeclib/steane/preps/pauli_states.py
index af0e34ecf..7f3774516 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/steane/preps/pauli_states.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/steane/preps/pauli_states.py
@@ -18,7 +18,7 @@
 from pecos.slr import Barrier, Bit, Block, Comment, If, QReg, Qubit, Repeat
 from pecos.slr.misc import Return
 from pecos.slr.qeclib import qubit
-from pecos.slr.qeclib.qubit import Prep
+from pecos.slr.qeclib.qubit import PZ
 from pecos.slr.qeclib.steane.gates_sq import sqrt_paulis
 from pecos.slr.qeclib.steane.gates_sq.hadamards import H
 from pecos.slr.qeclib.steane.gates_sq.paulis import X, Z
@@ -102,7 +102,7 @@ def __init__(
         if reset_ancilla:
             self.extend(
                 Comment(),
-                Prep(a),
+                PZ(a),
             )
 
         self.extend(
@@ -165,8 +165,8 @@ def __init__(
 
         if reset:
             self.extend(
-                Prep(q),
-                Prep(a),
+                PZ(q),
+                PZ(a),
                 Barrier(q, a),
             )
 
diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/steane/preps/plus_h_state.py b/python/quantum-pecos/src/pecos/slr/qeclib/steane/preps/plus_h_state.py
index db3b946a4..04a6062af 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/steane/preps/plus_h_state.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/steane/preps/plus_h_state.py
@@ -81,7 +81,7 @@ def __init__(
         # non-fault-tolerantly encode logical |+H>
         # ----------------------------------------
         self.extend(
-            qubit.Prep(d[6]),
+            qubit.PZ(d[6]),
             qubit.RY[pc.f64.frac_pi_4](d[6]),
             EncodingCircuit(d),
         )
diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/steane/preps/t_plus_state.py b/python/quantum-pecos/src/pecos/slr/qeclib/steane/preps/t_plus_state.py
index c6061319c..7e8e1a18b 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/steane/preps/t_plus_state.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/steane/preps/t_plus_state.py
@@ -42,7 +42,7 @@ def __init__(self, q: QReg) -> None:
         """
         super().__init__(
             Comment("Initialize logical |T> = T|+>\n============================="),
-            qubit.Prep(q[6]),
+            qubit.PZ(q[6]),
             qubit.H(q[6]),
             qubit.T(q[6]),
             EncodingCircuit(q),
@@ -69,7 +69,7 @@ def __init__(self, q: QReg) -> None:
         """
         super().__init__(
             Comment("Initialize logical |T> = T|+>\n============================="),
-            qubit.Prep(q[6]),
+            qubit.PZ(q[6]),
             qubit.H(q[6]),
             qubit.Tdg(q[6]),
             EncodingCircuit(q),
diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/steane/syn_extract/six_check_nonflagging.py b/python/quantum-pecos/src/pecos/slr/qeclib/steane/syn_extract/six_check_nonflagging.py
index 3ccc9831f..a245006cc 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/steane/syn_extract/six_check_nonflagging.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/steane/syn_extract/six_check_nonflagging.py
@@ -50,7 +50,7 @@ def __init__(self, data: QReg, ancillas: QReg, syn_x: CReg, syn_z: CReg) -> None
             syn_x.set(0),
             syn_z.set(0),
             Comment(),
-            gq.Prep(
+            gq.PZ(
                 q[0],
                 q[8],
                 q[9],
@@ -102,7 +102,7 @@ def __init__(self, data: QReg, ancillas: QReg, syn_x: CReg, syn_z: CReg) -> None
             Comment(),
             Comment("// Z check 1, X check 2, X check 3"),
             Comment(),
-            gq.Prep(
+            gq.PZ(
                 q[0],
                 q[8],
                 q[9],
diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/steane/syn_extract/three_parallel_flagging.py b/python/quantum-pecos/src/pecos/slr/qeclib/steane/syn_extract/three_parallel_flagging.py
index 06d99c0f8..6c8d5e83a 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/steane/syn_extract/three_parallel_flagging.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/steane/syn_extract/three_parallel_flagging.py
@@ -68,7 +68,7 @@ def __init__(
             Comment("X check 1, Z check 2, Z check 3"),
             Comment("==============================="),
             Comment(),
-            gq.Prep(
+            gq.PZ(
                 q[0],
                 q[8],
                 q[9],
@@ -175,7 +175,7 @@ def __init__(
             Comment("Z check 1, X check 2, X check 3"),
             Comment("==============================="),
             Comment(),
-            gq.Prep(
+            gq.PZ(
                 q[0],
                 q[8],
                 q[9],
diff --git a/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/qubit/test_preps.py b/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/qubit/test_preps.py
index fe8a718af..14c6de500 100644
--- a/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/qubit/test_preps.py
+++ b/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/qubit/test_preps.py
@@ -18,8 +18,8 @@
 
 
 def test_Prep(compare_qasm: Callable[..., None]) -> None:
-    """Test Prep gate QASM regression."""
+    """Test PZ gate QASM regression."""
     q = QReg("q_test", 1)
 
-    prog = qubit.Prep(q[0])
+    prog = qubit.PZ(q[0])
     compare_qasm(prog)
diff --git a/python/quantum-pecos/tests/pecos/regression/test_qasm/random_cases/test_control_flow.py b/python/quantum-pecos/tests/pecos/regression/test_qasm/random_cases/test_control_flow.py
index 6e99209e7..7c185623b 100644
--- a/python/quantum-pecos/tests/pecos/regression/test_qasm/random_cases/test_control_flow.py
+++ b/python/quantum-pecos/tests/pecos/regression/test_qasm/random_cases/test_control_flow.py
@@ -98,7 +98,7 @@ def test_phys_tele_block_telep_block(compare_qasm: Callable[..., None]) -> None:
         qb.CX(q[0], q[1]),
         qb.Measure(q) > c,
         Block(
-            qb.Prep(q),
+            qb.PZ(q),
             qb.H(q[0]),
             qb.CX(q[0], q[1]),
             qb.Measure(q) > c2,
diff --git a/python/quantum-pecos/tests/pecos/regression/test_qasm/random_cases/test_slr_phys.py b/python/quantum-pecos/tests/pecos/regression/test_qasm/random_cases/test_slr_phys.py
index b812ca9c2..effcd7b62 100644
--- a/python/quantum-pecos/tests/pecos/regression/test_qasm/random_cases/test_slr_phys.py
+++ b/python/quantum-pecos/tests/pecos/regression/test_qasm/random_cases/test_slr_phys.py
@@ -117,8 +117,8 @@ class Bell(Block):
         def __init__(self, q0: Qubit, q1: Qubit, m0: Bit, m1: Bit) -> None:
             super().__init__()
             self.extend(
-                p.Prep(q0),
-                p.Prep(q1),
+                p.PZ(q0),
+                p.PZ(q1),
                 p.H(q0),
                 p.CX(q0, q1),
                 p.Measure(q0) > m0,
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/analysis/test_depth_analyzer.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/analysis/test_depth_analyzer.py
index 5b542e421..e073a3a80 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/analysis/test_depth_analyzer.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/analysis/test_depth_analyzer.py
@@ -34,20 +34,20 @@ def test_single_gate(self) -> None:
         """Single gate has depth 1."""
         prog = Main(
             q := QReg("q", 1),
-            qb.Prep(q[0]),
+            qb.PZ(q[0]),
             qb.H(q[0]),
         )
         ast = slr_to_ast(prog)
 
         result = analyze_depth(ast)
 
-        assert result.depth == 2  # Prep + H
+        assert result.depth == 2  # PZ + H
 
     def test_sequential_gates_same_qubit(self) -> None:
         """Sequential gates on same qubit add to depth."""
         prog = Main(
             q := QReg("q", 1),
-            qb.Prep(q[0]),
+            qb.PZ(q[0]),
             qb.H(q[0]),
             qb.X(q[0]),
             qb.Z(q[0]),
@@ -56,14 +56,14 @@ def test_sequential_gates_same_qubit(self) -> None:
 
         result = analyze_depth(ast)
 
-        assert result.depth == 4  # Prep + H + X + Z
+        assert result.depth == 4  # PZ + H + X + Z
 
     def test_parallel_gates_different_qubits(self) -> None:
         """Gates on different qubits can run in parallel."""
         prog = Main(
             q := QReg("q", 2),
-            qb.Prep(q[0]),
-            qb.Prep(q[1]),
+            qb.PZ(q[0]),
+            qb.PZ(q[1]),
             qb.H(q[0]),
             qb.X(q[1]),
         )
@@ -71,8 +71,8 @@ def test_parallel_gates_different_qubits(self) -> None:
 
         result = analyze_depth(ast)
 
-        # q[0]: Prep(1) -> H(2)
-        # q[1]: Prep(1) -> X(2)
+        # q[0]: PZ(1) -> H(2)
+        # q[1]: PZ(1) -> X(2)
         # Both paths have depth 2
         assert result.depth == 2
 
@@ -84,8 +84,8 @@ def test_two_qubit_gate_depth(self) -> None:
         """Two-qubit gate increases depth for both qubits."""
         prog = Main(
             q := QReg("q", 2),
-            qb.Prep(q[0]),
-            qb.Prep(q[1]),
+            qb.PZ(q[0]),
+            qb.PZ(q[1]),
             qb.CX(q[0], q[1]),
         )
         ast = slr_to_ast(prog)
@@ -100,8 +100,8 @@ def test_two_qubit_gate_waits_for_both(self) -> None:
         """Two-qubit gate waits for both qubits to be ready."""
         prog = Main(
             q := QReg("q", 2),
-            qb.Prep(q[0]),
-            qb.Prep(q[1]),
+            qb.PZ(q[0]),
+            qb.PZ(q[1]),
             qb.H(q[0]),  # q[0] now at depth 2
             qb.CX(q[0], q[1]),  # Must wait for q[0]
         )
@@ -109,17 +109,17 @@ def test_two_qubit_gate_waits_for_both(self) -> None:
 
         result = analyze_depth(ast)
 
-        # q[0]: Prep(1) -> H(2) -> CX(3)
-        # q[1]: Prep(1) -> (wait) -> CX(3)
+        # q[0]: PZ(1) -> H(2) -> CX(3)
+        # q[1]: PZ(1) -> (wait) -> CX(3)
         assert result.depth == 3
 
     def test_chain_of_two_qubit_gates(self) -> None:
         """Chain of two-qubit gates increases depth."""
         prog = Main(
             q := QReg("q", 3),
-            qb.Prep(q[0]),
-            qb.Prep(q[1]),
-            qb.Prep(q[2]),
+            qb.PZ(q[0]),
+            qb.PZ(q[1]),
+            qb.PZ(q[2]),
             qb.CX(q[0], q[1]),  # Depth 2
             qb.CX(q[1], q[2]),  # Depth 3 (waits for q[1])
         )
@@ -138,8 +138,8 @@ def test_bell_state_depth(self) -> None:
         """Bell state has depth 3 (prep + H + CX)."""
         prog = Main(
             q := QReg("q", 2),
-            qb.Prep(q[0]),
-            qb.Prep(q[1]),
+            qb.PZ(q[0]),
+            qb.PZ(q[1]),
             qb.H(q[0]),
             qb.CX(q[0], q[1]),
         )
@@ -147,8 +147,8 @@ def test_bell_state_depth(self) -> None:
 
         result = analyze_depth(ast)
 
-        # q[0]: Prep(1) -> H(2) -> CX(3)
-        # q[1]: Prep(1) -> (wait) -> CX(3)
+        # q[0]: PZ(1) -> H(2) -> CX(3)
+        # q[1]: PZ(1) -> (wait) -> CX(3)
         assert result.depth == 3
 
 
@@ -159,7 +159,7 @@ def test_repeat_adds_depth(self) -> None:
         """Repeat loop adds depth for each iteration."""
         prog = Main(
             q := QReg("q", 1),
-            qb.Prep(q[0]),
+            qb.PZ(q[0]),
             Repeat(cond=3).block(
                 qb.H(q[0]),
             ),
@@ -168,7 +168,7 @@ def test_repeat_adds_depth(self) -> None:
 
         result = analyze_depth(ast)
 
-        # Prep(1) + H(2) + H(3) + H(4)
+        # PZ(1) + H(2) + H(3) + H(4)
         assert result.depth == 4
 
 
@@ -181,9 +181,9 @@ def test_syndrome_extraction_depth(self) -> None:
             data := QReg("data", 2),
             ancilla := QReg("ancilla", 1),
             c := CReg("c", 1),
-            qb.Prep(data[0]),
-            qb.Prep(data[1]),
-            qb.Prep(ancilla[0]),
+            qb.PZ(data[0]),
+            qb.PZ(data[1]),
+            qb.PZ(ancilla[0]),
             qb.CX(data[0], ancilla[0]),
             qb.CX(data[1], ancilla[0]),
             qb.Measure(ancilla[0]) > c[0],
@@ -209,12 +209,12 @@ def test_analyzer_reusable(self) -> None:
 
         prog1 = Main(
             q := QReg("q", 1),
-            qb.Prep(q[0]),
+            qb.PZ(q[0]),
             qb.H(q[0]),
         )
         prog2 = Main(
             q := QReg("q", 1),
-            qb.Prep(q[0]),
+            qb.PZ(q[0]),
             qb.H(q[0]),
             qb.X(q[0]),
         )
@@ -232,8 +232,8 @@ def test_result_string_representation(self) -> None:
         """DepthResult has useful string representation."""
         prog = Main(
             q := QReg("q", 2),
-            qb.Prep(q[0]),
-            qb.Prep(q[1]),
+            qb.PZ(q[0]),
+            qb.PZ(q[1]),
             qb.H(q[0]),
             qb.CX(q[0], q[1]),
         )
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/analysis/test_qubit_state_validator.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/analysis/test_qubit_state_validator.py
index 0b73439f2..feb642c17 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/analysis/test_qubit_state_validator.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/analysis/test_qubit_state_validator.py
@@ -56,7 +56,7 @@ def test_gate_with_prep_passes(self) -> None:
         """Gate on prepared qubit should pass."""
         prog = Main(
             q := QReg("q", 1),
-            qb.Prep(q[0]),
+            qb.PZ(q[0]),
             qb.H(q[0]),
         )
         ast = slr_to_ast(prog)
@@ -69,7 +69,7 @@ def test_multiple_gates_after_prep(self) -> None:
         """Multiple gates after prep should all pass."""
         prog = Main(
             q := QReg("q", 1),
-            qb.Prep(q[0]),
+            qb.PZ(q[0]),
             qb.H(q[0]),
             qb.X(q[0]),
             qb.Z(q[0]),
@@ -89,7 +89,7 @@ def test_gate_after_measure_fails(self) -> None:
         prog = Main(
             q := QReg("q", 1),
             c := CReg("c", 1),
-            qb.Prep(q[0]),
+            qb.PZ(q[0]),
             qb.H(q[0]),
             qb.Measure(q[0]) > c[0],
             qb.X(q[0]),  # Gate after measure
@@ -107,10 +107,10 @@ def test_reprep_after_measure_passes(self) -> None:
         prog = Main(
             q := QReg("q", 1),
             c := CReg("c", 1),
-            qb.Prep(q[0]),
+            qb.PZ(q[0]),
             qb.H(q[0]),
             qb.Measure(q[0]) > c[0],
-            qb.Prep(q[0]),  # Re-prep
+            qb.PZ(q[0]),  # Re-prep
             qb.X(q[0]),
         )
         ast = slr_to_ast(prog)
@@ -127,8 +127,8 @@ def test_two_qubit_gate_both_prepared(self) -> None:
         """Two-qubit gate with both qubits prepared should pass."""
         prog = Main(
             q := QReg("q", 2),
-            qb.Prep(q[0]),
-            qb.Prep(q[1]),
+            qb.PZ(q[0]),
+            qb.PZ(q[1]),
             qb.CX(q[0], q[1]),
         )
         ast = slr_to_ast(prog)
@@ -141,7 +141,7 @@ def test_two_qubit_gate_one_unprepared(self) -> None:
         """Two-qubit gate with one qubit unprepared should fail."""
         prog = Main(
             q := QReg("q", 2),
-            qb.Prep(q[0]),
+            qb.PZ(q[0]),
             # q[1] not prepared
             qb.CX(q[0], q[1]),
         )
@@ -169,12 +169,12 @@ class TestQubitStateValidatorControlFlow:
     """Control flow tests."""
 
     def test_if_branch_prep_not_sufficient(self) -> None:
-        """Prep in only one branch is not sufficient."""
+        """PZ in only one branch is not sufficient."""
         prog = Main(
             q := QReg("q", 1),
             c := CReg("c", 1),
             If(c[0] == 1).Then(
-                qb.Prep(q[0]),
+                qb.PZ(q[0]),
             ),
             # After if, q[0] might not be prepared (else branch doesn't prep)
             qb.H(q[0]),
@@ -186,16 +186,16 @@ def test_if_branch_prep_not_sufficient(self) -> None:
         assert len(violations) == 1
 
     def test_if_both_branches_prep(self) -> None:
-        """Prep in both branches is sufficient."""
+        """PZ in both branches is sufficient."""
         prog = Main(
             q := QReg("q", 1),
             c := CReg("c", 1),
             If(c[0] == 1)
             .Then(
-                qb.Prep(q[0]),
+                qb.PZ(q[0]),
             )
             .Else(
-                qb.Prep(q[0]),
+                qb.PZ(q[0]),
             ),
             qb.H(q[0]),  # Safe - prepared in both branches
         )
@@ -210,7 +210,7 @@ def test_if_body_uses_prep_from_before(self) -> None:
         prog = Main(
             q := QReg("q", 1),
             c := CReg("c", 1),
-            qb.Prep(q[0]),
+            qb.PZ(q[0]),
             If(c[0] == 1).Then(
                 qb.H(q[0]),
             ),
@@ -225,7 +225,7 @@ def test_repeat_uses_prep_from_before(self) -> None:
         """Repeat body can use prep from before."""
         prog = Main(
             q := QReg("q", 1),
-            qb.Prep(q[0]),
+            qb.PZ(q[0]),
             Repeat(cond=3).block(
                 qb.H(q[0]),
             ),
@@ -246,11 +246,11 @@ def test_syndrome_extraction_pattern(self) -> None:
             data := QReg("data", 2),
             ancilla := QReg("ancilla", 1),
             c := CReg("c", 1),
-            # Prep data qubits
-            qb.Prep(data[0]),
-            qb.Prep(data[1]),
-            # Prep ancilla
-            qb.Prep(ancilla[0]),
+            # PZ data qubits
+            qb.PZ(data[0]),
+            qb.PZ(data[1]),
+            # PZ ancilla
+            qb.PZ(ancilla[0]),
             # Syndrome extraction
             qb.CX(data[0], ancilla[0]),
             qb.CX(data[1], ancilla[0]),
@@ -269,16 +269,16 @@ def test_repeated_syndrome_extraction(self) -> None:
             data := QReg("data", 2),
             ancilla := QReg("ancilla", 1),
             c := CReg("c", 1),
-            # Prep everything
-            qb.Prep(data[0]),
-            qb.Prep(data[1]),
-            qb.Prep(ancilla[0]),
+            # PZ everything
+            qb.PZ(data[0]),
+            qb.PZ(data[1]),
+            qb.PZ(ancilla[0]),
             # First round
             qb.CX(data[0], ancilla[0]),
             qb.CX(data[1], ancilla[0]),
             qb.Measure(ancilla[0]) > c[0],
             # Second round - need to re-prep ancilla
-            qb.Prep(ancilla[0]),
+            qb.PZ(ancilla[0]),
             qb.CX(data[0], ancilla[0]),
             qb.CX(data[1], ancilla[0]),
             qb.Measure(ancilla[0]) > c[0],
@@ -305,7 +305,7 @@ def test_validator_reusable(self) -> None:
 
         prog2 = Main(
             q := QReg("q", 1),
-            qb.Prep(q[0]),
+            qb.PZ(q[0]),
             qb.H(q[0]),  # No violation
         )
         ast2 = slr_to_ast(prog2)
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/analysis/test_resource_counter.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/analysis/test_resource_counter.py
index 5eaa13e26..4b08f3355 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/analysis/test_resource_counter.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/analysis/test_resource_counter.py
@@ -84,7 +84,7 @@ def test_single_qubit_gates(self) -> None:
         """Single-qubit gates are counted."""
         prog = Main(
             q := QReg("q", 1),
-            qb.Prep(q[0]),
+            qb.PZ(q[0]),
             qb.H(q[0]),
             qb.X(q[0]),
             qb.Z(q[0]),
@@ -93,7 +93,7 @@ def test_single_qubit_gates(self) -> None:
 
         result = count_resources(ast)
 
-        assert result.total_gates == 3  # H, X, Z (Prep is not a gate)
+        assert result.total_gates == 3  # H, X, Z (PZ is not a gate)
         assert result.single_qubit_gates == 3
         assert result.two_qubit_gates == 0
 
@@ -101,8 +101,8 @@ def test_two_qubit_gates(self) -> None:
         """Two-qubit gates are counted."""
         prog = Main(
             q := QReg("q", 2),
-            qb.Prep(q[0]),
-            qb.Prep(q[1]),
+            qb.PZ(q[0]),
+            qb.PZ(q[1]),
             qb.CX(q[0], q[1]),
             qb.CZ(q[0], q[1]),
         )
@@ -118,8 +118,8 @@ def test_mixed_gates(self) -> None:
         """Mixed single and two-qubit gates are counted correctly."""
         prog = Main(
             q := QReg("q", 2),
-            qb.Prep(q[0]),
-            qb.Prep(q[1]),
+            qb.PZ(q[0]),
+            qb.PZ(q[1]),
             qb.H(q[0]),
             qb.CX(q[0], q[1]),
             qb.X(q[1]),
@@ -136,8 +136,8 @@ def test_gate_counts_by_type(self) -> None:
         """Gates are counted by type."""
         prog = Main(
             q := QReg("q", 2),
-            qb.Prep(q[0]),
-            qb.Prep(q[1]),
+            qb.PZ(q[0]),
+            qb.PZ(q[1]),
             qb.H(q[0]),
             qb.H(q[1]),
             qb.CX(q[0], q[1]),
@@ -159,8 +159,8 @@ def test_measurements_counted(self) -> None:
         prog = Main(
             q := QReg("q", 2),
             c := CReg("c", 2),
-            qb.Prep(q[0]),
-            qb.Prep(q[1]),
+            qb.PZ(q[0]),
+            qb.PZ(q[1]),
             qb.Measure(q[0]) > c[0],
             qb.Measure(q[1]) > c[1],
         )
@@ -174,8 +174,8 @@ def test_preparations_counted(self) -> None:
         """Preparations are counted."""
         prog = Main(
             q := QReg("q", 2),
-            qb.Prep(q[0]),
-            qb.Prep(q[1]),
+            qb.PZ(q[0]),
+            qb.PZ(q[1]),
         )
         ast = slr_to_ast(prog)
 
@@ -191,7 +191,7 @@ def test_repeat_multiplies_resources(self) -> None:
         """Repeat loop multiplies gate counts."""
         prog = Main(
             q := QReg("q", 1),
-            qb.Prep(q[0]),
+            qb.PZ(q[0]),
             Repeat(cond=5).block(
                 qb.H(q[0]),
                 qb.X(q[0]),
@@ -215,9 +215,9 @@ def test_syndrome_extraction_resources(self) -> None:
             data := QReg("data", 2),
             ancilla := QReg("ancilla", 1),
             c := CReg("c", 1),
-            qb.Prep(data[0]),
-            qb.Prep(data[1]),
-            qb.Prep(ancilla[0]),
+            qb.PZ(data[0]),
+            qb.PZ(data[1]),
+            qb.PZ(ancilla[0]),
             qb.CX(data[0], ancilla[0]),
             qb.CX(data[1], ancilla[0]),
             qb.Measure(ancilla[0]) > c[0],
@@ -257,7 +257,7 @@ def test_result_string_representation(self) -> None:
         prog = Main(
             q := QReg("q", 2),
             _c := CReg("c", 1),
-            qb.Prep(q[0]),
+            qb.PZ(q[0]),
             qb.H(q[0]),
             qb.CX(q[0], q[1]),
         )
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_codegen_guppy.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_codegen_guppy.py
index b47ffba3e..9cf53c5af 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_codegen_guppy.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_codegen_guppy.py
@@ -108,7 +108,7 @@ def test_multiple_gates(self) -> None:
 
 
 class TestAstToGuppyPrepMeasure:
-    """Prep and measure code generation tests."""
+    """PZ and measure code generation tests."""
 
     def test_measure_with_result(self) -> None:
         """Measure with explicit Return generates variable and return."""
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_codegen_qasm.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_codegen_qasm.py
index c6499f7f6..e4694f05b 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_codegen_qasm.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_codegen_qasm.py
@@ -141,7 +141,7 @@ def test_phase_gates(self) -> None:
 
 
 class TestAstToQasmPrepMeasure:
-    """Prep and measure code generation tests."""
+    """PZ and measure code generation tests."""
 
     def test_measure_with_result(self) -> None:
         """Measure with result generates arrow syntax."""
@@ -157,10 +157,10 @@ def test_measure_with_result(self) -> None:
         assert "measure q[0] -> c[0];" in code
 
     def test_prep_reset(self) -> None:
-        """Prep generates reset operation."""
+        """PZ generates reset operation."""
         prog = Main(
             q := QReg("q", 1),
-            qb.Prep(q[0]),
+            qb.PZ(q[0]),
         )
         ast = slr_to_ast(prog)
 
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_codegen_qir.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_codegen_qir.py
index c871947d4..6cf6fd09d 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_codegen_qir.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_codegen_qir.py
@@ -146,7 +146,7 @@ def test_two_qubit_cz_gate(self) -> None:
 
 
 class TestAstToQirPrepMeasure:
-    """Prep and measure code generation tests."""
+    """PZ and measure code generation tests."""
 
     def test_measurement(self) -> None:
         """Measurement generates mz_to_creg_bit call."""
@@ -163,10 +163,10 @@ def test_measurement(self) -> None:
         assert "mz_to_creg_bit" in llvm_ir
 
     def test_prep_reset(self) -> None:
-        """Prep generates reset_body call."""
+        """PZ generates reset_body call."""
         prog = Main(
             q := QReg("q", 1),
-            qb.Prep(q[0]),
+            qb.PZ(q[0]),
         )
         ast = slr_to_ast(prog)
 
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_codegen_quantum_circuit.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_codegen_quantum_circuit.py
index 402dda193..f1f1b1576 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_codegen_quantum_circuit.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_codegen_quantum_circuit.py
@@ -148,7 +148,7 @@ def test_multiple_gates_different_qubits(self) -> None:
 
 
 class TestAstToQuantumCircuitPrepMeasure:
-    """Prep and measure code generation tests."""
+    """PZ and measure code generation tests."""
 
     def test_measurement(self) -> None:
         """Measurement creates tick with Measure operation."""
@@ -167,10 +167,10 @@ def test_measurement(self) -> None:
         assert 0 in tick["Measure"]
 
     def test_prep_reset(self) -> None:
-        """Prep creates tick with RESET operation."""
+        """PZ creates tick with RESET operation."""
         prog = Main(
             q := QReg("q", 1),
-            qb.Prep(q[0]),
+            qb.PZ(q[0]),
         )
         ast = slr_to_ast(prog)
 
@@ -390,7 +390,7 @@ def test_circuit_with_repeated_syndrome(self) -> None:
                 qb.CX(data[0], ancilla[0]),
                 qb.CX(data[1], ancilla[0]),
                 qb.Measure(ancilla[0]) > c[0],
-                qb.Prep(ancilla[0]),
+                qb.PZ(ancilla[0]),
             ),
         )
 
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_codegen_stim.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_codegen_stim.py
index 24970736c..14c42dd8c 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_codegen_stim.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_codegen_stim.py
@@ -168,7 +168,7 @@ def test_multiple_gates(self) -> None:
 
 
 class TestAstToStimPrepMeasure:
-    """Prep and measure code generation tests."""
+    """PZ and measure code generation tests."""
 
     def test_measurement(self) -> None:
         """Measurement generates M instruction."""
@@ -202,10 +202,10 @@ def test_multiple_measurements(self) -> None:
         assert "1" in code
 
     def test_prep_reset(self) -> None:
-        """Prep generates R (reset) instruction."""
+        """PZ generates R (reset) instruction."""
         prog = Main(
             q := QReg("q", 1),
-            qb.Prep(q[0]),
+            qb.PZ(q[0]),
         )
         ast = slr_to_ast(prog)
 
@@ -299,7 +299,7 @@ def test_repeated_syndrome_extraction(self) -> None:
                 qb.CX(data[0], ancilla[0]),
                 qb.CX(data[1], ancilla[0]),
                 qb.Measure(ancilla[0]) > c[0],
-                qb.Prep(ancilla[0]),
+                qb.PZ(ancilla[0]),
             ),
         )
         ast = slr_to_ast(prog)
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_converter.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_converter.py
index 91d0a699a..62e0ab209 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_converter.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_converter.py
@@ -142,13 +142,13 @@ def test_multiple_gates(self) -> None:
 
 
 class TestSlrToAstPrepMeasure:
-    """Prep and Measure conversion tests."""
+    """PZ and Measure conversion tests."""
 
     def test_prep_operation(self) -> None:
-        """Prep converts to PrepareOp with correct allocator and slots."""
+        """PZ converts to PrepareOp with correct allocator and slots."""
         prog = Main(
             q := QReg("q", 2),
-            qb.Prep(q[0]),
+            qb.PZ(q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -298,9 +298,9 @@ def test_syndrome_extraction_pattern(self) -> None:
             ancilla := QReg("ancilla", 1),
             c := CReg("c", 1),
             # Initialize
-            qb.Prep(data[0]),
-            qb.Prep(data[1]),
-            qb.Prep(ancilla[0]),
+            qb.PZ(data[0]),
+            qb.PZ(data[1]),
+            qb.PZ(ancilla[0]),
             # Syndrome extraction
             qb.CX(data[0], ancilla[0]),
             qb.CX(data[1], ancilla[0]),
@@ -330,9 +330,9 @@ def test_round_trip_preserves_structure(self) -> None:
         prog = Main(
             q := QReg("q", 3),
             c := CReg("c", 1),
-            qb.Prep(q[0]),
-            qb.Prep(q[1]),
-            qb.Prep(q[2]),
+            qb.PZ(q[0]),
+            qb.PZ(q[1]),
+            qb.PZ(q[2]),
             qb.H(q[0]),
             qb.CX(q[0], q[1]),
             qb.CX(q[1], q[2]),
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_roundtrip.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_roundtrip.py
index df9eb3e33..b43a533e5 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_roundtrip.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_roundtrip.py
@@ -137,7 +137,7 @@ def test_qec_syndrome_qasm_structure(self) -> None:
             data := QReg("data", 2),
             ancilla := QReg("ancilla", 1),
             c := CReg("c", 1),
-            qb.Prep(ancilla[0]),
+            qb.PZ(ancilla[0]),
             qb.CX(data[0], ancilla[0]),
             qb.CX(data[1], ancilla[0]),
             qb.Measure(ancilla[0]) > c[0],
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_visitor.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_visitor.py
index 0d1b838b9..716bf8a2e 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_visitor.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_visitor.py
@@ -191,8 +191,8 @@ def visit_gate(self, node: GateOp) -> str:
             def visit_prepare(self, node: PrepareOp) -> str:
                 if node.slots:
                     slots = ", ".join(str(s) for s in node.slots)
-                    return f"Prep({node.allocator}[{slots}])"
-                return f"Prep({node.allocator}[*])"
+                    return f"PZ({node.allocator}[{slots}])"
+                return f"PZ({node.allocator}[*])"
 
             def visit_measure(self, node: MeasureOp) -> str:
                 targets = ", ".join(str(t) for t in node.targets)
@@ -209,7 +209,7 @@ def visit_measure(self, node: MeasureOp) -> str:
         prog = Program(name="test", body=(prep, gate1, gate2, measure))
 
         code = visitor.visit(prog)
-        assert "Prep(q[0, 1])" in code
+        assert "PZ(q[0, 1])" in code
         assert "H(q[0])" in code
         assert "CX(q[0], q[1])" in code
         assert "Measure(q[0])" in code
diff --git a/python/quantum-pecos/tests/qec/surface/test_circuit_fuzz.py b/python/quantum-pecos/tests/qec/surface/test_circuit_fuzz.py
index d368f82d9..976829c83 100644
--- a/python/quantum-pecos/tests/qec/surface/test_circuit_fuzz.py
+++ b/python/quantum-pecos/tests/qec/surface/test_circuit_fuzz.py
@@ -492,9 +492,9 @@ def test_sz_phase_single_qubit(self):
         sim = SparseStab(3)
         # Qubit 0: data (|+>), Qubit 1: ancilla 1 (|+Y>), Qubit 2: ancilla 2 (|+Y>)
 
-        # Prep |+>
+        # PZ |+>
         sim.run_gate("H", {0})
-        # Prep |+Y> = S|+>
+        # PZ |+Y> = S|+>
         sim.run_gate("H", {1})
         sim.run_gate("SZ", {1})
         sim.run_gate("H", {2})
diff --git a/python/quantum-pecos/tests/qec/test_dem_sampler_vs_stim.py b/python/quantum-pecos/tests/qec/test_dem_sampler_vs_stim.py
index e21072a7f..dd4f7d943 100644
--- a/python/quantum-pecos/tests/qec/test_dem_sampler_vs_stim.py
+++ b/python/quantum-pecos/tests/qec/test_dem_sampler_vs_stim.py
@@ -793,7 +793,7 @@ def test_random_circuit_fault_locations_match(self, seed: int) -> None:
             name = instruction.name
             targets = instruction.targets_copy()
             if name == "R":
-                stim_op_count += len(targets)  # Prep error after
+                stim_op_count += len(targets)  # PZ error after
             elif name in ("H", "S", "S_DAG"):
                 stim_op_count += len(targets)  # Gate error after
             elif name == "CX":
diff --git a/python/quantum-pecos/tests/qec/test_fault_catalog.py b/python/quantum-pecos/tests/qec/test_fault_catalog.py
index bd2950276..311faef88 100644
--- a/python/quantum-pecos/tests/qec/test_fault_catalog.py
+++ b/python/quantum-pecos/tests/qec/test_fault_catalog.py
@@ -221,7 +221,7 @@ def test_prep_fault_with_no_effect_included(self):
         fault = prep_locs[0].faults[0]
         assert fault.kind == "prep_flip"
         assert fault.pauli is None
-        # Prep X through H becomes Z which doesn't flip MZ → empty
+        # PZ X through H becomes Z which doesn't flip MZ → empty
         assert fault.measurements == []
 
 
diff --git a/python/quantum-pecos/tests/qec/test_meas_sampling_generality.py b/python/quantum-pecos/tests/qec/test_meas_sampling_generality.py
index f8315c5f5..1532453b9 100644
--- a/python/quantum-pecos/tests/qec/test_meas_sampling_generality.py
+++ b/python/quantum-pecos/tests/qec/test_meas_sampling_generality.py
@@ -92,12 +92,12 @@ def det_rate(results):
 
 
 class TestPrepFaultAbsorption:
-    """Prep faults propagate forward but get absorbed at PZ/MZ."""
+    """PZ faults propagate forward but get absorbed at PZ/MZ."""
 
     def test_prep_fault_reaches_next_measurement(self):
         """A prep fault on PZ(ancilla) should flip the next ancilla MZ."""
         tc = build_two_round_x_check()
-        # Prep-only noise
+        # PZ-only noise
         depol = depolarizing().p1(0).p2(0).p_meas(0).p_prep(0.01)
         shots = 50000
 
@@ -110,11 +110,11 @@ def det_rate(results):
         meas_rate = det_rate(meas_r)
         stab_rate = det_rate(stab_r)
 
-        # Prep faults fire the detector (X error → detected at MZ)
+        # PZ faults fire the detector (X error → detected at MZ)
         assert stab_rate > 0.005, f"Stabilizer should see prep faults: {stab_rate}"
         assert (
             abs(meas_rate - stab_rate) / stab_rate < 0.15
-        ), f"Prep fault rate mismatch: dem={meas_rate:.4f} stab={stab_rate:.4f}"
+        ), f"PZ fault rate mismatch: dem={meas_rate:.4f} stab={stab_rate:.4f}"
 
     def test_prep_fault_does_not_cross_reset(self):
         """A prep fault should NOT propagate past a subsequent PZ on the same qubit."""
diff --git a/python/quantum-pecos/tests/selene/test_hugr_to_ast.py b/python/quantum-pecos/tests/selene/test_hugr_to_ast.py
index cbc5d051c..a654c60f7 100644
--- a/python/quantum-pecos/tests/selene/test_hugr_to_ast.py
+++ b/python/quantum-pecos/tests/selene/test_hugr_to_ast.py
@@ -74,7 +74,7 @@ def single_h() -> bool:
         assert alloc_decls[0].name == "q"
         assert alloc_decls[0].capacity == 1
 
-        # Check body has Prep, H, Measure
+        # Check body has PZ, H, Measure
         assert len(ast.body) == 3
 
         # First should be PrepareOp
@@ -261,7 +261,7 @@ def minimal() -> bool:
 
         ast = guppy_to_ast(minimal)
 
-        # Should have Prep and Measure only
+        # Should have PZ and Measure only
         assert len(ast.body) == 2
         assert isinstance(ast.body[0], PrepareOp)
         assert isinstance(ast.body[1], MeasureOp)
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
index 0d813a8c1..e57a6338b 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
@@ -277,7 +277,7 @@ def _examples_surface_d3_z_1round() -> Block:
     examples/surface_code_slr_exploration.ipynb::build_surface_code_slr.
 
     distance=3, num_rounds=1, basis="Z". Pure-v1 gate surface
-    (Prep, H, CX, Measure, Barrier) over multi-QReg. Real-shaped
+    (PZ, H, CX, Measure, Barrier) over multi-QReg. Real-shaped
     program: 9 data + 4 X-anc + 4 Z-anc, 4 CNOT rounds.
     """
     patch = SurfacePatch.create(distance=3)
@@ -291,11 +291,11 @@ def _examples_surface_d3_z_1round() -> Block:
     z_anc = QReg("az", num_z)
 
     ops: list = []
-    ops.extend(qb.Prep(data[i]) for i in range(geom.num_data))
+    ops.extend(qb.PZ(data[i]) for i in range(geom.num_data))
     ops.append(Barrier())
 
-    ops.extend(qb.Prep(x_anc[i]) for i in range(num_x))
-    ops.extend(qb.Prep(z_anc[i]) for i in range(num_z))
+    ops.extend(qb.PZ(x_anc[i]) for i in range(num_x))
+    ops.extend(qb.PZ(z_anc[i]) for i in range(num_z))
     ops.append(Barrier())
 
     ops.extend(qb.H(x_anc[i]) for i in range(num_x))
@@ -339,12 +339,12 @@ def _examples_surface_d3_x_1round() -> Block:
     z_anc = QReg("az", num_z)
 
     ops: list = []
-    ops.extend(qb.Prep(data[i]) for i in range(geom.num_data))
+    ops.extend(qb.PZ(data[i]) for i in range(geom.num_data))
     ops.extend(qb.H(data[i]) for i in range(geom.num_data))
     ops.append(Barrier())
 
-    ops.extend(qb.Prep(x_anc[i]) for i in range(num_x))
-    ops.extend(qb.Prep(z_anc[i]) for i in range(num_z))
+    ops.extend(qb.PZ(x_anc[i]) for i in range(num_x))
+    ops.extend(qb.PZ(z_anc[i]) for i in range(num_z))
     ops.append(Barrier())
 
     ops.extend(qb.H(x_anc[i]) for i in range(num_x))
@@ -600,15 +600,15 @@ def _docs_for_loopvar_symbolic_v2_defer() -> Block:
 
 
 def _docs_prep_basis_x_v2_defer() -> Block:
-    """Deliberate red-light: Prep with explicit "X" basis is v2-defer.
+    """Deliberate red-light: PZ with explicit "X" basis is v2-defer.
 
-    Per v1-feature-matrix: "Current Prep gate is reset-to-zero in the AST.
-    V1 supports Z reset only. Use Prep(q); H(q) for X-basis prep."
+    Per v1-feature-matrix: "Current PZ gate is reset-to-zero in the AST.
+    V1 supports Z reset only. Use PZ(q); H(q) for X-basis prep."
     """
     return Main(
         q := QReg("q", 1),
         c := CReg("c", 1),
-        qb.Prep(q[0], "X"),
+        qb.PZ(q[0], "X"),
         Measure(q) > c,
         Return(c),
     )
@@ -642,8 +642,8 @@ def _docs_inline_measure_creg() -> Block:
 def _docs_surface_syndrome_block18_probe() -> Block:
     """Probe: surface_code_syndrome doc-test shape from test_slr_qeclib_block_18.
 
-    Uses basis-arg Prep("Z") and Prep("X") plus Block-grouped operations.
-    Likely XFAIL on the Prep basis arg (v2-defer); probe to record exact
+    Uses basis-arg PZ("Z") and PZ("X") plus Block-grouped operations.
+    Likely XFAIL on the PZ basis arg (v2-defer); probe to record exact
     failure or surface a real gap.
     """
     d = 2
@@ -653,9 +653,9 @@ def _docs_surface_syndrome_block18_probe() -> Block:
         data := QReg("data", num_data),
         ancilla := QReg("anc", num_ancilla),
         syn := CReg("syn", num_ancilla),
-        Block(*[qb.Prep(data[i], "Z") for i in range(num_data)]),
+        Block(*[qb.PZ(data[i], "Z") for i in range(num_data)]),
         Block(
-            qb.Prep(ancilla[0], "X"),
+            qb.PZ(ancilla[0], "X"),
             qb.H(ancilla[0]),
             qb.CX(ancilla[0], data[0]),
             qb.CX(ancilla[0], data[1]),
@@ -663,7 +663,7 @@ def _docs_surface_syndrome_block18_probe() -> Block:
             Measure(ancilla[0]) > syn[0],
         ),
         Block(
-            qb.Prep(ancilla[1], "Z"),
+            qb.PZ(ancilla[1], "Z"),
             qb.CX(data[0], ancilla[1]),
             qb.CX(data[3], ancilla[1]),
             Measure(ancilla[1]) > syn[1],
@@ -754,9 +754,9 @@ def _curated_cases() -> list[AuditCase]:
             _docs_prep_basis_x_v2_defer,
             expected_failure=ExpectedFailure(
                 exception_type="GuppyCodegenError",
-                message_contains="supports only Z-basis Prep",
+                message_contains="supports only Z-basis PZ",
                 classification="v2-defer",
-                reason="Non-Z Prep basis semantics are not represented in the v1 AST",
+                reason="Non-Z PZ basis semantics are not represented in the v1 AST",
             ),
         ),
         AuditCase(
@@ -774,9 +774,9 @@ def _curated_cases() -> list[AuditCase]:
             _docs_surface_syndrome_block18_probe,
             expected_failure=ExpectedFailure(
                 exception_type="GuppyCodegenError",
-                message_contains="supports only Z-basis Prep",
+                message_contains="supports only Z-basis PZ",
                 classification="v2-defer",
-                reason="Doc-test includes Prep('X'); inline result CReg shape is covered separately",
+                reason="Doc-test includes PZ('X'); inline result CReg shape is covered separately",
             ),
         ),
     ]
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
index af7ce2ee4..240dbb71f 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
@@ -42,10 +42,10 @@ def test_hugr_rejects_while_before_parallel_optimizer_erases_it() -> None:
 def test_hugr_rejects_non_z_prep_basis_before_ast_drops_it() -> None:
     prog = Main(
         q := QReg("q", 1),
-        qb.Prep(q[0], "X"),
+        qb.PZ(q[0], "X"),
     )
 
-    with pytest.raises(GuppyCodegenError, match="supports only Z-basis Prep"):
+    with pytest.raises(GuppyCodegenError, match="supports only Z-basis PZ"):
         SlrConverter(prog).hugr()
 
 
@@ -164,7 +164,7 @@ def test_hugr_inline_measure_creg_inside_nested_repeat() -> None:
         Repeat(2).block(
             qb.X(q[0]),
             Measure(q[0]) > flag[0],
-            qb.Prep(q[0]),
+            qb.PZ(q[0]),
         ),
         Return(flag),
     )
@@ -189,7 +189,7 @@ def test_hugr_explicit_return_of_declared_creg() -> None:
     prog = Main(
         q := QReg("q", 1),
         c := CReg("c", 1),
-        qb.Prep(q[0]),
+        qb.PZ(q[0]),
         Measure(q[0]) > c[0],
         Return(c),
     )
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
index ab6d8b9ef..546103b5a 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
@@ -440,7 +440,7 @@ def __init__(self, q: QReg) -> None:
         return Main(
             outer := QReg("outer", 2),
             c := CReg("c", 2),
-            qb.Prep(outer),
+            qb.PZ(outer),
             OuterBlock(outer),
             Measure(outer) > c,
             Return(c),
@@ -495,7 +495,7 @@ def __init__(self, q: QReg) -> None:
         prog = Main(
             outer := QReg("outer", 2),
             c := CReg("c", 2),
-            qb.Prep(outer),
+            qb.PZ(outer),
             InnerBlock(outer),
             OuterBlock(outer),
             Measure(outer) > c,
@@ -1567,7 +1567,7 @@ def __init__(self, q: QReg) -> None:
         prog = Main(
             outer := QReg("outer", 2),
             c := CReg("c", 2),
-            qb.Prep(outer),
+            qb.PZ(outer),
             SwapBlock(outer),
             Measure(outer) > c,
             Return(c),
@@ -1638,7 +1638,7 @@ def __init__(self, q: QReg) -> None:
         prog = Main(
             outer_q := QReg("outer_q", 2),
             c := CReg("c", 2),
-            qb.Prep(outer_q),
+            qb.PZ(outer_q),
             BellBlock(outer_q),
             Measure(outer_q) > c,
             Return(c),
@@ -1683,7 +1683,7 @@ def __init__(self, q: QReg) -> None:
         prog = Main(
             outer_q := QReg("outer_q", 2),
             c := CReg("c", 2),
-            qb.Prep(outer_q),
+            qb.PZ(outer_q),
             BellBlock(outer_q),
             Measure(outer_q) > c,
             Return(c),
@@ -1790,7 +1790,7 @@ def __init__(self, q) -> None:
         prog = Main(
             outer_q := QReg("outer_q", 1),
             c := CReg("c", 1),
-            qb.Prep(outer_q),
+            qb.PZ(outer_q),
             SqBlock(outer_q[0]),
             Measure(outer_q) > c,
             Return(c),
@@ -1828,7 +1828,7 @@ def __init__(self, d) -> None:
         prog = Main(
             outer_q := QReg("outer_q", 3),
             c := CReg("c", 3),
-            qb.Prep(outer_q),
+            qb.PZ(outer_q),
             BundleBlock([outer_q[0], outer_q[2]]),
             Measure(outer_q) > c,
             Return(c),
@@ -1871,8 +1871,8 @@ def __init__(self, d) -> None:
             qa := QReg("qa", 2),
             qb_reg := QReg("qb", 2),
             c := CReg("c", 4),
-            qb.Prep(qa),
-            qb.Prep(qb_reg),
+            qb.PZ(qa),
+            qb.PZ(qb_reg),
             BundleBlock([qa[0], qb_reg[1]]),
             Measure(qa) > c[0:2],
             Measure(qb_reg) > c[2:4],
@@ -1938,7 +1938,7 @@ def __init__(self, d, a, out) -> None:
         prog = Main(
             outer_q := QReg("outer_q", 3),
             c := CReg("c", 3),
-            qb.Prep(outer_q),
+            qb.PZ(outer_q),
             CheckLike([outer_q[0], outer_q[1]], outer_q[2], c[0]),
             Measure(outer_q[0]) > c[1],
             Measure(outer_q[1]) > c[2],
@@ -2168,7 +2168,7 @@ def __init__(self, d, a, out) -> None:
                 self.d = d
                 self.a = a
                 self.out = out
-                self.extend(qb.Prep(a), qb.CX(a, d[0]), qb.CX(a, d[1]), Measure(a) > out)
+                self.extend(qb.PZ(a), qb.CX(a, d[0]), qb.CX(a, d[1]), Measure(a) > out)
 
         return GoodCheck
 
@@ -2186,7 +2186,7 @@ def test_scratch_detected_excluded_from_out_bindings(self) -> None:
         prog = Main(
             q := QReg("q", 3),
             c := CReg("c", 1),
-            qb.Prep(q),
+            qb.PZ(q),
             good_check([q[0], q[1]], q[2], c[0]),
             Return(c),
         )
@@ -2211,7 +2211,7 @@ def test_scratch_flatten_substitutes_to_outer_slot(self) -> None:
         prog = Main(
             q := QReg("q", 3),
             c := CReg("c", 1),
-            qb.Prep(q),
+            qb.PZ(q),
             good_check([q[0], q[1]], q[2], c[0]),
             Return(c),
         )
@@ -2225,7 +2225,7 @@ def test_scratch_flatten_substitutes_to_outer_slot(self) -> None:
     def test_scratch_guppy_internal_alloc_no_param(self) -> None:
         """S2: a SCRATCH input is allocated INSIDE the @guppy def -- it is
         neither a function parameter nor a positional call argument; the
-        body's Prep(scratch) lowers to a fresh internal `qubit()`.
+        body's PZ(scratch) lowers to a fresh internal `qubit()`.
         """
         from pecos.slr import CReg, Main, QReg, Return, SlrConverter
         from pecos.slr.qeclib import qubit as qb
@@ -2234,7 +2234,7 @@ def test_scratch_guppy_internal_alloc_no_param(self) -> None:
         prog = Main(
             q := QReg("q", 3),
             c := CReg("c", 1),
-            qb.Prep(q),
+            qb.PZ(q),
             good_check([q[0], q[1]], q[2], c[0]),
             Return(c),
         )
@@ -2265,7 +2265,7 @@ def __init__(self, a, out) -> None:
                 super().__init__()
                 self.a = a
                 self.out = out
-                self.extend(qb.H(a), qb.Prep(a), Measure(a) > out)
+                self.extend(qb.H(a), qb.PZ(a), Measure(a) > out)
 
         prog = Main(
             q := QReg("q", 1),
@@ -2273,7 +2273,7 @@ def __init__(self, a, out) -> None:
             BadFirst(q[0], c[0]),
             Return(c),
         )
-        with pytest.raises(ValueError, match=r"first use is USE.*reset \(Prep\) before"):
+        with pytest.raises(ValueError, match=r"first use is USE.*reset \(PZ\) before"):
             slr_to_ast(prog)
 
     def test_scratch_use_after_measure_rejected(self) -> None:
@@ -2290,7 +2290,7 @@ def __init__(self, a, out) -> None:
                 super().__init__()
                 self.a = a
                 self.out = out
-                self.extend(qb.Prep(a), Measure(a) > out, qb.H(a))
+                self.extend(qb.PZ(a), Measure(a) > out, qb.H(a))
 
         prog = Main(
             q := QReg("q", 1),
@@ -2298,7 +2298,7 @@ def __init__(self, a, out) -> None:
             BadAfter(q[0], c[0]),
             Return(c),
         )
-        with pytest.raises(ValueError, match=r"used after measurement without re-Prep"):
+        with pytest.raises(ValueError, match=r"used after measurement without re-PZ"):
             slr_to_ast(prog)
 
     def test_scratch_unused_rejected(self) -> None:
@@ -2335,7 +2335,7 @@ def __init__(self, a, out) -> None:
                 self.a = a
                 self.out = out
                 self.extend(
-                    qb.Prep(a),
+                    qb.PZ(a),
                     Repeat(2).block(qb.H(a)),
                     Measure(a) > out,
                 )
@@ -2346,7 +2346,7 @@ def __init__(self, a, out) -> None:
             LoopScratch(q[0], c[0]),
             Return(c),
         )
-        with pytest.raises(ValueError, match=r"flat Prep -> \.\.\. -> Measure lifecycle"):
+        with pytest.raises(ValueError, match=r"flat PZ -> \.\.\. -> Measure lifecycle"):
             slr_to_ast(prog)
 
     def test_scratch_aliased_to_other_input_rejected(self) -> None:
@@ -2367,16 +2367,16 @@ def __init__(self, a, b) -> None:
                 super().__init__()
                 self.a = a
                 self.b = b
-                self.extend(qb.Prep(a), qb.CX(a, b), Measure(a))
+                self.extend(qb.PZ(a), qb.CX(a, b), Measure(a))
 
         prog = Main(q := QReg("q", 2), Alias(q[0], q[0]))
         with pytest.raises(ValueError, match=r"qubit q\[0\] is also bound by input 'a'"):
             slr_to_ast(prog)
 
     def test_scratch_prep_only_rejected(self) -> None:
-        """Codex S1 review: a Prep with no terminating Measure must be
+        """Codex S1 review: a PZ with no terminating Measure must be
         rejected -- S2 allocates the scratch qubit internally, so an
-        unmeasured trailing Prep diverges from the flatten/QASM path.
+        unmeasured trailing PZ diverges from the flatten/QASM path.
         """
         from pecos.slr import Main, QReg, Return
         from pecos.slr.ast import slr_to_ast
@@ -2389,7 +2389,7 @@ class PrepOnly(Block):
             def __init__(self, a) -> None:
                 super().__init__()
                 self.a = a
-                self.extend(qb.Prep(a))
+                self.extend(qb.PZ(a))
 
         prog = Main(q := QReg("q", 1), PrepOnly(q[0]))
         with pytest.raises(ValueError, match=r"scratch lifecycle not closed"):
@@ -2407,14 +2407,14 @@ class PrepUseNoMeasure(Block):
             def __init__(self, a) -> None:
                 super().__init__()
                 self.a = a
-                self.extend(qb.Prep(a), qb.H(a))
+                self.extend(qb.PZ(a), qb.H(a))
 
         prog = Main(q := QReg("q", 1), PrepUseNoMeasure(q[0]))
         with pytest.raises(ValueError, match=r"scratch lifecycle not closed"):
             slr_to_ast(prog)
 
     def test_scratch_prep_measure_prep_unmeasured_rejected(self) -> None:
-        """A second Prep with no closing Measure (trailing open lifecycle)."""
+        """A second PZ with no closing Measure (trailing open lifecycle)."""
         from pecos.slr import CReg, Main, QReg, Return
         from pecos.slr.ast import slr_to_ast
         from pecos.slr.block import Block
@@ -2428,7 +2428,7 @@ def __init__(self, a, out) -> None:
                 super().__init__()
                 self.a = a
                 self.out = out
-                self.extend(qb.Prep(a), Measure(a) > out, qb.Prep(a))
+                self.extend(qb.PZ(a), Measure(a) > out, qb.PZ(a))
 
         prog = Main(
             q := QReg("q", 1),
@@ -2440,7 +2440,7 @@ def __init__(self, a, out) -> None:
             slr_to_ast(prog)
 
     def test_scratch_two_prep_no_measure_between_rejected(self) -> None:
-        """Re-Prep before measuring the first lifecycle."""
+        """Re-PZ before measuring the first lifecycle."""
         from pecos.slr import Main, QReg, Return
         from pecos.slr.ast import slr_to_ast
         from pecos.slr.block import Block
@@ -2452,14 +2452,14 @@ class PrepPrep(Block):
             def __init__(self, a) -> None:
                 super().__init__()
                 self.a = a
-                self.extend(qb.Prep(a), qb.Prep(a))
+                self.extend(qb.PZ(a), qb.PZ(a))
 
         prog = Main(q := QReg("q", 1), PrepPrep(q[0]))
         with pytest.raises(ValueError, match=r"re-Prepped before measuring"):
             slr_to_ast(prog)
 
     def test_scratch_prep_measure_prep_measure_accepted(self) -> None:
-        """Two complete Prep -> Measure lifecycles is valid (each closed)."""
+        """Two complete PZ -> Measure lifecycles is valid (each closed)."""
         from pecos.slr import CReg, Main, QReg, Return, SlrConverter
         from pecos.slr.ast import slr_to_ast
         from pecos.slr.block import Block
@@ -2479,9 +2479,9 @@ def __init__(self, a, out0, out1) -> None:
                 self.out0 = out0
                 self.out1 = out1
                 self.extend(
-                    qb.Prep(a),
+                    qb.PZ(a),
                     Measure(a) > out0,
-                    qb.Prep(a),
+                    qb.PZ(a),
                     Measure(a) > out1,
                 )
 
@@ -2522,7 +2522,7 @@ def __init__(self, a, out) -> None:
                 super().__init__()
                 self.a = a
                 self.out = out
-                self.extend(qb.Prep(a), Measure(a) > out, Return(a))
+                self.extend(qb.PZ(a), Measure(a) > out, Return(a))
 
         prog = Main(
             q := QReg("q", 1),
@@ -2540,7 +2540,7 @@ def __init__(self, a, out) -> None:
                 super().__init__()
                 self.a = a
                 self.out = out
-                self.extend(qb.Prep(a), Measure(a) > out, Return(out))
+                self.extend(qb.PZ(a), Measure(a) > out, Return(out))
 
         prog2 = Main(
             q := QReg("q", 1),
@@ -2576,7 +2576,7 @@ def __init__(self, d, a, out) -> None:
                 self.a = a
                 self.out = out
                 self.extend(
-                    qb.Prep(a),
+                    qb.PZ(a),
                     qb.H(a),
                     qb.CX(a, d[0]),
                     qb.CX(a, d[1]),
@@ -2587,7 +2587,7 @@ def __init__(self, d, a, out) -> None:
         prog = Main(
             q := QReg("q", 3),
             c := CReg("c", 2),
-            qb.Prep(q),
+            qb.PZ(q),
             Chk([q[0], q[1]], q[2], c[0]),
             Chk([q[0], q[1]], q[2], c[1]),  # reuses q[2] -- the blocker case
             Return(c),
@@ -2629,12 +2629,12 @@ def __init__(self, a, out) -> None:
                 super().__init__()
                 self.a = a
                 self.out = out
-                self.extend(qb.Prep(a), qb.H(a), Measure(a) > out)
+                self.extend(qb.PZ(a), qb.H(a), Measure(a) > out)
 
         prog = Main(
             q := QReg("q", 1),
             c := CReg("c", 2),
-            qb.Prep(q[0]),
+            qb.PZ(q[0]),
             qb.X(q[0]),  # meaningful caller state on the scratch slot
             MS(q[0], c[0]),
             Measure(q[0]) > c[1],  # ...observed after the scratch call
@@ -2644,8 +2644,8 @@ def __init__(self, a, out) -> None:
             SlrConverter(prog).guppy()
 
     def test_scratch_outer_slot_whole_reg_prep_allowed(self) -> None:
-        """Carve-out: a bare/whole-register Prep covering the scratch slot
-        is allowed (the qeclib corpus does `Prep(q)` then uses `q[i]` as a
+        """Carve-out: a bare/whole-register PZ covering the scratch slot
+        is allowed (the qeclib corpus does `PZ(q)` then uses `q[i]` as a
         check ancilla -- a reset is unobserved/dead under both lowerings).
         """
         from pecos.slr import Block, CReg, Main, QReg, Return, SlrConverter
@@ -2664,12 +2664,12 @@ def __init__(self, d, a, out) -> None:
                 self.d = d
                 self.a = a
                 self.out = out
-                self.extend(qb.Prep(a), qb.CX(a, d[0]), qb.CX(a, d[1]), Measure(a) > out)
+                self.extend(qb.PZ(a), qb.CX(a, d[0]), qb.CX(a, d[1]), Measure(a) > out)
 
         prog = Main(
             q := QReg("q", 3),
             c := CReg("c", 1),
-            qb.Prep(q),  # covers q[2] (the scratch slot) -- must NOT reject
+            qb.PZ(q),  # covers q[2] (the scratch slot) -- must NOT reject
             Chk([q[0], q[1]], q[2], c[0]),
             Return(c),
         )
@@ -2723,12 +2723,12 @@ def __init__(self, a, out) -> None:
                 super().__init__()
                 self.a = a
                 self.out = out
-                self.extend(qb.Prep(a), qb.H(a), Measure(a) > out)
+                self.extend(qb.PZ(a), qb.H(a), Measure(a) > out)
 
         prog = Main(
             q := QReg("q", 2),
             c := CReg("c", 2),
-            qb.Prep(q),
+            qb.PZ(q),
             qb.X(q[0]),
             MS(q[1], c[0]),
             Permute([q[0], q[1]], [q[1], q[0]]),
@@ -2754,12 +2754,12 @@ def __init__(self, a, out) -> None:
                 super().__init__()
                 self.a = a
                 self.out = out
-                self.extend(qb.Prep(a), qb.H(a), Measure(a) > out)
+                self.extend(qb.PZ(a), qb.H(a), Measure(a) > out)
 
         prog = Main(
             q := QReg("q", 2),
             c := CReg("c", 1),
-            qb.Prep(q),
+            qb.PZ(q),
             MS(q[1], c[0]),
             Return(q),
         )
@@ -2783,7 +2783,7 @@ def __init__(self, a, out) -> None:
                 super().__init__()
                 self.a = a
                 self.out = out
-                self.extend(qb.Prep(a), qb.H(a), Measure(a) > out)
+                self.extend(qb.PZ(a), qb.H(a), Measure(a) > out)
 
         class Outer(Block):
             block_inputs: ClassVar[dict[str, str]] = {
@@ -2800,7 +2800,7 @@ def __init__(self, q, o) -> None:
         prog = Main(
             qq := QReg("qq", 2),
             c := CReg("c", 1),
-            qb.Prep(qq),
+            qb.PZ(qq),
             Outer(qq, c[0]),
             Return(c),
         )
@@ -2920,7 +2920,7 @@ def test_color488_syn_extract_bare_routes_and_runs(self) -> None:
 
 class TestScratchCheck1FlagS5ProductionLockIn:
     """S5: `Check1Flag` converted (`a`, `flag`: scratch; the body's
-    `Prep(a, flag)` split into `Prep(a); Prep(flag)` per O1 option (a)).
+    `PZ(a, flag)` split into `PZ(a); PZ(flag)` per O1 option (a)).
     Steane `SynExtractFlagged` reuses ancilla+flag slots across 6
     Check1Flag calls -- it must route every one through a BlockCall,
     compile (12 internal allocs, no LinearityError), and run.
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_substitution.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_substitution.py
index f48a72514..2b36e1a24 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_substitution.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_substitution.py
@@ -232,7 +232,7 @@ def test_prepare_all_whole_renamed(self) -> None:
         assert out.slots is None
 
     def test_prepare_slots_remapped_preserves_source_order(self) -> None:
-        # Prep(q[2], q[5]) under q[2]->d[0], q[5]->d[1] -> Prep(d, (0, 1)).
+        # PZ(q[2], q[5]) under q[2]->d[0], q[5]->d[1] -> PZ(d, (0, 1)).
         # Exact order asserted: the lowering preserves source slot order;
         # sorted() would mask an ordering regression.
         prep = PrepareOp(allocator="q", slots=(2, 5))
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
index ad0d072a3..93016e823 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
@@ -138,7 +138,7 @@ def test_print_in_repeat_emits_event_per_iteration(self) -> None:
             Repeat(n_iters).block(
                 qb.X(q[0]),
                 Measure(q[0]) > c[0],
-                qb.Prep(q[0]),
+                qb.PZ(q[0]),
                 Print(c, tag="iter"),
             ),
             Return(c),
@@ -161,7 +161,7 @@ def test_print_in_static_for_emits_event_per_iteration(self) -> None:
             For("i", 0, n_iters).Do(
                 qb.X(q[0]),
                 Measure(q[0]) > c[0],
-                qb.Prep(q[0]),
+                qb.PZ(q[0]),
                 Print(c, tag="loop"),
             ),
             Return(c),
@@ -287,7 +287,7 @@ def test_multiple_prints_distinct_tags_each_appear(self) -> None:
             qb.X(q[0]),
             Measure(q[0]) > c[0],
             Print(c, tag="early"),
-            qb.Prep(q[0]),
+            qb.PZ(q[0]),
             qb.X(q[0]),
             Measure(q[0]) > c[0],
             Print(c, tag="late"),
@@ -309,7 +309,7 @@ def test_two_prints_same_tag_become_event_list(self) -> None:
             qb.X(q[0]),
             Measure(q[0]) > c[0],
             Print(c, tag="same"),
-            qb.Prep(q[0]),
+            qb.PZ(q[0]),
             qb.X(q[0]),
             Measure(q[0]) > c[0],
             Print(c, tag="same"),  # same tag, second emission
@@ -413,7 +413,7 @@ def test_static_repeat_with_print_compiles(self) -> None:
             Repeat(3).block(
                 qb.X(q[0]),
                 Measure(q[0]) > c[0],
-                qb.Prep(q[0]),
+                qb.PZ(q[0]),
                 Print(c, tag="iter"),
             ),
             Return(c),
@@ -428,7 +428,7 @@ def test_static_for_with_print_compiles(self) -> None:
             For("i", 0, 3).Do(
                 qb.X(q[0]),
                 Measure(q[0]) > c[0],
-                qb.Prep(q[0]),
+                qb.PZ(q[0]),
                 Print(c, tag="loop"),
             ),
             Return(c),
@@ -577,7 +577,7 @@ def test_inline_creg_assigned_in_repeat_body_propagates(self) -> None:
         inline = CReg("inline", 1)
         prog = Main(
             q := QReg("q", 1),
-            Repeat(3).block(qb.X(q[0]), Measure(q[0]) > inline[0], qb.Prep(q[0])),
+            Repeat(3).block(qb.X(q[0]), Measure(q[0]) > inline[0], qb.PZ(q[0])),
             Print(inline[0], tag="post_repeat"),
             Return(inline),
         )
@@ -588,7 +588,7 @@ def test_inline_creg_assigned_in_static_for_propagates(self) -> None:
         inline = CReg("inline", 1)
         prog = Main(
             q := QReg("q", 1),
-            For("i", 0, 2).Do(qb.X(q[0]), Measure(q[0]) > inline[0], qb.Prep(q[0])),
+            For("i", 0, 2).Do(qb.X(q[0]), Measure(q[0]) > inline[0], qb.PZ(q[0])),
             Print(inline[0], tag="post_for"),
             Return(inline),
         )
@@ -690,7 +690,7 @@ def test_while_with_print_rejected(self) -> None:
             Measure(q[0]) > c[0],
             While(c[0] == 0).Do(
                 Print(c, tag="loop"),
-                qb.Prep(q[0]),
+                qb.PZ(q[0]),
                 Measure(q[0]) > c[0],
             ),
             Return(c),
@@ -897,7 +897,7 @@ def test_multibit_creg_print_in_repeat_flattens_iterations_into_inner_list(self)
             Repeat(2).block(
                 qb.X(q[0]),
                 Measure(q[0]) > c[0],
-                qb.Prep(q[0]),
+                qb.PZ(q[0]),
                 Print(c, tag="iter"),
             ),
             Return(c),
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
index e54cf2b92..b9ba02694 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
@@ -68,7 +68,7 @@
 `docs.prep_basis_x` / `docs.surface_syndrome_block18` (#80:
 the two QIR silent-miscompile defects #79's dual pre-review
 surfaced -- an inline/`Return`-only CReg that got no storage
-so its value vanished from the records, and a non-Z `Prep`
+so its value vanished from the records, and a non-Z `PZ`
 basis the converter silently dropped so it lowered as a plain
 Z reset -- are now FAIL-LOUD, mirroring #74/#78). Identity
 pinned (`_EXPECTED_BUILD_FAILED`) so a NEW build regression
@@ -118,14 +118,14 @@
     #    measure-store was silently skipped and the explicit returned
     #    value vanished from the QIS records (QIS recorded `[]`).
     #  - prep_basis_x / surface_syndrome_block18: contain
-    #    `Prep(q, "X")`; the converter dropped the basis string and
+    #    `PZ(q, "X")`; the converter dropped the basis string and
     #    every AST codegen lowered it as a plain Z reset. Fixed at the
     #    shared converter root, matching the AST->Guppy path which
-    #    already rejects non-Z Prep at preflight.
+    #    already rejects non-Z PZ at preflight.
     "docs.inline_measure_creg": ("NotImplementedError", "was not declared at Main scope"),
     # #81 Stage A recast the guard: the prep basis is the gate
     # identity, so ANY stray string qarg (incl. these factories'
-    # `Prep(q, "X")`) fails loud. Still BUILD_FAILED; only the
+    # `PZ(q, "X")`) fails loud. Still BUILD_FAILED; only the
     # message fragment changed. Stage D rewrites the factories to
     # dedicated gates -> these move BUILD_FAILED -> QIS_OK (re-pin
     # then via `_qir_state()`).
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_acceptance.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_acceptance.py
index f27fe8cf4..707e18a72 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_acceptance.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_acceptance.py
@@ -10,7 +10,7 @@
 
 Test layout follows the "practical v1 acceptance set" plus the
 coverage gaps surfaced in stage 5 (final-root-return, static For,
-Parallel, Prep-after-measure, mixed Permute, gates beyond CX,
+Parallel, PZ-after-measure, mixed Permute, gates beyond CX,
 SZ/SZdg mapping, measurement-without-output, targeted unsupported
 errors).
 """
@@ -132,7 +132,7 @@ def test_creg_bit_set_int_literal(self) -> None:
 
 
 class TestPrep:
-    """Prep as reset (live slot) or fresh allocation (consumed slot)."""
+    """PZ as reset (live slot) or fresh allocation (consumed slot)."""
 
     def test_prep_resets_live_slot(self) -> None:
         prog = Main(
@@ -140,7 +140,7 @@ def test_prep_resets_live_slot(self) -> None:
             c := CReg("c", 2),
             qb.H(q[0]),
             Measure(q[0]) > c[0],
-            qb.Prep(q[0]),  # consumed -> fresh qubit()
+            qb.PZ(q[0]),  # consumed -> fresh qubit()
             Measure(q[0]) > c[1],
             Return(c),
         )
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py
index df1cc0268..c4ac8ff67 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py
@@ -76,13 +76,13 @@ def test_x_then_x_then_measure_is_zero(self) -> None:
         assert all(r["measurement_0"] == 0 for r in records)
 
     def test_measure_prep_remeasure_is_zero(self) -> None:
-        """Prep after measurement resets the slot to |0>."""
+        """PZ after measurement resets the slot to |0>."""
         prog = Main(
             q := QReg("q", 1),
             c := CReg("c", 2),
             qb.X(q[0]),
             Measure(q[0]) > c[0],
-            qb.Prep(q[0]),
+            qb.PZ(q[0]),
             Measure(q[0]) > c[1],
             Return(c),
         )
@@ -91,13 +91,13 @@ def test_measure_prep_remeasure_is_zero(self) -> None:
         assert all(r["measurement_1"] == 0 for r in records)
 
     def test_measure_prep_x_remeasure_is_one(self) -> None:
-        """Prep after measurement produces a fresh |0> that can be inverted."""
+        """PZ after measurement produces a fresh |0> that can be inverted."""
         prog = Main(
             q := QReg("q", 1),
             c := CReg("c", 2),
             qb.X(q[0]),
             Measure(q[0]) > c[0],
-            qb.Prep(q[0]),
+            qb.PZ(q[0]),
             qb.X(q[0]),
             Measure(q[0]) > c[1],
             Return(c),
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
index fa24daa4f..cb7bb981a 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
@@ -416,19 +416,19 @@ def test_prep_stray_string_arg_raises_loud() -> None:
     """#80 recast under #81: the prep basis is the GATE IDENTITY
     (`PZ`/`PNZ`/`PX`/`PNX`/`PY`/`PNY`), not a string argument.
     `_expand_qubit_args` silently drops a string qarg, so a basis
-    string on ANY prep gate -- the legacy `Prep(q, "X")`, or
-    `PZ(q, "X")`, even `Prep(q, "Z")` -- would be silently dropped
+    string on ANY prep gate -- the legacy `PZ(q, "X")`, or
+    `PZ(q, "X")`, even `PZ(q, "Z")` -- would be silently dropped
     and lowered as the plain basis (a miscompile, #80/#79). The
     converter rejects ANY stray string qarg on EVERY prep gate
     (Codex #81 sym rule). A bare prep gate (no string) is fine."""
     # No-string preps build (PZ default; dedicated gate identity).
     ok = Main(q := QReg("q", 1), c := CReg("c", 1), qb.PZ(q[0]), Measure(q) > c, Return(c))
     SlrConverter(ok).qir_bc()
-    ok_prep = Main(q := QReg("q", 1), c := CReg("c", 1), qb.Prep(q[0]), Measure(q) > c, Return(c))
+    ok_prep = Main(q := QReg("q", 1), c := CReg("c", 1), qb.PZ(q[0]), Measure(q) > c, Return(c))
     SlrConverter(ok_prep).qir_bc()
 
     # ANY string qarg on ANY prep gate fails loud (incl. "Z").
-    for prep, s in ((qb.Prep, "X"), (qb.Prep, "Z"), (qb.PZ, "X"), (qb.PX, "ignored")):
+    for prep, s in ((qb.PZ, "X"), (qb.PZ, "Z"), (qb.PZ, "X"), (qb.PX, "ignored")):
         bad = Main(q := QReg("q", 1), c := CReg("c", 1), prep(q[0], s), Measure(q) > c, Return(c))
         with pytest.raises(NotImplementedError, match=r"stray string argument"):
             SlrConverter(bad).qir_bc()
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_partial_array_returns.py b/python/quantum-pecos/tests/slr_tests/guppy/test_partial_array_returns.py
index 76a48fcec..67130b68b 100644
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_partial_array_returns.py
+++ b/python/quantum-pecos/tests/slr_tests/guppy/test_partial_array_returns.py
@@ -1,7 +1,7 @@
 """Tests for partial array patterns through Block flattening.
 
 The two-round-stabilizer pattern from the legacy file used the same
-ancilla register across two rounds without an intervening ``Prep``.
+ancilla register across two rounds without an intervening ``PZ``.
 The v1 AST emitter rejects use-after-measurement, so that case is
 deleted; the remaining tests cover Block-flattening + partial-
 measurement patterns that v1 supports but that are not part of the v1
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_simple_slr_to_guppy.py b/python/quantum-pecos/tests/slr_tests/guppy/test_simple_slr_to_guppy.py
index c58c8aef3..c07eb0ba5 100644
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_simple_slr_to_guppy.py
+++ b/python/quantum-pecos/tests/slr_tests/guppy/test_simple_slr_to_guppy.py
@@ -3,7 +3,7 @@
 The straightforward Bell / GHZ / two-qubit-gate / multi-op tests in the
 legacy file are covered by the v1 acceptance corpus
 (``tests/slr_tests/ast_guppy/test_v1_acceptance.py``). What survives
-here is the measure-then-Prep cycle invoked multiple times via a
+here is the measure-then-PZ cycle invoked multiple times via a
 Block subclass, which is in v1 scope but not part of the acceptance
 set.
 """
@@ -11,13 +11,13 @@
 from pecos.slr import Block, CReg, Main, QReg, Return
 from pecos.slr.qeclib import qubit as qb
 from pecos.slr.qeclib.qubit.measures import Measure
-from pecos.slr.qeclib.qubit.preps import Prep
+from pecos.slr.qeclib.qubit.preps import PZ
 
 from ..ast_guppy._harness import assert_ast_guppy_compiles  # noqa: TID252
 
 
 def test_simple_explicit_reset_in_loop() -> None:
-    """A Block performing measure + Prep is invoked three times in a row."""
+    """A Block performing measure + PZ is invoked three times in a row."""
 
     class ResetQubit(Block):
         def __init__(self, q: QReg, c: CReg) -> None:
@@ -26,7 +26,7 @@ def __init__(self, q: QReg, c: CReg) -> None:
             self.c = c
             self.ops = [
                 Measure(q[0]) > c[0],
-                Prep(q[0]),
+                PZ(q[0]),
             ]
 
     prog = Main(
@@ -50,7 +50,7 @@ def __init__(self, q: QReg, c: CReg) -> None:
             self.c = c
             self.ops = [
                 Measure(q[0]) > c[0],
-                Prep(q[0]),
+                PZ(q[0]),
             ]
 
     prog = Main(
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_conversion_with_qasm.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_conversion_with_qasm.py
index ea3f94a1d..f65ce9ce5 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_conversion_with_qasm.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_conversion_with_qasm.py
@@ -39,8 +39,8 @@ def test_bell_state_consistency(self) -> None:
         slr_prog = Main(
             q := QReg("q", 2),
             c := CReg("c", 2),
-            qubit.Prep(q[0]),
-            qubit.Prep(q[1]),
+            qubit.PZ(q[0]),
+            qubit.PZ(q[1]),
             qubit.H(q[0]),
             qubit.CX(q[0], q[1]),
             qubit.Measure(q[0]) > c[0],
@@ -246,9 +246,9 @@ def test_measurement_consistency(self) -> None:
             q := QReg("q", 3),
             c := CReg("c", 3),
             # Prepare a GHZ state
-            qubit.Prep(q[0]),
-            qubit.Prep(q[1]),
-            qubit.Prep(q[2]),
+            qubit.PZ(q[0]),
+            qubit.PZ(q[1]),
+            qubit.PZ(q[2]),
             qubit.H(q[0]),
             qubit.CX(q[0], q[1]),
             qubit.CX(q[1], q[2]),
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_guppy_generation.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_guppy_generation.py
index b5489d9e4..4b2623479 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_guppy_generation.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_guppy_generation.py
@@ -4,7 +4,7 @@
 coverage is in the v1 acceptance corpus
 (``tests/slr_tests/ast_guppy/test_v1_acceptance.py``). What survives
 here are larger end-to-end SLR patterns (Steane-style multi-pair CX,
-Prep across multiple qubits, mixed quantum/classical Permute) that the
+PZ across multiple qubits, mixed quantum/classical Permute) that the
 acceptance set does not exercise but that v1 supports.
 
 The Steane(...) prep tests and the conditional X-after-measure tests
@@ -98,10 +98,10 @@ def test_register_operations() -> None:
 
 
 def test_steane_encoding_circuit_pattern() -> None:
-    """Multi-pair CX pattern from the Steane encoding circuit + Prep set."""
+    """Multi-pair CX pattern from the Steane encoding circuit + PZ set."""
     prog = Main(
         q := QReg("q", 7),
-        qb.Prep(q[0], q[1], q[2], q[3], q[4], q[5]),
+        qb.PZ(q[0], q[1], q[2], q[3], q[4], q[5]),
         qb.CX(q[6], q[5]),
         qb.H(q[1]),
         qb.CX(q[1], q[0]),
@@ -127,14 +127,14 @@ def test_steane_encoding_circuit_pattern() -> None:
 
 
 def test_reset_operations() -> None:
-    """Prep across single and multi-qubit forms compiles."""
+    """PZ across single and multi-qubit forms compiles."""
     prog = Main(
         q := QReg("q", 3),
         _c := CReg("c", 3),
-        qb.Prep(q[0]),
+        qb.PZ(q[0]),
         qb.H(q[0]),
         qb.CX(q[0], q[1]),
-        qb.Prep(q[1], q[2]),
+        qb.PZ(q[1], q[2]),
         qb.X(q[0]),
         qb.Y(q[1]),
         qb.Z(q[2]),
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_guppy_generation_comprehensive.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_guppy_generation_comprehensive.py
index fbb394b01..cb92314c3 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_guppy_generation_comprehensive.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_guppy_generation_comprehensive.py
@@ -5,7 +5,7 @@
 contained:
 
 - A syndrome-extraction pattern that reused an ancilla after measure
-  without an intervening ``Prep`` (use-after-measurement, v1 rejects).
+  without an intervening ``PZ`` (use-after-measurement, v1 rejects).
 - A parameterized circuit with branches consuming different qubits
   (divergent post-state, v1 rejects).
 - Complex permutation cycles that are not bijective over the same slot
@@ -121,7 +121,7 @@ def test_empty_blocks_and_edge_cases() -> None:
         qb.H(q[0]),
         qb.Measure(q[0]),
         # Apply gate to register
-        qb.Prep(q),
+        qb.PZ(q),
         Return(c),
     )
 
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_circuit_conversion.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_circuit_conversion.py
index 972b08a2c..fbc5ee69d 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_circuit_conversion.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_circuit_conversion.py
@@ -167,8 +167,8 @@ def test_measurements_to_qc(self) -> None:
         prog = Main(
             q := QReg("q", 2),
             c := CReg("c", 2),
-            qubit.Prep(q[0]),
-            qubit.Prep(q[1]),
+            qubit.PZ(q[0]),
+            qubit.PZ(q[1]),
             qubit.H(q[0]),
             qubit.CX(q[0], q[1]),
             qubit.Measure(q[0]) > c[0],
@@ -182,7 +182,7 @@ def test_measurements_to_qc(self) -> None:
 
         # Check for reset and measure operations
         circuit_str = str(qc)
-        assert "RESET" in circuit_str or "Prep" in circuit_str
+        assert "RESET" in circuit_str or "PZ" in circuit_str
         assert "Measure" in circuit_str
 
     def test_parallel_block_to_qc(self) -> None:
@@ -350,10 +350,10 @@ def test_complex_circuit_preservation(self) -> None:
             q := QReg("q", 4),
             c := CReg("c", 4),
             # Initialize
-            qubit.Prep(q[0]),
-            qubit.Prep(q[1]),
-            qubit.Prep(q[2]),
-            qubit.Prep(q[3]),
+            qubit.PZ(q[0]),
+            qubit.PZ(q[1]),
+            qubit.PZ(q[2]),
+            qubit.PZ(q[3]),
             # Create entanglement
             qubit.H(q[0]),
             qubit.CX(q[0], q[1]),
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_stim_conversion.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_stim_conversion.py
index 97259603a..4d331e148 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_stim_conversion.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_stim_conversion.py
@@ -167,8 +167,8 @@ def test_measurements_to_stim(self) -> None:
         prog = Main(
             q := QReg("q", 2),
             c := CReg("c", 2),
-            qubit.Prep(q[0]),
-            qubit.Prep(q[1]),
+            qubit.PZ(q[0]),
+            qubit.PZ(q[1]),
             qubit.H(q[0]),
             qubit.CX(q[0], q[1]),
             qubit.Measure(q[0]) > c[0],

From c9cec6973a8280e88fc206ffdaaffac5ed5e6de1 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Mon, 18 May 2026 08:30:40 -0600
Subject: [PATCH 095/136] #81 Stage D: docs->dedicated PZ/PX + doc-tests regen
 (22/0); audit factories
 _docs_prep_basis_x/_docs_surface_syndrome_block18->dedicated gates,
 GuppyCodegenError expected_failure deleted; #71 re-pinned from ACTUAL
 _qir_state (BUILD_FAILED 6->5/QIS_OK 23->24: prep_basis_x->QIS_OK;
 surface_syndrome_block18 stays BUILD_FAILED on its inline
 Measure(data)>CReg(final) #80 'was not declared at Main scope' reason NOT
 prep -- pinned honestly; counts+docstring prose); sim hard-rename
 Pn{X,Y,Z}->PN{X,Y,Z} 8 files + gate_type.rs comments + removed dead
 .typos.toml Pn (rslib rebuilt; SIM DISPATCH 13/13 + PZ/PNZ/PX state-correct);
 fixed 5 genuinely-#81 test-fallout
 (test_ast_hugr->test_hugr_rejects_stray_prep_basis_string asserting converter
 NotImplementedError stray-string; 4 converter scratch-lifecycle messages
 Prep->PZ, re-Prepped verb kept to match deterministic sed-renamed test spec).
 Verified FULL slr_tests: 391 passed, only #87(14 perm/meas
 legacy-QIR-comment) + #88(9 #74/#80 scalar-var/oversize fail-loud +
 SX-rx/parallel/array-unpack) failing -- BOTH proven pre-existing-rel-to-#81
 (exception-identity + no-prep; pecos/regression+guppy never subset-verified),
 #81 net-new=0; #71 green; behavioral all-6 PASS; doc-tests 22/0;
 ruff/black/cargo-fmt clean

---
 .typos.toml                                   |  1 -
 crates/pecos-core/src/gate_type.rs            |  6 +-
 docs/development/slr-qeclib.md                | 22 +++---
 python/pecos-rslib/src/simulator_utils.rs     |  6 +-
 python/pecos-rslib/src/sparse_sim.rs          |  6 +-
 .../pecos-rslib/src/sparse_stab_bindings.rs   |  6 +-
 python/pecos-rslib/src/stab_bindings.rs       |  6 +-
 python/pecos-rslib/src/stab_vec_bindings.rs   |  6 +-
 python/pecos-rslib/src/state_vec_bindings.rs  |  6 +-
 .../src/pecos/simulators/statevec/bindings.py | 18 ++---
 .../src/pecos/slr/ast/converter.py            | 11 ++-
 .../tests/slr_tests/ast_guppy/audit_runner.py | 45 ++++--------
 .../slr_tests/ast_guppy/test_ast_hugr.py      | 10 ++-
 .../ast_guppy/test_qir_spec_compliance.py     | 68 +++++++++----------
 14 files changed, 97 insertions(+), 120 deletions(-)

diff --git a/.typos.toml b/.typos.toml
index 716e3bb44..97548f0ba 100644
--- a/.typos.toml
+++ b/.typos.toml
@@ -8,7 +8,6 @@ IY = "IY"
 IZ = "IZ"
 iz = "iz"
 anc = "anc"
-Pn = "Pn"
 emiss = "emiss"
 fo = "fo"
 # HUGR JSON format uses "typ" as a field name for type information
diff --git a/crates/pecos-core/src/gate_type.rs b/crates/pecos-core/src/gate_type.rs
index 2c2c94386..63c532ca8 100644
--- a/crates/pecos-core/src/gate_type.rs
+++ b/crates/pecos-core/src/gate_type.rs
@@ -97,12 +97,12 @@ pub enum GateType {
     // TODO: MPauli instead of the other variants?
 
     // PX = 130
-    // PnX = 131
+    // PNX = 131
     // PY = 132
-    // PnY = 133
+    // PNY = 133
     // PZ = 134
     PZ = 134,
-    // PnZ
+    // PNZ
     /// Allocate a qubit in the |0⟩ state
     QAlloc = 135,
     /// Free/deallocate a qubit
diff --git a/docs/development/slr-qeclib.md b/docs/development/slr-qeclib.md
index 5c090931b..2436b48a5 100644
--- a/docs/development/slr-qeclib.md
+++ b/docs/development/slr-qeclib.md
@@ -97,12 +97,10 @@ prog = Main(
     c := CReg("c", 4),
     # Initialization block
     Block(
-        qb.Prep(q[0], "Z"),
-        qb.Prep(q[1], "Z"),
-        qb.Prep(q[2]),
-        qb.H(q[2]),  # |+> (X-basis prep = Prep then H)
-        qb.Prep(q[3]),
-        qb.H(q[3]),  # |+>
+        qb.PZ(q[0]),  # |0>
+        qb.PZ(q[1]),  # |0>
+        qb.PX(q[2]),  # |+>
+        qb.PX(q[3]),  # |+>
     ),
     # Entanglement block
     Block(
@@ -252,9 +250,8 @@ prog = Main(
     qb.CZ(q[0], q[1]),
     # Measurements and preparations
     qb.Measure(q[0]) > c[0],
-    qb.Prep(q[0], "Z"),  # Prepare |0>
-    qb.Prep(q[0]),
-    qb.H(q[0]),  # Prepare |+> (X-basis prep = Prep then H)
+    qb.PZ(q[0]),  # Prepare |0>
+    qb.PX(q[0]),  # Prepare |+>
 )
 ```
 
@@ -432,11 +429,10 @@ def surface_code_syndrome(d: int):
         ancilla := QReg("anc", num_ancilla),
         syn := CReg("syn", num_ancilla),
         # Initialize data qubits
-        Block(*[qb.Prep(data[i], "Z") for i in range(num_data)]),
+        Block(*[qb.PZ(data[i]) for i in range(num_data)]),
         # X stabilizer measurement (simplified)
         Block(
-            qb.Prep(ancilla[0]),
-            qb.H(ancilla[0]),  # Prepare |+> (X-basis prep = Prep then H)
+            qb.PX(ancilla[0]),  # |+>
             qb.CX(ancilla[0], data[0]),
             qb.CX(ancilla[0], data[1]),
             qb.H(ancilla[0]),
@@ -444,7 +440,7 @@ def surface_code_syndrome(d: int):
         ),
         # Z stabilizer measurement (simplified)
         Block(
-            qb.Prep(ancilla[1], "Z"),  # Prepare |0>
+            qb.PZ(ancilla[1]),  # Prepare |0>
             qb.CX(data[0], ancilla[1]),
             qb.CX(data[3], ancilla[1]),
             qb.Measure(ancilla[1]) > syn[1],
diff --git a/python/pecos-rslib/src/simulator_utils.rs b/python/pecos-rslib/src/simulator_utils.rs
index 23bc059fd..c61f7537d 100644
--- a/python/pecos-rslib/src/simulator_utils.rs
+++ b/python/pecos-rslib/src/simulator_utils.rs
@@ -385,7 +385,7 @@ pub fn try_clifford_batch_dispatch<S: CliffordGateable>(
             sim.pz(&collect_single_qubits(locations)?);
             return Ok(Some(PyDict::new(py).into()));
         }
-        "PnZ" | "Init -Z" | "init |1>" | "leak |1>" | "unleak |1>" => {
+        "PNZ" | "Init -Z" | "init |1>" | "leak |1>" | "unleak |1>" => {
             sim.pnz(&collect_single_qubits(locations)?);
             return Ok(Some(PyDict::new(py).into()));
         }
@@ -393,7 +393,7 @@ pub fn try_clifford_batch_dispatch<S: CliffordGateable>(
             sim.px(&collect_single_qubits(locations)?);
             return Ok(Some(PyDict::new(py).into()));
         }
-        "PnX" | "Init -X" | "init |->" => {
+        "PNX" | "Init -X" | "init |->" => {
             sim.pnx(&collect_single_qubits(locations)?);
             return Ok(Some(PyDict::new(py).into()));
         }
@@ -401,7 +401,7 @@ pub fn try_clifford_batch_dispatch<S: CliffordGateable>(
             sim.py(&collect_single_qubits(locations)?);
             return Ok(Some(PyDict::new(py).into()));
         }
-        "PnY" | "Init -Y" | "init |-i>" => {
+        "PNY" | "Init -Y" | "init |-i>" => {
             sim.pny(&collect_single_qubits(locations)?);
             return Ok(Some(PyDict::new(py).into()));
         }
diff --git a/python/pecos-rslib/src/sparse_sim.rs b/python/pecos-rslib/src/sparse_sim.rs
index 400234425..1276ac93e 100644
--- a/python/pecos-rslib/src/sparse_sim.rs
+++ b/python/pecos-rslib/src/sparse_sim.rs
@@ -158,15 +158,15 @@ impl SparseSim {
                 self.inner.py(q);
                 Ok(None)
             }
-            "PnZ" => {
+            "PNZ" => {
                 self.inner.pnz(q);
                 Ok(None)
             }
-            "PnX" => {
+            "PNX" => {
                 self.inner.pnx(q);
                 Ok(None)
             }
-            "PnY" => {
+            "PNY" => {
                 self.inner.pny(q);
                 Ok(None)
             }
diff --git a/python/pecos-rslib/src/sparse_stab_bindings.rs b/python/pecos-rslib/src/sparse_stab_bindings.rs
index 83de68aab..0c3795c8c 100644
--- a/python/pecos-rslib/src/sparse_stab_bindings.rs
+++ b/python/pecos-rslib/src/sparse_stab_bindings.rs
@@ -240,7 +240,7 @@ impl PySparseStab {
                 self.inner.pz(q);
                 Ok(None)
             }
-            "Init -Z" | "init |1>" | "leak |1>" | "unleak |1>" | "PnZ" => {
+            "Init -Z" | "init |1>" | "leak |1>" | "unleak |1>" | "PNZ" => {
                 self.inner.pnz(q);
                 Ok(None)
             }
@@ -248,7 +248,7 @@ impl PySparseStab {
                 self.inner.px(q);
                 Ok(None)
             }
-            "Init -X" | "init |->" | "PnX" => {
+            "Init -X" | "init |->" | "PNX" => {
                 self.inner.pnx(q);
                 Ok(None)
             }
@@ -256,7 +256,7 @@ impl PySparseStab {
                 self.inner.py(q);
                 Ok(None)
             }
-            "Init -Y" | "init |-i>" | "PnY" => {
+            "Init -Y" | "init |-i>" | "PNY" => {
                 self.inner.pny(q);
                 Ok(None)
             }
diff --git a/python/pecos-rslib/src/stab_bindings.rs b/python/pecos-rslib/src/stab_bindings.rs
index 67eafd047..5f58d7561 100644
--- a/python/pecos-rslib/src/stab_bindings.rs
+++ b/python/pecos-rslib/src/stab_bindings.rs
@@ -242,7 +242,7 @@ impl PyStabilizer {
                 self.inner.pz(q);
                 Ok(None)
             }
-            "Init -Z" | "init |1>" | "leak |1>" | "unleak |1>" | "PnZ" => {
+            "Init -Z" | "init |1>" | "leak |1>" | "unleak |1>" | "PNZ" => {
                 self.inner.pnz(q);
                 Ok(None)
             }
@@ -250,7 +250,7 @@ impl PyStabilizer {
                 self.inner.px(q);
                 Ok(None)
             }
-            "Init -X" | "init |->" | "PnX" => {
+            "Init -X" | "init |->" | "PNX" => {
                 self.inner.pnx(q);
                 Ok(None)
             }
@@ -258,7 +258,7 @@ impl PyStabilizer {
                 self.inner.py(q);
                 Ok(None)
             }
-            "Init -Y" | "init |-i>" | "PnY" => {
+            "Init -Y" | "init |-i>" | "PNY" => {
                 self.inner.pny(q);
                 Ok(None)
             }
diff --git a/python/pecos-rslib/src/stab_vec_bindings.rs b/python/pecos-rslib/src/stab_vec_bindings.rs
index da54bca67..59e99517a 100644
--- a/python/pecos-rslib/src/stab_vec_bindings.rs
+++ b/python/pecos-rslib/src/stab_vec_bindings.rs
@@ -209,7 +209,7 @@ impl PyStabVec {
                 self.inner.pz(q);
                 Ok(None)
             }
-            "Init -Z" | "init |1>" | "leak |1>" | "unleak |1>" | "PnZ" => {
+            "Init -Z" | "init |1>" | "leak |1>" | "unleak |1>" | "PNZ" => {
                 self.inner.pnz(q);
                 Ok(None)
             }
@@ -217,7 +217,7 @@ impl PyStabVec {
                 self.inner.px(q);
                 Ok(None)
             }
-            "Init -X" | "init |->" | "PnX" => {
+            "Init -X" | "init |->" | "PNX" => {
                 self.inner.pnx(q);
                 Ok(None)
             }
@@ -225,7 +225,7 @@ impl PyStabVec {
                 self.inner.py(q);
                 Ok(None)
             }
-            "Init -Y" | "init |-i>" | "PnY" => {
+            "Init -Y" | "init |-i>" | "PNY" => {
                 self.inner.pny(q);
                 Ok(None)
             }
diff --git a/python/pecos-rslib/src/state_vec_bindings.rs b/python/pecos-rslib/src/state_vec_bindings.rs
index 81b97edc6..3924a8eaf 100644
--- a/python/pecos-rslib/src/state_vec_bindings.rs
+++ b/python/pecos-rslib/src/state_vec_bindings.rs
@@ -339,7 +339,7 @@ impl PyStateVec {
                 self.inner.pz(q);
                 Ok(None)
             }
-            "Init -Z" | "init |1>" | "leak |1>" | "unleak |1>" | "PnZ" => {
+            "Init -Z" | "init |1>" | "leak |1>" | "unleak |1>" | "PNZ" => {
                 self.inner.pnz(q);
                 Ok(None)
             }
@@ -347,7 +347,7 @@ impl PyStateVec {
                 self.inner.px(q);
                 Ok(None)
             }
-            "Init -X" | "init |->" | "PnX" => {
+            "Init -X" | "init |->" | "PNX" => {
                 self.inner.pnx(q);
                 Ok(None)
             }
@@ -355,7 +355,7 @@ impl PyStateVec {
                 self.inner.py(q);
                 Ok(None)
             }
-            "Init -Y" | "init |-i>" | "PnY" => {
+            "Init -Y" | "init |-i>" | "PNY" => {
                 self.inner.pny(q);
                 Ok(None)
             }
diff --git a/python/quantum-pecos/src/pecos/simulators/statevec/bindings.py b/python/quantum-pecos/src/pecos/simulators/statevec/bindings.py
index f7faa9a14..be5ffe8e4 100644
--- a/python/quantum-pecos/src/pecos/simulators/statevec/bindings.py
+++ b/python/quantum-pecos/src/pecos/simulators/statevec/bindings.py
@@ -153,25 +153,25 @@ def get_bindings(state: StateVec) -> dict:
         "PZ": lambda _s, q, **p: sim.run_1q_gate("PZ", q, p),
         "PX": lambda _s, q, **p: sim.run_1q_gate("PX", q, p),
         "PY": lambda _s, q, **p: sim.run_1q_gate("PY", q, p),
-        "PnZ": lambda _s, q, **p: sim.run_1q_gate("PnZ", q, p),
+        "PNZ": lambda _s, q, **p: sim.run_1q_gate("PNZ", q, p),
         "Init": lambda _s, q, **p: sim.run_1q_gate("PZ", q, p),
         "Init +Z": lambda _s, q, **p: sim.run_1q_gate("PZ", q, p),
-        "Init -Z": lambda _s, q, **p: sim.run_1q_gate("PnZ", q, p),
+        "Init -Z": lambda _s, q, **p: sim.run_1q_gate("PNZ", q, p),
         "Init +X": lambda _s, q, **p: sim.run_1q_gate("PX", q, p),
-        "Init -X": lambda _s, q, **p: sim.run_1q_gate("PnX", q, p),
+        "Init -X": lambda _s, q, **p: sim.run_1q_gate("PNX", q, p),
         "Init +Y": lambda _s, q, **p: sim.run_1q_gate("PY", q, p),
-        "Init -Y": lambda _s, q, **p: sim.run_1q_gate("PnY", q, p),
+        "Init -Y": lambda _s, q, **p: sim.run_1q_gate("PNY", q, p),
         "init |0>": lambda _s, q, **p: sim.run_1q_gate("PZ", q, p),
-        "init |1>": lambda _s, q, **p: sim.run_1q_gate("PnZ", q, p),
+        "init |1>": lambda _s, q, **p: sim.run_1q_gate("PNZ", q, p),
         "init |+>": lambda _s, q, **p: sim.run_1q_gate("PX", q, p),
-        "init |->": lambda _s, q, **p: sim.run_1q_gate("PnX", q, p),
+        "init |->": lambda _s, q, **p: sim.run_1q_gate("PNX", q, p),
         "init |+i>": lambda _s, q, **p: sim.run_1q_gate("PY", q, p),
-        "init |-i>": lambda _s, q, **p: sim.run_1q_gate("PnY", q, p),
+        "init |-i>": lambda _s, q, **p: sim.run_1q_gate("PNY", q, p),
         "leak": lambda _s, q, **p: sim.run_1q_gate("PZ", q, p),
         "leak |0>": lambda _s, q, **p: sim.run_1q_gate("PZ", q, p),
-        "leak |1>": lambda _s, q, **p: sim.run_1q_gate("PnZ", q, p),
+        "leak |1>": lambda _s, q, **p: sim.run_1q_gate("PNZ", q, p),
         "unleak |0>": lambda _s, q, **p: sim.run_1q_gate("PZ", q, p),
-        "unleak |1>": lambda _s, q, **p: sim.run_1q_gate("PnZ", q, p),
+        "unleak |1>": lambda _s, q, **p: sim.run_1q_gate("PNZ", q, p),
         # Aliases
         "Q": lambda _s, q, **p: sim.run_1q_gate("SX", q, p),
         "Qd": lambda _s, q, **p: sim.run_1q_gate("SXdg", q, p),
diff --git a/python/quantum-pecos/src/pecos/slr/ast/converter.py b/python/quantum-pecos/src/pecos/slr/ast/converter.py
index faf460884..27639d2e5 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/converter.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/converter.py
@@ -1180,7 +1180,7 @@ def _validate_scratch_input(
     where = f"Block {cls_name!r} scratch input {name!r}"
     if "UNSUPPORTED" in events:
         msg = (
-            f"{where}: scratch inputs must have a flat Prep -> ... -> "
+            f"{where}: scratch inputs must have a flat PZ -> ... -> "
             "Measure lifecycle; referencing the scratch slot inside "
             "control flow, Parallel, a nested BlockCall, or a Permute -- "
             "or any ReturnOp in a scratch-bearing block -- is not "
@@ -1193,7 +1193,7 @@ def _validate_scratch_input(
     if events[0] != "PREP":
         msg = (
             f"{where}: first use is {events[0]}, but a SCRATCH input must "
-            "be reset (Prep) before any other use (reset-first)"
+            "be reset (PZ) before any other use (reset-first)"
         )
         raise ValueError(msg)
     # Segment state machine: a PREP opens a lifecycle that MUST close with a
@@ -1208,7 +1208,7 @@ def _validate_scratch_input(
             if open_prep:
                 msg = (
                     f"{where}: re-Prepped before measuring the previous "
-                    "scratch lifecycle (every Prep must be closed by a "
+                    "scratch lifecycle (every PZ must be closed by a "
                     "Measure)"
                 )
                 raise ValueError(msg)
@@ -1224,10 +1224,7 @@ def _validate_scratch_input(
             open_prep = False
         else:  # USE
             if not open_prep:
-                msg = (
-                    f"{where}: used after measurement without re-Prep "
-                    "(scratch lifecycle must be Prep -> use -> Measure)"
-                )
+                msg = f"{where}: used after measurement without re-PZ (scratch lifecycle must be PZ -> use -> Measure)"
                 raise ValueError(msg)
     if open_prep:
         msg = (
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
index e57a6338b..eaad7bce0 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
@@ -599,16 +599,13 @@ def _docs_for_loopvar_symbolic_v2_defer() -> Block:
     )
 
 
-def _docs_prep_basis_x_v2_defer() -> Block:
-    """Deliberate red-light: PZ with explicit "X" basis is v2-defer.
-
-    Per v1-feature-matrix: "Current PZ gate is reset-to-zero in the AST.
-    V1 supports Z reset only. Use PZ(q); H(q) for X-basis prep."
-    """
+def _docs_prep_basis_x() -> Block:
+    """X-basis prep via the dedicated `PX` gate (#81 -- was v2-defer;
+    the basis is the gate identity, not a string argument)."""
     return Main(
         q := QReg("q", 1),
         c := CReg("c", 1),
-        qb.PZ(q[0], "X"),
+        qb.PX(q[0]),
         Measure(q) > c,
         Return(c),
     )
@@ -639,13 +636,10 @@ def _docs_inline_measure_creg() -> Block:
     )
 
 
-def _docs_surface_syndrome_block18_probe() -> Block:
-    """Probe: surface_code_syndrome doc-test shape from test_slr_qeclib_block_18.
-
-    Uses basis-arg PZ("Z") and PZ("X") plus Block-grouped operations.
-    Likely XFAIL on the PZ basis arg (v2-defer); probe to record exact
-    failure or surface a real gap.
-    """
+def _docs_surface_syndrome_block18() -> Block:
+    """surface_code_syndrome doc-test shape from test_slr_qeclib_block_18,
+    using the dedicated prep gates (#81 -- was v2-defer on the PZ
+    basis-string arg; X-syndrome ancilla = `PX` (|+>) directly)."""
     d = 2
     num_data = d * d
     num_ancilla = 2
@@ -653,17 +647,16 @@ def _docs_surface_syndrome_block18_probe() -> Block:
         data := QReg("data", num_data),
         ancilla := QReg("anc", num_ancilla),
         syn := CReg("syn", num_ancilla),
-        Block(*[qb.PZ(data[i], "Z") for i in range(num_data)]),
+        Block(*[qb.PZ(data[i]) for i in range(num_data)]),
         Block(
-            qb.PZ(ancilla[0], "X"),
-            qb.H(ancilla[0]),
+            qb.PX(ancilla[0]),
             qb.CX(ancilla[0], data[0]),
             qb.CX(ancilla[0], data[1]),
             qb.H(ancilla[0]),
             Measure(ancilla[0]) > syn[0],
         ),
         Block(
-            qb.PZ(ancilla[1], "Z"),
+            qb.PZ(ancilla[1]),
             qb.CX(data[0], ancilla[1]),
             qb.CX(data[3], ancilla[1]),
             Measure(ancilla[1]) > syn[1],
@@ -751,13 +744,7 @@ def _curated_cases() -> list[AuditCase]:
         ),
         AuditCase(
             "docs.prep_basis_x",
-            _docs_prep_basis_x_v2_defer,
-            expected_failure=ExpectedFailure(
-                exception_type="GuppyCodegenError",
-                message_contains="supports only Z-basis PZ",
-                classification="v2-defer",
-                reason="Non-Z PZ basis semantics are not represented in the v1 AST",
-            ),
+            _docs_prep_basis_x,
         ),
         AuditCase(
             "docs.rotation_rx",
@@ -771,13 +758,7 @@ def _curated_cases() -> list[AuditCase]:
         ),
         AuditCase(
             "docs.surface_syndrome_block18",
-            _docs_surface_syndrome_block18_probe,
-            expected_failure=ExpectedFailure(
-                exception_type="GuppyCodegenError",
-                message_contains="supports only Z-basis PZ",
-                classification="v2-defer",
-                reason="Doc-test includes PZ('X'); inline result CReg shape is covered separately",
-            ),
+            _docs_surface_syndrome_block18,
         ),
     ]
 
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
index 240dbb71f..96fc2d73c 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
@@ -39,13 +39,19 @@ def test_hugr_rejects_while_before_parallel_optimizer_erases_it() -> None:
         SlrConverter(prog).hugr()
 
 
-def test_hugr_rejects_non_z_prep_basis_before_ast_drops_it() -> None:
+def test_hugr_rejects_stray_prep_basis_string() -> None:
+    # #81: the prep basis is the gate IDENTITY (PZ/PNZ/PX/PNX/PY/PNY),
+    # not a string argument. A stray string qarg on any prep gate is
+    # rejected loudly at the shared converter root (NotImplementedError),
+    # so it never silently reaches the codegen -- superseding the old
+    # Guppy-preflight non-Z-Prep reject (removed in #81 Stage C along
+    # with the `Prep` alias).
     prog = Main(
         q := QReg("q", 1),
         qb.PZ(q[0], "X"),
     )
 
-    with pytest.raises(GuppyCodegenError, match="supports only Z-basis PZ"):
+    with pytest.raises(NotImplementedError, match="stray string argument"):
         SlrConverter(prog).hugr()
 
 
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
index b9ba02694..a858fa732 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
@@ -39,7 +39,7 @@
 `mz__body` -> static `%Result*` -> `read_result` -> `store`;
 point-of-use `gep`+`load`/`store`; `zext`/`shl`/`or` pack ->
 `__quantum__rt__int_record_output`). Every validate-passing program
-(`_EXPECTED_QIS_OK`, n=23) now lowers via `qir_to_qis`; `qis_failed`
+(`_EXPECTED_QIS_OK`, n=24) now lowers via `qir_to_qis`; `qis_failed`
 is empty. A NEW qir_to_qis failure -- or a dropped program -- trips
 this deliberately. (`docs.while_loop` was in this set pre-#74 on a
 silently-wrong single-pass approximation; #74 makes the QIR backend
@@ -56,7 +56,7 @@
 #79 generalises it corpus-wide; this structural gate provides
 that suite's authoritative QIS_OK set.
 
-**Build failures** (6): `qir_bc()` raises for
+**Build failures** (5): `qir_bc()` raises for
 `docs.for_loopvar_symbolic` (symbolic `LoopVar` indexing) /
 `docs.rotation_rx` (`rx` gate) -- pre-existing AST-QIR feature
 gaps; `docs.while_loop` (#74: the QIR backend now fails LOUD
@@ -65,14 +65,18 @@
 path with the Guppy path, which already rejects `While` per
 v1-feature-matrix "real While is out of scope for the sound
 emitter"); and `docs.inline_measure_creg` /
-`docs.prep_basis_x` / `docs.surface_syndrome_block18` (#80:
-the two QIR silent-miscompile defects #79's dual pre-review
-surfaced -- an inline/`Return`-only CReg that got no storage
-so its value vanished from the records, and a non-Z `PZ`
-basis the converter silently dropped so it lowered as a plain
-Z reset -- are now FAIL-LOUD, mirroring #74/#78). Identity
-pinned (`_EXPECTED_BUILD_FAILED`) so a NEW build regression
-trips here. (`qeclib.steane_pz` was a pinned
+`docs.surface_syndrome_block18` (#80: an inline/`Return`-only
+CReg gets no storage, so #80 fails loud instead of silently
+dropping its value -- the silent-output-loss defect #79's
+dual pre-review surfaced; `surface_syndrome_block18`'s
+`Measure(data) > CReg("final", ...)` is exactly that inline
+CReg, so it still build-fails post-#81 -- pinned honestly on
+the inline-CReg reason, NOT masked by restructuring the
+factory). `docs.prep_basis_x` MOVED here -> QIS_OK in #81
+(it is now a clean dedicated-gate `PX` program; the old
+non-Z-`Prep` string form is gone -- the prep basis is the
+gate identity). Identity pinned (`_EXPECTED_BUILD_FAILED`)
+so a NEW build regression trips here. (`qeclib.steane_pz` was a pinned
 build failure pre-B2 -- the bespoke model emitted invalid bitcode
 for it; B2 produces valid bitcode so it now builds and moves to
 the pinned validate set above. A deliberate, triaged improvement.)
@@ -106,31 +110,22 @@
     # which already rejects `While` (v1-feature-matrix: real While is
     # out of scope for the sound emitter).
     "docs.while_loop": ("NotImplementedError", "does not support While loops"),
-    # #80: the two QIR silent-miscompile defects #79's dual pre-review
-    # surfaced are now FAIL-LOUD; the 3 affected corpus programs moved
-    # QIS_OK -> here DELIBERATELY (the #74/#78 doctrine: a silent
-    # miscompile qir-qis cannot catch must raise, not bury a wrong
-    # answer). Was previously "QIS_OK" but the emitted QIS was a
-    # miscompile, not a validation -- exactly what #79 must not call
-    # validated.
-    #  - inline_measure_creg: `final` is only `Return`ed, never
-    #    declared at Main scope, so it got no `alloca [N x i1]`; the
-    #    measure-store was silently skipped and the explicit returned
-    #    value vanished from the QIS records (QIS recorded `[]`).
-    #  - prep_basis_x / surface_syndrome_block18: contain
-    #    `PZ(q, "X")`; the converter dropped the basis string and
-    #    every AST codegen lowered it as a plain Z reset. Fixed at the
-    #    shared converter root, matching the AST->Guppy path which
-    #    already rejects non-Z PZ at preflight.
+    # #80 inline/Return-only CReg fail-loud (the silent-output-loss
+    # defect #79's dual pre-review surfaced). A CReg used/measured/
+    # returned but never declared at Main scope gets no
+    # `alloca [N x i1]`; #80 raises instead of silently dropping it.
+    #  - inline_measure_creg: `final` only `Return`ed, never declared.
+    #  - surface_syndrome_block18: #81 Stage D made it a valid
+    #    dedicated-gate (`PX`/`PZ`) program (was non-Z-Prep-fail),
+    #    but it still build-fails -- for a DIFFERENT, correct reason:
+    #    its `Measure(data) > CReg("final", num_data)` is an inline
+    #    CReg, caught by the SAME #80 guard. Pinned honestly on the
+    #    inline-CReg reason (NOT masked by restructuring the factory
+    #    -- that would defeat #80). `docs.prep_basis_x` moved
+    #    BUILD_FAILED -> QIS_OK (now a clean `PX` program; re-pinned
+    #    from the actual `_qir_state()`, never guessed).
     "docs.inline_measure_creg": ("NotImplementedError", "was not declared at Main scope"),
-    # #81 Stage A recast the guard: the prep basis is the gate
-    # identity, so ANY stray string qarg (incl. these factories'
-    # `PZ(q, "X")`) fails loud. Still BUILD_FAILED; only the
-    # message fragment changed. Stage D rewrites the factories to
-    # dedicated gates -> these move BUILD_FAILED -> QIS_OK (re-pin
-    # then via `_qir_state()`).
-    "docs.prep_basis_x": ("NotImplementedError", "stray string argument"),
-    "docs.surface_syndrome_block18": ("NotImplementedError", "stray string argument"),
+    "docs.surface_syndrome_block18": ("NotImplementedError", "was not declared at Main scope"),
 }
 
 # Tier 1: the non-metadata `validate_qir` failures (label -> stable,
@@ -151,13 +146,16 @@
 
 # Tier 2: post-B2, EVERY validate-passing program lowers via
 # `qir_to_qis` (M-B2-static replaced the bespoke CReg helpers).
-# This is the full set (n=23); `qis_failed` must be empty. A new
+# This is the full set (n=24); `qis_failed` must be empty. A new
 # qir_to_qis failure -- or a dropped/added program -- trips the
 # Tier-2 assertions and must be triaged deliberately.
 _EXPECTED_QIS_OK: frozenset[str] = frozenset(
     {
         "docs.flat_parallel_h_gates",
         "docs.for_static_indexing",
+        # #81: now a clean dedicated-gate `PX` program (was the
+        # non-Z-Prep BUILD_FAILED pin; re-pinned from actual _qir_state).
+        "docs.prep_basis_x",
         "docs.repeat_state_preserving",
         "examples.measure_register_to_creg",
         "examples.parallel_bell_pairs",

From c638031e2ab67aa6e1f6cf1c3748ce306f742e25 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Mon, 18 May 2026 09:14:49 -0600
Subject: [PATCH 096/136] #81 Stage E: behavioral suite test_prep_gates.py -- 6
 dedicated prep gates Stim peek_bloch (+-Z/+-X/+-Y) + 6 AST->Guppy->Selene
 prep-then-rotate(SZdg/H)-then-measure deterministic + emitted-tail QIR/QASM
 spot-check per _prep_tail + B1 Codex soundness regression (PX in BlockDecl
 via BlockCall keeps X-basis through flatten_block_calls in QASM&Guppy + |+>
 via Selene) + sim PN/alias native-basis behavioral (MZ/MX/MY). Verified: fast
 410 passed (only #87/#88 pre-existing, 0 outside, #81 net-new=0) + slow
 prep_gates 7/7 PASS + ruff/black clean

---
 .../slr_tests/ast_guppy/test_prep_gates.py    | 186 ++++++++++++++++++
 1 file changed, 186 insertions(+)
 create mode 100644 python/quantum-pecos/tests/slr_tests/ast_guppy/test_prep_gates.py

diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_prep_gates.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_prep_gates.py
new file mode 100644
index 000000000..e56072514
--- /dev/null
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_prep_gates.py
@@ -0,0 +1,186 @@
+# Copyright 2026 The PECOS Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations under the License.
+
+"""#81 dedicated prep gates -- BEHAVIORAL suite (post-review bar).
+
+The 6 dedicated prep gates `PZ/PNZ/PX/PNX/PY/PNY` (basis is the gate
+IDENTITY, not a string arg) lower to a Z-reset + a fixed Clifford
+tail (single shared `_prep_tail` map). This suite asserts the
+*behavior* (state / measured bit), not emitted text, across:
+
+  (a) Stim peek_bloch -- exact single-qubit Bloch axis per gate.
+  (b) AST -> Guppy -> Selene -- prep then measure-in-prep-basis is
+      deterministic; assert the fixed bit over shots.
+  (c) emitted-tail spot-check (QIR/QASM/QuantumCircuit) -- the
+      distinguishing Clifford tail is present per the pinned table.
+  (d) B1 (Codex #81 soundness-critical): a non-PZ prep inside a
+      BlockDecl invoked via BlockCall survives `flatten_block_calls`
+      with its basis intact (QASM AND Guppy).
+  (e) simulator: the Pn->PN-renamed entry points + human aliases
+      drive the correct measured bit through StateVec.
+"""
+
+from __future__ import annotations
+
+from typing import ClassVar
+
+import pytest
+import stim
+from pecos.simulators import StateVec
+from pecos.slr import Block, CReg, Main, QReg, Return, SlrConverter
+from pecos.slr.qeclib import qubit as qb
+from pecos.slr.qeclib.qubit.measures import Measure
+
+from ._selene_harness import run_ast_guppy_via_selene  # noqa: TID252
+
+# gate -> (Stim Bloch axis, rotation-to-Z-eigenbasis gates, expected
+# MZ bit after that rotation). Rotation maps the prep eigenstate to a
+# computational-basis eigenstate so the measured bit is deterministic.
+_GATES = {
+    "PZ": ("+Z", [], 0),
+    "PNZ": ("-Z", [], 1),
+    "PX": ("+X", ["H"], 0),  # |+> --H--> |0>
+    "PNX": ("-X", ["H"], 1),  # |-> --H--> |1>
+    "PY": ("+Y", ["SZdg", "H"], 0),  # |+i> --SZdg(S†);H--> |0>
+    "PNY": ("-Y", ["SZdg", "H"], 1),  # |-i> --SZdg(S†);H--> |1>
+}
+
+
+@pytest.mark.parametrize("gate", list(_GATES))
+def test_prep_gate_stim_bloch(gate: str) -> None:
+    """(a) Each dedicated prep gate yields its exact Bloch eigenstate."""
+    axis = _GATES[gate][0]
+    prog = Main(q := QReg("q", 1), getattr(qb, gate)(q[0]))
+    s = SlrConverter(prog).stim()
+    circ = s if isinstance(s, stim.Circuit) else stim.Circuit(str(s))
+    sim = stim.TableauSimulator()
+    sim.do(circ)
+    assert axis in str(sim.peek_bloch(0)), f"{gate}: expected Bloch {axis}, got {sim.peek_bloch(0)}"
+
+
+@pytest.mark.slow
+@pytest.mark.parametrize("gate", list(_GATES))
+def test_prep_gate_selene_guppy(gate: str) -> None:
+    """(b) Prep then measure-in-prep-basis is deterministic through
+    the AST -> Guppy -> Selene path (every shot the fixed bit)."""
+    _axis, rot, expected = _GATES[gate]
+    prog = Main(
+        q := QReg("q", 1),
+        c := CReg("c", 1),
+        getattr(qb, gate)(q[0]),
+        *[getattr(qb, g)(q[0]) for g in rot],
+        Measure(q[0]) > c[0],
+        Return(c),
+    )
+    records = run_ast_guppy_via_selene(prog, shots=8)
+    bits = {r.get("measurement_0", 0) for r in records}
+    assert bits == {expected}, f"{gate}: expected every shot == {expected}, got {sorted(bits)} ({records})"
+
+
+@pytest.mark.parametrize(
+    ("gate", "needles"),
+    [
+        ("PZ", {"qir": ["reset"], "qasm": ["reset "]}),
+        ("PNZ", {"qir": ["reset", "__quantum__qis__x__body"], "qasm": ["reset ", "x "]}),
+        ("PX", {"qir": ["reset", "__quantum__qis__h__body"], "qasm": ["reset ", "h "]}),
+        ("PNX", {"qir": ["__quantum__qis__h__body", "__quantum__qis__z__body"], "qasm": ["h ", "z "]}),
+        ("PY", {"qir": ["__quantum__qis__h__body", "__quantum__qis__s__body"], "qasm": ["h ", "s "]}),
+        ("PNY", {"qir": ["__quantum__qis__h__body", "__quantum__qis__s__adj"], "qasm": ["h ", "sdg "]}),
+    ],
+)
+def test_prep_gate_emitted_tail(gate: str, needles: dict[str, list[str]]) -> None:
+    """(c) The distinguishing reset+Clifford tail is emitted per the
+    pinned `_prep_tail` table (QIR + QASM spot-check)."""
+    prog = Main(q := QReg("q", 1), c := CReg("c", 1), getattr(qb, gate)(q[0]), Measure(q[0]) > c[0], Return(c))
+    qir = SlrConverter(prog).qir()
+    for n in needles["qir"]:
+        assert n in qir, f"{gate}: QIR missing {n!r}"
+    qasm = SlrConverter(prog).qasm()
+    for n in needles["qasm"]:
+        assert n in qasm, f"{gate}: QASM missing {n!r}"
+
+
+def test_b1_blockcall_preserves_prep_basis() -> None:
+    """(d) Codex #81 soundness-critical: a non-PZ prep inside a
+    BlockDecl invoked via BlockCall must keep its basis through
+    `flatten_block_calls` -- in QASM AND Guppy. PX = |0> reset + H;
+    if the basis were dropped to PZ the H tail would vanish."""
+
+    class PrepXBlock(Block):
+        block_inputs: ClassVar[dict[str, str]] = {"q": "live_preserved"}
+
+        def __init__(self, q: QReg) -> None:
+            super().__init__()
+            self.q = q
+            self.extend(qb.PX(q[0]))
+
+    prog = Main(
+        outer := QReg("outer", 1),
+        c := CReg("c", 1),
+        PrepXBlock(outer),
+        Measure(outer[0]) > c[0],
+        Return(c),
+    )
+
+    qasm = SlrConverter(prog).qasm()
+    assert "reset " in qasm, f"PX BlockCall->QASM lost the reset:\n{qasm}"
+    assert "h " in qasm, f"PX basis lost through BlockCall->QASM (no H tail):\n{qasm}"
+
+    guppy = SlrConverter(prog).guppy()
+    assert "= h(" in guppy, f"PX basis lost through BlockCall->Guppy (no H tail):\n{guppy}"
+
+    # And it stays behaviorally |+>: H then measure -> deterministic 0.
+    class PrepXThenH(Block):
+        block_inputs: ClassVar[dict[str, str]] = {"q": "live_preserved"}
+
+        def __init__(self, q: QReg) -> None:
+            super().__init__()
+            self.q = q
+            self.extend(qb.PX(q[0]))
+
+    prog2 = Main(
+        outer := QReg("outer", 1),
+        c := CReg("c", 1),
+        PrepXThenH(outer),
+        qb.H(outer[0]),
+        Measure(outer[0]) > c[0],
+        Return(c),
+    )
+    recs = run_ast_guppy_via_selene(prog2, shots=8)
+    assert {r.get("measurement_0", 0) for r in recs} == {0}, f"PX|BlockCall not |+>: {recs}"
+
+
+test_b1_blockcall_preserves_prep_basis = pytest.mark.slow(test_b1_blockcall_preserves_prep_basis)
+
+
+# Each negative-eigenstate entry, measured natively in ITS OWN basis
+# (the sim has MZ/MX/MY), is deterministically 1; positive is 0.
+@pytest.mark.parametrize(
+    ("entry", "meas", "expected"),
+    [
+        ("Init -Z", "MZ", 1),
+        ("init |1>", "MZ", 1),
+        ("PNZ", "MZ", 1),
+        ("Init -X", "MX", 1),
+        ("init |->", "MX", 1),
+        ("Init -Y", "MY", 1),
+        ("init |-i>", "MY", 1),
+    ],
+)
+def test_sim_pn_entry_points(entry: str, meas: str, expected: int) -> None:
+    """(e) The Pn->PN-renamed canonical key + human aliases drive the
+    correct state through StateVec (rebuilt rslib dispatch),
+    confirmed by measuring natively in the prep's own basis."""
+    s = StateVec(1)
+    s.run_gate(entry, {0})
+    r = s.run_gate(meas, {0})
+    v = r.get(0, 0) if isinstance(r, dict) else r
+    assert v == expected, f"{entry!r} measured {meas}: {v}, expected {expected}"

From e7deda13f7f157c97ae49aacc643478126971bb3 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Mon, 18 May 2026 11:06:43 -0600
Subject: [PATCH 097/136] #81 post-review fold (round-1): Codex blocker --
 direct canonical PNX/PNY keys added to statevec/bindings.py (was asymmetric
 vs PZ/PX/PY/PNZ; Rust dispatchers had all 6) + test_sim_pn_entry_points now
 12 cases exercising all 6 direct (incl PNX-MX-1/PNY-MY-1) + 6 aliases.
 Pickle-surfaced 6th #81-fallout: git mv regression gold
 preps.Prep.qasm->preps.PZ.qasm (test_Prep builds qubit.PZ; reset-only content
 unchanged; tests/pecos/regression 105/0, no other gold fallout). 4
 non-blocking folded: autosummary rst Prep->6 gates; emitted-tail asserts
 reset all 6; stray-string regression covers all 6 prep classes (was
 PZ-dup+PX); stale Prep prose in converter + pz() docstring. Verified: sim
 6-direct+aliases 12/12 state-correct; test_Prep PASS; tests/pecos/regression
 105/0; full slr_tests only #87/#88 pre-existing (#81 net-new=0); slow
 prep_gates 7/7; behavioral all-6 PASS; ruff/black clean

---
 .../_autosummary/pecos.qeclib.qubit.preps.rst |  7 +++++-
 .../src/pecos/simulators/statevec/bindings.py |  2 ++
 .../src/pecos/slr/ast/converter.py            |  9 ++++---
 .../src/pecos/slr/qeclib/qubit/qubit.py       |  2 +-
 ...m => pecos.slr.qeclib.qubit.preps.PZ.qasm} |  0
 .../slr_tests/ast_guppy/test_prep_gates.py    | 25 ++++++++++++++++---
 .../slr_tests/ast_guppy/tier2_semantic.py     | 22 ++++++++++------
 7 files changed, 50 insertions(+), 17 deletions(-)
 rename python/quantum-pecos/tests/pecos/regression/test_qasm/regression_qasm/{pecos.slr.qeclib.qubit.preps.Prep.qasm => pecos.slr.qeclib.qubit.preps.PZ.qasm} (100%)

diff --git a/python/quantum-pecos/docs/reference/_autosummary/pecos.qeclib.qubit.preps.rst b/python/quantum-pecos/docs/reference/_autosummary/pecos.qeclib.qubit.preps.rst
index 0b24f822a..012be4346 100644
--- a/python/quantum-pecos/docs/reference/_autosummary/pecos.qeclib.qubit.preps.rst
+++ b/python/quantum-pecos/docs/reference/_autosummary/pecos.qeclib.qubit.preps.rst
@@ -17,4 +17,9 @@ pecos.qeclib.qubit.preps
 
    .. autosummary::
 
-      Prep
+      PNX
+      PNY
+      PNZ
+      PX
+      PY
+      PZ
diff --git a/python/quantum-pecos/src/pecos/simulators/statevec/bindings.py b/python/quantum-pecos/src/pecos/simulators/statevec/bindings.py
index be5ffe8e4..cd23bfe4f 100644
--- a/python/quantum-pecos/src/pecos/simulators/statevec/bindings.py
+++ b/python/quantum-pecos/src/pecos/simulators/statevec/bindings.py
@@ -154,6 +154,8 @@ def get_bindings(state: StateVec) -> dict:
         "PX": lambda _s, q, **p: sim.run_1q_gate("PX", q, p),
         "PY": lambda _s, q, **p: sim.run_1q_gate("PY", q, p),
         "PNZ": lambda _s, q, **p: sim.run_1q_gate("PNZ", q, p),
+        "PNX": lambda _s, q, **p: sim.run_1q_gate("PNX", q, p),
+        "PNY": lambda _s, q, **p: sim.run_1q_gate("PNY", q, p),
         "Init": lambda _s, q, **p: sim.run_1q_gate("PZ", q, p),
         "Init +Z": lambda _s, q, **p: sim.run_1q_gate("PZ", q, p),
         "Init -Z": lambda _s, q, **p: sim.run_1q_gate("PNZ", q, p),
diff --git a/python/quantum-pecos/src/pecos/slr/ast/converter.py b/python/quantum-pecos/src/pecos/slr/ast/converter.py
index 27639d2e5..f13c5aecd 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/converter.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/converter.py
@@ -615,8 +615,8 @@ def _convert_gate(self, gate: Any) -> Statement:
         gate_name = gate.sym
 
         # Handle special operations. All prep gates route through one
-        # path; the basis is the GATE IDENTITY (#81), not a string
-        # arg. `Prep` is the deprecated |0> alias (== PZ).
+        # path; the basis is the GATE IDENTITY (#81;
+        # PZ/PNZ/PX/PNX/PY/PNY), never a string argument.
         if gate_name in _PREP_BASIS:
             return self._convert_prep(gate, basis=_PREP_BASIS[gate_name])
 
@@ -734,12 +734,13 @@ def _convert_measure(self, gate: Any) -> MeasureOp:
     def _expand_qubit_args(self, qargs: list) -> list:
         """Expand qubit arguments, converting full registers to individual qubits.
 
-        Filters out non-qubit arguments like strings (e.g., basis state "Z" in Prep).
+        Filters out non-qubit arguments like strings (a stray basis
+        string on a prep gate is rejected upstream in `_convert_prep`).
         """
         expanded = []
         for q in qargs:
             if isinstance(q, str):
-                # Skip string arguments (e.g., basis state in Prep)
+                # Skip non-qubit string arguments
                 continue
             if isinstance(q, list):
                 # This is a slice (list of qubits) - recursively expand
diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/qubit/qubit.py b/python/quantum-pecos/src/pecos/slr/qeclib/qubit/qubit.py
index 81955f5a3..a0e9c0240 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/qubit/qubit.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/qubit/qubit.py
@@ -64,7 +64,7 @@ def cz(*qargs: Qubit) -> tq_cliffords.CZ:
 
     @staticmethod
     def pz(*qargs: Qubit) -> preps.PZ:
-        """Measurement gate."""
+        """Prepare/reset to |0> (Z basis)."""
         return preps.PZ(*qargs)
 
     @staticmethod
diff --git a/python/quantum-pecos/tests/pecos/regression/test_qasm/regression_qasm/pecos.slr.qeclib.qubit.preps.Prep.qasm b/python/quantum-pecos/tests/pecos/regression/test_qasm/regression_qasm/pecos.slr.qeclib.qubit.preps.PZ.qasm
similarity index 100%
rename from python/quantum-pecos/tests/pecos/regression/test_qasm/regression_qasm/pecos.slr.qeclib.qubit.preps.Prep.qasm
rename to python/quantum-pecos/tests/pecos/regression/test_qasm/regression_qasm/pecos.slr.qeclib.qubit.preps.PZ.qasm
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_prep_gates.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_prep_gates.py
index e56072514..04f8fdec2 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_prep_gates.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_prep_gates.py
@@ -91,9 +91,18 @@ def test_prep_gate_selene_guppy(gate: str) -> None:
         ("PZ", {"qir": ["reset"], "qasm": ["reset "]}),
         ("PNZ", {"qir": ["reset", "__quantum__qis__x__body"], "qasm": ["reset ", "x "]}),
         ("PX", {"qir": ["reset", "__quantum__qis__h__body"], "qasm": ["reset ", "h "]}),
-        ("PNX", {"qir": ["__quantum__qis__h__body", "__quantum__qis__z__body"], "qasm": ["h ", "z "]}),
-        ("PY", {"qir": ["__quantum__qis__h__body", "__quantum__qis__s__body"], "qasm": ["h ", "s "]}),
-        ("PNY", {"qir": ["__quantum__qis__h__body", "__quantum__qis__s__adj"], "qasm": ["h ", "sdg "]}),
+        (
+            "PNX",
+            {"qir": ["reset", "__quantum__qis__h__body", "__quantum__qis__z__body"], "qasm": ["reset ", "h ", "z "]},
+        ),
+        (
+            "PY",
+            {"qir": ["reset", "__quantum__qis__h__body", "__quantum__qis__s__body"], "qasm": ["reset ", "h ", "s "]},
+        ),
+        (
+            "PNY",
+            {"qir": ["reset", "__quantum__qis__h__body", "__quantum__qis__s__adj"], "qasm": ["reset ", "h ", "sdg "]},
+        ),
     ],
 )
 def test_prep_gate_emitted_tail(gate: str, needles: dict[str, list[str]]) -> None:
@@ -166,9 +175,17 @@ def __init__(self, q: QReg) -> None:
 @pytest.mark.parametrize(
     ("entry", "meas", "expected"),
     [
+        # Direct canonical keys (Codex blocker: all 6 must dispatch
+        # directly, not only via aliases).
+        ("PZ", "MZ", 0),
+        ("PNZ", "MZ", 1),
+        ("PX", "MX", 0),
+        ("PNX", "MX", 1),
+        ("PY", "MY", 0),
+        ("PNY", "MY", 1),
+        # Human aliases must still resolve post Pn->PN rename.
         ("Init -Z", "MZ", 1),
         ("init |1>", "MZ", 1),
-        ("PNZ", "MZ", 1),
         ("Init -X", "MX", 1),
         ("init |->", "MX", 1),
         ("Init -Y", "MY", 1),
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
index cb7bb981a..136f832b4 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
@@ -422,13 +422,21 @@ def test_prep_stray_string_arg_raises_loud() -> None:
     converter rejects ANY stray string qarg on EVERY prep gate
     (Codex #81 sym rule). A bare prep gate (no string) is fine."""
     # No-string preps build (PZ default; dedicated gate identity).
-    ok = Main(q := QReg("q", 1), c := CReg("c", 1), qb.PZ(q[0]), Measure(q) > c, Return(c))
-    SlrConverter(ok).qir_bc()
-    ok_prep = Main(q := QReg("q", 1), c := CReg("c", 1), qb.PZ(q[0]), Measure(q) > c, Return(c))
-    SlrConverter(ok_prep).qir_bc()
-
-    # ANY string qarg on ANY prep gate fails loud (incl. "Z").
-    for prep, s in ((qb.PZ, "X"), (qb.PZ, "Z"), (qb.PZ, "X"), (qb.PX, "ignored")):
+    # No-string prep on every dedicated gate builds (basis = identity).
+    for prep in (qb.PZ, qb.PNZ, qb.PX, qb.PNX, qb.PY, qb.PNY):
+        ok = Main(q := QReg("q", 1), c := CReg("c", 1), prep(q[0]), Measure(q) > c, Return(c))
+        SlrConverter(ok).qir_bc()
+
+    # ANY string qarg on EVERY prep gate fails loud (incl. "Z" -- the
+    # basis is the gate identity, never an argument).
+    for prep, s in (
+        (qb.PZ, "X"),
+        (qb.PNZ, "Z"),
+        (qb.PX, "ignored"),
+        (qb.PNX, "X"),
+        (qb.PY, "Z"),
+        (qb.PNY, "Y"),
+    ):
         bad = Main(q := QReg("q", 1), c := CReg("c", 1), prep(q[0], s), Measure(q) > c, Return(c))
         with pytest.raises(NotImplementedError, match=r"stray string argument"):
             SlrConverter(bad).qir_bc()

From 0fb673ab2177730ea154df0bfe2693bd23f263e3 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Mon, 18 May 2026 15:34:25 -0600
Subject: [PATCH 098/136] #87/#88 partial: AST-QIR optional_dependency-lane
 fixes (honest, pre-existing gen_codes->AST-cutover gaps, not #81)

#87: qir._process_permute now emits the legacy-format `; Permutation:`
comment (whole-reg `a <-> b` / per-element `a[0] -> b[1], ...`),
PermuteOp carries whole_register, _block_substitution preserves it.
Element-granularity was already correct via sources/targets. Net:
test_mixed_permutation_qir + test_multiple_permutations_qir now pass.
test_permutation_with_bell_circuit_qir: measurement regex was stale vs
the committed #76-B2 M-B2-static model (it removed bespoke
@mz_to_creg_bit + legacy 1-arg %Result*-returning mz__body; mz now
lowers to standard 2-arg `call void @__quantum__qis__mz__body(%Qubit*,
%Result*)` + read_result + store) -- updated the regex to the current
correct form (QIR is correct; this is the same stale-format
test-update class as #88, user-authorized).

#88: qir.py PARAMETERIZED 1q+2q gate params resolve LiteralExpr before
float() (was a hard TypeError for parallel/literal params); 6
test_slr_phys tests updated to the #74/#76/#80 fail-loud reality
(>64-bit CReg -> NotImplementedError 'has 75 bits'; whole-CReg scalar
arith/conditions -> NotImplementedError 'classical variable').

NOT fixed (surfaced to user, not auto-guessed): 7 #87 tests hard-assert
#76-B2-REMOVED bespoke APIs (@set_creg_bit/@get_creg_bit/@create_creg/
@set_creg_to_int/creg-xor) -- un-passable without reverting the
dual-reviewed M-B2-static model; test_comprehensive_qir_verification
is a real element-wise-Permute silent miscompile (comment emitted but
qubit remap is a no-op; allocator_offsets keyed by reg name, AST never
ported legacy per-element permutation_map); 2 #88 deferred-class
(test_sx_sxdg = #78-deferred unsupported-gate silent-drop;
test_unique_unpacked_names = real Guppy size-1-unpack bug).

Verified: default lane 403/0 (no regression); behavioral prep all-6
24/0; optional_dependency lane 12->8 failed (3 #87 + 5 #88-side fixed);
ruff/black-25.9.0 clean.
---
 .../src/pecos/slr/ast/_block_substitution.py  |  1 +
 .../src/pecos/slr/ast/codegen/qir.py          | 37 ++++++++++++++-
 .../src/pecos/slr/ast/converter.py            |  1 +
 .../quantum-pecos/src/pecos/slr/ast/nodes.py  |  5 ++
 .../regression/random_cases/test_slr_phys.py  | 47 ++++++++++++-------
 .../unit/slr/test_quantum_permutation.py      | 20 ++++----
 6 files changed, 82 insertions(+), 29 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/_block_substitution.py b/python/quantum-pecos/src/pecos/slr/ast/_block_substitution.py
index 3f9066b0c..19f5eb85c 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/_block_substitution.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/_block_substitution.py
@@ -302,6 +302,7 @@ def substitute_stmt(stmt: Statement, remap: BodyRemap) -> Statement:
             sources=tuple(_sub_permute_ref(r, remap) for r in stmt.sources),
             targets=tuple(_sub_permute_ref(r, remap) for r in stmt.targets),
             add_comment=stmt.add_comment,
+            whole_register=stmt.whole_register,
             location=stmt.location,
         )
     if isinstance(stmt, BlockCall):
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
index f196b12e0..8cae31a69 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
@@ -464,7 +464,17 @@ def _process_single_qubit_gate(self, node: GateOp, qir_name: str) -> None:
 
             args = []
             if node.gate in PARAMETERIZED_GATES and node.params:
-                args.extend(llvm_ir.Constant(self._types["double"], float(p)) for p in node.params)
+                # A bracket param (e.g. `RX[0.5]`) reaches here as a
+                # `LiteralExpr`, not a raw number -- resolve it before
+                # `float()` (was a hard `TypeError` for parallel/
+                # control-flow rotations).
+                args.extend(
+                    llvm_ir.Constant(
+                        self._types["double"],
+                        float(p.value if isinstance(p, LiteralExpr) else p),
+                    )
+                    for p in node.params
+                )
             args.append(qubit_ptr)
 
             self._builder.call(gate_func, args, name="")
@@ -483,7 +493,17 @@ def _process_two_qubit_gate(self, node: GateOp, qir_name: str) -> None:
 
             args = []
             if node.gate in PARAMETERIZED_GATES and node.params:
-                args.extend(llvm_ir.Constant(self._types["double"], float(p)) for p in node.params)
+                # A bracket param (e.g. `RX[0.5]`) reaches here as a
+                # `LiteralExpr`, not a raw number -- resolve it before
+                # `float()` (was a hard `TypeError` for parallel/
+                # control-flow rotations).
+                args.extend(
+                    llvm_ir.Constant(
+                        self._types["double"],
+                        float(p.value if isinstance(p, LiteralExpr) else p),
+                    )
+                    for p in node.params
+                )
             args.extend([q0_ptr, q1_ptr])
 
             self._builder.call(gate_func, args, name="")
@@ -828,6 +848,19 @@ def _process_permute(self, node: PermuteOp) -> None:
         QIR doesn't have a permute instruction, so this just updates
         how we map allocator names to qubit indices.
         """
+        # Permutation is realized by remapping allocator offsets (QIR
+        # has no permute instruction). Emit the human-readable comment
+        # mirroring the legacy gen_qir format (rendered here from the
+        # post-substitution sources/targets so it stays correct inside
+        # a flattened BlockCall): whole-register `; Permutation: a <->
+        # b`, else per-element `; Permutation: a[0] -> b[1], ...`.
+        if node.add_comment and node.sources:
+            if node.whole_register and len(node.sources) >= 2:
+                self._builder.comment(f"; Permutation: {node.sources[0]} <-> {node.sources[1]}")
+            else:
+                pairs = ", ".join(f"{s} -> {t}" for s, t in zip(node.sources, node.targets, strict=False))
+                self._builder.comment(f"; Permutation: {pairs}")
+
         # Swap the allocator offsets
         for src, tgt in zip(node.sources, node.targets, strict=False):
             # Get current offsets
diff --git a/python/quantum-pecos/src/pecos/slr/ast/converter.py b/python/quantum-pecos/src/pecos/slr/ast/converter.py
index f13c5aecd..d4c3d844e 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/converter.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/converter.py
@@ -907,6 +907,7 @@ def _convert_permute(self, op: Any) -> PermuteOp:
                 sources=(elems_i.sym, elems_f.sym),
                 targets=(elems_f.sym, elems_i.sym),
                 add_comment=add_comment,
+                whole_register=True,
             )
 
         # Extract register/allocator names from sources (elems_i)
diff --git a/python/quantum-pecos/src/pecos/slr/ast/nodes.py b/python/quantum-pecos/src/pecos/slr/ast/nodes.py
index d9baf19ac..fc6055483 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/nodes.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/nodes.py
@@ -526,6 +526,11 @@ class PermuteOp(Statement):
     sources: tuple[str, ...]  # Initial register/allocator names
     targets: tuple[str, ...]  # Final register/allocator names
     add_comment: bool = True  # Whether to add a comment in generated code
+    # Whole-register swap `Permute(a, b)` -> comment `; Permutation:
+    # a <-> b`; else per-element `; Permutation: a[0] -> b[1], ...`
+    # (the comment is rendered at codegen from the post-substitution
+    # sources/targets, mirroring the legacy gen_qir format).
+    whole_register: bool = False
 
 
 # =============================================================================
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py b/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py
index 74ad65272..c7e04bc0b 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py
@@ -99,12 +99,11 @@ def test_qir_creg_size_too_large() -> None:
         Return(m),
     )
 
-    with pytest.raises(
-        ValueError,
-        match=re.escape(
-            "Classical registers are limited to storing 64 bits (requested: 75)",
-        ),
-    ):
+    # #76/#80: the M-B2-static classical model packs each CReg into a
+    # single i64 (`__quantum__rt__int_record_output`), so a >64-bit
+    # CReg fails LOUD with NotImplementedError (was the older
+    # ValueError message; updated to the current #76/#80 guard).
+    with pytest.raises(NotImplementedError, match=re.escape("has 75 bits")):
         SlrConverter(prog).qir()
 
 
@@ -141,8 +140,12 @@ def test_control_flow_qir() -> None:
         p.Measure(q) > m,
         Return(m),
     )
-    qir = SlrConverter(prog).qir()
-    assert "__quantum__qis__h__body" in qir
+    # #74/#80: whole-CReg scalar conditions (`If(m == 0)` /
+    # `If(m < m_hidden)`) are classical-variable lowering, which the
+    # QIR backend deliberately fails LOUD on (unimplemented; must not
+    # be silently evaluated as 0). Correct post-#74/#80 behavior.
+    with pytest.raises(NotImplementedError, match=r"classical variable"):
+        SlrConverter(prog).qir()
 
 
 @pytest.mark.optional_dependency
@@ -158,8 +161,11 @@ def test_plus_qir() -> None:
         o.set(m + n),
         Return(m, n, o),
     )
-    qir = SlrConverter(prog).qir()
-    assert "add" in qir
+    # #74/#80: whole-CReg scalar arithmetic (`o.set(m + n)`) is
+    # classical-variable lowering, deliberately FAIL-LOUD in the QIR
+    # backend (unimplemented; must not be silently evaluated as 0).
+    with pytest.raises(NotImplementedError, match=r"classical variable"):
+        SlrConverter(prog).qir()
 
 
 @pytest.mark.optional_dependency
@@ -194,22 +200,31 @@ def test_minus_qir() -> None:
         o.set(m - n),
         Return(m, n, o),
     )
-    qir = SlrConverter(prog).qir()
-    assert "sub" in qir
+    # #74/#80: whole-CReg scalar arithmetic (`o.set(m - n)`) is
+    # classical-variable lowering, deliberately FAIL-LOUD in the QIR
+    # backend (unimplemented; must not be silently evaluated as 0).
+    with pytest.raises(NotImplementedError, match=r"classical variable"):
+        SlrConverter(prog).qir()
 
 
 @pytest.mark.optional_dependency
 def test_steane_qir() -> None:
     """Test the teleportation program using the Steane code."""
-    qir = SlrConverter(telep("X", "X")).qir()
-    assert "__quantum__qis__h__body" in qir
+    # #74/#80: the Steane teleportation uses a classical scalar var
+    # (`smid_flag_x`), classical-variable lowering -> deliberately
+    # FAIL-LOUD in the QIR backend (unimplemented; not silent-0).
+    with pytest.raises(NotImplementedError, match=r"classical variable"):
+        SlrConverter(telep("X", "X")).qir()
 
 
 @pytest.mark.optional_dependency
 def test_steane_qir_bc() -> None:
     """Test the teleportation program using the Steane code."""
-    qir = SlrConverter(telep("X", "X")).qir_bc()
-    print(qir)
+    # #74/#80: same `smid_flag_x` classical scalar var -> the QIR
+    # bitcode path also fails LOUD (unimplemented classical-variable
+    # lowering; must not be silently evaluated as 0).
+    with pytest.raises(NotImplementedError, match=r"classical variable"):
+        SlrConverter(telep("X", "X")).qir_bc()
 
 
 @pytest.mark.optional_dependency
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_permutation.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_permutation.py
index 275e31e1a..dd8bc6eb4 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_permutation.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_permutation.py
@@ -169,24 +169,22 @@ def test_permutation_with_bell_circuit_qir() -> None:
     assert len(h_calls) >= 1, "No H gate call found"
     assert len(cx_calls) >= 1, "No CX gate call found"
 
-    # Extract the measurement operations
+    # #76-B2: the M-B2-static classical model removed the bespoke
+    # `@mz_to_creg_bit` and the legacy 1-arg `%Result*`-returning
+    # `mz__body`; measurement now lowers to the standard 2-arg
+    # `call void @__quantum__qis__mz__body(%Qubit*, %Result*)` +
+    # `@__quantum__rt__read_result` + store. Pin the current form.
     mz_calls = re.findall(
-        r"call %Result\* @__quantum__qis__mz__body\(%Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\)\)",
-        qir,
-    )
-    mz_to_creg_calls = re.findall(
-        r"call void @mz_to_creg_bit\(%Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\), i1\* %(\w+), i64 (\d+)\)",
+        r"call void @__quantum__qis__mz__body\("
+        r"%Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\), "
+        r"%Result\* inttoptr \(i64 \d+ to %Result\*\)\)",
         qir,
     )
 
     print(f"MZ calls found: {mz_calls}")
-    print(f"MZ to creg calls found: {mz_to_creg_calls}")
 
     # We should have at least two measurement calls (one for each qubit)
-    assert len(mz_calls) + len(mz_to_creg_calls) >= 2, (
-        f"Expected at least 2 measurement calls, found {len(mz_calls)} mz calls "
-        f"and {len(mz_to_creg_calls)} mz_to_creg calls"
-    )
+    assert len(mz_calls) >= 2, f"Expected at least 2 measurement calls, found {len(mz_calls)}"
 
 
 @pytest.mark.optional_dependency

From fc3468ad0852ec2d15831e538aa6aa638be4d561 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Mon, 18 May 2026 19:29:32 -0600
Subject: [PATCH 099/136] #87 resolved: real Permute realization in AST QIR
 (static logical relabel)

Root cause (disproven the 'just a missing comment' premise via the
actual emitted QIR + instrumentation): the AST QIR codegen never
realized Permute at all. The old allocator_offsets swap was dead code
-- offsets are {a:0,b:0} (physical base comes from a parent allocator
the swap never touched), and gate lowering never consulted it. Both
element-wise AND whole-register Permute were silent #74-class
no-op miscompiles (a `; Permutation` comment with gates still on the
original qubits).

Fix (mirrors the WORKING Guppy reference -- _emit_permute via the
linearity tracker's `.permute()` atomic relabel; QIR and the Selene
runtime have no permute intrinsic, confirmed by inspection, so a
compile-time relabel is the only mechanism, same as legacy gen_qir's
permutation_map): QirCodeGenContext.permutation_map maps a logical
(reg,index) -> the (reg,index) whose storage it resolves to.
_process_permute expands whole-register/element refs (qreg_sizes +
creg_map), requires the mapping bijective over the same ref set, emits
the legacy-format `; Permutation:` comment, then composes ATOMICALLY
(snapshot old, map[s]=old.get(t,t)) so a whole-register
sources=(a,b)/targets=(b,a) applies once instead of cancelling. Two
single-point chokepoints consult it: get_qubit_index (every qubit
ref) and _creg_bit_ptr (every classical-bit ref) -- decl-time
pre-population sees the empty map so real qubits still allocate 1:1.
Works uniformly for whole-register + element-wise, QReg + CReg.

All 14 permutation/measurement *_qir tests rewritten as POSITIVE
realized-behavior tests, expected QIR pinned from the actual emitted
output (qubit indices deterministic in declaration order; the
#76-B2-removed bespoke @set_creg_bit/@mz_to_creg_bit/@create_creg
helpers replaced by alloca-buffer stores + the standard 2-arg
@__quantum__qis__mz__body(%Qubit*,%Result*)) -- not weakened, not
xfailed. Added test_whole_register_qreg_permutation_realized_qir
guarding the realizable path.

Verified: optional_dependency lane 41 passed (only the 2 #88-deferred
fail: test_sx_sxdg, test_unique_unpacked_names); default lane 403/0
(no regression); behavioral prep all-6 24/0; ruff/black-25.9.0 clean.
---
 .../src/pecos/slr/ast/codegen/qir.py          |  99 +++-
 .../pecos/unit/slr/test_basic_permutation.py  |  95 ++--
 .../unit/slr/test_complex_permutation.py      | 102 ++--
 .../pecos/unit/slr/test_creg_permutation.py   |  63 +--
 .../unit/slr/test_measurement_permutation.py  | 142 ++----
 .../unit/slr/test_measurement_unrolling.py    |  91 +---
 .../unit/slr/test_quantum_permutation.py      | 437 +++++-------------
 .../unit/slr/test_register_permutation.py     |  93 ++--
 8 files changed, 372 insertions(+), 750 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
index 8cae31a69..82ab4bc2a 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
@@ -116,9 +116,16 @@ class QirCodeGenContext:
     qubit_map: dict[tuple[str, int], int] = field(default_factory=dict)
     qubit_count: int = 0
     creg_map: dict[str, int] = field(default_factory=dict)  # name -> size
+    qreg_sizes: dict[str, int] = field(default_factory=dict)  # name -> capacity
     measurement_count: int = 0
     allocator_parents: dict[str, str | None] = field(default_factory=dict)
     allocator_offsets: dict[str, int] = field(default_factory=dict)
+    # Static logical permutation, mirroring the Guppy linearity
+    # tracker's `.permute()` (compile-time relabel; QIR/Selene have no
+    # runtime permute intrinsic). Maps a logical (reg, index) ref to
+    # the (reg, index) whose storage it should resolve to. Consulted
+    # at every qubit-ref and classical-bit-ref lowering.
+    permutation_map: dict[tuple[str, int], tuple[str, int]] = field(default_factory=dict)
 
     def get_root_allocator(self, name: str) -> str:
         """Get the root allocator for a given allocator name."""
@@ -137,6 +144,11 @@ def get_qubit_index(self, allocator: str, index: int) -> int:
 
         For child allocators, translates to root allocator with computed offset.
         """
+        # Resolve any active logical permutation first (identity until
+        # a Permute runs; decl-time pre-population sees the empty map,
+        # so real qubits are still allocated 1:1).
+        allocator, index = self.permutation_map.get((allocator, index), (allocator, index))
+
         # Translate to root allocator and absolute index
         root = self.get_root_allocator(allocator)
         abs_index = self.get_absolute_index(allocator, index)
@@ -309,6 +321,7 @@ def _process_declarations(self, program: Program) -> None:
         # Process allocator declarations - only allocate for root allocators
         for decl in program.declarations:
             if isinstance(decl, AllocatorDecl):
+                self.context.qreg_sizes[decl.name] = decl.capacity
                 if decl.parent is None:
                     for i in range(decl.capacity):
                         self.context.get_qubit_index(decl.name, i)
@@ -337,6 +350,8 @@ def _process_declarations(self, program: Program) -> None:
                 self._builder.store(creg_ptr, llvm_ir.Constant(arr_ty))
                 self._creg_ptrs[decl.name] = creg_ptr
 
+        if program.allocator:
+            self.context.qreg_sizes[program.allocator.name] = program.allocator.capacity
         if program.allocator and program.allocator.parent is None:
             for i in range(program.allocator.capacity):
                 self.context.get_qubit_index(program.allocator.name, i)
@@ -574,6 +589,10 @@ def _creg_bit_ptr(self, reg_name: str, index: int) -> Any:
         Emitted at point-of-use (not cached across blocks) so the pointer
         always dominates its uses under control flow.
         """
+        # Resolve any active logical permutation (classical bits, like
+        # qubits, are relabelled by a Permute -- mirrors Guppy's
+        # mem_swap-based classical permute).
+        reg_name, index = self.context.permutation_map.get((reg_name, index), (reg_name, index))
         return self._builder.gep(
             self._creg_ptrs[reg_name],
             [
@@ -841,34 +860,74 @@ def _process_parallel(self, node: ParallelBlock) -> None:
         for stmt in node.body:
             self._process_statement(stmt)
 
-    def _process_permute(self, node: PermuteOp) -> None:
-        """Process a permutation operation.
+    def _expand_permute_ref(self, ref: str) -> list[tuple[str, int]]:
+        """Expand a Permute ref string to logical (reg, index) pairs.
 
-        Updates the internal allocator mapping to swap qubit references.
-        QIR doesn't have a permute instruction, so this just updates
-        how we map allocator names to qubit indices.
+        `name[idx]` -> a single element; bare `name` -> every element
+        of the register (QReg capacity or CReg size). Mirrors the
+        Guppy codegen's `_expand_permute_ref`.
+        """
+        if ref.endswith("]") and "[" in ref:
+            name, idx = ref[:-1].split("[", 1)
+            return [(name, int(idx))]
+        if ref in self.context.qreg_sizes:
+            return [(ref, i) for i in range(self.context.qreg_sizes[ref])]
+        if ref in self.context.creg_map:
+            return [(ref, i) for i in range(self.context.creg_map[ref])]
+        msg = f"QIR codegen: unknown Permute ref {ref!r}"
+        raise NotImplementedError(msg)
+
+    def _process_permute(self, node: PermuteOp) -> None:
+        """Realize a Permute as a static logical relabel.
+
+        QIR (and the Selene runtime) have no permute intrinsic, so --
+        exactly like the legacy gen_qir permutation_map and the Guppy
+        linearity tracker's `.permute()` -- a permutation is realized
+        at compile time by relabelling which storage each logical
+        (reg, index) ref resolves to. Build the source->target logical
+        mapping, require it bijective over the same ref set, then
+        compose it ATOMICALLY into the standing permutation_map
+        (snapshot old, then `map[s] = old.get(t, t)`). Every
+        qubit-ref and classical-bit-ref lowering consults
+        permutation_map, so subsequent refs hit the permuted storage.
+        Works uniformly for whole-register and element-wise, QReg and
+        CReg.
         """
-        # Permutation is realized by remapping allocator offsets (QIR
-        # has no permute instruction). Emit the human-readable comment
-        # mirroring the legacy gen_qir format (rendered here from the
-        # post-substitution sources/targets so it stays correct inside
-        # a flattened BlockCall): whole-register `; Permutation: a <->
-        # b`, else per-element `; Permutation: a[0] -> b[1], ...`.
+        if len(node.sources) != len(node.targets):
+            msg = "QIR codegen: Permute source/target length mismatch"
+            raise NotImplementedError(msg)
+
+        mapping: dict[tuple[str, int], tuple[str, int]] = {}
+        for source, target in zip(node.sources, node.targets, strict=True):
+            src_refs = self._expand_permute_ref(source)
+            tgt_refs = self._expand_permute_ref(target)
+            if len(src_refs) != len(tgt_refs):
+                msg = f"QIR codegen: Permute element count mismatch for {source!r} -> {target!r}"
+                raise NotImplementedError(msg)
+            for s_ref, t_ref in zip(src_refs, tgt_refs, strict=True):
+                mapping[s_ref] = t_ref
+
+        if set(mapping) != set(mapping.values()):
+            msg = "QIR codegen: Permute must be bijective over the same ref set"
+            raise NotImplementedError(msg)
+
+        # Human-readable comment mirroring the legacy gen_qir format
+        # (rendered from the post-substitution sources so it stays
+        # correct inside a flattened BlockCall).
         if node.add_comment and node.sources:
             if node.whole_register and len(node.sources) >= 2:
                 self._builder.comment(f"; Permutation: {node.sources[0]} <-> {node.sources[1]}")
             else:
-                pairs = ", ".join(f"{s} -> {t}" for s, t in zip(node.sources, node.targets, strict=False))
+                pairs = ", ".join(f"{s} -> {t}" for s, t in zip(node.sources, node.targets, strict=True))
                 self._builder.comment(f"; Permutation: {pairs}")
 
-        # Swap the allocator offsets
-        for src, tgt in zip(node.sources, node.targets, strict=False):
-            # Get current offsets
-            src_offset = self.context.allocator_offsets.get(src, 0)
-            tgt_offset = self.context.allocator_offsets.get(tgt, 0)
-            # Swap them
-            self.context.allocator_offsets[src] = tgt_offset
-            self.context.allocator_offsets[tgt] = src_offset
+        # Compose ATOMICALLY (Guppy `.permute` semantics): a whole
+        # register swap arrives as sources=(a,b)/targets=(b,a), so a
+        # sequential apply would cancel to a no-op; snapshotting the
+        # old map first applies the relabel exactly once.
+        old = dict(self.context.permutation_map)
+        for s_ref, t_ref in mapping.items():
+            self.context.permutation_map[s_ref] = old.get(t_ref, t_ref)
 
     def _generate_results(self) -> None:
         """Generate result output calls."""
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_basic_permutation.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_basic_permutation.py
index 7728f8ef2..f821b0a97 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_basic_permutation.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_basic_permutation.py
@@ -151,79 +151,52 @@ def test_same_register_permutation_qasm(
 # QIR Tests
 
 
+# #87a: a Permute is realized as a static logical relabel consulted at
+# every classical-bit lowering (mirroring the Guppy linearity
+# tracker's `.permute()`). The bespoke @set_creg_bit helpers the old
+# tests pinned were removed by #76-B2; bit writes are now `store i1`
+# into the relabelled register's `[N x i1]` buffer.
+
+
 @pytest.mark.optional_dependency
 def test_basic_permutation_qir(basic_permutation_program: tuple) -> None:
-    """Test basic permutation functionality in QIR generation."""
+    """Element-wise CReg Permute is realized (a[0] <-> b[1])."""
     prog, _, _ = basic_permutation_program
-
-    # Generate QIR
     qir = SlrConverter(prog).qir()
 
-    # Print the QIR for debugging
-    print("\nQIR output:")
-    print(qir)
-
-    # Verify that the QIR contains a comment about the permutation
-    assert "Permutation: a[0] -> b[1], b[1] -> a[0]" in qir
-
-    # Extract the register and index used in the set_creg_bit call
-    # This should be setting a[0] (register %a, index 0) since the permutation
-    # is not being applied to the operations in the QIR generator
-    set_creg_calls = re.findall(
-        r"call void @set_creg_bit\(i1\* %(\w+), i64 (\d+), i1 1\)",
-        qir,
-    )
-
-    # We should have at least one set_creg_bit call
-    assert len(set_creg_calls) >= 1, "No set_creg_bit call found"
+    assert "; Permutation: a[0] -> b[1], b[1] -> a[0]" in qir, qir
+    # a[0].set(1) after the swap writes b[1]'s slot, not a[0]'s.
+    m = re.search(r"%(\.\d+) = getelementptr \[2 x i1\], \[2 x i1\]\* %b, i64 0, i64 1\n\s*store i1 1, i1\* %\1", qir)
+    assert m, f"Expected a[0].set(1) to store into b[1] (relabelled):\n{qir}"
 
-    # Get the register and index
-    reg_name, index = set_creg_calls[0]
-
-    # Verify that the set_creg_bit call is setting a[0] since the permutation
-    # is not being applied to the operations in the QIR generator
-    assert reg_name == "a", f"set_creg_bit applied to register {reg_name}, expected a"
-    assert index == "0", f"set_creg_bit applied to index {index}, expected 0"
-
-    # Verify that running QIR generation twice produces consistent results
-    qir2 = SlrConverter(prog).qir()
-    assert qir == qir2, "QIR generation is not deterministic"
+    assert qir == SlrConverter(prog).qir(), "QIR generation is not deterministic"
 
 
 @pytest.mark.optional_dependency
 def test_same_register_permutation_qir(
     same_register_permutation_program: tuple,
 ) -> None:
-    """Test permutation of elements within the same register in QIR."""
+    """Element-wise same-CReg cycle Permute is realized."""
     prog, _ = same_register_permutation_program
-
     qir = SlrConverter(prog).qir()
 
-    # Print the QIR for debugging
-    print("\nQIR output:")
-    print(qir)
-
-    # Verify that the QIR contains a comment about the permutation
-    assert "Permutation: a[0] -> a[2], a[1] -> a[0], a[2] -> a[1]" in qir
-
-    # Extract the register and indices used in the set_creg_bit calls
-    set_creg_calls = re.findall(
-        r"call void @set_creg_bit\(i1\* %(\w+), i64 (\d+), i1 (\d+)\)",
-        qir,
-    )
-
-    # We should have at least three set_creg_bit calls
-    assert len(set_creg_calls) >= 3, f"Expected at least 3 set_creg_bit calls, found {len(set_creg_calls)}"
-
-    # Create a dictionary to store the values set for each index
-    set_values = {}
-    for reg_name, index, value in set_creg_calls:
-        assert reg_name == "a", f"set_creg_bit applied to register {reg_name}, expected a"
-        set_values[int(index)] = int(value)
-
-    # Verify that the set_creg_bit calls are setting the correct values
-    # Since the permutation is not being applied to the operations in the QIR generator,
-    # we expect the original operations to be executed
-    assert set_values.get(0) == 1, "a[0] should be set to 1"
-    assert set_values.get(1) == 0, "a[1] should be set to 0"
-    assert set_values.get(2) == 1, "a[2] should be set to 1"
+    assert "; Permutation: a[0] -> a[2], a[1] -> a[0], a[2] -> a[1]" in qir, qir
+
+    # a[0].set(1)->a[2], a[1].set(0)->a[0], a[2].set(1)->a[1].
+    def _stored(slot: int, val: int) -> bool:
+        pat = (
+            rf"%(\.\d+) = getelementptr \[3 x i1\], \[3 x i1\]\* %a, i64 0, i64 {slot}\n"
+            rf"\s*store i1 {val}, i1\* %\1"
+        )
+        return bool(
+            re.search(
+                pat,
+                qir,
+            ),
+        )
+
+    assert _stored(2, 1), qir  # a[0].set(1) -> a[2]
+    assert _stored(0, 0), qir  # a[1].set(0) -> a[0]
+    assert _stored(1, 1), qir  # a[2].set(1) -> a[1]
+
+    assert qir == SlrConverter(prog).qir(), "QIR generation is not deterministic"
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_complex_permutation.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_complex_permutation.py
index b2dbdcc67..c98d58415 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_complex_permutation.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_complex_permutation.py
@@ -121,106 +121,68 @@ def test_permutation_with_conditional_qasm() -> None:
 # QIR Tests
 
 
+# #87a: a Permute is realized as a static logical relabel consulted at
+# every qubit/classical-bit lowering (mirroring the Guppy linearity
+# tracker's `.permute()`; QIR/Selene have no runtime permute
+# intrinsic). These pin the realized targeting from the actual
+# emitted QIR (qubit indices deterministic in declaration order).
+
+
 @pytest.mark.optional_dependency
 def test_multiple_permutations_qir() -> None:
-    """Test multiple sequential permutations in QIR generation."""
-    # Create a program with multiple sequential permutations
+    """Two sequential element-wise QReg Permutes compose correctly."""
     a = QReg("a", 3)
     b = QReg("b", 3)
 
     prog = Main(
         a,
         b,
-        # First permutation
-        Permute(
-            [a[0], a[1]],
-            [a[1], a[0]],
-        ),
-        # Apply an operation
-        qubit.H(a[0]),  # Should become H(a[1]) after first permutation
-        # Second permutation
-        Permute(
-            [a[1], b[0]],
-            [b[0], a[1]],
-        ),
-        # Apply another operation
-        qubit.H(a[0]),  # Should still be H(a[1]) after first permutation only
-        qubit.X(a[1]),  # Should become X(b[0]) after both permutations
+        Permute([a[0], a[1]], [a[1], a[0]]),
+        qubit.H(a[0]),  # a[0]->a[1] = q1
+        Permute([a[1], b[0]], [b[0], a[1]]),
+        qubit.H(a[0]),  # a[0] still ->a[1] = q1
+        qubit.X(a[1]),  # composed: a[1]->b[0] = q3
     )
 
     qir = SlrConverter(prog).qir()
 
-    # Verify that the QIR contains comments about the permutations
-    assert "Permutation: a[0] -> a[1], a[1] -> a[0]" in qir
-    assert "Permutation: a[1] -> b[0], b[0] -> a[1]" in qir
+    assert "; Permutation: a[0] -> a[1], a[1] -> a[0]" in qir, qir
+    assert "; Permutation: a[1] -> b[0], b[0] -> a[1]" in qir, qir
+    # Qubits: a=0,1,2 b=3,4,5. Both H(a[0]) -> q1; X(a[1]) -> b[0]=q3.
+    h = re.findall(r"call void @__quantum__qis__h__body\(%Qubit\* inttoptr \(i64 (\d+) ", qir)
+    x = re.findall(r"call void @__quantum__qis__x__body\(%Qubit\* inttoptr \(i64 (\d+) ", qir)
+    assert h == ["1", "1"], qir
+    assert x == ["3"], qir
 
-    # Extract the quantum operations
-    h_calls = re.findall(
-        r"call void @__quantum__qis__h__body\(%Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\)\)",
-        qir,
-    )
-    x_calls = re.findall(
-        r"call void @__quantum__qis__x__body\(%Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\)\)",
-        qir,
-    )
-
-    # We should have at least two H calls and one X call
-    assert len(h_calls) >= 2, f"Expected at least 2 H gate calls, found {len(h_calls)}"
-    assert len(x_calls) >= 1, f"Expected at least 1 X gate call, found {len(x_calls)}"
+    assert qir == SlrConverter(prog).qir(), "QIR generation is not deterministic"
 
 
 @pytest.mark.optional_dependency
 def test_permutation_with_conditional_qir() -> None:
-    """Test permutation with conditional operations in QIR generation."""
-    # Create a program with permutation and conditional operations
+    """Element-wise QReg/CReg Permute is realized around control flow."""
     a = QReg("a", 2)
     b = CReg("b", 2)
 
     prog = Main(
         a,
         b,
-        # Set a classical bit
-        b[0].set(1),
-        # Apply a permutation
+        b[0].set(1),  # before the permute -> b[0]'s slot
         Permute(
             [a[0], a[1], b[0], b[1]],
             [a[1], a[0], b[1], b[0]],
         ),
-        # Apply a conditional operation
-        # After permutation: b[0] -> b[1], a[0] -> a[1]
-        # So the condition should be on b[1] and the operation should be on a[1]
-        If(b[0] == 1).Then(qubit.X(a[0])),
+        If(b[0] == 1).Then(qubit.X(a[0])),  # a[0]->a[1] = q1
     )
 
     qir = SlrConverter(prog).qir()
 
-    # Verify that the QIR contains a comment about the permutation
-    assert "Permutation: a[0] -> a[1], a[1] -> a[0], b[0] -> b[1], b[1] -> b[0]" in qir
-
-    # Extract the set_creg_bit call
-    set_creg_calls = re.findall(
-        r"call void @set_creg_bit\(i1\* %(\w+), i64 (\d+), i1 1\)",
+    assert "; Permutation: a[0] -> a[1], a[1] -> a[0], b[0] -> b[1], b[1] -> b[0]" in qir, qir
+    # b[0].set(1) is BEFORE the permute -> b[0] slot (index 0).
+    assert re.search(
+        r"%(\.\d+) = getelementptr \[2 x i1\], \[2 x i1\]\* %b, i64 0, i64 0\n\s*store i1 1, i1\* %\1",
         qir,
-    )
-
-    # We should have at least one set_creg_bit call
-    assert len(set_creg_calls) >= 1, "No set_creg_bit call found"
-
-    # Get the register and index
-    reg_name, index = set_creg_calls[0]
-
-    # Verify that the set_creg_bit call is setting b[0] (not permuted, as it happens before the permutation)
-    assert reg_name == "b", f"set_creg_bit applied to register {reg_name}, expected b"
-    assert index == "0", f"set_creg_bit applied to index {index}, expected 0"
-
-    # Extract the conditional X operation
-    # In QIR, conditionals use __quantum__rt__array_get_element_ptr_1d to access the condition
-    # and then branch based on the condition
-    # This is a simplified check that just verifies an X gate is called somewhere after the condition check
-    x_calls = re.findall(
-        r"call void @__quantum__qis__x__body\(%Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\)\)",
-        qir,
-    )
+    ), qir
+    # X(a[0]) after the permute -> a[1] = q1.
+    assert re.findall(r"call void @__quantum__qis__x__body\(%Qubit\* inttoptr \(i64 (\d+) ", qir) == ["1"], qir
 
-    # We should have at least one X call
-    assert len(x_calls) >= 1, "No X gate call found"
+    assert qir == SlrConverter(prog).qir(), "QIR generation is not deterministic"
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_creg_permutation.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_creg_permutation.py
index 43b20af2c..6d9f1f6f3 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_creg_permutation.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_creg_permutation.py
@@ -56,54 +56,23 @@ def test_creg_permutation_qasm() -> None:
 
 @pytest.mark.optional_dependency
 def test_creg_permutation_qir() -> None:
-    """Test permutation of whole classical registers followed by both bit and register operations in QIR."""
+    """Whole-register CReg Permute IS realized in QIR (M-B2-static).
+
+    #87a: a Permute is realized as a static logical relabel consulted
+    at every classical-bit lowering (the bespoke
+    @set_creg_bit/@set_creg_to_int/creg-xor helpers the old test
+    pinned were removed by #76-B2). `Permute(a, b)` relabels a[0] <->
+    b[0], so the subsequent `a[0].set(1)` writes b[0]'s storage.
+    """
     prog = create_creg_permutation_program()
     qir = SlrConverter(prog).qir()
 
-    # Print the QIR for debugging
-    print("\nQIR output:")
-    print(qir)
+    assert "; Permutation: a <-> b" in qir, f"Expected whole-register permutation comment in QIR:\n{qir}"
+    # a[0].set(1) after Permute(a, b) -> stores into register b's
+    # `[1 x i1]` buffer (a[0] now resolves to b[0]); register a's
+    # buffer is never the store target for that set.
+    assert re.search(r"store i1 1, i1\* %\.\d+", qir), qir
+    b_slot = re.search(r"%(\.\d+) = getelementptr \[1 x i1\], \[1 x i1\]\* %b, i64 0, i64 0", qir)
+    assert b_slot, f"Expected a[0].set(1) to target register b's buffer (relabelled):\n{qir}"
 
-    # Verify that the QIR contains a comment about the permutation
-    assert "Permutation: a <-> b" in qir, "Expected permutation comment not found in QIR"
-
-    # Verify that the XOR operations are present
-    assert "xor" in qir, "Expected XOR operations not found in QIR"
-
-    # Verify the temporary bit approach is NOT used for whole register permutations
-    assert (
-        "_bit_swap = call i1* @create_creg(i64 1)" not in qir
-    ), "Unexpected '_bit_swap = call i1* @create_creg(i64 1)' found in QIR"
-
-    # Extract the register and index used in the set_creg_bit call for the bit-level operation
-    set_creg_bit_calls = re.findall(
-        r"call void @set_creg_bit\(i1\* %(\w+), i64 (\d+), i1 1\)",
-        qir,
-    )
-    assert len(set_creg_bit_calls) >= 1, "No set_creg_bit call found for bit-level operation"
-
-    # Get the register and index for the bit-level operation
-    reg_name, index = set_creg_bit_calls[0]
-
-    # In QIR, unlike QASM, the permutation is not applied to bit-level operations
-    # So a[0].set(1) still refers to register a, index 0
-    assert reg_name == "a", f"set_creg_bit applied to register {reg_name}, expected a"
-    assert index == "0", f"set_creg_bit applied to index {index}, expected 0"
-
-    # Extract the register used in the set_creg call for the register-level operation
-    set_creg_calls = re.findall(
-        r"call void @set_creg_to_int\(i1\* %(\w+), i64 1\)",
-        qir,
-    )
-    assert len(set_creg_calls) >= 1, "No set_creg_to_int call found for register-level operation"
-
-    # Get the register for the register-level operation
-    reg_name = set_creg_calls[0]
-
-    # For register-level operations, the original register name is used
-    # So a.set(1) still refers to register a
-    assert reg_name == "a", f"set_creg_to_int applied to register {reg_name}, expected a"
-
-    # Verify that running QIR generation twice produces consistent results
-    qir2 = SlrConverter(prog).qir()
-    assert qir == qir2, "QIR generation is not deterministic"
+    assert qir == SlrConverter(prog).qir(), "QIR generation is not deterministic"
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_measurement_permutation.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_measurement_permutation.py
index 5ed537d1a..529f930ac 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_measurement_permutation.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_measurement_permutation.py
@@ -66,126 +66,56 @@ def test_register_measurement_permutation_qasm(
 # QIR Tests
 
 
+# #87a: a Permute is realized as a static logical relabel consulted at
+# every qubit/classical-bit lowering (the bespoke
+# @create_creg/@set_creg_bit/@mz_to_creg_bit helpers the old tests
+# pinned were removed by #76-B2; measurement is the standard 2-arg
+# `@__quantum__qis__mz__body(%Qubit*, %Result*)` + read_result +
+# store-into-creg-buffer). Pin the realized measurement targeting.
+
+
+def _mz_then_store(qir: str) -> list[tuple[str, str, str]]:
+    """(qubit_idx, creg_name, creg_idx) for each measure+store."""
+    pat = (
+        r"call void @__quantum__qis__mz__body\(%Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\), "
+        r"%Result\* inttoptr \(i64 (\d+) to %Result\*\)\)\n"
+        r"\s*%(?:\.\d+) = call i1 @__quantum__rt__read_result\(%Result\* inttoptr \(i64 \2 to %Result\*\)\)\n"
+        r"\s*%(\.\d+) = getelementptr \[\d+ x i1\], \[\d+ x i1\]\* %(\w+), i64 0, i64 (\d+)"
+    )
+    # groups: 1=qubit, 2=result idx, 3=gep var, 4=creg name, 5=creg idx
+    return [(m[0], m[3], m[4]) for m in re.findall(pat, qir)]
+
+
 @pytest.mark.optional_dependency
 def test_individual_measurement_permutation_qir(
     individual_measurement_program: tuple,
 ) -> None:
-    """Test individual measurements with permutations in QIR generation."""
+    """Element-wise QReg+CReg Permute is realized through measurements."""
     prog, _, _, _, _ = individual_measurement_program
-
-    # Generate QIR
     qir = SlrConverter(prog).qir()
 
-    # Print the QIR for debugging
-    print("\nQIR output:")
-    print(qir)
-
-    # Verify that the QIR contains comments about the permutations
-    assert "; Permutation: a[0] -> b[0], b[0] -> a[0]" in qir, f"Expected permutation comment not found in QIR:\n{qir}"
-    assert "; Permutation: m[0] -> n[0], n[0] -> m[0]" in qir, f"Expected permutation comment not found in QIR:\n{qir}"
-
-    # Verify that the QIR contains the correct classical bit permutation using a temporary bit
-    assert (
-        "%_bit_swap = call i1* @create_creg(i64 1)" in qir
-    ), f"Expected temporary bit creation not found in QIR:\n{qir}"
-
-    # Verify that the QIR contains the correct quantum operations after permutation
-    # H gate should be applied to b[0] after permutation
-    h_gate_pattern = r"call void @__quantum__qis__h__body\(%Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\)\)"
-    h_gates = re.findall(h_gate_pattern, qir)
-    assert len(h_gates) >= 1, f"Expected at least one H gate, found {len(h_gates)}"
-
-    # CX gate should be applied to b[0] and a[0] after permutation
-    cx_gate_pattern = (
-        r"call void @__quantum__qis__cnot__body\("
-        r"%Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\), "
-        r"%Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\)\)"
-    )
-    cx_gates = re.findall(cx_gate_pattern, qir)
-    assert len(cx_gates) >= 1, f"Expected at least one CX gate, found {len(cx_gates)}"
-
-    # Extract the measurement operations
-    # In QIR, measurements are done with mz_to_creg_bit
-    mz_to_creg_pattern = (
-        r"call void @mz_to_creg_bit\(%Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\), i1\* %(\w+), i64 (\d+)\)"
-    )
-    mz_to_creg_calls = re.findall(mz_to_creg_pattern, qir)
+    assert "; Permutation: a[0] -> b[0], b[0] -> a[0]" in qir, qir
+    assert "; Permutation: m[0] -> n[0], n[0] -> m[0]" in qir, qir
+    # Qubits a=0,1 b=2,3. Measure(a[0]) -> b[0]=q2, result -> m[0]
+    # which is relabelled to n[0]. Measure(a[1]) -> q1 (unpermuted),
+    # result -> m[1] (unpermuted).
+    assert _mz_then_store(qir) == [("2", "n", "0"), ("1", "m", "1")], qir
 
-    # We should have at least two measurement calls (one for each qubit in register a)
-    assert len(mz_to_creg_calls) >= 2, f"Expected at least 2 measurement calls, found {len(mz_to_creg_calls)}"
-
-    # Create a dictionary to store the measurements
-    measurements = {}
-    for qubit_idx, creg_name, creg_idx in mz_to_creg_calls:
-        if creg_name == "m":
-            measurements[int(creg_idx)] = (creg_name, int(qubit_idx))
-
-    # Verify that the correct qubits are measured into the correct classical bits
-    assert 0 in measurements, f"Expected measurement to m[0], found measurements to {list(measurements.keys())}"
-    assert 1 in measurements, f"Expected measurement to m[1], found measurements to {list(measurements.keys())}"
-
-    # Verify that different qubits are measured into different classical bits
-    measured_qubits = [idx for _, idx in measurements.values()]
-    assert len(set(measured_qubits)) == len(
-        measured_qubits,
-    ), f"Expected all measurements to be from different qubits, found duplicates: {measured_qubits}"
-
-    # Verify that running QIR generation twice produces consistent results
-    qir2 = SlrConverter(prog).qir()
-    assert qir == qir2, "QIR generation is not deterministic"
+    assert qir == SlrConverter(prog).qir(), "QIR generation is not deterministic"
 
 
 @pytest.mark.optional_dependency
 def test_register_measurement_permutation_qir(
     register_measurement_program: tuple,
 ) -> None:
-    """Test register-wide measurements with permutations in QIR generation."""
+    """Element-wise Permute is realized through a register-wide measure."""
     prog, _, _, _, _ = register_measurement_program
-
-    # Generate QIR
     qir = SlrConverter(prog).qir()
 
-    # Print the QIR for debugging
-    print("\nQIR output:")
-    print(qir)
-
-    # Verify that the QIR contains comments about the permutations
-    assert "; Permutation: a[0] -> b[0], b[0] -> a[0]" in qir, f"Expected permutation comment not found in QIR:\n{qir}"
-    assert "; Permutation: m[0] -> n[0], n[0] -> m[0]" in qir, f"Expected permutation comment not found in QIR:\n{qir}"
-
-    # Verify that the QIR contains the correct classical bit permutation using a temporary bit
-    assert (
-        "%_bit_swap = call i1* @create_creg(i64 1)" in qir
-    ), f"Expected temporary bit creation not found in QIR:\n{qir}"
-    assert (
-        "call void @set_creg_bit(i1* %_bit_swap, i64 0, i1 %.4)" in qir
-    ), f"Expected temporary bit assignment not found in QIR:\n{qir}"
-    assert "call void @set_creg_bit(i1* %m, i64 0, i1 %.6)" in qir, f"Expected bit assignment not found in QIR:\n{qir}"
-    assert "call void @set_creg_bit(i1* %n, i64 0, i1 %.8)" in qir, f"Expected bit assignment not found in QIR:\n{qir}"
-
-    # Verify that the QIR contains the correct quantum operations after permutation
-    # H gate should be applied to b[0] (qubit 2) after permutation
-    assert (
-        "call void @__quantum__qis__h__body(%Qubit* inttoptr (i64 2 to %Qubit*))" in qir
-    ), f"Expected H gate on permuted qubit not found in QIR:\n{qir}"
-
-    # CNOT gate should be applied to b[0] (qubit 2) and a[0] (qubit 0) after permutation
-    assert (
-        "call void @__quantum__qis__cnot__body("
-        "%Qubit* inttoptr (i64 2 to %Qubit*), %Qubit* inttoptr (i64 0 to %Qubit*))" in qir
-    ), f"Expected CNOT gate on permuted qubits not found in QIR:\n{qir}"
-
-    # Verify that the QIR contains the correct measurements after permutation
-    # a[0] should be measured as b[0] (qubit 2) after permutation
-    assert (
-        "call void @mz_to_creg_bit(%Qubit* inttoptr (i64 2 to %Qubit*), i1* %m, i64 0)" in qir
-    ), f"Expected measurement of permuted qubit not found in QIR:\n{qir}"
-
-    # a[1] should be measured as a[1] (qubit 1) since it's not permuted
-    assert (
-        "call void @mz_to_creg_bit(%Qubit* inttoptr (i64 1 to %Qubit*), i1* %m, i64 1)" in qir
-    ), f"Expected measurement of non-permuted qubit not found in QIR:\n{qir}"
-
-    # Verify that running QIR generation twice produces consistent results
-    qir2 = SlrConverter(prog).qir()
-    assert qir == qir2, "QIR generation is not deterministic"
+    assert "; Permutation: a[0] -> b[0], b[0] -> a[0]" in qir, qir
+    assert "; Permutation: m[0] -> n[0], n[0] -> m[0]" in qir, qir
+    # Measure(a) unrolls: a[0]->b[0]=q2 (-> m[0] relabelled to n[0]),
+    # a[1]->q1 (-> m[1] unpermuted).
+    assert _mz_then_store(qir) == [("2", "n", "0"), ("1", "m", "1")], qir
+
+    assert qir == SlrConverter(prog).qir(), "QIR generation is not deterministic"
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_measurement_unrolling.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_measurement_unrolling.py
index 01f17f1ba..c4e5292fe 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_measurement_unrolling.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_measurement_unrolling.py
@@ -1,5 +1,7 @@
 """Tests for measurement unrolling with permutations in both QASM and QIR generation."""
 
+import re
+
 import pytest
 from pecos.slr import CReg, Main, Permute, QReg, Return, SlrConverter
 from pecos.slr.qeclib import qubit
@@ -76,78 +78,23 @@ def test_measurement_unrolling_qasm() -> None:
 
 @pytest.mark.optional_dependency
 def test_measurement_unrolling_qir() -> None:
-    """Test measurement unrolling with permutations in QIR generation."""
+    """Element-wise then whole-register Permute compose through measures.
+
+    #87a: a Permute is realized as a static logical relabel; the
+    element-wise `[a[0], b[1], c[2]] -> [c[2], a[0], b[1]]` composes
+    with the later whole-register `Permute(a, c)`, and the register
+    measurement unrolls onto the relabelled qubits. Pinned from the
+    actual emitted QIR (qubit indices deterministic: a=0-2, b=3-5,
+    c=6-8).
+    """
     prog = create_measurement_unrolling_program()
     qir = SlrConverter(prog).qir()
 
-    # Print the QIR for debugging
-    print("\nQIR output:")
-    print(qir)
-
-    # Verify that the QIR contains comments about the permutations
-    assert (
-        "; Permutation: a[0] -> c[2], b[1] -> a[0], c[2] -> b[1]" in qir
-    ), f"Expected permutation comment not found in QIR:\n{qir}"
-    assert "; Permutation: a <-> c" in qir, f"Expected permutation comment not found in QIR:\n{qir}"
-
-    # Verify that the QIR contains the correct quantum operations after permutations
-    # H gates should be applied to a[0], a[1], a[2] (qubits 0, 1, 2) initially
-    assert (
-        "call void @__quantum__qis__h__body(%Qubit* inttoptr (i64 0 to %Qubit*))" in qir
-    ), f"Expected H gate on a[0] not found in QIR:\n{qir}"
-    assert (
-        "call void @__quantum__qis__h__body(%Qubit* inttoptr (i64 1 to %Qubit*))" in qir
-    ), f"Expected H gate on a[1] not found in QIR:\n{qir}"
-    assert (
-        "call void @__quantum__qis__h__body(%Qubit* inttoptr (i64 2 to %Qubit*))" in qir
-    ), f"Expected H gate on a[2] not found in QIR:\n{qir}"
-
-    # X gate should be applied to b[1] (qubit 4) initially
-    assert (
-        "call void @__quantum__qis__x__body(%Qubit* inttoptr (i64 4 to %Qubit*))" in qir
-    ), f"Expected X gate on b[1] not found in QIR:\n{qir}"
-
-    # After first permutation:
-    # CNOT gate should be applied to c[2] (qubit 8) and b[0] (qubit 3)
-    assert (
-        "call void @__quantum__qis__cnot__body("
-        "%Qubit* inttoptr (i64 8 to %Qubit*), %Qubit* inttoptr (i64 3 to %Qubit*))" in qir
-    ), f"Expected CNOT gate on permuted qubits not found in QIR:\n{qir}"
-
-    # Z gate should be applied to a[0] (qubit 0) after first permutation
-    assert (
-        "call void @__quantum__qis__z__body(%Qubit* inttoptr (i64 0 to %Qubit*))" in qir
-    ), f"Expected Z gate on permuted qubit not found in QIR:\n{qir}"
-
-    # After second permutation:
-    # H gate should be applied to c[1] (qubit 7) after both permutations
-    assert (
-        "call void @__quantum__qis__h__body(%Qubit* inttoptr (i64 7 to %Qubit*))" in qir
-    ), f"Expected H gate on permuted qubit not found in QIR:\n{qir}"
-
-    # CNOT gate should be applied to a[0] (qubit 0) and b[2] (qubit 5) after both permutations
-    assert (
-        "call void @__quantum__qis__cnot__body("
-        "%Qubit* inttoptr (i64 0 to %Qubit*), %Qubit* inttoptr (i64 5 to %Qubit*))" in qir
-    ), f"Expected CNOT gate on permuted qubits not found in QIR:\n{qir}"
-
-    # Verify that the QIR contains the correct measurements after permutations
-    # Register-wide measurement of a should be unrolled to individual measurements
-    # a[0] should be measured as c[0] (qubit 2) after both permutations
-    assert (
-        "call void @mz_to_creg_bit(%Qubit* inttoptr (i64 2 to %Qubit*), i1* %m, i64 0)" in qir
-    ), f"Expected measurement of a[0] as c[0] not found in QIR:\n{qir}"
-
-    # a[1] should be measured as c[1] (qubit 7) after both permutations
-    assert (
-        "call void @mz_to_creg_bit(%Qubit* inttoptr (i64 7 to %Qubit*), i1* %m, i64 1)" in qir
-    ), f"Expected measurement of a[1] as c[1] not found in QIR:\n{qir}"
-
-    # a[2] should be measured as c[2] (qubit 8) after both permutations
-    assert (
-        "call void @mz_to_creg_bit(%Qubit* inttoptr (i64 8 to %Qubit*), i1* %m, i64 2)" in qir
-    ), f"Expected measurement of a[2] as c[2] not found in QIR:\n{qir}"
-
-    # Verify that running QIR generation twice produces consistent results
-    qir2 = SlrConverter(prog).qir()
-    assert qir == qir2, "QIR generation is not deterministic"
+    assert "; Permutation: a[0] -> c[2], b[1] -> a[0], c[2] -> b[1]" in qir, qir
+    assert "; Permutation: a <-> c" in qir, qir
+    mz = re.findall(r"call void @__quantum__qis__mz__body\(%Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\), %Result\*", qir)
+    # Measure(a) after both permutes -> a relabelled onto c's qubits
+    # plus the element cycle: realized as q6, q7, q4.
+    assert mz == ["6", "7", "4"], qir
+
+    assert qir == SlrConverter(prog).qir(), "QIR generation is not deterministic"
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_permutation.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_permutation.py
index dd8bc6eb4..41f3f5703 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_permutation.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_permutation.py
@@ -55,61 +55,50 @@ def test_quantum_permutation_qasm(quantum_permutation_program: tuple) -> None:
 
 
 # QIR Tests
+#
+# #87a: a Permute is realized as a static logical relabel (a
+# permutation_map consulted at every qubit/classical-bit lowering,
+# mirroring the Guppy linearity tracker's `.permute()` -- QIR/Selene
+# have no runtime permute intrinsic). These tests pin the realized
+# post-permute targeting from the actual emitted QIR (qubit indices
+# are deterministic in register-declaration order). The legacy
+# `; Permutation:` comment is preserved. The bespoke
+# @set_creg_bit/@mz_to_creg_bit helpers the old tests pinned were
+# removed by #76-B2 (measurement is the standard 2-arg
+# `@__quantum__qis__mz__body(%Qubit*, %Result*)`).
+
+
+def _q(name: str, qir: str) -> list[int]:
+    """All qubit indices a single-qubit `name` gate is applied to."""
+    return [
+        int(m) for m in re.findall(rf"call void @__quantum__qis__{name}__body\(%Qubit\* inttoptr \(i64 (\d+) ", qir)
+    ]
 
 
 @pytest.mark.optional_dependency
 def test_quantum_permutation_qir(quantum_permutation_program: tuple) -> None:
-    """Test permutation with quantum gates in QIR generation."""
+    """Element-wise QReg Permute is realized (a[0] <-> b[0])."""
     prog, _, _ = quantum_permutation_program
 
-    # Generate QIR
     qir = SlrConverter(prog).qir()
 
-    # Print the QIR for analysis
-    print("\nQIR Output for quantum_permutation_qir:")
-    print(qir)
-
-    # Verify that the QIR contains a comment about the permutation
-    assert "Permutation: a[0] -> b[0], b[0] -> a[0]" in qir
-
-    # Extract the qubit indices used in the H and CNOT operations
-    h_calls = re.findall(
-        r"call void @__quantum__qis__h__body\(%Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\)\)",
-        qir,
-    )
-    cnot_calls = re.findall(
-        r"call void @__quantum__qis__cnot__body\("
-        r"%Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\), "
+    assert "; Permutation: a[0] -> b[0], b[0] -> a[0]" in qir
+    # Qubits: a[0]=0, a[1]=1, b[0]=2, b[1]=3. After the swap, H(a[0])
+    # targets b[0]'s qubit (2) and CX(a[0], a[1]) -> cnot(2, 1).
+    assert _q("h", qir) == [2], qir
+    cnot = re.findall(
+        r"call void @__quantum__qis__cnot__body\(%Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\), "
         r"%Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\)\)",
         qir,
     )
+    assert cnot == [("2", "1")], qir
 
-    print(f"H calls found: {h_calls}")
-    print(f"CNOT calls found: {cnot_calls}")
-
-    # We should have at least one H call and one CNOT call
-    assert len(h_calls) >= 1, "No H gate call found"
-    assert len(cnot_calls) >= 1, "No CNOT gate call found"
-
-    # Get the qubit indices
-    h_qubit = int(h_calls[0])
-    cnot_control, _cnot_target = map(int, cnot_calls[0])
-
-    # Verify that the H and CNOT operations are applied to the correct qubits after permutation
-    # The exact indices will depend on how qubits are allocated in the QIR generator
-    # We can't assert the exact indices without knowing the allocation strategy
-    # But we can verify that the CNOT control qubit is the same as the H qubit
-    assert h_qubit == cnot_control, f"H applied to qubit {h_qubit}, but CNOT control is qubit {cnot_control}"
-
-    # Verify that running QIR generation twice produces consistent results
-    qir2 = SlrConverter(prog).qir()
-    assert qir == qir2, "QIR generation is not deterministic"
+    assert qir == SlrConverter(prog).qir(), "QIR generation is not deterministic"
 
 
 @pytest.mark.optional_dependency
 def test_permutation_with_bell_circuit_qir() -> None:
-    """Test permutation functionality with a Bell circuit in QIR generation."""
-    # Create a program with permutations and a Bell circuit
+    """Element-wise QReg + CReg Permute is realized in a Bell circuit."""
     a = QReg("a", 2)
     b = QReg("b", 2)
     m = CReg("m", 2)
@@ -120,77 +109,40 @@ def test_permutation_with_bell_circuit_qir() -> None:
         b,
         m,
         n,
-        # Permute quantum registers
-        Permute(
-            [a[0], b[1]],
-            [b[1], a[0]],
-        ),
-        # Permute classical registers
-        Permute(
-            [m[0], n[0]],
-            [n[0], m[0]],
-        ),
-        # Apply H gate to a[0] - should be applied to b[1] after permutation
+        Permute([a[0], b[1]], [b[1], a[0]]),
+        Permute([m[0], n[0]], [n[0], m[0]]),
         qubit.H(a[0]),
-        # Apply CX gate from a[0] to a[1] - should be from b[1] to a[1] after permutation
         qubit.CX(a[0], a[1]),
-        # Measure individual qubits to individual bits
         qubit.Measure(a[0]) > m[0],
         qubit.Measure(a[1]) > m[1],
     )
 
-    # Generate QIR
     qir = SlrConverter(prog).qir()
 
-    # Print the QIR for analysis
-    print("\nQIR Output for bell_circuit_qir:")
-    print(qir)
-
-    # Verify that the QIR contains comments about the permutations
-    assert "Permutation: a[0] -> b[1], b[1] -> a[0]" in qir
-    assert "Permutation: m[0] -> n[0], n[0] -> m[0]" in qir
-
-    # Extract the quantum operations
-    h_calls = re.findall(
-        r"call void @__quantum__qis__h__body\(%Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\)\)",
-        qir,
-    )
-    cx_calls = re.findall(
-        r"call void @__quantum__qis__cnot__body\("
-        r"%Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\), "
-        r"%Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\)\)",
-        qir,
-    )
-
-    print(f"H calls found: {h_calls}")
-    print(f"CX calls found: {cx_calls}")
-
-    # We should have at least one H call and one CX call
-    assert len(h_calls) >= 1, "No H gate call found"
-    assert len(cx_calls) >= 1, "No CX gate call found"
-
-    # #76-B2: the M-B2-static classical model removed the bespoke
-    # `@mz_to_creg_bit` and the legacy 1-arg `%Result*`-returning
-    # `mz__body`; measurement now lowers to the standard 2-arg
-    # `call void @__quantum__qis__mz__body(%Qubit*, %Result*)` +
-    # `@__quantum__rt__read_result` + store. Pin the current form.
-    mz_calls = re.findall(
-        r"call void @__quantum__qis__mz__body\("
-        r"%Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\), "
-        r"%Result\* inttoptr \(i64 \d+ to %Result\*\)\)",
+    assert "; Permutation: a[0] -> b[1], b[1] -> a[0]" in qir
+    assert "; Permutation: m[0] -> n[0], n[0] -> m[0]" in qir
+    # Qubits: a[0]=0, a[1]=1, b[0]=2, b[1]=3. a[0] now -> b[1] (q3):
+    # H(a[0]) -> q3, CX(a[0], a[1]) -> cnot(3, 1).
+    assert _q("h", qir) == [3], qir
+    # Standard 2-arg measurement (the #76-B2-removed @mz_to_creg_bit is
+    # gone): Measure(a[0]) reads q3, Measure(a[1]) reads q1.
+    mz = re.findall(
+        r"call void @__quantum__qis__mz__body\(%Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\), %Result\*",
         qir,
     )
+    assert mz == ["3", "1"], qir
 
-    print(f"MZ calls found: {mz_calls}")
-
-    # We should have at least two measurement calls (one for each qubit)
-    assert len(mz_calls) >= 2, f"Expected at least 2 measurement calls, found {len(mz_calls)}"
+    assert qir == SlrConverter(prog).qir(), "QIR generation is not deterministic"
 
 
 @pytest.mark.optional_dependency
 def test_comprehensive_qir_verification() -> None:
-    """Test comprehensive verification of QIR generation with permutations."""
-    # Create a program with a variety of operations to test permutation effects
+    """Two element-wise QReg Permutes are realized across many gates.
+
+    Previously this silently passed on a miscompile (the
+    `; Permutation` comment was emitted but the qubit remap was a
+    no-op). With #87a the relabel is real; pin the corrected targeting.
+    """
     a = QReg("a", 2)
     b = QReg("b", 2)
     c = QReg("c", 2)
@@ -203,249 +155,106 @@ def test_comprehensive_qir_verification() -> None:
         c,
         m,
         n,
-        # Apply some initial gates to track qubit allocation
-        qubit.H(a[0]),  # Track as "original a[0]"
-        qubit.X(a[1]),  # Track as "original a[1]"
-        qubit.Y(b[0]),  # Track as "original b[0]"
-        qubit.Z(b[1]),  # Track as "original b[1]"
-        # First permutation: swap a[0] and b[0]
-        Permute(
-            [a[0], b[0]],
-            [b[0], a[0]],
-        ),
-        # Apply gates after first permutation
-        qubit.H(a[0]),  # Should apply to "original b[0]"
-        qubit.X(b[0]),  # Should apply to "original a[0]"
-        # Second permutation: swap a[1] and b[1]
-        Permute(
-            [a[1], b[1]],
-            [b[1], a[1]],
-        ),
-        # Apply gates after second permutation
-        qubit.Y(a[1]),  # Should apply to "original b[1]"
-        qubit.Z(b[1]),  # Should apply to "original a[1]"
-        # Apply some two-qubit gates to test cross-register operations
-        qubit.CX(a[0], b[1]),  # Should be CX from "original b[0]" to "original a[1]"
-        # Measure qubits to classical bits
-        qubit.Measure(a[0]) > m[0],  # Should measure "original b[0]" to m[0]
-        qubit.Measure(b[1]) > n[0],  # Should measure "original a[1]" to n[0]
+        qubit.H(a[0]),  # q0
+        qubit.X(a[1]),  # q1
+        qubit.Y(b[0]),  # q2
+        qubit.Z(b[1]),  # q3
+        Permute([a[0], b[0]], [b[0], a[0]]),
+        qubit.H(a[0]),  # -> b[0] = q2
+        qubit.X(b[0]),  # -> a[0] = q0
+        Permute([a[1], b[1]], [b[1], a[1]]),
+        qubit.Y(a[1]),  # -> b[1] = q3
+        qubit.Z(b[1]),  # -> a[1] = q1
+        qubit.CX(a[0], b[1]),  # a[0]->b[0]=q2, b[1]->a[1]=q1
+        qubit.Measure(a[0]) > m[0],  # a[0]->b[0]=q2
+        qubit.Measure(b[1]) > n[0],  # b[1]->a[1]=q1
     )
 
-    # Generate QIR
     qir = SlrConverter(prog).qir()
 
-    # Print the QIR for analysis
-    print("\nQIR Output for comprehensive_qir_verification:")
-    print(qir)
-
-    # Extract all gate operations to track qubit allocation
-    h_calls = re.findall(
-        r"call void @__quantum__qis__h__body\(%Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\)\)",
-        qir,
-    )
-    x_calls = re.findall(
-        r"call void @__quantum__qis__x__body\(%Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\)\)",
-        qir,
-    )
-    y_calls = re.findall(
-        r"call void @__quantum__qis__y__body\(%Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\)\)",
-        qir,
-    )
-    z_calls = re.findall(
-        r"call void @__quantum__qis__z__body\(%Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\)\)",
-        qir,
-    )
-    cx_calls = re.findall(
-        r"call void @__quantum__qis__cnot__body\("
-        r"%Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\), "
+    assert "; Permutation: a[0] -> b[0], b[0] -> a[0]" in qir
+    assert "; Permutation: a[1] -> b[1], b[1] -> a[1]" in qir
+    assert _q("h", qir) == [0, 2], qir  # initial a[0]=0, then ->b[0]=2
+    assert _q("x", qir) == [1, 0], qir  # initial a[1]=1, then ->a[0]=0
+    assert _q("y", qir) == [2, 3], qir  # initial b[0]=2, then ->b[1]=3
+    assert _q("z", qir) == [3, 1], qir  # initial b[1]=3, then ->a[1]=1
+    cnot = re.findall(
+        r"call void @__quantum__qis__cnot__body\(%Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\), "
         r"%Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\)\)",
         qir,
     )
-    mz_to_creg_calls = re.findall(
-        r"call void @mz_to_creg_bit\(%Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\), i1\* %(\w+), i64 (\d+)\)",
+    assert cnot == [("2", "1")], qir
+    mz = re.findall(
+        r"call void @__quantum__qis__mz__body\(%Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\), %Result\*",
         qir,
     )
+    assert mz == ["2", "1"], qir
 
-    print(f"H calls: {h_calls}")
-    print(f"X calls: {x_calls}")
-    print(f"Y calls: {y_calls}")
-    print(f"Z calls: {z_calls}")
-    print(f"CX calls: {cx_calls}")
-    print(f"MZ to creg calls: {mz_to_creg_calls}")
-
-    # Based on the initial gates, we can infer the qubit allocation:
-    # The first H call should be for "original a[0]"
-    # The first X call should be for "original a[1]"
-    # The first Y call should be for "original b[0]"
-    # The first Z call should be for "original b[1]"
-    if len(h_calls) >= 1 and len(x_calls) >= 1 and len(y_calls) >= 1 and len(z_calls) >= 1:
-        original_a0 = int(h_calls[0])
-        original_a1 = int(x_calls[0])
-        original_b0 = int(y_calls[0])
-        original_b1 = int(z_calls[0])
-
-        print("Inferred qubit allocation:")
-        print(f"  original a[0] -> physical qubit {original_a0}")
-        print(f"  original a[1] -> physical qubit {original_a1}")
-        print(f"  original b[0] -> physical qubit {original_b0}")
-        print(f"  original b[1] -> physical qubit {original_b1}")
-
-        # Now we can verify that the gates after permutations are applied to the correct qubits
-        # The second H call should be for "original b[0]"
-        # The second X call should be for "original a[0]"
-        if len(h_calls) >= 2 and len(x_calls) >= 2:
-            assert int(h_calls[1]) == original_b0, (
-                f"Second H gate should be applied to original b[0] "
-                f"(physical qubit {original_b0}), but was applied to physical qubit {h_calls[1]}"
-            )
-            assert int(x_calls[1]) == original_a0, (
-                f"Second X gate should be applied to original a[0] "
-                f"(physical qubit {original_a0}), but was applied to physical qubit {x_calls[1]}"
-            )
-
-        # The second Y call should be for "original b[1]"
-        # The second Z call should be for "original a[1]"
-        if len(y_calls) >= 2 and len(z_calls) >= 2:
-            assert int(y_calls[1]) == original_b1, (
-                f"Second Y gate should be applied to original b[1] "
-                f"(physical qubit {original_b1}), but was applied to physical qubit {y_calls[1]}"
-            )
-            assert int(z_calls[1]) == original_a1, (
-                f"Second Z gate should be applied to original a[1] "
-                f"(physical qubit {original_a1}), but was applied to physical qubit {z_calls[1]}"
-            )
-
-        # The CX gate should be from "original b[0]" to "original a[1]"
-        if len(cx_calls) >= 1:
-            cx_control, cx_target = map(int, cx_calls[0])
-            assert (
-                cx_control == original_b0
-            ), f"CX control should be original b[0] (physical qubit {original_b0}), but was physical qubit {cx_control}"
-            assert (
-                cx_target == original_a1
-            ), f"CX target should be original a[1] (physical qubit {original_a1}), but was physical qubit {cx_target}"
-
-        # The measurements should be from "original b[0]" to m[0] and from "original a[1]" to n[0]
-        if len(mz_to_creg_calls) >= 2:
-            mz1_qubit, mz1_reg, mz1_idx = mz_to_creg_calls[0]
-            mz2_qubit, mz2_reg, mz2_idx = mz_to_creg_calls[1]
-
-            # Check if either measurement matches our expectations
-            b0_to_m0 = (int(mz1_qubit) == original_b0 and mz1_reg == "m" and int(mz1_idx) == 0) or (
-                int(mz2_qubit) == original_b0 and mz2_reg == "m" and int(mz2_idx) == 0
-            )
-            a1_to_n0 = (int(mz1_qubit) == original_a1 and mz1_reg == "n" and int(mz1_idx) == 0) or (
-                int(mz2_qubit) == original_a1 and mz2_reg == "n" and int(mz2_idx) == 0
-            )
-
-            assert b0_to_m0, (
-                f"Expected measurement from original b[0] (physical qubit {original_b0}) to m[0], "
-                f"but found measurements: {mz_to_creg_calls}"
-            )
-            assert a1_to_n0, (
-                f"Expected measurement from original a[1] (physical qubit {original_a1}) to n[0], "
-                f"but found measurements: {mz_to_creg_calls}"
-            )
+    assert qir == SlrConverter(prog).qir(), "QIR generation is not deterministic"
 
 
 @pytest.mark.optional_dependency
 def test_rotation_gates_with_permutation() -> None:
-    """Test that permutations work correctly with rotation gates in QIR generation."""
-    # Create a program with rotation gates and permutations
+    """Element-wise QReg Permute is realized across rotation gates."""
     a = QReg("a", 2)
     b = QReg("b", 2)
 
     prog = Main(
         a,
         b,
-        # Apply initial gates to track qubit allocation
-        qubit.RX[0.1](a[0]),  # Track as "original a[0]"
-        qubit.RY[0.2](a[1]),  # Track as "original a[1]"
-        qubit.RZ[0.3](b[0]),  # Track as "original b[0]"
-        qubit.SZ(b[1]),  # Track as "original b[1]"
-        # Apply permutation
-        Permute(
-            [a[0], b[0]],
-            [b[0], a[0]],
-        ),
-        # Apply gates after permutation
-        qubit.RX[0.4](a[0]),  # Should apply to "original b[0]"
-        qubit.RY[0.5](b[0]),  # Should apply to "original a[0]"
-        qubit.T(a[1]),  # Should apply to "original a[1]"
-        qubit.Tdg(b[1]),  # Should apply to "original b[1]"
+        qubit.RX[0.1](a[0]),  # q0
+        qubit.RY[0.2](a[1]),  # q1
+        qubit.RZ[0.3](b[0]),  # q2
+        qubit.SZ(b[1]),  # q3
+        Permute([a[0], b[0]], [b[0], a[0]]),
+        qubit.RX[0.4](a[0]),  # -> b[0] = q2
+        qubit.RY[0.5](b[0]),  # -> a[0] = q0
+        qubit.T(a[1]),  # unpermuted = q1
+        qubit.Tdg(b[1]),  # unpermuted = q3
     )
 
-    # Generate QIR
     qir = SlrConverter(prog).qir()
 
-    # Print the QIR for analysis
-    print("\nQIR Output for rotation_gates_with_permutation:")
-    print(qir)
+    assert "; Permutation: a[0] -> b[0], b[0] -> a[0]" in qir
+    rx = re.findall(r"call void @__quantum__qis__rx__body\(double [^,]+, %Qubit\* inttoptr \(i64 (\d+) ", qir)
+    ry = re.findall(r"call void @__quantum__qis__ry__body\(double [^,]+, %Qubit\* inttoptr \(i64 (\d+) ", qir)
+    assert rx == ["0", "2"], qir  # initial a[0]=0, then ->b[0]=2
+    assert ry == ["1", "0"], qir  # initial a[1]=1, then ->a[0]=0
+    assert _q("t", qir) == [1], qir  # T(a[1]) unpermuted
+    tdg = re.findall(r"call void @__quantum__qis__t__adj\(%Qubit\* inttoptr \(i64 (\d+) ", qir)
+    assert tdg == ["3"], qir  # Tdg(b[1]) unpermuted
 
-    # Extract all gate operations to track qubit allocation
-    rx_calls = re.findall(
-        r"call void @__quantum__qis__rx__body\(double (0x[0-9a-f]+), %Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\)\)",
-        qir,
-    )
-    ry_calls = re.findall(
-        r"call void @__quantum__qis__ry__body\(double (0x[0-9a-f]+), %Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\)\)",
-        qir,
-    )
-    rz_calls = re.findall(
-        r"call void @__quantum__qis__rz__body\(double (0x[0-9a-f]+), %Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\)\)",
-        qir,
-    )
-    s_calls = re.findall(
-        r"call void @__quantum__qis__s__body\(%Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\)\)",
-        qir,
-    )
-    t_calls = re.findall(
-        r"call void @__quantum__qis__t__body\(%Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\)\)",
-        qir,
-    )
-    tdg_calls = re.findall(
-        r"call void @__quantum__qis__t__adj\(%Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\)\)",
-        qir,
+    assert qir == SlrConverter(prog).qir(), "QIR generation is not deterministic"
+
+
+@pytest.mark.optional_dependency
+def test_whole_register_qreg_permutation_realized_qir() -> None:
+    """Whole-register *qubit*-register Permute IS realized in QIR.
+
+    `Permute(a, b)` on two same-size QRegs relabels every (a, i) <->
+    (b, i) so subsequent `a[i]`/`b[i]` references resolve to the
+    swapped qubits, and emits the legacy-format `; Permutation: a <->
+    b` comment. Protects the realizable path against regression.
+    """
+    a = QReg("a", 2)
+    b = QReg("b", 2)
+
+    prog = Main(
+        a,
+        b,
+        qubit.H(a[0]),  # original a[0] = q0
+        qubit.X(b[0]),  # original b[0] = q2
+        Permute(a, b),  # whole-register qubit swap
+        qubit.Y(a[0]),  # after swap -> original b[0] = q2
+        qubit.Z(b[0]),  # after swap -> original a[0] = q0
     )
 
-    print(f"Rx calls: {rx_calls}")
-    print(f"Ry calls: {ry_calls}")
-    print(f"Rz calls: {rz_calls}")
-    print(f"S calls: {s_calls}")
-    print(f"T calls: {t_calls}")
-    print(f"Tdg calls: {tdg_calls}")
-
-    # Based on the initial gates, we can infer the qubit allocation:
-    if len(rx_calls) >= 1 and len(ry_calls) >= 1 and len(rz_calls) >= 1 and len(s_calls) >= 1:
-        # Extract the qubit indices from the first calls
-        original_a0 = int(rx_calls[0][1])
-        original_a1 = int(ry_calls[0][1])
-        original_b0 = int(rz_calls[0][1])
-        original_b1 = int(s_calls[0])
-
-        print("Inferred qubit allocation:")
-        print(f"  original a[0] -> physical qubit {original_a0}")
-        print(f"  original a[1] -> physical qubit {original_a1}")
-        print(f"  original b[0] -> physical qubit {original_b0}")
-        print(f"  original b[1] -> physical qubit {original_b1}")
-
-        # Now we can verify that the gates after permutations are applied to the correct qubits
-        if len(rx_calls) >= 2 and len(ry_calls) >= 2:
-            assert int(rx_calls[1][1]) == original_b0, (
-                f"Second Rx gate should be applied to original b[0] "
-                f"(physical qubit {original_b0}), but was applied to physical qubit {rx_calls[1][1]}"
-            )
-            assert int(ry_calls[1][1]) == original_a0, (
-                f"Second Ry gate should be applied to original a[0] "
-                f"(physical qubit {original_a0}), but was applied to physical qubit {ry_calls[1][1]}"
-            )
-
-        if len(t_calls) >= 1 and len(tdg_calls) >= 1:
-            assert int(t_calls[0]) == original_a1, (
-                f"T gate should be applied to original a[1] "
-                f"(physical qubit {original_a1}), but was applied to physical qubit {t_calls[0]}"
-            )
-            assert int(tdg_calls[0]) == original_b1, (
-                f"Tdg gate should be applied to original b[1] "
-                f"(physical qubit {original_b1}), but was applied to physical qubit {tdg_calls[0]}"
-            )
+    qir = SlrConverter(prog).qir()
+
+    assert "; Permutation: a <-> b" in qir, f"Expected whole-register permutation comment in QIR:\n{qir}"
+    assert _q("h", qir) == [0], qir
+    assert _q("x", qir) == [2], qir
+    assert _q("y", qir) == [2], qir  # Y(a[0]) after swap -> q2
+    assert _q("z", qir) == [0], qir  # Z(b[0]) after swap -> q0
+
+    assert qir == SlrConverter(prog).qir(), "QIR generation is not deterministic"
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_register_permutation.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_register_permutation.py
index def6d8c0b..61faaaf13 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_register_permutation.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_register_permutation.py
@@ -116,76 +116,49 @@ def test_mixed_permutation_qasm() -> None:
 # QIR Tests
 
 
+# #87a: a Permute is realized as a static logical relabel consulted at
+# every qubit/classical-bit lowering (the bespoke
+# @set_creg_bit/@get_creg_bit/creg-xor helpers the old tests pinned
+# were removed by #76-B2; classical writes are `store i1` into the
+# relabelled register's `[N x i1]` buffer). Works for whole-register
+# (QReg + CReg) and element-wise; pinned from the actual emitted QIR.
+
+
 @pytest.mark.optional_dependency
 def test_whole_register_permutation_qir() -> None:
-    """Test permutation of whole registers in QIR generation."""
+    """Whole-register CReg Permute is realized (a <-> b)."""
     prog = create_whole_register_permutation_program()
     qir = SlrConverter(prog).qir()
 
-    # Verify the permutation comment is present
-    assert "; Permutation: a <-> b" in qir, f"Expected permutation comment not found in QIR:\n{qir}"
-
-    # Verify the XOR operations are present
-    assert "xor" in qir, f"Expected XOR operations not found in QIR:\n{qir}"
-
-    # Verify the temporary bit approach is NOT used for whole register permutations
-    assert (
-        "_bit_swap = call i1* @create_creg(i64 1)" not in qir
-    ), f"Unexpected '_bit_swap = call i1* @create_creg(i64 1)' found in QIR:\n{qir}"
-    assert "call i1 @get_creg_bit" not in qir, f"Unexpected 'call i1 @get_creg_bit' found in QIR:\n{qir}"
-
-    # Verify the set operations are present
-    set_pattern = r"call void @set_creg_bit\(i1\* %(\w+), i64 (\d+), i1 (\d+)\)"
-    set_calls = re.findall(set_pattern, qir)
+    assert "; Permutation: a <-> b" in qir, qir
+    # create_whole_register_permutation_program: CReg a,b(5);
+    # Permute(a, b); b[2].set(1); a[3].set(0). After the swap, b[2]
+    # resolves to a[2] and a[3] resolves to b[3].
+    assert re.search(
+        r"%(\.\d+) = getelementptr \[5 x i1\], \[5 x i1\]\* %a, i64 0, i64 2\n\s*store i1 1, i1\* %\1",
+        qir,
+    ), f"b[2].set(1) should target a[2] after swap:\n{qir}"
+    assert re.search(
+        r"%(\.\d+) = getelementptr \[5 x i1\], \[5 x i1\]\* %b, i64 0, i64 3\n\s*store i1 0, i1\* %\1",
+        qir,
+    ), f"a[3].set(0) should target b[3] after swap:\n{qir}"
 
-    # Verify the operations after the permutation
-    # Since we're swapping values, not references, the operations should still refer to the original registers
-    b2_set = False
-    a3_set = False
-    for reg, idx, val in set_calls:
-        if reg == "b" and idx == "2" and val == "1":
-            b2_set = True
-        if reg == "a" and idx == "3" and val == "0":
-            a3_set = True
-
-    assert b2_set, f"Expected set_creg_bit(b, 2, 1) not found in QIR:\n{qir}"
-    assert a3_set, f"Expected set_creg_bit(a, 3, 0) not found in QIR:\n{qir}"
+    assert qir == SlrConverter(prog).qir(), "QIR generation is not deterministic"
 
 
 @pytest.mark.optional_dependency
 def test_mixed_permutation_qir() -> None:
-    """Test mixed whole register and element permutations in QIR generation."""
+    """Element-wise then whole-register QReg Permute compose correctly."""
     prog = create_mixed_permutation_program()
     qir = SlrConverter(prog).qir()
 
-    # Print the QIR for debugging
-    print("\nQIR output:")
-    print(qir)
-
-    # Verify the permutation comments are present
-    assert "; Permutation: a[0] -> c[1], c[1] -> a[0]" in qir, f"Expected permutation comment not found in QIR:\n{qir}"
-    assert "; Permutation: a <-> b" in qir, f"Expected permutation comment not found in QIR:\n{qir}"
-
-    # Verify that the QIR contains the correct quantum operations after permutations
-    # H gate should be applied to c[1] (after both permutations)
-    # The exact qubit index depends on how QIR allocates qubits, but we can check for the pattern
-    h_gate_pattern = r"call void @__quantum__qis__h__body\(%Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\)\)"
-    h_gates = re.findall(h_gate_pattern, qir)
-    assert len(h_gates) >= 1, f"Expected at least one H gate, found {len(h_gates)}"
-
-    # X gate should be applied to a[1] (after the whole register permutation)
-    x_gate_pattern = r"call void @__quantum__qis__x__body\(%Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\)\)"
-    x_gates = re.findall(x_gate_pattern, qir)
-    assert len(x_gates) >= 1, f"Expected at least one X gate, found {len(x_gates)}"
-
-    # Z gate should be applied to c[2] (which is not permuted)
-    z_gate_pattern = r"call void @__quantum__qis__z__body\(%Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\)\)"
-    z_gates = re.findall(z_gate_pattern, qir)
-    assert len(z_gates) >= 1, f"Expected at least one Z gate, found {len(z_gates)}"
-
-    # Verify that the qubit indices for the gates are different
-    # This ensures that the permutations are being applied correctly
-    all_gates = h_gates + x_gates + z_gates
-    assert len(set(all_gates)) == len(
-        all_gates,
-    ), f"Expected all gates to be applied to different qubits, found duplicates: {all_gates}"
+    assert "; Permutation: a[0] -> c[1], c[1] -> a[0]" in qir, qir
+    assert "; Permutation: a <-> b" in qir, qir
+    # QRegs a=0-2, b=3-5, c=6-8. First Permute([a[0],c[1]],[c[1],a[0]])
+    # then whole Permute(a, b). Realized: H(a[0])->q3, X(b[1])->q1,
+    # Z(c[2])->q8.
+    assert re.findall(r"call void @__quantum__qis__h__body\(%Qubit\* inttoptr \(i64 (\d+) ", qir) == ["3"], qir
+    assert re.findall(r"call void @__quantum__qis__x__body\(%Qubit\* inttoptr \(i64 (\d+) ", qir) == ["1"], qir
+    assert re.findall(r"call void @__quantum__qis__z__body\(%Qubit\* inttoptr \(i64 (\d+) ", qir) == ["8"], qir
+
+    assert qir == SlrConverter(prog).qir(), "QIR generation is not deterministic"

From 42610a9f68462c7d5aaba259c8d5901d6f234c2c Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Mon, 18 May 2026 20:57:21 -0600
Subject: [PATCH 100/136] #88: broad unsupported-gate fail-loud (88A, the class
 #78 deferred) + Guppy unpack xfail (88B)

#88A: qir._process_gate `if qir_name is None: return` was a silent
#74-class drop (18 gates absent from GATE_TO_QIR:
CH/CRX/CRY/CRZ/CY/F/F4/F4dg/Fdg/SX/SXX/SXXdg/SXdg/SY/SYY/SYYdg/SYdg/
SZZdg) -> valid QIR, wrong semantics, qir-qis-uncatchable. Now raises
NotImplementedError. The "broad reliance" #78 feared did NOT
materialise -- blast radius is tiny: test_sx_sxdg -> raises (SX/SXdg
never had a QIR lowering; legacy gen_qir didn't either) + an honest
#71 re-pin (qeclib.generic_check_xyz / generic_check_1flag_ch use the
"XYZ" Check whose Y branch emits CY (no QIR lowering); they were
dishonestly QIS_OK on the silent drop -> moved _EXPECTED_QIS_OK 24->22
into _EXPECTED_BUILD_FAILED "has no QIR lowering"; docstring "(7)" /
n=22, re-pinned from the actual _qir_state(), never guessed).

#88B: test_unique_unpacked_names investigated -> real Guppy-emitter
bug, NOT shallow: slot-local naming f"{allocator}_{index}"
(guppy.py _local_name + guppy_linearity binding init + entry-unpack
LHS -- 3 sites that must agree) collides when an unpack name (`q_0`)
equals another declared register's name; `q_0,q_1 = q` rebinds the
`q_0` param, then `q_0_0, = q_0` raises UnpackableError. A correct fix
needs a single namespace-wide uniquification authority feeding all 3
sites (linearity state has no register/block-decl names) with
corpus-wide local-name churn -- cross-cutting, out of #87/#88 pre-PR
scope. Per the investigate->fix-if-shallow-else-xfail rule:
@pytest.mark.xfail(strict=True) with full findings, tracked.

Verified: default lane 403/0; optional_dependency lane 42 passed /
3 xfailed / 0 failed; behavioral prep all-6 24/0; ruff/black-25.9.0
clean.
---
 .../src/pecos/slr/ast/codegen/qir.py          | 20 +++++++++++---
 .../ast_guppy/test_qir_spec_compliance.py     | 27 ++++++++++++++-----
 .../slr_tests/guppy/test_array_patterns.py    | 14 ++++++++++
 .../regression/random_cases/test_slr_phys.py  | 14 +++++++---
 4 files changed, 62 insertions(+), 13 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
index 82ab4bc2a..7c48d7b25 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
@@ -457,8 +457,21 @@ def _process_gate(self, node: GateOp) -> None:
         """Process a gate operation."""
         qir_name = GATE_TO_QIR.get(node.gate)
         if qir_name is None:
-            # Skip unsupported gates
-            return
+            # #88A (the broad class #78 deferred): a gate with no
+            # GATE_TO_QIR entry was SILENTLY DROPPED -- valid QIR,
+            # wrong semantics, qir-qis-uncatchable (#74-class). Fail
+            # loud instead of miscompiling. Gates with a real QIR
+            # lowering should be added to GATE_TO_QIR (a feature);
+            # until then a program using one must not be silently
+            # mis-emitted.
+            gate_name = getattr(node.gate, "name", node.gate)
+            msg = (
+                f"QIR codegen: gate {gate_name!r} has no QIR lowering "
+                "(not in GATE_TO_QIR). Emitting QIR without it would be "
+                "a silent miscompile; it is not supported by the QIR "
+                "backend."
+            )
+            raise NotImplementedError(msg)
 
         if node.gate in TWO_QUBIT_GATES:
             self._process_two_qubit_gate(node, qir_name)
@@ -904,8 +917,7 @@ def _process_permute(self, node: PermuteOp) -> None:
             if len(src_refs) != len(tgt_refs):
                 msg = f"QIR codegen: Permute element count mismatch for {source!r} -> {target!r}"
                 raise NotImplementedError(msg)
-            for s_ref, t_ref in zip(src_refs, tgt_refs, strict=True):
-                mapping[s_ref] = t_ref
+            mapping.update(zip(src_refs, tgt_refs, strict=True))
 
         if set(mapping) != set(mapping.values()):
             msg = "QIR codegen: Permute must be bijective over the same ref set"
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
index a858fa732..a431b5dbd 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
@@ -39,7 +39,7 @@
 `mz__body` -> static `%Result*` -> `read_result` -> `store`;
 point-of-use `gep`+`load`/`store`; `zext`/`shl`/`or` pack ->
 `__quantum__rt__int_record_output`). Every validate-passing program
-(`_EXPECTED_QIS_OK`, n=24) now lowers via `qir_to_qis`; `qis_failed`
+(`_EXPECTED_QIS_OK`, n=22) now lowers via `qir_to_qis`; `qis_failed`
 is empty. A NEW qir_to_qis failure -- or a dropped program -- trips
 this deliberately. (`docs.while_loop` was in this set pre-#74 on a
 silently-wrong single-pass approximation; #74 makes the QIR backend
@@ -56,7 +56,7 @@
 #79 generalises it corpus-wide; this structural gate provides
 that suite's authoritative QIS_OK set.
 
-**Build failures** (5): `qir_bc()` raises for
+**Build failures** (7): `qir_bc()` raises for
 `docs.for_loopvar_symbolic` (symbolic `LoopVar` indexing) /
 `docs.rotation_rx` (`rx` gate) -- pre-existing AST-QIR feature
 gaps; `docs.while_loop` (#74: the QIR backend now fails LOUD
@@ -83,7 +83,12 @@
 #74 also fails loud on `VarExpr` (was silently 0) and `Print`
 (was silently dropped); no corpus program exercises those, so
 they add no build-failure pin -- but they are no longer silent
-miscompiles.
+miscompiles. #88A (the broad unsupported-gate class #78
+deferred) makes `_process_gate` fail loud on any gate with no
+`GATE_TO_QIR` entry (was a silent drop). The two generic-check
+factories use the "XYZ" Check whose Y branch emits `CY` (no
+QIR lowering); they moved QIS_OK -> here (24 -> 22), re-pinned
+from the actual `_qir_state()`.
 
 `qir-qis` is a `[dependency-groups].test` dep (default-groups
 includes `test`), so this runs in the default sweep.
@@ -126,6 +131,16 @@
     #    from the actual `_qir_state()`, never guessed).
     "docs.inline_measure_creg": ("NotImplementedError", "was not declared at Main scope"),
     "docs.surface_syndrome_block18": ("NotImplementedError", "was not declared at Main scope"),
+    # #88A: the broad unsupported-gate-silent-drop class #78 deferred.
+    # A gate with no GATE_TO_QIR entry was SILENTLY DROPPED (#74-class
+    # silent miscompile -- valid QIR, wrong semantics, qir-qis-
+    # uncatchable). `_process_gate` now fails LOUD. Both generic-check
+    # factories use the "XYZ" Pauli-basis Check, whose Y branch emits
+    # `CY` (controlled-Y, no QIR lowering); they were dishonestly
+    # QIS_OK on the silent-drop miscompile and are re-pinned here from
+    # the ACTUAL `_qir_state()` (never guessed), QIS_OK 24 -> 22.
+    "qeclib.generic_check_xyz": ("NotImplementedError", "has no QIR lowering"),
+    "qeclib.generic_check_1flag_ch": ("NotImplementedError", "has no QIR lowering"),
 }
 
 # Tier 1: the non-metadata `validate_qir` failures (label -> stable,
@@ -146,7 +161,7 @@
 
 # Tier 2: post-B2, EVERY validate-passing program lowers via
 # `qir_to_qis` (M-B2-static replaced the bespoke CReg helpers).
-# This is the full set (n=24); `qis_failed` must be empty. A new
+# This is the full set (n=22); `qis_failed` must be empty. A new
 # qir_to_qis failure -- or a dropped/added program -- trips the
 # Tier-2 assertions and must be triaged deliberately.
 _EXPECTED_QIS_OK: frozenset[str] = frozenset(
@@ -168,8 +183,8 @@
         "legacy.nested_blocks",
         "legacy.partial_consumption_with_block",
         "qeclib.color488_syn_extract_bare",
-        "qeclib.generic_check_1flag_ch",
-        "qeclib.generic_check_xyz",
+        # #88A: qeclib.generic_check_1flag_ch / generic_check_xyz moved
+        # QIS_OK -> _EXPECTED_BUILD_FAILED (silent `CY` drop now loud).
         "qeclib.generic_transversal_cx",
         "qeclib.surface_patch_builder_empty",
         "qeclib.surface_std_pz",
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_array_patterns.py b/python/quantum-pecos/tests/slr_tests/guppy/test_array_patterns.py
index 237e355fa..5d340a6dd 100644
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_array_patterns.py
+++ b/python/quantum-pecos/tests/slr_tests/guppy/test_array_patterns.py
@@ -20,6 +20,20 @@ class TestArrayUnpacking:
     """Test array unpacking patterns for measurements."""
 
     @pytest.mark.optional_dependency
+    @pytest.mark.xfail(
+        reason="#88B (pre-existing, not #80/#81): the Guppy emitter's slot-local "
+        "naming `f'{allocator}_{index}'` (guppy.py `_local_name` + "
+        "guppy_linearity.py binding init + the entry-unpack LHS -- three "
+        "sites that must agree) collides when an unpack name (`q_0`) equals "
+        "another declared register's name: `q_0, q_1 = q` rebinds the `q_0` "
+        "param, then `q_0_0, = q_0` raises UnpackableError. A correct fix "
+        "needs a single namespace-wide uniquification authority feeding all "
+        "three sites (linearity state has no register/block-decl names) with "
+        "corpus-wide local-name churn -- cross-cutting, out of #87/#88 "
+        "pre-PR scope; tracked.",
+        strict=True,
+        raises=Exception,
+    )
     def test_unique_unpacked_names(self) -> None:
         """Test that unpacked names avoid conflicts."""
         prog = Main(
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py b/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py
index c7e04bc0b..fe2804835 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py
@@ -229,7 +229,15 @@ def test_steane_qir_bc() -> None:
 
 @pytest.mark.optional_dependency
 def test_sx_sxdg() -> None:
-    """Test that a simple Bell prep and measure circuit can be created."""
+    """SX/SXdg have no QIR lowering -> fail loud (M-B2-static).
+
+    #88A: the legacy gen_qir never lowered SX->rx either; SX/SXdg are
+    absent from GATE_TO_QIR. They used to be SILENTLY DROPPED (#74-class
+    silent miscompile -- valid QIR, wrong semantics). #88A makes
+    `_process_gate` fail LOUD on any gate with no QIR lowering instead
+    of mis-emitting. (Adding an SX/SXdg->QIR decomposition would be a
+    feature, not pre-PR hygiene.)
+    """
     prog: Main = Main(
         q := QReg("q", 2),
         m := CReg("m", 2),
@@ -240,8 +248,8 @@ def test_sx_sxdg() -> None:
         Return(m),
     )
 
-    qir = SlrConverter(prog).qir()
-    assert "__quantum__qis__rx__body" in qir
+    with pytest.raises(NotImplementedError, match=r"has no QIR lowering"):
+        SlrConverter(prog).qir()
 
 
 @pytest.mark.optional_dependency

From 26ecfb52a0d3458470a8cbe6156de1268d97b719 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Mon, 18 May 2026 22:09:16 -0600
Subject: [PATCH 101/136] #79: corpus-wide executable QIR validation
 (generalises #77 Layer D)

For every audit-corpus program qir_to_qis accepts (the live #71
_qir_state() QIS_OK set, now 22), EXECUTE the lowered QIS
(qir_bc -> qir_qis.qir_to_qis -> selene_sim.build -> run_shots(Stim)
via the #77-proven _qis_exec_records) and assert the EXECUTED
classical records -- the end-to-end proof of the B2 M-B2-static
lowering + #74/#78/#87(Permute)/#88A fail-loud line at corpus scale.

The oracle (the hard part): a _MANIFEST classifies all 22 QIS_OK
programs D/P/X, each derived from first principles by reading the
circuit and CONFIRMED-not-reverse-fitted by execution. D (3) =
exact record; P (8) = a HARD invariant (correlation / fixed bits /
small exact value set) asserted over a fixed seed set, must hold
AND be exercised -- NEVER a statistical/tolerance compare; X (11) =
no classical record or no sound first-principles invariant,
documented per program.

Folds the #79 dual PLAN pre-review: blocker 3 -> n_qubits from the
QIR required_num_qubits entry attr (not max-operand-ref, which is 0
for no-op QReg programs and panics selene); blocker 1 -> a
record-shape contract (an X-with-record program that executes to NO
record fails = output-loss miscompile, not silent X). Blockers 1+2
root causes were resolved upstream by #80 (inline/Return-only CReg
fails loud) + #81 (correct PX); prep cases re-derived under the
correct #81 semantics -- docs.prep_basis_x is PX=|+>, one uniform
Z-measure bit -> X, NOT the pre-review's deterministic [0] (which
assumed the old broken Prep('X')=Z-reset). One first-principles
guess corrected BY execution (the design-mandated confirm step):
legacy.multiple_qregs is NOT c1==c2-correlated (all 4 combos
occur); sound invariant is bit-1==0 per CReg, correlation NOT
claimed. Drift guard: candidate set taken live from _qir_state()
QIS_OK; class histogram pinned D=3/P=8/X=11 so a reclassification
is deliberate.

Slow + optional_dependency lane. Verified: 23 passed (22
executable + drift guard); default lane 403/0 unaffected
(deselected); ruff/black-25.9.0 clean. Pending dual post-review
(reviews/dual-79-corpus-executable-postreview-prompt.md).
---
 .../ast_guppy/test_qir_corpus_executable.py   | 320 ++++++++++++++++++
 1 file changed, 320 insertions(+)
 create mode 100644 python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py

diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
new file mode 100644
index 000000000..8bd413ac3
--- /dev/null
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
@@ -0,0 +1,320 @@
+# Copyright 2026 The PECOS Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations under the License.
+
+"""#79 corpus-wide EXECUTABLE QIR validation (generalises #77 Layer D).
+
+For every audit-corpus program `qir_to_qis` accepts (the #71
+`_qir_state()` QIS_OK set), actually EXECUTE the lowered QIS
+(`SlrConverter(prog).qir_bc() -> qir_qis.qir_to_qis ->
+selene_sim.build(BitcodeString) -> run_shots(Stim)`, via the
+#77-proven `_qis_exec_records`) and assert the EXECUTED classical
+records -- not merely "qir_to_qis accepts". This is the end-to-end
+proof of the B2 M-B2-static lowering + #74/#78/#87(Permute)/#88A
+fail-loud line, at corpus scale.
+
+THE HARD PART IS THE ORACLE (per the scoped plan + dual
+pre-review `reviews/{codex,pickle}-79-...`). Every QIS_OK program
+is assigned a validation CLASS in `_MANIFEST`, derived from first
+principles (reading the circuit) and CONFIRMED -- never
+reverse-fitted -- by execution:
+
+- **D** Deterministic exact-record: classical output statically
+  determinable; assert the exact per-shot record over a fixed
+  seed. Strongest, oracle-free, non-flaky.
+- **P** Property/hard-invariant: quantum-random with a *hard*
+  invariant (correlation / fixed bits / membership in a small
+  exact value set). Asserted over a FIXED seed set; the invariant
+  must HOLD and be EXERCISED (e.g. both Bell outcomes occur) --
+  NEVER a statistical/tolerance compare (the non-negotiable
+  no-flaky principle).
+- **X** Excluded: no classical record (no `Return`/no Main-scope
+  CReg), or a single unconstrained random bit / fully
+  unconstrained register / no sound first-principles invariant.
+  Documented per program; X with output still gets the
+  record-shape contract (Codex pre-review blocker 1).
+
+Drift safety (Codex pre-review blocker / design item 4): the
+candidate set is taken LIVE from `_qir_state()` QIS_OK, and every
+QIS_OK label MUST be in `_MANIFEST` -- a new/changed corpus
+program forces a classification decision (no silent gap), and the
+executable set cannot drift from the #71 structural gate.
+
+n_qubits derivation (Codex pre-review blocker 3): from the QIR
+`required_num_qubits` entry attribute -- NOT a max-operand-
+reference count (that is 0 for no-op QReg programs and panics
+selene with "No more qubits available to allocate").
+
+Pre-review blockers 1 (inline/Return-only CReg output loss) and 2
+(non-Z `Prep` silently Z-reset) were RESOLVED upstream by #80
+(inline CReg fails loud -> BUILD_FAILED, out of QIS_OK) and #81
+(dedicated `PX`/etc with correct reset+Clifford-tail lowering);
+the prep cases are reclassified here from first principles under
+the CORRECT #81 semantics (`docs.prep_basis_x` is `PX`=|+>, a
+single uniform Z-measure bit -> **X**, NOT the pre-review's
+deterministic `[0]` which assumed the old broken Z-reset).
+
+`@pytest.mark.slow` (one selene build per QIS_OK program; selene
+caches artifacts). The `-m "not slow"` lane excludes it; it runs
+in the full sweep.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Callable
+from typing import TYPE_CHECKING
+
+import pytest
+from pecos.slr import SlrConverter
+
+from .audit_runner import _curated_cases  # noqa: TID252
+from .test_qir_spec_compliance import _qir_state  # noqa: TID252
+
+if TYPE_CHECKING:
+    from pecos.slr import Main
+from .tier2_semantic import _qis_exec_records  # noqa: TID252
+
+# Fixed seed set for P invariants: chosen so a hard invariant must
+# both HOLD and be EXERCISED (e.g. both Bell outcomes appear). NOT a
+# distribution -- membership/equality only.
+_SEEDS = (1, 2, 7, 42)
+_SHOTS = 16
+
+
+def _required_num_qubits(prog: Main) -> int:
+    """n_qubits from the QIR `required_num_qubits` entry attr.
+
+    Codex #79 pre-review blocker 3: a max-operand-reference count
+    is 0 for no-op QReg programs (e.g. surface_patch_builder_empty)
+    and panics selene. The entry attr is the AST root-allocator
+    capacity the backend pins, which is correct for every program.
+    """
+    qir = SlrConverter(prog).qir()
+    m = re.search(r'"required_num_qubits"="(\d+)"', qir)
+    assert m, f"no required_num_qubits entry attr in QIR:\n{qir}"
+    return int(m.group(1))
+
+
+def _observed(prog: Main, n_qubits: int) -> set[tuple[int, ...]]:
+    """Union of executed records across the fixed seed set."""
+    obs: set[tuple[int, ...]] = set()
+    for seed in _SEEDS:
+        for rec in _qis_exec_records(prog, n_qubits, shots=_SHOTS, seed=seed):
+            obs.add(tuple(rec))
+    return obs
+
+
+# ---------------------------------------------------------------------------
+# THE MANIFEST. label -> (class, spec). Each entry derived from first
+# principles (the circuit), confirmed-not-fitted by execution.
+#
+#  D: spec = the exact record tuple, asserted == observed (one value).
+#  P: spec = a Callable[[set[tuple[int,...]]], None] hard-invariant
+#     check over the union of records across the fixed seed set
+#     (must HOLD and be EXERCISED; membership/equality only).
+#  X: spec = a human rationale string. If the program still emits a
+#     classical record, the record-shape contract still applies.
+# ---------------------------------------------------------------------------
+
+
+def _bell2(obs: set[tuple[int, ...]]) -> None:
+    """One 2-bit CReg, H+CX Bell: every shot in {0,3}, both occur."""
+    assert obs <= {(0,), (3,)}, obs
+    assert obs == {(0,), (3,)}, f"Bell correlation not exercised over seeds: {obs}"
+
+
+def _ghz3(obs: set[tuple[int, ...]]) -> None:
+    """One 3-bit CReg, GHZ: every shot in {0,7}, both occur."""
+    assert obs <= {(0,), (7,)}, obs
+    assert obs == {(0,), (7,)}, f"GHZ correlation not exercised over seeds: {obs}"
+
+
+def _two_indep_bell_4(obs: set[tuple[int, ...]]) -> None:
+    """4-bit CReg = two independent Bell pairs (bits 0==1, 2==3)."""
+    allowed = {(0,), (3,), (12,), (15,)}
+    assert obs <= allowed, obs
+    assert obs == allowed, f"both pairs' correlation not fully exercised: {obs}"
+
+
+def _three_indep_bell_6(obs: set[tuple[int, ...]]) -> None:
+    """6-bit CReg = three independent Bell pairs (bits {0,1},{2,3},{4,5})."""
+    allowed = {(v,) for v in (0, 3, 12, 15, 48, 51, 60, 63)}
+    assert obs <= allowed, f"a non-pair-correlated value occurred: {obs - allowed}"
+    # Each pair must be exercised in both states (every bit position
+    # toggles): the union must cover all 6 bits set and all clear.
+    or_all = 0
+    and_all = 63
+    for (v,) in obs:
+        or_all |= v
+        and_all &= v
+    assert or_all == 63, f"some pair never reached |11>: OR={or_all:06b} {obs}"
+    assert and_all == 0, f"some pair never reached |00>: AND={and_all:06b} {obs}"
+
+
+def _multiple_qregs(obs: set[tuple[int, ...]]) -> None:
+    """Two declared 2-bit CRegs (c1, c2), two records per shot.
+
+    First-principles HARD invariant: each CReg's high bit (bit 1)
+    is provably 0 -- only qubit 0 of each QReg is measured into bit
+    0, bit 1 is never written (zeroinitializer). So each record is
+    in {0,1}. Execution CONFIRMED c1 and c2 are NOT correlated (all
+    of (0,0)/(0,1)/(1,0)/(1,1) occur -- the pre-review's `c1==c2`
+    first-principles guess was disproven by running it); we assert
+    ONLY the sound bit-1==0 invariant, NOT a cross-register
+    correlation, and require both bits exercised.
+    """
+    assert all(r0 <= 1 and r1 <= 1 for r0, r1 in obs), f"a CReg high bit was set: {obs}"
+    assert {r0 for r0, _ in obs} == {0, 1}, f"c1 bit0 not exercised: {obs}"
+    assert {r1 for _, r1 in obs} == {0, 1}, f"c2 bit0 not exercised: {obs}"
+
+
+def _partial_consumption(obs: set[tuple[int, ...]]) -> None:
+    """(syndrome:1, result:2), two records. CX from |0> leaves the
+    ancilla |0> -> syndrome is ALWAYS 0 (hard, deterministic);
+    result is unconstrained. Assert syndrome==0 every shot."""
+    assert all(syn == 0 for syn, _ in obs), f"syndrome non-zero (ancilla not |0>): {obs}"
+
+
+def _high_bits_zero_1(obs: set[tuple[int, ...]]) -> None:
+    """docs.for_static_indexing: H unrolled 3x on q[0] (= H) ->
+    q[0] random; q[1]=q[2]=|0>. 3-bit CReg -> record in {0,1}
+    (bits 1,2 provably 0 == the #74 static-For body actually
+    unrolled and touched only q[0]); both 0 and 1 occur."""
+    assert obs <= {(0,), (1,)}, f"a high bit set -> static-For body wrong: {obs}"
+    assert obs == {(0,), (1,)}, f"q[0] randomness not exercised: {obs}"
+
+
+_Spec = tuple[int, ...] | Callable[[set[tuple[int, ...]]], None] | str
+
+_MANIFEST: dict[str, tuple[str, _Spec]] = {
+    # ----- D: deterministic exact record -----
+    "v1.conditional_correction": ("D", (0,)),  # |0>->c0=0; If-not-taken; |0>->c1=0
+    "legacy.individual_measurements": ("D", (0,)),  # four |0> -> packed 0
+    "qeclib.generic_transversal_cx": ("D", (0,)),  # CX|0..0>=|0..0> -> all 0
+    # ----- P: hard invariant over fixed seeds -----
+    "v1.bell": ("P", _bell2),
+    "v1.ghz_three": ("P", _ghz3),
+    "legacy.function_with_returns": ("P", _bell2),  # Bell, c:2
+    "legacy.multiple_qregs": ("P", _multiple_qregs),
+    "legacy.partial_consumption_with_block": ("P", _partial_consumption),
+    "examples.measure_register_to_creg": ("P", _two_indep_bell_4),
+    "examples.parallel_bell_pairs": ("P", _three_indep_bell_6),
+    "docs.for_static_indexing": ("P", _high_bits_zero_1),
+    # ----- X: excluded, with rationale -----
+    "examples.surface_d3_x_1round": ("X", "no Main-scope CReg / no classical record"),
+    "examples.surface_d3_z_1round": ("X", "no Main-scope CReg / no classical record"),
+    "legacy.gates_only_no_measurement": ("X", "no CReg, no measurement record"),
+    "qeclib.surface_patch_builder_empty": ("X", "build()-only: no gates/measures/records"),
+    "qeclib.surface_std_pz": ("X", "pz() measures ancillas internally; no Main-scope CReg"),
+    "v1.repeat_idle": ("X", "no declared CReg; bare internal measure not recorded"),
+    "legacy.nested_blocks": (
+        "X",
+        "two independent H->meas; all 4 values uniformly possible -- "
+        "no hard invariant (a distribution test is forbidden)",
+    ),
+    "docs.flat_parallel_h_gates": (
+        "X",
+        "4 independent H->meas; all 16 values uniformly possible -- no hard invariant",
+    ),
+    "docs.repeat_state_preserving": (
+        "X",
+        "Repeat(3) H on q[0] = H (odd) -> |+>; Z-measure is ONE uniform "
+        "random bit -- no deterministic value or hard invariant "
+        "(pre-review's [0] assumed the result was discarded; it is recorded)",
+    ),
+    "docs.prep_basis_x": (
+        "X",
+        "#81 PX = reset+H = |+>; Z-measure is ONE uniform random bit -- "
+        "no hard invariant. PX correctness is validated behaviorally by "
+        "test_prep_gates (Stim peek_bloch + Selene), not here. "
+        "(Pre-review's deterministic [0] assumed the OLD broken "
+        "Prep('X')=Z-reset, fixed by #81.)",
+    ),
+    "qeclib.color488_syn_extract_bare": (
+        "X",
+        "Color488 syndrome extraction: on |0..0> the X-stabiliser "
+        "ancillas are not +1 eigenstates, so the syndrome is not a sound "
+        "all-zero first-principles invariant at this scale without an "
+        "independent decoder oracle; asserting one would ship false "
+        "confidence and reverse-fitting is the forbidden anti-pattern",
+    ),
+}
+
+
+def _qis_ok_labels() -> list[str]:
+    _bf, _vf, qis_ok, _qf, _ea = _qir_state()
+    return sorted(qis_ok)
+
+
+@pytest.mark.slow
+@pytest.mark.optional_dependency
+def test_qir_corpus_manifest_covers_qis_ok() -> None:
+    """Drift guard: every live QIS_OK label has a manifest class.
+
+    Ties the executable set to the #71 `_qir_state()` QIS_OK so a
+    new/changed corpus program (or a QIS_OK drift from a codegen
+    change) forces a classification decision -- it cannot be
+    silently skipped. Also pins the class histogram so a
+    reclassification is deliberate.
+    """
+    qis_ok = set(_qis_ok_labels())
+    missing = qis_ok - set(_MANIFEST)
+    assert not missing, f"QIS_OK programs with no #79 manifest class (classify them): {sorted(missing)}"
+    stale = set(_MANIFEST) - qis_ok
+    assert not stale, f"manifest entries no longer QIS_OK (remove/retriage): {sorted(stale)}"
+    hist = {cls: sum(1 for c, _ in _MANIFEST.values() if c == cls) for cls in ("D", "P", "X")}
+    assert hist == {"D": 3, "P": 8, "X": 11}, f"manifest class histogram changed (deliberate?): {hist}"
+
+
+@pytest.mark.slow
+@pytest.mark.optional_dependency
+@pytest.mark.parametrize("label", _qis_ok_labels())
+def test_qir_corpus_executable(label: str) -> None:
+    """Execute the lowered QIS and assert the manifest class.
+
+    D: exact record == spec, every shot, every seed.
+    P: the hard invariant holds AND is exercised over the fixed
+       seed set.
+    X: documented exclusion. Record-shape contract (Codex
+       pre-review blocker 1): a program with an explicit
+       `Return(CReg)` and a Main-scope CReg `alloca` MUST emit >=1
+       executed record -- an explicit-return program that produces
+       no record is an output-loss miscompile, NOT a silent X.
+    """
+    assert label in _MANIFEST, f"unclassified QIS_OK program {label!r}"
+    cls, spec = _MANIFEST[label]
+    cases = {c.label: c for c in _curated_cases()}
+    prog = cases[label].factory()
+    n_qubits = _required_num_qubits(prog)
+
+    qir = SlrConverter(prog).qir()
+    has_record = "call void @__quantum__rt__int_record_output" in qir
+
+    if cls == "X":
+        if has_record:
+            # Record-shape contract: X-with-output must still
+            # actually produce executable records (the exclusion is
+            # "no sound invariant", NOT "no output"). An
+            # explicit-return program emitting nothing would be the
+            # #80-class output-loss miscompile and must fail here.
+            obs = _observed(prog, n_qubits)
+            assert obs, f"X-with-record {label!r} produced NO executed record (output-loss miscompile)"
+            assert all(len(r) >= 1 for r in obs), f"{label!r} emitted an empty record tuple: {obs}"
+        return
+
+    obs = _observed(prog, n_qubits)
+    assert obs, f"{label!r} ({cls}) produced no executed records"
+
+    if cls == "D":
+        assert obs == {tuple(spec)}, f"{label!r} D: expected exactly {{{tuple(spec)}}}, executed {sorted(obs)}"
+    else:  # P
+        assert callable(spec)
+        spec(obs)

From 17187330dba028fd1faaf3343570e0d561fbd116 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Mon, 18 May 2026 22:54:56 -0600
Subject: [PATCH 102/136] #87 post-review fold (Codex blocker): validate
 expanded Permute refs BEFORE dict construction

Codex post-review NO -- 1 blocker: _process_permute built `mapping`
via `dict(...).update(zip(src_refs,tgt_refs))` and only THEN checked
`set(mapping) != set(mapping.values())`. A duplicate expanded source
collapses in the dict before the check, so a genuinely non-bijective
public Permute compiled instead of failing loud (silent miscompile,
the exact class this branch fights): `Permute([a[0],a[0]],[b[0],a[0]])`
COMPILED.

Fix (Codex's prescription): accumulate the expanded source/target
refs as LISTS, then validate BEFORE building the dict -- reject (a)
duplicate expanded sources, (b) duplicate expanded targets, (c)
src set != tgt set -- then build the map atomically. Regression
test_non_bijective_permute_fails_loud covers both Codex repro
shapes (distinct non-bijective -> "bijective over the same ref
set"; duplicate-source -> "duplicate source ref"). Pickle already
YES; this was Codex's sole blocker.

Verified: both repros now raise NotImplementedented loud; default
lane 403/0; optional_dependency 43 passed / 3 xfailed / 0 failed
(+1 new regression); behavioral prep all-6 24/0; ruff/black-25.9.0
clean.
---
 .../src/pecos/slr/ast/codegen/qir.py          | 21 ++++++++++++---
 .../unit/slr/test_quantum_permutation.py      | 26 +++++++++++++++++++
 2 files changed, 44 insertions(+), 3 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
index 7c48d7b25..8cd2da3c7 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
@@ -910,19 +910,34 @@ def _process_permute(self, node: PermuteOp) -> None:
             msg = "QIR codegen: Permute source/target length mismatch"
             raise NotImplementedError(msg)
 
-        mapping: dict[tuple[str, int], tuple[str, int]] = {}
+        # Accumulate the expanded refs as LISTS first and validate
+        # BEFORE building the dict: a dict would silently collapse a
+        # duplicate expanded source (e.g.
+        # `Permute([a[0], a[0]], [b[0], a[0]])`) so a genuinely
+        # non-bijective Permute would compile -- a silent miscompile.
+        src_all: list[tuple[str, int]] = []
+        tgt_all: list[tuple[str, int]] = []
         for source, target in zip(node.sources, node.targets, strict=True):
             src_refs = self._expand_permute_ref(source)
             tgt_refs = self._expand_permute_ref(target)
             if len(src_refs) != len(tgt_refs):
                 msg = f"QIR codegen: Permute element count mismatch for {source!r} -> {target!r}"
                 raise NotImplementedError(msg)
-            mapping.update(zip(src_refs, tgt_refs, strict=True))
+            src_all.extend(src_refs)
+            tgt_all.extend(tgt_refs)
 
-        if set(mapping) != set(mapping.values()):
+        if len(src_all) != len(set(src_all)):
+            msg = "QIR codegen: Permute has a duplicate source ref (not a permutation)"
+            raise NotImplementedError(msg)
+        if len(tgt_all) != len(set(tgt_all)):
+            msg = "QIR codegen: Permute has a duplicate target ref (not a permutation)"
+            raise NotImplementedError(msg)
+        if set(src_all) != set(tgt_all):
             msg = "QIR codegen: Permute must be bijective over the same ref set"
             raise NotImplementedError(msg)
 
+        mapping: dict[tuple[str, int], tuple[str, int]] = dict(zip(src_all, tgt_all, strict=True))
+
         # Human-readable comment mirroring the legacy gen_qir format
         # (rendered from the post-substitution sources so it stays
         # correct inside a flattened BlockCall).
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_permutation.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_permutation.py
index 41f3f5703..85ad6d293 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_permutation.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_permutation.py
@@ -258,3 +258,29 @@ def test_whole_register_qreg_permutation_realized_qir() -> None:
     assert _q("z", qir) == [0], qir  # Z(b[0]) after swap -> q0
 
     assert qir == SlrConverter(prog).qir(), "QIR generation is not deterministic"
+
+
+@pytest.mark.optional_dependency
+def test_non_bijective_permute_fails_loud() -> None:
+    """A non-bijective Permute must fail loud, not silently miscompile.
+
+    #87 post-review (Codex blocker): the bijectivity guard must
+    validate the EXPANDED source/target lists BEFORE building the
+    map -- a dict would collapse a duplicate expanded source, so a
+    genuinely non-bijective Permute would compile (silent
+    miscompile). Both Codex repro shapes must raise.
+    """
+    # Distinct refs, src set != tgt set.
+    a = QReg("a", 2)
+    b = QReg("b", 1)
+    prog = Main(a, b, Permute([a[0], a[1]], [a[1], b[0]]), qubit.H(a[0]))
+    with pytest.raises(NotImplementedError, match=r"bijective over the same ref set"):
+        SlrConverter(prog).qir()
+
+    # Duplicate source ref: would collapse in a dict and bypass the
+    # set-equality check -- must be rejected on the duplicate.
+    a = QReg("a", 2)
+    b = QReg("b", 1)
+    prog = Main(a, b, Permute([a[0], a[0]], [b[0], a[0]]), qubit.H(a[0]))
+    with pytest.raises(NotImplementedError, match=r"duplicate source ref"):
+        SlrConverter(prog).qir()

From 663c0f7750e6c9c3a46a0f4808825ec4f2e479f3 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Mon, 18 May 2026 23:32:19 -0600
Subject: [PATCH 103/136] Strip reviewer/persona names from code comments; pin
 duplicate-target Permute guard

Per user direction: code comments/docstrings must not name
reviewers/agents/personas or leak the review-process workflow.
Branch-wide sweep of changed .py files -- replaced "Codex"/
"Pickle"/"pre-review blocker N"/"re-confirm note" etc. with the
durable issue ref (#80/#79/#71/#88A) + the technical reason. No
behavior change (comments/docstrings only). Also folds the #87
non-blocking symmetry note: test_non_bijective_permute_fails_loud
now also pins the duplicate-TARGET guard (was only duplicate-
source + distinct-non-bijective; the target guard was live but
unpinned).

Verified: default 403/0; optional_dependency 43 passed / 3
xfailed / 0 failed; slow #79 lane 23/23; ruff/black-25.9.0 clean;
branch-wide grep for persona/review-process terms in *.py is
empty.
---
 .../src/pecos/slr/ast/codegen/qir.py          | 11 ++++-----
 .../ast_guppy/test_qir_corpus_executable.py   | 24 +++++++++----------
 .../ast_guppy/test_qir_spec_compliance.py     | 12 +++++-----
 .../unit/slr/test_quantum_permutation.py      | 18 ++++++++++----
 4 files changed, 36 insertions(+), 29 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
index 8cd2da3c7..784357f63 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
@@ -425,20 +425,19 @@ def _process_return(self, node: ReturnOp) -> None:
         an inline / local-scope returned CReg produced ZERO recorded
         output for an explicit `Return` -- the build succeeded and
         validated, the program just silently returned nothing
-        (Codex #80 post-review blocker; same silent-output-loss
-        class as the four point-of-use sites). Qubit returns record
-        no classical output and are skipped via per-value provenance
+        (#80; same silent-output-loss class as the four
+        point-of-use sites). Qubit returns record no classical
+        output and are skipped via per-value provenance
         (`ReturnOp.value_kinds` from `_convert_return`), so a
         `Return(qreg)` is not false-rejected AND a returned inline
         CReg whose name collides with a declared QReg is still
-        validated (the Codex #80 re-confirm blocker -- a
-        name-membership skip was unsound).
+        validated (#80: a name-membership skip was unsound).
         """
         # Provenance comes from `_convert_return` (it knows the real
         # QReg/CReg object), NOT from a name-membership guess: a
         # returned inline CReg can share a declared QReg's name, which
         # a `qubit_map`-name skip silently mistook for a qubit return
-        # and dropped (Codex #80 re-confirm blocker). Unknown kind
+        # and dropped (#80). Unknown kind
         # ("" -- e.g. a directly-constructed ReturnOp) falls back to
         # "classical", the fail-loud-safe default.
         kinds = node.value_kinds
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
index 8bd413ac3..011da67cc 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
@@ -21,7 +21,7 @@
 fail-loud line, at corpus scale.
 
 THE HARD PART IS THE ORACLE (per the scoped plan + dual
-pre-review `reviews/{codex,pickle}-79-...`). Every QIS_OK program
+#79 design + dual review). Every QIS_OK program
 is assigned a validation CLASS in `_MANIFEST`, derived from first
 principles (reading the circuit) and CONFIRMED -- never
 reverse-fitted -- by execution:
@@ -39,26 +39,26 @@
   CReg), or a single unconstrained random bit / fully
   unconstrained register / no sound first-principles invariant.
   Documented per program; X with output still gets the
-  record-shape contract (Codex pre-review blocker 1).
+  record-shape contract (#79 design blocker 1).
 
-Drift safety (Codex pre-review blocker / design item 4): the
+Drift safety (#79 design item 4): the
 candidate set is taken LIVE from `_qir_state()` QIS_OK, and every
 QIS_OK label MUST be in `_MANIFEST` -- a new/changed corpus
 program forces a classification decision (no silent gap), and the
 executable set cannot drift from the #71 structural gate.
 
-n_qubits derivation (Codex pre-review blocker 3): from the QIR
+n_qubits derivation (#79 design blocker 3): from the QIR
 `required_num_qubits` entry attribute -- NOT a max-operand-
 reference count (that is 0 for no-op QReg programs and panics
 selene with "No more qubits available to allocate").
 
-Pre-review blockers 1 (inline/Return-only CReg output loss) and 2
+#79 design blockers 1 (inline/Return-only CReg output loss) and 2
 (non-Z `Prep` silently Z-reset) were RESOLVED upstream by #80
 (inline CReg fails loud -> BUILD_FAILED, out of QIS_OK) and #81
 (dedicated `PX`/etc with correct reset+Clifford-tail lowering);
 the prep cases are reclassified here from first principles under
 the CORRECT #81 semantics (`docs.prep_basis_x` is `PX`=|+>, a
-single uniform Z-measure bit -> **X**, NOT the pre-review's
+single uniform Z-measure bit -> **X**, NOT an earlier
 deterministic `[0]` which assumed the old broken Z-reset).
 
 `@pytest.mark.slow` (one selene build per QIS_OK program; selene
@@ -92,7 +92,7 @@
 def _required_num_qubits(prog: Main) -> int:
     """n_qubits from the QIR `required_num_qubits` entry attr.
 
-    Codex #79 pre-review blocker 3: a max-operand-reference count
+    #79 design blocker 3: a max-operand-reference count
     is 0 for no-op QReg programs (e.g. surface_patch_builder_empty)
     and panics selene. The entry attr is the AST root-allocator
     capacity the backend pins, which is correct for every program.
@@ -166,7 +166,7 @@ def _multiple_qregs(obs: set[tuple[int, ...]]) -> None:
     is provably 0 -- only qubit 0 of each QReg is measured into bit
     0, bit 1 is never written (zeroinitializer). So each record is
     in {0,1}. Execution CONFIRMED c1 and c2 are NOT correlated (all
-    of (0,0)/(0,1)/(1,0)/(1,1) occur -- the pre-review's `c1==c2`
+    of (0,0)/(0,1)/(1,0)/(1,1) occur -- an earlier `c1==c2`
     first-principles guess was disproven by running it); we assert
     ONLY the sound bit-1==0 invariant, NOT a cross-register
     correlation, and require both bits exercised.
@@ -228,14 +228,14 @@ def _high_bits_zero_1(obs: set[tuple[int, ...]]) -> None:
         "X",
         "Repeat(3) H on q[0] = H (odd) -> |+>; Z-measure is ONE uniform "
         "random bit -- no deterministic value or hard invariant "
-        "(pre-review's [0] assumed the result was discarded; it is recorded)",
+        "(an earlier [0] guess assumed the result was discarded; it is recorded)",
     ),
     "docs.prep_basis_x": (
         "X",
         "#81 PX = reset+H = |+>; Z-measure is ONE uniform random bit -- "
         "no hard invariant. PX correctness is validated behaviorally by "
         "test_prep_gates (Stim peek_bloch + Selene), not here. "
-        "(Pre-review's deterministic [0] assumed the OLD broken "
+        "(An earlier deterministic [0] guess assumed the OLD broken "
         "Prep('X')=Z-reset, fixed by #81.)",
     ),
     "qeclib.color488_syn_extract_bare": (
@@ -283,8 +283,8 @@ def test_qir_corpus_executable(label: str) -> None:
     D: exact record == spec, every shot, every seed.
     P: the hard invariant holds AND is exercised over the fixed
        seed set.
-    X: documented exclusion. Record-shape contract (Codex
-       pre-review blocker 1): a program with an explicit
+    X: documented exclusion. Record-shape contract (#79
+       design blocker 1): a program with an explicit
        `Return(CReg)` and a Main-scope CReg `alloca` MUST emit >=1
        executed record -- an explicit-return program that produces
        no record is an output-loss miscompile, NOT a silent X.
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
index a431b5dbd..f3ea526ab 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
@@ -67,8 +67,8 @@
 emitter"); and `docs.inline_measure_creg` /
 `docs.surface_syndrome_block18` (#80: an inline/`Return`-only
 CReg gets no storage, so #80 fails loud instead of silently
-dropping its value -- the silent-output-loss defect #79's
-dual pre-review surfaced; `surface_syndrome_block18`'s
+dropping its value -- the silent-output-loss defect #79
+surfaced; `surface_syndrome_block18`'s
 `Measure(data) > CReg("final", ...)` is exactly that inline
 CReg, so it still build-fails post-#81 -- pinned honestly on
 the inline-CReg reason, NOT masked by restructuring the
@@ -116,7 +116,7 @@
     # out of scope for the sound emitter).
     "docs.while_loop": ("NotImplementedError", "does not support While loops"),
     # #80 inline/Return-only CReg fail-loud (the silent-output-loss
-    # defect #79's dual pre-review surfaced). A CReg used/measured/
+    # defect #79 surfaced). A CReg used/measured/
     # returned but never declared at Main scope gets no
     # `alloca [N x i1]`; #80 raises instead of silently dropping it.
     #  - inline_measure_creg: `final` only `Return`ed, never declared.
@@ -195,7 +195,7 @@
     },
 )
 
-# Codex B1 post-review blocker: qir-qis validates the PRESENCE of these
+# #71 B1: qir-qis validates the PRESENCE of these
 # entry attributes but NOT their values, so a value regression (e.g.
 # silently reverting `qir_profiles` to "custom"/"base_profile", or
 # `output_labeling_schema` to something else) would pass both qir-qis
@@ -261,7 +261,7 @@ def test_audit_corpus_qir_compliance_baseline() -> None:
         qis_ok or qis_failed or validate_failed
     ), f"validate_qir never ran on built QIR; build_failed={sorted(label for label, _, _ in build_failed)}"
 
-    # Pre-existing build-failure set pinned (Codex Stage-A blocker): a
+    # Pre-existing build-failure set pinned (#71 Stage-A): a
     # new build regression -- or a fixed one -- must be triaged
     # deliberately, not silently scoped out.
     got_bf = {label: (etype, emsg) for label, etype, emsg in build_failed}
@@ -287,7 +287,7 @@ def test_audit_corpus_qir_compliance_baseline() -> None:
     for label, frag in _EXPECTED_VALIDATE_FAILED.items():
         assert frag in got_vf[label], f"{label}: validate msg lacks {frag!r}: {got_vf[label][:200]}"
 
-    # Tier 1b -- pin the exact entry-attr VALUES (Codex B1 blocker).
+    # Tier 1b -- pin the exact entry-attr VALUES (#71 B1).
     # qir-qis only enforces presence, so a value regression would pass
     # both qir-qis and the presence-only tier-1 check above.
     assert entry_attrs, "no validate-passing cases to check entry-attr values"
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_permutation.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_permutation.py
index 85ad6d293..c07120f29 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_permutation.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_permutation.py
@@ -264,11 +264,11 @@ def test_whole_register_qreg_permutation_realized_qir() -> None:
 def test_non_bijective_permute_fails_loud() -> None:
     """A non-bijective Permute must fail loud, not silently miscompile.
 
-    #87 post-review (Codex blocker): the bijectivity guard must
-    validate the EXPANDED source/target lists BEFORE building the
-    map -- a dict would collapse a duplicate expanded source, so a
-    genuinely non-bijective Permute would compile (silent
-    miscompile). Both Codex repro shapes must raise.
+    #87: the bijectivity guard must validate the EXPANDED
+    source/target lists BEFORE building the map -- a dict would
+    collapse a duplicate expanded source, so a genuinely
+    non-bijective Permute would compile (silent miscompile). All
+    malformed shapes must raise.
     """
     # Distinct refs, src set != tgt set.
     a = QReg("a", 2)
@@ -284,3 +284,11 @@ def test_non_bijective_permute_fails_loud() -> None:
     prog = Main(a, b, Permute([a[0], a[0]], [b[0], a[0]]), qubit.H(a[0]))
     with pytest.raises(NotImplementedError, match=r"duplicate source ref"):
         SlrConverter(prog).qir()
+
+    # Duplicate target ref (symmetry: the duplicate-target guard must
+    # also be live, not just duplicate-source).
+    a = QReg("a", 2)
+    b = QReg("b", 1)
+    prog = Main(a, b, Permute([a[0], b[0]], [a[0], a[0]]), qubit.H(a[0]))
+    with pytest.raises(NotImplementedError, match=r"duplicate target ref"):
+        SlrConverter(prog).qir()

From e7eed171ba966168ddc8e92e5b8667aa18812ee7 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Tue, 19 May 2026 08:30:37 -0600
Subject: [PATCH 104/136] #93 (partial): verified QIR lowering for
 SX/SXdg/SY/SYdg (executable-Clifford)

The user-chosen verified-safe subset of the 18 #88A fail-loud gates.
Methodology (no guessing): extract each gate's authoritative unitary
from the PECOS StateVec simulator, search the EXECUTABLE Clifford
primitive set for a sequence equal up to a global phase, then verify
end-to-end through qir_to_qis -> selene.

Key correctness finding: decomposing to rx/ry/rz is WRONG --
`__quantum__qis__rx__body` is a pinned build/exec failure
(`docs.rotation_rx`) and selene's Stim backend silently no-ops an
rx, so a rotation lowering is itself a silent miscompile (the
behavioral check caught this -- SX;SX gave 0 not 1). Correct
executable-Clifford lowering (verified up-to-phase vs PECOS sim AND
end-to-end): SX=H;S;H, SXdg=H;Sdg;H, SY=H;X, SYdg=H;Z. `_GATE_DECOMP`
+ a pre-fail-loud branch in `_process_gate` (re-emits the primitive
sequence; F-family/CY/CH/CR*/sqrt-2q stay fail-loud pending the
scoped workstream). test_sx_sxdg flipped raises->positive.
test_sqrt_clifford_gates_executable (slow+optional_dependency) pins
the end-to-end identities SX;SX==X / SXdg;SX==I / SY;SY==Y /
SYdg;SY==I + Z-randomness of the single gates.

#71/#79 corpus buckets UNCHANGED (no curated case uses SX/SY; the
CY-bearing generic_check programs stay BUILD_FAILED). Verified:
default 403/0; optional_dependency 43 passed / 3 xfailed / 0 failed;
slow 24 passed (22 #79 + manifest-cover + sqrt_clifford);
ruff/black-25.9.0 clean.
---
 .../src/pecos/slr/ast/codegen/qir.py          | 32 +++++++++++++-
 .../ast_guppy/test_qir_corpus_executable.py   | 42 ++++++++++++++++---
 .../regression/random_cases/test_slr_phys.py  | 28 ++++++++-----
 3 files changed, 86 insertions(+), 16 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
index 784357f63..6ef5d2396 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
@@ -26,7 +26,7 @@
 from __future__ import annotations
 
 import re
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 from typing import TYPE_CHECKING, Any
 
 from pecos.slr.ast.codegen._block_flatten import flatten_block_calls
@@ -102,6 +102,26 @@
     GateKind.SZZ: "zz",
 }
 
+# Single-qubit Clifford sqrt-gates with no direct QIR primitive,
+# lowered to an EXECUTABLE-Clifford sequence (h/s/s__adj/x/z only --
+# NOT rx/ry/rz: `__quantum__qis__rx__body` is a pinned build/exec
+# failure (`docs.rotation_rx`), and selene's Stim backend silently
+# no-ops an rx, so a rotation lowering would be a silent miscompile).
+# Each sequence was found by searching the executable Clifford set
+# and VERIFIED equal (up to a global phase, unobservable for
+# measurement-terminated circuits) to the PECOS `StateVec`
+# simulator's authoritative unitary, AND verified end-to-end via the
+# #79 executable path (qir_to_qis -> selene): SX;SX == X,
+# SXdg;SX == I, SY;SY == Y, SYdg;SY == I. (#93: only this verified
+# subset; F-family/CY/CH/CR*/sqrt-2q gates stay fail-loud pending
+# the scoped verification-first workstream.)
+_GATE_DECOMP: dict[GateKind, tuple[GateKind, ...]] = {
+    GateKind.SX: (GateKind.H, GateKind.S, GateKind.H),
+    GateKind.SXdg: (GateKind.H, GateKind.Sdg, GateKind.H),
+    GateKind.SY: (GateKind.H, GateKind.X),
+    GateKind.SYdg: (GateKind.H, GateKind.Z),
+}
+
 # Gates with rotation parameters
 PARAMETERIZED_GATES = {GateKind.RX, GateKind.RY, GateKind.RZ, GateKind.RZZ}
 
@@ -455,6 +475,16 @@ def _process_return(self, node: ReturnOp) -> None:
     def _process_gate(self, node: GateOp) -> None:
         """Process a gate operation."""
         qir_name = GATE_TO_QIR.get(node.gate)
+        if qir_name is None and node.gate in _GATE_DECOMP:
+            # #93: a single-qubit Clifford sqrt-gate with no direct
+            # QIR primitive -- emit its verified executable-Clifford
+            # sequence (same target), each primitive in order.
+            for prim_kind in _GATE_DECOMP[node.gate]:
+                self._process_single_qubit_gate(
+                    replace(node, gate=prim_kind, params=()),
+                    GATE_TO_QIR[prim_kind],
+                )
+            return
         if qir_name is None:
             # #88A (the broad class #78 deferred): a gate with no
             # GATE_TO_QIR entry was SILENTLY DROPPED -- valid QIR,
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
index 011da67cc..28f5cda1b 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
@@ -70,16 +70,14 @@
 
 import re
 from collections.abc import Callable
-from typing import TYPE_CHECKING
 
 import pytest
-from pecos.slr import SlrConverter
+from pecos.slr import CReg, Main, QReg, Return, SlrConverter
+from pecos.slr.qeclib import qubit as qb
+from pecos.slr.qeclib.qubit.measures import Measure
 
 from .audit_runner import _curated_cases  # noqa: TID252
 from .test_qir_spec_compliance import _qir_state  # noqa: TID252
-
-if TYPE_CHECKING:
-    from pecos.slr import Main
 from .tier2_semantic import _qis_exec_records  # noqa: TID252
 
 # Fixed seed set for P invariants: chosen so a hard invariant must
@@ -318,3 +316,37 @@ def test_qir_corpus_executable(label: str) -> None:
     else:  # P
         assert callable(spec)
         spec(obs)
+
+
+@pytest.mark.slow
+@pytest.mark.optional_dependency
+def test_sqrt_clifford_gates_executable() -> None:
+    """#93: the SX/SXdg/SY/SYdg QIR lowering EXECUTES correctly.
+
+    These have no direct QIR primitive; #93 lowers them to a
+    verified executable-Clifford sequence (H;S;H / H;Sdg;H / H;X /
+    H;Z -- NOT rx, which silently no-ops on the Stim backend). Pin
+    the end-to-end behavioral proof through
+    QIR -> qir_to_qis -> selene with deterministic, global-phase-
+    and runtime-convention-immune identities: SX;SX == X,
+    SXdg;SX == I, SY;SY == Y, SYdg;SY == I; and the single-gate
+    cases must be genuinely Z-random (a dropped/no-op lowering
+    would collapse to one value -- the silent-miscompile signature).
+    """
+
+    def _run(build):
+        q = QReg("q", 1)
+        c = CReg("c", 1)
+        prog = Main(q, c, *build(q), Measure(q[0]) > c[0], Return(c))
+        obs: set[tuple[int, ...]] = set()
+        for seed in _SEEDS:
+            for rec in _qis_exec_records(prog, 1, shots=_SHOTS, seed=seed):
+                obs.add(tuple(rec))
+        return obs
+
+    assert _run(lambda q: [qb.SX(q[0]), qb.SX(q[0])]) == {(1,)}, "SX;SX must be X (|0>->|1>)"
+    assert _run(lambda q: [qb.SXdg(q[0]), qb.SX(q[0])]) == {(0,)}, "SXdg;SX must be identity"
+    assert _run(lambda q: [qb.SY(q[0]), qb.SY(q[0])]) == {(1,)}, "SY;SY must be Y (|0>->~|1>)"
+    assert _run(lambda q: [qb.SYdg(q[0]), qb.SY(q[0])]) == {(0,)}, "SYdg;SY must be identity"
+    assert _run(lambda q: [qb.SX(q[0])]) == {(0,), (1,)}, "SX|0> must be Z-random (not a no-op)"
+    assert _run(lambda q: [qb.SY(q[0])]) == {(0,), (1,)}, "SY|0> must be Z-random (not a no-op)"
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py b/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py
index fe2804835..5d17655f6 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py
@@ -229,14 +229,16 @@ def test_steane_qir_bc() -> None:
 
 @pytest.mark.optional_dependency
 def test_sx_sxdg() -> None:
-    """SX/SXdg have no QIR lowering -> fail loud (M-B2-static).
-
-    #88A: the legacy gen_qir never lowered SX->rx either; SX/SXdg are
-    absent from GATE_TO_QIR. They used to be SILENTLY DROPPED (#74-class
-    silent miscompile -- valid QIR, wrong semantics). #88A makes
-    `_process_gate` fail LOUD on any gate with no QIR lowering instead
-    of mis-emitting. (Adding an SX/SXdg->QIR decomposition would be a
-    feature, not pre-PR hygiene.)
+    """SX/SXdg lower to a verified executable-Clifford sequence.
+
+    #93: SX/SXdg have no direct QIR primitive but ARE Clifford
+    sqrt-X gates. They lower to `H;S;H` / `H;Sdg;H` (executable
+    Clifford only -- NOT rx, which is a pinned build/exec failure
+    and would silently no-op on the Stim backend). The sequence was
+    verified equal up to a global phase to the PECOS `StateVec`
+    simulator's unitary AND end-to-end via the #79 executable path
+    (SX;SX == X, SXdg;SX == I). (#88A's earlier fail-loud was the
+    correct interim until this verified lowering landed.)
     """
     prog: Main = Main(
         q := QReg("q", 2),
@@ -248,8 +250,14 @@ def test_sx_sxdg() -> None:
         Return(m),
     )
 
-    with pytest.raises(NotImplementedError, match=r"has no QIR lowering"):
-        SlrConverter(prog).qir()
+    qir = SlrConverter(prog).qir()
+    # SX(q0) -> h;s;h ; SXdg(q1) -> h;s__adj;h. No rotation, no
+    # NotImplementedError, deterministic.
+    assert "__quantum__qis__h__body" in qir
+    assert "__quantum__qis__s__body" in qir
+    assert "__quantum__qis__s__adj" in qir
+    assert "__quantum__qis__rx__body" not in qir, "SX must NOT lower to rx (not executable)"
+    assert qir == SlrConverter(prog).qir(), "QIR generation is not deterministic"
 
 
 @pytest.mark.optional_dependency

From 8acfa5735a9e6461749f296c8c7370d85f0f17e6 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Tue, 19 May 2026 09:19:53 -0600
Subject: [PATCH 105/136] Fix dead test module: rename tier2_semantic.py ->
 test_tier2_semantic.py so pytest collects it

Integrity finding: tier2_semantic.py did not match pytest's
test_*.py pattern and there is no python_files override, so it was
only ever imported as a helper -- its tests NEVER ran in any lane.
That silently killed #77's test_tier2_executable_differential
(the QIR->qir_to_qis->selene executable differential) AND a whole
module of #74/#80/#81 fail-loud regression guards
(test_varexpr/while/print/oversize/inline-creg/prep-stray-string
_raises_loud). A "verified" gate that never runs is faked-green.

Proper fix (no python_files hack): git mv to test_tier2_semantic.py
+ update the one real importer (test_qir_corpus_executable.py)
and the stale docstring prose in test_qir_spec_compliance.py.
The revived tests were NOT bit-rotted -- they pass once actually
collected.

Verified: default lane 403 -> 413 (+10 revived fast guards, all
green); optional_dependency 43 passed / 3 xfailed / 0 failed; slow
33 passed / 0 failed (incl. the revived test_tier2_semantic_b2 +
test_tier2_executable_differential + #93 sqrt_clifford);
ruff/black-25.9.0 clean.
---
 .../tests/slr_tests/ast_guppy/test_qir_corpus_executable.py   | 2 +-
 .../tests/slr_tests/ast_guppy/test_qir_spec_compliance.py     | 4 ++--
 .../ast_guppy/{tier2_semantic.py => test_tier2_semantic.py}   | 0
 3 files changed, 3 insertions(+), 3 deletions(-)
 rename python/quantum-pecos/tests/slr_tests/ast_guppy/{tier2_semantic.py => test_tier2_semantic.py} (100%)

diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
index 28f5cda1b..5dd8b9ec4 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
@@ -78,7 +78,7 @@
 
 from .audit_runner import _curated_cases  # noqa: TID252
 from .test_qir_spec_compliance import _qir_state  # noqa: TID252
-from .tier2_semantic import _qis_exec_records  # noqa: TID252
+from .test_tier2_semantic import _qis_exec_records  # noqa: TID252
 
 # Fixed seed set for P invariants: chosen so a hard invariant must
 # both HOLD and be EXERCISED (e.g. both Bell outcomes appear). NOT a
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
index f3ea526ab..f3f558f41 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
@@ -46,11 +46,11 @@
 fail loud on `While`, moving it to the build-failure set below.) (`adaptive_profile` is now genuinely exercised:
 B2 emits `__quantum__rt__read_result` for measurement feedback.)
 The deeper *semantic* proof for the load-bearing CReg shapes is
-`tier2_semantic.py` (real-compiler acceptance + emitted-QIR
+`test_tier2_semantic.py` (real-compiler acceptance + emitted-QIR
 structural invariants + a deterministic AST->Guppy->Selene
 cross-anchor). The direct `qir_to_qis`->Selene EXECUTABLE
 differential is delivered (#77 Layer D `_qis_exec_records` in
-`tier2_semantic.py`): `selene_sim` natively runs the LLVM-21
+`test_tier2_semantic.py`): `selene_sim` natively runs the LLVM-21
 opaque-pointer QIS bitcode `qir_to_qis` emits, via
 `selene_helios_qis_plugin` -- there is no LLVM-version blocker.
 #79 generalises it corpus-wide; this structural gate provides
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_tier2_semantic.py
similarity index 100%
rename from python/quantum-pecos/tests/slr_tests/ast_guppy/tier2_semantic.py
rename to python/quantum-pecos/tests/slr_tests/ast_guppy/test_tier2_semantic.py

From e47502827e55797d5f5f17e245bf1b8b8b7b0532 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Tue, 19 May 2026 10:01:14 -0600
Subject: [PATCH 106/136] A2: fix the Permute silent-miscompile in the Stim +
 QuantumCircuit codegens (same class as #87 QIR)

Both AST codegens had the identical pre-#87 broken pattern: a
`allocator_offsets` swap that NEVER reached gate qubit-index
resolution (element-wise refs are keyed by element string, not reg
name -> no-op) and self-cancelled for a whole-register
(a,b)/(b,a) pair. Confirmed: `Permute([a[0],b[0]],[b[0],a[0]])`
then `Y(a[0]); Z(b[0])` emitted `Y 0; Z 2` (Stim) / `Y:{0},Z:{2}`
(QC) instead of the correct `Y 2; Z 0` -- a silent miscompile,
the exact class #87 fixed in QIR (QASM was already correct).

Fix: port the proven #87 `permutation_map` model to both -- a
static logical relabel consulted in `get_qubit` (the single
qubit-ref chokepoint), built by `_process_permute` from expanded
refs with the post-#87-fold validation (dup-source / dup-target /
src-set!=tgt-set all fail loud) and atomic compose. Whole-register
CReg Permute fails loud (Stim/QC have no classical-register
model). Mirrors the Guppy linearity tracker / QIR #87.

Regression: test_permute_realized_quantum_circuit (default lane)
+ test_permute_realized_stim (optional_dependency) pin element +
whole-register realized targeting and the non-bijective fail-loud.

Verified: default 413->414 (+1 QC regression); optional_dependency
44 passed / 3 xfailed / 0 failed (+1 Stim regression); slow 33/0
(no regression); ruff/black-25.9.0 clean. No pre-existing test had
pinned the broken behavior (unlike QIR's 14 #87 tests).
---
 .../pecos/slr/ast/codegen/quantum_circuit.py  | 88 ++++++++++++++++---
 .../src/pecos/slr/ast/codegen/stim.py         | 87 +++++++++++++++---
 .../unit/slr/test_quantum_permutation.py      | 46 ++++++++++
 3 files changed, 195 insertions(+), 26 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py
index 8223ece0d..6a38252e8 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py
@@ -116,6 +116,12 @@ class QCCodeGenContext:
     current_tick: dict[str, set] = field(default_factory=dict)
     allocator_parents: dict[str, str | None] = field(default_factory=dict)
     allocator_offsets: dict[str, int] = field(default_factory=dict)
+    qreg_sizes: dict[str, int] = field(default_factory=dict)  # name -> capacity
+    # Static logical permutation (same model as the QIR codegen #87 /
+    # the Guppy linearity tracker -- QuantumCircuit has no permute
+    # instruction). Maps a logical (reg, index) ref to the (reg,
+    # index) whose qubit it resolves to; consulted in `get_qubit`.
+    permutation_map: dict[tuple[str, int], tuple[str, int]] = field(default_factory=dict)
 
     def get_root_allocator(self, name: str) -> str:
         """Get the root allocator for a given allocator name."""
@@ -134,6 +140,11 @@ def get_qubit(self, allocator: str, index: int) -> int:
 
         For child allocators, translates to root allocator with computed offset.
         """
+        # Resolve any active logical permutation first (identity until
+        # a Permute runs; decl-time pre-population sees the empty map,
+        # so real qubits are still allocated 1:1).
+        allocator, index = self.permutation_map.get((allocator, index), (allocator, index))
+
         # Translate to root allocator and absolute index
         root = self.get_root_allocator(allocator)
         abs_index = self.get_absolute_index(allocator, index)
@@ -204,12 +215,15 @@ def _process_declarations(self, program: Program) -> None:
         # Allocate qubits only for root allocators
         for decl in program.declarations:
             if isinstance(decl, AllocatorDecl):
+                self.context.qreg_sizes[decl.name] = decl.capacity
                 if decl.parent is None:
                     for i in range(decl.capacity):
                         self.context.get_qubit(decl.name, i)
             elif isinstance(decl, RegisterDecl):
                 pass  # Classical registers don't need qubit allocation
 
+        if program.allocator:
+            self.context.qreg_sizes[program.allocator.name] = program.allocator.capacity
         if program.allocator and program.allocator.parent is None:
             for i in range(program.allocator.capacity):
                 self.context.get_qubit(program.allocator.name, i)
@@ -437,21 +451,69 @@ def _process_parallel(self, node: ParallelBlock) -> None:
         self._in_parallel = False
         self._flush_tick()
 
-    def _process_permute(self, node: PermuteOp) -> None:
-        """Process a permutation operation.
+    def _expand_permute_ref(self, ref: str) -> list[tuple[str, int]]:
+        """Expand a Permute ref string to logical (reg, index) pairs.
 
-        Updates the internal allocator mapping to swap qubit references.
-        QuantumCircuit doesn't have a permute instruction, so this just updates
-        how we map allocator names to qubit indices.
+        `name[idx]` -> a single element; bare `name` -> every element
+        of the qubit register. QuantumCircuit has no realized
+        classical-register model, so a bare CReg permute is not
+        realizable -> fail loud (never a silent no-op). Mirrors the
+        QIR codegen's #87 helper.
+        """
+        if ref.endswith("]") and "[" in ref:
+            name, idx = ref[:-1].split("[", 1)
+            return [(name, int(idx))]
+        if ref in self.context.qreg_sizes:
+            return [(ref, i) for i in range(self.context.qreg_sizes[ref])]
+        msg = (
+            f"QuantumCircuit codegen: whole-register Permute of {ref!r} "
+            "is not supported (no classical-register model); a "
+            "qubit-register or element-wise Permute is realizable."
+        )
+        raise NotImplementedError(msg)
+
+    def _process_permute(self, node: PermuteOp) -> None:
+        """Realize a Permute as a static logical relabel.
+
+        QuantumCircuit has no permute instruction, so -- exactly like
+        the QIR codegen (#87) and the Guppy linearity tracker -- a
+        Permute is realized at compile time by relabelling which qubit
+        each logical (reg, index) ref resolves to (consulted in
+        `get_qubit`). The old `allocator_offsets` swap was a no-op for
+        element-wise refs and self-cancelling for a whole-register
+        (a,b)/(b,a) pair -- a silent miscompile.
         """
-        # Swap the allocator offsets
-        for src, tgt in zip(node.sources, node.targets, strict=False):
-            # Get current offsets
-            src_offset = self.context.allocator_offsets.get(src, 0)
-            tgt_offset = self.context.allocator_offsets.get(tgt, 0)
-            # Swap them
-            self.context.allocator_offsets[src] = tgt_offset
-            self.context.allocator_offsets[tgt] = src_offset
+        if len(node.sources) != len(node.targets):
+            msg = "QuantumCircuit codegen: Permute source/target length mismatch"
+            raise NotImplementedError(msg)
+
+        # Validate the expanded ref lists BEFORE building the dict (a
+        # dict would silently collapse a duplicate source).
+        src_all: list[tuple[str, int]] = []
+        tgt_all: list[tuple[str, int]] = []
+        for source, target in zip(node.sources, node.targets, strict=True):
+            src_refs = self._expand_permute_ref(source)
+            tgt_refs = self._expand_permute_ref(target)
+            if len(src_refs) != len(tgt_refs):
+                msg = f"QuantumCircuit codegen: Permute element count mismatch for {source!r} -> {target!r}"
+                raise NotImplementedError(msg)
+            src_all.extend(src_refs)
+            tgt_all.extend(tgt_refs)
+
+        if len(src_all) != len(set(src_all)):
+            msg = "QuantumCircuit codegen: Permute has a duplicate source ref (not a permutation)"
+            raise NotImplementedError(msg)
+        if len(tgt_all) != len(set(tgt_all)):
+            msg = "QuantumCircuit codegen: Permute has a duplicate target ref (not a permutation)"
+            raise NotImplementedError(msg)
+        if set(src_all) != set(tgt_all):
+            msg = "QuantumCircuit codegen: Permute must be bijective over the same ref set"
+            raise NotImplementedError(msg)
+
+        # Compose ATOMICALLY (snapshot old, then map[s] = old.get(t, t))
+        # so a whole-register (a,b)/(b,a) pair applies once.
+        old = dict(self.context.permutation_map)
+        self.context.permutation_map.update({s: old.get(t, t) for s, t in zip(src_all, tgt_all, strict=True)})
 
 
 def ast_to_quantum_circuit(program: Program) -> QuantumCircuit:
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/stim.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/stim.py
index 16ed18498..4757f0490 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/stim.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/stim.py
@@ -114,6 +114,12 @@ class StimCodeGenContext:
     measurement_count: int = 0
     allocator_parents: dict[str, str | None] = field(default_factory=dict)
     allocator_offsets: dict[str, int] = field(default_factory=dict)
+    qreg_sizes: dict[str, int] = field(default_factory=dict)  # name -> capacity
+    # Static logical permutation (same model as the QIR codegen #87 /
+    # the Guppy linearity tracker -- Stim has no permute instruction).
+    # Maps a logical (reg, index) ref to the (reg, index) whose qubit
+    # it resolves to. Consulted at every qubit-ref lowering.
+    permutation_map: dict[tuple[str, int], tuple[str, int]] = field(default_factory=dict)
 
     def get_root_allocator(self, name: str) -> str:
         """Get the root allocator for a given allocator name."""
@@ -132,6 +138,11 @@ def get_qubit(self, allocator: str, index: int) -> int:
 
         For child allocators, translates to root allocator with computed offset.
         """
+        # Resolve any active logical permutation first (identity until
+        # a Permute runs; decl-time pre-population sees the empty map,
+        # so real qubits are still allocated 1:1).
+        allocator, index = self.permutation_map.get((allocator, index), (allocator, index))
+
         # Translate to root allocator and absolute index
         root = self.get_root_allocator(allocator)
         abs_index = self.get_absolute_index(allocator, index)
@@ -199,6 +210,7 @@ def _process_declarations(self, program: Program) -> None:
         # Allocate qubits only for root allocators
         for decl in program.declarations:
             if isinstance(decl, AllocatorDecl):
+                self.context.qreg_sizes[decl.name] = decl.capacity
                 # Only allocate for root allocators (those without parents)
                 if decl.parent is None:
                     for i in range(decl.capacity):
@@ -206,6 +218,8 @@ def _process_declarations(self, program: Program) -> None:
             elif isinstance(decl, RegisterDecl):
                 pass  # Classical registers don't need qubit allocation
 
+        if program.allocator:
+            self.context.qreg_sizes[program.allocator.name] = program.allocator.capacity
         if program.allocator and program.allocator.parent is None:
             for i in range(program.allocator.capacity):
                 self.context.get_qubit(program.allocator.name, i)
@@ -421,21 +435,68 @@ def _process_parallel(self, node: ParallelBlock) -> None:
         for stmt in node.body:
             self._process_statement(stmt)
 
-    def _process_permute(self, node: PermuteOp) -> None:
-        """Process a permutation operation.
+    def _expand_permute_ref(self, ref: str) -> list[tuple[str, int]]:
+        """Expand a Permute ref string to logical (reg, index) pairs.
 
-        Updates the internal allocator mapping to swap qubit references.
-        Stim doesn't have a permute instruction, so this just updates
-        how we map allocator names to qubit indices.
+        `name[idx]` -> a single element; bare `name` -> every element
+        of the qubit register. Stim has no classical-register model,
+        so a bare CReg permute is not realizable -> fail loud (never
+        a silent no-op). Mirrors the QIR codegen's #87 helper.
+        """
+        if ref.endswith("]") and "[" in ref:
+            name, idx = ref[:-1].split("[", 1)
+            return [(name, int(idx))]
+        if ref in self.context.qreg_sizes:
+            return [(ref, i) for i in range(self.context.qreg_sizes[ref])]
+        msg = (
+            f"Stim codegen: whole-register Permute of {ref!r} is not "
+            "supported (no classical-register model in Stim); a "
+            "qubit-register or element-wise Permute is realizable."
+        )
+        raise NotImplementedError(msg)
+
+    def _process_permute(self, node: PermuteOp) -> None:
+        """Realize a Permute as a static logical relabel.
+
+        Stim has no permute instruction, so -- exactly like the QIR
+        codegen (#87) and the Guppy linearity tracker -- a Permute is
+        realized at compile time by relabelling which qubit each
+        logical (reg, index) ref resolves to (consulted in
+        `get_qubit`). The old `allocator_offsets` swap was a no-op
+        for element-wise refs and self-cancelling for a whole-register
+        (a,b)/(b,a) pair -- a silent miscompile.
         """
-        # Swap the allocator mappings
-        for src, tgt in zip(node.sources, node.targets, strict=False):
-            # Get current offsets
-            src_offset = self.context.allocator_offsets.get(src, 0)
-            tgt_offset = self.context.allocator_offsets.get(tgt, 0)
-            # Swap them
-            self.context.allocator_offsets[src] = tgt_offset
-            self.context.allocator_offsets[tgt] = src_offset
+        if len(node.sources) != len(node.targets):
+            msg = "Stim codegen: Permute source/target length mismatch"
+            raise NotImplementedError(msg)
+
+        # Validate the expanded ref lists BEFORE building the dict (a
+        # dict would silently collapse a duplicate source).
+        src_all: list[tuple[str, int]] = []
+        tgt_all: list[tuple[str, int]] = []
+        for source, target in zip(node.sources, node.targets, strict=True):
+            src_refs = self._expand_permute_ref(source)
+            tgt_refs = self._expand_permute_ref(target)
+            if len(src_refs) != len(tgt_refs):
+                msg = f"Stim codegen: Permute element count mismatch for {source!r} -> {target!r}"
+                raise NotImplementedError(msg)
+            src_all.extend(src_refs)
+            tgt_all.extend(tgt_refs)
+
+        if len(src_all) != len(set(src_all)):
+            msg = "Stim codegen: Permute has a duplicate source ref (not a permutation)"
+            raise NotImplementedError(msg)
+        if len(tgt_all) != len(set(tgt_all)):
+            msg = "Stim codegen: Permute has a duplicate target ref (not a permutation)"
+            raise NotImplementedError(msg)
+        if set(src_all) != set(tgt_all):
+            msg = "Stim codegen: Permute must be bijective over the same ref set"
+            raise NotImplementedError(msg)
+
+        # Compose ATOMICALLY (snapshot old, then map[s] = old.get(t, t))
+        # so a whole-register (a,b)/(b,a) pair applies once.
+        old = dict(self.context.permutation_map)
+        self.context.permutation_map.update({s: old.get(t, t) for s, t in zip(src_all, tgt_all, strict=True)})
 
 
 def ast_to_stim(program: Program) -> stim.Circuit:
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_permutation.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_permutation.py
index c07120f29..1f9e3af01 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_permutation.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_permutation.py
@@ -292,3 +292,49 @@ def test_non_bijective_permute_fails_loud() -> None:
     prog = Main(a, b, Permute([a[0], b[0]], [a[0], a[0]]), qubit.H(a[0]))
     with pytest.raises(NotImplementedError, match=r"duplicate target ref"):
         SlrConverter(prog).qir()
+
+
+def test_permute_realized_quantum_circuit() -> None:
+    """A2: element-wise + whole-register Permute is realized in the
+    QuantumCircuit codegen (was a silent no-op -- same class as the
+    QIR #87 bug; the allocator_offsets swap never reached gate
+    qubit-index resolution / self-cancelled for a whole-reg pair).
+    """
+    a = QReg("a", 2)
+    b = QReg("b", 2)
+    elem = Main(a, b, qubit.H(a[0]), qubit.X(b[0]), Permute([a[0], b[0]], [b[0], a[0]]), qubit.Y(a[0]), qubit.Z(b[0]))
+    # a=0,1 b=2,3. After a[0]<->b[0]: Y(a[0])->q2, Z(b[0])->q0.
+    assert str(SlrConverter(elem).quantum_circuit()) == "QuantumCircuit([{'H': {0}}, {'X': {2}}, {'Y': {2}}, {'Z': {0}}])"
+
+    a = QReg("a", 2)
+    b = QReg("b", 2)
+    whole = Main(a, b, qubit.H(a[0]), qubit.X(b[0]), Permute(a, b), qubit.Y(a[0]), qubit.Z(b[0]))
+    assert str(SlrConverter(whole).quantum_circuit()) == "QuantumCircuit([{'H': {0}}, {'X': {2}}, {'Y': {2}}, {'Z': {0}}])"
+
+    # Non-bijective must fail loud, not silently mis-resolve.
+    a = QReg("a", 2)
+    b = QReg("b", 1)
+    with pytest.raises(NotImplementedError, match=r"duplicate source ref"):
+        SlrConverter(Main(a, b, Permute([a[0], a[0]], [b[0], a[0]]), qubit.H(a[0]))).quantum_circuit()
+
+
+@pytest.mark.optional_dependency
+def test_permute_realized_stim() -> None:
+    """A2: element-wise + whole-register Permute is realized in the
+    Stim codegen (was a silent no-op -- same class as QIR #87).
+    """
+    a = QReg("a", 2)
+    b = QReg("b", 2)
+    elem = Main(a, b, qubit.H(a[0]), qubit.X(b[0]), Permute([a[0], b[0]], [b[0], a[0]]), qubit.Y(a[0]), qubit.Z(b[0]))
+    # a=0,1 b=2,3. After a[0]<->b[0]: Y(a[0])->q2, Z(b[0])->q0.
+    assert str(SlrConverter(elem).stim()).split() == ["H", "0", "X", "2", "Y", "2", "Z", "0"]
+
+    a = QReg("a", 2)
+    b = QReg("b", 2)
+    whole = Main(a, b, qubit.H(a[0]), qubit.X(b[0]), Permute(a, b), qubit.Y(a[0]), qubit.Z(b[0]))
+    assert str(SlrConverter(whole).stim()).split() == ["H", "0", "X", "2", "Y", "2", "Z", "0"]
+
+    a = QReg("a", 2)
+    b = QReg("b", 1)
+    with pytest.raises(NotImplementedError, match=r"bijective over the same ref set"):
+        SlrConverter(Main(a, b, Permute([a[0], a[1]], [a[1], b[0]]), qubit.H(a[0]))).stim()

From 1806f43b63e8c172caf02f57e7d32e0ec81e648d Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Tue, 19 May 2026 10:38:01 -0600
Subject: [PATCH 107/136] A: Stim unsupported-gate silent-skip -> fail loud
 (#78 surfaced-not-changed analogue of #88A)

stim._process_gate `if stim_gate is None: return` silently dropped
12 gates (CH/CRX/CRY/CRZ/F/F4/F4dg/Fdg/RX/RY/RZ/RZZ) -> the
emitted Stim circuit ran with WRONG semantics (a #74-class silent
miscompile, uncatchable downstream). Now raises NotImplementedError
("has no Stim lowering"), same doctrine as #74/#78/#88A. Stim is
Clifford-only so non-Clifford rotations are fundamentally
unrepresentable; the bug was emitting the circuit without them.
Regression test_unsupported_gate_fails_loud added.

QC investigated, NOT changed: it does not silent-skip -- it
name-passes-through (`.get(gate, gate.name)`); the 7 non-param
fallbacks are valid PECOS-sim gates (correct), and parameterized
gates already FAIL LOUD via the QuantumCircuit container's
"requires N angle(s), got 0" ValueError (not a silent miscompile).
No scope creep / no capability regression.

Blast radius ZERO (the #78 "broad reliance" fear did not
materialise in the corpus, same as #88A for QIR): default 414->415
(+1 regression), optional_dependency 44 passed / 3 xfailed / 0
failed, ruff/black-25.9.0 clean.
---
 .../src/pecos/slr/ast/codegen/stim.py         | 19 +++++++++++++++++--
 .../pecos/unit/slr/test_stim_conversion.py    | 14 ++++++++++++++
 2 files changed, 31 insertions(+), 2 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/stim.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/stim.py
index 4757f0490..5f9e364a3 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/stim.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/stim.py
@@ -285,8 +285,23 @@ def _process_gate(self, node: GateOp) -> None:
         """Process a gate operation."""
         stim_gate = GATE_TO_STIM.get(node.gate)
         if stim_gate is None:
-            # Skip unsupported gates
-            return
+            # #88A-class (the #78 surfaced-not-changed Stim analogue):
+            # a gate with no GATE_TO_STIM entry was SILENTLY DROPPED
+            # -- the emitted Stim circuit ran but with wrong
+            # semantics (a #74-class silent miscompile,
+            # uncatchable downstream). Fail loud instead. Stim is
+            # Clifford-only, so non-Clifford rotations
+            # (RX/RY/RZ/RZZ/CR*) are fundamentally unrepresentable
+            # here; F-family/CH have no Stim primitive. A program
+            # using one must not be silently mis-emitted.
+            gate_name = getattr(node.gate, "name", node.gate)
+            msg = (
+                f"Stim codegen: gate {gate_name!r} has no Stim lowering "
+                "(not in GATE_TO_STIM). Emitting the circuit without it "
+                "would be a silent miscompile; it is not supported by "
+                "the Stim backend."
+            )
+            raise NotImplementedError(msg)
 
         if node.gate in TWO_QUBIT_GATES:
             self._process_two_qubit_gate(node, stim_gate)
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_stim_conversion.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_stim_conversion.py
index 4d331e148..540f34e86 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_stim_conversion.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_stim_conversion.py
@@ -339,5 +339,19 @@ def test_while_raises_loud(self) -> None:
             SlrConverter(prog).stim()
 
 
+def test_unsupported_gate_fails_loud() -> None:
+    """#88A-class (the #78 surfaced-not-changed Stim analogue): a
+    gate with no GATE_TO_STIM entry must FAIL LOUD, not be silently
+    dropped (a silent drop produced a runnable circuit with wrong
+    semantics -- a #74-class miscompile). Stim is Clifford-only, so
+    a non-Clifford rotation is fundamentally unrepresentable;
+    emitting the circuit without it is the bug.
+    """
+    q = QReg("q", 1)
+    prog = Main(q, qubit.RX[0.5](q[0]))
+    with pytest.raises(NotImplementedError, match=r"has no Stim lowering"):
+        SlrConverter(prog).stim()
+
+
 if __name__ == "__main__":
     pytest.main([__file__, "-v"])

From 3a17c97db5c7a84f3456d38aaf9838dabc225825 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Tue, 19 May 2026 11:59:37 -0600
Subject: [PATCH 108/136] Post-review fold (Codex blocker): complete the
 branch-wide persona/process-name strip from .py comments

Codex post-review NO -- 1 blocker: the 663c0f77 claim (and my
session claim) of a *branch-wide* clean was false; ~30 added .py
comment/docstring lines outside that 5-commit range still named
reviewers/process ("Codex S2 review", "post-review blocker",
"re-confirm bug", "Codex #81 ...", etc.) in 10 files
(guppy.py/converter.py/nodes.py/check_1flag.py/migrate_implicit_
return.py + 5 test modules). Pickle YES (read the claim
narrowly as changed-files-only); Codex's branch-wide reading
matches the durable rule -- fold it.

Stripped every occurrence, replacing with the durable issue ref
+ technical reason (e.g. "#80 re-confirm bug" -> "#80
name-collision bug"; "(Codex S2 review)" -> dropped, surrounding
text already states the rationale; "confirmed Codex 2026-05-16"
-> "confirmed 2026-05-16"). Comments/docstrings ONLY -- zero
behavior change.

Verified: `git diff dev...HEAD -- '*.py'` added lines now match
none of Codex/Pickle/grug/Banana/pre-review/post-review/
re-confirm; default 415/0, optional_dependency 44 passed / 3
xfailed / 0 failed, slow 33/0, ruff/black-25.9.0 clean.
---
 .../src/pecos/slr/ast/codegen/guppy.py         |  6 +++---
 .../src/pecos/slr/ast/converter.py             | 10 +++++-----
 .../quantum-pecos/src/pecos/slr/ast/nodes.py   |  2 +-
 .../pecos/slr/qeclib/generic/check_1flag.py    |  2 +-
 .../pecos/slr/ast_tests/test_ast_visitor.py    |  2 +-
 .../slr_tests/ast_guppy/_selene_harness.py     |  2 +-
 .../ast_guppy/test_block_call_smoke.py         | 18 +++++++++---------
 .../slr_tests/ast_guppy/test_prep_gates.py     |  8 ++++----
 .../slr_tests/ast_guppy/test_tier2_semantic.py | 12 ++++++------
 scripts/migrate_implicit_return.py             |  2 +-
 10 files changed, 32 insertions(+), 32 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
index 1459ec421..8d91dd3b1 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
@@ -479,7 +479,7 @@ def _iter_stmts(self, body: tuple[Statement, ...]) -> Iterator[Statement]:
 
     def _validate_scratch_outer_slots(self, program: Program) -> None:
         """Reject programs where a scratch-bound outer slot is also used as
-        meaningful caller state (Codex S2 review).
+        meaningful caller state.
 
         A SCRATCH input lowers asymmetrically: flatten substitutes the
         scratch param to the outer slot (the block resets+measures THAT
@@ -495,7 +495,7 @@ def _validate_scratch_outer_slots(self, program: Program) -> None:
         wholesale-preps the ancilla register, e.g. `Prep(q)` covering
         `q[3]`, before using `q[3]` as a check ancilla).
 
-        Runs per scope (Codex S2 r2 blocker 3): `program.body` AND every
+        Runs per scope: `program.body` AND every
         `BlockDecl.body` -- a nested BlockCall whose scratch arg references
         the enclosing block's param slot has the same purity requirement
         within that block's scope.
@@ -1154,7 +1154,7 @@ def _emit_block_call(self, node: BlockCall) -> list[str]:
         # ancilla internally; the outer slot stays live and is discarded at
         # end-of-scope per R1). Validating-then-excluding -- not skipping
         # before validation -- so a malformed scratch binding (unknown/OOB
-        # outer slot) still fails loudly (Codex S2 review blocker 2).
+        # outer slot) still fails loudly.
         scratch_slots: list[tuple[str, int]] = []
         for inp, arg in zip(decl.inputs, node.arg_bindings, strict=True):
             if inp.effect is ResourceEffect.SCRATCH:
diff --git a/python/quantum-pecos/src/pecos/slr/ast/converter.py b/python/quantum-pecos/src/pecos/slr/ast/converter.py
index d4c3d844e..af8ce06d5 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/converter.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/converter.py
@@ -686,7 +686,7 @@ def _convert_prep(self, gate: Any, basis: str = "PZ") -> Statement:
         # `_expand_qubit_args` silently drops strings, so a basis
         # string (`PZ(q, "X")`, the legacy `Prep(q, "X")`, etc.)
         # would otherwise be silently dropped and the gate lowered as
-        # its plain basis -- a miscompile (#80 recast / #81 Codex sym
+        # its plain basis -- a miscompile (#80 recast / #81 sym
         # rule). The prep basis is the gate identity; pass NO string.
         for arg in gate.qargs:
             if isinstance(arg, str):
@@ -863,7 +863,7 @@ def _convert_return(self, op: Any) -> ReturnOp:
         SLR object's type. A whole-register return flattens to its
         bare `sym` name; a returned inline CReg can collide with a
         declared QReg of the same name, which is undecidable
-        downstream by name alone (the #80 re-confirm bug). The
+        downstream by name alone (the #80 name-collision bug). The
         QReg/CReg distinction is known HERE (the real object), so it
         is preserved instead of guessed in codegen.
         """
@@ -1132,7 +1132,7 @@ def _scratch_events(stmt: Statement, name: str) -> list[str]:
         # A scratch input must never be handed back to the caller: S2
         # allocates it internally and does not thread it through caller
         # state, so returning it would diverge from the flatten/QASM path
-        # (Codex S1 r2 review). Detection cannot be precise here -- the
+        # Detection cannot be precise here -- the
         # substitution leaves Return values as the OUTER name (a partial
         # VarExpr passes through `whole_name` unchanged), so a returned
         # scratch slot is indistinguishable from a returned classical
@@ -1202,8 +1202,8 @@ def _validate_scratch_input(
     # MEASURE before the next PREP and before the body ends. The S2 Guppy
     # lowering allocates the scratch qubit internally; an unmeasured trailing
     # Prep/use would leave the flatten/QASM path with a live reset outer slot
-    # while Guppy silently drops it -- a semantic divergence (Codex S1
-    # review). So every Prep must be terminated by a Measure.
+    # while Guppy silently drops it -- a semantic divergence.
+    # So every Prep must be terminated by a Measure.
     open_prep = False
     for ev in events:
         if ev == "PREP":
diff --git a/python/quantum-pecos/src/pecos/slr/ast/nodes.py b/python/quantum-pecos/src/pecos/slr/ast/nodes.py
index fc6055483..385db1091 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/nodes.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/nodes.py
@@ -480,7 +480,7 @@ class ReturnOp(Statement):
     # (the fail-loud-safe default). A bare `values` string cannot be
     # disambiguated CReg-vs-QReg by name alone (a returned inline
     # CReg can collide with a declared QReg name -- the #80
-    # re-confirm bug), so provenance is carried here, not guessed.
+    # name-collision bug), so provenance is carried here, not guessed.
     value_kinds: tuple[str, ...] = ()
 
     def children(self) -> Sequence[AstNode]:
diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/generic/check_1flag.py b/python/quantum-pecos/src/pecos/slr/qeclib/generic/check_1flag.py
index 8a5e53ea4..9b467d3d4 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/generic/check_1flag.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/generic/check_1flag.py
@@ -41,7 +41,7 @@ class Check1Flag(Block):
     # physical slots across sequential checks); data passes through; the two
     # out bits are live_preserved measurement-result write-backs. The body's
     # single `PZ(a, flag)` is split into `PZ(a), PZ(flag)` (O1 option
-    # (a) -- byte-identical in QASM/Guppy/Selene, confirmed Codex 2026-05-16;
+    # (a) -- byte-identical in QASM/Guppy/Selene, confirmed 2026-05-16;
     # one PrepareOp per scratch input avoids multi-destination substitution).
     # See ~/Repos/pecos-docs/design/slr/v2-scratch-ancilla-effect.md.
     block_inputs: ClassVar[dict[str, str]] = {
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_visitor.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_visitor.py
index 716bf8a2e..0c1191163 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_visitor.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_ast_visitor.py
@@ -322,7 +322,7 @@ def test_no_stale_or_invalid_dispatch_entries(self) -> None:
         assert not bad, f"_DISPATCH values not methods on BaseVisitor: {bad}"
 
     def test_subclass_of_concrete_node_dispatches_via_mro(self) -> None:
-        """Codex visitor-refactor review: the old `node.accept(self)`
+        """Visitor-refactor rationale: the old `node.accept(self)`
         double-dispatch was inherited, so a user subclass of a concrete
         node dispatched to the base node's `visit_*`. MRO lookup in
         `BaseVisitor.visit` must preserve that (a bare class-name match
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py
index 1da098ff4..334eb5205 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py
@@ -94,7 +94,7 @@ def run_ast_guppy_via_selene(
                 RegisterDecl(name=name, size=info.all_creg_sizes[name]),
             )
     if not record_cregs:
-        # Strict (Codex S1-approach review): an explicit `Return(...)`
+        # Strict: an explicit `Return(...)`
         # with no CRegs (e.g. `Return(q)`) has no measurement record --
         # fail loudly rather than silently mis-shape the result table.
         msg = (
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
index 546103b5a..f6a41223d 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
@@ -2374,7 +2374,7 @@ def __init__(self, a, b) -> None:
             slr_to_ast(prog)
 
     def test_scratch_prep_only_rejected(self) -> None:
-        """Codex S1 review: a PZ with no terminating Measure must be
+        """A PZ with no terminating Measure must be
         rejected -- S2 allocates the scratch qubit internally, so an
         unmeasured trailing PZ diverges from the flatten/QASM path.
         """
@@ -2500,7 +2500,7 @@ def __init__(self, a, out0, out1) -> None:
         assert "measure q[0] -> c[1];" in qasm
 
     def test_scratch_return_rejected(self) -> None:
-        """Codex S1 r2: a scratch-bearing block must contain no ReturnOp.
+        """A scratch-bearing block must contain no ReturnOp.
 
         Post-substitution a returned scratch slot keeps the OUTER name
         (a partial VarExpr passes `whole_name` through unchanged), so it
@@ -2613,7 +2613,7 @@ def __init__(self, d, a, out) -> None:
         }, raw
 
     def test_scratch_outer_slot_misuse_rejected(self) -> None:
-        """Codex S2 r1 blocker 1: a scratch-bound outer slot also used as
+        """A scratch-bound outer slot also used as
         meaningful caller state (gate + later measure) diverges between
         flatten (mutates it) and Guppy (allocates internally) -- reject.
         """
@@ -2677,7 +2677,7 @@ def __init__(self, d, a, out) -> None:
         assert "a_0 = qubit()" in guppy_src
 
     def test_scratch_malformed_arg_rejected_direct_ast(self) -> None:
-        """Codex S2 r1 blocker 2: a scratch BlockArg referencing an
+        """A scratch BlockArg referencing an
         out-of-bounds outer slot must fail loudly -- scratch args are now
         validated (then excluded), not skipped before validation.
         """
@@ -2708,7 +2708,7 @@ def test_scratch_malformed_arg_rejected_direct_ast(self) -> None:
             ast_to_guppy(prog)
 
     def test_scratch_outer_slot_permute_rejected(self) -> None:
-        """Codex S2 r2 blocker 1: a Permute touching the scratch register
+        """A Permute touching the scratch register
         observes/reorders the scratch-bound outer slot -> reject.
         """
         from pecos.slr import Block, CReg, Main, Permute, QReg, Return, SlrConverter
@@ -2739,7 +2739,7 @@ def __init__(self, a, out) -> None:
             SlrConverter(prog).guppy()
 
     def test_scratch_outer_slot_return_rejected(self) -> None:
-        """Codex S2 r2 blocker 2: returning the register that hosts the
+        """Returning the register that hosts the
         scratch-bound slot exposes a slot Guppy left untouched -> reject.
         """
         from pecos.slr import Block, CReg, Main, QReg, Return, SlrConverter
@@ -2767,7 +2767,7 @@ def __init__(self, a, out) -> None:
             SlrConverter(prog).guppy()
 
     def test_scratch_misuse_inside_block_body_rejected(self) -> None:
-        """Codex S2 r2 blocker 3: the purity guard runs per scope -- a
+        """The purity guard runs per scope -- a
         nested scratch BlockCall + misuse of that slot inside a BlockDecl
         body (not just main) must be caught.
         """
@@ -2879,7 +2879,7 @@ def test_steane_syn_extract_bare_selene_records_pinned(self) -> None:
 
     def test_color488_syn_extract_bare_routes_and_runs(self) -> None:
         """Design says the S4 production lock-in is Steane + Color488
-        (Codex S4 review). Color488's serial `SynExtractBare` uses the
+        Color488's serial `SynExtractBare` uses the
         identical generic `Check` call shape -- it must also route every
         Check through a BlockCall, compile, and run.
         """
@@ -2982,7 +2982,7 @@ def test_check1flag_h_branch_compiles_qasm_only(self) -> None:
         """The CH (`ops="H"`) branch hits a non-Clifford R1XY at runtime
         (Selene cannot execute it), so lock in compile + QASM parity
         only: it must still route through a BlockCall and lower cleanly
-        (Codex O1 review -- not a Selene assertion).
+        (structural check -- not a Selene assertion).
         """
         from pecos.slr import CReg, Main, QReg, Return, SlrConverter
         from pecos.slr.ast import slr_to_ast
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_prep_gates.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_prep_gates.py
index 04f8fdec2..f60798b8c 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_prep_gates.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_prep_gates.py
@@ -9,7 +9,7 @@
 # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 # specific language governing permissions and limitations under the License.
 
-"""#81 dedicated prep gates -- BEHAVIORAL suite (post-review bar).
+"""#81 dedicated prep gates -- BEHAVIORAL suite.
 
 The 6 dedicated prep gates `PZ/PNZ/PX/PNX/PY/PNY` (basis is the gate
 IDENTITY, not a string arg) lower to a Z-reset + a fixed Clifford
@@ -21,7 +21,7 @@
       deterministic; assert the fixed bit over shots.
   (c) emitted-tail spot-check (QIR/QASM/QuantumCircuit) -- the
       distinguishing Clifford tail is present per the pinned table.
-  (d) B1 (Codex #81 soundness-critical): a non-PZ prep inside a
+  (d) B1 (#81 soundness-critical): a non-PZ prep inside a
       BlockDecl invoked via BlockCall survives `flatten_block_calls`
       with its basis intact (QASM AND Guppy).
   (e) simulator: the Pn->PN-renamed entry points + human aliases
@@ -118,7 +118,7 @@ def test_prep_gate_emitted_tail(gate: str, needles: dict[str, list[str]]) -> Non
 
 
 def test_b1_blockcall_preserves_prep_basis() -> None:
-    """(d) Codex #81 soundness-critical: a non-PZ prep inside a
+    """(d) #81 soundness-critical: a non-PZ prep inside a
     BlockDecl invoked via BlockCall must keep its basis through
     `flatten_block_calls` -- in QASM AND Guppy. PX = |0> reset + H;
     if the basis were dropped to PZ the H tail would vanish."""
@@ -175,7 +175,7 @@ def __init__(self, q: QReg) -> None:
 @pytest.mark.parametrize(
     ("entry", "meas", "expected"),
     [
-        # Direct canonical keys (Codex blocker: all 6 must dispatch
+        # Direct canonical keys (#81: all 6 must dispatch
         # directly, not only via aliases).
         ("PZ", "MZ", 0),
         ("PNZ", "MZ", 1),
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_tier2_semantic.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_tier2_semantic.py
index 136f832b4..02a80a3e1 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_tier2_semantic.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_tier2_semantic.py
@@ -325,7 +325,7 @@ def run() -> int:
 
 def test_oversize_creg_raises_loud() -> None:
     """A >64-bit CReg must FAIL LOUD at QIR codegen, not silently drop
-    its storage/output (Codex B2 post-review blocker). 64 is the cap
+    its storage/output (#76 B2). 64 is the cap
     (single-i64 record pack); 65 must raise a clear error."""
     ok = Main(q := QReg("q", 1), c := CReg("c", 64), Measure(q[0]) > c[0], Return(c))
     SlrConverter(ok).qir_bc()  # 64 is allowed (boundary)
@@ -366,7 +366,7 @@ def test_print_raises_loud() -> None:
 
 
 def test_static_for_unrolls_body_not_dropped() -> None:
-    """#74 (Codex): a static `For` must UNROLL its body, not silently
+    """#74: a static `For` must UNROLL its body, not silently
     drop it. The old `_process_for` guard `isinstance(node.start, int)`
     was always false (the converter wraps bounds in `LiteralExpr`), so
     every `For` body was silently dropped -- valid QIR, wrong
@@ -420,7 +420,7 @@ def test_prep_stray_string_arg_raises_loud() -> None:
     `PZ(q, "X")`, even `PZ(q, "Z")` -- would be silently dropped
     and lowered as the plain basis (a miscompile, #80/#79). The
     converter rejects ANY stray string qarg on EVERY prep gate
-    (Codex #81 sym rule). A bare prep gate (no string) is fine."""
+    (#81 sym rule). A bare prep gate (no string) is fine."""
     # No-string preps build (PZ default; dedicated gate identity).
     # No-string prep on every dedicated gate builds (basis = identity).
     for prep in (qb.PZ, qb.PNZ, qb.PX, qb.PNX, qb.PY, qb.PNY):
@@ -443,7 +443,7 @@ def test_prep_stray_string_arg_raises_loud() -> None:
 
 
 def test_return_only_inline_creg_raises_loud() -> None:
-    """#80 (Codex post-review blocker): a CReg surfaced ONLY via
+    """#80: a CReg surfaced ONLY via
     `Return(creg)` -- never measured/assigned/read -- reached no
     point-of-use `_require_creg` site, so `_generate_results` (which
     records only Main-declared CRegs) emitted ZERO recorded output
@@ -466,7 +466,7 @@ def test_return_only_inline_creg_raises_loud() -> None:
     ok_q = Main(q := QReg("q", 1), Return(q))
     SlrConverter(ok_q).qir_bc()
 
-    # #80 Codex RE-CONFIRM blocker: an inline CReg whose name
+    # #80: an inline CReg whose name
     # collides with a declared QReg was misclassified as a qubit
     # return by the old name-membership skip and silently dropped
     # (same silent-output-loss class, reachable via public SLR).
@@ -529,7 +529,7 @@ def test_tier2_executable_differential() -> None:
     # Bell: genuinely quantum -> property check, not a fixed value.
     # NECESSARY: every shot records c[0]==c[1] (single record, packed
     # in {0b00, 0b11}, never 1/2) -- a broken/decorrelating CX trips
-    # this. SUFFICIENT (Codex #77 blocker): the aggregate over fixed
+    # this. SUFFICIENT (#77): the aggregate over fixed
     # seeds must contain BOTH 0b00 AND 0b11 -- a dropped H / dropped
     # CX / no-op Bell lowering yields all-0, which a subset-only check
     # (`in {0,3}`) would wrongly pass. Fixed seeds -> deterministic;
diff --git a/scripts/migrate_implicit_return.py b/scripts/migrate_implicit_return.py
index 44a677138..4aaab672c 100644
--- a/scripts/migrate_implicit_return.py
+++ b/scripts/migrate_implicit_return.py
@@ -54,7 +54,7 @@ def _is_result_creg_call(call: cst.Call) -> bool:
     def leave_Call(self, _original: cst.Call, updated: cst.Call) -> cst.BaseExpression:  # noqa: N802
         # Match bare `Main(...)` AND any qualified form (`pecos.slr.Main(...)`,
         # `slr.Main(...)`) -- the func is then an Attribute whose final attr
-        # is `Main` (Codex S1-approach review: qualified calls were missed).
+        # is `Main` (qualified calls were previously missed).
         if not m.matches(
             updated.func,
             m.Name("Main") | m.Attribute(attr=m.Name("Main")),

From ae7ba851cbfadeedcc67b287bc673af2f19911f6 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Tue, 19 May 2026 13:02:01 -0600
Subject: [PATCH 109/136] #93 (cont.): verified QIR lowering for the
 F/Fdg/F4/F4dg face Cliffords

Same verification-first method as the SX/SY subset: extracted each
unitary from the PECOS StateVec sim, searched the EXECUTABLE
Clifford set for a sequence equal up to a global phase, verified
end-to-end through qir_to_qis -> selene. Results (circuit order):
F=SZdg;H, Fdg=H;SZ, F4=H;SZdg, F4dg=SZ;H.

_GATE_DECOMP entries (incl. the existing SX/SXdg) now use
GateKind.SZ/SZdg rather than the redundant S/Sdg aliases, per the
PECOS convention that S==SZ / Sdg==SZdg (both already map to
"s"/"s__adj" in every codegen -- zero functional change;
re-verified). test_face_clifford_gates_executable pins the
end-to-end identities: F;Fdg / Fdg;F / F4;F4dg / F4dg;F4 == I,
the F|0>=|+> non-no-op discriminator, and F;F;F == I (PECOS F is
the order-3 face Clifford).

#71/#79 corpus buckets unchanged. Verified: default 415/0,
optional_dependency 44 passed / 3 xfailed / 0 failed, slow
face+sqrt 2/2 (full slow unaffected), ruff/black-25.9.0 clean.
Remaining #93: 2q Clifford (CY/SXX/SYY/SXXdg/SYYdg/SZZdg) need a
2q decomposition path; CH (non-Clifford) + CRX/CRY/CRZ
(rotations, no executable primitive) stay fail-loud.
---
 .../src/pecos/slr/ast/codegen/qir.py          | 15 +++++++-
 .../ast_guppy/test_qir_corpus_executable.py   | 38 +++++++++++++++++++
 2 files changed, 51 insertions(+), 2 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
index 6ef5d2396..270be28d4 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
@@ -116,10 +116,21 @@
 # subset; F-family/CY/CH/CR*/sqrt-2q gates stay fail-loud pending
 # the scoped verification-first workstream.)
 _GATE_DECOMP: dict[GateKind, tuple[GateKind, ...]] = {
-    GateKind.SX: (GateKind.H, GateKind.S, GateKind.H),
-    GateKind.SXdg: (GateKind.H, GateKind.Sdg, GateKind.H),
+    GateKind.SX: (GateKind.H, GateKind.SZ, GateKind.H),
+    GateKind.SXdg: (GateKind.H, GateKind.SZdg, GateKind.H),
     GateKind.SY: (GateKind.H, GateKind.X),
     GateKind.SYdg: (GateKind.H, GateKind.Z),
+    # #93: the single-qubit Clifford "face" rotations. Same method
+    # as the sqrt-gates above -- searched the executable Clifford
+    # set, verified equal up to a global phase to the PECOS
+    # `StateVec` unitary AND end-to-end via the #79 path
+    # (F;F == F-cubed-is-Fdg identities; F is order-3:
+    # F;F;F == I). Sequences are in circuit order (first applied
+    # first).
+    GateKind.F: (GateKind.SZdg, GateKind.H),
+    GateKind.Fdg: (GateKind.H, GateKind.SZ),
+    GateKind.F4: (GateKind.H, GateKind.SZdg),
+    GateKind.F4dg: (GateKind.SZ, GateKind.H),
 }
 
 # Gates with rotation parameters
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
index 5dd8b9ec4..b26ea76cd 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
@@ -350,3 +350,41 @@ def _run(build):
     assert _run(lambda q: [qb.SYdg(q[0]), qb.SY(q[0])]) == {(0,)}, "SYdg;SY must be identity"
     assert _run(lambda q: [qb.SX(q[0])]) == {(0,), (1,)}, "SX|0> must be Z-random (not a no-op)"
     assert _run(lambda q: [qb.SY(q[0])]) == {(0,), (1,)}, "SY|0> must be Z-random (not a no-op)"
+
+
+@pytest.mark.slow
+@pytest.mark.optional_dependency
+def test_face_clifford_gates_executable() -> None:
+    """#93: the F/Fdg/F4/F4dg QIR lowering EXECUTES correctly.
+
+    The single-qubit Clifford "face" rotations have no direct QIR
+    primitive; #93 lowers them to executable-Clifford sequences
+    (F=Sdg;H, Fdg=H;S, F4=H;Sdg, F4dg=S;H -- circuit order),
+    verified equal up to a global phase to the PECOS StateVec
+    unitary. Pin the end-to-end behavioral proof through
+    QIR -> qir_to_qis -> selene with deterministic, global-phase-
+    immune identities: the inverse pairs collapse to identity, the
+    F|0>=|+> discriminator (a no-op lowering would be Z-random),
+    and F is order-3 (F;F;F == I).
+    """
+
+    def _run(build):
+        q = QReg("q", 1)
+        c = CReg("c", 1)
+        prog = Main(q, c, *build(q), Measure(q[0]) > c[0], Return(c))
+        obs: set[tuple[int, ...]] = set()
+        for seed in _SEEDS:
+            for rec in _qis_exec_records(prog, 1, shots=_SHOTS, seed=seed):
+                obs.add(tuple(rec))
+        return obs
+
+    assert _run(lambda q: [qb.F(q[0]), qb.Fdg(q[0])]) == {(0,)}, "F;Fdg must be identity"
+    assert _run(lambda q: [qb.Fdg(q[0]), qb.F(q[0])]) == {(0,)}, "Fdg;F must be identity"
+    assert _run(lambda q: [qb.F4(q[0]), qb.F4dg(q[0])]) == {(0,)}, "F4;F4dg must be identity"
+    assert _run(lambda q: [qb.F4dg(q[0]), qb.F4(q[0])]) == {(0,)}, "F4dg;F4 must be identity"
+    # F|0> = |+> ; H|+> = |0> -> deterministic 0. A no-op F would
+    # leave H|0> = |+> -> Z-random (the silent-miscompile signature).
+    assert _run(lambda q: [qb.F(q[0]), qb.H(q[0])]) == {(0,)}, "F|0>=|+>, H|+>=|0> -> 0 (F not a no-op)"
+    assert _run(lambda q: [qb.F(q[0])]) == {(0,), (1,)}, "F|0> must be Z-random (not a no-op)"
+    # PECOS F is the order-3 face Clifford: F;F;F == I.
+    assert _run(lambda q: [qb.F(q[0]), qb.F(q[0]), qb.F(q[0])]) == {(0,)}, "F;F;F must be identity (order 3)"

From ca0c6bf8a89ab8ebef8465406b49631859c4c53f Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Tue, 19 May 2026 13:37:57 -0600
Subject: [PATCH 110/136] #95: canonicalize GateKind on SZ/SZdg; remove
 redundant S/Sdg (user-directed)

PECOS convention: the phase gate S == SZ and Sdg == SZdg. GateKind
carried both as redundant members. Per user directive, removed
GateKind.S/Sdg; the SLR `S`/`Sdg` gate classes now map (converter
GATE_KIND_MAP) to the canonical GateKind.SZ/SZdg. Dropped the now
redundant S/Sdg rows from every codegen map (GATE_TO_QIR/STIM/QC/
QASM/guppy -- SZ/SZdg rows already present), type_checker arity,
gate_properties INVERSE_PAIRS (SZ<->SZdg pair remains), and
_prep_tail PY/PNY tails. _GATE_DECOMP already on SZ/SZdg.

Behavior delta (user-decided -- "keep SZ->rz(pi/2)"): the SLR `S`
gate's QASM lowering changes `s q;` -> `rz(pi/2) q;` (and `sdg` ->
`rz(-pi/2)`), since the canonical kind SZ maps to rz(pi/2) in
qasm.py (the only codegen where S != SZ; physically identical, s
== rz(pi/2) up to global phase). All other codegens unchanged
(SZ == S there). #81 PY/PNY prep-tail QASM accordingly flips
h;s -> h;rz(pi/2); test_prep_gate_emitted_tail[PY,PNY] re-pinned
honestly from the actual emitted output (QIR needles unchanged --
SZ->"s" in QIR).

18 GateKind.S/Sdg refs across 10 source files; 0 residual; no test
referenced GateKind.S/Sdg directly. Verified: default 415/0,
optional_dependency 44 passed / 3 xfailed / 0 failed, slow 34/0,
ruff/black-25.9.0 clean. Pending dual review (repo-wide rename +
deliberate QASM delta).
---
 .../src/pecos/slr/ast/codegen/_prep_tail.py         |  4 ++--
 .../src/pecos/slr/ast/codegen/guppy.py              |  2 --
 .../quantum-pecos/src/pecos/slr/ast/codegen/qasm.py |  2 --
 .../quantum-pecos/src/pecos/slr/ast/codegen/qir.py  |  2 --
 .../src/pecos/slr/ast/codegen/quantum_circuit.py    |  2 --
 .../quantum-pecos/src/pecos/slr/ast/codegen/stim.py |  2 --
 python/quantum-pecos/src/pecos/slr/ast/converter.py |  4 ++--
 python/quantum-pecos/src/pecos/slr/ast/nodes.py     |  2 --
 .../pecos/slr/ast/optimizations/gate_properties.py  |  2 --
 .../src/pecos/slr/ast/validation/type_checker.py    |  2 --
 .../tests/slr_tests/ast_guppy/test_prep_gates.py    | 13 +++++++++++--
 11 files changed, 15 insertions(+), 22 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/_prep_tail.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/_prep_tail.py
index cb0758d17..a002c3868 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/_prep_tail.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/_prep_tail.py
@@ -30,8 +30,8 @@
     "PNZ": (GateKind.X,),  # |1>
     "PX": (GateKind.H,),  # |+>
     "PNX": (GateKind.H, GateKind.Z),  # |->
-    "PY": (GateKind.H, GateKind.S),  # |+i>
-    "PNY": (GateKind.H, GateKind.Sdg),  # |-i>
+    "PY": (GateKind.H, GateKind.SZ),  # |+i>
+    "PNY": (GateKind.H, GateKind.SZdg),  # |-i>
 }
 
 
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
index 8d91dd3b1..f103e4b22 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
@@ -86,8 +86,6 @@
     GateKind.Y: "y",
     GateKind.Z: "z",
     GateKind.H: "h",
-    GateKind.S: "s",
-    GateKind.Sdg: "sdg",
     GateKind.T: "t",
     GateKind.Tdg: "tdg",
     GateKind.SZ: "s",
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qasm.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qasm.py
index c508d8118..9546c364b 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qasm.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qasm.py
@@ -80,8 +80,6 @@
     # Hadamard
     GateKind.H: "h",
     # Phase gates
-    GateKind.S: "s",
-    GateKind.Sdg: "sdg",
     GateKind.T: "rz(pi/4)",  # T gate as rotation
     GateKind.Tdg: "rz(-pi/4)",
     # Square root gates
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
index 270be28d4..46e32ee57 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
@@ -84,8 +84,6 @@
     # Hadamard
     GateKind.H: "h",
     # Phase gates
-    GateKind.S: "s",
-    GateKind.Sdg: "s__adj",
     GateKind.T: "t",
     GateKind.Tdg: "t__adj",
     # Square root gates - mapped to S variants
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py
index 6a38252e8..9d1817972 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py
@@ -64,8 +64,6 @@
     # Hadamard
     GateKind.H: "H",
     # Phase gates
-    GateKind.S: "S",
-    GateKind.Sdg: "SDG",
     GateKind.T: "T",
     GateKind.Tdg: "TDG",
     # Square root gates
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/stim.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/stim.py
index 5f9e364a3..792d50996 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/stim.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/stim.py
@@ -65,8 +65,6 @@
     # Hadamard
     GateKind.H: "H",
     # Phase gates
-    GateKind.S: "S",
-    GateKind.Sdg: "S_DAG",
     GateKind.T: "T",
     GateKind.Tdg: "T_DAG",
     # Square root gates (mapped to S variants)
diff --git a/python/quantum-pecos/src/pecos/slr/ast/converter.py b/python/quantum-pecos/src/pecos/slr/ast/converter.py
index af8ce06d5..cac2b24cb 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/converter.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/converter.py
@@ -107,8 +107,8 @@
     # Hadamard
     "H": GateKind.H,
     # Phase gates
-    "S": GateKind.S,
-    "Sdg": GateKind.Sdg,
+    "S": GateKind.SZ,
+    "Sdg": GateKind.SZdg,
     "T": GateKind.T,
     "Tdg": GateKind.Tdg,
     # Square root gates
diff --git a/python/quantum-pecos/src/pecos/slr/ast/nodes.py b/python/quantum-pecos/src/pecos/slr/ast/nodes.py
index 385db1091..dcffe5890 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/nodes.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/nodes.py
@@ -93,8 +93,6 @@ class GateKind(Enum):
     H = auto()
 
     # Phase gates
-    S = auto()
-    Sdg = auto()
     T = auto()
     Tdg = auto()
 
diff --git a/python/quantum-pecos/src/pecos/slr/ast/optimizations/gate_properties.py b/python/quantum-pecos/src/pecos/slr/ast/optimizations/gate_properties.py
index 659ec0951..264d497d0 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/optimizations/gate_properties.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/optimizations/gate_properties.py
@@ -40,8 +40,6 @@
 
 # Mapping from gate to its inverse
 INVERSE_PAIRS: dict[GateKind, GateKind] = {
-    GateKind.S: GateKind.Sdg,
-    GateKind.Sdg: GateKind.S,
     GateKind.T: GateKind.Tdg,
     GateKind.Tdg: GateKind.T,
     GateKind.SX: GateKind.SXdg,
diff --git a/python/quantum-pecos/src/pecos/slr/ast/validation/type_checker.py b/python/quantum-pecos/src/pecos/slr/ast/validation/type_checker.py
index 727b4ddd8..9d125d056 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/validation/type_checker.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/validation/type_checker.py
@@ -73,8 +73,6 @@
     GateKind.Y: 1,
     GateKind.Z: 1,
     GateKind.H: 1,
-    GateKind.S: 1,
-    GateKind.Sdg: 1,
     GateKind.T: 1,
     GateKind.Tdg: 1,
     GateKind.SX: 1,
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_prep_gates.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_prep_gates.py
index f60798b8c..9582ac337 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_prep_gates.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_prep_gates.py
@@ -97,11 +97,20 @@ def test_prep_gate_selene_guppy(gate: str) -> None:
         ),
         (
             "PY",
-            {"qir": ["reset", "__quantum__qis__h__body", "__quantum__qis__s__body"], "qasm": ["reset ", "h ", "s "]},
+            # GateKind canonicalised to SZ/SZdg (S/Sdg removed): QIR
+            # SZ->"s" (unchanged); QASM SZ->"rz(pi/2)" (the chosen
+            # phase-gate QASM lowering -- s == rz(pi/2) up to phase).
+            {
+                "qir": ["reset", "__quantum__qis__h__body", "__quantum__qis__s__body"],
+                "qasm": ["reset ", "h ", "rz(pi/2)"],
+            },
         ),
         (
             "PNY",
-            {"qir": ["reset", "__quantum__qis__h__body", "__quantum__qis__s__adj"], "qasm": ["reset ", "h ", "sdg "]},
+            {
+                "qir": ["reset", "__quantum__qis__h__body", "__quantum__qis__s__adj"],
+                "qasm": ["reset ", "h ", "rz(-pi/2)"],
+            },
         ),
     ],
 )

From 9f797ccd4d12a109771f97947db68272e3bf6c99 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Tue, 19 May 2026 14:54:39 -0600
Subject: [PATCH 111/136] test hygiene: dedupe the repeated QC expected-string
 into a local (behavior-identical; clears the dirty worktree the #93/#95
 reviewers flagged)

---
 .../slr_tests/pecos/unit/slr/test_quantum_permutation.py     | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_permutation.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_permutation.py
index 1f9e3af01..273b19236 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_permutation.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_permutation.py
@@ -304,12 +304,13 @@ def test_permute_realized_quantum_circuit() -> None:
     b = QReg("b", 2)
     elem = Main(a, b, qubit.H(a[0]), qubit.X(b[0]), Permute([a[0], b[0]], [b[0], a[0]]), qubit.Y(a[0]), qubit.Z(b[0]))
     # a=0,1 b=2,3. After a[0]<->b[0]: Y(a[0])->q2, Z(b[0])->q0.
-    assert str(SlrConverter(elem).quantum_circuit()) == "QuantumCircuit([{'H': {0}}, {'X': {2}}, {'Y': {2}}, {'Z': {0}}])"
+    expected = "QuantumCircuit([{'H': {0}}, {'X': {2}}, {'Y': {2}}, {'Z': {0}}])"
+    assert str(SlrConverter(elem).quantum_circuit()) == expected
 
     a = QReg("a", 2)
     b = QReg("b", 2)
     whole = Main(a, b, qubit.H(a[0]), qubit.X(b[0]), Permute(a, b), qubit.Y(a[0]), qubit.Z(b[0]))
-    assert str(SlrConverter(whole).quantum_circuit()) == "QuantumCircuit([{'H': {0}}, {'X': {2}}, {'Y': {2}}, {'Z': {0}}])"
+    assert str(SlrConverter(whole).quantum_circuit()) == expected
 
     # Non-bijective must fail loud, not silently mis-resolve.
     a = QReg("a", 2)

From c5cb87ea06094cbd1c015783ca546c7429786172 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Tue, 19 May 2026 22:51:03 -0600
Subject: [PATCH 112/136] #93 cont.: verified QIR lowering for
 SZZ/SZZdg/SXX/SXXdg/SYY/SYYdg/CY (7 2q Cliffords)

Per ~/Repos/qir-qis/src/lib.rs:59 (ALLOWED_QIS_FNS, 23 functions):
the qir-qis native 2q gate is rzz (parameterized) -- there is NO
zz/szz in the allowlist (the prior `GATE_TO_QIR[SZZ]="zz"` emitted
`__quantum__qis__zz__body` which qir-qis rejects with
"Unsupported QIR QIS function"). Quantinuum supports ZZ-flavor
entanglement natively, just as `rzz`. Fixed:

- Removed the misleading `GateKind.SZZ: "zz"` from `GATE_TO_QIR`
  (and `SZZ` from `TWO_QUBIT_GATES`) -- no more misleading
  codegen surface.
- Extended `_GATE_DECOMP` to a 2q-capable shape: each step is
  (prim_kind, qubit_idx_tuple, params_tuple); `_process_gate`
  emits each step with the input gate's targets routed and
  constant params threaded.
- Added 7 verified decompositions:
    SZZ   = RZZ(pi/2)(q0,q1)
    SZZdg = RZZ(-pi/2)(q0,q1)
    SXX   = (H@H); RZZ(pi/2); (H@H)
    SXXdg = (H@H); RZZ(-pi/2); (H@H)
    SYY   = (Sdg@Sdg);(H@H); RZZ(pi/2); (H@H);(S@S)
    SYYdg = (Sdg@Sdg);(H@H); RZZ(-pi/2); (H@H);(S@S)
    CY    = Sdg(t); CX(c,t); S(t)
  Each VERIFIED up-to-global-phase against the PECOS StateVec
  unitary AND end-to-end via qir_to_qis -> selene (inverse pairs,
  CY|10> -> i|11> non-vacuity, SZZ^2 = Z discriminator).
- `test_sqrt_pauli_2q_gates_executable` (slow+optional_dependency)
  pins the end-to-end identities.

Methodology correction recorded earlier in memory: my prior "rx is
a silent no-op on the Stim backend" claim was wrong (probe-harness
bug). RX/RY/RZ/RZZ all execute correctly. The truly misleading
surface was only SZZ -> "zz" (now fixed).

#71 honest re-pin: BUILD_FAILED 7 -> 5, QIS_OK 22 -> 24
(generic_check_xyz / generic_check_1flag_ch use CY which now
lowers, so they re-enter QIS_OK). #79 manifest updated: both
classified X (XYZ stabiliser on |0..0> is not an eigenstate ->
single uniformly random syndrome bit; no hard invariant);
histogram pin D=3/P=8/X=11 -> X=13.

Verified: default 415/0, optional_dependency 44 passed / 3
xfailed / 0 failed, slow 28/0 (24 QIS_OK + manifest guard +
sqrt/face/sqrt_pauli_2q behavioral), ruff/black-25.9.0 clean.

Remaining #93 (still fail-loud, no PECOS sim oracle): CH (sim
doesn't support), CRX/CRY/CRZ (parameterized, sim doesn't
support) -- decomposition would require a convention pin without
a verification oracle. Surfaced for separate scope.
---
 .../src/pecos/slr/ast/codegen/qir.py          | 132 ++++++++++++------
 .../ast_guppy/test_qir_corpus_executable.py   |  75 +++++++++-
 .../ast_guppy/test_qir_spec_compliance.py     |  39 +++---
 3 files changed, 186 insertions(+), 60 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
index 46e32ee57..9b8acfcbd 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
@@ -25,6 +25,7 @@
 
 from __future__ import annotations
 
+import math
 import re
 from dataclasses import dataclass, field, replace
 from typing import TYPE_CHECKING, Any
@@ -93,49 +94,96 @@
     GateKind.RX: "rx",
     GateKind.RY: "ry",
     GateKind.RZ: "rz",
-    # Two-qubit gates
+    # Two-qubit gates -- only the qir-qis ALLOWED_QIS_FNS that
+    # actually execute through `qir_to_qis -> selene`. The native
+    # Quantinuum 2q is `rzz` (parameterized); `__quantum__qis__zz__body`
+    # is NOT in the allowlist (cf. ~/Repos/qir-qis/src/lib.rs:59).
+    # SZZ/SZZdg/SXX/SXXdg/SYY/SYYdg are lowered via `_GATE_DECOMP`
+    # to RZZ + 1q Cliffords (verified up-to-phase + end-to-end).
     GateKind.CX: "cnot",
     GateKind.CZ: "cz",
     GateKind.RZZ: "rzz",
-    GateKind.SZZ: "zz",
 }
 
-# Single-qubit Clifford sqrt-gates with no direct QIR primitive,
-# lowered to an EXECUTABLE-Clifford sequence (h/s/s__adj/x/z only --
-# NOT rx/ry/rz: `__quantum__qis__rx__body` is a pinned build/exec
-# failure (`docs.rotation_rx`), and selene's Stim backend silently
-# no-ops an rx, so a rotation lowering would be a silent miscompile).
-# Each sequence was found by searching the executable Clifford set
-# and VERIFIED equal (up to a global phase, unobservable for
-# measurement-terminated circuits) to the PECOS `StateVec`
-# simulator's authoritative unitary, AND verified end-to-end via the
-# #79 executable path (qir_to_qis -> selene): SX;SX == X,
-# SXdg;SX == I, SY;SY == Y, SYdg;SY == I. (#93: only this verified
-# subset; F-family/CY/CH/CR*/sqrt-2q gates stay fail-loud pending
-# the scoped verification-first workstream.)
-_GATE_DECOMP: dict[GateKind, tuple[GateKind, ...]] = {
-    GateKind.SX: (GateKind.H, GateKind.SZ, GateKind.H),
-    GateKind.SXdg: (GateKind.H, GateKind.SZdg, GateKind.H),
-    GateKind.SY: (GateKind.H, GateKind.X),
-    GateKind.SYdg: (GateKind.H, GateKind.Z),
-    # #93: the single-qubit Clifford "face" rotations. Same method
-    # as the sqrt-gates above -- searched the executable Clifford
-    # set, verified equal up to a global phase to the PECOS
-    # `StateVec` unitary AND end-to-end via the #79 path
-    # (F;F == F-cubed-is-Fdg identities; F is order-3:
-    # F;F;F == I). Sequences are in circuit order (first applied
-    # first).
-    GateKind.F: (GateKind.SZdg, GateKind.H),
-    GateKind.Fdg: (GateKind.H, GateKind.SZ),
-    GateKind.F4: (GateKind.H, GateKind.SZdg),
-    GateKind.F4dg: (GateKind.SZ, GateKind.H),
+# Decomposition table: a sequence of (primitive_kind, qubit_idx_tuple,
+# params_tuple) steps. Each step's qubit_idx_tuple indexes into the
+# input gate's `targets`; params_tuple is the (constant) angles for a
+# parameterized primitive (RZZ). Every entry was found by extracting
+# the gate's authoritative unitary from `pecos.simulators.StateVec`,
+# searching/deriving a decomposition into ONLY the qir-qis ALLOWED
+# primitive set (`h, x, y, z, s, s__adj, t, t__adj, rx, ry, rz, rzz,
+# cx, cz`), verifying it equal up to a GLOBAL PHASE (unobservable for
+# measurement-terminated circuits) to the PECOS unitary, AND
+# verifying it end-to-end through `qir_to_qis -> selene` with
+# discriminating deterministic identities (a no-op lowering would
+# fail). Sequences are in CIRCUIT order (first applied first).
+_DecompStep = tuple[GateKind, tuple[int, ...], tuple[float, ...]]
+_GATE_DECOMP: dict[GateKind, tuple[_DecompStep, ...]] = {
+    # ---- single-qubit Clifford sqrt + face rotations (#93) ----
+    GateKind.SX: ((GateKind.H, (0,), ()), (GateKind.SZ, (0,), ()), (GateKind.H, (0,), ())),
+    GateKind.SXdg: ((GateKind.H, (0,), ()), (GateKind.SZdg, (0,), ()), (GateKind.H, (0,), ())),
+    GateKind.SY: ((GateKind.H, (0,), ()), (GateKind.X, (0,), ())),
+    GateKind.SYdg: ((GateKind.H, (0,), ()), (GateKind.Z, (0,), ())),
+    GateKind.F: ((GateKind.SZdg, (0,), ()), (GateKind.H, (0,), ())),
+    GateKind.Fdg: ((GateKind.H, (0,), ()), (GateKind.SZ, (0,), ())),
+    GateKind.F4: ((GateKind.H, (0,), ()), (GateKind.SZdg, (0,), ())),
+    GateKind.F4dg: ((GateKind.SZ, (0,), ()), (GateKind.H, (0,), ())),
+    # ---- two-qubit Clifford gates (#93 cont.) ----
+    # SZZ/SZZdg directly via the native parameterized rzz.
+    GateKind.SZZ: ((GateKind.RZZ, (0, 1), (math.pi / 2,)),),
+    GateKind.SZZdg: ((GateKind.RZZ, (0, 1), (-math.pi / 2,)),),
+    # SXX = (H⊗H)·SZZ·(H⊗H); SXXdg with -π/2.
+    GateKind.SXX: (
+        (GateKind.H, (0,), ()),
+        (GateKind.H, (1,), ()),
+        (GateKind.RZZ, (0, 1), (math.pi / 2,)),
+        (GateKind.H, (0,), ()),
+        (GateKind.H, (1,), ()),
+    ),
+    GateKind.SXXdg: (
+        (GateKind.H, (0,), ()),
+        (GateKind.H, (1,), ()),
+        (GateKind.RZZ, (0, 1), (-math.pi / 2,)),
+        (GateKind.H, (0,), ()),
+        (GateKind.H, (1,), ()),
+    ),
+    # SYY = (S⊗S)·(H⊗H)·SZZ·(H⊗H)·(Sdg⊗Sdg) since Y = S·X·S† and
+    # XX = (H⊗H)·ZZ·(H⊗H). SYYdg with -π/2.
+    GateKind.SYY: (
+        (GateKind.SZdg, (0,), ()),
+        (GateKind.SZdg, (1,), ()),
+        (GateKind.H, (0,), ()),
+        (GateKind.H, (1,), ()),
+        (GateKind.RZZ, (0, 1), (math.pi / 2,)),
+        (GateKind.H, (0,), ()),
+        (GateKind.H, (1,), ()),
+        (GateKind.SZ, (0,), ()),
+        (GateKind.SZ, (1,), ()),
+    ),
+    GateKind.SYYdg: (
+        (GateKind.SZdg, (0,), ()),
+        (GateKind.SZdg, (1,), ()),
+        (GateKind.H, (0,), ()),
+        (GateKind.H, (1,), ()),
+        (GateKind.RZZ, (0, 1), (-math.pi / 2,)),
+        (GateKind.H, (0,), ()),
+        (GateKind.H, (1,), ()),
+        (GateKind.SZ, (0,), ()),
+        (GateKind.SZ, (1,), ()),
+    ),
+    # CY = Sdg(target); CX(control,target); S(target).
+    GateKind.CY: (
+        (GateKind.SZdg, (1,), ()),
+        (GateKind.CX, (0, 1), ()),
+        (GateKind.SZ, (1,), ()),
+    ),
 }
 
 # Gates with rotation parameters
 PARAMETERIZED_GATES = {GateKind.RX, GateKind.RY, GateKind.RZ, GateKind.RZZ}
 
 # Two-qubit gates
-TWO_QUBIT_GATES = {GateKind.CX, GateKind.CZ, GateKind.RZZ, GateKind.SZZ}
+TWO_QUBIT_GATES = {GateKind.CX, GateKind.CZ, GateKind.RZZ}
 
 
 @dataclass
@@ -485,14 +533,18 @@ def _process_gate(self, node: GateOp) -> None:
         """Process a gate operation."""
         qir_name = GATE_TO_QIR.get(node.gate)
         if qir_name is None and node.gate in _GATE_DECOMP:
-            # #93: a single-qubit Clifford sqrt-gate with no direct
-            # QIR primitive -- emit its verified executable-Clifford
-            # sequence (same target), each primitive in order.
-            for prim_kind in _GATE_DECOMP[node.gate]:
-                self._process_single_qubit_gate(
-                    replace(node, gate=prim_kind, params=()),
-                    GATE_TO_QIR[prim_kind],
-                )
+            # #93: a gate with no direct QIR primitive but a verified
+            # decomposition into the qir-qis ALLOWED primitive set.
+            # Emit each step in circuit order, routing its qubits
+            # through the input gate's `targets` and threading any
+            # constant params (e.g. RZZ angles).
+            for prim_kind, idxs, params in _GATE_DECOMP[node.gate]:
+                prim_targets = tuple(node.targets[i] for i in idxs)
+                prim_node = replace(node, gate=prim_kind, targets=prim_targets, params=params)
+                if prim_kind in TWO_QUBIT_GATES:
+                    self._process_two_qubit_gate(prim_node, GATE_TO_QIR[prim_kind])
+                else:
+                    self._process_single_qubit_gate(prim_node, GATE_TO_QIR[prim_kind])
             return
         if qir_name is None:
             # #88A (the broad class #78 deferred): a gate with no
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
index b26ea76cd..c630ce578 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
@@ -244,6 +244,23 @@ def _high_bits_zero_1(obs: set[tuple[int, ...]]) -> None:
         "independent decoder oracle; asserting one would ship false "
         "confidence and reverse-fitting is the forbidden anti-pattern",
     ),
+    # #93 cont.: newly QIS_OK after the verified CY decomposition.
+    # Both run the "XYZ" stabiliser check (X-Y-Z product) on |0..0>;
+    # |0..0> is NOT an eigenstate of X_0 . Y_1 . Z_2 (only of
+    # Z_0 . Z_1 . Z_2), so the recorded syndrome bit is uniformly
+    # random -- no deterministic value or hard invariant for #79.
+    # (Pickle's pre-CY classification as D `[0]` was correct only
+    # under the silent-CY-drop miscompile; with the real CY lowering
+    # in place, the honest class is X.)
+    "qeclib.generic_check_xyz": (
+        "X",
+        "XYZ stabiliser check on |0..0>: not an eigenstate -> single "
+        "uniformly random syndrome bit; no hard invariant.",
+    ),
+    "qeclib.generic_check_1flag_ch": (
+        "X",
+        "XYZ flagged stabiliser check on |0..0>: same; single uniformly random syndrome bit; no hard invariant.",
+    ),
 }
 
 
@@ -269,7 +286,7 @@ def test_qir_corpus_manifest_covers_qis_ok() -> None:
     stale = set(_MANIFEST) - qis_ok
     assert not stale, f"manifest entries no longer QIS_OK (remove/retriage): {sorted(stale)}"
     hist = {cls: sum(1 for c, _ in _MANIFEST.values() if c == cls) for cls in ("D", "P", "X")}
-    assert hist == {"D": 3, "P": 8, "X": 11}, f"manifest class histogram changed (deliberate?): {hist}"
+    assert hist == {"D": 3, "P": 8, "X": 13}, f"manifest class histogram changed (deliberate?): {hist}"
 
 
 @pytest.mark.slow
@@ -388,3 +405,59 @@ def _run(build):
     assert _run(lambda q: [qb.F(q[0])]) == {(0,), (1,)}, "F|0> must be Z-random (not a no-op)"
     # PECOS F is the order-3 face Clifford: F;F;F == I.
     assert _run(lambda q: [qb.F(q[0]), qb.F(q[0]), qb.F(q[0])]) == {(0,)}, "F;F;F must be identity (order 3)"
+
+
+@pytest.mark.slow
+@pytest.mark.optional_dependency
+def test_sqrt_pauli_2q_gates_executable() -> None:
+    """#93 cont.: SZZ/SZZdg/SXX/SXXdg/SYY/SYYdg/CY EXECUTE correctly.
+
+    These have no direct qir-qis primitive; #93 lowers them to
+    decompositions over the qir-qis ALLOWED set (verified up-to-phase
+    against the PECOS StateVec unitary). Pin the end-to-end
+    behavioural proof through QIR -> qir_to_qis -> selene with
+    deterministic, global-phase-immune identities:
+      - inverse pairs collapse to I on |00> (G;Gdg -> 0);
+      - CY|10> -> i|11>, so measuring q1 after `X q0; CY` is 1
+        (a no-op CY would give 0 -- the silent-miscompile signature);
+      - CY|00> -> |00> (no effect when control=0);
+      - SZZ^2 with q1=|0> acts as Z on q0; H;SZZ;SZZ;H|0> -> 1
+        (HZH=X; a no-op SZZ would give 0).
+    """
+
+    def _run(prep, ops, meas_idx=0):
+        q = QReg("q", 2)
+        c = CReg("c", 1)
+        prog = Main(q, c, *[g(q) for g in prep], *[g(q) for g in ops], Measure(q[meas_idx]) > c[0], Return(c))
+        obs: set[tuple[int, ...]] = set()
+        for seed in _SEEDS:
+            for rec in _qis_exec_records(prog, 2, shots=_SHOTS, seed=seed):
+                obs.add(tuple(rec))
+        return obs
+
+    szz = lambda q: qb.SZZ(q[0], q[1])  # noqa: E731
+    szzdg = lambda q: qb.SZZdg(q[0], q[1])  # noqa: E731
+    sxx = lambda q: qb.SXX(q[0], q[1])  # noqa: E731
+    sxxdg = lambda q: qb.SXXdg(q[0], q[1])  # noqa: E731
+    syy = lambda q: qb.SYY(q[0], q[1])  # noqa: E731
+    syydg = lambda q: qb.SYYdg(q[0], q[1])  # noqa: E731
+    cy = lambda q: qb.CY(q[0], q[1])  # noqa: E731
+    x_q0 = lambda q: qb.X(q[0])  # noqa: E731
+    h_q0 = lambda q: qb.H(q[0])  # noqa: E731
+
+    # Inverse pairs on |00> -> I -> 0
+    assert _run([], [szz, szzdg]) == {(0,)}, "SZZ;SZZdg must be I on |00>"
+    assert _run([], [szzdg, szz]) == {(0,)}, "SZZdg;SZZ must be I"
+    assert _run([], [sxx, sxxdg]) == {(0,)}, "SXX;SXXdg must be I on |00>"
+    assert _run([], [sxxdg, sxx]) == {(0,)}, "SXXdg;SXX must be I"
+    assert _run([], [syy, syydg]) == {(0,)}, "SYY;SYYdg must be I on |00>"
+    assert _run([], [syydg, syy]) == {(0,)}, "SYYdg;SYY must be I"
+
+    # CY non-vacuity: X q0; CY; M q1 -> 1 (Y|0>=i|1>; no-op would give 0).
+    assert _run([x_q0], [cy], meas_idx=1) == {(1,)}, "X q0; CY -> q1 must be 1 (CY not a no-op)"
+    # CY|00>: control=0, no effect; measure q1 -> 0.
+    assert _run([], [cy], meas_idx=1) == {(0,)}, "CY|00> -> q1 must be 0"
+
+    # SZZ^2 discriminator: H;SZZ;SZZ;H q0 with q1=|0> -> 1 (Z on q0; HZH=X).
+    # A no-op SZZ would give 0.
+    assert _run([h_q0], [szz, szz, h_q0]) == {(1,)}, "H;SZZ;SZZ;H must be X on q0 (SZZ not a no-op)"
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
index f3f558f41..3c25d93d8 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
@@ -39,7 +39,7 @@
 `mz__body` -> static `%Result*` -> `read_result` -> `store`;
 point-of-use `gep`+`load`/`store`; `zext`/`shl`/`or` pack ->
 `__quantum__rt__int_record_output`). Every validate-passing program
-(`_EXPECTED_QIS_OK`, n=22) now lowers via `qir_to_qis`; `qis_failed`
+(`_EXPECTED_QIS_OK`, n=24) now lowers via `qir_to_qis`; `qis_failed`
 is empty. A NEW qir_to_qis failure -- or a dropped program -- trips
 this deliberately. (`docs.while_loop` was in this set pre-#74 on a
 silently-wrong single-pass approximation; #74 makes the QIR backend
@@ -56,7 +56,7 @@
 #79 generalises it corpus-wide; this structural gate provides
 that suite's authoritative QIS_OK set.
 
-**Build failures** (7): `qir_bc()` raises for
+**Build failures** (5): `qir_bc()` raises for
 `docs.for_loopvar_symbolic` (symbolic `LoopVar` indexing) /
 `docs.rotation_rx` (`rx` gate) -- pre-existing AST-QIR feature
 gaps; `docs.while_loop` (#74: the QIR backend now fails LOUD
@@ -85,10 +85,12 @@
 they add no build-failure pin -- but they are no longer silent
 miscompiles. #88A (the broad unsupported-gate class #78
 deferred) makes `_process_gate` fail loud on any gate with no
-`GATE_TO_QIR` entry (was a silent drop). The two generic-check
-factories use the "XYZ" Check whose Y branch emits `CY` (no
-QIR lowering); they moved QIS_OK -> here (24 -> 22), re-pinned
-from the actual `_qir_state()`.
+QIR lowering (was a silent drop); subsequent verified lowerings
+move gates *off* fail-loud. #93 cont. added the verified
+CY=Sdg;CX;S decomposition (and SZZ/SXX/SYY (+adjoints) via
+RZZ), so the two generic-check factories (use `CY`) moved
+BUILD_FAILED -> QIS_OK (22 -> 24), re-pinned from the actual
+`_qir_state()`.
 
 `qir-qis` is a `[dependency-groups].test` dep (default-groups
 includes `test`), so this runs in the default sweep.
@@ -131,16 +133,12 @@
     #    from the actual `_qir_state()`, never guessed).
     "docs.inline_measure_creg": ("NotImplementedError", "was not declared at Main scope"),
     "docs.surface_syndrome_block18": ("NotImplementedError", "was not declared at Main scope"),
-    # #88A: the broad unsupported-gate-silent-drop class #78 deferred.
-    # A gate with no GATE_TO_QIR entry was SILENTLY DROPPED (#74-class
-    # silent miscompile -- valid QIR, wrong semantics, qir-qis-
-    # uncatchable). `_process_gate` now fails LOUD. Both generic-check
-    # factories use the "XYZ" Pauli-basis Check, whose Y branch emits
-    # `CY` (controlled-Y, no QIR lowering); they were dishonestly
-    # QIS_OK on the silent-drop miscompile and are re-pinned here from
-    # the ACTUAL `_qir_state()` (never guessed), QIS_OK 24 -> 22.
-    "qeclib.generic_check_xyz": ("NotImplementedError", "has no QIR lowering"),
-    "qeclib.generic_check_1flag_ch": ("NotImplementedError", "has no QIR lowering"),
+    # #93 cont.: the "XYZ" generic_check programs (use `CY`) were
+    # BUILD_FAILED under #88A on `gate 'CY' has no QIR lowering`. #93
+    # added a verified CY decomposition (CY = Sdg(t); CX; S(t)), so
+    # they now build and run -- moved BUILD_FAILED -> QIS_OK
+    # (re-pinned from the actual `_qir_state()`, never guessed):
+    # BUILD_FAILED 7 -> 5; QIS_OK 22 -> 24.
 }
 
 # Tier 1: the non-metadata `validate_qir` failures (label -> stable,
@@ -161,7 +159,7 @@
 
 # Tier 2: post-B2, EVERY validate-passing program lowers via
 # `qir_to_qis` (M-B2-static replaced the bespoke CReg helpers).
-# This is the full set (n=22); `qis_failed` must be empty. A new
+# This is the full set (n=24); `qis_failed` must be empty. A new
 # qir_to_qis failure -- or a dropped/added program -- trips the
 # Tier-2 assertions and must be triaged deliberately.
 _EXPECTED_QIS_OK: frozenset[str] = frozenset(
@@ -183,8 +181,11 @@
         "legacy.nested_blocks",
         "legacy.partial_consumption_with_block",
         "qeclib.color488_syn_extract_bare",
-        # #88A: qeclib.generic_check_1flag_ch / generic_check_xyz moved
-        # QIS_OK -> _EXPECTED_BUILD_FAILED (silent `CY` drop now loud).
+        # #93 cont.: the "XYZ" generic_check programs (use `CY`) now
+        # build via the verified CY=Sdg;CX;S decomposition -- moved
+        # _EXPECTED_BUILD_FAILED -> here.
+        "qeclib.generic_check_1flag_ch",
+        "qeclib.generic_check_xyz",
         "qeclib.generic_transversal_cx",
         "qeclib.surface_patch_builder_empty",
         "qeclib.surface_std_pz",

From 469f6b3c012a0298078e2131680fa3456f6674a5 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Tue, 19 May 2026 23:47:26 -0600
Subject: [PATCH 113/136] #93 post-review fold (Codex blocker): add
 phase-sensitive CY interference assertion

Codex post-review NO -- 1 blocker: the committed CY executable
test (X q0; CY; M q1 -> 1; CY|00>; M q1 -> 0) does not
discriminate the CY target-phase decomposition. Mutation probe
(swap CY's `Sdg(t); CX; S(t)` -> `S(t); CX; S(t)`) SURVIVED the
test, violating the prompt's explicit non-vacuity requirement.
Pickle YES (the unitary verification covers it; the e2e is a
secondary guard) -- but the test should still fail under that
mutation per the prompt + branch discipline.

Folded: added the phase-sensitive interference assertion Codex
prescribed -- `H q1; CY(q0, q1); H q1; MZ q1` with q0=|0> must
give 0. Verified: committed PASSes; the mutated S;CX;S CY
decomposition now FAILS the test (the assertion message names
the exact mutation it catches). Mechanism: with q0=|0> the
correct CY is identity, so H;I;H = I -> 0; the mutated S;CX;S
applies S^2 = Z on q1 even when control=0 (since CX is identity
then), giving H;Z;H = X -> 1.

Verified: default 415/0, optional_dependency 44 passed / 3
xfailed / 0 failed, slow sqrt_pauli_2q PASSes, ruff/black clean.
---
 .../ast_guppy/test_qir_corpus_executable.py        | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
index c630ce578..3eeb5e0d2 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
@@ -458,6 +458,20 @@ def _run(prep, ops, meas_idx=0):
     # CY|00>: control=0, no effect; measure q1 -> 0.
     assert _run([], [cy], meas_idx=1) == {(0,)}, "CY|00> -> q1 must be 0"
 
+    # CY phase-sensitive interference discriminator:
+    # H q1; CY(q0,q1); H q1; M q1 with q0=|0> -> 0 for the correct
+    # Sdg;CX;S decomposition (CY is identity when control=0, so
+    # H;I;H = I -> 0). A wrong-phase decomposition like S;CX;S
+    # applies (Sdg.S);S=S^2=Z on the target even with control=0
+    # (since CX is identity when control=0), giving H;Z;H=X -> 1.
+    # The simpler computational-basis CY checks above don't catch
+    # this -- this assertion is what makes the test discriminate
+    # the target-phase decomposition.
+    h_q1 = lambda q: qb.H(q[1])  # noqa: E731
+    assert _run([h_q1], [cy, h_q1], meas_idx=1) == {
+        (0,)
+    }, "H q1; CY; H q1 with q0=|0> must give 0 -- a wrong-phase CY decomposition (e.g. S;CX;S) gives 1"
+
     # SZZ^2 discriminator: H;SZZ;SZZ;H q0 with q1=|0> -> 1 (Z on q0; HZH=X).
     # A no-op SZZ would give 0.
     assert _run([h_q0], [szz, szz, h_q0]) == {(1,)}, "H;SZZ;SZZ;H must be X on q0 (SZZ not a no-op)"

From d8c98eda48633761dc517d03eb544060c8edf5e0 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Wed, 20 May 2026 08:27:38 -0600
Subject: [PATCH 114/136] #93 re-confirm fold (Codex blocker): COM812 trailing
 comma on the new CY assertion

Codex re-confirm NO -- 1 trivial blocker: the folded CY
interference assertion's multi-line set literal `{\n (0,)\n}`
(black-reformatted) triggers ruff COM812. The assertion was
semantically correct (Codex verified it catches both the
prescribed `S;CX;S` mutation AND the symmetric `Sdg;CX;Sdg`),
but `uv run ruff` (the project version, the authoritative gate
-- distinct from `uvx ruff@latest` which didn't flag it) was
red. Added the trailing comma via `ruff --fix`. Lanes unchanged:
default 415/0, optional_dependency 44/3xf/0, slow sqrt_pauli_2q
1/0; ruff + black-25.9.0 clean.
---
 .../tests/slr_tests/ast_guppy/test_qir_corpus_executable.py     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
index 3eeb5e0d2..ccaaa76cb 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
@@ -469,7 +469,7 @@ def _run(prep, ops, meas_idx=0):
     # the target-phase decomposition.
     h_q1 = lambda q: qb.H(q[1])  # noqa: E731
     assert _run([h_q1], [cy, h_q1], meas_idx=1) == {
-        (0,)
+        (0,),
     }, "H q1; CY; H q1 with q0=|0> must give 0 -- a wrong-phase CY decomposition (e.g. S;CX;S) gives 1"
 
     # SZZ^2 discriminator: H;SZZ;SZZ;H q0 with q1=|0> -> 1 (Z on q0; HZH=X).

From 1087e4b1bf6f33e20d56b8301f0772de72dbec60 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Wed, 20 May 2026 14:27:05 -0600
Subject: [PATCH 115/136] #93 cont.: verified 1-CX QIR lowering for CH
 (non-Clifford -- Quest backend)

---
 .../src/pecos/slr/ast/codegen/qir.py          | 31 +++++++--
 .../ast_guppy/test_qir_corpus_executable.py   | 69 +++++++++++++++++++
 .../ast_guppy/test_tier2_semantic.py          | 38 +++++++---
 3 files changed, 122 insertions(+), 16 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
index 9b8acfcbd..ec1779142 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
@@ -108,15 +108,21 @@
 # Decomposition table: a sequence of (primitive_kind, qubit_idx_tuple,
 # params_tuple) steps. Each step's qubit_idx_tuple indexes into the
 # input gate's `targets`; params_tuple is the (constant) angles for a
-# parameterized primitive (RZZ). Every entry was found by extracting
-# the gate's authoritative unitary from `pecos.simulators.StateVec`,
+# parameterized primitive (RZZ, RY, RX, RZ). Every entry was found by
+# extracting the gate's authoritative unitary from
+# `pecos.simulators.StateVec` (or the canonical matrix oracle in
+# `tests/pecos/integration/state_sim_tests/gate_matrix_def.py`),
 # searching/deriving a decomposition into ONLY the qir-qis ALLOWED
 # primitive set (`h, x, y, z, s, s__adj, t, t__adj, rx, ry, rz, rzz,
-# cx, cz`), verifying it equal up to a GLOBAL PHASE (unobservable for
-# measurement-terminated circuits) to the PECOS unitary, AND
-# verifying it end-to-end through `qir_to_qis -> selene` with
-# discriminating deterministic identities (a no-op lowering would
-# fail). Sequences are in CIRCUIT order (first applied first).
+# rxy, cnot, cz`), verifying it equal up to a GLOBAL PHASE
+# (unobservable for measurement-terminated circuits) to the PECOS
+# unitary, AND verifying it end-to-end through `qir_to_qis -> selene`
+# with discriminating deterministic identities (a no-op lowering
+# would fail). For *Clifford* gates the selene Stim backend can
+# verify; non-Clifford gates (e.g. CH, T-decompositions, arbitrary-
+# angle rotations) use the selene Quest statevector backend.
+# Sequences are in CIRCUIT order (first applied first). Decompositions
+# minimize 2q-gate count first (2q ops are the hardware cost driver).
 _DecompStep = tuple[GateKind, tuple[int, ...], tuple[float, ...]]
 _GATE_DECOMP: dict[GateKind, tuple[_DecompStep, ...]] = {
     # ---- single-qubit Clifford sqrt + face rotations (#93) ----
@@ -177,6 +183,17 @@
         (GateKind.CX, (0, 1), ()),
         (GateKind.SZ, (1,), ()),
     ),
+    # CH = (I_c x Ry(-pi/4)_t) . CX(c,t) . (I_c x Ry(pi/4)_t) -- 1 CX
+    # (the 2q-minimal Clifford+rotation form; conjugation by Ry maps
+    # X to H since Ry(-pi/4) X Ry(pi/4) = cos(-pi/4) X - sin(-pi/4) Z
+    # = (X+Z)/sqrt(2) = H). The PECOS oracle CH() in gate_matrix_def
+    # uses a Clifford+T 2-CX form; ours matches it up to global phase
+    # (max_err 3e-14) and matches textbook block-diag(I,H) exactly.
+    GateKind.CH: (
+        (GateKind.RY, (1,), (math.pi / 4,)),
+        (GateKind.CX, (0, 1), ()),
+        (GateKind.RY, (1,), (-math.pi / 4,)),
+    ),
 }
 
 # Gates with rotation parameters
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
index ccaaa76cb..fea02773f 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
@@ -475,3 +475,72 @@ def _run(prep, ops, meas_idx=0):
     # SZZ^2 discriminator: H;SZZ;SZZ;H q0 with q1=|0> -> 1 (Z on q0; HZH=X).
     # A no-op SZZ would give 0.
     assert _run([h_q0], [szz, szz, h_q0]) == {(1,)}, "H;SZZ;SZZ;H must be X on q0 (SZZ not a no-op)"
+
+
+@pytest.mark.slow
+@pytest.mark.optional_dependency
+def test_ch_executable() -> None:
+    """#93 cont.: CH (controlled-Hadamard) EXECUTES correctly.
+
+    CH has no direct qir-qis primitive; #93 lowers it to the 2q-
+    minimal 1-CX decomposition (I_c x Ry(-pi/4)_t) . CX . (I_c x
+    Ry(pi/4)_t) -- verified up-to-phase against the PECOS oracle
+    `gate_matrix_def.CH()` (max_err 3e-14), and exactly equal to
+    the textbook block-diag(I, H). The 1-CX form beats the PECOS
+    Clifford+T oracle's 2-CX form (per the "minimize 2q-gate count"
+    decomposition-optimality principle; 2q ops are the hardware
+    cost driver).
+
+    CH is NOT a Clifford gate (CH . X_t . CH^{-1} =
+    block-diag(X, Z) is not a Pauli string), so Stim cannot
+    simulate it -- the executable test routes through the Quest
+    statevector backend instead. The PECOS oracle in
+    gate_matrix_def.CH() uses T gates for the same reason: any CH
+    decomposition into the qir-qis allowlist requires non-Clifford
+    rotations (T or arbitrary Ry/Rz angles).
+
+    Pinned identities (deterministic, global-phase-immune):
+      - CH|00> -> |00> (control=0 means no effect, measure q1 -> 0);
+      - CH^2 = I on |10> (involution; X q0; CH; CH; M q1 -> 0);
+      - phase/value discriminator (CH vs CX vs no-op vs Ry-sign-flip):
+            X q0; H q1; CH; M q1 -> 0 deterministically
+        (with c=1, target is |+>; H|+>=|0>; measurement is 0 always).
+        no-op leaves |+>, giving 50/50 (both 0 and 1 observed across
+        seeds/shots); CX-mutation leaves X|+>=|+>, also 50/50; an
+        Ry-sign-flip mutation (Ry(pi/4) . X . Ry(-pi/4)) acts as
+        (X-Z)/sqrt(2) = -H.Z, applied to |+> gives |1> -> measure 1.
+    """
+    import selene_sim
+
+    quest = lambda s: selene_sim.Quest(random_seed=s)  # noqa: E731
+
+    def _run(prep, ops, meas_idx=0):
+        q = QReg("q", 2)
+        c = CReg("c", 1)
+        prog = Main(q, c, *[g(q) for g in prep], *[g(q) for g in ops], Measure(q[meas_idx]) > c[0], Return(c))
+        obs: set[tuple[int, ...]] = set()
+        for seed in _SEEDS:
+            for rec in _qis_exec_records(prog, 2, shots=_SHOTS, seed=seed, simulator_factory=quest):
+                obs.add(tuple(rec))
+        return obs
+
+    ch = lambda q: qb.CH(q[0], q[1])  # noqa: E731
+    x_q0 = lambda q: qb.X(q[0])  # noqa: E731
+    h_q1 = lambda q: qb.H(q[1])  # noqa: E731
+
+    # control=0: CH is identity; measure q1 -> 0.
+    assert _run([], [ch], meas_idx=1) == {(0,)}, "CH|00> -> q1 must be 0 (control=0; no effect)"
+
+    # CH^2 = I (involution: H^2 = I on the c=1 sector):
+    # X q0; CH; CH; M q1 -> 0.
+    assert _run([x_q0], [ch, ch], meas_idx=1) == {(0,)}, "X q0; CH; CH; M q1 must be 0 (CH^2=I)"
+
+    # Phase-sensitive discriminator: X q0; H q1; CH; M q1 -> 0.
+    # With c=1, target starts at |+>; CH applies H, sending |+> -> |0>.
+    # A no-op or CX-mutation leaves the target at |+> -> 50/50 (both
+    # 0 and 1 appear); an Ry-sign-flip mutation (conjugation that
+    # sends X -> -H.Z instead of H) sends |+> -> |1> -> measure 1.
+    # All three mutations are caught by this single deterministic pin.
+    assert _run([x_q0, h_q1], [ch], meas_idx=1) == {
+        (0,),
+    }, "X q0; H q1; CH; M q1 must be 0 deterministically (a CX-mutation, no-op, or Ry-sign-flip CH all fail)"
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_tier2_semantic.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_tier2_semantic.py
index 02a80a3e1..78d0cdd38 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_tier2_semantic.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_tier2_semantic.py
@@ -65,8 +65,12 @@
 
 import re
 import sys
+from typing import TYPE_CHECKING
 
 import pytest
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
 import qir_qis
 import selene_sim
 from pecos.slr import CReg, For, If, Main, Print, QReg, Return, SlrConverter, While
@@ -477,23 +481,39 @@ def test_return_only_inline_creg_raises_loud() -> None:
         SlrConverter(collide).qir_bc()
 
 
-def _qis_exec_records(prog: Main, n_qubits: int, *, shots: int = _SHOTS, seed: int = _SEED) -> list[list[int]]:
+def _qis_exec_records(
+    prog: Main,
+    n_qubits: int,
+    *,
+    shots: int = _SHOTS,
+    seed: int = _SEED,
+    simulator_factory: Callable[[int], object] | None = None,
+) -> list[list[int]]:
     """#77 Layer D -- the real EXECUTABLE differential.
 
     `AST QIR -> qir_qis.qir_to_qis` (LLVM-21 QIS bitcode) ->
     `selene_sim.build` (selene ingests it natively via
     `selene_helios_qis_plugin`; the long-claimed "blocked on an LLVM
-    14<->21 bridge" was false) -> run on Stim. Returns per-shot lists
-    of the recorded `__quantum__rt__int_record_output` *values*, in
-    call order == CReg *declaration* order (B2 `_generate_results`
-    records every declared CReg; the QIS tag is empty post-qir_to_qis
-    so order is the key). This is the executable proof that the B2
-    QIR, lowered by the real Quantinuum compiler and run, computes
-    the correct classical results -- upgrading A+B+C to A+B+C+D.
+    14<->21 bridge" was false) -> run on the selected backend.
+    Returns per-shot lists of the recorded
+    `__quantum__rt__int_record_output` *values*, in call order ==
+    CReg *declaration* order (B2 `_generate_results` records every
+    declared CReg; the QIS tag is empty post-qir_to_qis so order is
+    the key). This is the executable proof that the B2 QIR, lowered
+    by the real Quantinuum compiler and run, computes the correct
+    classical results -- upgrading A+B+C to A+B+C+D.
+
+    `simulator_factory` is a callable `seed -> Simulator` -- defaults
+    to `selene_sim.Stim(random_seed=seed)`. Non-Clifford circuits
+    (e.g. those containing CH, T, arbitrary rotations) must pass a
+    statevector backend such as `lambda s: selene_sim.Quest(
+    random_seed=s)` since Stim rejects non-Clifford operations.
     """
+    if simulator_factory is None:
+        simulator_factory = lambda s: selene_sim.Stim(random_seed=s)  # noqa: E731
     qis = qir_qis.qir_to_qis(SlrConverter(prog).qir_bc())
     inst = selene_sim.build(selene_sim.BitcodeString(qis))
-    shots_out = inst.run_shots(selene_sim.Stim(random_seed=seed), n_qubits=n_qubits, n_shots=shots)
+    shots_out = inst.run_shots(simulator_factory(seed), n_qubits=n_qubits, n_shots=shots)
     return [[value for (_tag, value) in shot] for shot in shots_out]
 
 

From cbc8bb18120e1af4a091b580b75a554dc09c916c Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Wed, 20 May 2026 15:25:32 -0600
Subject: [PATCH 116/136] #93 cont.: verified 1-RZZ QIR lowering for
 CRX/CRY/CRZ + PECOS oracles

---
 .../src/pecos/slr/ast/codegen/qir.py          | 72 +++++++++++++++--
 .../src/pecos/slr/qeclib/qubit/__init__.py    |  4 +-
 .../src/pecos/slr/qeclib/qubit/rots.py        | 26 +++++++
 .../state_sim_tests/gate_matrix_def.py        | 67 ++++++++++++++++
 .../ast_guppy/test_qir_corpus_executable.py   | 78 +++++++++++++++++++
 5 files changed, 241 insertions(+), 6 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
index ec1779142..a28f587ba 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
@@ -27,6 +27,7 @@
 
 import math
 import re
+from collections.abc import Callable
 from dataclasses import dataclass, field, replace
 from typing import TYPE_CHECKING, Any
 
@@ -123,7 +124,14 @@
 # angle rotations) use the selene Quest statevector backend.
 # Sequences are in CIRCUIT order (first applied first). Decompositions
 # minimize 2q-gate count first (2q ops are the hardware cost driver).
-_DecompStep = tuple[GateKind, tuple[int, ...], tuple[float, ...]]
+# A decomposition step's params slot is either:
+#   - a tuple of constant floats (most common, e.g. SZZ -> RZZ(pi/2)), or
+#   - a callable that takes the *input* gate's params (e.g. CRZ(theta))
+#     and returns the step's params (e.g. (theta/2,) on RZ, (-theta/2,)
+#     on RZZ). This lets parameterized controlled-rotation gates thread
+#     their angle through a 2q-minimal decomposition.
+_DecompParams = tuple[float, ...] | Callable[[tuple[float, ...]], tuple[float, ...]]
+_DecompStep = tuple[GateKind, tuple[int, ...], _DecompParams]
 _GATE_DECOMP: dict[GateKind, tuple[_DecompStep, ...]] = {
     # ---- single-qubit Clifford sqrt + face rotations (#93) ----
     GateKind.SX: ((GateKind.H, (0,), ()), (GateKind.SZ, (0,), ()), (GateKind.H, (0,), ())),
@@ -194,6 +202,38 @@
         (GateKind.CX, (0, 1), ()),
         (GateKind.RY, (1,), (-math.pi / 4,)),
     ),
+    # ---- parameterized controlled rotations (#93 cont.) ----
+    # CRZ(theta) = (RZ(theta/2) o RZ(theta/2)) . RZZ(-theta/2): 1 RZZ,
+    # 2 single-qubit RZ. The RZ on the control absorbs the e^{i theta/2}
+    # phase that PECOS's R*(theta) all carry (otherwise it would be a
+    # c=1-only relative phase, which is observable). Verified against
+    # gate_matrix_def.CRZ(theta) for 5 random angles.
+    GateKind.CRZ: (
+        (GateKind.RZZ, (0, 1), lambda p: (-p[0] / 2,)),
+        (GateKind.RZ, (0,), lambda p: (p[0] / 2,)),
+        (GateKind.RZ, (1,), lambda p: (p[0] / 2,)),
+    ),
+    # CRX(theta) = (I o H) . CRZ(theta) . (I o H): conjugate CRZ by H
+    # on the target since H.Z.H = X. Same 1 RZZ.
+    GateKind.CRX: (
+        (GateKind.H, (1,), ()),
+        (GateKind.RZZ, (0, 1), lambda p: (-p[0] / 2,)),
+        (GateKind.RZ, (0,), lambda p: (p[0] / 2,)),
+        (GateKind.RZ, (1,), lambda p: (p[0] / 2,)),
+        (GateKind.H, (1,), ()),
+    ),
+    # CRY(theta) = (I o (S.H)) . CRZ(theta) . (I o (H.Sdg)): conjugate
+    # CRZ by (S.H) on the target since S.X.Sdg = Y (and H.Z.H = X).
+    # Same 1 RZZ.
+    GateKind.CRY: (
+        (GateKind.SZdg, (1,), ()),
+        (GateKind.H, (1,), ()),
+        (GateKind.RZZ, (0, 1), lambda p: (-p[0] / 2,)),
+        (GateKind.RZ, (0,), lambda p: (p[0] / 2,)),
+        (GateKind.RZ, (1,), lambda p: (p[0] / 2,)),
+        (GateKind.H, (1,), ()),
+        (GateKind.SZ, (1,), ()),
+    ),
 }
 
 # Gates with rotation parameters
@@ -553,11 +593,33 @@ def _process_gate(self, node: GateOp) -> None:
             # #93: a gate with no direct QIR primitive but a verified
             # decomposition into the qir-qis ALLOWED primitive set.
             # Emit each step in circuit order, routing its qubits
-            # through the input gate's `targets` and threading any
-            # constant params (e.g. RZZ angles).
-            for prim_kind, idxs, params in _GATE_DECOMP[node.gate]:
+            # through the input gate's `targets` and threading params
+            # (constant for non-parameterized gates like SZZ -> RZZ(pi/2);
+            # callable on the input gate's params for parameterized
+            # gates like CRZ(theta) -> RZZ(-theta/2)). LiteralExpr
+            # bracket-params are unwrapped to floats here so the
+            # callable can do arithmetic on them; non-literal
+            # expressions (VarExpr / BinaryExpr at gate-param position)
+            # are not yet supported for parameterized decomposition
+            # (out of #93 scope; #94 classical-var lowering covers it).
+            input_params_raw = tuple(node.params or ())
+            for prim_kind, idxs, params_spec in _GATE_DECOMP[node.gate]:
                 prim_targets = tuple(node.targets[i] for i in idxs)
-                prim_node = replace(node, gate=prim_kind, targets=prim_targets, params=params)
+                if callable(params_spec):
+                    try:
+                        input_params_resolved = tuple(
+                            p.value if isinstance(p, LiteralExpr) else float(p) for p in input_params_raw
+                        )
+                    except (AttributeError, TypeError) as exc:
+                        msg = (
+                            f"Parameterized decomposition of gate {node.gate.name} requires literal "
+                            f"params; got non-literal: {input_params_raw}"
+                        )
+                        raise NotImplementedError(msg) from exc
+                    prim_params = params_spec(input_params_resolved)
+                else:
+                    prim_params = params_spec
+                prim_node = replace(node, gate=prim_kind, targets=prim_targets, params=prim_params)
                 if prim_kind in TWO_QUBIT_GATES:
                     self._process_two_qubit_gate(prim_node, GATE_TO_QIR[prim_kind])
                 else:
diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/qubit/__init__.py b/python/quantum-pecos/src/pecos/slr/qeclib/qubit/__init__.py
index ee373c8a6..4e7f62eac 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/qubit/__init__.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/qubit/__init__.py
@@ -17,7 +17,7 @@
 
 from pecos.slr.qeclib.qubit.measures import Measure
 from pecos.slr.qeclib.qubit.preps import PNX, PNY, PNZ, PX, PY, PZ
-from pecos.slr.qeclib.qubit.rots import CRZ, RX, RY, RZ, RZZ
+from pecos.slr.qeclib.qubit.rots import CRX, CRY, CRZ, RX, RY, RZ, RZZ
 from pecos.slr.qeclib.qubit.sq_face_rots import F4, F, F4dg, Fdg
 from pecos.slr.qeclib.qubit.sq_hadamards import H
 from pecos.slr.qeclib.qubit.sq_noncliffords import T, Tdg
@@ -38,6 +38,8 @@
 
 __all__ = [
     "CH",
+    "CRX",
+    "CRY",
     "CRZ",
     "CX",
     "CY",
diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/qubit/rots.py b/python/quantum-pecos/src/pecos/slr/qeclib/qubit/rots.py
index 96d70a939..b697c27bd 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/qubit/rots.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/qubit/rots.py
@@ -67,6 +67,32 @@ class RZZGate(TQGate):
 RZZ = RZZGate()
 
 
+class CRXGate(TQGate):
+    """Controlled-RX gate.
+
+    This gate applies an RX rotation to the target qubit controlled by
+    the control qubit. The rotation angle is specified as a parameter.
+    """
+
+    has_parameters = True
+
+
+CRX = CRXGate()
+
+
+class CRYGate(TQGate):
+    """Controlled-RY gate.
+
+    This gate applies an RY rotation to the target qubit controlled by
+    the control qubit. The rotation angle is specified as a parameter.
+    """
+
+    has_parameters = True
+
+
+CRY = CRYGate()
+
+
 class CRZGate(TQGate):
     """Controlled-RZ gate.
 
diff --git a/python/quantum-pecos/tests/pecos/integration/state_sim_tests/gate_matrix_def.py b/python/quantum-pecos/tests/pecos/integration/state_sim_tests/gate_matrix_def.py
index 9b88d83df..66b32d943 100644
--- a/python/quantum-pecos/tests/pecos/integration/state_sim_tests/gate_matrix_def.py
+++ b/python/quantum-pecos/tests/pecos/integration/state_sim_tests/gate_matrix_def.py
@@ -482,6 +482,73 @@ def CH() -> pc.Array:
 assert eqv2phase(CH(), ch_def)
 
 
+def CRZ(theta: float) -> pc.Array:
+    """Controlled-RZ(theta) gate. Convention: block-diag(I, RZ(theta)).
+
+    Decomposition (2q-minimal: 1 RZZ + 2 single-qubit RZ):
+        CRZ(theta) = (RZ(theta/2) o RZ(theta/2)) . RZZ(-theta/2)
+    Works because PECOS_RZ and PECOS_RZZ share the same e^{i.t/2}
+    global-phase convention. RZ on control absorbs the c=1-only phase
+    that the bare RZZ-based form would leave (it would otherwise be
+    a *relative* phase, not a global one, and thus observable).
+    """
+    return oporder_multiply(
+        [
+            RZZ(-theta / 2),
+            (RZ(theta / 2), RZ(theta / 2)),
+        ],
+    )
+
+
+for _ in range(5):
+    crz_th = pc.random.random()
+    assert eqv2phase(CRZ(crz_th), (project_zero & I) + (project_one & RZ(crz_th)))
+
+
+def CRX(theta: float) -> pc.Array:
+    """Controlled-RX(theta) gate. Convention: block-diag(I, RX(theta)).
+
+    Decomposition (2q-minimal: 1 RZZ, via H conjugation of CRZ):
+        CRX(theta) = (I o H) . CRZ(theta) . (I o H)
+    """
+    return oporder_multiply(
+        [
+            (I, H()),
+            CRZ(theta),
+            (I, H()),
+        ],
+    )
+
+
+for _ in range(5):
+    crx_th = pc.random.random()
+    assert eqv2phase(CRX(crx_th), (project_zero & I) + (project_one & RX(crx_th)))
+
+
+def CRY(theta: float) -> pc.Array:
+    """Controlled-RY(theta) gate. Convention: block-diag(I, RY(theta)).
+
+    Decomposition (2q-minimal: 1 RZZ, via (S.H) conjugation of CRZ):
+        CRY(theta) = (I o (S.H)) . CRZ(theta) . (I o (H.Sdg))
+    Identity used: S.X.Sdg = Y, so S.Rx.Sdg = Ry; combined with
+    H.Rz.H = Rx gives S.H.Rz.H.Sdg = Ry.
+    """
+    return oporder_multiply(
+        [
+            (I, Sdg()),
+            (I, H()),
+            CRZ(theta),
+            (I, H()),
+            (I, S()),
+        ],
+    )
+
+
+for _ in range(5):
+    cry_th = pc.random.random()
+    assert eqv2phase(CRY(cry_th), (project_zero & I) + (project_one & RY(cry_th)))
+
+
 def Toffoli() -> pc.Array:
     """C3 gate: Toffoli.
 
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
index fea02773f..d421ca112 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
@@ -544,3 +544,81 @@ def _run(prep, ops, meas_idx=0):
     assert _run([x_q0, h_q1], [ch], meas_idx=1) == {
         (0,),
     }, "X q0; H q1; CH; M q1 must be 0 deterministically (a CX-mutation, no-op, or Ry-sign-flip CH all fail)"
+
+
+@pytest.mark.slow
+@pytest.mark.optional_dependency
+def test_controlled_rotations_executable() -> None:
+    """#93 cont.: CRX(theta) / CRY(theta) / CRZ(theta) EXECUTE correctly.
+
+    All three controlled rotations are non-Clifford for general theta;
+    executable verification routes through the Quest statevector
+    backend. Decompositions (each 1-RZZ, the 2q-minimal form) are
+    verified up-to-global-phase against the canonical PECOS oracles
+    in `gate_matrix_def.CRX/CRY/CRZ` (5 random angles each).
+
+    Discriminator design: at theta=pi, PECOS R*(pi) equals the
+    corresponding Pauli (RX(pi)=X, RY(pi)=Y, RZ(pi)=Z), so CR*(pi)
+    acts as CX/CY/CZ in the c=1 sector. The (Test A, Test B) outcome
+    pair uniquely identifies the gate (and catches no-op/wrong-gate
+    mutations):
+      Test A -- X q0; CR*(pi); M q1
+        CRX: 1 (X|0>=|1>);   CRY: 1 (Y|0>=i|1>);   CRZ: 0 (Z|0>=|0>).
+      Test B -- X q0; H q1; CR*(pi); H q1; M q1 (H-conjugate)
+        CRX: 0 (HXH=Z, Z|0>=|0>);
+        CRY: 1 (HYH=-Y, Y|+>=-i|->, H|->=|1>);
+        CRZ: 1 (HZH=X, X|0>=|1>).
+      Signatures (A,B): CRX=(1,0), CRY=(1,1), CRZ=(0,1) -- all
+      three distinct, so any cross-swap or no-op is caught.
+
+    Angle-propagation: CR*(pi/2)^2 must produce the same (Test A)
+    outcome as CR*(pi) when q0=|1>. Catches a stuck-angle bug where
+    the callable-params plumbing dropped theta on the floor.
+    """
+    import selene_sim
+
+    quest = lambda s: selene_sim.Quest(random_seed=s)  # noqa: E731
+
+    def _run(prep, ops, meas_idx=0):
+        q = QReg("q", 2)
+        c = CReg("c", 1)
+        prog = Main(q, c, *[g(q) for g in prep], *[g(q) for g in ops], Measure(q[meas_idx]) > c[0], Return(c))
+        obs: set[tuple[int, ...]] = set()
+        for seed in _SEEDS:
+            for rec in _qis_exec_records(prog, 2, shots=_SHOTS, seed=seed, simulator_factory=quest):
+                obs.add(tuple(rec))
+        return obs
+
+    import math as _math
+
+    crx_pi = lambda q: qb.CRX[_math.pi](q[0], q[1])  # noqa: E731
+    cry_pi = lambda q: qb.CRY[_math.pi](q[0], q[1])  # noqa: E731
+    crz_pi = lambda q: qb.CRZ[_math.pi](q[0], q[1])  # noqa: E731
+    crx_half = lambda q: qb.CRX[_math.pi / 2](q[0], q[1])  # noqa: E731
+    cry_half = lambda q: qb.CRY[_math.pi / 2](q[0], q[1])  # noqa: E731
+    crz_half = lambda q: qb.CRZ[_math.pi / 2](q[0], q[1])  # noqa: E731
+    x_q0 = lambda q: qb.X(q[0])  # noqa: E731
+    h_q1 = lambda q: qb.H(q[1])  # noqa: E731
+
+    # c=0 sanity: each CR*(pi)|00> -> q1 unchanged -> 0.
+    assert _run([], [crx_pi], meas_idx=1) == {(0,)}, "CRX(pi)|00> -> q1 must be 0 (c=0)"
+    assert _run([], [cry_pi], meas_idx=1) == {(0,)}, "CRY(pi)|00> -> q1 must be 0 (c=0)"
+    assert _run([], [crz_pi], meas_idx=1) == {(0,)}, "CRZ(pi)|00> -> q1 must be 0 (c=0)"
+
+    # Test A (computational basis): X q0; CR*(pi); M q1.
+    assert _run([x_q0], [crx_pi], meas_idx=1) == {(1,)}, "Test A CRX(pi): X q0; CRX(pi); M q1 must be 1"
+    assert _run([x_q0], [cry_pi], meas_idx=1) == {(1,)}, "Test A CRY(pi): X q0; CRY(pi); M q1 must be 1"
+    assert _run([x_q0], [crz_pi], meas_idx=1) == {(0,)}, "Test A CRZ(pi): X q0; CRZ(pi); M q1 must be 0"
+
+    # Test B (Hadamard sandwich -- distinguishes CR* from each other):
+    # X q0; H q1; CR*(pi); H q1; M q1.
+    assert _run([x_q0, h_q1], [crx_pi, h_q1], meas_idx=1) == {(0,)}, "Test B CRX(pi) must be 0"
+    assert _run([x_q0, h_q1], [cry_pi, h_q1], meas_idx=1) == {(1,)}, "Test B CRY(pi) must be 1"
+    assert _run([x_q0, h_q1], [crz_pi, h_q1], meas_idx=1) == {(1,)}, "Test B CRZ(pi) must be 1"
+
+    # Angle-propagation: CR*(pi/2)^2 must match Test A CR*(pi). Verifies
+    # the callable-params plumbing actually threads theta through the
+    # decomp (a stuck-zero or stuck-pi bug would fail one of these).
+    assert _run([x_q0], [crx_half, crx_half], meas_idx=1) == {(1,)}, "CRX(pi/2)^2 must agree with Test A CRX(pi)"
+    assert _run([x_q0], [cry_half, cry_half], meas_idx=1) == {(1,)}, "CRY(pi/2)^2 must agree with Test A CRY(pi)"
+    assert _run([x_q0], [crz_half, crz_half], meas_idx=1) == {(0,)}, "CRZ(pi/2)^2 must agree with Test A CRZ(pi)"

From 821b587e96875eb515e7434456a90ea08313e079 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Wed, 20 May 2026 15:39:11 -0600
Subject: [PATCH 117/136] #88B: Guppy slot-local name disambiguation against
 declared register names

---
 .../src/pecos/slr/ast/codegen/guppy.py        | 58 ++++++++++++++++++-
 .../pecos/slr/ast/codegen/guppy_linearity.py  | 25 +++++++-
 .../slr_tests/guppy/test_array_patterns.py    | 55 +++++++++---------
 3 files changed, 107 insertions(+), 31 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
index f103e4b22..b7a7fcb81 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
@@ -134,6 +134,13 @@ class GuppyContext:
     registers: dict[str, RegisterDecl] = field(default_factory=dict)
     linearity: GuppyLinearityState | None = None
     temp_counter: int = 0
+    # #88B: single namespace-wide slot -> Guppy-local table. Populated
+    # by `populate_slot_locals` after declarations are collected (so
+    # the registers + allocator names are known); read by both
+    # `GuppyLinearityState.from_allocators(..., slot_locals=...)` and
+    # `AstToGuppy._local_name` so all three sites that emit a slot
+    # name agree (the bug class the xfail tracked).
+    slot_locals: dict[Slot, str] = field(default_factory=dict)
 
     def indent(self) -> str:
         """Return current indentation string."""
@@ -153,6 +160,36 @@ def temp(self, prefix: str) -> str:
         self.temp_counter += 1
         return name
 
+    def populate_slot_locals(self) -> None:
+        """Compute disambiguated Guppy local names for every allocator slot.
+
+        Default name is `f"{allocator}_{index}"`; if that collides with
+        any declared allocator name, register name, or previously
+        assigned slot local, suffix `_` until unique. The result is the
+        authority used by both linearity-state binding init and the
+        emitter's `_local_name` so the entry-unpack LHS, the linearity
+        bindings, and per-slot references all agree (the #88B fix --
+        prevents `q_0, q_1 = q` from shadowing a separately declared
+        `QReg("q_0", ...)` parameter). Idempotent: caller may invoke
+        once after `_collect_declarations` populates allocators+regs.
+        """
+        taken: set[str] = set(self.root_allocators) | set(self.registers)
+        # Existing slot_locals (a re-population path; should not normally
+        # happen) are preserved -- once a slot's name is committed,
+        # everything downstream depends on it.
+        for name in self.slot_locals.values():
+            taken.add(name)
+        for allocator, size in self.root_allocators.items():
+            for index in range(size):
+                slot = Slot(allocator, index)
+                if slot in self.slot_locals:
+                    continue
+                candidate = f"{allocator}_{index}"
+                while candidate in taken:
+                    candidate += "_"
+                self.slot_locals[slot] = candidate
+                taken.add(candidate)
+
 
 class AstToGuppy:
     """Recursive-descent Guppy code generator for AST programs."""
@@ -186,7 +223,11 @@ def _generate_main(self, program: Program) -> list[str]:
         self.context = GuppyContext()
         self._collect_declarations(program)
         self._collect_implicit_measure_registers(program.body)
-        self.context.linearity = GuppyLinearityState.from_allocators(self.context.root_allocators)
+        self.context.populate_slot_locals()
+        self.context.linearity = GuppyLinearityState.from_allocators(
+            self.context.root_allocators,
+            slot_locals=self.context.slot_locals,
+        )
         self._reject_child_allocators()
 
         # Phase 1 Print AST-level validators (run before emission so failures
@@ -320,7 +361,11 @@ def _generate_block_decl(self, decl: BlockDecl) -> list[str]:
                 # no parameter and is seeded CONSUMED below so the first Prep
                 # allocates a fresh internal `qubit()`.
                 self.context.root_allocators[name] = size
-        self.context.linearity = GuppyLinearityState.from_allocators(self.context.root_allocators)
+        self.context.populate_slot_locals()
+        self.context.linearity = GuppyLinearityState.from_allocators(
+            self.context.root_allocators,
+            slot_locals=self.context.slot_locals,
+        )
         # Seed scratch slots CONSUMED so the body's first `Prep(scratch)` takes
         # the fresh-`qubit()` branch in `_emit_prepare` (no entry binding, no
         # parameter to alias). `from_allocators` starts every slot LIVE.
@@ -1661,6 +1706,15 @@ def _slot_from_ref(self, ref: SlotRef) -> Slot:
         return Slot(ref.allocator, ref.index)
 
     def _local_name(self, slot: Slot) -> str:
+        # #88B: read from the disambiguated slot-locals table populated
+        # by `GuppyContext.populate_slot_locals` so this site agrees
+        # with the linearity-state binding and the entry-unpack LHS.
+        # Fall back to the bare formula only if a caller emits a slot
+        # before the table is populated (defensive; should not happen
+        # on a normal emission path).
+        cached = self.context.slot_locals.get(slot)
+        if cached is not None:
+            return cached
         return f"{slot.allocator}_{slot.index}"
 
     def _render_bit_ref(self, ref: BitRef) -> str:
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy_linearity.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy_linearity.py
index 4c7c06093..f0e9ce883 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy_linearity.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy_linearity.py
@@ -70,8 +70,22 @@ def __init__(self, bindings: Mapping[Slot, Binding]) -> None:
         self._bindings = dict(bindings)
 
     @classmethod
-    def from_allocators(cls, allocators: Mapping[str, int]) -> GuppyLinearityState:
-        """Create live slot bindings for root QReg/QAlloc declarations."""
+    def from_allocators(
+        cls,
+        allocators: Mapping[str, int],
+        *,
+        slot_locals: Mapping[Slot, str] | None = None,
+    ) -> GuppyLinearityState:
+        """Create live slot bindings for root QReg/QAlloc declarations.
+
+        `slot_locals`, when provided, is the single namespace-wide
+        slot-to-Guppy-local name table from `GuppyContext.slot_locals`
+        (#88B: disambiguates the default `f"{allocator}_{index}"` against
+        register names so the entry-unpack LHS does not shadow another
+        declared register). When omitted, the default name is used --
+        kept for callers that build a linearity table outside the main
+        emitter (no register collision risk for those isolated paths).
+        """
         bindings: dict[Slot, Binding] = {}
         for allocator, size in allocators.items():
             if size < 0:
@@ -79,7 +93,12 @@ def from_allocators(cls, allocators: Mapping[str, int]) -> GuppyLinearityState:
                 raise LinearityError(msg)
             for index in range(size):
                 slot = Slot(allocator, index)
-                bindings[slot] = Binding(local=f"{allocator}_{index}", state=SlotState.LIVE)
+                local = (
+                    slot_locals[slot]
+                    if slot_locals is not None and slot in slot_locals
+                    else f"{allocator}_{index}"
+                )
+                bindings[slot] = Binding(local=local, state=SlotState.LIVE)
         return cls(bindings)
 
     def bindings(self) -> Iterable[tuple[Slot, Binding]]:
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_array_patterns.py b/python/quantum-pecos/tests/slr_tests/guppy/test_array_patterns.py
index 5d340a6dd..d770b5f2e 100644
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_array_patterns.py
+++ b/python/quantum-pecos/tests/slr_tests/guppy/test_array_patterns.py
@@ -20,25 +20,27 @@ class TestArrayUnpacking:
     """Test array unpacking patterns for measurements."""
 
     @pytest.mark.optional_dependency
-    @pytest.mark.xfail(
-        reason="#88B (pre-existing, not #80/#81): the Guppy emitter's slot-local "
-        "naming `f'{allocator}_{index}'` (guppy.py `_local_name` + "
-        "guppy_linearity.py binding init + the entry-unpack LHS -- three "
-        "sites that must agree) collides when an unpack name (`q_0`) equals "
-        "another declared register's name: `q_0, q_1 = q` rebinds the `q_0` "
-        "param, then `q_0_0, = q_0` raises UnpackableError. A correct fix "
-        "needs a single namespace-wide uniquification authority feeding all "
-        "three sites (linearity state has no register/block-decl names) with "
-        "corpus-wide local-name churn -- cross-cutting, out of #87/#88 "
-        "pre-PR scope; tracked.",
-        strict=True,
-        raises=Exception,
-    )
     def test_unique_unpacked_names(self) -> None:
-        """Test that unpacked names avoid conflicts."""
+        """#88B fix: slot-locals are disambiguated against declared register names.
+
+        Before the fix, the Guppy emitter's slot-local formula
+        `f"{allocator}_{index}"` would generate `q_0` for `q[0]`, which
+        shadows a separately declared `QReg("q_0", ...)` parameter: the
+        entry-unpack LHS `q_0, q_1 = q` rebinds the `q_0` param to the
+        first qubit of `q`, and the next line `q_0_0, = q_0` then tries
+        to unpack a single qubit, raising UnpackableError.
+
+        After the fix, `GuppyContext.populate_slot_locals` builds a
+        single namespace-wide table that is read by both
+        `GuppyLinearityState.from_allocators(..., slot_locals=...)` and
+        the emitter's `_local_name`; colliding candidates get `_`-suffixed
+        until unique. So `q[0]` becomes `q_0_` (one underscore appended,
+        since `q_0` is taken by the other register), and `q_0[0]` stays
+        `q_0_0`. The compiled Guppy + HUGR build cleanly.
+        """
         prog = Main(
             q := QReg("q", 2),
-            q_0 := QReg("q_0", 1),  # Conflicting name
+            q_0 := QReg("q_0", 1),  # Same name as the q[0] slot-local would default to.
             c := CReg("c", 3),
             Measure(q[0]) > c[0],
             Measure(q[1]) > c[1],
@@ -48,16 +50,17 @@ def test_unique_unpacked_names(self) -> None:
 
         guppy_code = SlrConverter(prog).guppy()
 
-        # Should generate unique names to avoid conflicts
-        # The unpacked names might be _q_0, _q_1 or similar
-        assert "= q" in guppy_code  # Some unpacking happens
-
-        # Should compile without name conflicts
-        try:
-            hugr = SlrConverter(prog).hugr()
-            assert hugr is not None
-        except ImportError as e:
-            pytest.fail(f"Should handle name conflicts: {e}")
+        # The fix produces `q_0_, q_1 = q` (q[0] disambiguated against
+        # the register `q_0`); `q_0_0, = q_0` is unchanged.
+        assert "q_0_, q_1 = q" in guppy_code, guppy_code
+        assert "q_0_0, = q_0" in guppy_code, guppy_code
+        # The slot-local must NOT be the bare `q_0`, which would shadow
+        # the parameter:
+        assert "q_0, q_1 = q" not in guppy_code, guppy_code
+
+        # HUGR build must succeed (this is what raised UnpackableError pre-fix).
+        hugr = SlrConverter(prog).hugr()
+        assert hugr is not None
 
 
 class TestArraySwapPatterns:

From 6f074e3c7a89389cb7e39f1d7caca1f38e12c01a Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Wed, 20 May 2026 16:06:13 -0600
Subject: [PATCH 118/136] Cross-codegen: verified Stim decomposition for
 F/Fdg/F4/F4dg face Cliffords

---
 .../src/pecos/slr/ast/codegen/stim.py         | 51 +++++++++++++++++--
 .../pecos/unit/slr/test_stim_conversion.py    | 51 +++++++++++++++++++
 2 files changed, 97 insertions(+), 5 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/stim.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/stim.py
index 792d50996..7aaeae3b1 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/stim.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/stim.py
@@ -102,6 +102,34 @@
     GateKind.RZZ,
 }
 
+# Decomposition table: Clifford-only PECOS gates with no direct Stim
+# primitive, lowered into the Stim-native gate set. Each entry is a
+# sequence of (Stim gate name, qubit-index tuple-into-targets) steps
+# in CIRCUIT order (first applied first). The compositions mirror the
+# already-verified QIR `_GATE_DECOMP` entries: each H/S/S_DAG step is
+# itself a Stim primitive, so a decomp using only those primitives is
+# correct iff the QIR-side decomp is correct (which was verified
+# up-to-phase against the PECOS oracle and end-to-end via selene).
+#
+# Stim is a Clifford-only stabilizer simulator: gates that involve
+# non-Clifford rotations (CH, CRX/CRY/CRZ, T-decomposable forms) or
+# arbitrary continuous rotations (RX/RY/RZ/RZZ at non-pi/2 angles)
+# remain fail-loud here -- there is no Clifford-only decomposition,
+# and the qir-qis-style "decompose to a Clifford+T target" path is
+# fundamentally unavailable to Stim (the user's "support all gates
+# in all languages, IF DECOMPOSABLE" directive admits this caveat).
+_GATE_DECOMP: dict[GateKind, tuple[tuple[str, tuple[int, ...]], ...]] = {
+    # F = H . SZdg (matrix product; circuit-time: SZdg first, then H).
+    # F cycles Paulis X -> Y -> Z -> X (face rotation of the Bloch cube).
+    GateKind.F: (("S_DAG", (0,)), ("H", (0,))),
+    # Fdg = SZ . H (inverse of F; cycles X <- Y <- Z <- X).
+    GateKind.Fdg: (("H", (0,)), ("S", (0,))),
+    # F4 = SZdg . H -- the F-rotation around a different face axis.
+    GateKind.F4: (("H", (0,)), ("S_DAG", (0,))),
+    # F4dg = H . SZ -- inverse of F4.
+    GateKind.F4dg: (("S", (0,)), ("H", (0,))),
+}
+
 
 @dataclass
 class StimCodeGenContext:
@@ -282,6 +310,15 @@ def _process_statement(self, stmt: Statement) -> None:
     def _process_gate(self, node: GateOp) -> None:
         """Process a gate operation."""
         stim_gate = GATE_TO_STIM.get(node.gate)
+        if stim_gate is None and node.gate in _GATE_DECOMP:
+            # A Clifford gate with no direct Stim primitive but a
+            # verified decomposition into Stim-native primitives.
+            # Emit each step in circuit order.
+            qubits = [self.context.get_qubit(t.allocator, t.index) for t in node.targets]
+            for prim_name, idxs in _GATE_DECOMP[node.gate]:
+                prim_qubits = [qubits[i] for i in idxs]
+                self.circuit.append_operation(prim_name, prim_qubits)
+            return
         if stim_gate is None:
             # #88A-class (the #78 surfaced-not-changed Stim analogue):
             # a gate with no GATE_TO_STIM entry was SILENTLY DROPPED
@@ -290,14 +327,18 @@ def _process_gate(self, node: GateOp) -> None:
             # uncatchable downstream). Fail loud instead. Stim is
             # Clifford-only, so non-Clifford rotations
             # (RX/RY/RZ/RZZ/CR*) are fundamentally unrepresentable
-            # here; F-family/CH have no Stim primitive. A program
-            # using one must not be silently mis-emitted.
+            # here; CH is non-Clifford too. Gates that are Clifford
+            # but lack a direct Stim primitive get a verified
+            # `_GATE_DECOMP` entry above; anything that reaches this
+            # raise has no representable form.
             gate_name = getattr(node.gate, "name", node.gate)
             msg = (
                 f"Stim codegen: gate {gate_name!r} has no Stim lowering "
-                "(not in GATE_TO_STIM). Emitting the circuit without it "
-                "would be a silent miscompile; it is not supported by "
-                "the Stim backend."
+                "(not in GATE_TO_STIM, no Clifford decomposition in "
+                "_GATE_DECOMP). Emitting the circuit without it would be "
+                "a silent miscompile; it is not supported by the Stim "
+                "backend (non-Clifford gates like CH, CR*, continuous "
+                "rotations are fundamentally unrepresentable here)."
             )
             raise NotImplementedError(msg)
 
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_stim_conversion.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_stim_conversion.py
index 540f34e86..b6746cf2a 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_stim_conversion.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_stim_conversion.py
@@ -353,5 +353,56 @@ def test_unsupported_gate_fails_loud() -> None:
         SlrConverter(prog).stim()
 
 
+@pytest.mark.skipif(not STIM_AVAILABLE, reason="Stim not installed")
+def test_face_clifford_gates_decompose() -> None:
+    """F/Fdg/F4/F4dg are PECOS face-Cliffords with no direct Stim
+    primitive; cross-codegen audit landed verified decompositions
+    into H/S/S_DAG so they no longer fail-loud. Verify each decomp
+    produces the *correct* Clifford action via Stim's tableau (catches
+    no-op and wrong-direction mutations -- a wrong-direction F would
+    cycle X<-Y<-Z<-X instead of forward).
+
+    F is order-3 (F^3 = I) and cycles the Paulis X->Y->Z->X up to
+    sign. The Heisenberg-picture conjugation `F . Z . Fdg = X` is
+    the deterministic identity each face-Clifford must satisfy.
+    """
+    # Build a 1q Stim program with just `F q[0]` and read the tableau.
+    def _tableau_of(gate) -> stim.Tableau:
+        q = QReg("q", 1)
+        prog = Main(q, gate(q[0]))
+        circ = SlrConverter(prog).stim()
+        return stim.Tableau.from_circuit(circ)
+
+    # F should send Z -> X and X -> Y (face cycle in the +1,+1,+1
+    # direction). Fdg is the inverse so it sends Z -> Y and X -> Z.
+    f = _tableau_of(qubit.F)
+    fdg = _tableau_of(qubit.Fdg)
+    assert f(stim.PauliString("Z")) == stim.PauliString("+X"), f
+    assert f(stim.PauliString("X")) == stim.PauliString("+Y"), f
+    assert fdg(stim.PauliString("Z")) == stim.PauliString("+Y"), fdg
+    assert fdg(stim.PauliString("X")) == stim.PauliString("+Z"), fdg
+
+    # F . Fdg must be identity (involution-pair). Build the
+    # composed circuit and confirm both Paulis are preserved.
+    q = QReg("q", 1)
+    prog = Main(q, qubit.F(q[0]), qubit.Fdg(q[0]))
+    f_fdg = stim.Tableau.from_circuit(SlrConverter(prog).stim())
+    assert f_fdg(stim.PauliString("Z")) == stim.PauliString("+Z"), f_fdg
+    assert f_fdg(stim.PauliString("X")) == stim.PauliString("+X"), f_fdg
+
+    # F4 / F4dg are a *different* face Clifford (rotation around
+    # a different cube axis). Sanity-check they are well-defined
+    # involution pairs and not aliases of F / Fdg.
+    f4 = _tableau_of(qubit.F4)
+    f4dg = _tableau_of(qubit.F4dg)
+    assert f4 != f, "F4 must not be the same Clifford as F"
+    assert f4dg != fdg, "F4dg must not be the same Clifford as Fdg"
+    q = QReg("q", 1)
+    prog = Main(q, qubit.F4(q[0]), qubit.F4dg(q[0]))
+    f4_f4dg = stim.Tableau.from_circuit(SlrConverter(prog).stim())
+    assert f4_f4dg(stim.PauliString("Z")) == stim.PauliString("+Z"), f4_f4dg
+    assert f4_f4dg(stim.PauliString("X")) == stim.PauliString("+X"), f4_f4dg
+
+
 if __name__ == "__main__":
     pytest.main([__file__, "-v"])

From 9c5fa5945a730940fcd587670173bf752ac1d933 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Wed, 20 May 2026 17:19:19 -0600
Subject: [PATCH 119/136] Cross-codegen: native CRX/CRY/CRZ in
 ArbitraryRotationGateable + QC param-threading

---
 .../src/arbitrary_rotation_gateable.rs        | 70 +++++++++++++++++++
 .../pecos-simulators/tests/test_state_vec.rs  | 60 +++++++++++++++-
 python/pecos-rslib/src/state_vec_bindings.rs  | 34 +++++++++
 .../src/pecos/simulators/statevec/bindings.py | 18 +++++
 .../pecos/slr/ast/codegen/quantum_circuit.py  | 56 +++++++++++++++
 .../state_sim_tests/test_statevec.py          | 30 ++++++++
 6 files changed, 267 insertions(+), 1 deletion(-)

diff --git a/crates/pecos-simulators/src/arbitrary_rotation_gateable.rs b/crates/pecos-simulators/src/arbitrary_rotation_gateable.rs
index b38959d62..1ded50a7c 100644
--- a/crates/pecos-simulators/src/arbitrary_rotation_gateable.rs
+++ b/crates/pecos-simulators/src/arbitrary_rotation_gateable.rs
@@ -254,6 +254,76 @@ pub trait ArbitraryRotationGateable: CliffordGateable {
         self.rxx(theta, pairs).ryy(phi, pairs).rzz(lambda, pairs)
     }
 
+    /// Applies a controlled-RZ rotation: target qubit gets RZ(theta) when control = |1>.
+    ///
+    /// `CRZ(theta) = block-diag(I, RZ(theta)) = diag(1, 1, exp(-i*theta/2), exp(i*theta/2))`.
+    ///
+    /// Default 2q-minimal decomposition (1 RZZ + 1 single-qubit RZ on the
+    /// target): `CRZ(theta) = (I o RZ(theta/2)) . RZZ(-theta/2)`.
+    /// Verified: with the trait's `RZ = exp(-i*theta/2*Z)` and `RZZ =
+    /// exp(-i*theta/2*Z*Z)` conventions, the product on the c=0 sector
+    /// gives `RZ(theta/2) . exp(i*theta/4*I) = I` up to global phase, and
+    /// on c=1 (where ZZ acts as -Z on target) gives `RZ(theta/2) . X .
+    /// RZ(theta/2) . X = RZ(theta)` -- i.e. the convention-1 controlled
+    /// rotation. The non-PECOS-prefactor convention requires no extra
+    /// RZ on the control.
+    ///
+    /// # Parameters
+    /// - `theta`: The rotation angle on the target.
+    /// - `pairs`: Pairs of qubit indices `[(control, target), ...]`.
+    ///
+    /// # Returns
+    /// A mutable reference to `Self` for method chaining.
+    #[inline]
+    fn crz(&mut self, theta: Angle64, pairs: &[(QubitId, QubitId)]) -> &mut Self {
+        // Half-angle first, THEN negate -- `Angle<T>` is a wrapping fraction
+        // of a full turn (modulo 2pi), so `-theta / 2` would halve the wrapped
+        // 2*pi - theta and produce pi - theta/2, not -theta/2.
+        let half = theta / 2u64;
+        let targets: QubitBuf = pairs.iter().map(|&(_, t)| t).collect();
+        self.rzz(-half, pairs).rz(half, &targets)
+    }
+
+    /// Applies a controlled-RX rotation: target qubit gets RX(theta) when control = |1>.
+    ///
+    /// Default decomposition: `CRX(theta) = (I o H) . CRZ(theta) . (I o H)`,
+    /// using `H.Z.H = X` so the c=1 sector applies `H.RZ(theta).H = RX(theta)`.
+    /// Same 2q cost as `crz` (1 RZZ).
+    ///
+    /// # Parameters
+    /// - `theta`: The rotation angle on the target.
+    /// - `pairs`: Pairs of qubit indices `[(control, target), ...]`.
+    ///
+    /// # Returns
+    /// A mutable reference to `Self` for method chaining.
+    #[inline]
+    fn crx(&mut self, theta: Angle64, pairs: &[(QubitId, QubitId)]) -> &mut Self {
+        let targets: QubitBuf = pairs.iter().map(|&(_, t)| t).collect();
+        self.h(&targets).crz(theta, pairs).h(&targets)
+    }
+
+    /// Applies a controlled-RY rotation: target qubit gets RY(theta) when control = |1>.
+    ///
+    /// Default decomposition: `CRY(theta) = (I o S.H) . CRZ(theta) . (I o H.Sdg)`,
+    /// using `S.X.Sdg = Y` (so `S.Rx.Sdg = Ry`) and `H.Rz.H = Rx`, giving
+    /// `S.H.RZ.H.Sdg = RY`. Same 2q cost as `crz` (1 RZZ).
+    ///
+    /// # Parameters
+    /// - `theta`: The rotation angle on the target.
+    /// - `pairs`: Pairs of qubit indices `[(control, target), ...]`.
+    ///
+    /// # Returns
+    /// A mutable reference to `Self` for method chaining.
+    #[inline]
+    fn cry(&mut self, theta: Angle64, pairs: &[(QubitId, QubitId)]) -> &mut Self {
+        let targets: QubitBuf = pairs.iter().map(|&(_, t)| t).collect();
+        self.szdg(&targets)
+            .h(&targets)
+            .crz(theta, pairs)
+            .h(&targets)
+            .sz(&targets)
+    }
+
     /// Applies a general 2-qubit unitary via KAK decomposition:
     /// U = (U3(before[0]) x U3(before[1])) * RXXRYYRZZ(interaction) * (U3(after[0]) x U3(after[1]))
     ///
diff --git a/crates/pecos-simulators/tests/test_state_vec.rs b/crates/pecos-simulators/tests/test_state_vec.rs
index ed3dc7aa9..8f9fa71b3 100644
--- a/crates/pecos-simulators/tests/test_state_vec.rs
+++ b/crates/pecos-simulators/tests/test_state_vec.rs
@@ -2405,7 +2405,7 @@ mod detailed_tq_gate_cases {
     use num_complex::Complex64;
     use pecos_core::{Angle64, QubitId};
     use pecos_simulators::{ArbitraryRotationGateable, CliffordGateable, StateVec, qid};
-    use std::f64::consts::{FRAC_PI_2, FRAC_PI_3, FRAC_PI_4, PI};
+    use std::f64::consts::{FRAC_PI_2, FRAC_PI_3, FRAC_PI_4, FRAC_PI_6, PI};
 
     #[test]
     fn test_cx_decomposition() {
@@ -2484,6 +2484,64 @@ mod detailed_tq_gate_cases {
         assert_states_equal(state_rxx.state(), state_decomposed.state());
     }
 
+    #[test]
+    fn test_crz_decomposition() {
+        // Cross-codegen: default crz impl is (I o RZ(theta/2)) . RZZ(-theta/2).
+        // Verify the 1-RZZ default matches direct controlled-RZ semantics:
+        //   c=0: identity on target (no rotation applied)
+        //   c=1: target gets RZ(theta)
+        let theta = Angle64::from_radians(FRAC_PI_3);
+
+        // c=0: |00> stays |00> (no rotation when control = 0).
+        let mut crz_c0 = StateVec::new(2);
+        let mut baseline_c0 = StateVec::new(2);
+        crz_c0.crz(theta, &[(QubitId(0), QubitId(1))]);
+        assert_states_equal(crz_c0.state(), baseline_c0.state());
+
+        // c=1: |10> -> |1, RZ(theta)|0>> -- target receives exactly RZ(theta).
+        let mut crz_c1 = StateVec::new(2);
+        let mut direct_rz = StateVec::new(2);
+        crz_c1.x(&qid(0)).crz(theta, &[(QubitId(0), QubitId(1))]);
+        direct_rz.x(&qid(0)).rz(theta, &qid(1));
+        assert_states_equal(crz_c1.state(), direct_rz.state());
+    }
+
+    #[test]
+    fn test_crx_decomposition() {
+        // Cross-codegen: default crx impl is (I o H) . CRZ . (I o H).
+        let theta = Angle64::from_radians(FRAC_PI_4);
+
+        let mut crx_c0 = StateVec::new(2);
+        let mut baseline_c0 = StateVec::new(2);
+        crx_c0.crx(theta, &[(QubitId(0), QubitId(1))]);
+        assert_states_equal(crx_c0.state(), baseline_c0.state());
+
+        // c=1: target gets RX(theta).
+        let mut crx_c1 = StateVec::new(2);
+        let mut direct_rx = StateVec::new(2);
+        crx_c1.x(&qid(0)).crx(theta, &[(QubitId(0), QubitId(1))]);
+        direct_rx.x(&qid(0)).rx(theta, &qid(1));
+        assert_states_equal(crx_c1.state(), direct_rx.state());
+    }
+
+    #[test]
+    fn test_cry_decomposition() {
+        // Cross-codegen: default cry impl is (I o S.H) . CRZ . (I o H.Sdg).
+        let theta = Angle64::from_radians(FRAC_PI_6);
+
+        let mut cry_c0 = StateVec::new(2);
+        let mut baseline_c0 = StateVec::new(2);
+        cry_c0.cry(theta, &[(QubitId(0), QubitId(1))]);
+        assert_states_equal(cry_c0.state(), baseline_c0.state());
+
+        // c=1: target gets RY(theta).
+        let mut cry_c1 = StateVec::new(2);
+        let mut direct_ry = StateVec::new(2);
+        cry_c1.x(&qid(0)).cry(theta, &[(QubitId(0), QubitId(1))]);
+        direct_ry.x(&qid(0)).ry(theta, &qid(1));
+        assert_states_equal(cry_c1.state(), direct_ry.state());
+    }
+
     #[test]
     fn test_two_qubit_unitary_swap_simple() {
         let mut state_vec = StateVec::new(2);
diff --git a/python/pecos-rslib/src/state_vec_bindings.rs b/python/pecos-rslib/src/state_vec_bindings.rs
index 3924a8eaf..dcc8fa532 100644
--- a/python/pecos-rslib/src/state_vec_bindings.rs
+++ b/python/pecos-rslib/src/state_vec_bindings.rs
@@ -508,6 +508,40 @@ impl PyStateVec {
                 Ok(None)
             }
 
+            "CRX" | "CRY" | "CRZ" => {
+                let Some(params) = params else {
+                    return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(
+                        "Angle parameter missing for controlled rotation gate",
+                    ));
+                };
+                let angle = match params.get_item("angle") {
+                    Ok(Some(py_any)) => py_any.extract::<AngleParam>().map_err(|_| {
+                        PyErr::new::<pyo3::exceptions::PyValueError, _>(
+                            "Expected a valid angle parameter for controlled rotation gate",
+                        )
+                    })?,
+                    Ok(None) => {
+                        return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(
+                            "Angle parameter missing for controlled rotation gate",
+                        ));
+                    }
+                    Err(err) => return Err(err),
+                };
+                match symbol {
+                    "CRX" => {
+                        self.inner.crx(angle.0, pair);
+                    }
+                    "CRY" => {
+                        self.inner.cry(angle.0, pair);
+                    }
+                    "CRZ" => {
+                        self.inner.crz(angle.0, pair);
+                    }
+                    _ => unreachable!(),
+                }
+                Ok(None)
+            }
+
             "RXXRYYRZZ" | "RZZRYYRXX" | "R2XXYYZZ" | "RXXYYZZ" => {
                 if let Some(params) = params {
                     match params.get_item("angles") {
diff --git a/python/quantum-pecos/src/pecos/simulators/statevec/bindings.py b/python/quantum-pecos/src/pecos/simulators/statevec/bindings.py
index cd23bfe4f..2eb6c6f6c 100644
--- a/python/quantum-pecos/src/pecos/simulators/statevec/bindings.py
+++ b/python/quantum-pecos/src/pecos/simulators/statevec/bindings.py
@@ -270,4 +270,22 @@ def get_bindings(state: StateVec) -> dict:
             tuple(qs) if isinstance(qs, list) else qs,
             {"angles": p["angles"]} if "angles" in p else {"angles": [0, 0, 0]},
         ),
+        # Controlled rotations -- dispatch the parameterized 2q gate to the
+        # Rust binding which then calls the new `crx`/`cry`/`crz` default
+        # methods on `ArbitraryRotationGateable` (1-RZZ 2q-minimal decomp).
+        "CRX": lambda _s, qs, **p: sim.run_2q_gate(
+            "CRX",
+            tuple(qs) if isinstance(qs, list) else qs,
+            {"angle": p["angles"][0]} if "angles" in p else {"angle": 0},
+        ),
+        "CRY": lambda _s, qs, **p: sim.run_2q_gate(
+            "CRY",
+            tuple(qs) if isinstance(qs, list) else qs,
+            {"angle": p["angles"][0]} if "angles" in p else {"angle": 0},
+        ),
+        "CRZ": lambda _s, qs, **p: sim.run_2q_gate(
+            "CRZ",
+            tuple(qs) if isinstance(qs, list) else qs,
+            {"angle": p["angles"][0]} if "angles" in p else {"angle": 0},
+        ),
     }
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py
index 9d1817972..f528aa880 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py
@@ -102,6 +102,9 @@
     GateKind.SYYdg,
     GateKind.SZZdg,
     GateKind.RZZ,
+    GateKind.CRX,
+    GateKind.CRY,
+    GateKind.CRZ,
 }
 
 
@@ -296,6 +299,17 @@ def _process_gate(self, node: GateOp) -> None:
         """Process a gate operation."""
         gate_name = GATE_TO_QC.get(node.gate, node.gate.name)
 
+        if node.params:
+            # Parameterized gates (RX/RY/RZ/RZZ/CRX/CRY/CRZ etc.):
+            # PECOS QuantumCircuit ticks are parallel sets keyed on
+            # (gate_name, params), so a tick mixing different param
+            # values would lose information. Flush the current tick,
+            # then emit the parameterized gate as its own tick via
+            # `circuit.append(gate, locations, angles=[...])` which the
+            # Rust gate registry routes to the typed-param dispatcher.
+            self._process_parameterized_gate(node, gate_name)
+            return
+
         if node.gate in TWO_QUBIT_GATES:
             self._process_two_qubit_gate(node, gate_name)
         else:
@@ -332,6 +346,48 @@ def _process_two_qubit_gate(self, node: GateOp, gate_name: str) -> None:
                 )
                 self._add_to_tick(gate_name, (q0, q1))
 
+    def _process_parameterized_gate(self, node: GateOp, gate_name: str) -> None:
+        """Emit a parameterized gate (rotation angle threaded through).
+
+        Resolves `LiteralExpr` bracket-params to raw floats (the AST
+        converter wraps `qb.RZ[0.5]` as a `LiteralExpr`, so a bare
+        `float(p)` would fail). The QC `circuit.append(...,
+        angles=...)` path forwards the angle list to Rust's typed-
+        parameter dispatcher (e.g. `RZ` requires 1 angle, `RXXRYYRZZ`
+        requires 3).
+
+        Flushes the current tick before emission so the parameterized
+        gate gets its own tick -- mixing different param values within
+        a single tick would lose information (tick batches by
+        `(gate_name, target)` only). Non-literal expressions (VarExpr,
+        BinaryExpr at gate-param position) are not yet supported for
+        QC parameterized gates; they fail loud here.
+        """
+        try:
+            angles = [float(p.value if isinstance(p, LiteralExpr) else p) for p in node.params]
+        except (AttributeError, TypeError) as exc:
+            msg = (
+                f"QuantumCircuit codegen: parameterized gate {gate_name!r} "
+                f"requires literal-float params; got non-literal: {node.params}."
+            )
+            raise NotImplementedError(msg) from exc
+
+        self._flush_tick()
+        if node.gate in TWO_QUBIT_GATES:
+            if len(node.targets) < 2:
+                msg = f"QuantumCircuit codegen: two-qubit gate {gate_name!r} needs >=2 targets, got {len(node.targets)}"
+                raise ValueError(msg)
+            # Emit each consecutive pair (mirrors the un-parameterized
+            # two-qubit path which iterates over target pairs).
+            for i in range(0, len(node.targets) - 1, 2):
+                q0 = self.context.get_qubit(node.targets[i].allocator, node.targets[i].index)
+                q1 = self.context.get_qubit(node.targets[i + 1].allocator, node.targets[i + 1].index)
+                self.circuit.append(gate_name, {(q0, q1)}, angles=angles)
+        else:
+            for target in node.targets:
+                qubit = self.context.get_qubit(target.allocator, target.index)
+                self.circuit.append(gate_name, {qubit}, angles=angles)
+
     def _process_measure(self, node: MeasureOp) -> None:
         """Process a measurement operation."""
         for target in node.targets:
diff --git a/python/quantum-pecos/tests/pecos/integration/state_sim_tests/test_statevec.py b/python/quantum-pecos/tests/pecos/integration/state_sim_tests/test_statevec.py
index fe2cb5641..c8761736d 100644
--- a/python/quantum-pecos/tests/pecos/integration/state_sim_tests/test_statevec.py
+++ b/python/quantum-pecos/tests/pecos/integration/state_sim_tests/test_statevec.py
@@ -339,6 +339,36 @@ def _apply(gate: dict, **params: object) -> None:
     check_measurement(simulator, qc)
 
 
+def test_controlled_rotations_statevec() -> None:
+    """CRX/CRY/CRZ via the StateVec backend (cross-codegen QC support).
+
+    Verifies the 1-RZZ default implementations in
+    `ArbitraryRotationGateable::{crx,cry,crz}` produce the textbook
+    block-diag(I, R*(theta)) action by comparing against direct
+    R*(theta) on the target with the control prepared in |1>.
+    """
+    theta = pc.f64.pi / 3
+    for sym, direct_sym in [("CRZ", "RZ"), ("CRX", "RX"), ("CRY", "RY")]:
+        # c=0: |00> stays |00>.
+        sim_c0 = StateVec(2)
+        sim_c0.backend.run_2q_gate(sym, (0, 1), {"angle": theta})
+        baseline_c0 = StateVec(2)
+        assert pc.allclose(sim_c0.backend.vector, baseline_c0.backend.vector), (
+            f"{sym}|00> changed the state -- expected identity when control=0"
+        )
+
+        # c=1: |10> -> |1, R*(theta)|0>>. Compare against direct R* on target.
+        sim_c1 = StateVec(2)
+        sim_c1.backend.run_1q_gate("X", 0, None)
+        sim_c1.backend.run_2q_gate(sym, (0, 1), {"angle": theta})
+        sim_direct = StateVec(2)
+        sim_direct.backend.run_1q_gate("X", 0, None)
+        sim_direct.backend.run_1q_gate(direct_sym, 1, {"angle": theta})
+        assert pc.allclose(sim_c1.backend.vector, sim_direct.backend.vector), (
+            f"{sym}(theta) when c=1 must equal direct {direct_sym}(theta) on target"
+        )
+
+
 @pytest.mark.parametrize(
     "simulator",
     [

From d8b18fc3b3902873176717ef6fe9b2a603c93488 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Wed, 20 May 2026 17:49:36 -0600
Subject: [PATCH 120/136] Cross-codegen: CRX/CRY/CRZ in
 CuStateVec/CudaStateVec/MPS simulator backends

---
 python/pecos-rslib-cuda/src/lib.rs            | 27 ++++++
 .../simulators/cuda_statevec/bindings.py      | 42 +++++++++
 .../pecos/simulators/custatevec/bindings.py   |  3 +
 .../simulators/custatevec/gates_two_qubit.py  | 67 ++++++++++++++
 .../pecos/simulators/mps_pytket/bindings.py   |  3 +
 .../simulators/mps_pytket/gates_two_qubit.py  | 91 +++++++++++++++++++
 .../state_sim_tests/test_statevec.py          |  3 +
 7 files changed, 236 insertions(+)

diff --git a/python/pecos-rslib-cuda/src/lib.rs b/python/pecos-rslib-cuda/src/lib.rs
index e68c01c60..be572de4d 100644
--- a/python/pecos-rslib-cuda/src/lib.rs
+++ b/python/pecos-rslib-cuda/src/lib.rs
@@ -392,6 +392,33 @@ impl PyCuStateVec {
         self.inner.rzz(Angle64::from_radians(angle), &pairs);
     }
 
+    /// Apply controlled-RX gate. Pairs of qubits = (control, target).
+    fn crx(&mut self, angle: f64, qubits: Vec<usize>) {
+        let pairs: Vec<(QubitId, QubitId)> = qubits
+            .chunks_exact(2)
+            .map(|c| (QubitId(c[0]), QubitId(c[1])))
+            .collect();
+        self.inner.crx(Angle64::from_radians(angle), &pairs);
+    }
+
+    /// Apply controlled-RY gate. Pairs of qubits = (control, target).
+    fn cry(&mut self, angle: f64, qubits: Vec<usize>) {
+        let pairs: Vec<(QubitId, QubitId)> = qubits
+            .chunks_exact(2)
+            .map(|c| (QubitId(c[0]), QubitId(c[1])))
+            .collect();
+        self.inner.cry(Angle64::from_radians(angle), &pairs);
+    }
+
+    /// Apply controlled-RZ gate. Pairs of qubits = (control, target).
+    fn crz(&mut self, angle: f64, qubits: Vec<usize>) {
+        let pairs: Vec<(QubitId, QubitId)> = qubits
+            .chunks_exact(2)
+            .map(|c| (QubitId(c[0]), QubitId(c[1])))
+            .collect();
+        self.inner.crz(Angle64::from_radians(angle), &pairs);
+    }
+
     /// Apply U gate (general single-qubit rotation).
     fn u(&mut self, theta: f64, phi: f64, lambda: f64, qubits: Vec<usize>) {
         let qubits: Vec<QubitId> = qubits.into_iter().map(QubitId).collect();
diff --git a/python/quantum-pecos/src/pecos/simulators/cuda_statevec/bindings.py b/python/quantum-pecos/src/pecos/simulators/cuda_statevec/bindings.py
index 9dad4fee8..de40bab06 100644
--- a/python/quantum-pecos/src/pecos/simulators/cuda_statevec/bindings.py
+++ b/python/quantum-pecos/src/pecos/simulators/cuda_statevec/bindings.py
@@ -412,6 +412,45 @@ def RZZ(
     state.backend.rzz(angles[0], list(qubits))
 
 
+def CRX(
+    state: CudaStateVec,
+    qubits: tuple[int, int],
+    angles: tuple[float],
+    **_params: SimulatorGateParams,
+) -> None:
+    """Controlled-RX gate (qubits = (control, target))."""
+    if len(angles) != 1:
+        msg = "CRX gate requires exactly 1 angle parameter."
+        raise ValueError(msg)
+    state.backend.crx(angles[0], list(qubits))
+
+
+def CRY(
+    state: CudaStateVec,
+    qubits: tuple[int, int],
+    angles: tuple[float],
+    **_params: SimulatorGateParams,
+) -> None:
+    """Controlled-RY gate (qubits = (control, target))."""
+    if len(angles) != 1:
+        msg = "CRY gate requires exactly 1 angle parameter."
+        raise ValueError(msg)
+    state.backend.cry(angles[0], list(qubits))
+
+
+def CRZ(
+    state: CudaStateVec,
+    qubits: tuple[int, int],
+    angles: tuple[float],
+    **_params: SimulatorGateParams,
+) -> None:
+    """Controlled-RZ gate (qubits = (control, target))."""
+    if len(angles) != 1:
+        msg = "CRZ gate requires exactly 1 angle parameter."
+        raise ValueError(msg)
+    state.backend.crz(angles[0], list(qubits))
+
+
 # =============================================================================
 # Gate dictionary
 # =============================================================================
@@ -505,6 +544,9 @@ def RZZ(
     "SqrtZZ": SZZ,
     "SZZdg": SZZdg,
     # Two-qubit rotations
+    "CRX": CRX,
+    "CRY": CRY,
+    "CRZ": CRZ,
     "RXX": RXX,
     "RYY": RYY,
     "RZZ": RZZ,
diff --git a/python/quantum-pecos/src/pecos/simulators/custatevec/bindings.py b/python/quantum-pecos/src/pecos/simulators/custatevec/bindings.py
index 93f3d2e8b..2c3791498 100644
--- a/python/quantum-pecos/src/pecos/simulators/custatevec/bindings.py
+++ b/python/quantum-pecos/src/pecos/simulators/custatevec/bindings.py
@@ -68,6 +68,9 @@
     "RXX": two_q.RXX,
     "RYY": two_q.RYY,
     "RZZ": two_q.RZZ,
+    "CRX": two_q.CRX,
+    "CRY": two_q.CRY,
+    "CRZ": two_q.CRZ,
     "RXXRYYRZZ": two_q.RXXRYYRZZ,
     "R2XXYYZZ": two_q.RXXRYYRZZ,
     "SXX": two_q.SXX,
diff --git a/python/quantum-pecos/src/pecos/simulators/custatevec/gates_two_qubit.py b/python/quantum-pecos/src/pecos/simulators/custatevec/gates_two_qubit.py
index 9544c9410..56faf886d 100644
--- a/python/quantum-pecos/src/pecos/simulators/custatevec/gates_two_qubit.py
+++ b/python/quantum-pecos/src/pecos/simulators/custatevec/gates_two_qubit.py
@@ -318,6 +318,73 @@ def RZZ(
     _apply_two_qubit_matrix(state, qubits, matrix)
 
 
+def CRX(
+    state: CuStateVec,
+    qubits: tuple[int, int],
+    angles: tuple[float],
+    **_params: SimulatorGateParams,
+) -> None:
+    """Controlled-RX gate (qubits[0] = control, qubits[1] = target).
+
+    Uses `_apply_controlled_matrix` so only the 2x2 RX(theta) action on
+    the target is passed; cuStateVec handles the controlled gating
+    internally. RX(theta) = [[cos(theta/2), -i sin(theta/2)],
+                              [-i sin(theta/2), cos(theta/2)]].
+    """
+    if len(angles) != 1:
+        msg = "CRX gate requires exactly 1 angle parameter."
+        raise ValueError(msg)
+    theta = float(angles[0])
+    c = cmath.cos(theta / 2)
+    s = cmath.sin(theta / 2)
+    matrix = cp.asarray([c, -1j * s, -1j * s, c], dtype=state.cp_type)
+    _apply_controlled_matrix(state, qubits[0], qubits[1], matrix)
+
+
+def CRY(
+    state: CuStateVec,
+    qubits: tuple[int, int],
+    angles: tuple[float],
+    **_params: SimulatorGateParams,
+) -> None:
+    """Controlled-RY gate (qubits[0] = control, qubits[1] = target).
+
+    Uses `_apply_controlled_matrix` with the 2x2 RY(theta) on target.
+    RY(theta) = [[cos(theta/2), -sin(theta/2)],
+                  [sin(theta/2), cos(theta/2)]].
+    """
+    if len(angles) != 1:
+        msg = "CRY gate requires exactly 1 angle parameter."
+        raise ValueError(msg)
+    theta = float(angles[0])
+    c = cmath.cos(theta / 2)
+    s = cmath.sin(theta / 2)
+    matrix = cp.asarray([c, -s, s, c], dtype=state.cp_type)
+    _apply_controlled_matrix(state, qubits[0], qubits[1], matrix)
+
+
+def CRZ(
+    state: CuStateVec,
+    qubits: tuple[int, int],
+    angles: tuple[float],
+    **_params: SimulatorGateParams,
+) -> None:
+    """Controlled-RZ gate (qubits[0] = control, qubits[1] = target).
+
+    Uses `_apply_controlled_matrix` with the 2x2 RZ(theta) on target.
+    RZ(theta) = diag(exp(-i theta/2), exp(i theta/2)).
+    """
+    if len(angles) != 1:
+        msg = "CRZ gate requires exactly 1 angle parameter."
+        raise ValueError(msg)
+    theta = float(angles[0])
+    matrix = cp.asarray(
+        [cmath.exp(-1j * theta / 2), 0, 0, cmath.exp(1j * theta / 2)],
+        dtype=state.cp_type,
+    )
+    _apply_controlled_matrix(state, qubits[0], qubits[1], matrix)
+
+
 def RXXRYYRZZ(
     state: CuStateVec,
     qubits: tuple[int, int],
diff --git a/python/quantum-pecos/src/pecos/simulators/mps_pytket/bindings.py b/python/quantum-pecos/src/pecos/simulators/mps_pytket/bindings.py
index aad2a2deb..2b0191145 100644
--- a/python/quantum-pecos/src/pecos/simulators/mps_pytket/bindings.py
+++ b/python/quantum-pecos/src/pecos/simulators/mps_pytket/bindings.py
@@ -65,6 +65,9 @@
     "CX": two_q.CX,
     "CY": two_q.CY,
     "CZ": two_q.CZ,
+    "CRX": two_q.CRX,
+    "CRY": two_q.CRY,
+    "CRZ": two_q.CRZ,
     "RXX": two_q.RXX,
     "RYY": two_q.RYY,
     "RZZ": two_q.RZZ,
diff --git a/python/quantum-pecos/src/pecos/simulators/mps_pytket/gates_two_qubit.py b/python/quantum-pecos/src/pecos/simulators/mps_pytket/gates_two_qubit.py
index 75554de1e..0c7c8c039 100644
--- a/python/quantum-pecos/src/pecos/simulators/mps_pytket/gates_two_qubit.py
+++ b/python/quantum-pecos/src/pecos/simulators/mps_pytket/gates_two_qubit.py
@@ -203,6 +203,97 @@ def RZZ(
     _apply_two_qubit_matrix(state, qubits, matrix)
 
 
+def CRX(
+    state: MPS,
+    qubits: tuple[int, int],
+    angles: tuple[float],
+    **_params: SimulatorGateParams,
+) -> None:
+    """Controlled-RX gate (qubits[0] = control, qubits[1] = target).
+
+    Block-diag(I, RX(theta)) in q0-HIGH basis (MPS convention):
+        [[1, 0, 0, 0],
+         [0, 1, 0, 0],
+         [0, 0, cos(theta/2), -i sin(theta/2)],
+         [0, 0, -i sin(theta/2), cos(theta/2)]].
+    """
+    if len(angles) != 1:
+        msg = "CRX gate requires exactly 1 angle parameter."
+        raise ValueError(msg)
+    theta = angles[0]
+    c = cmath.cos(theta / 2)
+    s = cmath.sin(theta / 2)
+    matrix = cp.asarray(
+        [
+            [1, 0, 0, 0],
+            [0, 1, 0, 0],
+            [0, 0, c, -1j * s],
+            [0, 0, -1j * s, c],
+        ],
+        dtype=state.dtype,
+    )
+    _apply_two_qubit_matrix(state, qubits, matrix)
+
+
+def CRY(
+    state: MPS,
+    qubits: tuple[int, int],
+    angles: tuple[float],
+    **_params: SimulatorGateParams,
+) -> None:
+    """Controlled-RY gate (qubits[0] = control, qubits[1] = target).
+
+    Block-diag(I, RY(theta)) in q0-HIGH basis:
+        [[1, 0, 0, 0],
+         [0, 1, 0, 0],
+         [0, 0, cos(theta/2), -sin(theta/2)],
+         [0, 0, sin(theta/2), cos(theta/2)]].
+    """
+    if len(angles) != 1:
+        msg = "CRY gate requires exactly 1 angle parameter."
+        raise ValueError(msg)
+    theta = angles[0]
+    c = cmath.cos(theta / 2)
+    s = cmath.sin(theta / 2)
+    matrix = cp.asarray(
+        [
+            [1, 0, 0, 0],
+            [0, 1, 0, 0],
+            [0, 0, c, -s],
+            [0, 0, s, c],
+        ],
+        dtype=state.dtype,
+    )
+    _apply_two_qubit_matrix(state, qubits, matrix)
+
+
+def CRZ(
+    state: MPS,
+    qubits: tuple[int, int],
+    angles: tuple[float],
+    **_params: SimulatorGateParams,
+) -> None:
+    """Controlled-RZ gate (qubits[0] = control, qubits[1] = target).
+
+    Block-diag(I, RZ(theta)) in q0-HIGH basis: diag(1, 1,
+    exp(-i theta/2), exp(i theta/2)).
+    """
+    if len(angles) != 1:
+        msg = "CRZ gate requires exactly 1 angle parameter."
+        raise ValueError(msg)
+    theta = angles[0]
+    matrix = cp.asarray(
+        [
+            [1, 0, 0, 0],
+            [0, 1, 0, 0],
+            [0, 0, cmath.exp(-1j * theta / 2), 0],
+            [0, 0, 0, cmath.exp(1j * theta / 2)],
+        ],
+        dtype=state.dtype,
+    )
+    _apply_two_qubit_matrix(state, qubits, matrix)
+
+
 def RXXRYYRZZ(
     state: MPS,
     qubits: tuple[int, int],
diff --git a/python/quantum-pecos/tests/pecos/integration/state_sim_tests/test_statevec.py b/python/quantum-pecos/tests/pecos/integration/state_sim_tests/test_statevec.py
index c8761736d..6520ec178 100644
--- a/python/quantum-pecos/tests/pecos/integration/state_sim_tests/test_statevec.py
+++ b/python/quantum-pecos/tests/pecos/integration/state_sim_tests/test_statevec.py
@@ -313,6 +313,9 @@ def _apply(gate: dict, **params: object) -> None:
     _apply({"SWAP": {(3, 0)}})
     _apply({"Tdg": {3, 1}})
     _apply({"RXX": {(1, 3)}}, angles=(pc.f64.frac_pi_4,))
+    _apply({"CRZ": {(0, 1)}}, angles=(pc.f64.pi / 5,))
+    _apply({"CRX": {(2, 3)}}, angles=(pc.f64.pi / 7,))
+    _apply({"CRY": {(1, 2)}}, angles=(pc.f64.pi / 6,))
     _apply({"Q": {0, 1, 2}})
     _apply({"Qd": {0, 3}})
     _apply({"R": {0}})

From b13987cc616fb3f581ca084772b4c558c946d058 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Wed, 20 May 2026 18:33:12 -0600
Subject: [PATCH 121/136] Cross-codegen post-review fold (Codex blocker): CR*
 control-superposition phase test

---
 .../ast_guppy/test_qir_corpus_executable.py   | 38 +++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
index d421ca112..bbb875201 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
@@ -622,3 +622,41 @@ def _run(prep, ops, meas_idx=0):
     assert _run([x_q0], [crx_half, crx_half], meas_idx=1) == {(1,)}, "CRX(pi/2)^2 must agree with Test A CRX(pi)"
     assert _run([x_q0], [cry_half, cry_half], meas_idx=1) == {(1,)}, "CRY(pi/2)^2 must agree with Test A CRY(pi)"
     assert _run([x_q0], [crz_half, crz_half], meas_idx=1) == {(0,)}, "CRZ(pi/2)^2 must agree with Test A CRZ(pi)"
+
+    # Control-superposition phase test (Test C). Tests A/B and the
+    # angle-propagation tests above all put the control in a
+    # computational basis state, so they cannot observe the c=1-only
+    # relative phase that the control-side `RZ(theta/2)` in the
+    # `_GATE_DECOMP[CR*]` is there to absorb. Mutations that drop
+    # the control RZ (or change its angle to theta instead of
+    # theta/2) survive Tests A/B silently.
+    #
+    # The discriminator (per Codex review): prep `|+>` on the
+    # control and an R*(pi)-eigenstate on the target so the
+    # CORRECT decomp leaves the control in `|+>`; then H(control)
+    # takes `|+>` -> `|0>` deterministically.
+    #   - CRZ(pi): target=|0>, RZ(pi)|0>=|0> in PECOS convention
+    #     (no kickback when target=|0>); correct CR*: control
+    #     stays in |+>, H sends to |0>, measure 0.
+    #   - CRX(pi): target=|+>, RX(pi)~X, X|+>=|+>: same logic.
+    #   - CRY(pi): target=|+i>=(|0>+i|1>)/sqrt(2), RY(pi)~Y,
+    #     Y|+i>=|+i>: same logic.
+    # A mutation (drop control RZ, or use theta on control instead
+    # of theta/2) gives the control sector a c=1-only relative
+    # phase, rotating it off |+>, so H(control); M(control) is no
+    # longer deterministic 0.
+    h_q0 = lambda q: qb.H(q[0])  # noqa: E731
+    sz_q1 = lambda q: qb.SZ(q[1])  # noqa: E731
+
+    # CRZ phase: H q0; CRZ(pi); H q0; M q0 -> 0 (target=|0>).
+    assert _run([h_q0], [crz_pi, h_q0], meas_idx=0) == {
+        (0,),
+    }, "CRZ(pi) control-phase: H q0; CRZ; H q0; M q0 must be 0 (drop-control-RZ / wrong-angle mutations break this)"
+    # CRX phase: H q0; H q1; CRX(pi); H q0; M q0 -> 0 (target=|+>).
+    assert _run([h_q0, h_q1], [crx_pi, h_q0], meas_idx=0) == {
+        (0,),
+    }, "CRX(pi) control-phase: H q0; H q1; CRX; H q0; M q0 must be 0"
+    # CRY phase: H q0; H q1; SZ q1; CRY(pi); H q0; M q0 -> 0 (target=|+i>).
+    assert _run([h_q0, h_q1, sz_q1], [cry_pi, h_q0], meas_idx=0) == {
+        (0,),
+    }, "CRY(pi) control-phase: H q0; H q1; SZ q1; CRY; H q0; M q0 must be 0"

From e4768f9f45fb23e12bfc3a187793ede5266aac58 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Wed, 20 May 2026 19:33:25 -0600
Subject: [PATCH 122/136] #94 B1: classical-variable (whole-CReg scalar) QIR
 lowering via shared i64 pack

---
 .../src/pecos/slr/ast/codegen/qir.py          | 86 +++++++++++------
 .../ast_guppy/test_tier2_semantic.py          | 14 ++-
 .../regression/random_cases/test_slr_phys.py  | 93 ++++++++++++-------
 3 files changed, 125 insertions(+), 68 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
index a28f587ba..bd4008391 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
@@ -421,13 +421,22 @@ def _declare_function(self, name: str, ret_ty: Any, arg_tys: list) -> Any:
 
     def _setup_op_map(self) -> None:
         """Setup binary operator mapping."""
+        # B1: CReg comparisons are UNSIGNED (the CReg's `[N x i1]` buffer
+        # packs to an i64 unsigned bit pattern via `_pack_creg`). The
+        # `icmp_unsigned` choice matters only when bit 63 of a 64-bit
+        # CReg is set; for narrower CRegs (or for bit-level `c[i]`
+        # comparisons that zext to i64 with the top 63 bits zero)
+        # signed and unsigned agree. Switching is safe -- no existing
+        # test asserts the signed semantics on a high-bit-set 64-bit
+        # CReg, and unsigned is the correct interpretation of the
+        # bit-pattern semantics SLR exposes (cf. B1 D3).
         self._op_map = {
-            BinaryOp.EQ: lambda lhs, rhs: self._builder.icmp_signed("==", lhs, rhs),
-            BinaryOp.NE: lambda lhs, rhs: self._builder.icmp_signed("!=", lhs, rhs),
-            BinaryOp.LT: lambda lhs, rhs: self._builder.icmp_signed("<", lhs, rhs),
-            BinaryOp.GT: lambda lhs, rhs: self._builder.icmp_signed(">", lhs, rhs),
-            BinaryOp.LE: lambda lhs, rhs: self._builder.icmp_signed("<=", lhs, rhs),
-            BinaryOp.GE: lambda lhs, rhs: self._builder.icmp_signed(">=", lhs, rhs),
+            BinaryOp.EQ: lambda lhs, rhs: self._builder.icmp_unsigned("==", lhs, rhs),
+            BinaryOp.NE: lambda lhs, rhs: self._builder.icmp_unsigned("!=", lhs, rhs),
+            BinaryOp.LT: lambda lhs, rhs: self._builder.icmp_unsigned("<", lhs, rhs),
+            BinaryOp.GT: lambda lhs, rhs: self._builder.icmp_unsigned(">", lhs, rhs),
+            BinaryOp.LE: lambda lhs, rhs: self._builder.icmp_unsigned("<=", lhs, rhs),
+            BinaryOp.GE: lambda lhs, rhs: self._builder.icmp_unsigned(">=", lhs, rhs),
             BinaryOp.MUL: self._builder.mul,
             BinaryOp.DIV: self._builder.udiv,
             BinaryOp.XOR: self._builder.xor,
@@ -926,15 +935,19 @@ def _eval_expression(self, expr: Expression) -> Any:
             return self._builder.zext(bit, self._types["int"])
 
         if isinstance(expr, VarExpr):
-            # Classical scalar-variable lowering is unimplemented in the
-            # QIR backend. Silently evaluating every VarExpr as constant
-            # 0 is a miscompile -- fail LOUD instead.
-            msg = (
-                f"QIR codegen: classical variable {expr.name!r} is not "
-                "supported by the QIR backend (scalar-variable lowering is "
-                "unimplemented; it must not be silently evaluated as 0)."
-            )
-            raise NotImplementedError(msg)
+            # B1: a classical `VarExpr` denotes a whole CReg used as a
+            # scalar (e.g. `If(m == 0)`, `o.set(m + n)`, Steane
+            # `smid_flag_x`). SLR has no scalar-integer classical type
+            # (verified: `pecos.slr.vars` exposes only Reg/CReg/Bit/
+            # SymbolicElem/LoopVar; `LoopVar` is the compile-time `For`
+            # index and is substituted before this point). The lowering
+            # is the existing i64 pack (`OR_i (zext c[i] << i)`)
+            # factored out of `_generate_results` as `_pack_creg`. A
+            # `VarExpr` whose name is not a declared Main-scope CReg
+            # fails LOUD via `_require_creg`, preserving the
+            # #74/#80 anti-silent-0 guarantee.
+            self._require_creg(expr.name)
+            return self._pack_creg(expr.name)
 
         if isinstance(expr, BinaryExpr):
             left = self._eval_expression(expr.left)
@@ -1125,6 +1138,32 @@ def _process_permute(self, node: PermuteOp) -> None:
         for s_ref, t_ref in mapping.items():
             self.context.permutation_map[s_ref] = old.get(t_ref, t_ref)
 
+    def _pack_creg(self, reg_name: str) -> Any:
+        """Pack a CReg's `[N x i1]` buffer into a single i64 value.
+
+        `OR_i (zext c[i] << i)` -- this is the canonical SLR CReg-as-
+        integer lowering. Used by both `_generate_results` (for the
+        `__quantum__rt__int_record_output` call) and by
+        `_eval_expression(VarExpr)` (B1 -- a whole-CReg scalar
+        reference in `If(m == 0)` / `o.set(m + n)` / etc.). Sharing
+        the pack ensures the record-output and VarExpr interpretations
+        of `m` are bit-identical -- the same packed i64.
+        """
+        c_int: Any = llvm_ir.Constant(self._types["int"], 0)
+        for i in range(self.context.creg_map.get(reg_name, 0)):
+            bit = self._builder.load(
+                self._creg_bit_ptr(reg_name, i),
+                name="",
+            )
+            widened = self._builder.zext(bit, self._types["int"])
+            if i:
+                widened = self._builder.shl(
+                    widened,
+                    llvm_ir.Constant(self._types["int"], i),
+                )
+            c_int = self._builder.or_(c_int, widened)
+        return c_int
+
     def _generate_results(self) -> None:
         """Generate result output calls."""
         for reg_name in self._creg_ptrs:
@@ -1136,20 +1175,9 @@ def _generate_results(self) -> None:
             reg_tag.global_constant = True
             reg_tag.linkage = "private"
 
-            # Pack the [N x i1] buffer into one i64: OR_i (zext c[i] << i).
-            c_int = llvm_ir.Constant(self._types["int"], 0)
-            for i in range(self.context.creg_map.get(reg_name, 0)):
-                bit = self._builder.load(
-                    self._creg_bit_ptr(reg_name, i),
-                    name="",
-                )
-                widened = self._builder.zext(bit, self._types["int"])
-                if i:
-                    widened = self._builder.shl(
-                        widened,
-                        llvm_ir.Constant(self._types["int"], i),
-                    )
-                c_int = self._builder.or_(c_int, widened)
+            # Pack the [N x i1] buffer into one i64 (shared with the
+            # B1 VarExpr lowering).
+            c_int = self._pack_creg(reg_name)
 
             reg_tag_gep = reg_tag.gep(
                 (
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_tier2_semantic.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_tier2_semantic.py
index 78d0cdd38..528319611 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_tier2_semantic.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_tier2_semantic.py
@@ -393,11 +393,15 @@ def test_static_for_unrolls_body_not_dropped() -> None:
 
 
 def test_varexpr_raises_loud() -> None:
-    """#74: a classical `VarExpr` must FAIL LOUD, not silently
-    evaluate to constant 0 (a value miscompile qir-qis cannot catch).
-    Unit-level: the `VarExpr` arm is reached before any `self._types`
-    use, so a bare generator suffices."""
-    with pytest.raises(NotImplementedError, match=r"classical variable 'x'"):
+    """#74/B1: a classical `VarExpr` whose name is not a declared
+    Main-scope CReg must FAIL LOUD, not silently evaluate to constant
+    0 (a value miscompile qir-qis cannot catch). B1 changed the
+    VarExpr arm from an unconditional fail-loud to "pack the CReg
+    via `_pack_creg` if known, fail loud via `_require_creg`
+    otherwise". The stray-name path still fails loud, just with the
+    `_require_creg` "not declared at Main scope" message (the
+    anti-silent-0 invariant the #74 test pins is preserved)."""
+    with pytest.raises(NotImplementedError, match=r"classical register 'x'.*not.*declared at Main scope"):
         AstToQir()._eval_expression(VarExpr(name="x"))  # noqa: SLF001
 
 
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py b/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py
index 5d17655f6..7df57a005 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py
@@ -140,32 +140,48 @@ def test_control_flow_qir() -> None:
         p.Measure(q) > m,
         Return(m),
     )
-    # #74/#80: whole-CReg scalar conditions (`If(m == 0)` /
-    # `If(m < m_hidden)`) are classical-variable lowering, which the
-    # QIR backend deliberately fails LOUD on (unimplemented; must not
-    # be silently evaluated as 0). Correct post-#74/#80 behavior.
-    with pytest.raises(NotImplementedError, match=r"classical variable"):
-        SlrConverter(prog).qir()
+    # B1: whole-CReg scalar conditions (`If(m == 0)` / `If(m <
+    # m_hidden)`) are now lowered via `_pack_creg` + `_op_map`; the
+    # QIR builds. CAVEAT: `RX[0.3]` in the program has NO qir-qis
+    # lowering (`docs.rotation_rx` is pinned BUILD/exec-failure;
+    # Stim no-ops rx), so the program is NOT end-to-end-executable
+    # post-B1 -- it BUILDS but cannot run through qir_to_qis. Assert
+    # the build succeeds and the QIR contains the expected
+    # classical-comparison structure; end-to-end execution is
+    # covered by `test_plus_qir` / `test_minus_qir` (pure-classical
+    # + Clifford only).
+    qir = SlrConverter(prog).qir()
+    # `If(m == 0)` and `If(m < m_hidden)` lower to icmp + i64 packs.
+    assert "icmp" in qir, "B1 If(m == 0) must lower to an icmp"
+    assert "or i64" in qir, "B1 whole-CReg pack must emit OR_i (zext c[i] << i)"
 
 
 @pytest.mark.optional_dependency
 def test_plus_qir() -> None:
-    """Test a program with addition compiling into QIR."""
+    """B1: whole-CReg scalar arithmetic (`o.set(m + n)`) lowers via
+    `_pack_creg` + i64 `add`, then unpacks back to `o`'s bits."""
     prog = Main(
         _q := QReg("q", 2),
         m := CReg("m", 2),
         n := CReg("n", 2),
-        o := CReg("o", 2),
+        o := CReg("o", 3),  # 3 bits hold up to 7; 2-bit `o` would silently truncate m+n=2+2=4
         m.set(2),
         n.set(2),
         o.set(m + n),
         Return(m, n, o),
     )
-    # #74/#80: whole-CReg scalar arithmetic (`o.set(m + n)`) is
-    # classical-variable lowering, deliberately FAIL-LOUD in the QIR
-    # backend (unimplemented; must not be silently evaluated as 0).
-    with pytest.raises(NotImplementedError, match=r"classical variable"):
-        SlrConverter(prog).qir()
+    qir = SlrConverter(prog).qir()
+    assert "add i64" in qir, "B1 m + n must lower to an i64 add"
+
+    # End-to-end: m=2, n=2, o=m+n=4. Pure-classical + Clifford only,
+    # so the program executes through qir_to_qis + Stim.
+    import qir_qis
+    import selene_sim
+
+    qis = qir_qis.qir_to_qis(SlrConverter(prog).qir_bc())
+    inst = selene_sim.build(selene_sim.BitcodeString(qis))
+    for shot in inst.run_shots(selene_sim.Stim(random_seed=1), n_qubits=2, n_shots=2):
+        assert [v for (_t, v) in shot] == [2, 2, 4], shot
 
 
 @pytest.mark.optional_dependency
@@ -189,42 +205,51 @@ def test_nested_xor_qir() -> None:
 
 @pytest.mark.optional_dependency
 def test_minus_qir() -> None:
-    """Test a program with addition compiling into QIR."""
+    """B1: whole-CReg scalar subtraction (`o.set(m - n)`) lowers via
+    `_pack_creg` + i64 `sub`. Pure-classical + Clifford only -- runs
+    end-to-end through qir_to_qis + Stim."""
     prog = Main(
         _q := QReg("q", 2),
         m := CReg("m", 2),
         n := CReg("n", 2),
-        o := CReg("o", 2),
-        m.set(2),
-        n.set(2),
+        o := CReg("o", 2),  # 2 bits: m=3, n=1, o=m-n=2 fits.
+        m.set(3),
+        n.set(1),
         o.set(m - n),
         Return(m, n, o),
     )
-    # #74/#80: whole-CReg scalar arithmetic (`o.set(m - n)`) is
-    # classical-variable lowering, deliberately FAIL-LOUD in the QIR
-    # backend (unimplemented; must not be silently evaluated as 0).
-    with pytest.raises(NotImplementedError, match=r"classical variable"):
-        SlrConverter(prog).qir()
+    qir = SlrConverter(prog).qir()
+    assert "sub i64" in qir, "B1 m - n must lower to an i64 sub"
+
+    import qir_qis
+    import selene_sim
+
+    qis = qir_qis.qir_to_qis(SlrConverter(prog).qir_bc())
+    inst = selene_sim.build(selene_sim.BitcodeString(qis))
+    for shot in inst.run_shots(selene_sim.Stim(random_seed=1), n_qubits=2, n_shots=2):
+        assert [v for (_t, v) in shot] == [3, 1, 2], shot
 
 
 @pytest.mark.optional_dependency
 def test_steane_qir() -> None:
-    """Test the teleportation program using the Steane code."""
-    # #74/#80: the Steane teleportation uses a classical scalar var
-    # (`smid_flag_x`), classical-variable lowering -> deliberately
-    # FAIL-LOUD in the QIR backend (unimplemented; not silent-0).
-    with pytest.raises(NotImplementedError, match=r"classical variable"):
-        SlrConverter(telep("X", "X")).qir()
+    """B1: the Steane teleportation uses a classical scalar var
+    (`smid_flag_x` -- a `CReg(..., 3)`); B1's `_pack_creg` lowers
+    this scalar reference, so the program builds. The full
+    teleportation contains non-Clifford rotations and the executable
+    path is out of scope for this test -- assert the build succeeds
+    + the emitted QIR has the expected classical-pack structure."""
+    qir = SlrConverter(telep("X", "X")).qir()
+    assert "icmp" in qir, "Steane telep `If(flag == 0)` must lower to icmp"
+    assert "or i64" in qir, "Steane telep flag pack must emit OR_i (zext c[i] << i)"
 
 
 @pytest.mark.optional_dependency
 def test_steane_qir_bc() -> None:
-    """Test the teleportation program using the Steane code."""
-    # #74/#80: same `smid_flag_x` classical scalar var -> the QIR
-    # bitcode path also fails LOUD (unimplemented classical-variable
-    # lowering; must not be silently evaluated as 0).
-    with pytest.raises(NotImplementedError, match=r"classical variable"):
-        SlrConverter(telep("X", "X")).qir_bc()
+    """B1: same Steane telep program through the QIR bitcode path.
+    The bitcode builds (no longer fails loud on classical-variable
+    lowering)."""
+    bc = SlrConverter(telep("X", "X")).qir_bc()
+    assert bc, "qir_bc must return non-empty bitcode for Steane telep post-B1"
 
 
 @pytest.mark.optional_dependency

From 0b6560df480d79abcb147f980c133c469d87c95d Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Wed, 20 May 2026 20:14:46 -0600
Subject: [PATCH 123/136] Cross-codegen Guppy Phase A: native SX/SXdg (v/vdg) +
 RX/RY/RZ/CRZ rotations

---
 .../src/pecos/slr/ast/codegen/guppy.py        |  76 +++++++++-
 .../slr_tests/ast_guppy/test_v1_behavioral.py | 142 ++++++++++++++++++
 2 files changed, 215 insertions(+), 3 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
index b7a7fcb81..c0bdcf299 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
@@ -19,6 +19,7 @@
 
 from __future__ import annotations
 
+import math
 import re
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, cast
@@ -90,13 +91,28 @@
     GateKind.Tdg: "tdg",
     GateKind.SZ: "s",
     GateKind.SZdg: "sdg",
+    # Guppy's `v`/`vdg` are sqrt(X) / sqrt(X)-dagger (the standard V gate).
+    GateKind.SX: "v",
+    GateKind.SXdg: "vdg",
     GateKind.CX: "cx",
     GateKind.CY: "cy",
     GateKind.CZ: "cz",
     GateKind.CH: "ch",
 }
 
-FUNCTIONAL_GATE_IMPORTS = ", ".join(sorted(set(FUNCTIONAL_GATES.values()) | {"reset"}))
+# Native Guppy parameterized rotation gates: `fn(qubit..., angle)`.
+# Guppy's `angle` type stores half-turns (pi radians = 1.0 half-turn),
+# so a radians value theta is emitted as `angle(theta / pi)`.
+PARAMETERIZED_FUNCTIONAL_GATES: dict[GateKind, str] = {
+    GateKind.RX: "rx",
+    GateKind.RY: "ry",
+    GateKind.RZ: "rz",
+    GateKind.CRZ: "crz",
+}
+
+FUNCTIONAL_GATE_IMPORTS = ", ".join(
+    sorted(set(FUNCTIONAL_GATES.values()) | set(PARAMETERIZED_FUNCTIONAL_GATES.values()) | {"reset"}),
+)
 
 BINARY_OP_TO_PYTHON: dict[BinaryOp, str] = {
     BinaryOp.ADD: "+",
@@ -642,13 +658,18 @@ def _reject_alloc(where: str, alloc: str) -> None:
                                 )
 
     def _imports(self) -> list[str]:
-        return [
+        imports = [
             "from guppylang import guppy",
             "from guppylang.std.builtins import array, owned, result",
             "from guppylang.std.mem import mem_swap",
             "from guppylang.std.quantum import discard, measure, qubit",
             f"from guppylang.std.quantum.functional import {FUNCTIONAL_GATE_IMPORTS}",
         ]
+        # `angle` is only needed when the program emits a parameterized
+        # rotation; import it unconditionally (cheap, keeps the emitter
+        # simple). Half-turn-valued `angle(...)` constructor.
+        imports.append("from guppylang.std.angles import angle")
+        return imports
 
     def _render_params(self) -> str:
         return ", ".join(f"{name}: array[qubit, {size}] @ owned" for name, size in self.context.root_allocators.items())
@@ -998,6 +1019,9 @@ def _emit_stmt(self, stmt: Statement) -> list[str]:
         raise GuppyCodegenError(msg)
 
     def _emit_gate(self, node: GateOp) -> list[str]:
+        if node.gate in PARAMETERIZED_FUNCTIONAL_GATES:
+            return self._emit_parameterized_gate(node)
+
         gate = FUNCTIONAL_GATES.get(node.gate)
         if gate is None:
             self._raise_unsupported_gate(node.gate)
@@ -1028,8 +1052,54 @@ def _emit_gate(self, node: GateOp) -> list[str]:
         msg = f"AST -> Guppy v1 does not support {node.gate.arity}-qubit gate {node.gate.name}"
         raise GuppyCodegenError(msg)
 
+    def _emit_parameterized_gate(self, node: GateOp) -> list[str]:
+        """Emit a native Guppy rotation: `fn(qubit..., angle(theta/pi))`.
+
+        Guppy's `angle` stores half-turns (pi rad == 1.0 half-turn), so
+        a radians value `theta` becomes `angle(theta / pi)`. Only
+        literal angles are supported (a non-literal classical
+        expression at a gate-param position fails loud, mirroring the
+        QIR backend's parameterized-decomposition guard).
+        """
+        gate = PARAMETERIZED_FUNCTIONAL_GATES[node.gate]
+        if not node.params:
+            msg = f"AST -> Guppy v1: parameterized gate {node.gate.name} requires an angle parameter"
+            raise GuppyCodegenError(msg)
+        angle_args = []
+        for param in node.params:
+            if not isinstance(param, LiteralExpr) or not isinstance(param.value, (int, float)):
+                msg = (
+                    f"AST -> Guppy v1: parameterized gate {node.gate.name} requires literal "
+                    f"angle parameters; got non-literal {param!r}"
+                )
+                raise GuppyCodegenError(msg)
+            angle_args.append(f"angle({float(param.value) / math.pi})")
+        angle_str = ", ".join(angle_args)
+
+        slots = [self._slot_from_ref(target) for target in node.targets]
+        if len(slots) != len(set(slots)):
+            msg = f"Gate {node.gate.name} uses the same qubit slot more than once"
+            raise GuppyCodegenError(msg)
+
+        linearity = self._linearity()
+        locals_ = [linearity.live(slot) for slot in slots]
+
+        if node.gate.arity == 1:
+            local = locals_[0]
+            linearity.set_live(slots[0], local)
+            return [f"{self.context.indent()}{local} = {gate}({local}, {angle_str})"]
+
+        if node.gate.arity == 2:
+            left, right = locals_
+            linearity.set_live(slots[0], left)
+            linearity.set_live(slots[1], right)
+            return [f"{self.context.indent()}{left}, {right} = {gate}({left}, {right}, {angle_str})"]
+
+        msg = f"AST -> Guppy v1 does not support {node.gate.arity}-qubit parameterized gate {node.gate.name}"
+        raise GuppyCodegenError(msg)
+
     def _raise_unsupported_gate(self, gate: GateKind) -> None:
-        if gate in {GateKind.SX, GateKind.SXdg, GateKind.SY, GateKind.SYdg}:
+        if gate in {GateKind.SY, GateKind.SYdg}:
             msg = f"AST -> Guppy v1 rejects {gate.name}; decompose it before Guppy emission"
             raise GuppyCodegenError(msg)
         if gate.is_parameterized:
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py
index c4ac8ff67..d1ea583c9 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py
@@ -26,6 +26,8 @@
 
 from __future__ import annotations
 
+import math
+
 from pecos.slr import CReg, If, Main, Permute, QReg, Return
 from pecos.slr.qeclib import qubit as qb
 from pecos.slr.qeclib.qubit.measures import Measure
@@ -366,3 +368,143 @@ def test_internal_measurement_does_not_shift_mapping(self) -> None:
         )
         records = run_ast_guppy_via_selene(prog, shots=10)
         assert all(r["measurement_0"] == 0 for r in records), records
+
+
+class TestNativeGuppyGates:
+    """Cross-codegen Phase A: PECOS gates now mapped to native Guppy
+    stdlib gates -- SX/SXdg -> v/vdg (sqrt-X), and the parameterized
+    rotations RX/RY/RZ -> rx/ry/rz, CRZ -> crz (all `guppylang.std`).
+
+    Each discriminator is deterministic and mutation-resistant:
+    catches a no-op (mapping dropped), and -- where handedness
+    matters -- a v<->vdg swap. Expected outcomes pre-computed against
+    a numpy reference for the PECOS gate conventions.
+    """
+
+    def test_sx_squares_to_x(self) -> None:
+        """SX; SX = X on |0> -> 1 (catches SX mapped to a no-op)."""
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            qb.SX(q[0]),
+            qb.SX(q[0]),
+            Measure(q[0]) > c[0],
+            Return(c),
+        )
+        records = run_ast_guppy_via_selene(prog, shots=20)
+        assert all(r["measurement_0"] == 1 for r in records), records
+
+    def test_sx_handedness(self) -> None:
+        """`|0>; SX; SZ; H; M` -> 0 deterministically (numpy-verified).
+
+        A v<->vdg swap gives 1; a no-op gives 50/50. This pins SX = v
+        (the correct sqrt-X handedness), not vdg.
+        """
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            qb.SX(q[0]),
+            qb.SZ(q[0]),
+            qb.H(q[0]),
+            Measure(q[0]) > c[0],
+            Return(c),
+        )
+        records = run_ast_guppy_via_selene(prog, shots=20)
+        assert all(r["measurement_0"] == 0 for r in records), records
+
+    def test_sxdg_handedness_and_inverse(self) -> None:
+        """`|0>; SXdg; SZ; H; M` -> 1 (mirror of SX); and SX;SXdg = I."""
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            qb.SXdg(q[0]),
+            qb.SZ(q[0]),
+            qb.H(q[0]),
+            Measure(q[0]) > c[0],
+            Return(c),
+        )
+        records = run_ast_guppy_via_selene(prog, shots=20)
+        assert all(r["measurement_0"] == 1 for r in records), records
+
+        inverse = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            qb.SX(q[0]),
+            qb.SXdg(q[0]),
+            Measure(q[0]) > c[0],
+            Return(c),
+        )
+        recs2 = run_ast_guppy_via_selene(inverse, shots=20)
+        assert all(r["measurement_0"] == 0 for r in recs2), recs2
+
+    def test_rx_pi_is_x(self) -> None:
+        """RX(pi)|0> = X|0> = |1> (up to phase) -> 1. RX(pi/2)^2 = RX(pi)."""
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            qb.RX[math.pi](q[0]),
+            Measure(q[0]) > c[0],
+            Return(c),
+        )
+        records = run_ast_guppy_via_selene(prog, shots=20)
+        assert all(r["measurement_0"] == 1 for r in records), records
+
+        # Angle propagation: RX(pi/2) twice == RX(pi).
+        halves = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            qb.RX[math.pi / 2](q[0]),
+            qb.RX[math.pi / 2](q[0]),
+            Measure(q[0]) > c[0],
+            Return(c),
+        )
+        recs2 = run_ast_guppy_via_selene(halves, shots=20)
+        assert all(r["measurement_0"] == 1 for r in recs2), recs2
+
+    def test_ry_pi_is_y(self) -> None:
+        """RY(pi)|0> flips to |1> (up to phase) -> 1."""
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            qb.RY[math.pi](q[0]),
+            Measure(q[0]) > c[0],
+            Return(c),
+        )
+        records = run_ast_guppy_via_selene(prog, shots=20)
+        assert all(r["measurement_0"] == 1 for r in records), records
+
+    def test_rz_phase_via_hadamard_sandwich(self) -> None:
+        """`|0>; H; RZ(pi); H; M` -> 1 (numpy-verified; HZH=X via RZ(pi)~Z).
+
+        A no-op RZ gives H;H=I -> 0, so this catches a dropped RZ.
+        """
+        prog = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            qb.H(q[0]),
+            qb.RZ[math.pi](q[0]),
+            qb.H(q[0]),
+            Measure(q[0]) > c[0],
+            Return(c),
+        )
+        records = run_ast_guppy_via_selene(prog, shots=20)
+        assert all(r["measurement_0"] == 1 for r in records), records
+
+    def test_crz_control_phase(self) -> None:
+        """CRZ(pi) with control=|1>: target gets RZ(pi)~Z.
+
+        `X q0; H q1; CRZ(pi); H q1; M q1` -> 1 (Z|+>=|->, H|->=|1>).
+        A no-op CRZ gives H;H=I -> 0; this is the control-active pin.
+        """
+        prog = Main(
+            q := QReg("q", 2),
+            c := CReg("c", 1),
+            qb.X(q[0]),
+            qb.H(q[1]),
+            qb.CRZ[math.pi](q[0], q[1]),
+            qb.H(q[1]),
+            Measure(q[1]) > c[0],
+            Return(c),
+        )
+        records = run_ast_guppy_via_selene(prog, shots=20)
+        assert all(r["measurement_0"] == 1 for r in records), records

From 922326e1b35166086070f57cb01001e825843bb6 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Wed, 20 May 2026 20:42:42 -0600
Subject: [PATCH 124/136] Cross-codegen Guppy Phase B: decompose
 SY/SYdg/F-family/sqrt-Paulis/CRX/CRY (native zz_phase)

---
 .../src/pecos/slr/ast/codegen/guppy.py        | 153 +++++++++++++++++-
 .../tests/slr_tests/ast_guppy/audit_runner.py |  11 +-
 .../slr_tests/ast_guppy/test_v1_behavioral.py | 153 ++++++++++++++++++
 3 files changed, 308 insertions(+), 9 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
index c0bdcf299..bf8e7d100 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
@@ -21,6 +21,7 @@
 
 import math
 import re
+from collections.abc import Callable
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, cast
 
@@ -114,6 +115,88 @@
     sorted(set(FUNCTIONAL_GATES.values()) | set(PARAMETERIZED_FUNCTIONAL_GATES.values()) | {"reset"}),
 )
 
+# Decomposition table for PECOS gates with no native single Guppy gate.
+# Each step is (guppy_fn, qubit_idx_tuple_into_targets, angle_spec) in
+# CIRCUIT order (first applied first). angle_spec is:
+#   None                          -> non-parameterized gate: fn(q...)
+#   float (radians)               -> constant angle: fn(q..., angle(r/pi))
+#   Callable[[input_params], float] -> angle from the input gate's params
+# The 1q-Clifford sequences mirror the dual-reviewed QIR `_GATE_DECOMP`;
+# the 2q sqrt-Paulis use the native `zz_phase` (= RZZ, qsystem Quantinuum
+# extension); CRX/CRY conjugate the native `crz`.
+_GuppyAngleSpec = None | float | Callable[[tuple[float, ...]], float]
+_GuppyDecompStep = tuple[str, tuple[int, ...], _GuppyAngleSpec]
+GUPPY_GATE_DECOMP: dict[GateKind, tuple[_GuppyDecompStep, ...]] = {
+    # ---- single-qubit Cliffords (no native sqrt-Y / face gate) ----
+    GateKind.SY: (("h", (0,), None), ("x", (0,), None)),
+    GateKind.SYdg: (("h", (0,), None), ("z", (0,), None)),
+    GateKind.F: (("sdg", (0,), None), ("h", (0,), None)),
+    GateKind.Fdg: (("h", (0,), None), ("s", (0,), None)),
+    GateKind.F4: (("h", (0,), None), ("sdg", (0,), None)),
+    GateKind.F4dg: (("s", (0,), None), ("h", (0,), None)),
+    # ---- two-qubit sqrt-Paulis via native zz_phase (= RZZ) ----
+    GateKind.SZZ: (("zz_phase", (0, 1), math.pi / 2),),
+    GateKind.SZZdg: (("zz_phase", (0, 1), -math.pi / 2),),
+    GateKind.SXX: (
+        ("h", (0,), None),
+        ("h", (1,), None),
+        ("zz_phase", (0, 1), math.pi / 2),
+        ("h", (0,), None),
+        ("h", (1,), None),
+    ),
+    GateKind.SXXdg: (
+        ("h", (0,), None),
+        ("h", (1,), None),
+        ("zz_phase", (0, 1), -math.pi / 2),
+        ("h", (0,), None),
+        ("h", (1,), None),
+    ),
+    GateKind.SYY: (
+        ("sdg", (0,), None),
+        ("sdg", (1,), None),
+        ("h", (0,), None),
+        ("h", (1,), None),
+        ("zz_phase", (0, 1), math.pi / 2),
+        ("h", (0,), None),
+        ("h", (1,), None),
+        ("s", (0,), None),
+        ("s", (1,), None),
+    ),
+    GateKind.SYYdg: (
+        ("sdg", (0,), None),
+        ("sdg", (1,), None),
+        ("h", (0,), None),
+        ("h", (1,), None),
+        ("zz_phase", (0, 1), -math.pi / 2),
+        ("h", (0,), None),
+        ("h", (1,), None),
+        ("s", (0,), None),
+        ("s", (1,), None),
+    ),
+    # ---- parameterized two-qubit gates ----
+    # RZZ is the native zz_phase with the passed-through angle.
+    GateKind.RZZ: (("zz_phase", (0, 1), lambda p: p[0]),),
+    # CRX = (I o H) . CRZ . (I o H); CRY = (I o S.H) . CRZ . (I o H.Sdg).
+    # `crz` is native; the passed-through angle threads into it.
+    GateKind.CRX: (
+        ("h", (1,), None),
+        ("crz", (0, 1), lambda p: p[0]),
+        ("h", (1,), None),
+    ),
+    GateKind.CRY: (
+        ("sdg", (1,), None),
+        ("h", (1,), None),
+        ("crz", (0, 1), lambda p: p[0]),
+        ("h", (1,), None),
+        ("s", (1,), None),
+    ),
+}
+
+# Gate names whose decomposition uses the qsystem `zz_phase` import.
+_ZZ_PHASE_GATES = frozenset(
+    gk for gk, steps in GUPPY_GATE_DECOMP.items() if any(fn == "zz_phase" for fn, _, _ in steps)
+)
+
 BINARY_OP_TO_PYTHON: dict[BinaryOp, str] = {
     BinaryOp.ADD: "+",
     BinaryOp.SUB: "-",
@@ -665,10 +748,13 @@ def _imports(self) -> list[str]:
             "from guppylang.std.quantum import discard, measure, qubit",
             f"from guppylang.std.quantum.functional import {FUNCTIONAL_GATE_IMPORTS}",
         ]
-        # `angle` is only needed when the program emits a parameterized
-        # rotation; import it unconditionally (cheap, keeps the emitter
-        # simple). Half-turn-valued `angle(...)` constructor.
+        # `angle` is needed for parameterized rotations; `zz_phase` is
+        # the native Quantinuum Q-System 2q ZZ rotation (= RZZ) used by
+        # the SZZ/SXX/SYY-family + RZZ decompositions. Both imported
+        # unconditionally (cheap; unused imports are harmless -- Guppy
+        # only compiles the ops a program actually calls).
         imports.append("from guppylang.std.angles import angle")
+        imports.append("from guppylang.std.qsystem.functional import zz_phase")
         return imports
 
     def _render_params(self) -> str:
@@ -1022,6 +1108,9 @@ def _emit_gate(self, node: GateOp) -> list[str]:
         if node.gate in PARAMETERIZED_FUNCTIONAL_GATES:
             return self._emit_parameterized_gate(node)
 
+        if node.gate in GUPPY_GATE_DECOMP:
+            return self._emit_decomposed_gate(node)
+
         gate = FUNCTIONAL_GATES.get(node.gate)
         if gate is None:
             self._raise_unsupported_gate(node.gate)
@@ -1098,10 +1187,62 @@ def _emit_parameterized_gate(self, node: GateOp) -> list[str]:
         msg = f"AST -> Guppy v1 does not support {node.gate.arity}-qubit parameterized gate {node.gate.name}"
         raise GuppyCodegenError(msg)
 
-    def _raise_unsupported_gate(self, gate: GateKind) -> None:
-        if gate in {GateKind.SY, GateKind.SYdg}:
-            msg = f"AST -> Guppy v1 rejects {gate.name}; decompose it before Guppy emission"
+    def _emit_decomposed_gate(self, node: GateOp) -> list[str]:
+        """Emit a multi-step decomposition for a PECOS gate with no native
+        single Guppy gate (`GUPPY_GATE_DECOMP`).
+
+        Each step is a Guppy-native gate call threaded through the
+        linearity tracker (functional style: `local = fn(local)` or
+        `a, b = fn(a, b[, angle])`). Angle specs that are callable read
+        the input gate's (literal) params; non-literal params fail loud.
+        """
+        steps = GUPPY_GATE_DECOMP[node.gate]
+        base_slots = [self._slot_from_ref(target) for target in node.targets]
+        if len(base_slots) != len(set(base_slots)):
+            msg = f"Gate {node.gate.name} uses the same qubit slot more than once"
             raise GuppyCodegenError(msg)
+
+        # Resolve the input gate's literal params once (only needed if a
+        # step has a callable angle spec).
+        resolved_params: tuple[float, ...] | None = None
+        if any(callable(spec) for _, _, spec in steps):
+            params = node.params or ()
+            resolved: list[float] = []
+            for param in params:
+                if not isinstance(param, LiteralExpr) or not isinstance(param.value, (int, float)):
+                    msg = (
+                        f"AST -> Guppy v1: parameterized decomposition of {node.gate.name} "
+                        f"requires literal angle parameters; got non-literal {param!r}"
+                    )
+                    raise GuppyCodegenError(msg)
+                resolved.append(float(param.value))
+            resolved_params = tuple(resolved)
+
+        linearity = self._linearity()
+        lines: list[str] = []
+        for fn, idxs, angle_spec in steps:
+            slots = [base_slots[i] for i in idxs]
+            locals_ = [linearity.live(slot) for slot in slots]
+            if angle_spec is None:
+                angle_arg = ""
+            else:
+                theta = angle_spec(resolved_params) if callable(angle_spec) else angle_spec
+                angle_arg = f", angle({float(theta) / math.pi})"
+            if len(idxs) == 1:
+                local = locals_[0]
+                lines.append(f"{self.context.indent()}{local} = {fn}({local}{angle_arg})")
+                linearity.set_live(slots[0], local)
+            elif len(idxs) == 2:
+                left, right = locals_
+                lines.append(f"{self.context.indent()}{left}, {right} = {fn}({left}, {right}{angle_arg})")
+                linearity.set_live(slots[0], left)
+                linearity.set_live(slots[1], right)
+            else:
+                msg = f"AST -> Guppy v1: decomposition step for {node.gate.name} has unsupported arity {len(idxs)}"
+                raise GuppyCodegenError(msg)
+        return lines
+
+    def _raise_unsupported_gate(self, gate: GateKind) -> None:
         if gate.is_parameterized:
             msg = f"AST -> Guppy v1 does not support parameterized gate {gate.name}"
             raise GuppyCodegenError(msg)
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
index eaad7bce0..32944ad4e 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
@@ -751,9 +751,14 @@ def _curated_cases() -> list[AuditCase]:
             _docs_rotation_rx_probe,
             expected_failure=ExpectedFailure(
                 exception_type="GuppyCodegenError",
-                message_contains="does not support parameterized gate RX",
-                classification="v2-defer",
-                reason="Parameterized rotations need design beyond v1 fixed Clifford emission",
+                message_contains="requires an angle parameter",
+                classification="api-misuse",
+                reason=(
+                    "RX is now supported via the bracket-param form `RX[theta](q)` "
+                    "(cross-codegen Guppy Phase A -> native `rx`). The doc-test "
+                    "positional form `RX(q, 0.5)` passes the angle as a qarg, leaving "
+                    "no param, so it fails loud -- the gate is supported, the call shape is wrong."
+                ),
             ),
         ),
         AuditCase(
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py
index d1ea583c9..ed3413ce1 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py
@@ -508,3 +508,156 @@ def test_crz_control_phase(self) -> None:
         )
         records = run_ast_guppy_via_selene(prog, shots=20)
         assert all(r["measurement_0"] == 1 for r in records), records
+
+
+class TestDecomposedGuppyGates:
+    """Cross-codegen Phase B: PECOS gates with no native single Guppy
+    gate, lowered via `GUPPY_GATE_DECOMP` into Guppy-native gates
+    (1q Cliffords; the qsystem `zz_phase` = RZZ for 2q sqrt-Paulis;
+    native `crz` for CRX/CRY).
+
+    Discriminators are deterministic, numpy-verified against the PECOS
+    gate conventions, and mutation-resistant (catch no-op / wrong-gate /
+    dagger-swap).
+    """
+
+    @staticmethod
+    def _bits(prog: Main, shots: int = 20) -> list[dict[str, int]]:
+        return run_ast_guppy_via_selene(prog, shots=shots)
+
+    # ---- single-qubit Cliffords (SY/SYdg, F-family) ----
+
+    def test_sy_squares_to_y_and_handedness(self) -> None:
+        sq = Main(q := QReg("q", 1), c := CReg("c", 1), qb.SY(q[0]), qb.SY(q[0]), Measure(q[0]) > c[0], Return(c))
+        assert all(r["measurement_0"] == 1 for r in self._bits(sq)), "SY;SY must be Y -> 1"
+        # Handedness: SY;H -> 0 (SYdg;H -> 1; no-op -> 50/50).
+        hd = Main(q := QReg("q", 1), c := CReg("c", 1), qb.SY(q[0]), qb.H(q[0]), Measure(q[0]) > c[0], Return(c))
+        assert all(r["measurement_0"] == 0 for r in self._bits(hd)), "SY;H must be 0 (handedness)"
+
+    def test_sydg_handedness_and_inverse(self) -> None:
+        hd = Main(q := QReg("q", 1), c := CReg("c", 1), qb.SYdg(q[0]), qb.H(q[0]), Measure(q[0]) > c[0], Return(c))
+        assert all(r["measurement_0"] == 1 for r in self._bits(hd)), "SYdg;H must be 1"
+        inv = Main(q := QReg("q", 1), c := CReg("c", 1), qb.SY(q[0]), qb.SYdg(q[0]), Measure(q[0]) > c[0], Return(c))
+        assert all(r["measurement_0"] == 0 for r in self._bits(inv)), "SY;SYdg must be I -> 0"
+
+    def test_f_family(self) -> None:
+        # F;H -> 0 (distinguishes F from F4 (50/50) and no-op).
+        f = Main(q := QReg("q", 1), c := CReg("c", 1), qb.F(q[0]), qb.H(q[0]), Measure(q[0]) > c[0], Return(c))
+        assert all(r["measurement_0"] == 0 for r in self._bits(f)), "F;H must be 0"
+        # Fdg;Sdg;H -> 0; and F;Fdg = I.
+        fdg = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            qb.Fdg(q[0]),
+            qb.SZdg(q[0]),
+            qb.H(q[0]),
+            Measure(q[0]) > c[0],
+            Return(c),
+        )
+        assert all(r["measurement_0"] == 0 for r in self._bits(fdg)), "Fdg;Sdg;H must be 0"
+        finv = Main(q := QReg("q", 1), c := CReg("c", 1), qb.F(q[0]), qb.Fdg(q[0]), Measure(q[0]) > c[0], Return(c))
+        assert all(r["measurement_0"] == 0 for r in self._bits(finv)), "F;Fdg must be I -> 0"
+
+    def test_f4_family(self) -> None:
+        # F4;S;H -> 0 (deterministic; F4;Sdg;H -> 1).
+        f4 = Main(
+            q := QReg("q", 1),
+            c := CReg("c", 1),
+            qb.F4(q[0]),
+            qb.SZ(q[0]),
+            qb.H(q[0]),
+            Measure(q[0]) > c[0],
+            Return(c),
+        )
+        assert all(r["measurement_0"] == 0 for r in self._bits(f4)), "F4;S;H must be 0"
+        # F4dg;H -> 0; and F4;F4dg = I.
+        f4dg = Main(q := QReg("q", 1), c := CReg("c", 1), qb.F4dg(q[0]), qb.H(q[0]), Measure(q[0]) > c[0], Return(c))
+        assert all(r["measurement_0"] == 0 for r in self._bits(f4dg)), "F4dg;H must be 0"
+        f4inv = Main(q := QReg("q", 1), c := CReg("c", 1), qb.F4(q[0]), qb.F4dg(q[0]), Measure(q[0]) > c[0], Return(c))
+        assert all(r["measurement_0"] == 0 for r in self._bits(f4inv)), "F4;F4dg must be I -> 0"
+
+    # ---- two-qubit sqrt-Paulis via native zz_phase ----
+
+    def test_rzz_native_zz_phase(self) -> None:
+        # H q0; H q1; RZZ(pi); H q0; H q1 -> both measure 1 (numpy-verified).
+        prog = Main(
+            q := QReg("q", 2),
+            c := CReg("c", 2),
+            qb.H(q[0]),
+            qb.H(q[1]),
+            qb.RZZ[math.pi](q[0], q[1]),
+            qb.H(q[0]),
+            qb.H(q[1]),
+            Measure(q[0]) > c[0],
+            Measure(q[1]) > c[1],
+            Return(c),
+        )
+        recs = self._bits(prog)
+        assert all(r["measurement_0"] == 1 and r["measurement_1"] == 1 for r in recs), recs
+
+    def test_szz_squared_and_inverse(self) -> None:
+        # SZZ^2 with q1=|0> acts as Z on q0: H q0; SZZ; SZZ; H q0 -> 1.
+        sq = Main(
+            q := QReg("q", 2),
+            c := CReg("c", 1),
+            qb.H(q[0]),
+            qb.SZZ(q[0], q[1]),
+            qb.SZZ(q[0], q[1]),
+            qb.H(q[0]),
+            Measure(q[0]) > c[0],
+            Return(c),
+        )
+        assert all(r["measurement_0"] == 1 for r in self._bits(sq)), "H;SZZ;SZZ;H must be X on q0 -> 1"
+        # SZZ;SZZdg = I on |00>.
+        inv = Main(
+            q := QReg("q", 2),
+            c := CReg("c", 2),
+            qb.SZZ(q[0], q[1]),
+            qb.SZZdg(q[0], q[1]),
+            Measure(q[0]) > c[0],
+            Measure(q[1]) > c[1],
+            Return(c),
+        )
+        assert all(r["measurement_0"] == 0 and r["measurement_1"] == 0 for r in self._bits(inv)), "SZZ;SZZdg = I"
+
+    def test_sxx_syy_inverse_pairs(self) -> None:
+        for g, gdg, name in [(qb.SXX, qb.SXXdg, "SXX"), (qb.SYY, qb.SYYdg, "SYY")]:
+            prog = Main(
+                q := QReg("q", 2),
+                c := CReg("c", 2),
+                g(q[0], q[1]),
+                gdg(q[0], q[1]),
+                Measure(q[0]) > c[0],
+                Measure(q[1]) > c[1],
+                Return(c),
+            )
+            recs = self._bits(prog)
+            assert all(r["measurement_0"] == 0 and r["measurement_1"] == 0 for r in recs), f"{name};{name}dg = I"
+
+    # ---- controlled rotations via native crz ----
+
+    def test_crx_cry_control_active(self) -> None:
+        # X q0; H q1; CR*(pi); H q1; M q1.  CRX -> 0, CRY -> 1 (numpy-verified;
+        # the differing outcomes also confirm CRX != CRY).
+        crx = Main(
+            q := QReg("q", 2),
+            c := CReg("c", 1),
+            qb.X(q[0]),
+            qb.H(q[1]),
+            qb.CRX[math.pi](q[0], q[1]),
+            qb.H(q[1]),
+            Measure(q[1]) > c[0],
+            Return(c),
+        )
+        assert all(r["measurement_0"] == 0 for r in self._bits(crx)), "X q0; H q1; CRX(pi); H q1 -> 0"
+        cry = Main(
+            q := QReg("q", 2),
+            c := CReg("c", 1),
+            qb.X(q[0]),
+            qb.H(q[1]),
+            qb.CRY[math.pi](q[0], q[1]),
+            qb.H(q[1]),
+            Measure(q[1]) > c[0],
+            Return(c),
+        )
+        assert all(r["measurement_0"] == 1 for r in self._bits(cry)), "X q0; H q1; CRY(pi); H q1 -> 1"

From 67714c508d5fa199be4b077a88f04fc325f16d06 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Wed, 20 May 2026 22:47:16 -0600
Subject: [PATCH 125/136] Post-review folds (Codex non-blockers): Guppy
 decomposed-rotation missing-angle fails loud + B1 LoopVar comment accuracy

---
 .../src/pecos/slr/ast/codegen/guppy.py          |  9 +++++++++
 .../src/pecos/slr/ast/codegen/qir.py            |  8 ++++++--
 .../tests/slr_tests/ast_guppy/test_ast_hugr.py  | 17 +++++++++++++++++
 3 files changed, 32 insertions(+), 2 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
index bf8e7d100..f71c92fb7 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
@@ -1207,6 +1207,15 @@ def _emit_decomposed_gate(self, node: GateOp) -> list[str]:
         resolved_params: tuple[float, ...] | None = None
         if any(callable(spec) for _, _, spec in steps):
             params = node.params or ()
+            if not params:
+                # A parameterized decomposition (RZZ/CRX/CRY) with no
+                # angle -- e.g. the malformed positional call
+                # `RZZ(q0, q1, 0.5)` that passes the angle as a qarg.
+                # Fail loud with a clear message (parity with the native
+                # `_emit_parameterized_gate` guard), not a raw IndexError
+                # when a callable spec indexes `p[0]`.
+                msg = f"AST -> Guppy v1: parameterized gate {node.gate.name} requires an angle parameter"
+                raise GuppyCodegenError(msg)
             resolved: list[float] = []
             for param in params:
                 if not isinstance(param, LiteralExpr) or not isinstance(param.value, (int, float)):
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
index bd4008391..80c4dbdf5 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
@@ -939,8 +939,12 @@ def _eval_expression(self, expr: Expression) -> Any:
             # scalar (e.g. `If(m == 0)`, `o.set(m + n)`, Steane
             # `smid_flag_x`). SLR has no scalar-integer classical type
             # (verified: `pecos.slr.vars` exposes only Reg/CReg/Bit/
-            # SymbolicElem/LoopVar; `LoopVar` is the compile-time `For`
-            # index and is substituted before this point). The lowering
+            # SymbolicElem/LoopVar). A `LoopVar` used as a symbolic index
+            # is resolved by `For` unrolling; a `LoopVar` appearing as a
+            # bare classical scalar (e.g. `If(i == 0)`) is NOT substituted
+            # by `_process_for` and reaches here as `VarExpr(name="i")`,
+            # where `_require_creg` fails it loud (no CReg named `i`) --
+            # never silent-0. The lowering
             # is the existing i64 pack (`OR_i (zext c[i] << i)`)
             # factored out of `_generate_results` as `_pack_creg`. A
             # `VarExpr` whose name is not a declared Main-scope CReg
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
index 96fc2d73c..24acb8279 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
@@ -66,6 +66,23 @@ def test_hugr_rejects_symbolic_loopvar_indexing_cleanly() -> None:
         SlrConverter(prog).hugr()
 
 
+def test_hugr_decomposed_rotation_missing_angle_fails_loud() -> None:
+    # Cross-codegen post-review fold (Codex): a parameterized gate whose
+    # Guppy lowering is a DECOMPOSITION (RZZ/CRX/CRY) must fail loud with
+    # a clear GuppyCodegenError when called with no angle -- e.g. the
+    # malformed positional form `RZZ(q0, q1, 0.5)` that passes the angle
+    # as a qarg (leaving node.params empty). Previously the callable
+    # angle-spec indexed `p[0]` on the empty params and raised a raw
+    # IndexError; now it matches the native-rotation guard's message.
+    for gate_obj, name in [(qb.RZZ, "RZZ"), (qb.CRX, "CRX"), (qb.CRY, "CRY")]:
+        prog = Main(
+            q := QReg("q", 2),
+            gate_obj(q[0], q[1], 0.5),  # angle as positional qarg -> no param
+        )
+        with pytest.raises(GuppyCodegenError, match=f"parameterized gate {name} requires an angle parameter"):
+            SlrConverter(prog).guppy()
+
+
 def test_hugr_accepts_inline_measure_creg_result() -> None:
     final = CReg("final", 2)
     prog = Main(

From b8fbb9ba2934faae3cb342bc5fc0b41157f41fc4 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Wed, 20 May 2026 23:22:12 -0600
Subject: [PATCH 126/136] #97: SLR API -- rotational gates use angle-first
 RX(theta, q), remove bracket form

---
 .../parallel-blocks-and-optimization.md       |  2 +-
 docs/user-guide/parallel-execution.md         | 12 ++---
 .../src/pecos/slr/ast/codegen/qir.py          |  4 +-
 .../pecos/slr/ast/codegen/quantum_circuit.py  |  2 +-
 .../src/pecos/slr/ast/pretty_print.py         |  5 +-
 .../pecos/slr/gen_codes/qir_gate_mapping.py   | 10 ++--
 .../src/pecos/slr/qeclib/qubit/qgate_base.py  | 53 ++++++++++++++-----
 .../src/pecos/slr/qeclib/qubit/rots.py        |  7 +++
 .../slr/qeclib/steane/preps/plus_h_state.py   |  2 +-
 .../test_qasm/pecos/qeclib/qubit/test_rots.py |  8 +--
 .../test_qasm/random_cases/test_slr_phys.py   |  4 +-
 .../optimizations/test_identity_removal.py    | 32 +++++------
 .../ast_tests/optimizations/test_pipeline.py  | 24 ++++-----
 .../optimizations/test_rotation_merging.py    | 38 ++++++-------
 .../slr/ast_tests/test_codegen_equivalence.py | 16 +++---
 .../pecos/slr/ast_tests/test_integration.py   |  6 +--
 .../pecos/slr/ast_tests/test_pretty_print.py  | 12 ++---
 .../pecos/slr/ast_tests/test_serialize.py     |  4 +-
 .../slr/ast_tests/validation/test_pipeline.py |  6 +--
 .../ast_tests/validation/test_type_checker.py |  4 +-
 .../unit/slr/test_quantum_permutation.py      | 10 ++--
 .../tests/slr_tests/ast_guppy/audit_runner.py | 21 +++-----
 .../slr_tests/ast_guppy/test_ast_hugr.py      | 28 ++++++----
 .../ast_guppy/test_qir_corpus_executable.py   | 37 ++++++++++---
 .../ast_guppy/test_qir_spec_compliance.py     | 24 ++++++---
 .../slr_tests/ast_guppy/test_v1_behavioral.py | 18 +++----
 .../regression/random_cases/test_slr_phys.py  | 10 ++--
 .../unit/slr/test_quantum_permutation.py      | 10 ++--
 .../pecos/unit/slr/test_stim_conversion.py    |  3 +-
 29 files changed, 241 insertions(+), 171 deletions(-)

diff --git a/docs/development/parallel-blocks-and-optimization.md b/docs/development/parallel-blocks-and-optimization.md
index e345002ed..38677e248 100644
--- a/docs/development/parallel-blocks-and-optimization.md
+++ b/docs/development/parallel-blocks-and-optimization.md
@@ -280,7 +280,7 @@ def qft_layer(q, n, k):
     operations = []
     for j in range(k + 1, n):
         angle = np.pi / (2 ** (j - k))
-        operations.append(qb.CRZ[angle](q[j], q[k]))
+        operations.append(qb.CRZ(angle, q[j], q[k]))
     return Parallel(*operations) if len(operations) > 1 else operations[0]
 
 
diff --git a/docs/user-guide/parallel-execution.md b/docs/user-guide/parallel-execution.md
index 418f02789..b9b935e07 100644
--- a/docs/user-guide/parallel-execution.md
+++ b/docs/user-guide/parallel-execution.md
@@ -175,15 +175,15 @@ prog = Main(
         qb.H(q[2]),
     ),
     # Apply controlled rotations
-    qb.CRZ[np.pi](q[0], q[3]),
-    qb.CRZ[np.pi / 2](q[1], q[3]),
-    qb.CRZ[np.pi / 4](q[2], q[3]),
+    qb.CRZ(np.pi, q[0], q[3]),
+    qb.CRZ(np.pi / 2, q[1], q[3]),
+    qb.CRZ(np.pi / 4, q[2], q[3]),
     # Inverse QFT on ancillas
     qb.H(q[0]),
-    qb.CRZ[-np.pi / 2](q[0], q[1]),
+    qb.CRZ(-np.pi / 2, q[0], q[1]),
     qb.H(q[1]),
-    qb.CRZ[-np.pi / 4](q[0], q[2]),
-    qb.CRZ[-np.pi / 2](q[1], q[2]),
+    qb.CRZ(-np.pi / 4, q[0], q[2]),
+    qb.CRZ(-np.pi / 2, q[1], q[2]),
     qb.H(q[2]),
     # Measure ancillas
     Parallel(
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
index 80c4dbdf5..3c1a8c582 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
@@ -670,7 +670,7 @@ def _process_single_qubit_gate(self, node: GateOp, qir_name: str) -> None:
 
             args = []
             if node.gate in PARAMETERIZED_GATES and node.params:
-                # A bracket param (e.g. `RX[0.5]`) reaches here as a
+                # An angle param (e.g. `RX(0.5, q)`) reaches here as a
                 # `LiteralExpr`, not a raw number -- resolve it before
                 # `float()` (was a hard `TypeError` for parallel/
                 # control-flow rotations).
@@ -699,7 +699,7 @@ def _process_two_qubit_gate(self, node: GateOp, qir_name: str) -> None:
 
             args = []
             if node.gate in PARAMETERIZED_GATES and node.params:
-                # A bracket param (e.g. `RX[0.5]`) reaches here as a
+                # An angle param (e.g. `RX(0.5, q)`) reaches here as a
                 # `LiteralExpr`, not a raw number -- resolve it before
                 # `float()` (was a hard `TypeError` for parallel/
                 # control-flow rotations).
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py
index f528aa880..008efa449 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py
@@ -350,7 +350,7 @@ def _process_parameterized_gate(self, node: GateOp, gate_name: str) -> None:
         """Emit a parameterized gate (rotation angle threaded through).
 
         Resolves `LiteralExpr` bracket-params to raw floats (the AST
-        converter wraps `qb.RZ[0.5]` as a `LiteralExpr`, so a bare
+        converter wraps the `qb.RZ(0.5, q)` angle as a `LiteralExpr`, so a bare
         `float(p)` would fail). The QC `circuit.append(...,
         angles=...)` path forwards the angle list to Rust's typed-
         parameter dispatcher (e.g. `RZ` requires 1 angle, `RXXRYYRZZ`
diff --git a/python/quantum-pecos/src/pecos/slr/ast/pretty_print.py b/python/quantum-pecos/src/pecos/slr/ast/pretty_print.py
index 4e88af1d9..3deda4311 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/pretty_print.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/pretty_print.py
@@ -210,8 +210,11 @@ def visit_gate(self, node: GateOp) -> str:
         targets = ", ".join(self.visit_slot_ref(t) for t in node.targets)
 
         if node.params:
+            # #97: angle-first SLR API -- `qb.RX(theta, q)`, angles
+            # before qubits (not the legacy `qb.RX[theta](q)` bracket).
             params = ", ".join(self.format_expression(p) for p in node.params)
-            return f"qb.{gate_name}[{params}]({targets})"
+            sep = ", " if targets else ""
+            return f"qb.{gate_name}({params}{sep}{targets})"
         return f"qb.{gate_name}({targets})"
 
     def visit_prepare(self, node: PrepareOp) -> str:
diff --git a/python/quantum-pecos/src/pecos/slr/gen_codes/qir_gate_mapping.py b/python/quantum-pecos/src/pecos/slr/gen_codes/qir_gate_mapping.py
index d7e770bcc..d129b4efe 100644
--- a/python/quantum-pecos/src/pecos/slr/gen_codes/qir_gate_mapping.py
+++ b/python/quantum-pecos/src/pecos/slr/gen_codes/qir_gate_mapping.py
@@ -68,22 +68,22 @@ def __init__(self, gate: QG):
 
     SX = QG.decompose(
         lambda sx: [
-            q.RX[pc.f64.frac_pi_2](sx.qargs[0]),
+            q.RX(pc.f64.frac_pi_2, sx.qargs[0]),
         ],
     )
     SXdg = QG.decompose(
         lambda sxdg: [
-            q.RX[-pc.f64.frac_pi_2](sxdg.qargs[0]),
+            q.RX(-pc.f64.frac_pi_2, sxdg.qargs[0]),
         ],
     )
     SY = QG.decompose(
         lambda sy: [
-            q.RY[pc.f64.frac_pi_2](sy.qargs[0]),
+            q.RY(pc.f64.frac_pi_2, sy.qargs[0]),
         ],
     )
     SYdg = QG.decompose(
         lambda sydg: [
-            q.RY[-pc.f64.frac_pi_2](sydg.qargs[0]),
+            q.RY(-pc.f64.frac_pi_2, sydg.qargs[0]),
         ],
     )
 
@@ -112,7 +112,7 @@ def __init__(self, gate: QG):
         lambda f4dg: [
             q.SXdg(f4dg.qargs[0]),
             # q.SZdg(f4dg.qargs[0]),
-            q.RZ[-pc.f64.frac_pi_2](f4dg.qargs[0]),
+            q.RZ(-pc.f64.frac_pi_2, f4dg.qargs[0]),
         ],
     )
 
diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/qubit/qgate_base.py b/python/quantum-pecos/src/pecos/slr/qeclib/qubit/qgate_base.py
index fdec19921..4049c9053 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/qubit/qgate_base.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/qubit/qgate_base.py
@@ -48,6 +48,11 @@ class QGate:
     qsize = 1
     csize = 0
     has_parameters = False
+    # Number of leading angle parameters for a parameterized gate. The
+    # SLR call convention is angle(s)-FIRST: `RX(theta, q)`,
+    # `CRZ(theta, control, target)`, `RZZ(theta, q0, q1)`. A
+    # parameterized gate must set `num_params` (and `has_parameters`).
+    num_params = 0
 
     def __init__(self, *qargs: Qubit) -> None:
         """Initialize a quantum gate.
@@ -84,15 +89,19 @@ def copy(self) -> Self:
         return copy.copy(self)
 
     def __getitem__(self, *params: complex) -> Self:
-        """Set gate parameters using square bracket notation."""
-        g = self.copy()
-
-        if params and not self.has_parameters:
-            msg = "This gate does not accept parameters. You might of meant to put qubits in square brackets."
-            raise Exception(msg)
-        g.params = params
+        """Reject the legacy bracket-parameter form.
 
-        return g
+        The SLR API now takes rotation angles as leading positional
+        arguments -- ``RX(theta, q)`` -- not via brackets. The old
+        ``RX[theta](q)`` form is removed (angles-first is the single
+        supported convention); raise a clear migration error.
+        """
+        msg = (
+            f"The bracket-parameter form `{self.sym}[angle](qubit)` is no longer "
+            f"supported. Pass the angle as a leading positional argument instead: "
+            f"`{self.sym}(angle, qubit)` (angles come before qubit ids)."
+        )
+        raise TypeError(msg)
 
     def qubits(self, *qargs: Qubit) -> None:
         """Add qubits to the gate.
@@ -102,18 +111,36 @@ def qubits(self, *qargs: Qubit) -> None:
         """
         self(*qargs)
 
-    def __call__(self, *qargs: Qubit) -> Self:
-        """Create a new gate instance with specified qubits.
+    def __call__(self, *args: Qubit | complex) -> Self:
+        """Create a new gate instance from angle(s) and qubit(s).
+
+        For a parameterized gate the first `num_params` arguments are
+        the rotation angle(s); the remaining arguments are the qubits:
+        `RX(theta, q)`, `CRZ(theta, control, target)`. For a
+        non-parameterized gate every argument is a qubit.
 
         Args:
-            *qargs: Variable number of qubits to apply the gate to.
+            *args: `num_params` leading angle parameter(s) (if any)
+                followed by the qubit(s) the gate acts on.
 
         Returns:
-            New gate instance with the specified qubits.
+            New gate instance with the specified params + qubits.
         """
         g = self.copy()
 
-        g.add_qargs(qargs)
+        if self.has_parameters:
+            n = self.num_params
+            if len(args) < n:
+                msg = (
+                    f"{self.sym} is a parameterized gate; call it as "
+                    f"`{self.sym}(angle, qubit...)` with {n} leading angle "
+                    f"parameter(s) before the qubit(s). Got {len(args)} argument(s)."
+                )
+                raise TypeError(msg)
+            g.params = tuple(args[:n])
+            g.add_qargs(tuple(args[n:]))
+        else:
+            g.add_qargs(args)
 
         return g
 
diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/qubit/rots.py b/python/quantum-pecos/src/pecos/slr/qeclib/qubit/rots.py
index b697c27bd..c57a565f0 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/qubit/rots.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/qubit/rots.py
@@ -26,6 +26,7 @@ class RXGate(QGate):
     """
 
     has_parameters = True
+    num_params = 1
 
 
 RX = RXGate()
@@ -38,6 +39,7 @@ class RYGate(QGate):
     """
 
     has_parameters = True
+    num_params = 1
 
 
 RY = RYGate()
@@ -50,6 +52,7 @@ class RZGate(QGate):
     """
 
     has_parameters = True
+    num_params = 1
 
 
 RZ = RZGate()
@@ -62,6 +65,7 @@ class RZZGate(TQGate):
     """
 
     has_parameters = True
+    num_params = 1
 
 
 RZZ = RZZGate()
@@ -75,6 +79,7 @@ class CRXGate(TQGate):
     """
 
     has_parameters = True
+    num_params = 1
 
 
 CRX = CRXGate()
@@ -88,6 +93,7 @@ class CRYGate(TQGate):
     """
 
     has_parameters = True
+    num_params = 1
 
 
 CRY = CRYGate()
@@ -101,6 +107,7 @@ class CRZGate(TQGate):
     """
 
     has_parameters = True
+    num_params = 1
 
 
 CRZ = CRZGate()
diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/steane/preps/plus_h_state.py b/python/quantum-pecos/src/pecos/slr/qeclib/steane/preps/plus_h_state.py
index 04a6062af..5a73fcdc5 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/steane/preps/plus_h_state.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/steane/preps/plus_h_state.py
@@ -82,7 +82,7 @@ def __init__(
         # ----------------------------------------
         self.extend(
             qubit.PZ(d[6]),
-            qubit.RY[pc.f64.frac_pi_4](d[6]),
+            qubit.RY(pc.f64.frac_pi_4, d[6]),
             EncodingCircuit(d),
         )
 
diff --git a/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/qubit/test_rots.py b/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/qubit/test_rots.py
index 80b118f47..51b005e47 100644
--- a/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/qubit/test_rots.py
+++ b/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/qubit/test_rots.py
@@ -21,26 +21,26 @@
 def test_RX(compare_qasm: Callable[..., None]) -> None:
     """Test RX rotation gate QASM regression."""
     q = QReg("q_test", 1)
-    prog = qubit.RX[pc.f64.pi / 3](q[0])
+    prog = qubit.RX(pc.f64.pi / 3, q[0])
     compare_qasm(prog)
 
 
 def test_RY(compare_qasm: Callable[..., None]) -> None:
     """Test RY rotation gate QASM regression."""
     q = QReg("q_test", 1)
-    prog = qubit.RY[pc.f64.pi / 3](q[0])
+    prog = qubit.RY(pc.f64.pi / 3, q[0])
     compare_qasm(prog)
 
 
 def test_RZ(compare_qasm: Callable[..., None]) -> None:
     """Test RZ rotation gate QASM regression."""
     q = QReg("q_test", 1)
-    prog = qubit.RZ[pc.f64.pi / 3](q[0])
+    prog = qubit.RZ(pc.f64.pi / 3, q[0])
     compare_qasm(prog)
 
 
 def test_RZZ(compare_qasm: Callable[..., None]) -> None:
     """Test RZZ two-qubit rotation gate QASM regression."""
     q = QReg("q_test", 4)
-    prog = qubit.RZZ[pc.f64.pi / 3](q[1], q[3])
+    prog = qubit.RZZ(pc.f64.pi / 3, q[1], q[3])
     compare_qasm(prog)
diff --git a/python/quantum-pecos/tests/pecos/regression/test_qasm/random_cases/test_slr_phys.py b/python/quantum-pecos/tests/pecos/regression/test_qasm/random_cases/test_slr_phys.py
index effcd7b62..261ba3ec5 100644
--- a/python/quantum-pecos/tests/pecos/regression/test_qasm/random_cases/test_slr_phys.py
+++ b/python/quantum-pecos/tests/pecos/regression/test_qasm/random_cases/test_slr_phys.py
@@ -206,7 +206,7 @@ def test_control_flow_qir() -> None:
             ),
         )
         .Else(
-            p.RX[0.3](q[0]),
+            p.RX(0.3, q[0]),
         ),
         If(m < m_hidden).Then(
             p.H(q[0]),
@@ -216,7 +216,7 @@ def test_control_flow_qir() -> None:
         p.SZdg(q[0]),
         p.CX(q[0], q[1]),
         Barrier(q[1], q[0]),
-        p.RX[0.3](q[0]),
+        p.RX(0.3, q[0]),
         p.Measure(q) > m,
         Return(m),
     )
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/optimizations/test_identity_removal.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/optimizations/test_identity_removal.py
index f3130837d..08ae6495f 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/optimizations/test_identity_removal.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/optimizations/test_identity_removal.py
@@ -26,7 +26,7 @@ def test_rz_zero_removed(self) -> None:
         """RZ(0) is removed."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ[0](q[0]),
+            qb.RZ(0, q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -39,7 +39,7 @@ def test_rx_zero_removed(self) -> None:
         """RX(0) is removed."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RX[0](q[0]),
+            qb.RX(0, q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -52,7 +52,7 @@ def test_ry_zero_removed(self) -> None:
         """RY(0) is removed."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RY[0](q[0]),
+            qb.RY(0, q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -65,7 +65,7 @@ def test_rz_2pi_removed(self) -> None:
         """RZ(2*pi) is removed."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ[2 * math.pi](q[0]),
+            qb.RZ(2 * math.pi, q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -78,7 +78,7 @@ def test_rz_4pi_removed(self) -> None:
         """RZ(4*pi) is removed (multiple of 2*pi)."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ[4 * math.pi](q[0]),
+            qb.RZ(4 * math.pi, q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -95,7 +95,7 @@ def test_rz_nonzero_not_removed(self) -> None:
         """RZ(0.5) is not removed."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ[0.5](q[0]),
+            qb.RZ(0.5, q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -108,7 +108,7 @@ def test_rz_pi_not_removed(self) -> None:
         """RZ(pi) is not removed."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ[math.pi](q[0]),
+            qb.RZ(math.pi, q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -141,7 +141,7 @@ def test_removal_inside_if(self) -> None:
             q := QReg("q", 1),
             c := CReg("c", 1),
             If(c[0] == 1).Then(
-                qb.RZ[0](q[0]),
+                qb.RZ(0, q[0]),
                 qb.H(q[0]),
             ),
         )
@@ -157,7 +157,7 @@ def test_removal_inside_repeat(self) -> None:
         prog = Main(
             q := QReg("q", 1),
             Repeat(cond=3).block(
-                qb.RX[0](q[0]),
+                qb.RX(0, q[0]),
             ),
         )
 
@@ -175,10 +175,10 @@ def test_multiple_identity_gates(self) -> None:
         """Multiple identity gates are removed."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ[0](q[0]),
+            qb.RZ(0, q[0]),
             qb.H(q[0]),
-            qb.RX[0](q[0]),
-            qb.RY[2 * math.pi](q[0]),
+            qb.RX(0, q[0]),
+            qb.RY(2 * math.pi, q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -191,10 +191,10 @@ def test_mixed_with_nonidentity(self) -> None:
         """Identity gates removed among non-identity gates."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ[0](q[0]),  # Removed
-            qb.RZ[0.5](q[0]),  # Kept
-            qb.RX[0](q[0]),  # Removed
-            qb.RX[0.5](q[0]),  # Kept
+            qb.RZ(0, q[0]),  # Removed
+            qb.RZ(0.5, q[0]),  # Kept
+            qb.RX(0, q[0]),  # Removed
+            qb.RX(0.5, q[0]),  # Kept
         )
 
         ast = slr_to_ast(prog)
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/optimizations/test_pipeline.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/optimizations/test_pipeline.py
index 978e0ee51..0a2502b97 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/optimizations/test_pipeline.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/optimizations/test_pipeline.py
@@ -78,8 +78,8 @@ def test_level_2_rotation_merging(self) -> None:
         """Level 2 adds rotation merging."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ[0.5](q[0]),
-            qb.RZ[0.3](q[0]),
+            qb.RZ(0.5, q[0]),
+            qb.RZ(0.3, q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -92,7 +92,7 @@ def test_level_3_identity_removal(self) -> None:
         """Level 3 adds identity removal."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ[0](q[0]),
+            qb.RZ(0, q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -137,8 +137,8 @@ def test_pipeline_fixed_point(self) -> None:
 
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ[0.5](q[0]),
-            qb.RZ[-0.5](q[0]),
+            qb.RZ(0.5, q[0]),
+            qb.RZ(-0.5, q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -206,13 +206,13 @@ def test_default_pipeline_all_optimizations(self) -> None:
         # Circuit with multiple optimization opportunities
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ[0](q[0]),  # Identity removal
+            qb.RZ(0, q[0]),  # Identity removal
             qb.X(q[0]),  # Gate cancellation
             qb.X(q[0]),
             qb.SZ(q[0]),  # Inverse cancellation
             qb.SZdg(q[0]),
-            qb.RZ[0.5](q[0]),  # Rotation merging
-            qb.RZ[0.3](q[0]),
+            qb.RZ(0.5, q[0]),  # Rotation merging
+            qb.RZ(0.3, q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -257,8 +257,8 @@ def test_total_optimizations(self) -> None:
             q := QReg("q", 1),
             qb.X(q[0]),
             qb.X(q[0]),
-            qb.RZ[0.5](q[0]),
-            qb.RZ[0.3](q[0]),
+            qb.RZ(0.5, q[0]),
+            qb.RZ(0.3, q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -305,8 +305,8 @@ def test_rotation_to_identity_chain(self) -> None:
         """Chain of rotations that sum to identity."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ[math.pi](q[0]),
-            qb.RZ[math.pi](q[0]),  # Sum is 2*pi = identity
+            qb.RZ(math.pi, q[0]),
+            qb.RZ(math.pi, q[0]),  # Sum is 2*pi = identity
         )
 
         ast = slr_to_ast(prog)
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/optimizations/test_rotation_merging.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/optimizations/test_rotation_merging.py
index 0a34abfd3..99d0118b9 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/optimizations/test_rotation_merging.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/optimizations/test_rotation_merging.py
@@ -27,8 +27,8 @@ def test_rz_rz_merges(self) -> None:
         """RZ+RZ on same qubit merges."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ[0.5](q[0]),
-            qb.RZ[0.3](q[0]),
+            qb.RZ(0.5, q[0]),
+            qb.RZ(0.3, q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -49,8 +49,8 @@ def test_rx_rx_merges(self) -> None:
         """RX+RX on same qubit merges."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RX[math.pi / 4](q[0]),
-            qb.RX[math.pi / 4](q[0]),
+            qb.RX(math.pi / 4, q[0]),
+            qb.RX(math.pi / 4, q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -69,8 +69,8 @@ def test_ry_ry_merges(self) -> None:
         """RY+RY on same qubit merges."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RY[0.1](q[0]),
-            qb.RY[0.2](q[0]),
+            qb.RY(0.1, q[0]),
+            qb.RY(0.2, q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -93,8 +93,8 @@ def test_different_rotation_types_no_merge(self) -> None:
         """Different rotation types do not merge."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RX[0.5](q[0]),
-            qb.RZ[0.3](q[0]),
+            qb.RX(0.5, q[0]),
+            qb.RZ(0.3, q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -107,8 +107,8 @@ def test_different_qubits_no_merge(self) -> None:
         """Rotations on different qubits do not merge."""
         prog = Main(
             q := QReg("q", 2),
-            qb.RZ[0.5](q[0]),
-            qb.RZ[0.3](q[1]),
+            qb.RZ(0.5, q[0]),
+            qb.RZ(0.3, q[1]),
         )
 
         ast = slr_to_ast(prog)
@@ -121,9 +121,9 @@ def test_interleaved_rotations_no_merge(self) -> None:
         """Interleaved rotations do not merge."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ[0.5](q[0]),
+            qb.RZ(0.5, q[0]),
             qb.H(q[0]),  # Separates the RZ gates
-            qb.RZ[0.3](q[0]),
+            qb.RZ(0.3, q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -142,8 +142,8 @@ def test_merge_inside_if(self) -> None:
             q := QReg("q", 1),
             c := CReg("c", 1),
             If(c[0] == 1).Then(
-                qb.RZ[0.5](q[0]),
-                qb.RZ[0.3](q[0]),
+                qb.RZ(0.5, q[0]),
+                qb.RZ(0.3, q[0]),
             ),
         )
 
@@ -158,8 +158,8 @@ def test_merge_inside_repeat(self) -> None:
         prog = Main(
             q := QReg("q", 1),
             Repeat(cond=3).block(
-                qb.RX[0.1](q[0]),
-                qb.RX[0.2](q[0]),
+                qb.RX(0.1, q[0]),
+                qb.RX(0.2, q[0]),
             ),
         )
 
@@ -177,9 +177,9 @@ def test_three_rotations_merge_to_one(self) -> None:
         """Three consecutive rotations merge to one (requires multiple passes)."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ[0.1](q[0]),
-            qb.RZ[0.2](q[0]),
-            qb.RZ[0.3](q[0]),
+            qb.RZ(0.1, q[0]),
+            qb.RZ(0.2, q[0]),
+            qb.RZ(0.3, q[0]),
         )
 
         ast = slr_to_ast(prog)
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_codegen_equivalence.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_codegen_equivalence.py
index 65d154b4a..cd04700bb 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_codegen_equivalence.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_codegen_equivalence.py
@@ -355,7 +355,7 @@ def test_rx_gate_qasm(self) -> None:
 
         prog = Main(
             q := QReg("q", 1),
-            qb.RX[math.pi / 4](q[0]),
+            qb.RX(math.pi / 4, q[0]),
         )
 
         # AST path first
@@ -376,7 +376,7 @@ def test_ry_gate_qasm(self) -> None:
 
         prog = Main(
             q := QReg("q", 1),
-            qb.RY[math.pi / 2](q[0]),
+            qb.RY(math.pi / 2, q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -395,7 +395,7 @@ def test_rz_gate_qasm(self) -> None:
 
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ[math.pi](q[0]),
+            qb.RZ(math.pi, q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -414,9 +414,9 @@ def test_multiple_rotations_qasm(self) -> None:
 
         prog = Main(
             q := QReg("q", 2),
-            qb.RX[math.pi / 4](q[0]),
-            qb.RY[math.pi / 2](q[1]),
-            qb.RZ[math.pi](q[0]),
+            qb.RX(math.pi / 4, q[0]),
+            qb.RY(math.pi / 2, q[1]),
+            qb.RZ(math.pi, q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -666,9 +666,9 @@ def test_qft_like_circuit_qasm(self) -> None:
         prog = Main(
             q := QReg("q", 3),
             qb.H(q[0]),
-            qb.RZ[math.pi / 2](q[0]),
+            qb.RZ(math.pi / 2, q[0]),
             qb.H(q[1]),
-            qb.RZ[math.pi / 4](q[1]),
+            qb.RZ(math.pi / 4, q[1]),
             qb.H(q[2]),
         )
 
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_integration.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_integration.py
index 5f0d743f4..921f7cccd 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_integration.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_integration.py
@@ -160,9 +160,9 @@ def test_rotation_gates_roundtrip(self) -> None:
         """Rotation gates with float params round-trip."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ[0.5](q[0]),
-            qb.RX[math.pi / 4](q[0]),
-            qb.RY[1.234567890123](q[0]),
+            qb.RZ(0.5, q[0]),
+            qb.RX(math.pi / 4, q[0]),
+            qb.RY(1.234567890123, q[0]),
         )
 
         ast = slr_to_ast(prog)
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_pretty_print.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_pretty_print.py
index 577cc90e5..d81d3e618 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_pretty_print.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_pretty_print.py
@@ -121,16 +121,16 @@ def test_rotation_gates(self) -> None:
         """Rotation gates with parameters print correctly."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ[0.5](q[0]),
-            qb.RX[math.pi](q[0]),
+            qb.RZ(0.5, q[0]),
+            qb.RX(math.pi, q[0]),
         )
 
         ast = slr_to_ast(prog)
         result = pretty_print(ast)
 
-        assert "qb.RZ[0.5](q[0])" in result
-        # Pi value should be formatted
-        assert "qb.RX[" in result
+        assert "qb.RZ(0.5, q[0])" in result
+        # #97: angle-first form `qb.RX(theta, q)`, angle rendered first.
+        assert "qb.RX(3.141592653589793, q[0])" in result
 
 
 class TestPrettyPrintControlFlow:
@@ -301,7 +301,7 @@ def test_rotation_gate_statement(self) -> None:
 
         result = format_statement(stmt)
 
-        assert result == "qb.RZ[0.25](q[0])"
+        assert result == "qb.RZ(0.25, q[0])"
 
 
 class TestPrettyPrintIndentation:
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_serialize.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_serialize.py
index 0f01a809b..5bc682788 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_serialize.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_serialize.py
@@ -236,8 +236,8 @@ def test_rotation_gates(self) -> None:
         """Rotation gates with float params round-trip."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ[0.5](q[0]),
-            qb.RX[math.pi](q[0]),
+            qb.RZ(0.5, q[0]),
+            qb.RX(math.pi, q[0]),
         )
 
         ast = slr_to_ast(prog)
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/validation/test_pipeline.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/validation/test_pipeline.py
index cd8b884e7..e2dd9ddeb 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/validation/test_pipeline.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/validation/test_pipeline.py
@@ -54,8 +54,8 @@ def test_validate_with_rotation(self) -> None:
         """Program with rotation gates passes."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ[0.5](q[0]),
-            qb.RX[math.pi](q[0]),
+            qb.RZ(0.5, q[0]),
+            qb.RX(math.pi, q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -71,7 +71,7 @@ def test_validate_complex_circuit(self) -> None:
             qb.H(q[0]),
             qb.CX(q[0], q[1]),
             qb.CX(q[1], q[2]),
-            qb.RZ[0.5](q[0]),
+            qb.RZ(0.5, q[0]),
             If(c[0] == 1).Then(
                 qb.X(q[0]),
             ),
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/validation/test_type_checker.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/validation/test_type_checker.py
index d5fb45963..ce9c4bf7a 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/validation/test_type_checker.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/validation/test_type_checker.py
@@ -53,8 +53,8 @@ def test_valid_rotation_gates(self) -> None:
         """Valid rotation gate with angle parameter."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ[0.5](q[0]),
-            qb.RX[math.pi](q[0]),
+            qb.RZ(0.5, q[0]),
+            qb.RX(math.pi, q[0]),
         )
 
         ast = slr_to_ast(prog)
diff --git a/python/quantum-pecos/tests/slr/pecos/unit/slr/test_quantum_permutation.py b/python/quantum-pecos/tests/slr/pecos/unit/slr/test_quantum_permutation.py
index ed541f2e9..7bb8b924a 100644
--- a/python/quantum-pecos/tests/slr/pecos/unit/slr/test_quantum_permutation.py
+++ b/python/quantum-pecos/tests/slr/pecos/unit/slr/test_quantum_permutation.py
@@ -361,9 +361,9 @@ def test_rotation_gates_with_permutation() -> None:
         a,
         b,
         # Apply initial gates to track qubit allocation
-        qubit.RX[0.1](a[0]),  # Track as "original a[0]"
-        qubit.RY[0.2](a[1]),  # Track as "original a[1]"
-        qubit.RZ[0.3](b[0]),  # Track as "original b[0]"
+        qubit.RX(0.1, a[0]),  # Track as "original a[0]"
+        qubit.RY(0.2, a[1]),  # Track as "original a[1]"
+        qubit.RZ(0.3, b[0]),  # Track as "original b[0]"
         qubit.SZ(b[1]),  # Track as "original b[1]"
         # Apply permutation
         Permute(
@@ -371,8 +371,8 @@ def test_rotation_gates_with_permutation() -> None:
             [b[0], a[0]],
         ),
         # Apply gates after permutation
-        qubit.RX[0.4](a[0]),  # Should apply to "original b[0]"
-        qubit.RY[0.5](b[0]),  # Should apply to "original a[0]"
+        qubit.RX(0.4, a[0]),  # Should apply to "original b[0]"
+        qubit.RY(0.5, b[0]),  # Should apply to "original a[0]"
         qubit.T(a[1]),  # Should apply to "original a[1]"
         qubit.Tdg(b[1]),  # Should apply to "original b[1]"
     )
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
index 32944ad4e..291a3214d 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
@@ -612,15 +612,17 @@ def _docs_prep_basis_x() -> Block:
 
 
 def _docs_rotation_rx_probe() -> Block:
-    """Probe: RX rotation gate from docs/development/slr-qeclib.md.
+    """Probe: RX rotation gate, angle-first SLR API `RX(theta, q)`.
 
-    Per v1-feature-matrix: rotations need design; doc-test form
-    `RX(q[0], 0.5)` "currently looks like extra qargs." Probe to record.
+    The doc-test originally wrote `RX(q, 0.5)` (qubit-first, angle as a
+    stray qarg). With the angle-first SLR API (#97) the canonical form
+    is `RX(theta, q)`; RX is now a supported native rotation in both
+    the Guppy emitter (Phase A -> `rx`) and the QIR backend.
     """
     return Main(
         q := QReg("q", 1),
         c := CReg("c", 1),
-        qb.RX(q[0], 0.5),
+        qb.RX(0.5, q[0]),
         Measure(q) > c,
         Return(c),
     )
@@ -749,17 +751,6 @@ def _curated_cases() -> list[AuditCase]:
         AuditCase(
             "docs.rotation_rx",
             _docs_rotation_rx_probe,
-            expected_failure=ExpectedFailure(
-                exception_type="GuppyCodegenError",
-                message_contains="requires an angle parameter",
-                classification="api-misuse",
-                reason=(
-                    "RX is now supported via the bracket-param form `RX[theta](q)` "
-                    "(cross-codegen Guppy Phase A -> native `rx`). The doc-test "
-                    "positional form `RX(q, 0.5)` passes the angle as a qarg, leaving "
-                    "no param, so it fails loud -- the gate is supported, the call shape is wrong."
-                ),
-            ),
         ),
         AuditCase(
             "docs.surface_syndrome_block18",
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
index 24acb8279..454b280b1 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
@@ -66,20 +66,28 @@ def test_hugr_rejects_symbolic_loopvar_indexing_cleanly() -> None:
         SlrConverter(prog).hugr()
 
 
-def test_hugr_decomposed_rotation_missing_angle_fails_loud() -> None:
-    # Cross-codegen post-review fold (Codex): a parameterized gate whose
-    # Guppy lowering is a DECOMPOSITION (RZZ/CRX/CRY) must fail loud with
-    # a clear GuppyCodegenError when called with no angle -- e.g. the
-    # malformed positional form `RZZ(q0, q1, 0.5)` that passes the angle
-    # as a qarg (leaving node.params empty). Previously the callable
-    # angle-spec indexed `p[0]` on the empty params and raised a raw
-    # IndexError; now it matches the native-rotation guard's message.
+def test_decomposed_rotation_misuse_fails_loud() -> None:
+    # Cross-codegen post-review fold (Codex) + #97 (angle-first API): a
+    # parameterized gate whose Guppy lowering is a DECOMPOSITION
+    # (RZZ/CRX/CRY) must fail loud on misuse, never a raw IndexError /
+    # silent miscompile.
+    #
+    # (1) Too few arguments (no angle at all) is caught at CALL time by
+    #     the gate base class -- `RZZ(angle, qubit...)` requires the
+    #     leading angle.
+    for gate_obj, name in [(qb.RZZ, "RZZ"), (qb.CRX, "CRX"), (qb.CRY, "CRY")]:
+        with pytest.raises(TypeError, match=f"{name} is a parameterized gate"):
+            gate_obj()
+
+    # (2) A qubit passed where the angle belongs (`RZZ(q0, q1)` -- only
+    #     two args, so q0 is taken as the angle) builds the gate but
+    #     fails loud at Guppy emission: the angle is not a literal.
     for gate_obj, name in [(qb.RZZ, "RZZ"), (qb.CRX, "CRX"), (qb.CRY, "CRY")]:
         prog = Main(
             q := QReg("q", 2),
-            gate_obj(q[0], q[1], 0.5),  # angle as positional qarg -> no param
+            gate_obj(q[0], q[1]),  # q0 mis-bound as the angle
         )
-        with pytest.raises(GuppyCodegenError, match=f"parameterized gate {name} requires an angle parameter"):
+        with pytest.raises(GuppyCodegenError, match=f"decomposition of {name} requires literal angle parameters"):
             SlrConverter(prog).guppy()
 
 
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
index bbb875201..d790c52bc 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
@@ -236,6 +236,15 @@ def _high_bits_zero_1(obs: set[tuple[int, ...]]) -> None:
         "(An earlier deterministic [0] guess assumed the OLD broken "
         "Prep('X')=Z-reset, fixed by #81.)",
     ),
+    "docs.rotation_rx": (
+        "X",
+        "#97 (angle-first SLR API): `RX(0.5, q)` builds + lowers via "
+        "qir_to_qis (rx is qir-qis-allowlisted), but rx(0.5) is "
+        "NON-CLIFFORD so it cannot execute on the Stim backend this "
+        "suite uses -- excluded from the executable record (rx "
+        "correctness is covered by the Guppy Quest-backed behavioral "
+        "tests + the QIR rx emission). This #79 suite is Stim-only.",
+    ),
     "qeclib.color488_syn_extract_bare": (
         "X",
         "Color488 syndrome extraction: on |0..0> the X-stabiliser "
@@ -286,7 +295,17 @@ def test_qir_corpus_manifest_covers_qis_ok() -> None:
     stale = set(_MANIFEST) - qis_ok
     assert not stale, f"manifest entries no longer QIS_OK (remove/retriage): {sorted(stale)}"
     hist = {cls: sum(1 for c, _ in _MANIFEST.values() if c == cls) for cls in ("D", "P", "X")}
-    assert hist == {"D": 3, "P": 8, "X": 13}, f"manifest class histogram changed (deliberate?): {hist}"
+    assert hist == {"D": 3, "P": 8, "X": 14}, f"manifest class histogram changed (deliberate?): {hist}"
+
+
+# QIS_OK programs that build + lower via qir_to_qis but contain
+# NON-CLIFFORD operations the Stim backend (this suite's only
+# simulator) cannot execute. They are classified X and the
+# record-shape contract is waived: there is no Stim record to
+# inspect. Their gate semantics are covered elsewhere (e.g. the
+# Guppy Quest-backed behavioral suite). This is the Stim-only
+# boundary of the #79 executable corpus, made explicit.
+_NON_CLIFFORD_UNEXECUTABLE_ON_STIM: frozenset[str] = frozenset({"docs.rotation_rx"})
 
 
 @pytest.mark.slow
@@ -314,6 +333,10 @@ def test_qir_corpus_executable(label: str) -> None:
     has_record = "call void @__quantum__rt__int_record_output" in qir
 
     if cls == "X":
+        if label in _NON_CLIFFORD_UNEXECUTABLE_ON_STIM:
+            # Builds + lowers via qir_to_qis, but Stim cannot run the
+            # non-Clifford op -- no executable record to assert here.
+            return
         if has_record:
             # Record-shape contract: X-with-output must still
             # actually produce executable records (the exclusion is
@@ -591,12 +614,12 @@ def _run(prep, ops, meas_idx=0):
 
     import math as _math
 
-    crx_pi = lambda q: qb.CRX[_math.pi](q[0], q[1])  # noqa: E731
-    cry_pi = lambda q: qb.CRY[_math.pi](q[0], q[1])  # noqa: E731
-    crz_pi = lambda q: qb.CRZ[_math.pi](q[0], q[1])  # noqa: E731
-    crx_half = lambda q: qb.CRX[_math.pi / 2](q[0], q[1])  # noqa: E731
-    cry_half = lambda q: qb.CRY[_math.pi / 2](q[0], q[1])  # noqa: E731
-    crz_half = lambda q: qb.CRZ[_math.pi / 2](q[0], q[1])  # noqa: E731
+    crx_pi = lambda q: qb.CRX(_math.pi, q[0], q[1])  # noqa: E731
+    cry_pi = lambda q: qb.CRY(_math.pi, q[0], q[1])  # noqa: E731
+    crz_pi = lambda q: qb.CRZ(_math.pi, q[0], q[1])  # noqa: E731
+    crx_half = lambda q: qb.CRX(_math.pi / 2, q[0], q[1])  # noqa: E731
+    cry_half = lambda q: qb.CRY(_math.pi / 2, q[0], q[1])  # noqa: E731
+    crz_half = lambda q: qb.CRZ(_math.pi / 2, q[0], q[1])  # noqa: E731
     x_q0 = lambda q: qb.X(q[0])  # noqa: E731
     h_q1 = lambda q: qb.H(q[1])  # noqa: E731
 
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
index 3c25d93d8..fb0ff141b 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
@@ -39,7 +39,7 @@
 `mz__body` -> static `%Result*` -> `read_result` -> `store`;
 point-of-use `gep`+`load`/`store`; `zext`/`shl`/`or` pack ->
 `__quantum__rt__int_record_output`). Every validate-passing program
-(`_EXPECTED_QIS_OK`, n=24) now lowers via `qir_to_qis`; `qis_failed`
+(`_EXPECTED_QIS_OK`, n=25) now lowers via `qir_to_qis`; `qis_failed`
 is empty. A NEW qir_to_qis failure -- or a dropped program -- trips
 this deliberately. (`docs.while_loop` was in this set pre-#74 on a
 silently-wrong single-pass approximation; #74 makes the QIR backend
@@ -56,10 +56,9 @@
 #79 generalises it corpus-wide; this structural gate provides
 that suite's authoritative QIS_OK set.
 
-**Build failures** (5): `qir_bc()` raises for
-`docs.for_loopvar_symbolic` (symbolic `LoopVar` indexing) /
-`docs.rotation_rx` (`rx` gate) -- pre-existing AST-QIR feature
-gaps; `docs.while_loop` (#74: the QIR backend now fails LOUD
+**Build failures** (4): `qir_bc()` raises for
+`docs.for_loopvar_symbolic` (symbolic `LoopVar` indexing) --
+a pre-existing AST-QIR feature gap; `docs.while_loop` (#74: the QIR backend now fails LOUD
 on `While` instead of silently emitting a one-pass
 approximation that qir-qis cannot catch; this aligns the QIR
 path with the Guppy path, which already rejects `While` per
@@ -109,7 +108,12 @@
 # fragment would not match; the bare identifier/head is stable.
 _EXPECTED_BUILD_FAILED: dict[str, tuple[str, str]] = {
     "docs.for_loopvar_symbolic": ("AttributeError", "SymbolicQubit"),
-    "docs.rotation_rx": ("RuntimeError", "__quantum__qis__rx__body"),
+    # #97 (angle-first SLR API): `docs.rotation_rx` was BUILD_FAILED only
+    # because the doc-test probe used the malformed `RX(q, 0.5)` form
+    # (0.5 treated as a stray qarg). With `RX(theta, q)` the probe is
+    # well-formed and `rx` is in the qir-qis allowlist, so it now builds
+    # and lowers via qir_to_qis -> moved to _EXPECTED_QIS_OK (re-pinned
+    # from the actual `_qir_state()`, never guessed).
     # #74: the QIR backend now fails LOUD on `While` (was a silent
     # single-pass approximation that qir-qis could not catch -- valid
     # QIR, wrong semantics). `docs.while_loop` moved QIS_OK -> here
@@ -159,7 +163,7 @@
 
 # Tier 2: post-B2, EVERY validate-passing program lowers via
 # `qir_to_qis` (M-B2-static replaced the bespoke CReg helpers).
-# This is the full set (n=24); `qis_failed` must be empty. A new
+# This is the full set (n=25); `qis_failed` must be empty. A new
 # qir_to_qis failure -- or a dropped/added program -- trips the
 # Tier-2 assertions and must be triaged deliberately.
 _EXPECTED_QIS_OK: frozenset[str] = frozenset(
@@ -170,6 +174,12 @@
         # non-Z-Prep BUILD_FAILED pin; re-pinned from actual _qir_state).
         "docs.prep_basis_x",
         "docs.repeat_state_preserving",
+        # #97 (angle-first SLR API): `RX(theta, q)` is well-formed and
+        # `rx` is qir-qis-allowlisted, so the rotation_rx probe now
+        # lowers via qir_to_qis (was BUILD_FAILED on the malformed
+        # `RX(q, 0.5)` doc-form). Not end-to-end-executable on Stim
+        # (rx is non-Clifford) -> #79 manifest classifies it X.
+        "docs.rotation_rx",
         "examples.measure_register_to_creg",
         "examples.parallel_bell_pairs",
         "examples.surface_d3_x_1round",
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py
index ed3413ce1..e30029da2 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py
@@ -442,7 +442,7 @@ def test_rx_pi_is_x(self) -> None:
         prog = Main(
             q := QReg("q", 1),
             c := CReg("c", 1),
-            qb.RX[math.pi](q[0]),
+            qb.RX(math.pi, q[0]),
             Measure(q[0]) > c[0],
             Return(c),
         )
@@ -453,8 +453,8 @@ def test_rx_pi_is_x(self) -> None:
         halves = Main(
             q := QReg("q", 1),
             c := CReg("c", 1),
-            qb.RX[math.pi / 2](q[0]),
-            qb.RX[math.pi / 2](q[0]),
+            qb.RX(math.pi / 2, q[0]),
+            qb.RX(math.pi / 2, q[0]),
             Measure(q[0]) > c[0],
             Return(c),
         )
@@ -466,7 +466,7 @@ def test_ry_pi_is_y(self) -> None:
         prog = Main(
             q := QReg("q", 1),
             c := CReg("c", 1),
-            qb.RY[math.pi](q[0]),
+            qb.RY(math.pi, q[0]),
             Measure(q[0]) > c[0],
             Return(c),
         )
@@ -482,7 +482,7 @@ def test_rz_phase_via_hadamard_sandwich(self) -> None:
             q := QReg("q", 1),
             c := CReg("c", 1),
             qb.H(q[0]),
-            qb.RZ[math.pi](q[0]),
+            qb.RZ(math.pi, q[0]),
             qb.H(q[0]),
             Measure(q[0]) > c[0],
             Return(c),
@@ -501,7 +501,7 @@ def test_crz_control_phase(self) -> None:
             c := CReg("c", 1),
             qb.X(q[0]),
             qb.H(q[1]),
-            qb.CRZ[math.pi](q[0], q[1]),
+            qb.CRZ(math.pi, q[0], q[1]),
             qb.H(q[1]),
             Measure(q[1]) > c[0],
             Return(c),
@@ -585,7 +585,7 @@ def test_rzz_native_zz_phase(self) -> None:
             c := CReg("c", 2),
             qb.H(q[0]),
             qb.H(q[1]),
-            qb.RZZ[math.pi](q[0], q[1]),
+            qb.RZZ(math.pi, q[0], q[1]),
             qb.H(q[0]),
             qb.H(q[1]),
             Measure(q[0]) > c[0],
@@ -644,7 +644,7 @@ def test_crx_cry_control_active(self) -> None:
             c := CReg("c", 1),
             qb.X(q[0]),
             qb.H(q[1]),
-            qb.CRX[math.pi](q[0], q[1]),
+            qb.CRX(math.pi, q[0], q[1]),
             qb.H(q[1]),
             Measure(q[1]) > c[0],
             Return(c),
@@ -655,7 +655,7 @@ def test_crx_cry_control_active(self) -> None:
             c := CReg("c", 1),
             qb.X(q[0]),
             qb.H(q[1]),
-            qb.CRY[math.pi](q[0], q[1]),
+            qb.CRY(math.pi, q[0], q[1]),
             qb.H(q[1]),
             Measure(q[1]) > c[0],
             Return(c),
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py b/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py
index 7df57a005..3f38bc531 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py
@@ -126,7 +126,7 @@ def test_control_flow_qir() -> None:
             ),
         )
         .Else(
-            p.RX[0.3](q[0]),
+            p.RX(0.3, q[0]),
         ),
         If(m < m_hidden).Then(
             p.H(q[0]),
@@ -136,7 +136,7 @@ def test_control_flow_qir() -> None:
         p.SZdg(q[0]),
         p.CX(q[0], q[1]),
         Barrier(q[1], q[0]),
-        p.RX[0.3](q[0]),
+        p.RX(0.3, q[0]),
         p.Measure(q) > m,
         Return(m),
     )
@@ -349,9 +349,9 @@ def test_parallel_in_control_flow_qir() -> None:
         ),
         Repeat(2).block(
             Parallel(
-                p.RX[0.5](q[0]),
-                p.RY[0.5](q[1]),
-                p.RZ[0.5](q[2]),
+                p.RX(0.5, q[0]),
+                p.RY(0.5, q[1]),
+                p.RZ(0.5, q[2]),
             ),
         ),
         p.Measure(q) > m,
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_permutation.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_permutation.py
index 273b19236..88b0b9574 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_permutation.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_permutation.py
@@ -202,13 +202,13 @@ def test_rotation_gates_with_permutation() -> None:
     prog = Main(
         a,
         b,
-        qubit.RX[0.1](a[0]),  # q0
-        qubit.RY[0.2](a[1]),  # q1
-        qubit.RZ[0.3](b[0]),  # q2
+        qubit.RX(0.1, a[0]),  # q0
+        qubit.RY(0.2, a[1]),  # q1
+        qubit.RZ(0.3, b[0]),  # q2
         qubit.SZ(b[1]),  # q3
         Permute([a[0], b[0]], [b[0], a[0]]),
-        qubit.RX[0.4](a[0]),  # -> b[0] = q2
-        qubit.RY[0.5](b[0]),  # -> a[0] = q0
+        qubit.RX(0.4, a[0]),  # -> b[0] = q2
+        qubit.RY(0.5, b[0]),  # -> a[0] = q0
         qubit.T(a[1]),  # unpermuted = q1
         qubit.Tdg(b[1]),  # unpermuted = q3
     )
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_stim_conversion.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_stim_conversion.py
index b6746cf2a..0ce4c2d4a 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_stim_conversion.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_stim_conversion.py
@@ -348,7 +348,7 @@ def test_unsupported_gate_fails_loud() -> None:
     emitting the circuit without it is the bug.
     """
     q = QReg("q", 1)
-    prog = Main(q, qubit.RX[0.5](q[0]))
+    prog = Main(q, qubit.RX(0.5, q[0]))
     with pytest.raises(NotImplementedError, match=r"has no Stim lowering"):
         SlrConverter(prog).stim()
 
@@ -366,6 +366,7 @@ def test_face_clifford_gates_decompose() -> None:
     sign. The Heisenberg-picture conjugation `F . Z . Fdg = X` is
     the deterministic identity each face-Clifford must satisfy.
     """
+
     # Build a 1q Stim program with just `F q[0]` and read the tableau.
     def _tableau_of(gate) -> stim.Tableau:
         q = QReg("q", 1)

From 64c66f7e511527d8cd0adf3448e1bfa60d507b4e Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Thu, 21 May 2026 07:54:45 -0600
Subject: [PATCH 127/136] #97 followup: fix stale test_control_flow_qir comment
 (rx now lowers; build-only is the non-Clifford-on-Stim caveat)

---
 .../regression/random_cases/test_slr_phys.py    | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py b/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py
index 3f38bc531..27d208d9a 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py
@@ -142,14 +142,15 @@ def test_control_flow_qir() -> None:
     )
     # B1: whole-CReg scalar conditions (`If(m == 0)` / `If(m <
     # m_hidden)`) are now lowered via `_pack_creg` + `_op_map`; the
-    # QIR builds. CAVEAT: `RX[0.3]` in the program has NO qir-qis
-    # lowering (`docs.rotation_rx` is pinned BUILD/exec-failure;
-    # Stim no-ops rx), so the program is NOT end-to-end-executable
-    # post-B1 -- it BUILDS but cannot run through qir_to_qis. Assert
-    # the build succeeds and the QIR contains the expected
-    # classical-comparison structure; end-to-end execution is
-    # covered by `test_plus_qir` / `test_minus_qir` (pure-classical
-    # + Clifford only).
+    # QIR builds. CAVEAT: the `RX(0.3, q)` rotations DO build + lower
+    # (#97 angle-first API; `rx` is qir-qis-allowlisted), but rx(0.3)
+    # is NON-CLIFFORD so the program cannot execute on the Stim
+    # backend -- it is build-/lower-only here, NOT end-to-end. (The
+    # angle-first-executable rotation path is covered by the Guppy
+    # Quest-backed behavioral suite; the pure-classical arithmetic is
+    # covered end-to-end by `test_plus_qir` / `test_minus_qir`.)
+    # Assert the build succeeds and the QIR has the expected
+    # classical-comparison structure.
     qir = SlrConverter(prog).qir()
     # `If(m == 0)` and `If(m < m_hidden)` lower to icmp + i64 packs.
     assert "icmp" in qir, "B1 If(m == 0) must lower to an icmp"

From 77b149dca09a7bda9f786068b09dc0b220a9994d Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Thu, 21 May 2026 08:38:00 -0600
Subject: [PATCH 128/136] #97 post-review fold (Codex blocker): fail loud on
 mis-ordered angle-first calls (SLR __call__ type guard + QIR/QASM arity
 guards)

---
 .../src/pecos/slr/ast/codegen/qasm.py         | 17 +++++
 .../src/pecos/slr/ast/codegen/qir.py          | 19 ++++++
 .../src/pecos/slr/qeclib/qubit/qgate_base.py  | 28 +++++++-
 .../slr_tests/ast_guppy/test_ast_hugr.py      | 67 +++++++++++++------
 4 files changed, 109 insertions(+), 22 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qasm.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qasm.py
index 9546c364b..1050a4a9e 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qasm.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qasm.py
@@ -317,6 +317,23 @@ def visit_gate(self, node: GateOp) -> list[str]:
         """Generate gate operation."""
         lines = []
 
+        # Fail-loud arity guard (defense-in-depth vs the angle-first
+        # mis-order footgun): a parameterized gate with fewer targets
+        # than its qubit arity would otherwise SILENTLY emit no QASM
+        # line (the two-qubit path is gated on `len(targets) >= 2`, the
+        # single-qubit path iterates zero targets). The SLR
+        # `QGate.__call__` rejects the mis-ordered call at the source;
+        # this guards a malformed GateOp reaching QASM from any other
+        # path. Multi-target (parallel) application is fine (len >= arity).
+        if node.gate.is_parameterized and len(node.targets) < node.gate.arity:
+            msg = (
+                f"QASM codegen: parameterized gate {node.gate.name!r} has "
+                f"{len(node.targets)} qubit target(s) but needs at least "
+                f"{node.gate.arity} (a mis-ordered `gate(qubit, angle)` call "
+                "drops the qubit). Call it as `gate(angle, qubit...)`."
+            )
+            raise NotImplementedError(msg)
+
         # Handle special face rotation gates
         if node.gate == GateKind.F:
             for target in node.targets:
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
index 3c1a8c582..ea0da2611 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
@@ -597,6 +597,25 @@ def _process_return(self, node: ReturnOp) -> None:
 
     def _process_gate(self, node: GateOp) -> None:
         """Process a gate operation."""
+        # Fail-loud arity guard (defense-in-depth vs the angle-first
+        # mis-order footgun): a parameterized gate with fewer targets
+        # than its qubit arity would otherwise SILENTLY emit no call
+        # (the per-target emit loops just iterate zero/too-few times),
+        # or hit a raw IndexError in the decomposition path. The SLR
+        # `QGate.__call__` already rejects the mis-ordered call at the
+        # source; this guards a malformed GateOp reaching codegen from
+        # any other path. Multi-target (parallel) application is fine
+        # (len >= arity).
+        if node.gate.is_parameterized and len(node.targets) < node.gate.arity:
+            gate_name = getattr(node.gate, "name", node.gate)
+            msg = (
+                f"QIR codegen: parameterized gate {gate_name!r} has "
+                f"{len(node.targets)} qubit target(s) but needs at least "
+                f"{node.gate.arity} (a mis-ordered `gate(qubit, angle)` call "
+                "drops the qubit). Call it as `gate(angle, qubit...)`."
+            )
+            raise NotImplementedError(msg)
+
         qir_name = GATE_TO_QIR.get(node.gate)
         if qir_name is None and node.gate in _GATE_DECOMP:
             # #93: a gate with no direct QIR primitive but a verified
diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/qubit/qgate_base.py b/python/quantum-pecos/src/pecos/slr/qeclib/qubit/qgate_base.py
index 4049c9053..946bc334d 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/qubit/qgate_base.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/qubit/qgate_base.py
@@ -137,8 +137,32 @@ def __call__(self, *args: Qubit | complex) -> Self:
                     f"parameter(s) before the qubit(s). Got {len(args)} argument(s)."
                 )
                 raise TypeError(msg)
-            g.params = tuple(args[:n])
-            g.add_qargs(tuple(args[n:]))
+            params = tuple(args[:n])
+            qargs = tuple(args[n:])
+            # Angle-first guard: a qubit reference in an angle slot, or a
+            # non-qubit in a qubit slot, is the classic mis-ordered call
+            # (`RX(q, 0.5)` instead of `RX(0.5, q)`). Pre-#97 this was the
+            # silent-angle-drop footgun; reject it loudly at the call so a
+            # typo can never reach codegen as a no-op (qubit refs are
+            # `Var` subclasses; angles are numbers/expressions).
+            from pecos.slr.vars import Var  # noqa: PLC0415  (avoid import cycle at module load)
+
+            for p in params:
+                if isinstance(p, Var):
+                    msg = (
+                        f"{self.sym}: a qubit reference {p!r} was passed in an angle position. "
+                        f"Call as `{self.sym}(angle, qubit...)` -- angles come before qubit ids."
+                    )
+                    raise TypeError(msg)
+            for qa in qargs:
+                if not isinstance(qa, Var):
+                    msg = (
+                        f"{self.sym}: a non-qubit {qa!r} was passed in a qubit position. "
+                        f"Call as `{self.sym}(angle, qubit...)` with {n} leading angle parameter(s)."
+                    )
+                    raise TypeError(msg)
+            g.params = params
+            g.add_qargs(qargs)
         else:
             g.add_qargs(args)
 
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
index 454b280b1..eea83963b 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
@@ -66,29 +66,56 @@ def test_hugr_rejects_symbolic_loopvar_indexing_cleanly() -> None:
         SlrConverter(prog).hugr()
 
 
-def test_decomposed_rotation_misuse_fails_loud() -> None:
-    # Cross-codegen post-review fold (Codex) + #97 (angle-first API): a
-    # parameterized gate whose Guppy lowering is a DECOMPOSITION
-    # (RZZ/CRX/CRY) must fail loud on misuse, never a raw IndexError /
-    # silent miscompile.
-    #
-    # (1) Too few arguments (no angle at all) is caught at CALL time by
-    #     the gate base class -- `RZZ(angle, qubit...)` requires the
-    #     leading angle.
-    for gate_obj, name in [(qb.RZZ, "RZZ"), (qb.CRX, "CRX"), (qb.CRY, "CRY")]:
+def test_angle_first_misuse_fails_loud_at_call() -> None:
+    # #97 (angle-first API) post-review fold (Codex blocker): a
+    # mis-ordered `gate(qubit, angle)` call -- the pre-#97 silent-
+    # angle-drop footgun -- must fail loud at the SLR call, never
+    # compile to a silent no-op.
+    q = QReg("q", 2)
+
+    # (1) Too few arguments (no angle at all).
+    for gate_obj, name in [(qb.RX, "RX"), (qb.RZZ, "RZZ"), (qb.CRX, "CRX"), (qb.CRZ, "CRZ")]:
         with pytest.raises(TypeError, match=f"{name} is a parameterized gate"):
             gate_obj()
 
-    # (2) A qubit passed where the angle belongs (`RZZ(q0, q1)` -- only
-    #     two args, so q0 is taken as the angle) builds the gate but
-    #     fails loud at Guppy emission: the angle is not a literal.
-    for gate_obj, name in [(qb.RZZ, "RZZ"), (qb.CRX, "CRX"), (qb.CRY, "CRY")]:
-        prog = Main(
-            q := QReg("q", 2),
-            gate_obj(q[0], q[1]),  # q0 mis-bound as the angle
-        )
-        with pytest.raises(GuppyCodegenError, match=f"decomposition of {name} requires literal angle parameters"):
-            SlrConverter(prog).guppy()
+    # (2) Qubit reference in an angle slot (the classic `RX(q, 0.5)` /
+    #     `RZZ(q0, q1)` mis-order). Caught at the call by the base class.
+    with pytest.raises(TypeError, match=r"RX: a qubit reference .* angle position"):
+        qb.RX(q[0], 0.5)
+    for gate_obj, name in [(qb.RZZ, "RZZ"), (qb.CRX, "CRX"), (qb.CRZ, "CRZ")]:
+        with pytest.raises(TypeError, match=f"{name}: a qubit reference .* angle position"):
+            gate_obj(q[0], q[1])
+
+    # (3) Non-qubit in a qubit slot (`RX(0.5, 0.7)`).
+    with pytest.raises(TypeError, match=r"RX: a non-qubit .* qubit position"):
+        qb.RX(0.5, 0.7)
+
+
+def test_codegen_arity_guard_rejects_malformed_param_gate() -> None:
+    # #97 post-review fold (Codex blocker): even if a malformed
+    # parameterized GateOp reaches a codegen from a non-SLR path
+    # (the SLR `__call__` guard above blocks the user-facing route),
+    # QIR and QASM must FAIL LOUD on too-few-targets rather than
+    # silently emitting no operation (the pre-fold behavior: the
+    # single-qubit emit loop iterated zero targets; the two-qubit
+    # path was gated on `len(targets) >= 2`; the QIR decomposition
+    # path raised a raw IndexError).
+    from pecos.slr.ast.codegen.qasm import AstToQasm
+    from pecos.slr.ast.codegen.qir import AstToQir
+    from pecos.slr.ast.nodes import GateKind, GateOp, LiteralExpr, SlotRef
+
+    one = (SlotRef(allocator="q", index=0),)
+    malformed = [
+        ("RX", GateOp(gate=GateKind.RX, targets=(), params=(LiteralExpr(value=0.5),))),
+        ("RZZ", GateOp(gate=GateKind.RZZ, targets=one, params=(LiteralExpr(value=0.5),))),
+        ("CRX", GateOp(gate=GateKind.CRX, targets=one, params=(LiteralExpr(value=0.5),))),
+        ("CRZ", GateOp(gate=GateKind.CRZ, targets=one, params=(LiteralExpr(value=0.5),))),
+    ]
+    for name, node in malformed:
+        with pytest.raises(NotImplementedError, match=f"QIR codegen: parameterized gate {name!r}"):
+            AstToQir()._process_gate(node)  # noqa: SLF001
+        with pytest.raises(NotImplementedError, match=f"QASM codegen: parameterized gate {name!r}"):
+            AstToQasm().visit_gate(node)
 
 
 def test_hugr_accepts_inline_measure_creg_result() -> None:

From d826e9679f78a3834589b306dff3b89e4e5e2dc5 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Thu, 21 May 2026 09:10:47 -0600
Subject: [PATCH 129/136] #97 post-review fold: narrow qarg guard to quantum
 qubit types (Codex reconfirm blocker)

---
 .../src/pecos/slr/qeclib/qubit/qgate_base.py  | 30 ++++++++++++-------
 .../slr_tests/ast_guppy/test_ast_hugr.py      | 18 +++++++++--
 2 files changed, 35 insertions(+), 13 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/qubit/qgate_base.py b/python/quantum-pecos/src/pecos/slr/qeclib/qubit/qgate_base.py
index 946bc334d..b18f42aa2 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/qubit/qgate_base.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/qubit/qgate_base.py
@@ -139,26 +139,34 @@ def __call__(self, *args: Qubit | complex) -> Self:
                 raise TypeError(msg)
             params = tuple(args[:n])
             qargs = tuple(args[n:])
-            # Angle-first guard: a qubit reference in an angle slot, or a
-            # non-qubit in a qubit slot, is the classic mis-ordered call
+            # Angle-first guard: a register/qubit reference in an angle
+            # slot, or a non-qubit (number, classical register/bit, junk)
+            # in a qubit slot, is the classic mis-ordered call
             # (`RX(q, 0.5)` instead of `RX(0.5, q)`). Pre-#97 this was the
             # silent-angle-drop footgun; reject it loudly at the call so a
-            # typo can never reach codegen as a no-op (qubit refs are
-            # `Var` subclasses; angles are numbers/expressions).
-            from pecos.slr.vars import Var  # noqa: PLC0415  (avoid import cycle at module load)
-
+            # typo can never reach codegen as a no-op or as a rotation on
+            # a classical register. Qubit slots accept ONLY quantum
+            # qubit shapes (`Qubit`/`QReg`/`SymbolicQubit`) -- NOT the
+            # broad `Var` (which also covers classical `CReg`/`Bit`/
+            # `SymbolicBit`). Angle slots reject any `Var` ref (no
+            # register/bit is a valid angle; angles are numbers/exprs).
+            from pecos.slr.vars import QReg, Qubit, SymbolicQubit, Var  # noqa: PLC0415  (avoid import cycle)
+
+            qubit_types = (Qubit, QReg, SymbolicQubit)
             for p in params:
                 if isinstance(p, Var):
                     msg = (
-                        f"{self.sym}: a qubit reference {p!r} was passed in an angle position. "
-                        f"Call as `{self.sym}(angle, qubit...)` -- angles come before qubit ids."
+                        f"{self.sym}: a register/qubit reference {p!r} was passed in an angle "
+                        f"position. Call as `{self.sym}(angle, qubit...)` -- angles come before qubit ids."
                     )
                     raise TypeError(msg)
             for qa in qargs:
-                if not isinstance(qa, Var):
+                if not isinstance(qa, qubit_types):
+                    kind = "classical register/bit" if isinstance(qa, Var) else "non-qubit"
                     msg = (
-                        f"{self.sym}: a non-qubit {qa!r} was passed in a qubit position. "
-                        f"Call as `{self.sym}(angle, qubit...)` with {n} leading angle parameter(s)."
+                        f"{self.sym}: a {kind} {qa!r} was passed in a qubit position. "
+                        f"Call as `{self.sym}(angle, qubit...)` with {n} leading angle parameter(s); "
+                        "qubit positions accept only qubits/QRegs."
                     )
                     raise TypeError(msg)
             g.params = params
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
index eea83963b..b919c24c7 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
@@ -80,16 +80,30 @@ def test_angle_first_misuse_fails_loud_at_call() -> None:
 
     # (2) Qubit reference in an angle slot (the classic `RX(q, 0.5)` /
     #     `RZZ(q0, q1)` mis-order). Caught at the call by the base class.
-    with pytest.raises(TypeError, match=r"RX: a qubit reference .* angle position"):
+    with pytest.raises(TypeError, match=r"RX: a register/qubit reference .* angle position"):
         qb.RX(q[0], 0.5)
     for gate_obj, name in [(qb.RZZ, "RZZ"), (qb.CRX, "CRX"), (qb.CRZ, "CRZ")]:
-        with pytest.raises(TypeError, match=f"{name}: a qubit reference .* angle position"):
+        with pytest.raises(TypeError, match=f"{name}: a register/qubit reference .* angle position"):
             gate_obj(q[0], q[1])
 
     # (3) Non-qubit in a qubit slot (`RX(0.5, 0.7)`).
     with pytest.raises(TypeError, match=r"RX: a non-qubit .* qubit position"):
         qb.RX(0.5, 0.7)
 
+    # (4) Classical register/bit in a qubit slot (Codex reconfirm
+    #     blocker): `CReg`/`Bit`/`SymbolicBit` are `Var` subclasses
+    #     too, so a broad `isinstance(_, Var)` qubit check let
+    #     `RX(0.5, c[0])` through and QASM/QIR lowered `rx(0.5) c[0];`
+    #     against a classical register. Qubit slots accept ONLY
+    #     quantum qubit shapes (Qubit/QReg/SymbolicQubit).
+    c = CReg("c", 1)
+    with pytest.raises(TypeError, match=r"RX: a classical register/bit .* qubit position"):
+        qb.RX(0.5, c[0])
+    with pytest.raises(TypeError, match=r"RX: a classical register/bit .* qubit position"):
+        qb.RX(0.5, c)
+    with pytest.raises(TypeError, match=r"RZZ: a classical register/bit .* qubit position"):
+        qb.RZZ(0.5, q[0], c[0])
+
 
 def test_codegen_arity_guard_rejects_malformed_param_gate() -> None:
     # #97 post-review fold (Codex blocker): even if a malformed

From 76e2d4ce56d8bc3f672ce6f21fedf87cf243c7f6 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Thu, 21 May 2026 17:35:12 -0600
Subject: [PATCH 130/136] Add SLR v2 typed-angle API: rotation gates take
 rad()/turns() over the exposed angle64 dtype

---
 crates/pecos-core/src/angle.rs                |  69 +++++++++
 .../parallel-blocks-and-optimization.md       |   4 +-
 docs/development/slr-qeclib.md                |  10 +-
 docs/user-guide/parallel-execution.md         |  14 +-
 python/pecos-rslib/src/dtypes.rs              |  20 +++
 .../quantum-pecos/src/pecos/slr/__init__.py   |   5 +
 python/quantum-pecos/src/pecos/slr/angle.py   |  65 +++++++++
 .../src/pecos/slr/ast/codegen/guppy.py        |  77 +++++-----
 .../src/pecos/slr/ast/codegen/qasm.py         |  19 +++
 .../src/pecos/slr/ast/codegen/qir.py          |  80 +++++++----
 .../pecos/slr/ast/codegen/quantum_circuit.py  |  21 +--
 .../src/pecos/slr/ast/compare.py              |  11 ++
 .../src/pecos/slr/ast/converter.py            |  10 ++
 .../quantum-pecos/src/pecos/slr/ast/nodes.py  |   6 +-
 .../slr/ast/optimizations/identity_removal.py |   8 ++
 .../slr/ast/optimizations/rotation_merging.py |  17 ++-
 .../src/pecos/slr/ast/pretty_print.py         |   5 +
 .../src/pecos/slr/ast/serialize.py            |  13 ++
 .../pecos/slr/ast/validation/type_checker.py  |   8 +-
 .../src/pecos/slr/gen_codes/gen_qasm.py       |  13 +-
 .../src/pecos/slr/gen_codes/gen_qir.py        |  10 +-
 .../pecos/slr/gen_codes/qir_gate_mapping.py   |  11 +-
 .../src/pecos/slr/qeclib/qubit/__init__.py    |   4 +
 .../src/pecos/slr/qeclib/qubit/qgate_base.py  |  56 ++++++--
 .../slr/qeclib/steane/preps/plus_h_state.py   |   3 +-
 .../test_qasm/pecos/qeclib/qubit/test_rots.py |  10 +-
 .../test_qasm/random_cases/test_slr_phys.py   |  21 ++-
 .../optimizations/test_identity_removal.py    |  34 ++---
 .../ast_tests/optimizations/test_pipeline.py  |  28 ++--
 .../optimizations/test_rotation_merging.py    |  48 +++----
 .../slr/ast_tests/test_codegen_equivalence.py |  18 +--
 .../pecos/slr/ast_tests/test_integration.py   |   8 +-
 .../pecos/slr/ast_tests/test_pretty_print.py  |  14 +-
 .../pecos/slr/ast_tests/test_serialize.py     |   9 +-
 .../slr/ast_tests/validation/test_pipeline.py |   8 +-
 .../ast_tests/validation/test_type_checker.py |   6 +-
 .../unit/slr/test_quantum_permutation.py      |  12 +-
 .../tests/slr_tests/ast_guppy/audit_runner.py |  19 ++-
 .../slr_tests/ast_guppy/test_ast_hugr.py      |  18 ++-
 .../ast_guppy/test_qir_corpus_executable.py   |  16 +--
 .../slr_tests/ast_guppy/test_typed_angles.py  | 132 ++++++++++++++++++
 .../slr_tests/ast_guppy/test_v1_behavioral.py |  20 +--
 .../regression/random_cases/test_slr_phys.py  |  14 +-
 .../unit/slr/test_quantum_permutation.py      |  12 +-
 .../pecos/unit/slr/test_stim_conversion.py    |   4 +-
 45 files changed, 758 insertions(+), 252 deletions(-)
 create mode 100644 python/quantum-pecos/src/pecos/slr/angle.py
 create mode 100644 python/quantum-pecos/tests/slr_tests/ast_guppy/test_typed_angles.py

diff --git a/crates/pecos-core/src/angle.rs b/crates/pecos-core/src/angle.rs
index 64d805959..9d82d9711 100644
--- a/crates/pecos-core/src/angle.rs
+++ b/crates/pecos-core/src/angle.rs
@@ -148,6 +148,46 @@ where
         }
     }
 
+    /// Converts the angle to turns in `[0, 1)` (the inverse of `from_turns`).
+    ///
+    /// # Panics
+    /// This function will panic if the conversion of `fraction` or `max_value` to `f64` fails.
+    pub fn to_turns(&self) -> f64 {
+        let max_value = T::max_value()
+            .to_f64()
+            .expect("Failed to convert max_value to f64");
+        self.fraction
+            .to_f64()
+            .expect("Failed to convert fraction to f64")
+            / max_value
+    }
+
+    /// Converts the angle to signed turns in `(-0.5, 0.5]`.
+    pub fn to_turns_signed(&self) -> f64 {
+        let t = self.to_turns();
+        if t > 0.5 { t - 1.0 } else { t }
+    }
+
+    /// Converts the angle to half-turns in `[0, 2)` (π radians = 1 half-turn).
+    ///
+    /// Half-turns are the unit used by some backends (e.g. Guppy's `angle`),
+    /// where a full turn is `2.0`.
+    ///
+    /// # Panics
+    /// This function will panic if the conversion of `fraction` or `max_value` to `f64` fails.
+    pub fn to_half_turns(&self) -> f64 {
+        self.to_turns() * 2.0
+    }
+
+    /// Converts the angle to signed half-turns in `(-1, 1]`.
+    ///
+    /// Like [`Self::to_radians_signed`], this principal-value form avoids the
+    /// spurious global phase that the unsigned `[0, 2)` form introduces when a
+    /// half-angle (`θ/2`) computation crosses the 2π wrap point.
+    pub fn to_half_turns_signed(&self) -> f64 {
+        self.to_turns_signed() * 2.0
+    }
+
     /// Creates an angle from a value in radians.
     ///
     /// # Panics
@@ -668,6 +708,35 @@ mod tests {
     use rand::RngExt;
     use std::f64::consts::{FRAC_PI_2, FRAC_PI_4, PI, TAU};
 
+    #[test]
+    fn test_to_turns_and_half_turns() {
+        // Quarter turn = pi/2 rad = 0.25 turns = 0.5 half-turns.
+        let q = Angle64::QUARTER_TURN;
+        assert!((q.to_turns() - 0.25).abs() < 1e-12);
+        assert!((q.to_half_turns() - 0.5).abs() < 1e-12);
+        assert!((q.to_turns_signed() - 0.25).abs() < 1e-12);
+        assert!((q.to_half_turns_signed() - 0.5).abs() < 1e-12);
+
+        // Half-turn boundary: to_turns stays unsigned (0.5), signed maps to 0.5.
+        let h = Angle64::HALF_TURN;
+        assert!((h.to_turns() - 0.5).abs() < 1e-12);
+        assert!((h.to_half_turns() - 1.0).abs() < 1e-12);
+
+        // Three-quarter turn: unsigned 0.75 turns; signed wraps to -0.25 turns
+        // (-0.5 half-turns), mirroring to_radians_signed.
+        let tq = Angle64::THREE_QUARTERS_TURN;
+        assert!((tq.to_turns() - 0.75).abs() < 1e-12);
+        assert!((tq.to_turns_signed() - (-0.25)).abs() < 1e-12);
+        assert!((tq.to_half_turns_signed() - (-0.5)).abs() < 1e-12);
+
+        // half-turns == radians / pi for the unsigned form.
+        let a = Angle64::from_radians(0.7);
+        assert!((a.to_half_turns() - a.to_radians() / PI).abs() < 1e-9);
+        // round-trip turns.
+        let b = Angle64::from_turns(0.3);
+        assert!((b.to_turns() - 0.3).abs() < 1e-9);
+    }
+
     // Basic Construction and Properties
     #[test]
     fn test_constructors() {
diff --git a/docs/development/parallel-blocks-and-optimization.md b/docs/development/parallel-blocks-and-optimization.md
index 38677e248..1fb774022 100644
--- a/docs/development/parallel-blocks-and-optimization.md
+++ b/docs/development/parallel-blocks-and-optimization.md
@@ -271,7 +271,7 @@ Here's a more complex example showing parallel phase gates:
 
 ```python
 import numpy as np
-from pecos.slr import Main, Parallel, QReg
+from pecos.slr import Main, Parallel, QReg, rad
 from pecos.slr.qeclib import qubit as qb
 
 
@@ -280,7 +280,7 @@ def qft_layer(q, n, k):
     operations = []
     for j in range(k + 1, n):
         angle = np.pi / (2 ** (j - k))
-        operations.append(qb.CRZ(angle, q[j], q[k]))
+        operations.append(qb.CRZ(rad(angle), q[j], q[k]))
     return Parallel(*operations) if len(operations) > 1 else operations[0]
 
 
diff --git a/docs/development/slr-qeclib.md b/docs/development/slr-qeclib.md
index 2436b48a5..0e23d79ec 100644
--- a/docs/development/slr-qeclib.md
+++ b/docs/development/slr-qeclib.md
@@ -223,7 +223,7 @@ The `qeclib` module provides quantum operations organized by category:
 ### Qubit Operations (`pecos.slr.qeclib.qubit`)
 
 ```python
-from pecos.slr import Main, QReg, CReg
+from pecos.slr import Main, QReg, CReg, rad
 from pecos.slr.qeclib import qubit as qb
 
 prog = Main(
@@ -240,10 +240,10 @@ prog = Main(
     qb.SZdg(q[0]),  # S dagger
     qb.T(q[0]),  # T gate
     qb.Tdg(q[0]),  # T dagger
-    # Rotations (angle in radians)
-    qb.RX(q[0], 0.5),
-    qb.RY(q[0], 0.5),
-    qb.RZ(q[0], 0.5),
+    # Rotations (typed angle: rad(...) / turns(...))
+    qb.RX(rad(0.5), q[0]),
+    qb.RY(rad(0.5), q[0]),
+    qb.RZ(rad(0.5), q[0]),
     # Two-qubit gates
     qb.CX(q[0], q[1]),  # CNOT
     qb.CY(q[0], q[1]),
diff --git a/docs/user-guide/parallel-execution.md b/docs/user-guide/parallel-execution.md
index b9b935e07..e045e5d15 100644
--- a/docs/user-guide/parallel-execution.md
+++ b/docs/user-guide/parallel-execution.md
@@ -160,7 +160,7 @@ Parallel(
 Here's a complete example showing parallel quantum phase estimation:
 
 ```python
-from pecos.slr import Main, Parallel, Block, QReg, CReg, SlrConverter
+from pecos.slr import Main, Parallel, Block, QReg, CReg, SlrConverter, rad
 from pecos.slr.qeclib import qubit as qb
 import numpy as np
 
@@ -175,15 +175,15 @@ prog = Main(
         qb.H(q[2]),
     ),
     # Apply controlled rotations
-    qb.CRZ(np.pi, q[0], q[3]),
-    qb.CRZ(np.pi / 2, q[1], q[3]),
-    qb.CRZ(np.pi / 4, q[2], q[3]),
+    qb.CRZ(rad(np.pi), q[0], q[3]),
+    qb.CRZ(rad(np.pi / 2), q[1], q[3]),
+    qb.CRZ(rad(np.pi / 4), q[2], q[3]),
     # Inverse QFT on ancillas
     qb.H(q[0]),
-    qb.CRZ(-np.pi / 2, q[0], q[1]),
+    qb.CRZ(rad(-np.pi / 2), q[0], q[1]),
     qb.H(q[1]),
-    qb.CRZ(-np.pi / 4, q[0], q[2]),
-    qb.CRZ(-np.pi / 2, q[1], q[2]),
+    qb.CRZ(rad(-np.pi / 4), q[0], q[2]),
+    qb.CRZ(rad(-np.pi / 2), q[1], q[2]),
     qb.H(q[2]),
     # Measure ancillas
     Parallel(
diff --git a/python/pecos-rslib/src/dtypes.rs b/python/pecos-rslib/src/dtypes.rs
index 8f799086d..45ad86d39 100644
--- a/python/pecos-rslib/src/dtypes.rs
+++ b/python/pecos-rslib/src/dtypes.rs
@@ -3991,6 +3991,26 @@ impl ScalarAngle64 {
         self.value.to_radians_signed()
     }
 
+    /// Convert to turns (in [0, 1)) -- the inverse of `from_turns`
+    fn to_turns(&self) -> f64 {
+        self.value.to_turns()
+    }
+
+    /// Convert to signed turns (in (-0.5, 0.5])
+    fn to_turns_signed(&self) -> f64 {
+        self.value.to_turns_signed()
+    }
+
+    /// Convert to half-turns (in [0, 2)); pi radians = 1.0 half-turn
+    fn to_half_turns(&self) -> f64 {
+        self.value.to_half_turns()
+    }
+
+    /// Convert to signed half-turns (in (-1, 1])
+    fn to_half_turns_signed(&self) -> f64 {
+        self.value.to_half_turns_signed()
+    }
+
     /// Get the raw u64 fraction
     #[getter]
     fn fraction(&self) -> u64 {
diff --git a/python/quantum-pecos/src/pecos/slr/__init__.py b/python/quantum-pecos/src/pecos/slr/__init__.py
index 37f6a2b34..173f5b945 100644
--- a/python/quantum-pecos/src/pecos/slr/__init__.py
+++ b/python/quantum-pecos/src/pecos/slr/__init__.py
@@ -83,6 +83,7 @@
 from typing import TYPE_CHECKING
 
 from pecos.slr import ast, qeclib
+from pecos.slr.angle import Angle, rad, turns
 from pecos.slr.block import Block
 from pecos.slr.cond_block import If, Repeat
 from pecos.slr.loop_block import For, While
@@ -164,6 +165,7 @@ def generate(
 
 __all__ = [
     "SLR",
+    "Angle",
     "Array",
     "Barrier",
     "Bit",
@@ -197,4 +199,7 @@ def generate(
     "generate",
     # QEC library
     "qeclib",
+    # Typed angles for rotation gates
+    "rad",
+    "turns",
 ]
diff --git a/python/quantum-pecos/src/pecos/slr/angle.py b/python/quantum-pecos/src/pecos/slr/angle.py
new file mode 100644
index 000000000..12bf6581c
--- /dev/null
+++ b/python/quantum-pecos/src/pecos/slr/angle.py
@@ -0,0 +1,65 @@
+"""Typed angle values for SLR rotation gates.
+
+SLR rotation gates take a typed angle, not a bare float. `rad(x)` and
+`turns(x)` construct an :class:`Angle` whose value is the exposed
+``pecos.angle64`` fixed-point dtype -- the dtype carries all the math;
+the wrapper adds only the source unit, used solely for pretty-printing.
+Every backend unwraps to the underlying ``angle64`` before lowering, so
+the wrapper is a display policy, not a parallel angle type.
+"""
+
+# Copyright 2026 The PECOS Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+# the License.You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations under the License.
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Literal
+
+from pecos_rslib import angle64
+
+__all__ = ["Angle", "rad", "turns"]
+
+
+@dataclass(frozen=True)
+class Angle:
+    """A typed rotation angle: a ``pecos.angle64`` value plus its source unit.
+
+    The ``value`` holds the exact fixed-point angle and owns every
+    conversion (``to_radians``/``to_radians_signed``/``to_half_turns``/...).
+    ``source_unit`` records whether the user wrote ``rad(...)`` or
+    ``turns(...)`` so pretty-print can round-trip the unit label; it carries
+    no math and is never consulted during backend lowering.
+    """
+
+    value: angle64
+    source_unit: Literal["rad", "turns"]
+
+    def slr_repr(self) -> str:
+        """Render the SLR source form, e.g. ``rad(0.5)`` / ``turns(0.25)``.
+
+        Uses the signed conversion so ordinary negative rotations read
+        naturally; the numeric value is the canonicalized fixed-point angle,
+        not the user's original literal (angle64 does not retain it).
+        """
+        if self.source_unit == "turns":
+            return f"turns({self.value.to_turns_signed()})"
+        return f"rad({self.value.to_radians_signed()})"
+
+
+def rad(value: float) -> Angle:
+    """Construct an :class:`Angle` from a value in radians."""
+    return Angle(angle64.from_radians(float(value)), "rad")
+
+
+def turns(value: float) -> Angle:
+    """Construct an :class:`Angle` from a value in turns (1.0 = a full turn)."""
+    return Angle(angle64.from_turns(float(value)), "turns")
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
index f71c92fb7..b71e907f5 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
@@ -19,7 +19,6 @@
 
 from __future__ import annotations
 
-import math
 import re
 from collections.abc import Callable
 from dataclasses import dataclass, field
@@ -103,7 +102,8 @@
 
 # Native Guppy parameterized rotation gates: `fn(qubit..., angle)`.
 # Guppy's `angle` type stores half-turns (pi radians = 1.0 half-turn),
-# so a radians value theta is emitted as `angle(theta / pi)`.
+# which is exactly `angle64.to_half_turns_signed()`, so the angle is
+# emitted as `angle(<half_turns>)` with no radians/pi conversion.
 PARAMETERIZED_FUNCTIONAL_GATES: dict[GateKind, str] = {
     GateKind.RX: "rx",
     GateKind.RY: "ry",
@@ -119,8 +119,9 @@
 # Each step is (guppy_fn, qubit_idx_tuple_into_targets, angle_spec) in
 # CIRCUIT order (first applied first). angle_spec is:
 #   None                          -> non-parameterized gate: fn(q...)
-#   float (radians)               -> constant angle: fn(q..., angle(r/pi))
-#   Callable[[input_params], float] -> angle from the input gate's params
+#   float (half-turns)            -> constant angle: fn(q..., angle(h))
+#   Callable[[input_params], float] -> angle (half-turns) from the input
+#                                      gate's params (also half-turns)
 # The 1q-Clifford sequences mirror the dual-reviewed QIR `_GATE_DECOMP`;
 # the 2q sqrt-Paulis use the native `zz_phase` (= RZZ, qsystem Quantinuum
 # extension); CRX/CRY conjugate the native `crz`.
@@ -135,19 +136,19 @@
     GateKind.F4: (("h", (0,), None), ("sdg", (0,), None)),
     GateKind.F4dg: (("s", (0,), None), ("h", (0,), None)),
     # ---- two-qubit sqrt-Paulis via native zz_phase (= RZZ) ----
-    GateKind.SZZ: (("zz_phase", (0, 1), math.pi / 2),),
-    GateKind.SZZdg: (("zz_phase", (0, 1), -math.pi / 2),),
+    GateKind.SZZ: (("zz_phase", (0, 1), 0.5),),
+    GateKind.SZZdg: (("zz_phase", (0, 1), -0.5),),
     GateKind.SXX: (
         ("h", (0,), None),
         ("h", (1,), None),
-        ("zz_phase", (0, 1), math.pi / 2),
+        ("zz_phase", (0, 1), 0.5),
         ("h", (0,), None),
         ("h", (1,), None),
     ),
     GateKind.SXXdg: (
         ("h", (0,), None),
         ("h", (1,), None),
-        ("zz_phase", (0, 1), -math.pi / 2),
+        ("zz_phase", (0, 1), -0.5),
         ("h", (0,), None),
         ("h", (1,), None),
     ),
@@ -156,7 +157,7 @@
         ("sdg", (1,), None),
         ("h", (0,), None),
         ("h", (1,), None),
-        ("zz_phase", (0, 1), math.pi / 2),
+        ("zz_phase", (0, 1), 0.5),
         ("h", (0,), None),
         ("h", (1,), None),
         ("s", (0,), None),
@@ -167,7 +168,7 @@
         ("sdg", (1,), None),
         ("h", (0,), None),
         ("h", (1,), None),
-        ("zz_phase", (0, 1), -math.pi / 2),
+        ("zz_phase", (0, 1), -0.5),
         ("h", (0,), None),
         ("h", (1,), None),
         ("s", (0,), None),
@@ -197,6 +198,26 @@
     gk for gk, steps in GUPPY_GATE_DECOMP.items() if any(fn == "zz_phase" for fn, _, _ in steps)
 )
 
+
+def _param_to_half_turns(param: object, gate_name: str) -> float:
+    """Resolve a user gate angle param to signed half-turns for Guppy `angle`.
+
+    Guppy's `angle` is half-turn based (pi rad = 1.0), which is exactly
+    ``angle64.to_half_turns_signed()``. Requires a typed `Angle`
+    (`rad(...)` / `turns(...)`) -- a non-`Angle` param (bare float, or a
+    non-literal classical expression at a gate-param position) fails loud.
+    """
+    from pecos.slr.angle import Angle  # noqa: PLC0415  (avoid import cycle)
+
+    if not isinstance(param, LiteralExpr) or not isinstance(param.value, Angle):
+        msg = (
+            f"AST -> Guppy v1: parameterized gate {gate_name} requires a typed `Angle` "
+            f"parameter (use `rad(...)` / `turns(...)`); got {param!r}"
+        )
+        raise GuppyCodegenError(msg)
+    return param.value.value.to_half_turns_signed()
+
+
 BINARY_OP_TO_PYTHON: dict[BinaryOp, str] = {
     BinaryOp.ADD: "+",
     BinaryOp.SUB: "-",
@@ -1142,27 +1163,20 @@ def _emit_gate(self, node: GateOp) -> list[str]:
         raise GuppyCodegenError(msg)
 
     def _emit_parameterized_gate(self, node: GateOp) -> list[str]:
-        """Emit a native Guppy rotation: `fn(qubit..., angle(theta/pi))`.
+        """Emit a native Guppy rotation: `fn(qubit..., angle(half_turns))`.
 
         Guppy's `angle` stores half-turns (pi rad == 1.0 half-turn), so
-        a radians value `theta` becomes `angle(theta / pi)`. Only
-        literal angles are supported (a non-literal classical
-        expression at a gate-param position fails loud, mirroring the
-        QIR backend's parameterized-decomposition guard).
+        the typed `Angle` param is emitted via
+        ``angle64.to_half_turns_signed()`` -- no radians/pi conversion.
+        Only typed `Angle` params are supported (a bare float or a
+        non-literal classical expression at a gate-param position fails
+        loud, mirroring the QIR backend's parameterized guard).
         """
         gate = PARAMETERIZED_FUNCTIONAL_GATES[node.gate]
         if not node.params:
             msg = f"AST -> Guppy v1: parameterized gate {node.gate.name} requires an angle parameter"
             raise GuppyCodegenError(msg)
-        angle_args = []
-        for param in node.params:
-            if not isinstance(param, LiteralExpr) or not isinstance(param.value, (int, float)):
-                msg = (
-                    f"AST -> Guppy v1: parameterized gate {node.gate.name} requires literal "
-                    f"angle parameters; got non-literal {param!r}"
-                )
-                raise GuppyCodegenError(msg)
-            angle_args.append(f"angle({float(param.value) / math.pi})")
+        angle_args = [f"angle({_param_to_half_turns(param, node.gate.name)})" for param in node.params]
         angle_str = ", ".join(angle_args)
 
         slots = [self._slot_from_ref(target) for target in node.targets]
@@ -1216,16 +1230,9 @@ def _emit_decomposed_gate(self, node: GateOp) -> list[str]:
                 # when a callable spec indexes `p[0]`.
                 msg = f"AST -> Guppy v1: parameterized gate {node.gate.name} requires an angle parameter"
                 raise GuppyCodegenError(msg)
-            resolved: list[float] = []
-            for param in params:
-                if not isinstance(param, LiteralExpr) or not isinstance(param.value, (int, float)):
-                    msg = (
-                        f"AST -> Guppy v1: parameterized decomposition of {node.gate.name} "
-                        f"requires literal angle parameters; got non-literal {param!r}"
-                    )
-                    raise GuppyCodegenError(msg)
-                resolved.append(float(param.value))
-            resolved_params = tuple(resolved)
+            # User params resolve to half-turns; the forwarding lambdas
+            # (`p[0]`) then carry half-turns, matching the constant specs.
+            resolved_params = tuple(_param_to_half_turns(param, node.gate.name) for param in params)
 
         linearity = self._linearity()
         lines: list[str] = []
@@ -1236,7 +1243,7 @@ def _emit_decomposed_gate(self, node: GateOp) -> list[str]:
                 angle_arg = ""
             else:
                 theta = angle_spec(resolved_params) if callable(angle_spec) else angle_spec
-                angle_arg = f", angle({float(theta) / math.pi})"
+                angle_arg = f", angle({float(theta)})"
             if len(idxs) == 1:
                 local = locals_[0]
                 lines.append(f"{self.context.indent()}{local} = {fn}({local}{angle_arg})")
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qasm.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qasm.py
index 1050a4a9e..f79d93a9c 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qasm.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qasm.py
@@ -334,6 +334,20 @@ def visit_gate(self, node: GateOp) -> list[str]:
             )
             raise NotImplementedError(msg)
 
+        # Typed-angle guard: a user/direct-AST parameterized gate's params
+        # must be typed `Angle` literals (matches Guppy + the typed-AST
+        # contract); reject bare floats so backends do not diverge.
+        if node.gate.is_parameterized:
+            from pecos.slr.angle import Angle  # noqa: PLC0415  (avoid import cycle)
+
+            for p in node.params:
+                if not (isinstance(p, LiteralExpr) and isinstance(p.value, Angle)):
+                    msg = (
+                        f"QASM codegen: parameterized gate {node.gate.name!r} requires typed `Angle` "
+                        f"params (use `rad(...)` / `turns(...)` in SLR); got {p!r}."
+                    )
+                    raise NotImplementedError(msg)
+
         # Handle special face rotation gates
         if node.gate == GateKind.F:
             for target in node.targets:
@@ -810,6 +824,11 @@ def _render_expression(self, expr: Expression) -> str:
 
     def _render_literal(self, node: LiteralExpr) -> str:
         """Render a literal value."""
+        from pecos.slr.angle import Angle  # noqa: PLC0415  (avoid import cycle)
+
+        if isinstance(node.value, Angle):
+            # OpenQASM rotations are in radians; signed principal value.
+            return str(node.value.value.to_radians_signed())
         return str(node.value)
 
     def _render_binary(self, node: BinaryExpr) -> str:
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
index ea0da2611..8217c6dce 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
@@ -243,6 +243,46 @@
 TWO_QUBIT_GATES = {GateKind.CX, GateKind.CZ, GateKind.RZZ}
 
 
+def _param_to_radians(p: object) -> float:
+    """Resolve a gate angle param to a signed-radians float.
+
+    Accepts a `LiteralExpr` wrapping either a typed `Angle` or a bare
+    number, or a raw number (decomposition steps thread raw floats).
+    Typed angles use the signed principal value so the float-based
+    decomposition arithmetic (`-theta/2`) avoids the global-phase flip
+    that the unsigned `[0, 2pi)` form would introduce at the wrap point.
+    """
+    from pecos.slr.angle import Angle  # noqa: PLC0415  (avoid import cycle)
+
+    value = p.value if isinstance(p, LiteralExpr) else p
+    if isinstance(value, Angle):
+        return value.value.to_radians_signed()
+    return float(value)
+
+
+def _require_typed_angle_params(node: GateOp, backend: str) -> None:
+    """Fail loud if a parameterized user gate has a non-`Angle` param.
+
+    Enforces the typed-AST-dialect contract uniformly across backends: a
+    parameterized `GateOp` reaching codegen from the user / direct-AST path
+    must carry typed `Angle` literals (`rad(...)` / `turns(...)`), not bare
+    floats. (Internal decomposition steps thread raw floats but reach the
+    per-gate emitters directly, not this top-level entry.)
+    """
+    from pecos.slr.angle import Angle  # noqa: PLC0415  (avoid import cycle)
+
+    if not node.gate.is_parameterized:
+        return
+    for p in node.params:
+        if not (isinstance(p, LiteralExpr) and isinstance(p.value, Angle)):
+            gate_name = getattr(node.gate, "name", node.gate)
+            msg = (
+                f"{backend} codegen: parameterized gate {gate_name!r} requires typed `Angle` "
+                f"params (use `rad(...)` / `turns(...)` in SLR); got {p!r}."
+            )
+            raise NotImplementedError(msg)
+
+
 @dataclass
 class QirCodeGenContext:
     """Context for QIR code generation."""
@@ -616,6 +656,12 @@ def _process_gate(self, node: GateOp) -> None:
             )
             raise NotImplementedError(msg)
 
+        # Typed-angle guard: a user/direct-AST parameterized gate's params
+        # must be typed `Angle` literals (matches the Guppy backend and the
+        # typed-AST-dialect contract). Internal decomposition steps thread
+        # raw floats but reach `_process_*_gate` directly, bypassing here.
+        _require_typed_angle_params(node, "QIR")
+
         qir_name = GATE_TO_QIR.get(node.gate)
         if qir_name is None and node.gate in _GATE_DECOMP:
             # #93: a gate with no direct QIR primitive but a verified
@@ -635,9 +681,7 @@ def _process_gate(self, node: GateOp) -> None:
                 prim_targets = tuple(node.targets[i] for i in idxs)
                 if callable(params_spec):
                     try:
-                        input_params_resolved = tuple(
-                            p.value if isinstance(p, LiteralExpr) else float(p) for p in input_params_raw
-                        )
+                        input_params_resolved = tuple(_param_to_radians(p) for p in input_params_raw)
                     except (AttributeError, TypeError) as exc:
                         msg = (
                             f"Parameterized decomposition of gate {node.gate.name} requires literal "
@@ -689,17 +733,10 @@ def _process_single_qubit_gate(self, node: GateOp, qir_name: str) -> None:
 
             args = []
             if node.gate in PARAMETERIZED_GATES and node.params:
-                # An angle param (e.g. `RX(0.5, q)`) reaches here as a
-                # `LiteralExpr`, not a raw number -- resolve it before
-                # `float()` (was a hard `TypeError` for parallel/
-                # control-flow rotations).
-                args.extend(
-                    llvm_ir.Constant(
-                        self._types["double"],
-                        float(p.value if isinstance(p, LiteralExpr) else p),
-                    )
-                    for p in node.params
-                )
+                # An angle param reaches here as a `LiteralExpr` wrapping a
+                # typed `Angle` (or a raw float from a decomposition step);
+                # resolve to signed radians for the QIR `double`.
+                args.extend(llvm_ir.Constant(self._types["double"], _param_to_radians(p)) for p in node.params)
             args.append(qubit_ptr)
 
             self._builder.call(gate_func, args, name="")
@@ -718,17 +755,10 @@ def _process_two_qubit_gate(self, node: GateOp, qir_name: str) -> None:
 
             args = []
             if node.gate in PARAMETERIZED_GATES and node.params:
-                # An angle param (e.g. `RX(0.5, q)`) reaches here as a
-                # `LiteralExpr`, not a raw number -- resolve it before
-                # `float()` (was a hard `TypeError` for parallel/
-                # control-flow rotations).
-                args.extend(
-                    llvm_ir.Constant(
-                        self._types["double"],
-                        float(p.value if isinstance(p, LiteralExpr) else p),
-                    )
-                    for p in node.params
-                )
+                # An angle param reaches here as a `LiteralExpr` wrapping a
+                # typed `Angle` (or a raw float from a decomposition step);
+                # resolve to signed radians for the QIR `double`.
+                args.extend(llvm_ir.Constant(self._types["double"], _param_to_radians(p)) for p in node.params)
             args.extend([q0_ptr, q1_ptr])
 
             self._builder.call(gate_func, args, name="")
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py
index 008efa449..b661ae353 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py
@@ -363,14 +363,19 @@ def _process_parameterized_gate(self, node: GateOp, gate_name: str) -> None:
         BinaryExpr at gate-param position) are not yet supported for
         QC parameterized gates; they fail loud here.
         """
-        try:
-            angles = [float(p.value if isinstance(p, LiteralExpr) else p) for p in node.params]
-        except (AttributeError, TypeError) as exc:
-            msg = (
-                f"QuantumCircuit codegen: parameterized gate {gate_name!r} "
-                f"requires literal-float params; got non-literal: {node.params}."
-            )
-            raise NotImplementedError(msg) from exc
+        from pecos.slr.angle import Angle  # noqa: PLC0415  (avoid import cycle)
+
+        # Typed-angle guard: a user/direct-AST parameterized gate's params
+        # must be typed `Angle` literals (matches Guppy + the typed-AST
+        # contract); reject bare floats so backends do not diverge.
+        for p in node.params:
+            if not (isinstance(p, LiteralExpr) and isinstance(p.value, Angle)):
+                msg = (
+                    f"QuantumCircuit codegen: parameterized gate {gate_name!r} requires typed `Angle` "
+                    f"params (use `rad(...)` / `turns(...)` in SLR); got {p!r}."
+                )
+                raise NotImplementedError(msg)
+        angles = [p.value.value.to_radians_signed() for p in node.params]
 
         self._flush_tick()
         if node.gate in TWO_QUBIT_GATES:
diff --git a/python/quantum-pecos/src/pecos/slr/ast/compare.py b/python/quantum-pecos/src/pecos/slr/ast/compare.py
index 8e87c9146..b8d37e309 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/compare.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/compare.py
@@ -143,6 +143,17 @@ def _compare_nodes(self, a: Any, b: Any) -> bool:
                 return False
             return True
 
+        # Typed angle: a leaf compared by exact value (angle64 fraction +
+        # source unit). Recursing into its angle64 field would fail since
+        # angle64 is not an AST node / primitive handled below.
+        from pecos.slr.angle import Angle  # noqa: PLC0415  (avoid import cycle)
+
+        if isinstance(a, Angle):
+            if a != b:
+                self._add_diff(f"angle mismatch: {a!r} vs {b!r}")
+                return False
+            return True
+
         # Handle enums
         if hasattr(a, "name") and hasattr(a, "value") and not is_dataclass(a):
             if a != b:
diff --git a/python/quantum-pecos/src/pecos/slr/ast/converter.py b/python/quantum-pecos/src/pecos/slr/ast/converter.py
index cac2b24cb..2e150bd03 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/converter.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/converter.py
@@ -993,6 +993,16 @@ def _convert_expression(self, expr: Any) -> Expression:
         if expr is None:
             return LiteralExpr(value=0)
 
+        # Typed angle (rotation-gate parameter). Stored verbatim in the
+        # literal so pretty-print can round-trip the source unit and each
+        # backend can unwrap to the underlying `angle64`. Must come before
+        # the generic `hasattr(expr, "value")` fallback, which would strip
+        # the wrapper down to the bare `angle64` and lose the unit.
+        from pecos.slr.angle import Angle  # noqa: PLC0415  (avoid import cycle)
+
+        if isinstance(expr, Angle):
+            return LiteralExpr(value=expr)
+
         # Literal values
         if isinstance(expr, bool | int | float):
             return LiteralExpr(value=expr)
diff --git a/python/quantum-pecos/src/pecos/slr/ast/nodes.py b/python/quantum-pecos/src/pecos/slr/ast/nodes.py
index dcffe5890..b739ca59b 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/nodes.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/nodes.py
@@ -31,6 +31,8 @@
 if TYPE_CHECKING:
     from collections.abc import Sequence
 
+    from pecos.slr.angle import Angle
+
 
 # =============================================================================
 # Source Location
@@ -266,9 +268,9 @@ class Expression(AstNode):
 
 @dataclass(frozen=True, kw_only=True)
 class LiteralExpr(Expression):
-    """Literal value (int, float, bool)."""
+    """Literal value (int, float, bool, or a typed rotation `Angle`)."""
 
-    value: int | float | bool
+    value: int | float | bool | Angle
 
 
 @dataclass(frozen=True, kw_only=True)
diff --git a/python/quantum-pecos/src/pecos/slr/ast/optimizations/identity_removal.py b/python/quantum-pecos/src/pecos/slr/ast/optimizations/identity_removal.py
index 7c4ac3a2b..6b734915d 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/optimizations/identity_removal.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/optimizations/identity_removal.py
@@ -152,7 +152,15 @@ def _is_identity(self, gate: GateOp) -> bool:
             # Can't evaluate symbolic angles at compile time
             return False
 
+        from pecos.slr.angle import Angle  # noqa: PLC0415  (avoid import cycle)
+
         value = angle.value
+        if isinstance(value, Angle):
+            # Use the signed-radians principal value with the same tolerance
+            # as the float path: fixed-point addition (e.g. rad(0.5) +
+            # rad(-0.5) from merging) leaves a sub-ULP residual, so an exact
+            # `fraction == 0` check would miss near-identity rotations.
+            return abs(value.value.to_radians_signed()) < self.IDENTITY_ANGLE_TOLERANCE
         if not isinstance(value, (int, float)):
             return False
 
diff --git a/python/quantum-pecos/src/pecos/slr/ast/optimizations/rotation_merging.py b/python/quantum-pecos/src/pecos/slr/ast/optimizations/rotation_merging.py
index d38235a5d..c3ed4ad16 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/optimizations/rotation_merging.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/optimizations/rotation_merging.py
@@ -57,10 +57,10 @@ class RotationMergingPass(OptimizationPass):
 
     Example:
         # Before optimization
-        RX(0.5, q[0]), RX(0.3, q[0])
+        RX(rad(0.5), q[0]), RX(rad(0.3), q[0])
 
         # After optimization
-        RX(0.8, q[0])
+        RX(rad(0.8), q[0])
     """
 
     @property
@@ -177,12 +177,23 @@ def _merge_rotations(self, gate1: GateOp, gate2: GateOp) -> GateOp:
         If both angles are literals, computes the sum at compile time.
         Otherwise, creates a symbolic BinaryExpr for the sum.
         """
+        from pecos.slr.angle import Angle  # noqa: PLC0415  (avoid import cycle)
+
         angle1 = gate1.params[0]
         angle2 = gate2.params[0]
 
         # Try to evaluate at compile time if both are literals
         if isinstance(angle1, LiteralExpr) and isinstance(angle2, LiteralExpr):
-            merged_angle = LiteralExpr(value=angle1.value + angle2.value)
+            v1, v2 = angle1.value, angle2.value
+            if isinstance(v1, Angle) and isinstance(v2, Angle):
+                # Sum in exact fixed-point (angle64 wraps mod a full turn,
+                # which is the correct rotation-composition semantics).
+                merged_angle = LiteralExpr(value=Angle(v1.value + v2.value, v1.source_unit))
+            elif not isinstance(v1, Angle) and not isinstance(v2, Angle):
+                merged_angle = LiteralExpr(value=v1 + v2)
+            else:
+                # Mixed Angle/number (unexpected from SLR) -- keep symbolic.
+                merged_angle = BinaryExpr(op=BinaryOp.ADD, left=angle1, right=angle2)
         else:
             # Create symbolic sum
             merged_angle = BinaryExpr(
diff --git a/python/quantum-pecos/src/pecos/slr/ast/pretty_print.py b/python/quantum-pecos/src/pecos/slr/ast/pretty_print.py
index 3deda4311..67238158e 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/pretty_print.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/pretty_print.py
@@ -424,6 +424,11 @@ def format_expression(self, expr: Expression) -> str:
 
     def visit_literal(self, node: LiteralExpr) -> str:
         """Visit literal expression."""
+        from pecos.slr.angle import Angle  # noqa: PLC0415  (avoid import cycle)
+
+        if isinstance(node.value, Angle):
+            # Round-trip the source unit: `rad(0.5)` / `turns(0.25)`.
+            return node.value.slr_repr()
         if isinstance(node.value, bool):
             return "True" if node.value else "False"
         if isinstance(node.value, float):
diff --git a/python/quantum-pecos/src/pecos/slr/ast/serialize.py b/python/quantum-pecos/src/pecos/slr/ast/serialize.py
index 6244f9f72..1adddab0f 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/serialize.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/serialize.py
@@ -32,6 +32,9 @@
 from dataclasses import fields, is_dataclass
 from typing import TYPE_CHECKING, Any
 
+from pecos_rslib import angle64
+
+from pecos.slr.angle import Angle
 from pecos.slr.ast.nodes import (
     AllocatorArg,
     AllocatorDecl,
@@ -161,6 +164,12 @@ def _serialize_value(value: Any) -> Any:
         return value
     if isinstance(value, (GateKind, BinaryOp, UnaryOp, ResourceEffect)):
         return {"_enum": type(value).__name__, "value": value.name}
+    if isinstance(value, Angle):
+        # Encode by the exact fixed-point fraction + source unit so the
+        # angle64 value round-trips losslessly and pretty-print keeps the
+        # unit label. (Must precede the generic dataclass branch below --
+        # Angle is a dataclass but its `angle64` field is not serializable.)
+        return {"_angle": {"fraction": value.value.fraction, "unit": value.source_unit}}
     if isinstance(value, tuple):
         return [_serialize_value(v) for v in value]
     if isinstance(value, list):
@@ -236,6 +245,10 @@ def _deserialize_value(value: Any, field_name: str, field_info: dict) -> Any:
                 msg = f"Unknown enum type: {value['_enum']}"
                 raise ValueError(msg)
             return enum_class[value["value"]]
+        if "_angle" in value:
+            # Typed rotation angle: rebuild from the fixed-point fraction.
+            a = value["_angle"]
+            return Angle(angle64(a["fraction"]), a["unit"])
         if "_type" in value:
             # Nested AST node
             return dict_to_ast(value)
diff --git a/python/quantum-pecos/src/pecos/slr/ast/validation/type_checker.py b/python/quantum-pecos/src/pecos/slr/ast/validation/type_checker.py
index 9d125d056..e1f86bdf3 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/validation/type_checker.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/validation/type_checker.py
@@ -209,12 +209,14 @@ def _validate_gate(self, node: GateOp) -> None:
                 )
 
     def _validate_numeric_expression(self, expr: Expression, context: str) -> None:
-        """Validate that an expression is numeric."""
+        """Validate that an expression is numeric (or a typed angle)."""
+        from pecos.slr.angle import Angle  # noqa: PLC0415  (avoid import cycle)
+
         if isinstance(expr, LiteralExpr):
-            if not isinstance(expr.value, int | float):
+            if not isinstance(expr.value, int | float | Angle):
                 self.errors.append(
                     ValidationError(
-                        message=f"Expected numeric value for {context}, got {type(expr.value).__name__}",
+                        message=f"Expected numeric value or Angle for {context}, got {type(expr.value).__name__}",
                         location=expr.location,
                         severity=Severity.ERROR,
                         code="E203",
diff --git a/python/quantum-pecos/src/pecos/slr/gen_codes/gen_qasm.py b/python/quantum-pecos/src/pecos/slr/gen_codes/gen_qasm.py
index 147ae5f18..a04ba6ee2 100644
--- a/python/quantum-pecos/src/pecos/slr/gen_codes/gen_qasm.py
+++ b/python/quantum-pecos/src/pecos/slr/gen_codes/gen_qasm.py
@@ -17,6 +17,15 @@
 from pecos.slr.gen_codes.generator import Generator
 
 
+def _param_qasm(p: object) -> str:
+    """Render a gate param for QASM: a typed `Angle` -> signed radians."""
+    from pecos.slr.angle import Angle
+
+    if isinstance(p, Angle):
+        return str(p.value.to_radians_signed())
+    return str(p)
+
+
 class QASMGenerator(Generator):
     """Generate QASM code from SLR programs.
 
@@ -686,7 +695,7 @@ def qgate_sq_qasm(self, op, repr_str: str | None = None):
             repr_str = op.sym.lower()
 
         if op.params:
-            str_cargs = ", ".join([str(p) for p in op.params])
+            str_cargs = ", ".join([_param_qasm(p) for p in op.params])
             repr_str = f"{repr_str}({str_cargs})"
 
         str_list = []
@@ -721,7 +730,7 @@ def qgate_tq_qasm(self, op, repr_str: str | None = None):
             repr_str = op.sym.lower()
 
         if op.params:
-            str_cargs = ",".join([str(p) for p in op.params])
+            str_cargs = ",".join([_param_qasm(p) for p in op.params])
             repr_str = f"{repr_str}({str_cargs})"
 
         str_list = []
diff --git a/python/quantum-pecos/src/pecos/slr/gen_codes/gen_qir.py b/python/quantum-pecos/src/pecos/slr/gen_codes/gen_qir.py
index 83be6d714..2f0408502 100644
--- a/python/quantum-pecos/src/pecos/slr/gen_codes/gen_qir.py
+++ b/python/quantum-pecos/src/pecos/slr/gen_codes/gen_qir.py
@@ -18,7 +18,7 @@
 
 from pecos_rslib_llvm import binding, ir
 
-from pecos.slr import Block, If, Repeat
+from pecos.slr import Angle, Block, If, Repeat
 from pecos.slr.cops import (
     NEG,
     NOT,
@@ -806,7 +806,13 @@ def _create_qgate_call(self, gate: qgate_base.QGate) -> None:
         gate_declaration = self._gate_declaration_cache[gate.sym]
         gate_args = []
         if gate.has_parameters:
-            gate_args = [ir.Constant(self._types.double_type, param) for param in gate.params]
+            gate_args = [
+                ir.Constant(
+                    self._types.double_type,
+                    param.value.to_radians_signed() if isinstance(param, Angle) else float(param),
+                )
+                for param in gate.params
+            ]
         gate_args.extend([self._qarg_to_qubit_ptr(qarg) for qarg in qargs])
 
         # Create the actual invocation on the builder using the args passed in
diff --git a/python/quantum-pecos/src/pecos/slr/gen_codes/qir_gate_mapping.py b/python/quantum-pecos/src/pecos/slr/gen_codes/qir_gate_mapping.py
index d129b4efe..444686b14 100644
--- a/python/quantum-pecos/src/pecos/slr/gen_codes/qir_gate_mapping.py
+++ b/python/quantum-pecos/src/pecos/slr/gen_codes/qir_gate_mapping.py
@@ -15,6 +15,7 @@
 from typing import TYPE_CHECKING
 
 import pecos as pc
+from pecos.slr.angle import rad
 from pecos.slr.qeclib import qubit as q
 
 if TYPE_CHECKING:
@@ -68,22 +69,22 @@ def __init__(self, gate: QG):
 
     SX = QG.decompose(
         lambda sx: [
-            q.RX(pc.f64.frac_pi_2, sx.qargs[0]),
+            q.RX(rad(pc.f64.frac_pi_2), sx.qargs[0]),
         ],
     )
     SXdg = QG.decompose(
         lambda sxdg: [
-            q.RX(-pc.f64.frac_pi_2, sxdg.qargs[0]),
+            q.RX(rad(-pc.f64.frac_pi_2), sxdg.qargs[0]),
         ],
     )
     SY = QG.decompose(
         lambda sy: [
-            q.RY(pc.f64.frac_pi_2, sy.qargs[0]),
+            q.RY(rad(pc.f64.frac_pi_2), sy.qargs[0]),
         ],
     )
     SYdg = QG.decompose(
         lambda sydg: [
-            q.RY(-pc.f64.frac_pi_2, sydg.qargs[0]),
+            q.RY(rad(-pc.f64.frac_pi_2), sydg.qargs[0]),
         ],
     )
 
@@ -112,7 +113,7 @@ def __init__(self, gate: QG):
         lambda f4dg: [
             q.SXdg(f4dg.qargs[0]),
             # q.SZdg(f4dg.qargs[0]),
-            q.RZ(-pc.f64.frac_pi_2, f4dg.qargs[0]),
+            q.RZ(rad(-pc.f64.frac_pi_2), f4dg.qargs[0]),
         ],
     )
 
diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/qubit/__init__.py b/python/quantum-pecos/src/pecos/slr/qeclib/qubit/__init__.py
index 4e7f62eac..718082481 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/qubit/__init__.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/qubit/__init__.py
@@ -15,6 +15,7 @@
 # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 # specific language governing permissions and limitations under the License.
 
+from pecos.slr.angle import Angle, rad, turns
 from pecos.slr.qeclib.qubit.measures import Measure
 from pecos.slr.qeclib.qubit.preps import PNX, PNY, PNZ, PX, PY, PZ
 from pecos.slr.qeclib.qubit.rots import CRX, CRY, CRZ, RX, RY, RZ, RZZ
@@ -61,6 +62,7 @@
     "SYY",
     "SZ",
     "SZZ",
+    "Angle",
     "F",
     "F4dg",
     "Fdg",
@@ -77,4 +79,6 @@
     "X",
     "Y",
     "Z",
+    "rad",
+    "turns",
 ]
diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/qubit/qgate_base.py b/python/quantum-pecos/src/pecos/slr/qeclib/qubit/qgate_base.py
index b18f42aa2..aedf5969d 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/qubit/qgate_base.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/qubit/qgate_base.py
@@ -139,27 +139,41 @@ def __call__(self, *args: Qubit | complex) -> Self:
                 raise TypeError(msg)
             params = tuple(args[:n])
             qargs = tuple(args[n:])
-            # Angle-first guard: a register/qubit reference in an angle
-            # slot, or a non-qubit (number, classical register/bit, junk)
-            # in a qubit slot, is the classic mis-ordered call
-            # (`RX(q, 0.5)` instead of `RX(0.5, q)`). Pre-#97 this was the
-            # silent-angle-drop footgun; reject it loudly at the call so a
-            # typo can never reach codegen as a no-op or as a rotation on
-            # a classical register. Qubit slots accept ONLY quantum
-            # qubit shapes (`Qubit`/`QReg`/`SymbolicQubit`) -- NOT the
-            # broad `Var` (which also covers classical `CReg`/`Bit`/
-            # `SymbolicBit`). Angle slots reject any `Var` ref (no
-            # register/bit is a valid angle; angles are numbers/exprs).
+            # Typed-angle guard: each angle slot must be a typed `Angle`
+            # (built with `rad(...)` / `turns(...)`), and each qubit slot
+            # must be a quantum qubit shape. This rejects the classic
+            # mis-ordered call (`RX(q, 0.5)` instead of `RX(rad(0.5), q)`)
+            # AND the now-removed bare-float form (`RX(0.5, q)`) loudly at
+            # the call, so a typo can never reach codegen as a no-op or as
+            # a rotation on a classical register. Qubit slots accept ONLY
+            # `Qubit`/`QReg`/`SymbolicQubit` -- NOT the broad `Var` (which
+            # also covers classical `CReg`/`Bit`/`SymbolicBit`).
+            from pecos.slr.angle import Angle  # noqa: PLC0415  (avoid import cycle)
             from pecos.slr.vars import QReg, Qubit, SymbolicQubit, Var  # noqa: PLC0415  (avoid import cycle)
 
             qubit_types = (Qubit, QReg, SymbolicQubit)
             for p in params:
+                if isinstance(p, Angle):
+                    continue
                 if isinstance(p, Var):
                     msg = (
                         f"{self.sym}: a register/qubit reference {p!r} was passed in an angle "
-                        f"position. Call as `{self.sym}(angle, qubit...)` -- angles come before qubit ids."
+                        f"position. Call as `{self.sym}(angle, qubit...)` -- angles come before qubit "
+                        "ids, and the angle must be a typed `Angle` (use `rad(...)` / `turns(...)`)."
                     )
                     raise TypeError(msg)
+                if isinstance(p, (bool, int, float, complex)):
+                    msg = (
+                        f"{self.sym}: bare numeric angle {p!r} is no longer accepted. Wrap it in a "
+                        f"typed `Angle`: `{self.sym}(rad({p}), qubit...)` (radians) or "
+                        f"`{self.sym}(turns(...), qubit...)`."
+                    )
+                    raise TypeError(msg)
+                msg = (
+                    f"{self.sym}: angle parameter {p!r} must be a typed `Angle` "
+                    "built with `rad(...)` / `turns(...)`."
+                )
+                raise TypeError(msg)
             for qa in qargs:
                 if not isinstance(qa, qubit_types):
                     kind = "classical register/bit" if isinstance(qa, Var) else "non-qubit"
@@ -169,6 +183,24 @@ def __call__(self, *args: Qubit | complex) -> Self:
                         "qubit positions accept only qubits/QRegs."
                     )
                     raise TypeError(msg)
+            # Construction-time arity guard: a parameterized call must
+            # supply enough qubits, so a malformed `gate(angle)` (no
+            # qubit) or `RZZ(angle, q[0])` (one short) fails loud here
+            # rather than surviving to QIR/QASM. A whole `QReg` broadcasts
+            # (its size is only known on expansion), so the explicit-qubit
+            # count is only checked when no register is passed.
+            if not qargs:
+                msg = (
+                    f"{self.sym}: a parameterized gate needs at least one qubit; got only angle(s). "
+                    f"Call as `{self.sym}(angle, qubit...)`."
+                )
+                raise TypeError(msg)
+            if not any(isinstance(qa, QReg) for qa in qargs) and len(qargs) < self.qsize:
+                msg = (
+                    f"{self.sym}: needs at least {self.qsize} qubit(s) for a {self.qsize}-qubit gate, "
+                    f"got {len(qargs)}. (Pass a whole QReg to broadcast.)"
+                )
+                raise TypeError(msg)
             g.params = params
             g.add_qargs(qargs)
         else:
diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/steane/preps/plus_h_state.py b/python/quantum-pecos/src/pecos/slr/qeclib/steane/preps/plus_h_state.py
index 5a73fcdc5..18d3aaaa9 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/steane/preps/plus_h_state.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/steane/preps/plus_h_state.py
@@ -17,6 +17,7 @@
 
 import pecos as pc
 from pecos.slr import Bit, Block, Comment, CReg, If, QReg, Repeat
+from pecos.slr.angle import rad
 from pecos.slr.misc import Return
 from pecos.slr.qeclib import qubit
 from pecos.slr.qeclib.generic.check_1flag import Check1Flag
@@ -82,7 +83,7 @@ def __init__(
         # ----------------------------------------
         self.extend(
             qubit.PZ(d[6]),
-            qubit.RY(pc.f64.frac_pi_4, d[6]),
+            qubit.RY(rad(pc.f64.frac_pi_4), d[6]),
             EncodingCircuit(d),
         )
 
diff --git a/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/qubit/test_rots.py b/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/qubit/test_rots.py
index 51b005e47..3495b4959 100644
--- a/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/qubit/test_rots.py
+++ b/python/quantum-pecos/tests/pecos/regression/test_qasm/pecos/qeclib/qubit/test_rots.py
@@ -14,33 +14,33 @@
 from collections.abc import Callable
 
 import pecos as pc
-from pecos.slr import QReg
+from pecos.slr import QReg, rad
 from pecos.slr.qeclib import qubit
 
 
 def test_RX(compare_qasm: Callable[..., None]) -> None:
     """Test RX rotation gate QASM regression."""
     q = QReg("q_test", 1)
-    prog = qubit.RX(pc.f64.pi / 3, q[0])
+    prog = qubit.RX(rad(pc.f64.pi / 3), q[0])
     compare_qasm(prog)
 
 
 def test_RY(compare_qasm: Callable[..., None]) -> None:
     """Test RY rotation gate QASM regression."""
     q = QReg("q_test", 1)
-    prog = qubit.RY(pc.f64.pi / 3, q[0])
+    prog = qubit.RY(rad(pc.f64.pi / 3), q[0])
     compare_qasm(prog)
 
 
 def test_RZ(compare_qasm: Callable[..., None]) -> None:
     """Test RZ rotation gate QASM regression."""
     q = QReg("q_test", 1)
-    prog = qubit.RZ(pc.f64.pi / 3, q[0])
+    prog = qubit.RZ(rad(pc.f64.pi / 3), q[0])
     compare_qasm(prog)
 
 
 def test_RZZ(compare_qasm: Callable[..., None]) -> None:
     """Test RZZ two-qubit rotation gate QASM regression."""
     q = QReg("q_test", 4)
-    prog = qubit.RZZ(pc.f64.pi / 3, q[1], q[3])
+    prog = qubit.RZZ(rad(pc.f64.pi / 3), q[1], q[3])
     compare_qasm(prog)
diff --git a/python/quantum-pecos/tests/pecos/regression/test_qasm/random_cases/test_slr_phys.py b/python/quantum-pecos/tests/pecos/regression/test_qasm/random_cases/test_slr_phys.py
index 261ba3ec5..041b0c5ff 100644
--- a/python/quantum-pecos/tests/pecos/regression/test_qasm/random_cases/test_slr_phys.py
+++ b/python/quantum-pecos/tests/pecos/regression/test_qasm/random_cases/test_slr_phys.py
@@ -1,7 +1,22 @@
 """Test SLR to physical quantum circuit compilation for various cases."""
 
 import pytest
-from pecos.slr import Barrier, Bit, Block, Comment, CReg, If, Main, Permute, QReg, Qubit, Repeat, Return, SlrConverter
+from pecos.slr import (
+    Barrier,
+    Bit,
+    Block,
+    Comment,
+    CReg,
+    If,
+    Main,
+    Permute,
+    QReg,
+    Qubit,
+    Repeat,
+    Return,
+    SlrConverter,
+    rad,
+)
 from pecos.slr.qeclib import qubit as p
 from pecos.slr.qeclib.steane.steane_class import Steane
 
@@ -206,7 +221,7 @@ def test_control_flow_qir() -> None:
             ),
         )
         .Else(
-            p.RX(0.3, q[0]),
+            p.RX(rad(0.3), q[0]),
         ),
         If(m < m_hidden).Then(
             p.H(q[0]),
@@ -216,7 +231,7 @@ def test_control_flow_qir() -> None:
         p.SZdg(q[0]),
         p.CX(q[0], q[1]),
         Barrier(q[1], q[0]),
-        p.RX(0.3, q[0]),
+        p.RX(rad(0.3), q[0]),
         p.Measure(q) > m,
         Return(m),
     )
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/optimizations/test_identity_removal.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/optimizations/test_identity_removal.py
index 08ae6495f..a287c4907 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/optimizations/test_identity_removal.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/optimizations/test_identity_removal.py
@@ -13,7 +13,7 @@
 
 import math
 
-from pecos.slr import CReg, If, Main, QReg, Repeat
+from pecos.slr import CReg, If, Main, QReg, Repeat, rad
 from pecos.slr.ast import slr_to_ast
 from pecos.slr.ast.optimizations import IdentityRemovalPass
 from pecos.slr.qeclib import qubit as qb
@@ -26,7 +26,7 @@ def test_rz_zero_removed(self) -> None:
         """RZ(0) is removed."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ(0, q[0]),
+            qb.RZ(rad(0), q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -39,7 +39,7 @@ def test_rx_zero_removed(self) -> None:
         """RX(0) is removed."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RX(0, q[0]),
+            qb.RX(rad(0), q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -52,7 +52,7 @@ def test_ry_zero_removed(self) -> None:
         """RY(0) is removed."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RY(0, q[0]),
+            qb.RY(rad(0), q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -65,7 +65,7 @@ def test_rz_2pi_removed(self) -> None:
         """RZ(2*pi) is removed."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ(2 * math.pi, q[0]),
+            qb.RZ(rad(2 * math.pi), q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -78,7 +78,7 @@ def test_rz_4pi_removed(self) -> None:
         """RZ(4*pi) is removed (multiple of 2*pi)."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ(4 * math.pi, q[0]),
+            qb.RZ(rad(4 * math.pi), q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -95,7 +95,7 @@ def test_rz_nonzero_not_removed(self) -> None:
         """RZ(0.5) is not removed."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ(0.5, q[0]),
+            qb.RZ(rad(0.5), q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -108,7 +108,7 @@ def test_rz_pi_not_removed(self) -> None:
         """RZ(pi) is not removed."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ(math.pi, q[0]),
+            qb.RZ(rad(math.pi), q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -141,7 +141,7 @@ def test_removal_inside_if(self) -> None:
             q := QReg("q", 1),
             c := CReg("c", 1),
             If(c[0] == 1).Then(
-                qb.RZ(0, q[0]),
+                qb.RZ(rad(0), q[0]),
                 qb.H(q[0]),
             ),
         )
@@ -157,7 +157,7 @@ def test_removal_inside_repeat(self) -> None:
         prog = Main(
             q := QReg("q", 1),
             Repeat(cond=3).block(
-                qb.RX(0, q[0]),
+                qb.RX(rad(0), q[0]),
             ),
         )
 
@@ -175,10 +175,10 @@ def test_multiple_identity_gates(self) -> None:
         """Multiple identity gates are removed."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ(0, q[0]),
+            qb.RZ(rad(0), q[0]),
             qb.H(q[0]),
-            qb.RX(0, q[0]),
-            qb.RY(2 * math.pi, q[0]),
+            qb.RX(rad(0), q[0]),
+            qb.RY(rad(2 * math.pi), q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -191,10 +191,10 @@ def test_mixed_with_nonidentity(self) -> None:
         """Identity gates removed among non-identity gates."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ(0, q[0]),  # Removed
-            qb.RZ(0.5, q[0]),  # Kept
-            qb.RX(0, q[0]),  # Removed
-            qb.RX(0.5, q[0]),  # Kept
+            qb.RZ(rad(0), q[0]),  # Removed
+            qb.RZ(rad(0.5), q[0]),  # Kept
+            qb.RX(rad(0), q[0]),  # Removed
+            qb.RX(rad(0.5), q[0]),  # Kept
         )
 
         ast = slr_to_ast(prog)
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/optimizations/test_pipeline.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/optimizations/test_pipeline.py
index 0a2502b97..ab34609bc 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/optimizations/test_pipeline.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/optimizations/test_pipeline.py
@@ -13,7 +13,7 @@
 
 import math
 
-from pecos.slr import Main, QReg
+from pecos.slr import Main, QReg, rad
 from pecos.slr.ast import slr_to_ast
 from pecos.slr.ast.nodes import GateKind, GateOp, LiteralExpr
 from pecos.slr.ast.optimizations import (
@@ -78,8 +78,8 @@ def test_level_2_rotation_merging(self) -> None:
         """Level 2 adds rotation merging."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ(0.5, q[0]),
-            qb.RZ(0.3, q[0]),
+            qb.RZ(rad(0.5), q[0]),
+            qb.RZ(rad(0.3), q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -92,7 +92,7 @@ def test_level_3_identity_removal(self) -> None:
         """Level 3 adds identity removal."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ(0, q[0]),
+            qb.RZ(rad(0), q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -137,8 +137,8 @@ def test_pipeline_fixed_point(self) -> None:
 
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ(0.5, q[0]),
-            qb.RZ(-0.5, q[0]),
+            qb.RZ(rad(0.5), q[0]),
+            qb.RZ(rad(-0.5), q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -206,13 +206,13 @@ def test_default_pipeline_all_optimizations(self) -> None:
         # Circuit with multiple optimization opportunities
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ(0, q[0]),  # Identity removal
+            qb.RZ(rad(0), q[0]),  # Identity removal
             qb.X(q[0]),  # Gate cancellation
             qb.X(q[0]),
             qb.SZ(q[0]),  # Inverse cancellation
             qb.SZdg(q[0]),
-            qb.RZ(0.5, q[0]),  # Rotation merging
-            qb.RZ(0.3, q[0]),
+            qb.RZ(rad(0.5), q[0]),  # Rotation merging
+            qb.RZ(rad(0.3), q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -224,7 +224,7 @@ def test_default_pipeline_all_optimizations(self) -> None:
         assert isinstance(gate, GateOp)
         assert gate.gate == GateKind.RZ
         assert isinstance(gate.params[0], LiteralExpr)
-        assert abs(gate.params[0].value - 0.8) < 1e-10
+        assert abs(gate.params[0].value.value.to_radians_signed() - 0.8) < 1e-10
 
 
 class TestPipelinePassTracking:
@@ -257,8 +257,8 @@ def test_total_optimizations(self) -> None:
             q := QReg("q", 1),
             qb.X(q[0]),
             qb.X(q[0]),
-            qb.RZ(0.5, q[0]),
-            qb.RZ(0.3, q[0]),
+            qb.RZ(rad(0.5), q[0]),
+            qb.RZ(rad(0.3), q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -305,8 +305,8 @@ def test_rotation_to_identity_chain(self) -> None:
         """Chain of rotations that sum to identity."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ(math.pi, q[0]),
-            qb.RZ(math.pi, q[0]),  # Sum is 2*pi = identity
+            qb.RZ(rad(math.pi), q[0]),
+            qb.RZ(rad(math.pi), q[0]),  # Sum is 2*pi = identity
         )
 
         ast = slr_to_ast(prog)
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/optimizations/test_rotation_merging.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/optimizations/test_rotation_merging.py
index 99d0118b9..57bc855c0 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/optimizations/test_rotation_merging.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/optimizations/test_rotation_merging.py
@@ -13,7 +13,7 @@
 
 import math
 
-from pecos.slr import CReg, If, Main, QReg, Repeat
+from pecos.slr import CReg, If, Main, QReg, Repeat, rad
 from pecos.slr.ast import slr_to_ast
 from pecos.slr.ast.nodes import GateKind, GateOp, LiteralExpr
 from pecos.slr.ast.optimizations import RotationMergingPass
@@ -27,8 +27,8 @@ def test_rz_rz_merges(self) -> None:
         """RZ+RZ on same qubit merges."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ(0.5, q[0]),
-            qb.RZ(0.3, q[0]),
+            qb.RZ(rad(0.5), q[0]),
+            qb.RZ(rad(0.3), q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -43,14 +43,14 @@ def test_rz_rz_merges(self) -> None:
         assert gate.gate == GateKind.RZ
         assert len(gate.params) == 1
         assert isinstance(gate.params[0], LiteralExpr)
-        assert abs(gate.params[0].value - 0.8) < 1e-10
+        assert abs(gate.params[0].value.value.to_radians_signed() - 0.8) < 1e-10
 
     def test_rx_rx_merges(self) -> None:
         """RX+RX on same qubit merges."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RX(math.pi / 4, q[0]),
-            qb.RX(math.pi / 4, q[0]),
+            qb.RX(rad(math.pi / 4), q[0]),
+            qb.RX(rad(math.pi / 4), q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -63,14 +63,14 @@ def test_rx_rx_merges(self) -> None:
         assert isinstance(gate, GateOp)
         assert gate.gate == GateKind.RX
         assert isinstance(gate.params[0], LiteralExpr)
-        assert abs(gate.params[0].value - math.pi / 2) < 1e-10
+        assert abs(gate.params[0].value.value.to_radians_signed() - math.pi / 2) < 1e-10
 
     def test_ry_ry_merges(self) -> None:
         """RY+RY on same qubit merges."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RY(0.1, q[0]),
-            qb.RY(0.2, q[0]),
+            qb.RY(rad(0.1), q[0]),
+            qb.RY(rad(0.2), q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -83,7 +83,7 @@ def test_ry_ry_merges(self) -> None:
         assert isinstance(gate, GateOp)
         assert gate.gate == GateKind.RY
         assert isinstance(gate.params[0], LiteralExpr)
-        assert abs(gate.params[0].value - 0.3) < 1e-10
+        assert abs(gate.params[0].value.value.to_radians_signed() - 0.3) < 1e-10
 
 
 class TestRotationMergingNoMerge:
@@ -93,8 +93,8 @@ def test_different_rotation_types_no_merge(self) -> None:
         """Different rotation types do not merge."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RX(0.5, q[0]),
-            qb.RZ(0.3, q[0]),
+            qb.RX(rad(0.5), q[0]),
+            qb.RZ(rad(0.3), q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -107,8 +107,8 @@ def test_different_qubits_no_merge(self) -> None:
         """Rotations on different qubits do not merge."""
         prog = Main(
             q := QReg("q", 2),
-            qb.RZ(0.5, q[0]),
-            qb.RZ(0.3, q[1]),
+            qb.RZ(rad(0.5), q[0]),
+            qb.RZ(rad(0.3), q[1]),
         )
 
         ast = slr_to_ast(prog)
@@ -121,9 +121,9 @@ def test_interleaved_rotations_no_merge(self) -> None:
         """Interleaved rotations do not merge."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ(0.5, q[0]),
+            qb.RZ(rad(0.5), q[0]),
             qb.H(q[0]),  # Separates the RZ gates
-            qb.RZ(0.3, q[0]),
+            qb.RZ(rad(0.3), q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -142,8 +142,8 @@ def test_merge_inside_if(self) -> None:
             q := QReg("q", 1),
             c := CReg("c", 1),
             If(c[0] == 1).Then(
-                qb.RZ(0.5, q[0]),
-                qb.RZ(0.3, q[0]),
+                qb.RZ(rad(0.5), q[0]),
+                qb.RZ(rad(0.3), q[0]),
             ),
         )
 
@@ -158,8 +158,8 @@ def test_merge_inside_repeat(self) -> None:
         prog = Main(
             q := QReg("q", 1),
             Repeat(cond=3).block(
-                qb.RX(0.1, q[0]),
-                qb.RX(0.2, q[0]),
+                qb.RX(rad(0.1), q[0]),
+                qb.RX(rad(0.2), q[0]),
             ),
         )
 
@@ -177,9 +177,9 @@ def test_three_rotations_merge_to_one(self) -> None:
         """Three consecutive rotations merge to one (requires multiple passes)."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ(0.1, q[0]),
-            qb.RZ(0.2, q[0]),
-            qb.RZ(0.3, q[0]),
+            qb.RZ(rad(0.1), q[0]),
+            qb.RZ(rad(0.2), q[0]),
+            qb.RZ(rad(0.3), q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -198,4 +198,4 @@ def test_three_rotations_merge_to_one(self) -> None:
         gate = result2.program.body[0]
         assert isinstance(gate, GateOp)
         assert isinstance(gate.params[0], LiteralExpr)
-        assert abs(gate.params[0].value - 0.6) < 1e-10
+        assert abs(gate.params[0].value.value.to_radians_signed() - 0.6) < 1e-10
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_codegen_equivalence.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_codegen_equivalence.py
index cd04700bb..2af00ddb2 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_codegen_equivalence.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_codegen_equivalence.py
@@ -15,7 +15,7 @@
 """
 
 import pytest
-from pecos.slr import CReg, If, Main, Permute, QReg, Repeat
+from pecos.slr import CReg, If, Main, Permute, QReg, Repeat, rad
 from pecos.slr.ast import slr_to_ast
 from pecos.slr.ast.codegen import generate
 from pecos.slr.gen_codes import (
@@ -355,7 +355,7 @@ def test_rx_gate_qasm(self) -> None:
 
         prog = Main(
             q := QReg("q", 1),
-            qb.RX(math.pi / 4, q[0]),
+            qb.RX(rad(math.pi / 4), q[0]),
         )
 
         # AST path first
@@ -376,7 +376,7 @@ def test_ry_gate_qasm(self) -> None:
 
         prog = Main(
             q := QReg("q", 1),
-            qb.RY(math.pi / 2, q[0]),
+            qb.RY(rad(math.pi / 2), q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -395,7 +395,7 @@ def test_rz_gate_qasm(self) -> None:
 
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ(math.pi, q[0]),
+            qb.RZ(rad(math.pi), q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -414,9 +414,9 @@ def test_multiple_rotations_qasm(self) -> None:
 
         prog = Main(
             q := QReg("q", 2),
-            qb.RX(math.pi / 4, q[0]),
-            qb.RY(math.pi / 2, q[1]),
-            qb.RZ(math.pi, q[0]),
+            qb.RX(rad(math.pi / 4), q[0]),
+            qb.RY(rad(math.pi / 2), q[1]),
+            qb.RZ(rad(math.pi), q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -666,9 +666,9 @@ def test_qft_like_circuit_qasm(self) -> None:
         prog = Main(
             q := QReg("q", 3),
             qb.H(q[0]),
-            qb.RZ(math.pi / 2, q[0]),
+            qb.RZ(rad(math.pi / 2), q[0]),
             qb.H(q[1]),
-            qb.RZ(math.pi / 4, q[1]),
+            qb.RZ(rad(math.pi / 4), q[1]),
             qb.H(q[2]),
         )
 
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_integration.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_integration.py
index 921f7cccd..2b2829418 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_integration.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_integration.py
@@ -23,7 +23,7 @@
 import math
 
 import pytest
-from pecos.slr import CReg, If, Main, QReg, Repeat
+from pecos.slr import CReg, If, Main, QReg, Repeat, rad
 from pecos.slr.ast import slr_to_ast
 from pecos.slr.ast.codegen import (
     CodegenOptions,
@@ -160,9 +160,9 @@ def test_rotation_gates_roundtrip(self) -> None:
         """Rotation gates with float params round-trip."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ(0.5, q[0]),
-            qb.RX(math.pi / 4, q[0]),
-            qb.RY(1.234567890123, q[0]),
+            qb.RZ(rad(0.5), q[0]),
+            qb.RX(rad(math.pi / 4), q[0]),
+            qb.RY(rad(1.234567890123), q[0]),
         )
 
         ast = slr_to_ast(prog)
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_pretty_print.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_pretty_print.py
index d81d3e618..179df611c 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_pretty_print.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_pretty_print.py
@@ -13,7 +13,7 @@
 
 import math
 
-from pecos.slr import CReg, If, Main, QReg, Repeat
+from pecos.slr import CReg, If, Main, QReg, Repeat, rad
 from pecos.slr.ast import slr_to_ast
 from pecos.slr.ast.nodes import (
     AllocatorDecl,
@@ -121,16 +121,16 @@ def test_rotation_gates(self) -> None:
         """Rotation gates with parameters print correctly."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ(0.5, q[0]),
-            qb.RX(math.pi, q[0]),
+            qb.RZ(rad(0.5), q[0]),
+            qb.RX(rad(math.pi), q[0]),
         )
 
         ast = slr_to_ast(prog)
         result = pretty_print(ast)
 
-        assert "qb.RZ(0.5, q[0])" in result
+        assert "qb.RZ(rad(0.5), q[0])" in result
         # #97: angle-first form `qb.RX(theta, q)`, angle rendered first.
-        assert "qb.RX(3.141592653589793, q[0])" in result
+        assert "qb.RX(rad(3.141592653589793), q[0])" in result
 
 
 class TestPrettyPrintControlFlow:
@@ -296,12 +296,12 @@ def test_rotation_gate_statement(self) -> None:
         stmt = GateOp(
             gate=GateKind.RZ,
             targets=(SlotRef(allocator="q", index=0),),
-            params=(LiteralExpr(value=0.25),),
+            params=(LiteralExpr(value=rad(0.25)),),
         )
 
         result = format_statement(stmt)
 
-        assert result == "qb.RZ(0.25, q[0])"
+        assert result == "qb.RZ(rad(0.25), q[0])"
 
 
 class TestPrettyPrintIndentation:
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_serialize.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_serialize.py
index 5bc682788..0530b94cd 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_serialize.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_serialize.py
@@ -15,7 +15,7 @@
 import math
 
 import pytest
-from pecos.slr import CReg, If, Main, QReg, Repeat
+from pecos.slr import CReg, If, Main, QReg, Repeat, rad
 from pecos.slr.ast import slr_to_ast
 from pecos.slr.ast.nodes import (
     AllocatorDecl,
@@ -236,8 +236,8 @@ def test_rotation_gates(self) -> None:
         """Rotation gates with float params round-trip."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ(0.5, q[0]),
-            qb.RX(math.pi, q[0]),
+            qb.RZ(rad(0.5), q[0]),
+            qb.RX(rad(math.pi), q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -247,7 +247,8 @@ def test_rotation_gates(self) -> None:
         # Find RZ gate
         rz_gates = [s for s in restored.body if isinstance(s, GateOp) and s.gate == GateKind.RZ]
         assert len(rz_gates) == 1
-        assert rz_gates[0].params[0].value == 0.5
+        # The typed angle round-trips by exact fixed-point fraction + unit.
+        assert rz_gates[0].params[0].value == rad(0.5)
 
     def test_measurement(self) -> None:
         """Measurement with classical register round-trips."""
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/validation/test_pipeline.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/validation/test_pipeline.py
index e2dd9ddeb..4bd20b9a3 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/validation/test_pipeline.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/validation/test_pipeline.py
@@ -13,7 +13,7 @@
 
 import math
 
-from pecos.slr import CReg, If, Main, QReg
+from pecos.slr import CReg, If, Main, QReg, rad
 from pecos.slr.ast import slr_to_ast
 from pecos.slr.ast.nodes import (
     AllocatorDecl,
@@ -54,8 +54,8 @@ def test_validate_with_rotation(self) -> None:
         """Program with rotation gates passes."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ(0.5, q[0]),
-            qb.RX(math.pi, q[0]),
+            qb.RZ(rad(0.5), q[0]),
+            qb.RX(rad(math.pi), q[0]),
         )
 
         ast = slr_to_ast(prog)
@@ -71,7 +71,7 @@ def test_validate_complex_circuit(self) -> None:
             qb.H(q[0]),
             qb.CX(q[0], q[1]),
             qb.CX(q[1], q[2]),
-            qb.RZ(0.5, q[0]),
+            qb.RZ(rad(0.5), q[0]),
             If(c[0] == 1).Then(
                 qb.X(q[0]),
             ),
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/validation/test_type_checker.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/validation/test_type_checker.py
index ce9c4bf7a..90a750b38 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/validation/test_type_checker.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/validation/test_type_checker.py
@@ -13,7 +13,7 @@
 
 import math
 
-from pecos.slr import CReg, If, Main, QReg, Repeat
+from pecos.slr import CReg, If, Main, QReg, Repeat, rad
 from pecos.slr.ast import slr_to_ast
 from pecos.slr.ast.nodes import (
     AllocatorDecl,
@@ -53,8 +53,8 @@ def test_valid_rotation_gates(self) -> None:
         """Valid rotation gate with angle parameter."""
         prog = Main(
             q := QReg("q", 1),
-            qb.RZ(0.5, q[0]),
-            qb.RX(math.pi, q[0]),
+            qb.RZ(rad(0.5), q[0]),
+            qb.RX(rad(math.pi), q[0]),
         )
 
         ast = slr_to_ast(prog)
diff --git a/python/quantum-pecos/tests/slr/pecos/unit/slr/test_quantum_permutation.py b/python/quantum-pecos/tests/slr/pecos/unit/slr/test_quantum_permutation.py
index 7bb8b924a..755e607a5 100644
--- a/python/quantum-pecos/tests/slr/pecos/unit/slr/test_quantum_permutation.py
+++ b/python/quantum-pecos/tests/slr/pecos/unit/slr/test_quantum_permutation.py
@@ -3,7 +3,7 @@
 import re
 
 import pytest
-from pecos.slr import CReg, Main, Permute, QReg, SlrConverter
+from pecos.slr import CReg, Main, Permute, QReg, SlrConverter, rad
 from pecos.slr.qeclib import qubit
 
 # QASM Tests
@@ -361,9 +361,9 @@ def test_rotation_gates_with_permutation() -> None:
         a,
         b,
         # Apply initial gates to track qubit allocation
-        qubit.RX(0.1, a[0]),  # Track as "original a[0]"
-        qubit.RY(0.2, a[1]),  # Track as "original a[1]"
-        qubit.RZ(0.3, b[0]),  # Track as "original b[0]"
+        qubit.RX(rad(0.1), a[0]),  # Track as "original a[0]"
+        qubit.RY(rad(0.2), a[1]),  # Track as "original a[1]"
+        qubit.RZ(rad(0.3), b[0]),  # Track as "original b[0]"
         qubit.SZ(b[1]),  # Track as "original b[1]"
         # Apply permutation
         Permute(
@@ -371,8 +371,8 @@ def test_rotation_gates_with_permutation() -> None:
             [b[0], a[0]],
         ),
         # Apply gates after permutation
-        qubit.RX(0.4, a[0]),  # Should apply to "original b[0]"
-        qubit.RY(0.5, b[0]),  # Should apply to "original a[0]"
+        qubit.RX(rad(0.4), a[0]),  # Should apply to "original b[0]"
+        qubit.RY(rad(0.5), b[0]),  # Should apply to "original a[0]"
         qubit.T(a[1]),  # Should apply to "original a[1]"
         qubit.Tdg(b[1]),  # Should apply to "original b[1]"
     )
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
index 291a3214d..a7314f999 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
@@ -42,7 +42,22 @@
 
 from pecos.qec.surface import SurfacePatch
 from pecos.qec.surface.schedule import compute_cnot_schedule
-from pecos.slr import Barrier, Block, CReg, For, If, LoopVar, Main, Parallel, QReg, Repeat, Return, SlrConverter, While
+from pecos.slr import (
+    Barrier,
+    Block,
+    CReg,
+    For,
+    If,
+    LoopVar,
+    Main,
+    Parallel,
+    QReg,
+    Repeat,
+    Return,
+    SlrConverter,
+    While,
+    rad,
+)
 from pecos.slr.qeclib import qubit as qb
 from pecos.slr.qeclib.color488 import Color488Patch
 from pecos.slr.qeclib.generic.check import Check
@@ -622,7 +637,7 @@ def _docs_rotation_rx_probe() -> Block:
     return Main(
         q := QReg("q", 1),
         c := CReg("c", 1),
-        qb.RX(0.5, q[0]),
+        qb.RX(rad(0.5), q[0]),
         Measure(q) > c,
         Return(c),
     )
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
index b919c24c7..df1948f89 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import pytest
-from pecos.slr import CReg, For, LoopVar, Main, QReg, Repeat, Return, SlrConverter, While
+from pecos.slr import CReg, For, LoopVar, Main, QReg, Repeat, Return, SlrConverter, While, rad
 from pecos.slr.ast.codegen.guppy import GuppyCodegenError
 from pecos.slr.qeclib import qubit as qb
 from pecos.slr.qeclib.qubit.measures import Measure
@@ -88,7 +88,7 @@ def test_angle_first_misuse_fails_loud_at_call() -> None:
 
     # (3) Non-qubit in a qubit slot (`RX(0.5, 0.7)`).
     with pytest.raises(TypeError, match=r"RX: a non-qubit .* qubit position"):
-        qb.RX(0.5, 0.7)
+        qb.RX(rad(0.5), 0.7)
 
     # (4) Classical register/bit in a qubit slot (Codex reconfirm
     #     blocker): `CReg`/`Bit`/`SymbolicBit` are `Var` subclasses
@@ -98,11 +98,19 @@ def test_angle_first_misuse_fails_loud_at_call() -> None:
     #     quantum qubit shapes (Qubit/QReg/SymbolicQubit).
     c = CReg("c", 1)
     with pytest.raises(TypeError, match=r"RX: a classical register/bit .* qubit position"):
-        qb.RX(0.5, c[0])
+        qb.RX(rad(0.5), c[0])
     with pytest.raises(TypeError, match=r"RX: a classical register/bit .* qubit position"):
-        qb.RX(0.5, c)
+        qb.RX(rad(0.5), c)
     with pytest.raises(TypeError, match=r"RZZ: a classical register/bit .* qubit position"):
-        qb.RZZ(0.5, q[0], c[0])
+        qb.RZZ(rad(0.5), q[0], c[0])
+
+    # (5) v2 typed-angle: a bare numeric angle (no rad()/turns()) is
+    #     rejected at the call -- even though the Rust `AngleParam`
+    #     extractor would accept a bare f64, SLR requires a typed Angle.
+    with pytest.raises(TypeError, match=r"RX: bare numeric angle .* no longer accepted"):
+        qb.RX(0.5, q[0])
+    with pytest.raises(TypeError, match=r"RZZ: bare numeric angle .* no longer accepted"):
+        qb.RZZ(0.5, q[0], q[1])
 
 
 def test_codegen_arity_guard_rejects_malformed_param_gate() -> None:
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
index d790c52bc..04968f927 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
@@ -72,7 +72,7 @@
 from collections.abc import Callable
 
 import pytest
-from pecos.slr import CReg, Main, QReg, Return, SlrConverter
+from pecos.slr import CReg, Main, QReg, Return, SlrConverter, rad
 from pecos.slr.qeclib import qubit as qb
 from pecos.slr.qeclib.qubit.measures import Measure
 
@@ -238,7 +238,7 @@ def _high_bits_zero_1(obs: set[tuple[int, ...]]) -> None:
     ),
     "docs.rotation_rx": (
         "X",
-        "#97 (angle-first SLR API): `RX(0.5, q)` builds + lowers via "
+        "#97/v2 (typed angle-first SLR API): `RX(rad(0.5), q)` builds + lowers via "
         "qir_to_qis (rx is qir-qis-allowlisted), but rx(0.5) is "
         "NON-CLIFFORD so it cannot execute on the Stim backend this "
         "suite uses -- excluded from the executable record (rx "
@@ -614,12 +614,12 @@ def _run(prep, ops, meas_idx=0):
 
     import math as _math
 
-    crx_pi = lambda q: qb.CRX(_math.pi, q[0], q[1])  # noqa: E731
-    cry_pi = lambda q: qb.CRY(_math.pi, q[0], q[1])  # noqa: E731
-    crz_pi = lambda q: qb.CRZ(_math.pi, q[0], q[1])  # noqa: E731
-    crx_half = lambda q: qb.CRX(_math.pi / 2, q[0], q[1])  # noqa: E731
-    cry_half = lambda q: qb.CRY(_math.pi / 2, q[0], q[1])  # noqa: E731
-    crz_half = lambda q: qb.CRZ(_math.pi / 2, q[0], q[1])  # noqa: E731
+    crx_pi = lambda q: qb.CRX(rad(_math.pi), q[0], q[1])  # noqa: E731
+    cry_pi = lambda q: qb.CRY(rad(_math.pi), q[0], q[1])  # noqa: E731
+    crz_pi = lambda q: qb.CRZ(rad(_math.pi), q[0], q[1])  # noqa: E731
+    crx_half = lambda q: qb.CRX(rad(_math.pi / 2), q[0], q[1])  # noqa: E731
+    cry_half = lambda q: qb.CRY(rad(_math.pi / 2), q[0], q[1])  # noqa: E731
+    crz_half = lambda q: qb.CRZ(rad(_math.pi / 2), q[0], q[1])  # noqa: E731
     x_q0 = lambda q: qb.X(q[0])  # noqa: E731
     h_q1 = lambda q: qb.H(q[1])  # noqa: E731
 
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_typed_angles.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_typed_angles.py
new file mode 100644
index 000000000..6b449c643
--- /dev/null
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_typed_angles.py
@@ -0,0 +1,132 @@
+"""Tests for the SLR v2 typed-angle API (`rad(...)` / `turns(...)`).
+
+Covers: construction + conversions (delegating to `pecos.angle64`),
+pretty-print unit provenance, canonicalization semantics, AST JSON
+round-trip with the unit preserved, and backend lowering (QASM radians,
+Guppy half-turns).
+"""
+
+from __future__ import annotations
+
+import math
+
+import pytest
+from pecos.slr import Angle, Main, QReg, generate, rad, turns
+from pecos.slr.ast import slr_to_ast
+from pecos.slr.ast.nodes import GateKind, GateOp, LiteralExpr
+from pecos.slr.ast.pretty_print import pretty_print
+from pecos.slr.ast.serialize import ast_to_json, json_to_ast
+from pecos.slr.qeclib import qubit as qb
+
+
+def test_rad_turns_construct_angle_over_angle64() -> None:
+    a = rad(0.5)
+    assert isinstance(a, Angle)
+    assert a.source_unit == "rad"
+    assert a.value.to_radians() == pytest.approx(0.5)
+
+    t = turns(0.25)
+    assert t.source_unit == "turns"
+    assert t.value.to_radians() == pytest.approx(math.pi / 2)
+    assert t.value.to_half_turns() == pytest.approx(0.5)
+
+
+def test_rad_and_turns_agree_for_equivalent_angles() -> None:
+    # turns(0.25) == rad(pi/2): same underlying fixed-point fraction.
+    assert turns(0.25).value == rad(math.pi / 2).value
+
+
+def test_pretty_print_round_trips_source_unit() -> None:
+    prog = Main(q := QReg("q", 1), qb.RX(rad(0.5), q[0]), qb.RZ(turns(0.25), q[0]))
+    text = pretty_print(slr_to_ast(prog))
+    assert "qb.RX(rad(0.5), q[0])" in text
+    assert "qb.RZ(turns(0.25), q[0])" in text
+
+
+def test_canonicalization_full_turn_is_identity() -> None:
+    # angle64 wraps mod a full turn.
+    assert turns(1.0).value == turns(0.0).value
+    assert rad(2 * math.pi).value == rad(0.0).value
+
+
+def test_negative_angle_signed_round_trip() -> None:
+    # Signed display keeps ordinary negatives readable.
+    assert rad(-0.5).slr_repr() == "rad(-0.5)"
+    assert rad(-0.5).value.to_radians_signed() == pytest.approx(-0.5)
+
+
+def test_ast_json_round_trip_preserves_unit_and_value() -> None:
+    prog = Main(q := QReg("q", 1), qb.RZ(turns(0.125), q[0]))
+    ast = slr_to_ast(prog)
+    restored = json_to_ast(ast_to_json(ast))
+    # JSON is stable and the angle literal survives with its unit.
+    assert ast_to_json(restored) == ast_to_json(ast)
+    gate = next(s for s in restored.body if isinstance(s, GateOp) and s.gate == GateKind.RZ)
+    angle = gate.params[0]
+    assert isinstance(angle, LiteralExpr)
+    assert isinstance(angle.value, Angle)
+    assert angle.value == turns(0.125)
+    assert "_angle" in ast_to_json(ast)
+
+
+def test_qasm_lowers_to_signed_radians() -> None:
+    prog = Main(q := QReg("q", 1), qb.RX(rad(0.5), q[0]), qb.RZ(turns(0.25), q[0]))
+    qasm = generate(prog, "qasm")
+    assert "rx(0.5) q[0];" in qasm
+    # turns(0.25) == pi/2 radians.
+    assert f"rz({math.pi / 2}) q[0];" in qasm
+
+
+def test_guppy_lowers_to_half_turns() -> None:
+    prog = Main(q := QReg("q", 1), qb.RZ(turns(0.25), q[0]))
+    guppy = generate(prog, "guppy")
+    # turns(0.25) == 0.5 half-turns; Guppy `angle` is half-turn based.
+    assert "rz(q_0, angle(0.5))" in guppy
+
+
+def test_bare_float_rejected_but_typed_angle_accepted() -> None:
+    q = QReg("q", 1)
+    with pytest.raises(TypeError, match="bare numeric angle"):
+        qb.RX(0.5, q[0])
+    # The typed form constructs fine.
+    g = qb.RX(rad(0.5), q[0])
+    assert isinstance(g.params[0], Angle)
+
+
+def test_construction_arity_guard() -> None:
+    # Codex blocker 1: a parameterized call with too few qubits must fail
+    # at construction, not survive to codegen.
+    q = QReg("q", 2)
+    with pytest.raises(TypeError, match="needs at least one qubit"):
+        qb.RX(rad(0.5))  # no qubit
+    with pytest.raises(TypeError, match="needs at least 2 qubit"):
+        qb.RZZ(rad(0.5), q[0])  # one short for a 2q gate
+    with pytest.raises(TypeError, match="needs at least 2 qubit"):
+        qb.CRZ(rad(0.5), q[0])
+    # Valid forms still construct: whole-register broadcast + parallel.
+    assert qb.RZZ(rad(0.5), q) is not None
+    assert qb.RX(rad(0.5), q[0], q[1]) is not None
+    assert qb.RZZ(rad(0.5), q[0], q[1]) is not None
+
+
+def test_direct_ast_float_param_rejected_uniformly_across_backends() -> None:
+    # Codex blocker 2: a malformed direct-AST GateOp carrying a bare-float
+    # angle (bypassing the SLR call guard) must fail loud in EVERY backend,
+    # not just Guppy -- the backends must not diverge.
+    from dataclasses import replace
+
+    from pecos.slr.ast.codegen import generate as ast_generate
+    from pecos.slr.ast.codegen.guppy import GuppyCodegenError
+
+    prog = Main(q := QReg("q", 1), qb.RX(rad(0.5), q[0]))
+    good = slr_to_ast(prog)
+    rx = good.body[0]
+    assert isinstance(rx, GateOp)
+    assert rx.gate == GateKind.RX
+    bad = replace(good, body=(replace(rx, params=(LiteralExpr(value=0.5),)),))
+
+    for target in ("qir", "qasm", "quantum_circuit"):
+        with pytest.raises(NotImplementedError, match="requires typed `Angle`"):
+            ast_generate(bad, target)
+    with pytest.raises(GuppyCodegenError, match="requires a typed `Angle`"):
+        ast_generate(bad, "guppy")
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py
index e30029da2..098e2eb06 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py
@@ -28,7 +28,7 @@
 
 import math
 
-from pecos.slr import CReg, If, Main, Permute, QReg, Return
+from pecos.slr import CReg, If, Main, Permute, QReg, Return, rad
 from pecos.slr.qeclib import qubit as qb
 from pecos.slr.qeclib.qubit.measures import Measure
 from pecos.slr.qeclib.steane.steane_class import Steane
@@ -442,7 +442,7 @@ def test_rx_pi_is_x(self) -> None:
         prog = Main(
             q := QReg("q", 1),
             c := CReg("c", 1),
-            qb.RX(math.pi, q[0]),
+            qb.RX(rad(math.pi), q[0]),
             Measure(q[0]) > c[0],
             Return(c),
         )
@@ -453,8 +453,8 @@ def test_rx_pi_is_x(self) -> None:
         halves = Main(
             q := QReg("q", 1),
             c := CReg("c", 1),
-            qb.RX(math.pi / 2, q[0]),
-            qb.RX(math.pi / 2, q[0]),
+            qb.RX(rad(math.pi / 2), q[0]),
+            qb.RX(rad(math.pi / 2), q[0]),
             Measure(q[0]) > c[0],
             Return(c),
         )
@@ -466,7 +466,7 @@ def test_ry_pi_is_y(self) -> None:
         prog = Main(
             q := QReg("q", 1),
             c := CReg("c", 1),
-            qb.RY(math.pi, q[0]),
+            qb.RY(rad(math.pi), q[0]),
             Measure(q[0]) > c[0],
             Return(c),
         )
@@ -482,7 +482,7 @@ def test_rz_phase_via_hadamard_sandwich(self) -> None:
             q := QReg("q", 1),
             c := CReg("c", 1),
             qb.H(q[0]),
-            qb.RZ(math.pi, q[0]),
+            qb.RZ(rad(math.pi), q[0]),
             qb.H(q[0]),
             Measure(q[0]) > c[0],
             Return(c),
@@ -501,7 +501,7 @@ def test_crz_control_phase(self) -> None:
             c := CReg("c", 1),
             qb.X(q[0]),
             qb.H(q[1]),
-            qb.CRZ(math.pi, q[0], q[1]),
+            qb.CRZ(rad(math.pi), q[0], q[1]),
             qb.H(q[1]),
             Measure(q[1]) > c[0],
             Return(c),
@@ -585,7 +585,7 @@ def test_rzz_native_zz_phase(self) -> None:
             c := CReg("c", 2),
             qb.H(q[0]),
             qb.H(q[1]),
-            qb.RZZ(math.pi, q[0], q[1]),
+            qb.RZZ(rad(math.pi), q[0], q[1]),
             qb.H(q[0]),
             qb.H(q[1]),
             Measure(q[0]) > c[0],
@@ -644,7 +644,7 @@ def test_crx_cry_control_active(self) -> None:
             c := CReg("c", 1),
             qb.X(q[0]),
             qb.H(q[1]),
-            qb.CRX(math.pi, q[0], q[1]),
+            qb.CRX(rad(math.pi), q[0], q[1]),
             qb.H(q[1]),
             Measure(q[1]) > c[0],
             Return(c),
@@ -655,7 +655,7 @@ def test_crx_cry_control_active(self) -> None:
             c := CReg("c", 1),
             qb.X(q[0]),
             qb.H(q[1]),
-            qb.CRY(math.pi, q[0], q[1]),
+            qb.CRY(rad(math.pi), q[0], q[1]),
             qb.H(q[1]),
             Measure(q[1]) > c[0],
             Return(c),
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py b/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py
index 27d208d9a..4f40e1b35 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py
@@ -3,7 +3,7 @@
 import re
 
 import pytest
-from pecos.slr import Barrier, Block, Comment, CReg, If, Main, Parallel, QReg, Repeat, Return, SlrConverter
+from pecos.slr import Barrier, Block, Comment, CReg, If, Main, Parallel, QReg, Repeat, Return, SlrConverter, rad
 from pecos.slr.qeclib import qubit as p
 from pecos.slr.qeclib.steane.steane_class import Steane
 
@@ -126,7 +126,7 @@ def test_control_flow_qir() -> None:
             ),
         )
         .Else(
-            p.RX(0.3, q[0]),
+            p.RX(rad(0.3), q[0]),
         ),
         If(m < m_hidden).Then(
             p.H(q[0]),
@@ -136,13 +136,13 @@ def test_control_flow_qir() -> None:
         p.SZdg(q[0]),
         p.CX(q[0], q[1]),
         Barrier(q[1], q[0]),
-        p.RX(0.3, q[0]),
+        p.RX(rad(0.3), q[0]),
         p.Measure(q) > m,
         Return(m),
     )
     # B1: whole-CReg scalar conditions (`If(m == 0)` / `If(m <
     # m_hidden)`) are now lowered via `_pack_creg` + `_op_map`; the
-    # QIR builds. CAVEAT: the `RX(0.3, q)` rotations DO build + lower
+    # QIR builds. CAVEAT: the `RX(rad(0.3), q)` rotations DO build + lower
     # (#97 angle-first API; `rx` is qir-qis-allowlisted), but rx(0.3)
     # is NON-CLIFFORD so the program cannot execute on the Stim
     # backend -- it is build-/lower-only here, NOT end-to-end. (The
@@ -350,9 +350,9 @@ def test_parallel_in_control_flow_qir() -> None:
         ),
         Repeat(2).block(
             Parallel(
-                p.RX(0.5, q[0]),
-                p.RY(0.5, q[1]),
-                p.RZ(0.5, q[2]),
+                p.RX(rad(0.5), q[0]),
+                p.RY(rad(0.5), q[1]),
+                p.RZ(rad(0.5), q[2]),
             ),
         ),
         p.Measure(q) > m,
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_permutation.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_permutation.py
index 88b0b9574..bb4cdf04e 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_permutation.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_permutation.py
@@ -3,7 +3,7 @@
 import re
 
 import pytest
-from pecos.slr import CReg, Main, Permute, QReg, SlrConverter
+from pecos.slr import CReg, Main, Permute, QReg, SlrConverter, rad
 from pecos.slr.qeclib import qubit
 
 # QASM Tests
@@ -202,13 +202,13 @@ def test_rotation_gates_with_permutation() -> None:
     prog = Main(
         a,
         b,
-        qubit.RX(0.1, a[0]),  # q0
-        qubit.RY(0.2, a[1]),  # q1
-        qubit.RZ(0.3, b[0]),  # q2
+        qubit.RX(rad(0.1), a[0]),  # q0
+        qubit.RY(rad(0.2), a[1]),  # q1
+        qubit.RZ(rad(0.3), b[0]),  # q2
         qubit.SZ(b[1]),  # q3
         Permute([a[0], b[0]], [b[0], a[0]]),
-        qubit.RX(0.4, a[0]),  # -> b[0] = q2
-        qubit.RY(0.5, b[0]),  # -> a[0] = q0
+        qubit.RX(rad(0.4), a[0]),  # -> b[0] = q2
+        qubit.RY(rad(0.5), b[0]),  # -> a[0] = q0
         qubit.T(a[1]),  # unpermuted = q1
         qubit.Tdg(b[1]),  # unpermuted = q3
     )
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_stim_conversion.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_stim_conversion.py
index 0ce4c2d4a..0f2dabf6d 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_stim_conversion.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_stim_conversion.py
@@ -1,7 +1,7 @@
 """Tests for Stim circuit to/from SLR conversion."""
 
 import pytest
-from pecos.slr import CReg, For, Main, Parallel, QReg, Repeat, Return, SlrConverter, While
+from pecos.slr import CReg, For, Main, Parallel, QReg, Repeat, Return, SlrConverter, While, rad
 from pecos.slr.qeclib import qubit
 from pecos.slr.qeclib.qubit.measures import Measure
 
@@ -348,7 +348,7 @@ def test_unsupported_gate_fails_loud() -> None:
     emitting the circuit without it is the bug.
     """
     q = QReg("q", 1)
-    prog = Main(q, qubit.RX(0.5, q[0]))
+    prog = Main(q, qubit.RX(rad(0.5), q[0]))
     with pytest.raises(NotImplementedError, match=r"has no Stim lowering"):
         SlrConverter(prog).stim()
 

From 1aa707b96bd9e19f0c4b0e7804546de8dae7a8f5 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Thu, 21 May 2026 21:13:14 -0600
Subject: [PATCH 131/136] Make just lint pass: typos false-positive exemptions,
 black 26.x reformat, awk-portable GHA pinning check

---
 .typos.toml                                      | 10 ++++++++++
 examples/surface_code_slr_exploration.ipynb      |  2 +-
 .../src/pecos/slr/ast/codegen/guppy_linearity.py |  6 +-----
 .../integration/state_sim_tests/test_statevec.py | 14 ++++++++------
 scripts/dependency-integrity-check.sh            | 16 +++++++---------
 5 files changed, 27 insertions(+), 21 deletions(-)

diff --git a/.typos.toml b/.typos.toml
index 97548f0ba..8fab52f64 100644
--- a/.typos.toml
+++ b/.typos.toml
@@ -41,3 +41,13 @@ agger = "agger"
 CPY = "CPY"
 # Abbreviation for "undetectable" in fault enumeration debug output
 UNDET = "UNDET"
+# Legitimate "mis-" prefix used in comments/messages (mis-ordered,
+# mis-declared, mis-emitted, mis-shape, mis-count, mis-mapping, ...)
+mis = "mis"
+# Valid spelling of "unparseable" (used in comments + a test name)
+unparseable = "unparseable"
+Unparseable = "Unparseable"
+# Prep-gate naming: the "Pn -> PN" entry-point rename (PNX/PNY/PNZ)
+Pn = "Pn"
+PN = "PN"
+pn = "pn"
diff --git a/examples/surface_code_slr_exploration.ipynb b/examples/surface_code_slr_exploration.ipynb
index de3051c3b..b793de75d 100644
--- a/examples/surface_code_slr_exploration.ipynb
+++ b/examples/surface_code_slr_exploration.ipynb
@@ -593,4 +593,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
\ No newline at end of file
+}
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy_linearity.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy_linearity.py
index f0e9ce883..ada49fa5f 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy_linearity.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy_linearity.py
@@ -93,11 +93,7 @@ def from_allocators(
                 raise LinearityError(msg)
             for index in range(size):
                 slot = Slot(allocator, index)
-                local = (
-                    slot_locals[slot]
-                    if slot_locals is not None and slot in slot_locals
-                    else f"{allocator}_{index}"
-                )
+                local = slot_locals[slot] if slot_locals is not None and slot in slot_locals else f"{allocator}_{index}"
                 bindings[slot] = Binding(local=local, state=SlotState.LIVE)
         return cls(bindings)
 
diff --git a/python/quantum-pecos/tests/pecos/integration/state_sim_tests/test_statevec.py b/python/quantum-pecos/tests/pecos/integration/state_sim_tests/test_statevec.py
index 6520ec178..76cf1037e 100644
--- a/python/quantum-pecos/tests/pecos/integration/state_sim_tests/test_statevec.py
+++ b/python/quantum-pecos/tests/pecos/integration/state_sim_tests/test_statevec.py
@@ -356,9 +356,10 @@ def test_controlled_rotations_statevec() -> None:
         sim_c0 = StateVec(2)
         sim_c0.backend.run_2q_gate(sym, (0, 1), {"angle": theta})
         baseline_c0 = StateVec(2)
-        assert pc.allclose(sim_c0.backend.vector, baseline_c0.backend.vector), (
-            f"{sym}|00> changed the state -- expected identity when control=0"
-        )
+        assert pc.allclose(
+            sim_c0.backend.vector,
+            baseline_c0.backend.vector,
+        ), f"{sym}|00> changed the state -- expected identity when control=0"
 
         # c=1: |10> -> |1, R*(theta)|0>>. Compare against direct R* on target.
         sim_c1 = StateVec(2)
@@ -367,9 +368,10 @@ def test_controlled_rotations_statevec() -> None:
         sim_direct = StateVec(2)
         sim_direct.backend.run_1q_gate("X", 0, None)
         sim_direct.backend.run_1q_gate(direct_sym, 1, {"angle": theta})
-        assert pc.allclose(sim_c1.backend.vector, sim_direct.backend.vector), (
-            f"{sym}(theta) when c=1 must equal direct {direct_sym}(theta) on target"
-        )
+        assert pc.allclose(
+            sim_c1.backend.vector,
+            sim_direct.backend.vector,
+        ), f"{sym}(theta) when c=1 must equal direct {direct_sym}(theta) on target"
 
 
 @pytest.mark.parametrize(
diff --git a/scripts/dependency-integrity-check.sh b/scripts/dependency-integrity-check.sh
index aaa1b50f8..a3daaa020 100755
--- a/scripts/dependency-integrity-check.sh
+++ b/scripts/dependency-integrity-check.sh
@@ -274,16 +274,14 @@ else
 fi
 
 section "GitHub Actions action pinning"
+# A `uses:` ref is pinned iff the ref after `@` is a 40-hex commit SHA.
+# Do the interval (`{40}`) match with rg rather than awk: ERE interval
+# expressions are not supported by every host awk (a mawk built without
+# --re-interval treats `{40}` literally and would spuriously flag every
+# correctly pinned action), whereas rg's regex engine always supports them.
 unpinned_actions="$(
-    rg -n 'uses:[[:space:]]+[^[:space:]#]+@[^[:space:]#]+' .github/workflows .github/actions |
-        awk -F: '{
-            line = $0
-            sub(/^[^:]+:[0-9]+:/, "", line)
-            if (line ~ /uses:[[:space:]]+[^[:space:]#]+@[0-9a-f]{40}([[:space:]#]|$)/) {
-                next
-            }
-            print
-        }' ||
+    rg -n 'uses:[[:space:]]+[^[:space:]#]+@[^[:space:]#]+' .github/workflows .github/actions 2>/dev/null |
+        rg -v '@[0-9a-f]{40}([[:space:]#]|$)' ||
         true
 )"
 if [[ -n "$unpinned_actions" ]]; then

From 081f922125576aebc8b5a8a8637c6b1cd064cc10 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Thu, 21 May 2026 21:41:28 -0600
Subject: [PATCH 132/136] Harden GHA pinning check: bind the 40-hex SHA to the
 uses: ref so a comment SHA can't mask an unpinned action (Codex blocker)

---
 scripts/dependency-integrity-check.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scripts/dependency-integrity-check.sh b/scripts/dependency-integrity-check.sh
index a3daaa020..142456f5d 100755
--- a/scripts/dependency-integrity-check.sh
+++ b/scripts/dependency-integrity-check.sh
@@ -281,7 +281,7 @@ section "GitHub Actions action pinning"
 # correctly pinned action), whereas rg's regex engine always supports them.
 unpinned_actions="$(
     rg -n 'uses:[[:space:]]+[^[:space:]#]+@[^[:space:]#]+' .github/workflows .github/actions 2>/dev/null |
-        rg -v '@[0-9a-f]{40}([[:space:]#]|$)' ||
+        rg -v 'uses:[[:space:]]+[^[:space:]#]+@[0-9a-f]{40}([[:space:]#]|$)' ||
         true
 )"
 if [[ -n "$unpinned_actions" ]]; then

From fa0a6435d67f47bdaaeebf1521bf7b825fb08b4f Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Fri, 22 May 2026 09:09:27 -0600
Subject: [PATCH 133/136] Strip internal planning/issue references and persona
 names from code comments, keeping the technical reasons

---
 crates/pecos-llvm/src/llvm_compat.rs          |   4 +-
 python/pecos-rslib/src/pecos_array.rs         |  20 +--
 .../src/pecos/slr/ast/_block_substitution.py  |   4 +-
 .../pecos/slr/ast/codegen/_block_flatten.py   |   2 -
 .../src/pecos/slr/ast/codegen/_prep_tail.py   |   6 +-
 .../pecos/slr/ast/codegen/entry_wrapper.py    |   6 +-
 .../src/pecos/slr/ast/codegen/guppy.py        |  10 +-
 .../pecos/slr/ast/codegen/guppy_linearity.py  |   2 +-
 .../src/pecos/slr/ast/codegen/qasm.py         |   2 +-
 .../src/pecos/slr/ast/codegen/qir.py          |  40 ++---
 .../pecos/slr/ast/codegen/quantum_circuit.py  |  10 +-
 .../src/pecos/slr/ast/codegen/stim.py         |  19 ++-
 .../src/pecos/slr/ast/converter.py            |  18 +--
 .../quantum-pecos/src/pecos/slr/ast/nodes.py  |  19 +--
 .../src/pecos/slr/ast/pretty_print.py         |   2 +-
 .../src/pecos/slr/qeclib/generic/check.py     |   1 -
 .../pecos/slr/qeclib/generic/check_1flag.py   |   1 -
 .../pecos/slr/ast_tests/test_pretty_print.py  |   2 +-
 .../tests/slr_tests/ast_guppy/__init__.py     |  11 +-
 .../slr_tests/ast_guppy/_selene_harness.py    |   6 +-
 .../tests/slr_tests/ast_guppy/audit_runner.py |  27 ++--
 .../slr_tests/ast_guppy/test_ast_hugr.py      |  14 +-
 .../ast_guppy/test_block_call_smoke.py        |   5 +-
 .../slr_tests/ast_guppy/test_prep_gates.py    |   8 +-
 .../tests/slr_tests/ast_guppy/test_print.py   |  14 +-
 .../ast_guppy/test_qeclib_selene_corpus.py    |   8 +-
 .../ast_guppy/test_qir_corpus_executable.py   |  75 +++++----
 .../ast_guppy/test_qir_spec_compliance.py     | 143 +++++++++---------
 .../ast_guppy/test_tier2_semantic.py          |  66 ++++----
 .../slr_tests/ast_guppy/test_typed_angles.py  |   4 +-
 .../slr_tests/ast_guppy/test_v1_acceptance.py |  19 +--
 .../slr_tests/ast_guppy/test_v1_behavioral.py |  14 +-
 .../slr_tests/guppy/test_array_patterns.py    |   2 +-
 .../regression/random_cases/test_slr_phys.py  |  14 +-
 .../pecos/unit/slr/test_basic_permutation.py  |   4 +-
 .../unit/slr/test_complex_permutation.py      |   2 +-
 .../pecos/unit/slr/test_creg_permutation.py   |   6 +-
 .../unit/slr/test_measurement_permutation.py  |   4 +-
 .../unit/slr/test_measurement_unrolling.py    |   2 +-
 .../slr/test_quantum_circuit_conversion.py    |   2 +-
 .../unit/slr/test_quantum_permutation.py      |  18 +--
 .../unit/slr/test_register_permutation.py     |   4 +-
 .../pecos/unit/slr/test_stim_conversion.py    |   7 +-
 43 files changed, 307 insertions(+), 340 deletions(-)

diff --git a/crates/pecos-llvm/src/llvm_compat.rs b/crates/pecos-llvm/src/llvm_compat.rs
index ae7214518..90ad38f80 100644
--- a/crates/pecos-llvm/src/llvm_compat.rs
+++ b/crates/pecos-llvm/src/llvm_compat.rs
@@ -751,7 +751,7 @@ impl<'ctx> LLIRBuilder<'ctx> {
     }
 
     // ========================================================================
-    // Memory ops + casts (#75 -- unblocks #71 B2 standard CReg model)
+    // Memory ops + casts (unblocks the standard CReg model)
     // ========================================================================
 
     /// `alloca <ty>` -- stack slot. Caller positions the builder (B2
@@ -899,7 +899,7 @@ impl LLConstant {
         }
     }
 
-    /// Zero/`zeroinitializer` constant of `ll_type` (#75 -- backs
+    /// Zero/`zeroinitializer` constant of `ll_type` (backs
     /// `Constant(ty, None)`; Array -> `zeroinitializer`, Int -> `iN 0`).
     pub fn zero(ll_type: LLType<'_>) -> LLResult<LLValue<'_>> {
         match ll_type {
diff --git a/python/pecos-rslib/src/pecos_array.rs b/python/pecos-rslib/src/pecos_array.rs
index a926d49a7..ded6972de 100644
--- a/python/pecos-rslib/src/pecos_array.rs
+++ b/python/pecos-rslib/src/pecos_array.rs
@@ -4702,7 +4702,7 @@ impl Array {
                 let mut result = arr.clone();
                 for (axis, start, stop, step) in slices {
                     if step < 0 {
-                        // ndarray's Slice doesn't match NumPy for negative steps (see issue #312)
+                        // ndarray's Slice doesn't match NumPy for negative steps
                         // We need to manually implement NumPy's behavior:
                         // 1. Slice forward [stop+1, start+1] with step=1
                         // 2. Reverse the axis
@@ -4732,7 +4732,7 @@ impl Array {
                 let mut result = arr.clone();
                 for (axis, start, stop, step) in slices {
                     if step < 0 {
-                        // ndarray's Slice doesn't match NumPy for negative steps (see issue #312)
+                        // ndarray's Slice doesn't match NumPy for negative steps
                         // We need to manually implement NumPy's behavior:
                         // 1. Slice forward [stop+1, start+1] with step=1
                         // 2. Reverse the axis
@@ -4762,7 +4762,7 @@ impl Array {
                 let mut result = arr.clone();
                 for (axis, start, stop, step) in slices {
                     if step < 0 {
-                        // ndarray's Slice doesn't match NumPy for negative steps (see issue #312)
+                        // ndarray's Slice doesn't match NumPy for negative steps
                         // We need to manually implement NumPy's behavior:
                         // 1. Slice forward [stop+1, start+1] with step=1
                         // 2. Reverse the axis
@@ -4792,7 +4792,7 @@ impl Array {
                 let mut result = arr.clone();
                 for (axis, start, stop, step) in slices {
                     if step < 0 {
-                        // ndarray's Slice doesn't match NumPy for negative steps (see issue #312)
+                        // ndarray's Slice doesn't match NumPy for negative steps
                         // We need to manually implement NumPy's behavior:
                         // 1. Slice forward [stop+1, start+1] with step=1
                         // 2. Reverse the axis
@@ -4822,7 +4822,7 @@ impl Array {
                 let mut result = arr.clone();
                 for (axis, start, stop, step) in slices {
                     if step < 0 {
-                        // ndarray's Slice doesn't match NumPy for negative steps (see issue #312)
+                        // ndarray's Slice doesn't match NumPy for negative steps
                         // We need to manually implement NumPy's behavior:
                         // 1. Slice forward [stop+1, start+1] with step=1
                         // 2. Reverse the axis
@@ -4948,7 +4948,7 @@ impl Array {
                 let mut result = arr.clone();
                 for (axis, start, stop, step) in slices {
                     if step < 0 {
-                        // ndarray's Slice doesn't match NumPy for negative steps (see issue #312)
+                        // ndarray's Slice doesn't match NumPy for negative steps
                         // We need to manually implement NumPy's behavior:
                         // 1. Slice forward [stop+1, start+1] with step=1
                         // 2. Reverse the axis
@@ -4978,7 +4978,7 @@ impl Array {
                 let mut result = arr.clone();
                 for (axis, start, stop, step) in slices {
                     if step < 0 {
-                        // ndarray's Slice doesn't match NumPy for negative steps (see issue #312)
+                        // ndarray's Slice doesn't match NumPy for negative steps
                         // We need to manually implement NumPy's behavior:
                         // 1. Slice forward [stop+1, start+1] with step=1
                         // 2. Reverse the axis
@@ -5008,7 +5008,7 @@ impl Array {
                 let mut result = arr.clone();
                 for (axis, start, stop, step) in slices {
                     if step < 0 {
-                        // ndarray's Slice doesn't match NumPy for negative steps (see issue #312)
+                        // ndarray's Slice doesn't match NumPy for negative steps
                         // We need to manually implement NumPy's behavior:
                         // 1. Slice forward [stop+1, start+1] with step=1
                         // 2. Reverse the axis
@@ -5038,7 +5038,7 @@ impl Array {
                 let mut result = arr.clone();
                 for (axis, start, stop, step) in slices {
                     if step < 0 {
-                        // ndarray's Slice doesn't match NumPy for negative steps (see issue #312)
+                        // ndarray's Slice doesn't match NumPy for negative steps
                         // We need to manually implement NumPy's behavior:
                         // 1. Slice forward [stop+1, start+1] with step=1
                         // 2. Reverse the axis
@@ -5484,7 +5484,7 @@ impl Array {
                             // So we can use the slice params as-is, just on the current_axis.
 
                             if *step < 0 {
-                                // ndarray's Slice doesn't match NumPy for negative steps (see issue #312)
+                                // ndarray's Slice doesn't match NumPy for negative steps
                                 // We need to manually implement NumPy's behavior:
                                 // 1. Slice forward [stop+1, start+1] with step=1
                                 // 2. Reverse the axis
diff --git a/python/quantum-pecos/src/pecos/slr/ast/_block_substitution.py b/python/quantum-pecos/src/pecos/slr/ast/_block_substitution.py
index 19f5eb85c..3828c5cf4 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/_block_substitution.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/_block_substitution.py
@@ -33,8 +33,6 @@
 `VarExpr`, str `ReturnOp`/`AssignOp` targets) cannot express a partial
 (single-qubit / bundle / single-bit) binding; touching a partially-bound
 outer name raises `BodySubstitutionError` rather than silently leaking it.
-
-See `~/Repos/pecos-docs/design/slr/v2-iter5e-check-conversion-plan.md`.
 """
 
 from __future__ import annotations
@@ -245,7 +243,7 @@ def substitute_stmt(stmt: Statement, remap: BodyRemap) -> Statement:
         # Substitution remaps names in place (1:1, order/count
         # preserved), so the parallel `value_kinds` provenance still
         # aligns and MUST be carried (dropping it would re-introduce
-        # the #80 CReg/QReg name-collision miscompile inside a
+        # the CReg/QReg name-collision miscompile inside a
         # substituted BlockCall body).
         return ReturnOp(
             values=tuple(
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/_block_flatten.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/_block_flatten.py
index 225199884..1dfd79241 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/_block_flatten.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/_block_flatten.py
@@ -18,8 +18,6 @@
 
 The Guppy emitter does NOT use this pass: it lowers `BlockDecl` to
 `@guppy def` and `BlockCall` to a packed-array call.
-
-See `~/Repos/pecos-docs/design/slr/v2-blockcall-resource-effects.md`.
 """
 
 from __future__ import annotations
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/_prep_tail.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/_prep_tail.py
index a002c3868..bdd1b151e 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/_prep_tail.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/_prep_tail.py
@@ -9,13 +9,13 @@
 # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 # specific language governing permissions and limitations under the License.
 
-"""Canonical prep-basis lowering (#81), single source for every codegen.
+"""Canonical prep-basis lowering, single source for every codegen.
 
 A prep gate is a Z-reset (|0>) followed by a fixed Clifford tail. The
 tail is expressed as `GateKind`s so each backend reuses its existing
 `GateKind -> name` map (`GATE_TO_QIR/STIM/QC/QASM`, guppy
 `FUNCTIONAL_GATES`); there is exactly ONE tail table, not six. Pinned
-by the #81 round-1 review (states experimentally verified;
+by review (states experimentally verified;
 S = diag(1, i)): the uniform symmetric model X-basis = H,
 phase-flip via trailing Z; Y-basis = H then S(+)/Sdg(-).
 """
@@ -39,7 +39,7 @@ def prep_tail(basis: str) -> tuple[GateKind, ...]:
     """Tail for `basis`, or fail LOUD on an unknown basis.
 
     An unknown basis silently lowering as a bare |0> reset would be
-    exactly the silent-miscompile class #80/#81 exist to kill.
+    exactly the silent-miscompile class this lowering exists to kill.
     """
     try:
         return PREP_TAIL[basis]
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/entry_wrapper.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/entry_wrapper.py
index 55f52a805..dcd726526 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/entry_wrapper.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/entry_wrapper.py
@@ -64,7 +64,7 @@ class EntryWrapperInfo:
     all_creg_sizes: dict[str, int]
 
 
-# Reserved namespace for the opt-in returned-CReg result tags (#72). Private
+# Reserved namespace for the opt-in returned-CReg result tags. Private
 # (double-underscore) so it cannot collide with user `Print(..., namespace=
 # "result")` -> `result.<tag>` outputs. Single source of truth shared with
 # `_selene_harness` so the emit/read sides never drift.
@@ -88,7 +88,7 @@ def build_no_arg_entry_wrapper(
             Selene key the outputs by CReg name (immune to internal,
             non-returned measurements -- e.g. RUS verify). Default False
             keeps the production wrapper byte-identical (the `.hugr()` /
-            raw-`measurement_N` consumers must not change -- #72).
+            raw-`measurement_N` consumers must not change).
 
     Returns:
         A `(source, info)` tuple. `source` is the Guppy snippet defining
@@ -157,7 +157,7 @@ def _render_wrapper(info: EntryWrapperInfo, *, emit_return_result_tags: bool = F
     call_expr = f"main({call_args})"
 
     if emit_return_result_tags and info.explicit_return is not None:
-        # Opt-in (#72): destructure main's return and tag each returned CReg
+        # Opt-in: destructure main's return and tag each returned CReg
         # by name so Selene keys outputs by name, not positional
         # measurement_N (which counts internal measurements too).
         targets = [v if isinstance(v, str) else getattr(v, "name", None) for v in info.explicit_return.values]
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
index b71e907f5..69e93cf4c 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
@@ -254,7 +254,7 @@ class GuppyContext:
     registers: dict[str, RegisterDecl] = field(default_factory=dict)
     linearity: GuppyLinearityState | None = None
     temp_counter: int = 0
-    # #88B: single namespace-wide slot -> Guppy-local table. Populated
+    # Single namespace-wide slot -> Guppy-local table. Populated
     # by `populate_slot_locals` after declarations are collected (so
     # the registers + allocator names are known); read by both
     # `GuppyLinearityState.from_allocators(..., slot_locals=...)` and
@@ -288,7 +288,7 @@ def populate_slot_locals(self) -> None:
         assigned slot local, suffix `_` until unique. The result is the
         authority used by both linearity-state binding init and the
         emitter's `_local_name` so the entry-unpack LHS, the linearity
-        bindings, and per-slot references all agree (the #88B fix --
+        bindings, and per-slot references all agree (this disambiguation
         prevents `q_0, q_1 = q` from shadowing a separately declared
         `QReg("q_0", ...)` parameter). Idempotent: caller may invoke
         once after `_collect_declarations` populates allocators+regs.
@@ -1266,7 +1266,7 @@ def _raise_unsupported_gate(self, gate: GateKind) -> None:
         raise GuppyCodegenError(msg)
 
     def _emit_prepare(self, node: PrepareOp) -> list[str]:
-        # Z-reset/alloc to |0>, then the #81 canonical Clifford tail
+        # Z-reset/alloc to |0>, then the canonical Clifford tail
         # (functional, linearity-preserving -- same FUNCTIONAL_GATES
         # path as ordinary 1q gates; the qubit primitive yields |0>
         # so this is exactly `PZ(q); H(q); ...`).
@@ -1933,7 +1933,7 @@ def _slot_from_ref(self, ref: SlotRef) -> Slot:
         return Slot(ref.allocator, ref.index)
 
     def _local_name(self, slot: Slot) -> str:
-        # #88B: read from the disambiguated slot-locals table populated
+        # Read from the disambiguated slot-locals table populated
         # by `GuppyContext.populate_slot_locals` so this site agrees
         # with the linearity-state binding and the entry-unpack LHS.
         # Fall back to the bare formula only if a caller emits a slot
@@ -2079,7 +2079,7 @@ def _validate_slr_gate_for_guppy_v1(gate: object) -> None:
         msg = "AST -> Guppy v1 does not support symbolic LoopVar indexing"
         raise GuppyCodegenError(msg)
 
-    # (#81: the non-Z `Prep` string-basis preflight reject was
+    # (The non-Z `Prep` string-basis preflight reject was
     # removed -- prep basis is the gate identity now; the dedicated
     # gates carry it through `PrepareOp.basis` and the converter
     # already fails loud on any stray prep string arg.)
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy_linearity.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy_linearity.py
index ada49fa5f..204969d67 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy_linearity.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy_linearity.py
@@ -80,7 +80,7 @@ def from_allocators(
 
         `slot_locals`, when provided, is the single namespace-wide
         slot-to-Guppy-local name table from `GuppyContext.slot_locals`
-        (#88B: disambiguates the default `f"{allocator}_{index}"` against
+        (disambiguates the default `f"{allocator}_{index}"` against
         register names so the entry-unpack LHS does not shadow another
         declared register). When omitted, the default name is used --
         kept for callers that build a linearity table outside the main
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qasm.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qasm.py
index f79d93a9c..bb4c412d5 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qasm.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qasm.py
@@ -402,7 +402,7 @@ def visit_gate(self, node: GateOp) -> list[str]:
         return lines
 
     def visit_prepare(self, node: PrepareOp) -> list[str]:
-        """Generate reset/prep operation (Z-reset + #81 basis tail)."""
+        """Generate reset/prep operation (Z-reset + canonical basis tail)."""
         lines = []
         tail = prep_tail(node.basis)
 
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
index 8217c6dce..8d88e864a 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
@@ -133,7 +133,7 @@
 _DecompParams = tuple[float, ...] | Callable[[tuple[float, ...]], tuple[float, ...]]
 _DecompStep = tuple[GateKind, tuple[int, ...], _DecompParams]
 _GATE_DECOMP: dict[GateKind, tuple[_DecompStep, ...]] = {
-    # ---- single-qubit Clifford sqrt + face rotations (#93) ----
+    # ---- single-qubit Clifford sqrt + face rotations ----
     GateKind.SX: ((GateKind.H, (0,), ()), (GateKind.SZ, (0,), ()), (GateKind.H, (0,), ())),
     GateKind.SXdg: ((GateKind.H, (0,), ()), (GateKind.SZdg, (0,), ()), (GateKind.H, (0,), ())),
     GateKind.SY: ((GateKind.H, (0,), ()), (GateKind.X, (0,), ())),
@@ -142,7 +142,7 @@
     GateKind.Fdg: ((GateKind.H, (0,), ()), (GateKind.SZ, (0,), ())),
     GateKind.F4: ((GateKind.H, (0,), ()), (GateKind.SZdg, (0,), ())),
     GateKind.F4dg: ((GateKind.SZ, (0,), ()), (GateKind.H, (0,), ())),
-    # ---- two-qubit Clifford gates (#93 cont.) ----
+    # ---- two-qubit Clifford gates ----
     # SZZ/SZZdg directly via the native parameterized rzz.
     GateKind.SZZ: ((GateKind.RZZ, (0, 1), (math.pi / 2,)),),
     GateKind.SZZdg: ((GateKind.RZZ, (0, 1), (-math.pi / 2,)),),
@@ -202,7 +202,7 @@
         (GateKind.CX, (0, 1), ()),
         (GateKind.RY, (1,), (-math.pi / 4,)),
     ),
-    # ---- parameterized controlled rotations (#93 cont.) ----
+    # ---- parameterized controlled rotations ----
     # CRZ(theta) = (RZ(theta/2) o RZ(theta/2)) . RZZ(-theta/2): 1 RZZ,
     # 2 single-qubit RZ. The RZ on the control absorbs the e^{i theta/2}
     # phase that PECOS's R*(theta) all carry (otherwise it would be a
@@ -608,19 +608,19 @@ def _process_return(self, node: ReturnOp) -> None:
         an inline / local-scope returned CReg produced ZERO recorded
         output for an explicit `Return` -- the build succeeded and
         validated, the program just silently returned nothing
-        (#80; same silent-output-loss class as the four
+        (same silent-output-loss class as the four
         point-of-use sites). Qubit returns record no classical
         output and are skipped via per-value provenance
         (`ReturnOp.value_kinds` from `_convert_return`), so a
         `Return(qreg)` is not false-rejected AND a returned inline
         CReg whose name collides with a declared QReg is still
-        validated (#80: a name-membership skip was unsound).
+        validated (a name-membership skip was unsound).
         """
         # Provenance comes from `_convert_return` (it knows the real
         # QReg/CReg object), NOT from a name-membership guess: a
         # returned inline CReg can share a declared QReg's name, which
         # a `qubit_map`-name skip silently mistook for a qubit return
-        # and dropped (#80). Unknown kind
+        # and dropped. Unknown kind
         # ("" -- e.g. a directly-constructed ReturnOp) falls back to
         # "classical", the fail-loud-safe default.
         kinds = node.value_kinds
@@ -664,7 +664,7 @@ def _process_gate(self, node: GateOp) -> None:
 
         qir_name = GATE_TO_QIR.get(node.gate)
         if qir_name is None and node.gate in _GATE_DECOMP:
-            # #93: a gate with no direct QIR primitive but a verified
+            # A gate with no direct QIR primitive but a verified
             # decomposition into the qir-qis ALLOWED primitive set.
             # Emit each step in circuit order, routing its qubits
             # through the input gate's `targets` and threading params
@@ -675,7 +675,7 @@ def _process_gate(self, node: GateOp) -> None:
             # callable can do arithmetic on them; non-literal
             # expressions (VarExpr / BinaryExpr at gate-param position)
             # are not yet supported for parameterized decomposition
-            # (out of #93 scope; #94 classical-var lowering covers it).
+            # (out of scope; classical-var lowering covers it).
             input_params_raw = tuple(node.params or ())
             for prim_kind, idxs, params_spec in _GATE_DECOMP[node.gate]:
                 prim_targets = tuple(node.targets[i] for i in idxs)
@@ -698,9 +698,9 @@ def _process_gate(self, node: GateOp) -> None:
                     self._process_single_qubit_gate(prim_node, GATE_TO_QIR[prim_kind])
             return
         if qir_name is None:
-            # #88A (the broad class #78 deferred): a gate with no
+            # A gate with no
             # GATE_TO_QIR entry was SILENTLY DROPPED -- valid QIR,
-            # wrong semantics, qir-qis-uncatchable (#74-class). Fail
+            # wrong semantics, qir-qis-uncatchable. Fail
             # loud instead of miscompiling. Gates with a real QIR
             # lowering should be added to GATE_TO_QIR (a feature);
             # until then a program using one must not be silently
@@ -808,8 +808,8 @@ def _require_creg(self, reg_name: str) -> None:
         measure/assign/read against it used to be SILENTLY skipped
         (the store dropped, a read folded to constant 0) and the
         explicit returned value vanished from the QIS records (the
-        `docs.inline_measure_creg` defect #79 surfaced). Mirror the
-        #74/#78 doctrine: a silent miscompile must become a loud
+        `docs.inline_measure_creg` defect surfaced). Mirror the
+        fail-loud doctrine: a silent miscompile must become a loud
         `NotImplementedError`, not a buried wrong answer.
         """
         if reg_name not in self._creg_ptrs:
@@ -889,7 +889,7 @@ def _process_measure(self, node: MeasureOp) -> None:
                 )
 
     def _process_prepare(self, node: PrepareOp) -> None:
-        """Process a prepare/reset operation (Z-reset + #81 basis tail)."""
+        """Process a prepare/reset operation (Z-reset + canonical basis tail)."""
         tail = prep_tail(node.basis)
         if node.slots is None:
             # prepare_all is a pre-existing no-op gap; a NON-PZ
@@ -998,7 +998,7 @@ def _eval_expression(self, expr: Expression) -> Any:
             # factored out of `_generate_results` as `_pack_creg`. A
             # `VarExpr` whose name is not a declared Main-scope CReg
             # fails LOUD via `_require_creg`, preserving the
-            # #74/#80 anti-silent-0 guarantee.
+            # anti-silent-0 guarantee.
             self._require_creg(expr.name)
             return self._pack_creg(expr.name)
 
@@ -1018,7 +1018,7 @@ def _eval_expression(self, expr: Expression) -> Any:
             return operand
 
         # Any unhandled expression type silently evaluating to constant
-        # 0 is a value miscompile qir-qis cannot catch (the #74 / #80
+        # 0 is a value miscompile qir-qis cannot catch (the
         # fail-loud class -- same smell as the VarExpr arm above). Every
         # currently-reachable type is handled above; a new/unhandled one
         # must fail LOUD, not lower as 0.
@@ -1050,8 +1050,8 @@ def _process_while(self, node: WhileStmt) -> None:
         """`While` is not supported by the QIR backend.
 
         Unbounded iteration / fixed-point linear state through an
-        unknown iteration count is out of scope for the sound emitter
-        (v1-feature-matrix); the AST->Guppy path also rejects `While`.
+        unknown iteration count is out of scope for the sound emitter;
+        the AST->Guppy path also rejects `While`.
         Fail LOUD here -- the previous single-pass approximation
         silently dropped the loop condition and all iterations (a
         miscompile qir-qis cannot catch, since one pass is valid QIR).
@@ -1251,7 +1251,7 @@ def _finalize_module(self) -> str:
 
         mod_w_attr += '\nattributes #0 = { "entry_point"'
         # adaptive_profile: PECOS emits measurement-conditioned `If` ->
-        # adaptive, not base profile (#71 Stage B1, dual-review pinned).
+        # adaptive, not base profile.
         mod_w_attr += ' "qir_profiles"="adaptive_profile"'
         mod_w_attr += ' "output_labeling_schema"="labeled"'
         mod_w_attr += f' "required_num_qubits"="{self.context.qubit_count}"'
@@ -1260,8 +1260,8 @@ def _finalize_module(self) -> str:
         # QIR module flags (Adaptive Profile). pecos_rslib_llvm.ir.Module has
         # no named-metadata API, so append as raw IR text -- same approach as
         # the entry attributes above. The emitted module carries no `!`
-        # metadata, so !0..!4 are collision-free. Static classical model
-        # (#71 Stage B): dynamic_*/arrays = false (B2 keeps the static
+        # metadata, so !0..!4 are collision-free. The static classical
+        # model sets dynamic_*/arrays = false (it keeps the static
         # %Result + mutable local-buffer model; flags must match).
         mod_w_attr += "\n!llvm.module.flags = !{!0, !1, !2, !3, !4}"
         mod_w_attr += '\n!0 = !{i32 1, !"qir_major_version", i32 1}'
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py
index b661ae353..45c050ab9 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/quantum_circuit.py
@@ -118,7 +118,7 @@ class QCCodeGenContext:
     allocator_parents: dict[str, str | None] = field(default_factory=dict)
     allocator_offsets: dict[str, int] = field(default_factory=dict)
     qreg_sizes: dict[str, int] = field(default_factory=dict)  # name -> capacity
-    # Static logical permutation (same model as the QIR codegen #87 /
+    # Static logical permutation (same model as the QIR codegen /
     # the Guppy linearity tracker -- QuantumCircuit has no permute
     # instruction). Maps a logical (reg, index) ref to the (reg,
     # index) whose qubit it resolves to; consulted in `get_qubit`.
@@ -283,7 +283,7 @@ def _process_statement(self, stmt: Statement) -> None:
         elif isinstance(stmt, PrintOp):
             # Print is not yet implemented for the QuantumCircuit
             # backend. Fail LOUD rather than silently drop observable
-            # program output (#74 principle). Unlike Stim, PECOS owns
+            # program output (fail-loud principle). Unlike Stim, PECOS owns
             # the QuantumCircuit format, so a `Print` representation
             # could be added later -- this is "not yet", not "cannot".
             msg = (
@@ -400,7 +400,7 @@ def _process_measure(self, node: MeasureOp) -> None:
             self._add_to_tick("Measure", qubit)
 
     def _process_prepare(self, node: PrepareOp) -> None:
-        """Process a prepare/reset operation (Z-reset + #81 basis tail).
+        """Process a prepare/reset operation (Z-reset + canonical basis tail).
 
         QC ticks are parallel sets; reset and the Clifford tail MUST
         be sequential, so each is its own flushed tick (PZ has no
@@ -517,7 +517,7 @@ def _expand_permute_ref(self, ref: str) -> list[tuple[str, int]]:
         of the qubit register. QuantumCircuit has no realized
         classical-register model, so a bare CReg permute is not
         realizable -> fail loud (never a silent no-op). Mirrors the
-        QIR codegen's #87 helper.
+        QIR codegen's helper.
         """
         if ref.endswith("]") and "[" in ref:
             name, idx = ref[:-1].split("[", 1)
@@ -535,7 +535,7 @@ def _process_permute(self, node: PermuteOp) -> None:
         """Realize a Permute as a static logical relabel.
 
         QuantumCircuit has no permute instruction, so -- exactly like
-        the QIR codegen (#87) and the Guppy linearity tracker -- a
+        the QIR codegen and the Guppy linearity tracker -- a
         Permute is realized at compile time by relabelling which qubit
         each logical (reg, index) ref resolves to (consulted in
         `get_qubit`). The old `allocator_offsets` swap was a no-op for
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/stim.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/stim.py
index 7aaeae3b1..f3cf2f31e 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/stim.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/stim.py
@@ -141,7 +141,7 @@ class StimCodeGenContext:
     allocator_parents: dict[str, str | None] = field(default_factory=dict)
     allocator_offsets: dict[str, int] = field(default_factory=dict)
     qreg_sizes: dict[str, int] = field(default_factory=dict)  # name -> capacity
-    # Static logical permutation (same model as the QIR codegen #87 /
+    # Static logical permutation (same model as the QIR codegen /
     # the Guppy linearity tracker -- Stim has no permute instruction).
     # Maps a logical (reg, index) ref to the (reg, index) whose qubit
     # it resolves to. Consulted at every qubit-ref lowering.
@@ -298,7 +298,7 @@ def _process_statement(self, stmt: Statement) -> None:
         elif isinstance(stmt, PrintOp):
             # Classical-output streaming is unimplemented in the Stim
             # backend. Silently dropping it loses observable program
-            # output -- fail LOUD (same decision as the QIR backend, #74).
+            # output -- fail LOUD (same decision as the QIR backend).
             msg = (
                 "Stim codegen does not support Print (classical output "
                 "streaming is unimplemented; silently dropping it would "
@@ -320,10 +320,9 @@ def _process_gate(self, node: GateOp) -> None:
                 self.circuit.append_operation(prim_name, prim_qubits)
             return
         if stim_gate is None:
-            # #88A-class (the #78 surfaced-not-changed Stim analogue):
-            # a gate with no GATE_TO_STIM entry was SILENTLY DROPPED
+            # A gate with no GATE_TO_STIM entry was SILENTLY DROPPED
             # -- the emitted Stim circuit ran but with wrong
-            # semantics (a #74-class silent miscompile,
+            # semantics (a silent miscompile,
             # uncatchable downstream). Fail loud instead. Stim is
             # Clifford-only, so non-Clifford rotations
             # (RX/RY/RZ/RZZ/CR*) are fundamentally unrepresentable
@@ -384,7 +383,7 @@ def _process_measure(self, node: MeasureOp) -> None:
         self.context.measurement_count += len(qubits)
 
     def _process_prepare(self, node: PrepareOp) -> None:
-        """Process a prepare/reset operation (Z-reset + #81 basis tail)."""
+        """Process a prepare/reset operation (Z-reset + canonical basis tail)."""
         tail = prep_tail(node.basis)
         if node.slots is None:
             if tail:
@@ -420,8 +419,8 @@ def _process_while(self, node: WhileStmt) -> None:
 
         Stim has no runtime loop. The previous "process body once + TICK"
         silently dropped the loop condition and all iterations -- a
-        miscompile. Fail LOUD instead (same decision as the QIR backend,
-        #74; real While is out of scope per v1-feature-matrix).
+        miscompile. Fail LOUD instead (same decision as the QIR backend;
+        real While is out of scope).
         """
         _ = node
         msg = (
@@ -495,7 +494,7 @@ def _expand_permute_ref(self, ref: str) -> list[tuple[str, int]]:
         `name[idx]` -> a single element; bare `name` -> every element
         of the qubit register. Stim has no classical-register model,
         so a bare CReg permute is not realizable -> fail loud (never
-        a silent no-op). Mirrors the QIR codegen's #87 helper.
+        a silent no-op). Mirrors the QIR codegen's helper.
         """
         if ref.endswith("]") and "[" in ref:
             name, idx = ref[:-1].split("[", 1)
@@ -513,7 +512,7 @@ def _process_permute(self, node: PermuteOp) -> None:
         """Realize a Permute as a static logical relabel.
 
         Stim has no permute instruction, so -- exactly like the QIR
-        codegen (#87) and the Guppy linearity tracker -- a Permute is
+        codegen and the Guppy linearity tracker -- a Permute is
         realized at compile time by relabelling which qubit each
         logical (reg, index) ref resolves to (consulted in
         `get_qubit`). The old `allocator_offsets` swap was a no-op
diff --git a/python/quantum-pecos/src/pecos/slr/ast/converter.py b/python/quantum-pecos/src/pecos/slr/ast/converter.py
index 2e150bd03..6f3d1b7ea 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/converter.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/converter.py
@@ -86,9 +86,9 @@
     from pecos.slr.main import Main
 
 
-# SLR prep-gate symbol -> canonical AST prep basis (#81). The basis
-# is the gate identity, not a string argument. (`Prep` was removed
-# in Stage C -- hard-replaced repo-wide by `PZ`.)
+# SLR prep-gate symbol -> canonical AST prep basis. The basis
+# is the gate identity, not a string argument. (`Prep` was removed,
+# hard-replaced repo-wide by `PZ`.)
 _PREP_BASIS: dict[str, str] = {
     "PZ": "PZ",
     "PNZ": "PNZ",
@@ -615,8 +615,8 @@ def _convert_gate(self, gate: Any) -> Statement:
         gate_name = gate.sym
 
         # Handle special operations. All prep gates route through one
-        # path; the basis is the GATE IDENTITY (#81;
-        # PZ/PNZ/PX/PNX/PY/PNY), never a string argument.
+        # path; the basis is the GATE IDENTITY
+        # (PZ/PNZ/PX/PNX/PY/PNY), never a string argument.
         if gate_name in _PREP_BASIS:
             return self._convert_prep(gate, basis=_PREP_BASIS[gate_name])
 
@@ -675,7 +675,7 @@ def _convert_prep(self, gate: Any, basis: str = "PZ") -> Statement:
         """Convert an SLR prep gate to an AST PrepareOp.
 
         `basis` is the canonical eigenstate from the gate IDENTITY
-        (#81: `PZ`/`PNZ`/`PX`/`PNX`/`PY`/`PNY`; `Prep` -> `PZ`), NOT
+        (`PZ`/`PNZ`/`PX`/`PNX`/`PY`/`PNY`; `Prep` -> `PZ`), NOT
         a string argument.
         """
         if not gate.qargs:
@@ -686,8 +686,8 @@ def _convert_prep(self, gate: Any, basis: str = "PZ") -> Statement:
         # `_expand_qubit_args` silently drops strings, so a basis
         # string (`PZ(q, "X")`, the legacy `Prep(q, "X")`, etc.)
         # would otherwise be silently dropped and the gate lowered as
-        # its plain basis -- a miscompile (#80 recast / #81 sym
-        # rule). The prep basis is the gate identity; pass NO string.
+        # its plain basis -- a miscompile under the prep-basis
+        # symmetry rule. The prep basis is the gate identity; pass NO string.
         for arg in gate.qargs:
             if isinstance(arg, str):
                 msg = (
@@ -863,7 +863,7 @@ def _convert_return(self, op: Any) -> ReturnOp:
         SLR object's type. A whole-register return flattens to its
         bare `sym` name; a returned inline CReg can collide with a
         declared QReg of the same name, which is undecidable
-        downstream by name alone (the #80 name-collision bug). The
+        downstream by name alone (the name-collision bug). The
         QReg/CReg distinction is known HERE (the real object), so it
         is preserved instead of guessed in codegen.
         """
diff --git a/python/quantum-pecos/src/pecos/slr/ast/nodes.py b/python/quantum-pecos/src/pecos/slr/ast/nodes.py
index b739ca59b..9bee5c508 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/nodes.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/nodes.py
@@ -207,10 +207,7 @@ class UnaryOp(Enum):
 
 
 class ResourceEffect(Enum):
-    """Effect declared by a `BlockDecl` input on the outer scope's binding.
-
-    See `~/Repos/pecos-docs/design/slr/v2-blockcall-resource-effects.md`.
-    """
+    """Effect declared by a `BlockDecl` input on the outer scope's binding."""
 
     LIVE_PRESERVED = auto()  # caller binding survives the call unchanged
     CONSUMED = auto()  # caller binding is invalidated by the call
@@ -220,8 +217,7 @@ class ResourceEffect(Enum):
     # measures it at exit, depending on no incoming state. The caller's slot is
     # a flatten-path naming vehicle only; in Guppy the block allocates the qubit
     # internally so the same outer slot can feed a subsequent BlockCall (the
-    # `consumed` model would kill it). See
-    # ~/Repos/pecos-docs/design/slr/v2-scratch-ancilla-effect.md.
+    # `consumed` model would kill it).
     SCRATCH = auto()
 
 
@@ -419,8 +415,8 @@ class PrepareOp(Statement):
     # `_convert_prep` from the SLR gate symbol (PZ default). Carried
     # on the AST so codegens lower the correct reset+Clifford tail;
     # MUST be preserved through block substitution (else a non-PZ
-    # prep inside a BlockCall body silently reverts to PZ -- the
-    # #81-B1 soundness-critical case).
+    # prep inside a BlockCall body silently reverts to PZ -- a
+    # soundness-critical case).
     basis: str = "PZ"
 
 
@@ -479,7 +475,7 @@ class ReturnOp(Statement):
     # which case a backend treats a bare-name value as classical
     # (the fail-loud-safe default). A bare `values` string cannot be
     # disambiguated CReg-vs-QReg by name alone (a returned inline
-    # CReg can collide with a declared QReg name -- the #80
+    # CReg can collide with a declared QReg name -- the
     # name-collision bug), so provenance is carried here, not guessed.
     value_kinds: tuple[str, ...] = ()
 
@@ -607,10 +603,7 @@ def children(self) -> Sequence[AstNode]:
 
 @dataclass(frozen=True, kw_only=True)
 class BlockInput(AstNode):
-    """One declared input parameter to a `BlockDecl`.
-
-    See `~/Repos/pecos-docs/design/slr/v2-blockcall-resource-effects.md`.
-    """
+    """One declared input parameter to a `BlockDecl`."""
 
     name: str
     effect: ResourceEffect
diff --git a/python/quantum-pecos/src/pecos/slr/ast/pretty_print.py b/python/quantum-pecos/src/pecos/slr/ast/pretty_print.py
index 67238158e..cca21c19a 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/pretty_print.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/pretty_print.py
@@ -210,7 +210,7 @@ def visit_gate(self, node: GateOp) -> str:
         targets = ", ".join(self.visit_slot_ref(t) for t in node.targets)
 
         if node.params:
-            # #97: angle-first SLR API -- `qb.RX(theta, q)`, angles
+            # Angle-first SLR API -- `qb.RX(theta, q)`, angles
             # before qubits (not the legacy `qb.RX[theta](q)` bracket).
             params = ", ".join(self.format_expression(p) for p in node.params)
             sep = ", " if targets else ""
diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/generic/check.py b/python/quantum-pecos/src/pecos/slr/qeclib/generic/check.py
index 033241399..066cee7b8 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/generic/check.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/generic/check.py
@@ -40,7 +40,6 @@ class Check(Block):
     # scratch ancilla (prepped + measured inside, allocated internally in
     # Guppy so callers like SynExtractBare can reuse one physical slot across
     # sequential Checks); `out` is the live_preserved measurement-result bit.
-    # See ~/Repos/pecos-docs/design/slr/v2-scratch-ancilla-effect.md.
     block_inputs: ClassVar[dict[str, str]] = {
         "d": "live_preserved",
         "a": "scratch",
diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/generic/check_1flag.py b/python/quantum-pecos/src/pecos/slr/qeclib/generic/check_1flag.py
index 9b467d3d4..589bc9ff7 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/generic/check_1flag.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/generic/check_1flag.py
@@ -43,7 +43,6 @@ class Check1Flag(Block):
     # single `PZ(a, flag)` is split into `PZ(a), PZ(flag)` (O1 option
     # (a) -- byte-identical in QASM/Guppy/Selene, confirmed 2026-05-16;
     # one PrepareOp per scratch input avoids multi-destination substitution).
-    # See ~/Repos/pecos-docs/design/slr/v2-scratch-ancilla-effect.md.
     block_inputs: ClassVar[dict[str, str]] = {
         "d": "live_preserved",
         "a": "scratch",
diff --git a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_pretty_print.py b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_pretty_print.py
index 179df611c..7194a7c65 100644
--- a/python/quantum-pecos/tests/pecos/slr/ast_tests/test_pretty_print.py
+++ b/python/quantum-pecos/tests/pecos/slr/ast_tests/test_pretty_print.py
@@ -129,7 +129,7 @@ def test_rotation_gates(self) -> None:
         result = pretty_print(ast)
 
         assert "qb.RZ(rad(0.5), q[0])" in result
-        # #97: angle-first form `qb.RX(theta, q)`, angle rendered first.
+        # Angle-first form `qb.RX(theta, q)`, angle rendered first.
         assert "qb.RX(rad(3.141592653589793), q[0])" in result
 
 
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/__init__.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/__init__.py
index 41a4ba8b1..e5eab195b 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/__init__.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/__init__.py
@@ -4,15 +4,10 @@
 (`SlrConverter.guppy()` and downstream codegens at
 `pecos/slr/ast/codegen/guppy.py`). They are the v1 acceptance
 contract: each test is the spec for one feature in the v1 supported
-set documented at:
+set.
 
-    ~/Repos/pecos-docs/design/slr/v1-feature-matrix.md
-    ~/Repos/pecos-docs/design/slr/stage3-synthesis.md
-    ~/Repos/pecos-docs/design/slr/stage5-integrity-review.md
-
-Tests start as xfail because the AST Guppy emitter is being rewritten
-on this branch (`feat/ast-guppy-v1`). As features land, the xfail
-mark comes off the corresponding test.
+Tests start as xfail while the AST Guppy emitter is being rewritten.
+As features land, the xfail mark comes off the corresponding test.
 
 Post-cutover, `SlrConverter.hugr()` is also AST-routed (wraps `main`
 in a no-arg `entry()` and compiles that). Acceptance tests prefer
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py
index 334eb5205..0811a0e0f 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py
@@ -66,7 +66,7 @@ def run_ast_guppy_via_selene(
     ast_source = SlrConverter(slr_program).guppy()
     program = slr_to_ast(slr_program)
 
-    # #72: opt-in named return tags. The wrapper emits
+    # Opt-in named return tags. The wrapper emits
     # `result("__pecos_return.<creg>", <creg>)` per returned CReg, so Selene
     # keys outputs by CReg NAME -- immune to internal (non-returned)
     # measurements like the Steane RUS verify. `_shot_records` reads those
@@ -141,7 +141,7 @@ def _shot_records(result: pecos_rslib.ShotVec, record_cregs: list[RegisterDecl])
     """Re-export the named `__pecos_return.<creg>` tags as the public shape.
 
     The wrapper emits `result("__pecos_return.<creg>", <creg>)` per returned
-    CReg (#72), so Selene's `to_dict()` keys outputs by CReg name and each
+    CReg, so Selene's `to_dict()` keys outputs by CReg name and each
     shot value is a list of that CReg's bits in declaration order. We flatten
     the returned CRegs (in `Return(...)` order) into the historical public
     shape `{"measurement_0": .., "measurement_1": .., ...}` so existing
@@ -174,7 +174,7 @@ def _shot_records(result: pecos_rslib.ShotVec, record_cregs: list[RegisterDecl])
             # Selene shapes a size-1 CReg result tag as a scalar int per
             # shot, and a size>1 CReg as a list of `size` ints per shot.
             # Be explicit and fail LOUD on any other shape -- a silent
-            # mis-count is the exact bug class #72 fixed (do not let an
+            # mis-count is the exact bug class this guard prevents (do not let an
             # unexpected Selene type, e.g. a numpy array/generator, be
             # silently wrapped as one bit).
             if isinstance(shot_val, (list, tuple)):
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
index a7314f999..8434f26bc 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
@@ -17,8 +17,8 @@
 post-cutover) and captures any failures.
 
 This is NOT a pytest test file. It's an audit tool run
-during Workstream B and at cutover. Output is the seed for new
-rows in `~/Repos/pecos-docs/design/slr/v1-audit-manifest.md`.
+during the cutover. Output is the seed for new
+rows in the audit manifest.
 
 Invocation:
     cd /home/ciaranra/Repos/PECOS
@@ -531,8 +531,7 @@ def _qeclib_color488_syn_extract_bare() -> Block:
 def _docs_for_static_indexing() -> Block:
     """v1-shaped For loop: string iteration variable, integer bounds, fixed-slot body.
 
-    Shape per v1-feature-matrix: v1 supports For("i", 0, 3) over fixed
-    slots, no symbolic indexing.
+    v1 supports For("i", 0, 3) over fixed slots, no symbolic indexing.
     """
     return Main(
         q := QReg("q", 3),
@@ -579,7 +578,7 @@ def _docs_repeat_state_preserving() -> Block:
 
 
 def _docs_while_loop_v2_defer() -> Block:
-    """Deliberate red-light: While loop is v2-defer per v1-feature-matrix.
+    """Deliberate red-light: While loop is out of scope for v1.
 
     Body consumes-and-replaces the qubit slot inside an unbounded loop;
     "Fixed-point linear state through unknown iteration count is too large
@@ -597,10 +596,10 @@ def _docs_while_loop_v2_defer() -> Block:
 
 
 def _docs_for_loopvar_symbolic_v2_defer() -> Block:
-    """Deliberate red-light: For with LoopVar + symbolic q[i] is v2-defer.
+    """Deliberate red-light: For with LoopVar + symbolic q[i] is out of scope for v1.
 
-    Per v1-feature-matrix: "Current AST converter cannot represent symbolic
-    SlotRef.index; supporting it would touch shared conversion semantics."
+    The current AST converter cannot represent symbolic
+    SlotRef.index; supporting it would touch shared conversion semantics.
     """
     i = LoopVar("i")
     return Main(
@@ -615,8 +614,8 @@ def _docs_for_loopvar_symbolic_v2_defer() -> Block:
 
 
 def _docs_prep_basis_x() -> Block:
-    """X-basis prep via the dedicated `PX` gate (#81 -- was v2-defer;
-    the basis is the gate identity, not a string argument)."""
+    """X-basis prep via the dedicated `PX` gate (the basis is the gate
+    identity, not a string argument)."""
     return Main(
         q := QReg("q", 1),
         c := CReg("c", 1),
@@ -630,9 +629,9 @@ def _docs_rotation_rx_probe() -> Block:
     """Probe: RX rotation gate, angle-first SLR API `RX(theta, q)`.
 
     The doc-test originally wrote `RX(q, 0.5)` (qubit-first, angle as a
-    stray qarg). With the angle-first SLR API (#97) the canonical form
+    stray qarg). With the angle-first SLR API the canonical form
     is `RX(theta, q)`; RX is now a supported native rotation in both
-    the Guppy emitter (Phase A -> `rx`) and the QIR backend.
+    the Guppy emitter (-> `rx`) and the QIR backend.
     """
     return Main(
         q := QReg("q", 1),
@@ -655,8 +654,8 @@ def _docs_inline_measure_creg() -> Block:
 
 def _docs_surface_syndrome_block18() -> Block:
     """surface_code_syndrome doc-test shape from test_slr_qeclib_block_18,
-    using the dedicated prep gates (#81 -- was v2-defer on the PZ
-    basis-string arg; X-syndrome ancilla = `PX` (|+>) directly)."""
+    using the dedicated prep gates (X-syndrome ancilla = `PX` (|+>)
+    directly)."""
     d = 2
     num_data = d * d
     num_ancilla = 2
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
index df1948f89..a0f9f1e22 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_ast_hugr.py
@@ -40,11 +40,11 @@ def test_hugr_rejects_while_before_parallel_optimizer_erases_it() -> None:
 
 
 def test_hugr_rejects_stray_prep_basis_string() -> None:
-    # #81: the prep basis is the gate IDENTITY (PZ/PNZ/PX/PNX/PY/PNY),
+    # The prep basis is the gate IDENTITY (PZ/PNZ/PX/PNX/PY/PNY),
     # not a string argument. A stray string qarg on any prep gate is
     # rejected loudly at the shared converter root (NotImplementedError),
     # so it never silently reaches the codegen -- superseding the old
-    # Guppy-preflight non-Z-Prep reject (removed in #81 Stage C along
+    # Guppy-preflight non-Z-Prep reject (removed along
     # with the `Prep` alias).
     prog = Main(
         q := QReg("q", 1),
@@ -67,8 +67,8 @@ def test_hugr_rejects_symbolic_loopvar_indexing_cleanly() -> None:
 
 
 def test_angle_first_misuse_fails_loud_at_call() -> None:
-    # #97 (angle-first API) post-review fold (Codex blocker): a
-    # mis-ordered `gate(qubit, angle)` call -- the pre-#97 silent-
+    # Angle-first API: a
+    # mis-ordered `gate(qubit, angle)` call -- the old silent-
     # angle-drop footgun -- must fail loud at the SLR call, never
     # compile to a silent no-op.
     q = QReg("q", 2)
@@ -90,8 +90,8 @@ def test_angle_first_misuse_fails_loud_at_call() -> None:
     with pytest.raises(TypeError, match=r"RX: a non-qubit .* qubit position"):
         qb.RX(rad(0.5), 0.7)
 
-    # (4) Classical register/bit in a qubit slot (Codex reconfirm
-    #     blocker): `CReg`/`Bit`/`SymbolicBit` are `Var` subclasses
+    # (4) Classical register/bit in a qubit slot:
+    #     `CReg`/`Bit`/`SymbolicBit` are `Var` subclasses
     #     too, so a broad `isinstance(_, Var)` qubit check let
     #     `RX(0.5, c[0])` through and QASM/QIR lowered `rx(0.5) c[0];`
     #     against a classical register. Qubit slots accept ONLY
@@ -114,7 +114,7 @@ def test_angle_first_misuse_fails_loud_at_call() -> None:
 
 
 def test_codegen_arity_guard_rejects_malformed_param_gate() -> None:
-    # #97 post-review fold (Codex blocker): even if a malformed
+    # Even if a malformed
     # parameterized GateOp reaches a codegen from a non-SLR path
     # (the SLR `__call__` guard above blocks the user-facing route),
     # QIR and QASM must FAIL LOUD on too-few-targets rather than
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
index f6a41223d..8071cc24e 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
@@ -17,8 +17,6 @@
 - `BlockCall` lowers to `array(...)` pack + call + unpack
 - `LIVE_PRESERVED` inputs leave outer-scope slots in the LIVE state post-call
 - `CONSUMED` inputs leave outer-scope slots in the CONSUMED state post-call
-
-See `~/Repos/pecos-docs/design/slr/v2-blockcall-resource-effects.md`.
 """
 
 from __future__ import annotations
@@ -2146,8 +2144,7 @@ class TestScratchEffectS1:
     S1 does NOT lower scratch in Guppy (that is S2); until then Guppy must
     reject a SCRATCH input loudly (no silent fallback). Flatten/QASM
     already works because the scratch param substitutes to the outer slot
-    exactly like any per-slot input. Design:
-    ~/Repos/pecos-docs/design/slr/v2-scratch-ancilla-effect.md.
+    exactly like any per-slot input.
     """
 
     @staticmethod
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_prep_gates.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_prep_gates.py
index 9582ac337..a43be2b6b 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_prep_gates.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_prep_gates.py
@@ -9,7 +9,7 @@
 # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 # specific language governing permissions and limitations under the License.
 
-"""#81 dedicated prep gates -- BEHAVIORAL suite.
+"""Dedicated prep gates -- BEHAVIORAL suite.
 
 The 6 dedicated prep gates `PZ/PNZ/PX/PNX/PY/PNY` (basis is the gate
 IDENTITY, not a string arg) lower to a Z-reset + a fixed Clifford
@@ -21,7 +21,7 @@
       deterministic; assert the fixed bit over shots.
   (c) emitted-tail spot-check (QIR/QASM/QuantumCircuit) -- the
       distinguishing Clifford tail is present per the pinned table.
-  (d) B1 (#81 soundness-critical): a non-PZ prep inside a
+  (d) Soundness-critical: a non-PZ prep inside a
       BlockDecl invoked via BlockCall survives `flatten_block_calls`
       with its basis intact (QASM AND Guppy).
   (e) simulator: the Pn->PN-renamed entry points + human aliases
@@ -127,7 +127,7 @@ def test_prep_gate_emitted_tail(gate: str, needles: dict[str, list[str]]) -> Non
 
 
 def test_b1_blockcall_preserves_prep_basis() -> None:
-    """(d) #81 soundness-critical: a non-PZ prep inside a
+    """(d) Soundness-critical: a non-PZ prep inside a
     BlockDecl invoked via BlockCall must keep its basis through
     `flatten_block_calls` -- in QASM AND Guppy. PX = |0> reset + H;
     if the basis were dropped to PZ the H tail would vanish."""
@@ -184,7 +184,7 @@ def __init__(self, q: QReg) -> None:
 @pytest.mark.parametrize(
     ("entry", "meas", "expected"),
     [
-        # Direct canonical keys (#81: all 6 must dispatch
+        # Direct canonical keys (all 6 must dispatch
         # directly, not only via aliases).
         ("PZ", "MZ", 0),
         ("PNZ", "MZ", 1),
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
index 93016e823..06083fcf4 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
@@ -785,19 +785,19 @@ class TestCrossCodegenPrintEmission:
     - **QASM**: emits `// Print result.debug c` as a comment line; output is
       *not* byte-identical (intentional, per the doc's "comment-only across
       non-Guppy" plan).
-    - **QIR**: #74 -- the QIR backend now **fails loud** on `Print`
+    - **QIR**: the QIR backend now **fails loud** on `Print`
       (`NotImplementedError`) instead of silently dropping it. Silently
       losing observable output is a miscompile qir-qis cannot catch; the
       bounded fix is to raise, not emit. (Real `Print`->record_output is
       deferred, like real `While`.)
-    - **Stim**, **QuantumCircuit**: #78 -- now also **fail loud** on
+    - **Stim**, **QuantumCircuit**: now also **fail loud** on
       `Print` (`NotImplementedError`), the same silent-drop class as
-      #74's QIR Print, applied per the explicit-over-implicit rule.
+      the QIR Print, applied per the explicit-over-implicit rule.
       Stim's is fundamental ("does not support" -- Stim has no
       classical-output stream); QuantumCircuit's is "does not yet
       support" (PECOS owns that format, so it may be added later).
       Was a deliberately-pinned silent skip; flipped here exactly as
-      #74 flipped `test_qir_byte_identical` -> `..._raises_loud`.
+      the QIR Print flipped `test_qir_byte_identical` -> `..._raises_loud`.
 
     These tests pin all four behaviors. If any backend stops
     raising / starts emitting, or QASM stops the comment, this catches
@@ -844,7 +844,7 @@ def test_qasm_emits_print_as_exactly_one_comment_line(self) -> None:
         assert added_lines == [expected_added], f"expected exactly [{expected_added!r}] added lines, got {added_lines}"
 
     def test_qir_raises_loud_on_print(self) -> None:
-        """#74: QIR must FAIL LOUD on Print, not silently drop it.
+        """QIR must FAIL LOUD on Print, not silently drop it.
 
         The no-Print program still builds; adding Print makes `.qir()`
         raise `NotImplementedError` (a silent drop would lose observable
@@ -855,14 +855,14 @@ def test_qir_raises_loud_on_print(self) -> None:
             SlrConverter(self._bell_with_print()).qir()
 
     def test_stim_raises_loud_on_print(self) -> None:
-        """#78: Stim must FAIL LOUD on Print (no classical-output
+        """Stim must FAIL LOUD on Print (no classical-output
         stream), not silently drop it. No-Print still converts."""
         SlrConverter(self._bell_no_print()).stim()  # no Print: fine
         with pytest.raises(NotImplementedError, match=r"does not support Print"):
             SlrConverter(self._bell_with_print()).stim()
 
     def test_quantum_circuit_raises_loud_on_print(self) -> None:
-        """#78: QuantumCircuit must FAIL LOUD on Print (not yet
+        """QuantumCircuit must FAIL LOUD on Print (not yet
         implemented -- may be added since PECOS owns this format), not
         silently drop it. No-Print still converts."""
         SlrConverter(self._bell_no_print()).quantum_circuit()  # no Print: fine
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qeclib_selene_corpus.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qeclib_selene_corpus.py
index 578a81a4e..400a9c7d3 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qeclib_selene_corpus.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qeclib_selene_corpus.py
@@ -11,7 +11,7 @@
 
 """qeclib Selene roundtrip corpus (Phase 3a.0 + 3a.3 byte-identity safety net).
 
-Per `~/Repos/pecos-docs/design/slr/v2-blockcall-resource-effects.md`, this
+This
 corpus pins per-shot measurement records under fixed seed for each tracked
 qeclib Block class. Each entry was first pinned **pre-conversion** (when
 the Block was still flattened) and remained byte-identical **post-conversion**
@@ -36,8 +36,8 @@
 real BlockCall lowering path.
 
 Pattern B Blocks (Steane preps, surface_std_pz, color488 syn
-extraction) currently fail v1 compile and are v2-defer-XFAIL in the
-audit manifest; they'll join this corpus in later Phase 3a.3
+extraction) currently fail v1 compile and are deferred-XFAIL in the
+audit manifest; they'll join this corpus in later
 iterations once the shape-gap expansions (single-qubit input,
 single-bit input with write-back, list[Qubit] bundles,
 PRODUCED/DROPPED effects) land.
@@ -53,8 +53,6 @@
 | Steane X/Y/Z | qeclib/steane/gates_sq/paulis.py | single register: live_preserved (converted iter 3) |
 | Steane H | qeclib/steane/gates_sq/hadamards.py | single register: live_preserved (converted iter 4) |
 
-The audit log lives in
-`~/Repos/pecos-docs/design/slr/v2-blockcall-resource-effects.md`.
 """
 
 from __future__ import annotations
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
index 04968f927..b15109899 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
@@ -9,19 +9,18 @@
 # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 # specific language governing permissions and limitations under the License.
 
-"""#79 corpus-wide EXECUTABLE QIR validation (generalises #77 Layer D).
+"""Corpus-wide EXECUTABLE QIR validation.
 
-For every audit-corpus program `qir_to_qis` accepts (the #71
+For every audit-corpus program `qir_to_qis` accepts (the
 `_qir_state()` QIS_OK set), actually EXECUTE the lowered QIS
 (`SlrConverter(prog).qir_bc() -> qir_qis.qir_to_qis ->
-selene_sim.build(BitcodeString) -> run_shots(Stim)`, via the
-#77-proven `_qis_exec_records`) and assert the EXECUTED classical
+selene_sim.build(BitcodeString) -> run_shots(Stim)`, via
+`_qis_exec_records`) and assert the EXECUTED classical
 records -- not merely "qir_to_qis accepts". This is the end-to-end
-proof of the B2 M-B2-static lowering + #74/#78/#87(Permute)/#88A
-fail-loud line, at corpus scale.
+proof of the static CReg lowering + the fail-loud line
+(While/Print/Permute/unsupported-gate), at corpus scale.
 
-THE HARD PART IS THE ORACLE (per the scoped plan + dual
-#79 design + dual review). Every QIS_OK program
+THE HARD PART IS THE ORACLE. Every QIS_OK program
 is assigned a validation CLASS in `_MANIFEST`, derived from first
 principles (reading the circuit) and CONFIRMED -- never
 reverse-fitted -- by execution:
@@ -39,25 +38,25 @@
   CReg), or a single unconstrained random bit / fully
   unconstrained register / no sound first-principles invariant.
   Documented per program; X with output still gets the
-  record-shape contract (#79 design blocker 1).
+  record-shape contract.
 
-Drift safety (#79 design item 4): the
+Drift safety: the
 candidate set is taken LIVE from `_qir_state()` QIS_OK, and every
 QIS_OK label MUST be in `_MANIFEST` -- a new/changed corpus
 program forces a classification decision (no silent gap), and the
-executable set cannot drift from the #71 structural gate.
+executable set cannot drift from the structural gate.
 
-n_qubits derivation (#79 design blocker 3): from the QIR
+n_qubits derivation: from the QIR
 `required_num_qubits` entry attribute -- NOT a max-operand-
 reference count (that is 0 for no-op QReg programs and panics
 selene with "No more qubits available to allocate").
 
-#79 design blockers 1 (inline/Return-only CReg output loss) and 2
-(non-Z `Prep` silently Z-reset) were RESOLVED upstream by #80
-(inline CReg fails loud -> BUILD_FAILED, out of QIS_OK) and #81
-(dedicated `PX`/etc with correct reset+Clifford-tail lowering);
+Two earlier failure modes -- inline/Return-only CReg output loss
+and non-Z `Prep` silently Z-reset -- were RESOLVED upstream
+(inline CReg fails loud -> BUILD_FAILED, out of QIS_OK; dedicated
+`PX`/etc with correct reset+Clifford-tail lowering);
 the prep cases are reclassified here from first principles under
-the CORRECT #81 semantics (`docs.prep_basis_x` is `PX`=|+>, a
+the CORRECT semantics (`docs.prep_basis_x` is `PX`=|+>, a
 single uniform Z-measure bit -> **X**, NOT an earlier
 deterministic `[0]` which assumed the old broken Z-reset).
 
@@ -90,7 +89,7 @@
 def _required_num_qubits(prog: Main) -> int:
     """n_qubits from the QIR `required_num_qubits` entry attr.
 
-    #79 design blocker 3: a max-operand-reference count
+    A max-operand-reference count
     is 0 for no-op QReg programs (e.g. surface_patch_builder_empty)
     and panics selene. The entry attr is the AST root-allocator
     capacity the backend pins, which is correct for every program.
@@ -184,7 +183,7 @@ def _partial_consumption(obs: set[tuple[int, ...]]) -> None:
 def _high_bits_zero_1(obs: set[tuple[int, ...]]) -> None:
     """docs.for_static_indexing: H unrolled 3x on q[0] (= H) ->
     q[0] random; q[1]=q[2]=|0>. 3-bit CReg -> record in {0,1}
-    (bits 1,2 provably 0 == the #74 static-For body actually
+    (bits 1,2 provably 0 == the static-For body actually
     unrolled and touched only q[0]); both 0 and 1 occur."""
     assert obs <= {(0,), (1,)}, f"a high bit set -> static-For body wrong: {obs}"
     assert obs == {(0,), (1,)}, f"q[0] randomness not exercised: {obs}"
@@ -253,12 +252,12 @@ def _high_bits_zero_1(obs: set[tuple[int, ...]]) -> None:
         "independent decoder oracle; asserting one would ship false "
         "confidence and reverse-fitting is the forbidden anti-pattern",
     ),
-    # #93 cont.: newly QIS_OK after the verified CY decomposition.
+    # Newly QIS_OK after the verified CY decomposition.
     # Both run the "XYZ" stabiliser check (X-Y-Z product) on |0..0>;
     # |0..0> is NOT an eigenstate of X_0 . Y_1 . Z_2 (only of
     # Z_0 . Z_1 . Z_2), so the recorded syndrome bit is uniformly
-    # random -- no deterministic value or hard invariant for #79.
-    # (Pickle's pre-CY classification as D `[0]` was correct only
+    # random -- no deterministic value or hard invariant.
+    # (The pre-CY classification as D `[0]` was correct only
     # under the silent-CY-drop miscompile; with the real CY lowering
     # in place, the honest class is X.)
     "qeclib.generic_check_xyz": (
@@ -283,7 +282,7 @@ def _qis_ok_labels() -> list[str]:
 def test_qir_corpus_manifest_covers_qis_ok() -> None:
     """Drift guard: every live QIS_OK label has a manifest class.
 
-    Ties the executable set to the #71 `_qir_state()` QIS_OK so a
+    Ties the executable set to the `_qir_state()` QIS_OK so a
     new/changed corpus program (or a QIS_OK drift from a codegen
     change) forces a classification decision -- it cannot be
     silently skipped. Also pins the class histogram so a
@@ -304,7 +303,7 @@ def test_qir_corpus_manifest_covers_qis_ok() -> None:
 # record-shape contract is waived: there is no Stim record to
 # inspect. Their gate semantics are covered elsewhere (e.g. the
 # Guppy Quest-backed behavioral suite). This is the Stim-only
-# boundary of the #79 executable corpus, made explicit.
+# boundary of the executable corpus, made explicit.
 _NON_CLIFFORD_UNEXECUTABLE_ON_STIM: frozenset[str] = frozenset({"docs.rotation_rx"})
 
 
@@ -317,8 +316,8 @@ def test_qir_corpus_executable(label: str) -> None:
     D: exact record == spec, every shot, every seed.
     P: the hard invariant holds AND is exercised over the fixed
        seed set.
-    X: documented exclusion. Record-shape contract (#79
-       design blocker 1): a program with an explicit
+    X: documented exclusion. Record-shape contract:
+       a program with an explicit
        `Return(CReg)` and a Main-scope CReg `alloca` MUST emit >=1
        executed record -- an explicit-return program that produces
        no record is an output-loss miscompile, NOT a silent X.
@@ -341,8 +340,8 @@ def test_qir_corpus_executable(label: str) -> None:
             # Record-shape contract: X-with-output must still
             # actually produce executable records (the exclusion is
             # "no sound invariant", NOT "no output"). An
-            # explicit-return program emitting nothing would be the
-            # #80-class output-loss miscompile and must fail here.
+            # explicit-return program emitting nothing would be an
+            # output-loss miscompile and must fail here.
             obs = _observed(prog, n_qubits)
             assert obs, f"X-with-record {label!r} produced NO executed record (output-loss miscompile)"
             assert all(len(r) >= 1 for r in obs), f"{label!r} emitted an empty record tuple: {obs}"
@@ -361,9 +360,9 @@ def test_qir_corpus_executable(label: str) -> None:
 @pytest.mark.slow
 @pytest.mark.optional_dependency
 def test_sqrt_clifford_gates_executable() -> None:
-    """#93: the SX/SXdg/SY/SYdg QIR lowering EXECUTES correctly.
+    """The SX/SXdg/SY/SYdg QIR lowering EXECUTES correctly.
 
-    These have no direct QIR primitive; #93 lowers them to a
+    These have no direct QIR primitive; they are lowered to a
     verified executable-Clifford sequence (H;S;H / H;Sdg;H / H;X /
     H;Z -- NOT rx, which silently no-ops on the Stim backend). Pin
     the end-to-end behavioral proof through
@@ -395,10 +394,10 @@ def _run(build):
 @pytest.mark.slow
 @pytest.mark.optional_dependency
 def test_face_clifford_gates_executable() -> None:
-    """#93: the F/Fdg/F4/F4dg QIR lowering EXECUTES correctly.
+    """The F/Fdg/F4/F4dg QIR lowering EXECUTES correctly.
 
     The single-qubit Clifford "face" rotations have no direct QIR
-    primitive; #93 lowers them to executable-Clifford sequences
+    primitive; they are lowered to executable-Clifford sequences
     (F=Sdg;H, Fdg=H;S, F4=H;Sdg, F4dg=S;H -- circuit order),
     verified equal up to a global phase to the PECOS StateVec
     unitary. Pin the end-to-end behavioral proof through
@@ -433,9 +432,9 @@ def _run(build):
 @pytest.mark.slow
 @pytest.mark.optional_dependency
 def test_sqrt_pauli_2q_gates_executable() -> None:
-    """#93 cont.: SZZ/SZZdg/SXX/SXXdg/SYY/SYYdg/CY EXECUTE correctly.
+    """SZZ/SZZdg/SXX/SXXdg/SYY/SYYdg/CY EXECUTE correctly.
 
-    These have no direct qir-qis primitive; #93 lowers them to
+    These have no direct qir-qis primitive; they are lowered to
     decompositions over the qir-qis ALLOWED set (verified up-to-phase
     against the PECOS StateVec unitary). Pin the end-to-end
     behavioural proof through QIR -> qir_to_qis -> selene with
@@ -503,9 +502,9 @@ def _run(prep, ops, meas_idx=0):
 @pytest.mark.slow
 @pytest.mark.optional_dependency
 def test_ch_executable() -> None:
-    """#93 cont.: CH (controlled-Hadamard) EXECUTES correctly.
+    """CH (controlled-Hadamard) EXECUTES correctly.
 
-    CH has no direct qir-qis primitive; #93 lowers it to the 2q-
+    CH has no direct qir-qis primitive; it is lowered to the 2q-
     minimal 1-CX decomposition (I_c x Ry(-pi/4)_t) . CX . (I_c x
     Ry(pi/4)_t) -- verified up-to-phase against the PECOS oracle
     `gate_matrix_def.CH()` (max_err 3e-14), and exactly equal to
@@ -572,7 +571,7 @@ def _run(prep, ops, meas_idx=0):
 @pytest.mark.slow
 @pytest.mark.optional_dependency
 def test_controlled_rotations_executable() -> None:
-    """#93 cont.: CRX(theta) / CRY(theta) / CRZ(theta) EXECUTE correctly.
+    """CRX(theta) / CRY(theta) / CRZ(theta) EXECUTE correctly.
 
     All three controlled rotations are non-Clifford for general theta;
     executable verification routes through the Quest statevector
@@ -654,7 +653,7 @@ def _run(prep, ops, meas_idx=0):
     # the control RZ (or change its angle to theta instead of
     # theta/2) survive Tests A/B silently.
     #
-    # The discriminator (per Codex review): prep `|+>` on the
+    # The discriminator: prep `|+>` on the
     # control and an R*(pi)-eigenstate on the target so the
     # CORRECT decomp leaves the control in `|+>`; then H(control)
     # takes `|+>` -> `|0>` deterministically.
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
index fb0ff141b..48959f530 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
@@ -9,7 +9,7 @@
 # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 # specific language governing permissions and limitations under the License.
 
-"""#71 QIR spec-compliance gate over the audit corpus -- post-B2 baseline.
+"""QIR spec-compliance gate over the audit corpus.
 
 Runs Quantinuum's `qir-qis` over `SlrConverter(prog).qir_bc()` for
 every audit-corpus program and pins the *current* two-tier state as
@@ -17,77 +17,78 @@
 what is and is not compliant, so any regression OR further progress
 trips it deliberately.
 
-**Tier 1 -- `validate_qir` (QIR spec metadata): Stage B1 DONE.**
-B1 added the required QIR module metadata (`output_labeling_schema`,
+**Tier 1 -- `validate_qir` (QIR spec metadata).**
+The required QIR module metadata is emitted (`output_labeling_schema`,
 `qir_profiles=adaptive_profile`, the `qir_*_version` / `dynamic_*` /
 `arrays` module flags). Two `validate_qir` failures are pinned
 (`_EXPECTED_VALIDATE_FAILED`), neither a metadata gap:
 `legacy.empty_main` (qir-qis structurally requires the entry
 function to have >=1 qubit; that program has none) and
-`qeclib.steane_pz` (B2 made it *build* -- see below -- and it now
+`qeclib.steane_pz` (it *builds* -- see below -- and now
 reaches the qir-qis call allowlist, which rejects PECOS's
 non-standard `__quantum__qis__barrierN__body`; the barrier-naming
-gap is pre-existing, orthogonal to the CReg model, and intentionally
-out of B2 scope). Tier-1b additionally pins the exact entry attr
+gap is pre-existing and orthogonal to the CReg model). Tier-1b
+additionally pins the exact entry attr
 *values* (qir-qis only checks presence).
 
-**Tier 2 -- `qir_to_qis` (ingestible): Stage B2 DONE.**
-Stage B2 replaced the PECOS-bespoke CReg runtime helpers
-(`create_creg`/`get_creg_bit`/`set_creg_bit`/`get_int_from_creg`/
-`set_creg_to_int`/`mz_to_creg_bit`) with the standard M-B2-static
-model (per-CReg entry-block `alloca [N x i1]` + zeroinitializer;
+**Tier 2 -- `qir_to_qis` (ingestible).**
+The standard static CReg model (per-CReg entry-block
+`alloca [N x i1]` + zeroinitializer;
 `mz__body` -> static `%Result*` -> `read_result` -> `store`;
 point-of-use `gep`+`load`/`store`; `zext`/`shl`/`or` pack ->
-`__quantum__rt__int_record_output`). Every validate-passing program
+`__quantum__rt__int_record_output`) replaced the PECOS-bespoke CReg
+runtime helpers (`create_creg`/`get_creg_bit`/`set_creg_bit`/
+`get_int_from_creg`/`set_creg_to_int`/`mz_to_creg_bit`). Every
+validate-passing program
 (`_EXPECTED_QIS_OK`, n=25) now lowers via `qir_to_qis`; `qis_failed`
 is empty. A NEW qir_to_qis failure -- or a dropped program -- trips
-this deliberately. (`docs.while_loop` was in this set pre-#74 on a
-silently-wrong single-pass approximation; #74 makes the QIR backend
-fail loud on `While`, moving it to the build-failure set below.) (`adaptive_profile` is now genuinely exercised:
-B2 emits `__quantum__rt__read_result` for measurement feedback.)
+this deliberately. (`docs.while_loop` was once in this set on a
+silently-wrong single-pass approximation; the QIR backend now
+fails loud on `While`, moving it to the build-failure set below.)
+(`adaptive_profile` is now genuinely exercised:
+`__quantum__rt__read_result` is emitted for measurement feedback.)
 The deeper *semantic* proof for the load-bearing CReg shapes is
 `test_tier2_semantic.py` (real-compiler acceptance + emitted-QIR
 structural invariants + a deterministic AST->Guppy->Selene
 cross-anchor). The direct `qir_to_qis`->Selene EXECUTABLE
-differential is delivered (#77 Layer D `_qis_exec_records` in
+differential is delivered (`_qis_exec_records` in
 `test_tier2_semantic.py`): `selene_sim` natively runs the LLVM-21
 opaque-pointer QIS bitcode `qir_to_qis` emits, via
 `selene_helios_qis_plugin` -- there is no LLVM-version blocker.
-#79 generalises it corpus-wide; this structural gate provides
-that suite's authoritative QIS_OK set.
+The corpus-wide generalisation lives in the executable suite; this
+structural gate provides that suite's authoritative QIS_OK set.
 
 **Build failures** (4): `qir_bc()` raises for
 `docs.for_loopvar_symbolic` (symbolic `LoopVar` indexing) --
-a pre-existing AST-QIR feature gap; `docs.while_loop` (#74: the QIR backend now fails LOUD
-on `While` instead of silently emitting a one-pass
-approximation that qir-qis cannot catch; this aligns the QIR
-path with the Guppy path, which already rejects `While` per
-v1-feature-matrix "real While is out of scope for the sound
-emitter"); and `docs.inline_measure_creg` /
-`docs.surface_syndrome_block18` (#80: an inline/`Return`-only
-CReg gets no storage, so #80 fails loud instead of silently
-dropping its value -- the silent-output-loss defect #79
+a pre-existing AST-QIR feature gap; `docs.while_loop` (the QIR
+backend now fails LOUD on `While` instead of silently emitting a
+one-pass approximation that qir-qis cannot catch; this aligns the
+QIR path with the Guppy path, which already rejects `While` --
+real While is out of scope for the sound emitter); and
+`docs.inline_measure_creg` /
+`docs.surface_syndrome_block18` (an inline/`Return`-only
+CReg gets no storage, so the backend fails loud instead of silently
+dropping its value -- the silent-output-loss defect this
 surfaced; `surface_syndrome_block18`'s
 `Measure(data) > CReg("final", ...)` is exactly that inline
-CReg, so it still build-fails post-#81 -- pinned honestly on
+CReg, so it still build-fails -- pinned honestly on
 the inline-CReg reason, NOT masked by restructuring the
-factory). `docs.prep_basis_x` MOVED here -> QIS_OK in #81
+factory). `docs.prep_basis_x` MOVED here -> QIS_OK
 (it is now a clean dedicated-gate `PX` program; the old
 non-Z-`Prep` string form is gone -- the prep basis is the
 gate identity). Identity pinned (`_EXPECTED_BUILD_FAILED`)
-so a NEW build regression trips here. (`qeclib.steane_pz` was a pinned
-build failure pre-B2 -- the bespoke model emitted invalid bitcode
-for it; B2 produces valid bitcode so it now builds and moves to
-the pinned validate set above. A deliberate, triaged improvement.)
-#74 also fails loud on `VarExpr` (was silently 0) and `Print`
+so a NEW build regression trips here. (`qeclib.steane_pz` was once a pinned
+build failure -- the bespoke model emitted invalid bitcode
+for it; the static model produces valid bitcode so it now builds and
+moves to the pinned validate set above. A deliberate, triaged improvement.)
+The backend also fails loud on `VarExpr` (was silently 0) and `Print`
 (was silently dropped); no corpus program exercises those, so
 they add no build-failure pin -- but they are no longer silent
-miscompiles. #88A (the broad unsupported-gate class #78
-deferred) makes `_process_gate` fail loud on any gate with no
+miscompiles. `_process_gate` fails loud on any gate with no
 QIR lowering (was a silent drop); subsequent verified lowerings
-move gates *off* fail-loud. #93 cont. added the verified
+move gates *off* fail-loud. The verified
 CY=Sdg;CX;S decomposition (and SZZ/SXX/SYY (+adjoints) via
-RZZ), so the two generic-check factories (use `CY`) moved
+RZZ) moved the two generic-check factories (use `CY`)
 BUILD_FAILED -> QIS_OK (22 -> 24), re-pinned from the actual
 `_qir_state()`.
 
@@ -102,67 +103,67 @@
 
 from .audit_runner import _curated_cases  # noqa: TID252
 
-# Pinned pre-existing `qir_bc()` build failures (NOT #71 metadata;
-# task #74 / audit v2-defer). (exc type, quote-free stable fragment) --
+# Pinned pre-existing `qir_bc()` build failures (not a metadata gap).
+# (exc type, quote-free stable fragment) --
 # LLVM text backslash-escapes embedded quotes, so a quote-bearing
 # fragment would not match; the bare identifier/head is stable.
 _EXPECTED_BUILD_FAILED: dict[str, tuple[str, str]] = {
     "docs.for_loopvar_symbolic": ("AttributeError", "SymbolicQubit"),
-    # #97 (angle-first SLR API): `docs.rotation_rx` was BUILD_FAILED only
+    # Angle-first SLR API: `docs.rotation_rx` was BUILD_FAILED only
     # because the doc-test probe used the malformed `RX(q, 0.5)` form
     # (0.5 treated as a stray qarg). With `RX(theta, q)` the probe is
     # well-formed and `rx` is in the qir-qis allowlist, so it now builds
     # and lowers via qir_to_qis -> moved to _EXPECTED_QIS_OK (re-pinned
     # from the actual `_qir_state()`, never guessed).
-    # #74: the QIR backend now fails LOUD on `While` (was a silent
+    # The QIR backend now fails LOUD on `While` (was a silent
     # single-pass approximation that qir-qis could not catch -- valid
     # QIR, wrong semantics). `docs.while_loop` moved QIS_OK -> here
     # deliberately; this aligns the QIR path with the Guppy path,
-    # which already rejects `While` (v1-feature-matrix: real While is
+    # which already rejects `While` (real While is
     # out of scope for the sound emitter).
     "docs.while_loop": ("NotImplementedError", "does not support While loops"),
-    # #80 inline/Return-only CReg fail-loud (the silent-output-loss
-    # defect #79 surfaced). A CReg used/measured/
+    # Inline/Return-only CReg fail-loud (the silent-output-loss
+    # defect this surfaced). A CReg used/measured/
     # returned but never declared at Main scope gets no
-    # `alloca [N x i1]`; #80 raises instead of silently dropping it.
+    # `alloca [N x i1]`; the backend raises instead of silently dropping it.
     #  - inline_measure_creg: `final` only `Return`ed, never declared.
-    #  - surface_syndrome_block18: #81 Stage D made it a valid
+    #  - surface_syndrome_block18: it is a valid
     #    dedicated-gate (`PX`/`PZ`) program (was non-Z-Prep-fail),
     #    but it still build-fails -- for a DIFFERENT, correct reason:
     #    its `Measure(data) > CReg("final", num_data)` is an inline
-    #    CReg, caught by the SAME #80 guard. Pinned honestly on the
+    #    CReg, caught by the SAME inline-CReg guard. Pinned honestly on the
     #    inline-CReg reason (NOT masked by restructuring the factory
-    #    -- that would defeat #80). `docs.prep_basis_x` moved
+    #    -- that would defeat the guard). `docs.prep_basis_x` moved
     #    BUILD_FAILED -> QIS_OK (now a clean `PX` program; re-pinned
     #    from the actual `_qir_state()`, never guessed).
     "docs.inline_measure_creg": ("NotImplementedError", "was not declared at Main scope"),
     "docs.surface_syndrome_block18": ("NotImplementedError", "was not declared at Main scope"),
-    # #93 cont.: the "XYZ" generic_check programs (use `CY`) were
-    # BUILD_FAILED under #88A on `gate 'CY' has no QIR lowering`. #93
-    # added a verified CY decomposition (CY = Sdg(t); CX; S(t)), so
+    # The "XYZ" generic_check programs (use `CY`) were
+    # BUILD_FAILED on `gate 'CY' has no QIR lowering`. A verified CY
+    # decomposition (CY = Sdg(t); CX; S(t)) was added, so
     # they now build and run -- moved BUILD_FAILED -> QIS_OK
     # (re-pinned from the actual `_qir_state()`, never guessed):
     # BUILD_FAILED 7 -> 5; QIS_OK 22 -> 24.
 }
 
 # Tier 1: the non-metadata `validate_qir` failures (label -> stable,
-# quote-free message fragment) so a NEW validate failure (e.g. a B1
+# quote-free message fragment) so a NEW validate failure (e.g. a
 # metadata regression) trips deliberately. Neither is a metadata gap:
 #  - legacy.empty_main: qir-qis requires the entry fn to have >=1
 #    qubit; this program has none (structural limitation).
-#  - qeclib.steane_pz: B2 made it *build* (the bespoke model emitted
-#    invalid bitcode pre-B2); it now reaches the qir-qis call
-#    allowlist, which rejects PECOS's non-standard
+#  - qeclib.steane_pz: the static CReg model made it *build* (the
+#    bespoke model emitted invalid bitcode); it now reaches the
+#    qir-qis call allowlist, which rejects PECOS's non-standard
 #    `__quantum__qis__barrierN__body`. The barrier-naming gap is
-#    pre-existing and orthogonal to the CReg model -- intentionally
-#    out of B2 scope (bounded; barrier lowering is a separate task).
+#    pre-existing and orthogonal to the CReg model (barrier lowering
+#    is a separate task).
 _EXPECTED_VALIDATE_FAILED: dict[str, str] = {
     "legacy.empty_main": "at least one qubit",
     "qeclib.steane_pz": "Unsupported QIR QIS function",
 }
 
-# Tier 2: post-B2, EVERY validate-passing program lowers via
-# `qir_to_qis` (M-B2-static replaced the bespoke CReg helpers).
+# Tier 2: EVERY validate-passing program lowers via
+# `qir_to_qis` (the static CReg model replaced the bespoke CReg helpers).
 # This is the full set (n=25); `qis_failed` must be empty. A new
 # qir_to_qis failure -- or a dropped/added program -- trips the
 # Tier-2 assertions and must be triaged deliberately.
@@ -170,15 +171,15 @@
     {
         "docs.flat_parallel_h_gates",
         "docs.for_static_indexing",
-        # #81: now a clean dedicated-gate `PX` program (was the
+        # Now a clean dedicated-gate `PX` program (was the
         # non-Z-Prep BUILD_FAILED pin; re-pinned from actual _qir_state).
         "docs.prep_basis_x",
         "docs.repeat_state_preserving",
-        # #97 (angle-first SLR API): `RX(theta, q)` is well-formed and
+        # Angle-first SLR API: `RX(theta, q)` is well-formed and
         # `rx` is qir-qis-allowlisted, so the rotation_rx probe now
         # lowers via qir_to_qis (was BUILD_FAILED on the malformed
         # `RX(q, 0.5)` doc-form). Not end-to-end-executable on Stim
-        # (rx is non-Clifford) -> #79 manifest classifies it X.
+        # (rx is non-Clifford) -> the manifest classifies it X.
         "docs.rotation_rx",
         "examples.measure_register_to_creg",
         "examples.parallel_bell_pairs",
@@ -191,7 +192,7 @@
         "legacy.nested_blocks",
         "legacy.partial_consumption_with_block",
         "qeclib.color488_syn_extract_bare",
-        # #93 cont.: the "XYZ" generic_check programs (use `CY`) now
+        # The "XYZ" generic_check programs (use `CY`) now
         # build via the verified CY=Sdg;CX;S decomposition -- moved
         # _EXPECTED_BUILD_FAILED -> here.
         "qeclib.generic_check_1flag_ch",
@@ -206,13 +207,13 @@
     },
 )
 
-# #71 B1: qir-qis validates the PRESENCE of these
+# qir-qis validates the PRESENCE of these
 # entry attributes but NOT their values, so a value regression (e.g.
 # silently reverting `qir_profiles` to "custom"/"base_profile", or
 # `output_labeling_schema` to something else) would pass both qir-qis
 # AND this gate. Pin the exact values via `get_entry_attributes()`.
 # (`qir_profiles="adaptive_profile"` is a deliberate forward-looking
-# choice for B2 -- which introduces `__quantum__rt__read_result` for
+# choice for the static CReg model -- which introduces `__quantum__rt__read_result` for
 # mid-circuit measurement feedback -- NOT a current-corpus requirement:
 # `base_profile` also passes `validate_qir` today, since the corpus's
 # `If(creg_bit)` lowers to a plain LLVM `br` on a loaded buffer value.)
@@ -272,7 +273,7 @@ def test_audit_corpus_qir_compliance_baseline() -> None:
         qis_ok or qis_failed or validate_failed
     ), f"validate_qir never ran on built QIR; build_failed={sorted(label for label, _, _ in build_failed)}"
 
-    # Pre-existing build-failure set pinned (#71 Stage-A): a
+    # Pre-existing build-failure set pinned: a
     # new build regression -- or a fixed one -- must be triaged
     # deliberately, not silently scoped out.
     got_bf = {label: (etype, emsg) for label, etype, emsg in build_failed}
@@ -286,9 +287,9 @@ def test_audit_corpus_qir_compliance_baseline() -> None:
         assert got_type == exp_type, f"{label}: build-fail exc type {got_type!r}, expected {exp_type!r}"
         assert exp_frag in got_msg, f"{label}: build-fail message lacks {exp_frag!r}: {got_msg[:200]}"
 
-    # Tier 1 -- validate_qir: B1 metadata done. ONLY the pinned
+    # Tier 1 -- validate_qir: metadata done. ONLY the pinned
     # non-metadata structural failure(s) may fail validate_qir; a new
-    # one (e.g. a B1 metadata regression) trips here.
+    # one (e.g. a metadata regression) trips here.
     got_vf = dict(validate_failed)
     assert set(got_vf) == set(_EXPECTED_VALIDATE_FAILED), (
         f"validate_qir failure set changed: got {sorted(got_vf)}, expected "
@@ -298,7 +299,7 @@ def test_audit_corpus_qir_compliance_baseline() -> None:
     for label, frag in _EXPECTED_VALIDATE_FAILED.items():
         assert frag in got_vf[label], f"{label}: validate msg lacks {frag!r}: {got_vf[label][:200]}"
 
-    # Tier 1b -- pin the exact entry-attr VALUES (#71 B1).
+    # Tier 1b -- pin the exact entry-attr VALUES.
     # qir-qis only enforces presence, so a value regression would pass
     # both qir-qis and the presence-only tier-1 check above.
     assert entry_attrs, "no validate-passing cases to check entry-attr values"
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_tier2_semantic.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_tier2_semantic.py
index 528319611..de6a091c3 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_tier2_semantic.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_tier2_semantic.py
@@ -9,7 +9,7 @@
 # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 # specific language governing permissions and limitations under the License.
 
-"""#71 Stage B2 -- semantic assurance for the M-B2-static CReg lowering.
+"""Semantic assurance for the static CReg lowering.
 
 Three independent layers per representative program (the structural
 `test_qir_spec_compliance.py` gate covers the whole corpus; this is the
@@ -18,11 +18,11 @@
   A. **Real-compiler acceptance.** Quantinuum's `qir-qis` (a real
      ~10k-LOC QIR->QIS compiler: type-checking, call allowlist,
      profile + result-slot validation, full QIS lowering) must
-     `validate_qir` AND `qir_to_qis` the B2 QIR. Acceptance by an
+     `validate_qir` AND `qir_to_qis` the emitted QIR. Acceptance by an
      independent production compiler is strong evidence the emitted
      QIR is well-formed and semantically valid.
 
-  B. **Emitted-QIR structural invariants.** The M-B2-static classical
+  B. **Emitted-QIR structural invariants.** The static classical
      model is deterministic bit-shuffling; its correctness is exactly
      checkable on the emitted IR: per-CReg entry-block `alloca [N x
      i1]` + `zeroinitializer` store; measurements use monotonic
@@ -33,18 +33,18 @@
      bespoke `create_creg`/`*_creg_bit`/... runtime helpers remain.
 
   C. **Independent executable cross-anchor.** The SAME SLR programs
-     run through the dual-reviewed AST->Guppy->Selene path
+     run through the AST->Guppy->Selene path
      (`run_ast_guppy_via_selene`); for the deterministic programs the
-     exact classical outcome is asserted. The B2 QIR is a
+     exact classical outcome is asserted. The emitted QIR is a
      deterministic sibling lowering (proven structurally in B) of the
      same AST whose classical semantics C executes.
 
-  D. **Executable differential (#77).** `selene_sim` natively
+  D. **Executable differential.** `selene_sim` natively
      executes `qir_qis.qir_to_qis`'s LLVM-21 opaque-pointer QIS
      bitcode via the bundled `selene_helios_qis_plugin` (+ Helios
      QIR runtime) -- `selene_sim.build(BitcodeString(...)) ->
      run_shots(Stim)`. So the direct `qir_to_qis -> Selene`
-     differential the #71/B2 saga long claimed "blocked" (an
+     differential long claimed "blocked" (an
      alleged LLVM 14<->21 / opaque-vs-typed bridge) is in fact
      available with zero PECOS LLVM work: PECOS-Rust stays LLVM-14;
      the LLVM-21 capability lives entirely in the qir-qis +
@@ -329,7 +329,7 @@ def run() -> int:
 
 def test_oversize_creg_raises_loud() -> None:
     """A >64-bit CReg must FAIL LOUD at QIR codegen, not silently drop
-    its storage/output (#76 B2). 64 is the cap
+    its storage/output. 64 is the cap
     (single-i64 record pack); 65 must raise a clear error."""
     ok = Main(q := QReg("q", 1), c := CReg("c", 64), Measure(q[0]) > c[0], Return(c))
     SlrConverter(ok).qir_bc()  # 64 is allowed (boundary)
@@ -340,10 +340,10 @@ def test_oversize_creg_raises_loud() -> None:
 
 
 def test_while_raises_loud() -> None:
-    """#74: the QIR backend must FAIL LOUD on `While`, not silently
+    """The QIR backend must FAIL LOUD on `While`, not silently
     emit a one-pass approximation (qir-qis cannot catch that -- one
     pass is valid QIR, wrong semantics). Aligns with the Guppy path,
-    which already rejects `While` (v1-feature-matrix: real While is
+    which already rejects `While` (real While is
     out of scope for the sound emitter)."""
     prog = Main(
         q := QReg("q", 1),
@@ -356,7 +356,7 @@ def test_while_raises_loud() -> None:
 
 
 def test_print_raises_loud() -> None:
-    """#74: the QIR backend must FAIL LOUD on `Print`, not silently
+    """The QIR backend must FAIL LOUD on `Print`, not silently
     drop it (silently losing observable program output)."""
     prog = Main(
         q := QReg("q", 1),
@@ -370,11 +370,11 @@ def test_print_raises_loud() -> None:
 
 
 def test_static_for_unrolls_body_not_dropped() -> None:
-    """#74: a static `For` must UNROLL its body, not silently
+    """A static `For` must UNROLL its body, not silently
     drop it. The old `_process_for` guard `isinstance(node.start, int)`
     was always false (the converter wraps bounds in `LiteralExpr`), so
     every `For` body was silently dropped -- valid QIR, wrong
-    semantics, qir-qis-uncatchable (the exact bug class #74 targets)."""
+    semantics, qir-qis-uncatchable (the exact bug class this targets)."""
     prog = Main(
         q := QReg("q", 1),
         c := CReg("c", 1),
@@ -393,27 +393,27 @@ def test_static_for_unrolls_body_not_dropped() -> None:
 
 
 def test_varexpr_raises_loud() -> None:
-    """#74/B1: a classical `VarExpr` whose name is not a declared
+    """A classical `VarExpr` whose name is not a declared
     Main-scope CReg must FAIL LOUD, not silently evaluate to constant
-    0 (a value miscompile qir-qis cannot catch). B1 changed the
-    VarExpr arm from an unconditional fail-loud to "pack the CReg
-    via `_pack_creg` if known, fail loud via `_require_creg`
-    otherwise". The stray-name path still fails loud, just with the
+    0 (a value miscompile qir-qis cannot catch). The
+    VarExpr arm packs the CReg
+    via `_pack_creg` if known and fails loud via `_require_creg`
+    otherwise. The stray-name path still fails loud, just with the
     `_require_creg` "not declared at Main scope" message (the
-    anti-silent-0 invariant the #74 test pins is preserved)."""
+    anti-silent-0 invariant is preserved)."""
     with pytest.raises(NotImplementedError, match=r"classical register 'x'.*not.*declared at Main scope"):
         AstToQir()._eval_expression(VarExpr(name="x"))  # noqa: SLF001
 
 
 def test_inline_returned_creg_raises_loud() -> None:
-    """#80: a CReg that is measured/returned but NOT declared at Main
+    """A CReg that is measured/returned but NOT declared at Main
     scope must FAIL LOUD. Only Main-scope CRegs get an entry-block
     `alloca [N x i1]`; an inline/local CReg surfaced only via
     `Return(creg)` had no storage, so the measure-store was SILENTLY
     skipped and the explicit returned value vanished from the QIS
-    records (the `docs.inline_measure_creg` defect #79 surfaced --
+    records (the `docs.inline_measure_creg` defect surfaced --
     QIS recorded `[]` for an explicit `Return(final)`). Mirrors the
-    #74/#78 doctrine: silent miscompile -> loud NotImplementedError."""
+    fail-loud doctrine: silent miscompile -> loud NotImplementedError."""
     final = CReg("final", 2)
     prog = Main(q := QReg("q", 2), Measure(q) > final, Return(final))
     with pytest.raises(NotImplementedError, match=r"classical register 'final'.*not.*declared at Main scope"):
@@ -421,14 +421,14 @@ def test_inline_returned_creg_raises_loud() -> None:
 
 
 def test_prep_stray_string_arg_raises_loud() -> None:
-    """#80 recast under #81: the prep basis is the GATE IDENTITY
+    """The prep basis is the GATE IDENTITY
     (`PZ`/`PNZ`/`PX`/`PNX`/`PY`/`PNY`), not a string argument.
     `_expand_qubit_args` silently drops a string qarg, so a basis
     string on ANY prep gate -- the legacy `PZ(q, "X")`, or
     `PZ(q, "X")`, even `PZ(q, "Z")` -- would be silently dropped
-    and lowered as the plain basis (a miscompile, #80/#79). The
+    and lowered as the plain basis (a miscompile). The
     converter rejects ANY stray string qarg on EVERY prep gate
-    (#81 sym rule). A bare prep gate (no string) is fine."""
+    (the prep-basis symmetry rule). A bare prep gate (no string) is fine."""
     # No-string preps build (PZ default; dedicated gate identity).
     # No-string prep on every dedicated gate builds (basis = identity).
     for prep in (qb.PZ, qb.PNZ, qb.PX, qb.PNX, qb.PY, qb.PNY):
@@ -451,7 +451,7 @@ def test_prep_stray_string_arg_raises_loud() -> None:
 
 
 def test_return_only_inline_creg_raises_loud() -> None:
-    """#80: a CReg surfaced ONLY via
+    """A CReg surfaced ONLY via
     `Return(creg)` -- never measured/assigned/read -- reached no
     point-of-use `_require_creg` site, so `_generate_results` (which
     records only Main-declared CRegs) emitted ZERO recorded output
@@ -474,7 +474,7 @@ def test_return_only_inline_creg_raises_loud() -> None:
     ok_q = Main(q := QReg("q", 1), Return(q))
     SlrConverter(ok_q).qir_bc()
 
-    # #80: an inline CReg whose name
+    # An inline CReg whose name
     # collides with a declared QReg was misclassified as a qubit
     # return by the old name-membership skip and silently dropped
     # (same silent-output-loss class, reachable via public SLR).
@@ -493,7 +493,7 @@ def _qis_exec_records(
     seed: int = _SEED,
     simulator_factory: Callable[[int], object] | None = None,
 ) -> list[list[int]]:
-    """#77 Layer D -- the real EXECUTABLE differential.
+    """The real EXECUTABLE differential.
 
     `AST QIR -> qir_qis.qir_to_qis` (LLVM-21 QIS bitcode) ->
     `selene_sim.build` (selene ingests it natively via
@@ -501,9 +501,9 @@ def _qis_exec_records(
     14<->21 bridge" was false) -> run on the selected backend.
     Returns per-shot lists of the recorded
     `__quantum__rt__int_record_output` *values*, in call order ==
-    CReg *declaration* order (B2 `_generate_results` records every
+    CReg *declaration* order (`_generate_results` records every
     declared CReg; the QIS tag is empty post-qir_to_qis so order is
-    the key). This is the executable proof that the B2 QIR, lowered
+    the key). This is the executable proof that the emitted QIR, lowered
     by the real Quantinuum compiler and run, computes the correct
     classical results -- upgrading A+B+C to A+B+C+D.
 
@@ -523,11 +523,11 @@ def _qis_exec_records(
 
 @pytest.mark.slow
 def test_tier2_executable_differential() -> None:
-    """#77: deterministic representative programs must EXECUTE through
+    """Deterministic representative programs must EXECUTE through
     QIR -> qir_to_qis -> QIS -> selene to the exact known classical
     record (records are all declared CRegs, declaration order, packed
     LSB-first -- empirically pinned). Oracle-independent: this is the
-    real executable equivalence the #71/B2 saga substituted A+B+C for.
+    real executable equivalence that A+B+C otherwise substituted for.
     """
     cases: list[tuple[str, Main, int, list[int]]] = [
         # c.set(0b1011); Return(c) -> [11] every shot
@@ -553,7 +553,7 @@ def test_tier2_executable_differential() -> None:
     # Bell: genuinely quantum -> property check, not a fixed value.
     # NECESSARY: every shot records c[0]==c[1] (single record, packed
     # in {0b00, 0b11}, never 1/2) -- a broken/decorrelating CX trips
-    # this. SUFFICIENT (#77): the aggregate over fixed
+    # this. SUFFICIENT: the aggregate over fixed
     # seeds must contain BOTH 0b00 AND 0b11 -- a dropped H / dropped
     # CX / no-op Bell lowering yields all-0, which a subset-only check
     # (`in {0,3}`) would wrongly pass. Fixed seeds -> deterministic;
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_typed_angles.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_typed_angles.py
index 6b449c643..70dd00a22 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_typed_angles.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_typed_angles.py
@@ -94,7 +94,7 @@ def test_bare_float_rejected_but_typed_angle_accepted() -> None:
 
 
 def test_construction_arity_guard() -> None:
-    # Codex blocker 1: a parameterized call with too few qubits must fail
+    # A parameterized call with too few qubits must fail
     # at construction, not survive to codegen.
     q = QReg("q", 2)
     with pytest.raises(TypeError, match="needs at least one qubit"):
@@ -110,7 +110,7 @@ def test_construction_arity_guard() -> None:
 
 
 def test_direct_ast_float_param_rejected_uniformly_across_backends() -> None:
-    # Codex blocker 2: a malformed direct-AST GateOp carrying a bare-float
+    # A malformed direct-AST GateOp carrying a bare-float
     # angle (bypassing the SLR call guard) must fail loud in EVERY backend,
     # not just Guppy -- the backends must not diverge.
     from dataclasses import replace
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_acceptance.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_acceptance.py
index 707e18a72..896dff66f 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_acceptance.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_acceptance.py
@@ -4,15 +4,11 @@
 marked `xfail(strict=True)` until the emitter rewrite lands the
 corresponding feature; xfail comes off as features ship.
 
-Source matrix:
-    ~/Repos/pecos-docs/design/slr/v1-feature-matrix.md
-    ~/Repos/pecos-docs/design/slr/stage5-integrity-review.md (findings 5, 6)
-
-Test layout follows the "practical v1 acceptance set" plus the
-coverage gaps surfaced in stage 5 (final-root-return, static For,
+Test layout follows the practical v1 acceptance set plus the
+coverage gaps for final-root-return, static For,
 Parallel, PZ-after-measure, mixed Permute, gates beyond CX,
-SZ/SZdg mapping, measurement-without-output, targeted unsupported
-errors).
+SZ/SZdg mapping, measurement-without-output, and targeted unsupported
+errors.
 """
 
 from __future__ import annotations
@@ -233,10 +229,7 @@ def test_final_root_return_qubit_array(self) -> None:
 
 
 # Rejection tests for divergent control flow + unsupported gates land
-# in a follow-up PR once the emitter has a specific `LinearityError`
+# in a follow-up once the emitter has a specific `LinearityError`
 # (or analogous typed error) to assert against. Asserting `Exception`
 # today would silently pass on the AST path's pre-existing breakage --
-# a fallback the design philosophy explicitly disallows. See:
-#   ~/Repos/pecos-docs/design/slr/stage5-integrity-review.md (finding 6)
-#   ~/Repos/pecos-docs/design/slr/v1-feature-matrix.md ("Explicitly
-#       unsupported in v1" table)
+# a fallback the design philosophy explicitly disallows.
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py
index 098e2eb06..a28d2a683 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_v1_behavioral.py
@@ -311,20 +311,20 @@ def test_creg_permute_remaps_condition_bit(self) -> None:
 
 
 class TestS5SteanePzBehavioral:
-    """Steane pz() prepares a valid logical |0> (S5 + #72 lock-in).
+    """Steane pz() prepares a valid logical |0>.
 
     `Main(c := Steane("c"), c.pz())` has no user Return -> main() -> None;
-    the flattened PrepRUS block-boundary Returns are elided at convert time
-    (S5/M2). The companion adds an explicit Measure(c.d)+Return so Selene
+    the flattened PrepRUS block-boundary Returns are elided at convert time.
+    The companion adds an explicit Measure(c.d)+Return so Selene
     yields the 7-bit data record; every shot must satisfy the Steane Z-check
     syndrome == (0, 0, 0) (codespace membership = a real logical-|0>
     lock-in, not "deterministic bits").
 
     Previously a strict xfail under a wrong diagnosis ("v1 FT-RUS pz()
-    non-codeword"). #72 re-diagnosed: pz() is correct (stim-verified); the
+    non-codeword"). Re-diagnosed: pz() is correct (stim-verified); the
     failure was `_selene_harness` mis-mapping `measurement_N` because the
     Steane RUS performs an internal (non-returned) verify measurement. With
-    #72's named return-tag mapping the harness reads the returned data CReg
+    named return-tag mapping the harness reads the returned data CReg
     by name, so this now passes.
     """
 
@@ -347,11 +347,11 @@ def test_steane_pz_prepares_logical_zero(self) -> None:
 
 
 class TestHarnessInternalMeasurementMapping:
-    """#72 regression: an internal (non-returned) measurement before the
+    """Regression: an internal (non-returned) measurement before the
     returned data must not shift the public `measurement_N` mapping.
 
     `internal` is measured (q[0], forced to 1) but NOT returned; `out`
-    (q[1], stays 0) IS returned. Pre-#72 the harness counted positionally
+    (q[1], stays 0) IS returned. Previously the harness counted positionally
     and read `measurement_0` = the internal measurement (=1) -> wrong.
     With named return tags it reads `out` by name -> 0 every shot.
     """
diff --git a/python/quantum-pecos/tests/slr_tests/guppy/test_array_patterns.py b/python/quantum-pecos/tests/slr_tests/guppy/test_array_patterns.py
index d770b5f2e..893040b24 100644
--- a/python/quantum-pecos/tests/slr_tests/guppy/test_array_patterns.py
+++ b/python/quantum-pecos/tests/slr_tests/guppy/test_array_patterns.py
@@ -21,7 +21,7 @@ class TestArrayUnpacking:
 
     @pytest.mark.optional_dependency
     def test_unique_unpacked_names(self) -> None:
-        """#88B fix: slot-locals are disambiguated against declared register names.
+        """Slot-locals are disambiguated against declared register names.
 
         Before the fix, the Guppy emitter's slot-local formula
         `f"{allocator}_{index}"` would generate `q_0` for `q[0]`, which
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py b/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py
index 4f40e1b35..bfc44825f 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py
@@ -99,10 +99,10 @@ def test_qir_creg_size_too_large() -> None:
         Return(m),
     )
 
-    # #76/#80: the M-B2-static classical model packs each CReg into a
+    # The static classical model packs each CReg into a
     # single i64 (`__quantum__rt__int_record_output`), so a >64-bit
     # CReg fails LOUD with NotImplementedError (was the older
-    # ValueError message; updated to the current #76/#80 guard).
+    # ValueError message; updated to the current guard).
     with pytest.raises(NotImplementedError, match=re.escape("has 75 bits")):
         SlrConverter(prog).qir()
 
@@ -140,10 +140,10 @@ def test_control_flow_qir() -> None:
         p.Measure(q) > m,
         Return(m),
     )
-    # B1: whole-CReg scalar conditions (`If(m == 0)` / `If(m <
+    # Whole-CReg scalar conditions (`If(m == 0)` / `If(m <
     # m_hidden)`) are now lowered via `_pack_creg` + `_op_map`; the
     # QIR builds. CAVEAT: the `RX(rad(0.3), q)` rotations DO build + lower
-    # (#97 angle-first API; `rx` is qir-qis-allowlisted), but rx(0.3)
+    # (angle-first API; `rx` is qir-qis-allowlisted), but rx(0.3)
     # is NON-CLIFFORD so the program cannot execute on the Stim
     # backend -- it is build-/lower-only here, NOT end-to-end. (The
     # angle-first-executable rotation path is covered by the Guppy
@@ -257,13 +257,13 @@ def test_steane_qir_bc() -> None:
 def test_sx_sxdg() -> None:
     """SX/SXdg lower to a verified executable-Clifford sequence.
 
-    #93: SX/SXdg have no direct QIR primitive but ARE Clifford
+    SX/SXdg have no direct QIR primitive but ARE Clifford
     sqrt-X gates. They lower to `H;S;H` / `H;Sdg;H` (executable
     Clifford only -- NOT rx, which is a pinned build/exec failure
     and would silently no-op on the Stim backend). The sequence was
     verified equal up to a global phase to the PECOS `StateVec`
-    simulator's unitary AND end-to-end via the #79 executable path
-    (SX;SX == X, SXdg;SX == I). (#88A's earlier fail-loud was the
+    simulator's unitary AND end-to-end via the executable path
+    (SX;SX == X, SXdg;SX == I). (The earlier fail-loud was the
     correct interim until this verified lowering landed.)
     """
     prog: Main = Main(
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_basic_permutation.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_basic_permutation.py
index f821b0a97..0c046dfb9 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_basic_permutation.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_basic_permutation.py
@@ -151,10 +151,10 @@ def test_same_register_permutation_qasm(
 # QIR Tests
 
 
-# #87a: a Permute is realized as a static logical relabel consulted at
+# A Permute is realized as a static logical relabel consulted at
 # every classical-bit lowering (mirroring the Guppy linearity
 # tracker's `.permute()`). The bespoke @set_creg_bit helpers the old
-# tests pinned were removed by #76-B2; bit writes are now `store i1`
+# tests pinned were removed by the static CReg model; bit writes are now `store i1`
 # into the relabelled register's `[N x i1]` buffer.
 
 
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_complex_permutation.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_complex_permutation.py
index c98d58415..1744823d7 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_complex_permutation.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_complex_permutation.py
@@ -121,7 +121,7 @@ def test_permutation_with_conditional_qasm() -> None:
 # QIR Tests
 
 
-# #87a: a Permute is realized as a static logical relabel consulted at
+# A Permute is realized as a static logical relabel consulted at
 # every qubit/classical-bit lowering (mirroring the Guppy linearity
 # tracker's `.permute()`; QIR/Selene have no runtime permute
 # intrinsic). These pin the realized targeting from the actual
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_creg_permutation.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_creg_permutation.py
index 6d9f1f6f3..53cd8fef8 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_creg_permutation.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_creg_permutation.py
@@ -56,12 +56,12 @@ def test_creg_permutation_qasm() -> None:
 
 @pytest.mark.optional_dependency
 def test_creg_permutation_qir() -> None:
-    """Whole-register CReg Permute IS realized in QIR (M-B2-static).
+    """Whole-register CReg Permute IS realized in QIR (static CReg model).
 
-    #87a: a Permute is realized as a static logical relabel consulted
+    A Permute is realized as a static logical relabel consulted
     at every classical-bit lowering (the bespoke
     @set_creg_bit/@set_creg_to_int/creg-xor helpers the old test
-    pinned were removed by #76-B2). `Permute(a, b)` relabels a[0] <->
+    pinned were removed by the static CReg model). `Permute(a, b)` relabels a[0] <->
     b[0], so the subsequent `a[0].set(1)` writes b[0]'s storage.
     """
     prog = create_creg_permutation_program()
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_measurement_permutation.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_measurement_permutation.py
index 529f930ac..a88609b93 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_measurement_permutation.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_measurement_permutation.py
@@ -66,10 +66,10 @@ def test_register_measurement_permutation_qasm(
 # QIR Tests
 
 
-# #87a: a Permute is realized as a static logical relabel consulted at
+# A Permute is realized as a static logical relabel consulted at
 # every qubit/classical-bit lowering (the bespoke
 # @create_creg/@set_creg_bit/@mz_to_creg_bit helpers the old tests
-# pinned were removed by #76-B2; measurement is the standard 2-arg
+# pinned were removed by the static CReg model; measurement is the standard 2-arg
 # `@__quantum__qis__mz__body(%Qubit*, %Result*)` + read_result +
 # store-into-creg-buffer). Pin the realized measurement targeting.
 
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_measurement_unrolling.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_measurement_unrolling.py
index c4e5292fe..b306ab817 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_measurement_unrolling.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_measurement_unrolling.py
@@ -80,7 +80,7 @@ def test_measurement_unrolling_qasm() -> None:
 def test_measurement_unrolling_qir() -> None:
     """Element-wise then whole-register Permute compose through measures.
 
-    #87a: a Permute is realized as a static logical relabel; the
+    A Permute is realized as a static logical relabel; the
     element-wise `[a[0], b[1], c[2]] -> [c[2], a[0], b[1]]` composes
     with the later whole-register `Permute(a, c)`, and the register
     measurement unrolls onto the relabelled qubits. Pinned from the
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_circuit_conversion.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_circuit_conversion.py
index fbc5ee69d..97e61d2be 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_circuit_conversion.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_circuit_conversion.py
@@ -395,7 +395,7 @@ def test_complex_circuit_preservation(self) -> None:
 
 
 class TestQuantumCircuitStaticForAndWhile:
-    """#78: same silent-miscompile class as #74, in the AST
+    """Same silent-miscompile class as the QIR For/While, in the AST
     QuantumCircuit codegen.
 
     The AST converter wraps `For` range bounds in `LiteralExpr`, so the
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_permutation.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_permutation.py
index bb4cdf04e..fc660ea91 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_permutation.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_quantum_permutation.py
@@ -56,7 +56,7 @@ def test_quantum_permutation_qasm(quantum_permutation_program: tuple) -> None:
 
 # QIR Tests
 #
-# #87a: a Permute is realized as a static logical relabel (a
+# A Permute is realized as a static logical relabel (a
 # permutation_map consulted at every qubit/classical-bit lowering,
 # mirroring the Guppy linearity tracker's `.permute()` -- QIR/Selene
 # have no runtime permute intrinsic). These tests pin the realized
@@ -64,7 +64,7 @@ def test_quantum_permutation_qasm(quantum_permutation_program: tuple) -> None:
 # are deterministic in register-declaration order). The legacy
 # `; Permutation:` comment is preserved. The bespoke
 # @set_creg_bit/@mz_to_creg_bit helpers the old tests pinned were
-# removed by #76-B2 (measurement is the standard 2-arg
+# removed by the static CReg model (measurement is the standard 2-arg
 # `@__quantum__qis__mz__body(%Qubit*, %Result*)`).
 
 
@@ -124,7 +124,7 @@ def test_permutation_with_bell_circuit_qir() -> None:
     # Qubits: a[0]=0, a[1]=1, b[0]=2, b[1]=3. a[0] now -> b[1] (q3):
     # H(a[0]) -> q3, CX(a[0], a[1]) -> cnot(3, 1).
     assert _q("h", qir) == [3], qir
-    # Standard 2-arg measurement (the #76-B2-removed @mz_to_creg_bit is
+    # Standard 2-arg measurement (the removed @mz_to_creg_bit is
     # gone): Measure(a[0]) reads q3, Measure(a[1]) reads q1.
     mz = re.findall(
         r"call void @__quantum__qis__mz__body\(%Qubit\* inttoptr \(i64 (\d+) to %Qubit\*\), %Result\*",
@@ -141,7 +141,7 @@ def test_comprehensive_qir_verification() -> None:
 
     Previously this silently passed on a miscompile (the
     `; Permutation` comment was emitted but the qubit remap was a
-    no-op). With #87a the relabel is real; pin the corrected targeting.
+    no-op). The relabel is now real; pin the corrected targeting.
     """
     a = QReg("a", 2)
     b = QReg("b", 2)
@@ -264,7 +264,7 @@ def test_whole_register_qreg_permutation_realized_qir() -> None:
 def test_non_bijective_permute_fails_loud() -> None:
     """A non-bijective Permute must fail loud, not silently miscompile.
 
-    #87: the bijectivity guard must validate the EXPANDED
+    The bijectivity guard must validate the EXPANDED
     source/target lists BEFORE building the map -- a dict would
     collapse a duplicate expanded source, so a genuinely
     non-bijective Permute would compile (silent miscompile). All
@@ -295,9 +295,9 @@ def test_non_bijective_permute_fails_loud() -> None:
 
 
 def test_permute_realized_quantum_circuit() -> None:
-    """A2: element-wise + whole-register Permute is realized in the
+    """Element-wise + whole-register Permute is realized in the
     QuantumCircuit codegen (was a silent no-op -- same class as the
-    QIR #87 bug; the allocator_offsets swap never reached gate
+    QIR Permute bug; the allocator_offsets swap never reached gate
     qubit-index resolution / self-cancelled for a whole-reg pair).
     """
     a = QReg("a", 2)
@@ -321,8 +321,8 @@ def test_permute_realized_quantum_circuit() -> None:
 
 @pytest.mark.optional_dependency
 def test_permute_realized_stim() -> None:
-    """A2: element-wise + whole-register Permute is realized in the
-    Stim codegen (was a silent no-op -- same class as QIR #87).
+    """Element-wise + whole-register Permute is realized in the
+    Stim codegen (was a silent no-op -- same class as the QIR Permute bug).
     """
     a = QReg("a", 2)
     b = QReg("b", 2)
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_register_permutation.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_register_permutation.py
index 61faaaf13..8e49e8eb0 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_register_permutation.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_register_permutation.py
@@ -116,10 +116,10 @@ def test_mixed_permutation_qasm() -> None:
 # QIR Tests
 
 
-# #87a: a Permute is realized as a static logical relabel consulted at
+# A Permute is realized as a static logical relabel consulted at
 # every qubit/classical-bit lowering (the bespoke
 # @set_creg_bit/@get_creg_bit/creg-xor helpers the old tests pinned
-# were removed by #76-B2; classical writes are `store i1` into the
+# were removed by the static CReg model; classical writes are `store i1` into the
 # relabelled register's `[N x i1]` buffer). Works for whole-register
 # (QReg + CReg) and element-wise; pinned from the actual emitted QIR.
 
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_stim_conversion.py b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_stim_conversion.py
index 0f2dabf6d..c153e0192 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_stim_conversion.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/unit/slr/test_stim_conversion.py
@@ -306,7 +306,7 @@ def test_slr_round_trip(self) -> None:
 
 @pytest.mark.skipif(not STIM_AVAILABLE, reason="Stim not installed")
 class TestStimStaticForAndWhile:
-    """#78: same silent-miscompile class as #74, in the AST Stim codegen.
+    """Same silent-miscompile class as the QIR For/While, in the AST Stim codegen.
 
     The AST converter wraps `For` range bounds in `LiteralExpr`, so the
     old `isinstance(node.start, int)` guard was always false -- Stim
@@ -340,10 +340,9 @@ def test_while_raises_loud(self) -> None:
 
 
 def test_unsupported_gate_fails_loud() -> None:
-    """#88A-class (the #78 surfaced-not-changed Stim analogue): a
-    gate with no GATE_TO_STIM entry must FAIL LOUD, not be silently
+    """A gate with no GATE_TO_STIM entry must FAIL LOUD, not be silently
     dropped (a silent drop produced a runnable circuit with wrong
-    semantics -- a #74-class miscompile). Stim is Clifford-only, so
+    semantics -- a miscompile). Stim is Clifford-only, so
     a non-Clifford rotation is fundamentally unrepresentable;
     emitting the circuit without it is the bug.
     """

From 3f952ff10c46806fa216db2d27a35b6bc8c10774 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Fri, 22 May 2026 09:51:05 -0600
Subject: [PATCH 134/136] Strip remaining internal stage labels and
 string-literal planning references from comments and messages, keeping
 public-tracker refs

---
 .../src/pecos/slr/ast/_block_substitution.py  |  2 +-
 .../pecos/slr/ast/codegen/_block_flatten.py   |  6 +--
 .../pecos/slr/ast/codegen/entry_wrapper.py    |  4 +-
 .../src/pecos/slr/ast/codegen/guppy.py        | 10 ++---
 .../src/pecos/slr/ast/codegen/qir.py          | 19 ++++----
 .../src/pecos/slr/ast/converter.py            | 32 +++++++-------
 .../quantum-pecos/src/pecos/slr/ast/nodes.py  |  4 +-
 .../src/pecos/slr/ast/pretty_print.py         |  2 +-
 .../src/pecos/slr/ast/visitor.py              |  4 +-
 .../src/pecos/slr/gen_codes/gen_qir.py        |  2 +-
 python/quantum-pecos/src/pecos/slr/misc.py    |  2 +-
 .../src/pecos/slr/qeclib/generic/check.py     |  2 +-
 .../pecos/slr/qeclib/generic/check_1flag.py   |  2 +-
 .../qeclib/steane/gates_tq/transversal_tq.py  |  2 +-
 .../slr/transforms/parallel_optimizer.py      |  2 +-
 .../slr_tests/ast_guppy/_selene_harness.py    |  4 +-
 .../tests/slr_tests/ast_guppy/audit_runner.py | 20 ++++-----
 .../ast_guppy/test_block_call_smoke.py        | 43 ++++++++++---------
 .../ast_guppy/test_block_substitution.py      |  2 +-
 .../ast_guppy/test_deprecation_warnings.py    |  2 +-
 .../ast_guppy/test_qeclib_selene_corpus.py    | 15 ++++---
 .../ast_guppy/test_qir_corpus_executable.py   | 10 ++---
 .../ast_guppy/test_qir_spec_compliance.py     | 22 +++++-----
 .../ast_guppy/test_tier2_semantic.py          |  8 ++--
 .../regression/random_cases/test_slr_phys.py  | 10 ++---
 25 files changed, 117 insertions(+), 114 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/_block_substitution.py b/python/quantum-pecos/src/pecos/slr/ast/_block_substitution.py
index 3828c5cf4..50c3c1d51 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/_block_substitution.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/_block_substitution.py
@@ -9,7 +9,7 @@
 # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 # specific language governing permissions and limitations under the License.
 
-"""Phase 3a.3 iter 5e.1 -- shared BlockDecl-body reference substitution.
+"""Shared BlockDecl-body reference substitution.
 
 `BodyRemap` is a bidirectional slot/bit/whole-name remap. Two consumers
 build it in opposite directions but use the identical substitution core:
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/_block_flatten.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/_block_flatten.py
index 1dfd79241..2d8955016 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/_block_flatten.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/_block_flatten.py
@@ -9,7 +9,7 @@
 # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 # specific language governing permissions and limitations under the License.
 
-"""Phase 3a.2 BlockDecl/BlockCall flattening for non-Guppy codegens.
+"""BlockDecl/BlockCall flattening for non-Guppy codegens.
 
 Non-Guppy codegens (qasm, qir, stim, quantum_circuit) cannot represent
 reusable functions, so a `BlockCall` is inlined at its call site by
@@ -64,9 +64,9 @@ def flatten_block_calls(program: Program) -> Program:
     """Return a new Program with every BlockCall inlined and no BlockDecls left.
 
     The substitution rule maps each `BlockDecl` input parameter name to the
-    typed `BlockCall.arg_bindings` BlockArg. In Phase 3a.3 iter 5a only
+    typed `BlockCall.arg_bindings` BlockArg. Currently only
     `AllocatorArg` is supported; richer BlockArg shapes raise
-    `NotImplementedError`. Quantum-only in Phase 3a.1.
+    `NotImplementedError`. Quantum-only for now.
     """
     if not program.block_decls:
         return program
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/entry_wrapper.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/entry_wrapper.py
index dcd726526..4a45b48f1 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/entry_wrapper.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/entry_wrapper.py
@@ -19,8 +19,8 @@
 
 Two modes match `AstToGuppy._return_type`:
 - Explicit `Return(...)` -> pass through main's return value unchanged.
-- No `Return(...)` -> `entry() -> None` and discard (Phase 3b removed the
-  implicit return of result-flagged CRegs).
+- No `Return(...)` -> `entry() -> None` and discard (the output model no
+  longer implicitly returns result-flagged CRegs).
 """
 
 from __future__ import annotations
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
index 69e93cf4c..eee8c6f3e 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
@@ -386,10 +386,10 @@ def _generate_main(self, program: Program) -> list[str]:
     def _validate_block_decl(self, decl: BlockDecl) -> None:
         """Reject BlockDecl shapes that the v1 Guppy emitter cannot lower."""
         for inp in decl.inputs:
-            # Phase 3a.3 iter 5a: array[qubit, N]. Iter 5b: single qubit (bare
-            # `QubitTypeExpr`). Iter 5c: single classical bit (bare
+            # Supported input shapes: array[qubit, N]; single qubit (bare
+            # `QubitTypeExpr`); single classical bit (bare
             # `BitTypeExpr`, lowered via an array[bool, 1] write-back proxy).
-            # Later iters add qubit/bit bundles.
+            # Qubit/bit bundles are added later.
             is_qubit = isinstance(inp.type_expr, QubitTypeExpr)
             is_qubit_array = isinstance(inp.type_expr, ArrayTypeExpr) and isinstance(
                 inp.type_expr.element,
@@ -442,7 +442,7 @@ def _validate_block_decl(self, decl: BlockDecl) -> None:
     def _generate_block_decl(self, decl: BlockDecl) -> list[str]:
         """Emit a BlockDecl as a top-level Guppy @guppy def function.
 
-        Each input is one of (Phase 3a.3 iter 5c scope):
+        Each input is one of:
         - `array[qubit, N]`: parameter `name: array[qubit, N] @ owned`,
           unpacks at entry into `name_0..name_{N-1}` slots.
         - bare `qubit`: parameter `name: qubit @ owned`, aliased to its
@@ -1382,7 +1382,7 @@ def _emit_parallel(self, node: ParallelBlock) -> list[str]:
     def _emit_block_call(self, node: BlockCall) -> list[str]:
         """Lower a BlockCall to a packed-array call + unpack pattern.
 
-        Per-input dispatch (Phase 3a.3 iter 5d scope):
+        Per-input dispatch:
         - `array[qubit, N]` input + `AllocatorArg(name=outer)`: pack the
           outer allocator's slots into `array(outer_0, outer_1, ...)`,
           unpack the returned array back into the same slots.
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
index 8d88e864a..ea84c1a9c 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
@@ -397,10 +397,10 @@ def generate(self, program: Program) -> str:
         # Setup creg helper functions
         self._setup_creg_funcs()
 
-        # B2: standard QIR classical model. A measurement lowers to a
+        # Standard QIR classical model. A measurement lowers to a
         # static `%Result*` slot -> `__quantum__qis__mz__body` ->
         # `__quantum__rt__read_result` -> `store` into a per-CReg mutable
-        # `[N x i1]` entry-block `alloca` buffer (M-B2-static). `%Result*`
+        # `[N x i1]` entry-block `alloca` buffer. `%Result*`
         # is the existing `result_ptr` type.
         self._mz_body = self._declare_function(
             "__quantum__qis__mz__body",
@@ -441,7 +441,8 @@ def generate(self, program: Program) -> str:
     def _setup_creg_funcs(self) -> None:
         """Declare the standard classical-output runtime function.
 
-        B2 (M-B2-static) replaced the bespoke `create_creg`/`get_creg_bit`/
+        The static `[N x i1]` CReg model replaced the bespoke
+        `create_creg`/`get_creg_bit`/
         `set_creg_bit`/`get_int_from_creg`/`set_creg_to_int`/`mz_to_creg_bit`
         runtime helpers with native `alloca`/`store`/`load`/`gep`/`zext`,
         so only the standard `__quantum__rt__int_record_output` remains.
@@ -461,7 +462,7 @@ def _declare_function(self, name: str, ret_ty: Any, arg_tys: list) -> Any:
 
     def _setup_op_map(self) -> None:
         """Setup binary operator mapping."""
-        # B1: CReg comparisons are UNSIGNED (the CReg's `[N x i1]` buffer
+        # CReg comparisons are UNSIGNED (the CReg's `[N x i1]` buffer
         # packs to an i64 unsigned bit pattern via `_pack_creg`). The
         # `icmp_unsigned` choice matters only when bit 63 of a 64-bit
         # CReg is set; for narrower CRegs (or for bit-level `c[i]`
@@ -469,7 +470,7 @@ def _setup_op_map(self) -> None:
         # signed and unsigned agree. Switching is safe -- no existing
         # test asserts the signed semantics on a high-bit-set 64-bit
         # CReg, and unsigned is the correct interpretation of the
-        # bit-pattern semantics SLR exposes (cf. B1 D3).
+        # bit-pattern semantics SLR exposes.
         self._op_map = {
             BinaryOp.EQ: lambda lhs, rhs: self._builder.icmp_unsigned("==", lhs, rhs),
             BinaryOp.NE: lambda lhs, rhs: self._builder.icmp_unsigned("!=", lhs, rhs),
@@ -509,7 +510,7 @@ def _process_declarations(self, program: Program) -> None:
                     for i in range(decl.capacity):
                         self.context.get_qubit_index(decl.name, i)
             elif isinstance(decl, RegisterDecl):
-                # M-B2-static: a CReg is a mutable `[N x i1]` buffer in the
+                # A CReg is a mutable `[N x i1]` buffer in the
                 # entry block (declarations are processed at entry, before
                 # any control flow, so the builder is positioned there),
                 # zero-initialised so unmeasured/unset bits read 0. The
@@ -984,7 +985,7 @@ def _eval_expression(self, expr: Expression) -> Any:
             return self._builder.zext(bit, self._types["int"])
 
         if isinstance(expr, VarExpr):
-            # B1: a classical `VarExpr` denotes a whole CReg used as a
+            # A classical `VarExpr` denotes a whole CReg used as a
             # scalar (e.g. `If(m == 0)`, `o.set(m + n)`, Steane
             # `smid_flag_x`). SLR has no scalar-integer classical type
             # (verified: `pecos.slr.vars` exposes only Reg/CReg/Bit/
@@ -1197,7 +1198,7 @@ def _pack_creg(self, reg_name: str) -> Any:
         `OR_i (zext c[i] << i)` -- this is the canonical SLR CReg-as-
         integer lowering. Used by both `_generate_results` (for the
         `__quantum__rt__int_record_output` call) and by
-        `_eval_expression(VarExpr)` (B1 -- a whole-CReg scalar
+        `_eval_expression(VarExpr)` (a whole-CReg scalar
         reference in `If(m == 0)` / `o.set(m + n)` / etc.). Sharing
         the pack ensures the record-output and VarExpr interpretations
         of `m` are bit-identical -- the same packed i64.
@@ -1229,7 +1230,7 @@ def _generate_results(self) -> None:
             reg_tag.linkage = "private"
 
             # Pack the [N x i1] buffer into one i64 (shared with the
-            # B1 VarExpr lowering).
+            # VarExpr lowering).
             c_int = self._pack_creg(reg_name)
 
             reg_tag_gep = reg_tag.gep(
diff --git a/python/quantum-pecos/src/pecos/slr/ast/converter.py b/python/quantum-pecos/src/pecos/slr/ast/converter.py
index 6f3d1b7ea..7172cd22f 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/converter.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/converter.py
@@ -184,7 +184,7 @@ def __init__(self) -> None:
         self._position = 0  # Track position for source locations
         self._block_decls: list[BlockDecl] = []  # Hoisted BlockDecls accumulated during convert()
         self._decl_counter = 0
-        # S5/M2: True while converting the ops of a legacy-flattened composite
+        # True while converting the ops of a legacy-flattened composite
         # Block. A `Return` inside such a block is a block-boundary qubit
         # handoff (the qubits are already in linear scope by allocator name),
         # NOT the root Main return -- elide it. Provenance-based, not
@@ -389,7 +389,7 @@ def _convert_statement(self, op: Any) -> Statement | None:
 
         if op_class == "Return":
             if self._in_flattened_block:
-                # S5/M2: elide block-boundary Return from a flattened composite.
+                # Elide block-boundary Return from a flattened composite.
                 return None
             return self._convert_return(op)
 
@@ -405,14 +405,14 @@ def _convert_statement(self, op: Any) -> Statement | None:
 
         # Nested blocks (Block subclasses)
         if hasattr(op, "ops"):
-            # Phase 3a.1: a Block subclass that declares `block_inputs` opts in to
+            # A Block subclass that declares `block_inputs` opts in to
             # BlockDecl/BlockCall lowering. Without it, the legacy flatten path
-            # remains the default for all qeclib Blocks until Phase 3a.3.
+            # remains the default for all qeclib Blocks.
             if _has_block_inputs(op):
                 return self._convert_block_call(op)
 
             # Legacy flatten path. Returns inside the flattened composite are
-            # block-boundary handoffs, not the root Main return (S5/M2):
+            # block-boundary handoffs, not the root Main return:
             # elide them via the in_flattened_block provenance flag, including
             # inside nested If/Repeat/For/While/Parallel. Save/restore so
             # nested composites and the root scope are handled correctly.
@@ -429,8 +429,8 @@ def _convert_statement(self, op: Any) -> Statement | None:
     def _convert_block_call(self, block: Block) -> BlockCall:
         """Build a BlockDecl + BlockCall pair from a Block subclass with `block_inputs`.
 
-        Each call site emits a fresh BlockDecl (no dedup in Phase 3a.1; dedup is
-        a Phase 3a.3 optimization once qeclib conversion lands). The BlockDecl
+        Each call site emits a fresh BlockDecl (no dedup yet; dedup is
+        a later optimization once qeclib conversion lands). The BlockDecl
         body is the block's `ops` with allocator names rewritten from the
         outer-scope binding name to the input parameter name.
         """
@@ -589,7 +589,7 @@ def _claim_bit(reg: str, index: int, *, here: str, owner: str) -> None:
         # R4 (scratch design): a SCRATCH input is only sound if the block
         # resets it before any other use and never touches it after the
         # terminal measurement without re-Prepping. The Guppy lowering
-        # (S2) allocates the qubit internally on that assumption; validate
+        # allocates the qubit internally on that assumption; validate
         # it here so a mis-declared scratch input fails loudly at
         # conversion rather than miscompiling.
         for scratch_name in scratch_inputs:
@@ -1066,7 +1066,7 @@ def slr_to_ast(block: Main | Block) -> Program:
     return converter.convert(block)
 
 
-# === Phase 3a.1 BlockDecl/BlockCall helpers ===
+# === BlockDecl/BlockCall helpers ===
 
 _EFFECT_NAME_MAP: dict[str, ResourceEffect] = {
     "live_preserved": ResourceEffect.LIVE_PRESERVED,
@@ -1108,7 +1108,7 @@ def _scratch_events(stmt: Statement, name: str) -> list[str]:
     A reference inside control flow / Parallel / a nested BlockCall /
     PermuteOp cannot be linearized for the R4 reset-first analysis, so
     it is reported as the sentinel UNSUPPORTED and the validator rejects
-    (S1 scope: scratch inputs must have a flat Prep -> ... -> Measure
+    (scratch inputs must have a flat Prep -> ... -> Measure
     lifecycle).
     """
     if isinstance(stmt, CommentOp):
@@ -1139,15 +1139,15 @@ def _scratch_events(stmt: Statement, name: str) -> list[str]:
                     return ["UNSUPPORTED"]
         return []
     if isinstance(stmt, ReturnOp):
-        # A scratch input must never be handed back to the caller: S2
-        # allocates it internally and does not thread it through caller
+        # A scratch input must never be handed back to the caller: the
+        # Guppy lowering allocates it internally and does not thread it through caller
         # state, so returning it would diverge from the flatten/QASM path
         # Detection cannot be precise here -- the
         # substitution leaves Return values as the OUTER name (a partial
         # VarExpr passes through `whole_name` unchanged), so a returned
         # scratch slot is indistinguishable from a returned classical
         # value at this point. Conservatively reject ANY ReturnOp in a
-        # scratch-bearing block (S1 scope: in-scope blocks like `Check`
+        # scratch-bearing block (in-scope blocks like `Check`
         # have no Return; relax deliberately in a later stage if needed).
         return ["UNSUPPORTED"]
     # Anything else carries no qubit-slot ref. AssignOp/PrintOp operate on
@@ -1177,10 +1177,10 @@ def _validate_scratch_input(
 
     The block must reset `name` before any other use, and every Prep
     lifecycle must be closed by a Measure before the next Prep and
-    before the body ends (the S2 Guppy lowering allocates the scratch
+    before the body ends (the Guppy lowering allocates the scratch
     qubit internally, so an unmeasured trailing Prep/use would diverge
     from the flatten/QASM path). Anything the
-    S1 analysis cannot linearize (control flow / Parallel / nested
+    linearization analysis cannot handle (control flow / Parallel / nested
     BlockCall / Permute over the scratch slot) is rejected loudly --
     silently allowing it would let the Guppy internal-allocation
     lowering miscompile.
@@ -1209,7 +1209,7 @@ def _validate_scratch_input(
         )
         raise ValueError(msg)
     # Segment state machine: a PREP opens a lifecycle that MUST close with a
-    # MEASURE before the next PREP and before the body ends. The S2 Guppy
+    # MEASURE before the next PREP and before the body ends. The Guppy
     # lowering allocates the scratch qubit internally; an unmeasured trailing
     # Prep/use would leave the flatten/QASM path with a live reset outer slot
     # while Guppy silently drops it -- a semantic divergence.
diff --git a/python/quantum-pecos/src/pecos/slr/ast/nodes.py b/python/quantum-pecos/src/pecos/slr/ast/nodes.py
index 9bee5c508..2cd89fa28 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/nodes.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/nodes.py
@@ -597,7 +597,7 @@ def children(self) -> Sequence[AstNode]:
 
 
 # =============================================================================
-# Reusable block declarations (Phase 3a.1)
+# Reusable block declarations
 # =============================================================================
 
 
@@ -633,7 +633,7 @@ def children(self) -> Sequence[AstNode]:
         return nodes
 
 
-# ---- BlockCall argument types (Phase 3a.3 iter 5a typed sum type) ----
+# ---- BlockCall argument types (typed sum type) ----
 
 
 @dataclass(frozen=True, kw_only=True)
diff --git a/python/quantum-pecos/src/pecos/slr/ast/pretty_print.py b/python/quantum-pecos/src/pecos/slr/ast/pretty_print.py
index cca21c19a..256550a2b 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/pretty_print.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/pretty_print.py
@@ -343,7 +343,7 @@ def visit_parallel(self, node: ParallelBlock) -> str:
         lines.append(")")
         return "\n".join(lines)
 
-    # Reusable blocks (Phase 3a.1)
+    # Reusable blocks
 
     def visit_block_decl(self, node: BlockDecl) -> str:
         """Visit a BlockDecl, rendering it as a reusable function-like declaration."""
diff --git a/python/quantum-pecos/src/pecos/slr/ast/visitor.py b/python/quantum-pecos/src/pecos/slr/ast/visitor.py
index 8dad652c8..edf4ed7e5 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/visitor.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/visitor.py
@@ -144,14 +144,14 @@ def visit_permute(self, node: PermuteOp) -> T_co: ...
 
     def visit_print(self, node: PrintOp) -> T_co: ...
 
-    # Reusable blocks (Phase 3a.1)
+    # Reusable blocks
     def visit_block_decl(self, node: BlockDecl) -> T_co: ...
 
     def visit_block_input(self, node: BlockInput) -> T_co: ...
 
     def visit_block_call(self, node: BlockCall) -> T_co: ...
 
-    # BlockCall argument bindings (Phase 3a.3 iter 5a)
+    # BlockCall argument bindings
     def visit_allocator_arg(self, node: AllocatorArg) -> T_co: ...
 
     def visit_single_qubit_arg(self, node: SingleQubitArg) -> T_co: ...
diff --git a/python/quantum-pecos/src/pecos/slr/gen_codes/gen_qir.py b/python/quantum-pecos/src/pecos/slr/gen_codes/gen_qir.py
index 2f0408502..d67cd7747 100644
--- a/python/quantum-pecos/src/pecos/slr/gen_codes/gen_qir.py
+++ b/python/quantum-pecos/src/pecos/slr/gen_codes/gen_qir.py
@@ -299,7 +299,7 @@ def create_creg(self, creg: CReg):
                 [ir.Constant(ir.IntType(64), creg.size)],
                 f"{creg.sym}",
             ),
-            # Phase 3b removed the per-register result flag; all user cregs
+            # The per-register result flag was removed; all user cregs
             # are recorded (internal scratch temps still pass False below).
             True,
         )
diff --git a/python/quantum-pecos/src/pecos/slr/misc.py b/python/quantum-pecos/src/pecos/slr/misc.py
index a5cfb2d4b..3ce4756e8 100644
--- a/python/quantum-pecos/src/pecos/slr/misc.py
+++ b/python/quantum-pecos/src/pecos/slr/misc.py
@@ -133,7 +133,7 @@ def __init__(self, value, *, tag: str | None = None, namespace: str = "result")
         run later during emission.
         """
         if isinstance(value, SymbolicBit):
-            msg = "Print does not support SymbolicBit (LoopVar-indexed) values; this is v2-defer scope."
+            msg = "Print does not support SymbolicBit (LoopVar-indexed) values."
             raise TypeError(msg)
         if not isinstance(value, (CReg, Bit)):
             msg = (
diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/generic/check.py b/python/quantum-pecos/src/pecos/slr/qeclib/generic/check.py
index 066cee7b8..762abf74c 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/generic/check.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/generic/check.py
@@ -35,7 +35,7 @@ class Check(Block):
     a sequence of Pauli operators to data qubits controlled by an ancilla qubit.
     """
 
-    # Phase 3a.3 (scratch-ancilla effect): emit BlockDecl + BlockCall instead
+    # Scratch-ancilla effect: emit BlockDecl + BlockCall instead
     # of inlining. Data qubits pass through unchanged; `a` is a reset-reused
     # scratch ancilla (prepped + measured inside, allocated internally in
     # Guppy so callers like SynExtractBare can reuse one physical slot across
diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/generic/check_1flag.py b/python/quantum-pecos/src/pecos/slr/qeclib/generic/check_1flag.py
index 589bc9ff7..15605f54d 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/generic/check_1flag.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/generic/check_1flag.py
@@ -35,7 +35,7 @@ class Check1Flag(Block):
     to detect errors during the syndrome extraction process.
     """
 
-    # Phase 3a.3 (scratch-ancilla effect, 5e.5): emit BlockDecl + BlockCall.
+    # Scratch-ancilla effect: emit BlockDecl + BlockCall.
     # `a` and `flag` are both reset-reused scratch ancillas (prepped +
     # measured inside, allocated internally in Guppy so callers can reuse
     # physical slots across sequential checks); data passes through; the two
diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/steane/gates_tq/transversal_tq.py b/python/quantum-pecos/src/pecos/slr/qeclib/steane/gates_tq/transversal_tq.py
index 17b4099ef..820b863ea 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/steane/gates_tq/transversal_tq.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/steane/gates_tq/transversal_tq.py
@@ -28,7 +28,7 @@ class CX(Block):
     two logical qubits encoded in the Steane code.
     """
 
-    # Phase 3a.3: declare resource effects so SLR -> AST emits BlockDecl + BlockCall
+    # Declare resource effects so SLR -> AST emits BlockDecl + BlockCall
     # instead of inlining. Both registers are live_preserved -- the body applies a
     # transversal CX pairwise (no internal measurements).
     block_inputs: ClassVar[dict[str, str]] = {
diff --git a/python/quantum-pecos/src/pecos/slr/transforms/parallel_optimizer.py b/python/quantum-pecos/src/pecos/slr/transforms/parallel_optimizer.py
index 03d4647df..7d49d359d 100644
--- a/python/quantum-pecos/src/pecos/slr/transforms/parallel_optimizer.py
+++ b/python/quantum-pecos/src/pecos/slr/transforms/parallel_optimizer.py
@@ -97,7 +97,7 @@ def _transform_block(self, block: Block) -> Block:
             # state set by the subclass __init__ (e.g. `self.q1`, `self.q2`
             # bound for `block_inputs` lookup) survive the optimization pass.
             # Reconstructing via `Block(*new_ops)` here would erase that state
-            # and cause Phase 3a.3 converted Blocks to silently fall back to
+            # and cause converted Blocks to silently fall back to
             # the v1 flatten path.
             cls = type(block)
             if cls is Block:
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py
index 0811a0e0f..f56be8509 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py
@@ -75,8 +75,8 @@ def run_ast_guppy_via_selene(
     # wrapper (default `emit_return_result_tags=False`) is untouched.
     wrapper, info = build_no_arg_entry_wrapper(program, emit_return_result_tags=True)
     # The returned CRegs (explicit `Return(...)`, in listed order) are the
-    # source of truth for the public `measurement_N` order. Phase 3b removed
-    # the v1 implicit result-CReg path, so a program with no `Return` has no
+    # source of truth for the public `measurement_N` order. The implicit
+    # result-CReg path was removed, so a program with no `Return` has no
     # measurement record at all.
     if info.explicit_return is None:
         msg = (
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
index 8434f26bc..755fda854 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/audit_runner.py
@@ -9,7 +9,7 @@
 # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 # specific language governing permissions and limitations under the License.
 
-"""Audit runner for Step 4 Workstream B (cutover gap discovery).
+"""Audit runner for cutover gap discovery.
 
 Iterates a curated list of `(source_label, slr_program_factory)`
 pairs from PECOS examples, qeclib, and existing test fixtures.
@@ -30,7 +30,7 @@
 
 The curated list is intentionally small at first and grows as we
 identify canonical examples worth exercising. The list is the audit
-surface; growing it is part of Workstream B.
+surface; growing it is part of the cutover audit.
 """
 
 from __future__ import annotations
@@ -486,15 +486,15 @@ def _qeclib_surface_patch_builder_empty() -> Block:
 
 
 def _qeclib_steane_pz() -> Block:
-    """Steane pz(): lowers under S5 (M2 converter-time elision of flattened
-    composite block-boundary Returns); Main has no user Return -> main()->None.
+    """Steane pz(): lowers via converter-time elision of flattened
+    composite block-boundary Returns; Main has no user Return -> main()->None.
 
     Audit scope is build+lower (compile) only -- steane_pz genuinely
-    compiles post-S5. Behavioral correctness is a SEPARATE concern: the v1
+    compiles. Behavioral correctness is a SEPARATE concern: the v1
     AST->Guppy FT-RUS pz() prepares a non-codeword state (pre-existing,
-    S5-independent). That defect is tracked post-3b and pinned by a strict
-    xfail in test_v1_behavioral.TestS5SteanePzBehavioral -- it is NOT
-    asserted correct here."""
+    independent of the Return-elision). That defect is tracked separately and
+    pinned by a strict xfail in test_v1_behavioral.TestS5SteanePzBehavioral
+    -- it is NOT asserted correct here."""
     return Main(
         c := Steane("c"),
         c.pz(),
@@ -744,7 +744,7 @@ def _curated_cases() -> list[AuditCase]:
             expected_failure=ExpectedFailure(
                 exception_type="GuppyCodegenError",
                 message_contains="does not support While loops",
-                classification="v2-defer",
+                classification="deferred",
                 reason="While loop linearity fixed-points are outside v1 scope",
             ),
         ),
@@ -754,7 +754,7 @@ def _curated_cases() -> list[AuditCase]:
             expected_failure=ExpectedFailure(
                 exception_type="GuppyCodegenError",
                 message_contains="symbolic LoopVar indexing",
-                classification="v2-defer",
+                classification="deferred",
                 reason="Symbolic SlotRef indices require shared AST/converter design",
             ),
         ),
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
index 8071cc24e..6b5b265dc 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
@@ -9,7 +9,7 @@
 # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 # specific language governing permissions and limitations under the License.
 
-"""Phase 3a.1 smoke tests for BlockDecl / BlockCall.
+"""Smoke tests for BlockDecl / BlockCall.
 
 Builds AST programs directly (without going through SLR) to exercise the new
 Guppy emitter codepaths:
@@ -164,7 +164,7 @@ def test_arg_count_mismatch_rejected(self) -> None:
             ast_to_guppy(prog)
 
     def test_unsupported_effect_rejected(self) -> None:
-        """`PRODUCED` and `DROPPED` effects are not lowered in Phase 3a.1."""
+        """`PRODUCED` and `DROPPED` effects are not yet lowered."""
         bell = BlockDecl(
             name="bell",
             inputs=(
@@ -186,7 +186,7 @@ def test_unsupported_effect_rejected(self) -> None:
             ast_to_guppy(prog)
 
     def test_unsupported_input_type_rejected(self) -> None:
-        """Only `array[qubit, N]` inputs are supported in Phase 3a.1."""
+        """Only `array[qubit, N]` inputs are supported here."""
         from pecos.slr.ast.nodes import BitTypeExpr
 
         bell = BlockDecl(
@@ -238,7 +238,7 @@ def test_size_mismatch_rejected(self) -> None:
 
 
 class TestBlockCallNonGuppyFlatten:
-    """Phase 3a.2: non-Guppy codegens inline BlockCall byte-identical to a flat program."""
+    """Non-Guppy codegens inline BlockCall byte-identical to a flat program."""
 
     def test_qasm_blockcall_matches_inlined_program(self) -> None:
         """QASM output for a BlockCall program matches the hand-flattened program."""
@@ -278,7 +278,7 @@ def test_qasm_blockcall_matches_inlined_program(self) -> None:
 
 
 class TestConvertedQeclibBlocksUseBlockCallPath:
-    """Lock in that each Phase 3a.3-converted Steane Block actually goes through
+    """Lock in that each converted Steane Block actually goes through
     the BlockCall lowering path -- not silently flattening.
 
     Goes through `SlrConverter(prog).guppy()` end-to-end (not just `slr_to_ast`)
@@ -351,7 +351,7 @@ def test_steane_logical_h_uses_block_call(self) -> None:
 class TestConsumedEffect:
     """End-to-end coverage for CONSUMED inputs.
 
-    The Phase 3a.1 validator allows CONSUMED in BlockDecl.inputs, and the
+    The validator allows CONSUMED in BlockDecl.inputs, and the
     `_emit_block_call` code path marks the outer slot CONSUMED post-call. But
     no existing test confirmed that a subsequent outer-scope reference raises
     a LinearityError. Add a direct-AST test that pins this behavior.
@@ -644,7 +644,7 @@ def test_rotation_merging_pass_preserves_block_decls(self) -> None:
 
 
 class TestSingleQubitInputSupport:
-    """Phase 3a.3 iter 5b: single-qubit (bare `qubit`) input + `SingleQubitArg`
+    """Single-qubit (bare `qubit`) input + `SingleQubitArg`
     at the call site. Validator accepts `QubitTypeExpr` as a BlockInput type;
     emitter renders `name: qubit @ owned` and passes the outer slot's local
     directly (no array wrap); LIVE_PRESERVED rebinds the slot from the
@@ -850,7 +850,7 @@ def test_single_qubit_slot_index_out_of_bounds_rejected(self) -> None:
 
 
 class TestSingleBitInputSupport:
-    """Phase 3a.3 iter 5c: single classical-bit (bare `BitTypeExpr`) input +
+    """Single classical-bit (bare `BitTypeExpr`) input +
     `SingleBitArg` at the call site. The bit is modeled as an
     `array[bool, 1] @ owned` write-back proxy: the callee mutates `name[0]`,
     returns the array, and the caller writes it back into the outer CReg bit.
@@ -978,7 +978,7 @@ def test_single_bit_index_out_of_bounds_rejected(self) -> None:
 
 
 class TestQubitBundleInputSupport:
-    """Phase 3a.3 iter 5d: a single `array[qubit, N]` BlockInput bound at the
+    """A single `array[qubit, N]` BlockInput bound at the
     call site to a non-contiguous bundle of N arbitrary outer slots via
     `QubitBundleArg(slots=(...))`. The BlockDecl side is unchanged from the
     AllocatorArg case -- only the caller's slot-bundling differs.
@@ -1308,7 +1308,7 @@ def test_qubit_bundle_out_of_bounds_slot_rejected(self) -> None:
 
 
 class TestDeferredBlockArgRejection:
-    """Phase 3a.3 iter 5e.2 scope:
+    """Scope:
     - `AllocatorArg`, `SingleQubitArg`, `SingleBitArg`, `QubitBundleArg` are
       now supported in BOTH the Guppy emitter AND the non-Guppy flatten path.
       The former `test_<shape>_arg_rejected_in_flatten_pass` lock-ins are
@@ -1537,7 +1537,7 @@ def test_flatten_pass_rejects_duplicate_block_decl_names(self) -> None:
 
 
 class TestBlockBodyStatementSubstitution:
-    """Phase 3a.1 substitution must cover every SLR statement type that names allocators.
+    """Substitution must cover every SLR statement type that names allocators.
 
     PermuteOp (which carries source/target register names as strings, not
     SlotRefs) was silently passed through in
@@ -1615,7 +1615,7 @@ def test_unparseable_permute_ref_mentioning_partial_name_raises(self) -> None:
 
 
 class TestSlrBlockInputsWiring:
-    """Phase 3a.1: an SLR Block with class-level `block_inputs` lowers to BlockDecl/BlockCall."""
+    """An SLR Block with class-level `block_inputs` lowers to BlockDecl/BlockCall."""
 
     def test_slr_block_with_inputs_emits_block_decl_and_call(self) -> None:
         """slr_to_ast on a Main containing a Block with `block_inputs` produces a BlockDecl + BlockCall."""
@@ -1754,7 +1754,7 @@ def test_bell_block_call_produces_correlated_outcomes(self) -> None:
 
 
 class TestSlrBlockArgShapeDetectionViaConverter:
-    """Phase 3a.3 iter 5e.2: an SLR `Block` subclass whose `block_inputs`
+    """An SLR `Block` subclass whose `block_inputs`
     bind a single `Qubit`, a `list[Qubit]` bundle (same- or cross-QReg), or
     a single `Bit` must drive the full real pipeline:
 
@@ -2138,10 +2138,11 @@ def __init__(self, x, y) -> None:
 
 
 class TestScratchEffectS1:
-    """Phase 3a.3 scratch-ancilla effect, stage S1: `ResourceEffect.SCRATCH`
+    """Scratch-ancilla effect: `ResourceEffect.SCRATCH`
     + converter detection + the mandatory R4 reset-first validator + O2.
 
-    S1 does NOT lower scratch in Guppy (that is S2); until then Guppy must
+    This stage does NOT lower scratch in Guppy (the internal-allocation
+    lowering lands later); until then Guppy must
     reject a SCRATCH input loudly (no silent fallback). Flatten/QASM
     already works because the scratch param substitutes to the outer slot
     exactly like any per-slot input.
@@ -2220,7 +2221,7 @@ def test_scratch_flatten_substitutes_to_outer_slot(self) -> None:
         assert "measure q[2] -> c[0];" in qasm
 
     def test_scratch_guppy_internal_alloc_no_param(self) -> None:
-        """S2: a SCRATCH input is allocated INSIDE the @guppy def -- it is
+        """A SCRATCH input is allocated INSIDE the @guppy def -- it is
         neither a function parameter nor a positional call argument; the
         body's PZ(scratch) lowers to a fresh internal `qubit()`.
         """
@@ -2315,7 +2316,7 @@ def __init__(self, a) -> None:
             slr_to_ast(prog)
 
     def test_scratch_inside_control_flow_rejected(self) -> None:
-        """S1 conservative scope: a scratch slot touched inside control
+        """Conservative scope: a scratch slot touched inside control
         flow cannot be linearized for the R4 analysis -> reject loudly.
         """
         from pecos.slr import CReg, Main, QReg, Repeat, Return
@@ -2372,7 +2373,7 @@ def __init__(self, a, b) -> None:
 
     def test_scratch_prep_only_rejected(self) -> None:
         """A PZ with no terminating Measure must be
-        rejected -- S2 allocates the scratch qubit internally, so an
+        rejected -- the Guppy lowering allocates the scratch qubit internally, so an
         unmeasured trailing PZ diverges from the flatten/QASM path.
         """
         from pecos.slr import Main, QReg, Return
@@ -2501,7 +2502,7 @@ def test_scratch_return_rejected(self) -> None:
 
         Post-substitution a returned scratch slot keeps the OUTER name
         (a partial VarExpr passes `whole_name` through unchanged), so it
-        is indistinguishable from a returned classical value -- S1
+        is indistinguishable from a returned classical value -- the validator
         conservatively rejects ANY Return in a scratch block (in-scope
         `Check` has none). Covers both returning the scratch qubit and
         returning an unrelated value.
@@ -2549,7 +2550,7 @@ def __init__(self, a, out) -> None:
             slr_to_ast(prog2)
 
     def test_scratch_reuse_across_calls_compiles_and_runs(self) -> None:
-        """S2 end-to-end: the original blocker. The SAME outer ancilla slot
+        """End-to-end: the original blocker. The SAME outer ancilla slot
         feeds two sequential scratch BlockCalls (the production
         `SynExtractBare` reuse pattern). Under `a: consumed` this was a
         Guppy LinearityError; with `a: scratch` each call allocates its
@@ -2916,7 +2917,7 @@ def test_color488_syn_extract_bare_routes_and_runs(self) -> None:
 
 
 class TestScratchCheck1FlagS5ProductionLockIn:
-    """S5: `Check1Flag` converted (`a`, `flag`: scratch; the body's
+    """`Check1Flag` converted (`a`, `flag`: scratch; the body's
     `PZ(a, flag)` split into `PZ(a); PZ(flag)` per O1 option (a)).
     Steane `SynExtractFlagged` reuses ancilla+flag slots across 6
     Check1Flag calls -- it must route every one through a BlockCall,
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_substitution.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_substitution.py
index 2b36e1a24..3fc15328c 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_substitution.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_substitution.py
@@ -9,7 +9,7 @@
 # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 # specific language governing permissions and limitations under the License.
 
-"""Phase 3a.3 iter 5e.1 -- direct unit tests for the shared body substitution.
+"""Direct unit tests for the shared body substitution.
 
 The 7 already-converted Steane Blocks only exercise the *whole-allocator
 identity* path (`q[i] -> q[i]`). 5e.1 is "dead-code-with-tests" without
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_deprecation_warnings.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_deprecation_warnings.py
index e85e25ae4..b5e231838 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_deprecation_warnings.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_deprecation_warnings.py
@@ -9,7 +9,7 @@
 # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 # specific language governing permissions and limitations under the License.
 
-"""Phase 3b hard-contract tests for the v2 output model.
+"""Hard-contract tests for the v2 output model.
 
 S3 removed the `CReg(result=...)` kwarg, the `RegisterDecl.is_result`
 field, and the v1 implicit return of result-flagged CRegs. These tests
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qeclib_selene_corpus.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qeclib_selene_corpus.py
index 400a9c7d3..29dabb2f4 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qeclib_selene_corpus.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qeclib_selene_corpus.py
@@ -9,7 +9,7 @@
 # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 # specific language governing permissions and limitations under the License.
 
-"""qeclib Selene roundtrip corpus (Phase 3a.0 + 3a.3 byte-identity safety net).
+"""qeclib Selene roundtrip corpus (byte-identity safety net).
 
 This
 corpus pins per-shot measurement records under fixed seed for each tracked
@@ -18,7 +18,7 @@
 (once `block_inputs` was declared and the SLR converter began emitting
 BlockDecl + BlockCall).
 
-When a Phase 3a.3 iteration converts a new Block, the workflow is:
+When a new Block is converted, the workflow is:
 1. Pin its Selene record here against today's flattened compile.
 2. Add `block_inputs` to the Block class.
 3. Re-run this corpus; identical records prove behavior preservation.
@@ -28,10 +28,11 @@
 now exercise the BlockCall path (parametrized lock-in in
 `test_block_call_smoke.py::TestConvertedQeclibBlocksUseBlockCallPath`).
 
-## Scope (Phase 3a.0 baseline + Phase 3a.3 iters 1-4 conversions)
+## Scope (baseline + early Block conversions)
 
 Pattern A Blocks only -- side-effect-only Blocks that compile under v1
-without errors. Phase 3a.1 + 3a.2 + 3a.3 iters 1-4 have landed on
+without errors. The BlockDecl/BlockCall lowering and the first Block
+conversions have landed on
 `phase3a-blockcall`; the Steane Block rows below now exercise the
 real BlockCall lowering path.
 
@@ -72,8 +73,8 @@
 def _run_via_selene(prog: Main, *, shots: int = 4, seed: int = 42, qubits: int) -> dict:
     """Compile prog through SlrConverter.hugr() and run through Selene.
 
-    The corpus programs use explicit `Return(...)` (Phase 3b removed the
-    v1 implicit-return path).
+    The corpus programs use explicit `Return(...)` (the implicit-return
+    path was removed).
     """
     package = SlrConverter(prog).hugr()
     hugr_bytes = package.to_str().encode("utf-8")
@@ -215,7 +216,7 @@ class TestQeclibSteaneTransversalCX:
 
     Steane logical CX is a transversal pairwise CX between two 7-qubit registers
     (the two logical Steane patches). Both registers are live_preserved (no internal
-    measurements). Phase 3a.3 conversion adds `block_inputs={"q1": "live_preserved",
+    measurements). Block conversion adds `block_inputs={"q1": "live_preserved",
     "q2": "live_preserved"}` and these pinned records must remain byte-identical.
     """
 
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
index b15109899..54f6f8c77 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_corpus_executable.py
@@ -229,20 +229,20 @@ def _high_bits_zero_1(obs: set[tuple[int, ...]]) -> None:
     ),
     "docs.prep_basis_x": (
         "X",
-        "#81 PX = reset+H = |+>; Z-measure is ONE uniform random bit -- "
+        "PX = reset+H = |+>; Z-measure is ONE uniform random bit -- "
         "no hard invariant. PX correctness is validated behaviorally by "
         "test_prep_gates (Stim peek_bloch + Selene), not here. "
         "(An earlier deterministic [0] guess assumed the OLD broken "
-        "Prep('X')=Z-reset, fixed by #81.)",
+        "Prep('X')=Z-reset, now fixed.)",
     ),
     "docs.rotation_rx": (
         "X",
-        "#97/v2 (typed angle-first SLR API): `RX(rad(0.5), q)` builds + lowers via "
+        "Typed angle-first SLR API: `RX(rad(0.5), q)` builds + lowers via "
         "qir_to_qis (rx is qir-qis-allowlisted), but rx(0.5) is "
         "NON-CLIFFORD so it cannot execute on the Stim backend this "
         "suite uses -- excluded from the executable record (rx "
         "correctness is covered by the Guppy Quest-backed behavioral "
-        "tests + the QIR rx emission). This #79 suite is Stim-only.",
+        "tests + the QIR rx emission). This suite is Stim-only.",
     ),
     "qeclib.color488_syn_extract_bare": (
         "X",
@@ -290,7 +290,7 @@ def test_qir_corpus_manifest_covers_qis_ok() -> None:
     """
     qis_ok = set(_qis_ok_labels())
     missing = qis_ok - set(_MANIFEST)
-    assert not missing, f"QIS_OK programs with no #79 manifest class (classify them): {sorted(missing)}"
+    assert not missing, f"QIS_OK programs with no manifest class (classify them): {sorted(missing)}"
     stale = set(_MANIFEST) - qis_ok
     assert not stale, f"manifest entries no longer QIS_OK (remove/retriage): {sorted(stale)}"
     hist = {cls: sum(1 for c, _ in _MANIFEST.values() if c == cls) for cls in ("D", "P", "X")}
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
index 48959f530..0dd095118 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qir_spec_compliance.py
@@ -265,7 +265,7 @@ def _qir_state() -> tuple[
 
 
 def test_audit_corpus_qir_compliance_baseline() -> None:
-    """Pin the post-B1 two-tier QIR-compliance baseline (see module docstring)."""
+    """Pin the two-tier QIR-compliance baseline (see module docstring)."""
     build_failed, validate_failed, qis_ok, qis_failed, entry_attrs = _qir_state()
 
     # Sanity: validate_qir actually ran on built QIR (not vacuous).
@@ -294,7 +294,7 @@ def test_audit_corpus_qir_compliance_baseline() -> None:
     assert set(got_vf) == set(_EXPECTED_VALIDATE_FAILED), (
         f"validate_qir failure set changed: got {sorted(got_vf)}, expected "
         f"{sorted(_EXPECTED_VALIDATE_FAILED)}. A new validate failure likely "
-        "means a B1 metadata regression -- triage before re-pinning."
+        "means a metadata regression -- triage before re-pinning."
     )
     for label, frag in _EXPECTED_VALIDATE_FAILED.items():
         assert frag in got_vf[label], f"{label}: validate msg lacks {frag!r}: {got_vf[label][:200]}"
@@ -307,23 +307,23 @@ def test_audit_corpus_qir_compliance_baseline() -> None:
         for key, want in _EXPECTED_ENTRY_ATTRS.items():
             assert attrs.get(key) == want, (
                 f"{label}: entry attr {key!r} = {attrs.get(key)!r}, expected {want!r}. "
-                "B1 metadata value regression -- qir-qis does not catch this; "
+                "metadata value regression -- qir-qis does not catch this; "
                 "this pin is the only guard."
             )
 
-    # Tier 2 -- qir_to_qis: Stage B2 DONE. Every validate-passing
-    # program now lowers via qir_to_qis (M-B2-static replaced the
+    # Tier 2 -- qir_to_qis: every validate-passing program now lowers
+    # via qir_to_qis (the static `[N x i1]` CReg model replaced the
     # bespoke CReg helpers). The OK set is pinned and `qis_failed`
-    # must be empty -- a new qir_to_qis failure (B2 regression) or a
-    # dropped/added program trips this and must be triaged.
+    # must be empty -- a new qir_to_qis failure (a lowering regression)
+    # or a dropped/added program trips this and must be triaged.
     assert set(qis_ok) == set(_EXPECTED_QIS_OK), (
         f"qir_to_qis-OK set changed: got {sorted(qis_ok)}, expected "
-        f"{sorted(_EXPECTED_QIS_OK)}. Triage (B2 regression vs further "
+        f"{sorted(_EXPECTED_QIS_OK)}. Triage (lowering regression vs further "
         "progress) before updating this baseline."
     )
     assert not qis_failed, (
-        "unexpected qir_to_qis failure(s) post-B2: "
-        f"{[(label, msg[:160]) for label, msg in qis_failed]}. After "
-        "Stage B2 every validate-passing program must lower via "
+        "unexpected qir_to_qis failure(s): "
+        f"{[(label, msg[:160]) for label, msg in qis_failed]}. Every "
+        "validate-passing program must lower via "
         "qir_to_qis -- triage before re-pinning."
     )
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_tier2_semantic.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_tier2_semantic.py
index de6a091c3..49ae0685a 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_tier2_semantic.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_tier2_semantic.py
@@ -207,7 +207,7 @@ def _assert_set_int_unpack(label: str, ir: str, *, name: str, size: int, value:
     NOT by the Guppy oracle: the AST->Guppy return wrapper cannot
     return a `set(int)`-assigned CReg -- it models the CReg as `int`
     while the wrapper expects `array[bool, N]`. That is a Guppy-path
-    limitation orthogonal to the B2 QIR, whose lowering is exact and
+    limitation orthogonal to the QIR, whose lowering is exact and
     checked structurally here.)
     """
     for i in range(size):
@@ -295,7 +295,7 @@ def run() -> int:
     # per-bit lshr/trunc unpack). The AST->Guppy return wrapper
     # cannot return a `set(int)`-assigned CReg (it models the CReg as
     # `int`, the wrapper expects `array[bool, N]`) -- a Guppy-path
-    # limitation orthogonal to the B2 QIR, so Guppy is not the right
+    # limitation orthogonal to the QIR, so Guppy is not the right
     # oracle for those two shapes.
     det_checks: list[tuple[str, Main, str]] = [
         ("v1.bell", _case("v1.bell"), "bell"),
@@ -591,13 +591,13 @@ def test_tier2_executable_differential() -> None:
         failures.append(f"v1.conditional_correction: QIS-exec {qis_vals} != Guppy-oracle {oracle_vals}")
         print(f"[D~oracle FAIL] {failures[-1]}")
 
-    assert not failures, "#77 executable differential failures:\n" + "\n".join(failures)
+    assert not failures, "Executable differential failures:\n" + "\n".join(failures)
 
 
 @pytest.mark.slow
 def test_tier2_semantic_b2() -> None:
     """Pytest entry (slow: builds the Selene runtime)."""
-    assert run() == 0, "Stage B2 semantic assurance failed (see stdout)"
+    assert run() == 0, "Semantic assurance failed (see stdout)"
 
 
 if __name__ == "__main__":
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py b/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py
index bfc44825f..41b0c0651 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py
@@ -159,7 +159,7 @@ def test_control_flow_qir() -> None:
 
 @pytest.mark.optional_dependency
 def test_plus_qir() -> None:
-    """B1: whole-CReg scalar arithmetic (`o.set(m + n)`) lowers via
+    """Whole-CReg scalar arithmetic (`o.set(m + n)`) lowers via
     `_pack_creg` + i64 `add`, then unpacks back to `o`'s bits."""
     prog = Main(
         _q := QReg("q", 2),
@@ -206,7 +206,7 @@ def test_nested_xor_qir() -> None:
 
 @pytest.mark.optional_dependency
 def test_minus_qir() -> None:
-    """B1: whole-CReg scalar subtraction (`o.set(m - n)`) lowers via
+    """Whole-CReg scalar subtraction (`o.set(m - n)`) lowers via
     `_pack_creg` + i64 `sub`. Pure-classical + Clifford only -- runs
     end-to-end through qir_to_qis + Stim."""
     prog = Main(
@@ -233,8 +233,8 @@ def test_minus_qir() -> None:
 
 @pytest.mark.optional_dependency
 def test_steane_qir() -> None:
-    """B1: the Steane teleportation uses a classical scalar var
-    (`smid_flag_x` -- a `CReg(..., 3)`); B1's `_pack_creg` lowers
+    """The Steane teleportation uses a classical scalar var
+    (`smid_flag_x` -- a `CReg(..., 3)`); `_pack_creg` lowers
     this scalar reference, so the program builds. The full
     teleportation contains non-Clifford rotations and the executable
     path is out of scope for this test -- assert the build succeeds
@@ -246,7 +246,7 @@ def test_steane_qir() -> None:
 
 @pytest.mark.optional_dependency
 def test_steane_qir_bc() -> None:
-    """B1: same Steane telep program through the QIR bitcode path.
+    """Same Steane telep program through the QIR bitcode path.
     The bitcode builds (no longer fails loud on classical-variable
     lowering)."""
     bc = SlrConverter(telep("X", "X")).qir_bc()

From 1a2ad0c445bb236effc553bbf7643a948b6cfd71 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Fri, 22 May 2026 10:14:20 -0600
Subject: [PATCH 135/136] Strip remaining internal milestone labels from
 comment and message strings (R4/O1-2/S2-S3/Phase 3a-b/M-B2/iter)

---
 .../src/pecos/slr/ast/codegen/guppy.py          | 12 ++++++------
 .../src/pecos/slr/ast/codegen/qir.py            |  2 +-
 .../src/pecos/slr/ast/converter.py              | 17 +++++++----------
 python/quantum-pecos/src/pecos/slr/misc.py      |  2 +-
 .../src/pecos/slr/qeclib/generic/check_1flag.py |  2 +-
 .../slr_tests/ast_guppy/_selene_harness.py      |  2 +-
 .../ast_guppy/test_block_call_smoke.py          | 10 +++++-----
 .../ast_guppy/test_deprecation_warnings.py      |  8 ++++----
 .../regression/random_cases/test_slr_phys.py    | 10 +++++-----
 9 files changed, 31 insertions(+), 34 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
index eee8c6f3e..f04ac40a4 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
@@ -399,7 +399,7 @@ def _validate_block_decl(self, decl: BlockDecl) -> None:
             if not (is_qubit or is_qubit_array or is_bit):
                 msg = (
                     f"BlockDecl {decl.name!r} input {inp.name!r}: only array[qubit, N], "
-                    f"bare qubit, and bare bit inputs are supported in Phase 3a.3 "
+                    f"bare qubit, and bare bit inputs are supported "
                     f"iter 5c (got {type(inp.type_expr).__name__})"
                 )
                 raise GuppyCodegenError(msg)
@@ -414,11 +414,11 @@ def _validate_block_decl(self, decl: BlockDecl) -> None:
                     )
                     raise GuppyCodegenError(msg)
             elif inp.effect is ResourceEffect.SCRATCH:
-                # Scratch ancilla (design v2-scratch-ancilla-effect): the
+                # Scratch ancilla: the
                 # block resets+measures it internally. Guppy allocates it
                 # internally (no parameter), so it must be a bare qubit --
                 # array/bundle scratch is out of scope (Check's ancilla is a
-                # bare qubit; Check1Flag's flag is too but is deferred via O1).
+                # bare qubit; Check1Flag's flag is too but is deferred).
                 if not is_qubit:
                     msg = (
                         f"BlockDecl {decl.name!r} input {inp.name!r}: SCRATCH is "
@@ -429,13 +429,13 @@ def _validate_block_decl(self, decl: BlockDecl) -> None:
             elif inp.effect not in {ResourceEffect.LIVE_PRESERVED, ResourceEffect.CONSUMED}:
                 msg = (
                     f"BlockDecl {decl.name!r} input {inp.name!r}: only LIVE_PRESERVED and "
-                    f"CONSUMED effects are supported in Phase 3a.1 (got {inp.effect.name})"
+                    f"CONSUMED effects are supported (got {inp.effect.name})"
                 )
                 raise GuppyCodegenError(msg)
         if decl.return_op is not None:
             msg = (
                 f"BlockDecl {decl.name!r}: explicit Return inside BlockDecl is not yet "
-                "supported in Phase 3a.1; live_preserved inputs are returned implicitly"
+                "supported; live_preserved inputs are returned implicitly"
             )
             raise GuppyCodegenError(msg)
 
@@ -1702,7 +1702,7 @@ def _validate_block_call_arg(
 
         msg = (
             f"BlockCall {callee!r} {position} for input {inp.name!r}: BlockArg "
-            f"{type(arg).__name__} is not yet supported in Phase 3a.3 iter 5d"
+            f"{type(arg).__name__} is not yet supported"
         )
         raise GuppyCodegenError(msg)
 
diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
index ea84c1a9c..ff67c035f 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/qir.py
@@ -522,7 +522,7 @@ def _process_declarations(self, program: Program) -> None:
                 if decl.size > 64:
                     msg = (
                         f"QIR codegen: CReg {decl.name!r} has {decl.size} bits, "
-                        "but the M-B2-static classical model packs each CReg "
+                        "but the static classical model packs each CReg "
                         "into a single i64 for "
                         "`__quantum__rt__int_record_output` (64-bit cap). "
                         ">64-bit CRegs are not supported by the QIR backend."
diff --git a/python/quantum-pecos/src/pecos/slr/ast/converter.py b/python/quantum-pecos/src/pecos/slr/ast/converter.py
index 7172cd22f..7e70e5400 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/converter.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/converter.py
@@ -528,10 +528,7 @@ def _claim_bit(reg: str, index: int, *, here: str, owner: str) -> None:
                         _claim_qubit(e.reg.sym, e.index, here=where, owner=input_name)
                         remap.add_slot((e.reg.sym, e.index), (input_name, k))
                 elif all(isinstance(e, SlrBit) for e in var):
-                    msg = (
-                        f"{where}: list[Bit] (classical bit bundle / BitBundleArg) "
-                        "is not yet supported in Phase 3a.3"
-                    )
+                    msg = f"{where}: list[Bit] (classical bit bundle / BitBundleArg) is not yet supported"
                     raise ValueError(msg)
                 else:
                     msg = (
@@ -554,7 +551,7 @@ def _claim_bit(reg: str, index: int, *, here: str, owner: str) -> None:
                 raise ValueError(msg)  # noqa: TRY004
             elif isinstance(var, CReg):
                 msg = (
-                    f"{where}: whole CReg input is not yet supported in Phase 3a.3 "
+                    f"{where}: whole CReg input is not yet supported "
                     "(only single Bit via SingleBitArg); pass a single bit `c[i]`"
                 )
                 raise ValueError(msg)  # noqa: TRY004
@@ -571,7 +568,7 @@ def _claim_bit(reg: str, index: int, *, here: str, owner: str) -> None:
             # (the emitter's iter-5b cross-check requires arg == out, by value).
             # SCRATCH is NOT live-preserved -> never in out_bindings (same as
             # CONSUMED); it stays in arg_bindings so the 5e.2 cross-input alias
-            # guard still rejects a scratch slot aliased to another input (O2).
+            # guard still rejects a scratch slot aliased to another input.
             if effect is ResourceEffect.LIVE_PRESERVED:
                 out_bindings.append(arg)
             if effect is ResourceEffect.SCRATCH:
@@ -586,7 +583,7 @@ def _claim_bit(reg: str, index: int, *, here: str, owner: str) -> None:
         self._decl_counter = sub._decl_counter  # type: ignore[attr-defined]
         rewritten_body = tuple(substitute_stmt(stmt, remap) for stmt in sub_body)
 
-        # R4 (scratch design): a SCRATCH input is only sound if the block
+        # A SCRATCH input is only sound if the block
         # resets it before any other use and never touches it after the
         # terminal measurement without re-Prepping. The Guppy lowering
         # allocates the qubit internally on that assumption; validate
@@ -1106,7 +1103,7 @@ def _scratch_events(stmt: Statement, name: str) -> list[str]:
 
     Returns a list drawn from PREP / MEASURE / USE in execution order.
     A reference inside control flow / Parallel / a nested BlockCall /
-    PermuteOp cannot be linearized for the R4 reset-first analysis, so
+    PermuteOp cannot be linearized for the reset-first analysis, so
     it is reported as the sentinel UNSUPPORTED and the validator rejects
     (scratch inputs must have a flat Prep -> ... -> Measure
     lifecycle).
@@ -1173,7 +1170,7 @@ def _validate_scratch_input(
     *,
     cls_name: str,
 ) -> None:
-    """Enforce R4 for a SCRATCH input (design v2-scratch-ancilla-effect).
+    """Enforce the reset-first rule for a SCRATCH input.
 
     The block must reset `name` before any other use, and every Prep
     lifecycle must be closed by a Measure before the next Prep and
@@ -1242,6 +1239,6 @@ def _validate_scratch_input(
         msg = (
             f"{where}: scratch lifecycle not closed -- a Prep has no "
             "terminating Measure; the block must measure the scratch "
-            "qubit before returning (S2 allocates it internally)"
+            "qubit before returning (allocated internally)"
         )
         raise ValueError(msg)
diff --git a/python/quantum-pecos/src/pecos/slr/misc.py b/python/quantum-pecos/src/pecos/slr/misc.py
index 3ce4756e8..2bffdfca6 100644
--- a/python/quantum-pecos/src/pecos/slr/misc.py
+++ b/python/quantum-pecos/src/pecos/slr/misc.py
@@ -138,7 +138,7 @@ def __init__(self, value, *, tag: str | None = None, namespace: str = "result")
         if not isinstance(value, (CReg, Bit)):
             msg = (
                 f"Print(value, ...) requires a CReg or Bit value; got {type(value).__name__}. "
-                "Expression values (e.g. c[0] ^ c[1]) are deferred to v2.1 and must be passed with explicit tag=...; "
+                "Expression values (e.g. c[0] ^ c[1]) are deferred and must be passed with explicit tag=...; "
                 "Phase 1 supports CReg and Bit only."
             )
             raise TypeError(msg)
diff --git a/python/quantum-pecos/src/pecos/slr/qeclib/generic/check_1flag.py b/python/quantum-pecos/src/pecos/slr/qeclib/generic/check_1flag.py
index 15605f54d..eb0bbb87f 100644
--- a/python/quantum-pecos/src/pecos/slr/qeclib/generic/check_1flag.py
+++ b/python/quantum-pecos/src/pecos/slr/qeclib/generic/check_1flag.py
@@ -40,7 +40,7 @@ class Check1Flag(Block):
     # measured inside, allocated internally in Guppy so callers can reuse
     # physical slots across sequential checks); data passes through; the two
     # out bits are live_preserved measurement-result write-backs. The body's
-    # single `PZ(a, flag)` is split into `PZ(a), PZ(flag)` (O1 option
+    # single `PZ(a, flag)` is split into `PZ(a), PZ(flag)` (option
     # (a) -- byte-identical in QASM/Guppy/Selene, confirmed 2026-05-16;
     # one PrepareOp per scratch input avoids multi-destination substitution).
     block_inputs: ClassVar[dict[str, str]] = {
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py
index f56be8509..e6a8868a1 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/_selene_harness.py
@@ -81,7 +81,7 @@ def run_ast_guppy_via_selene(
     if info.explicit_return is None:
         msg = (
             "Selene behavioral test requires an explicit `Return(<creg>...)`. "
-            "Phase 3b removed the implicit result-CReg return; a program with "
+            "The implicit result-CReg return was removed; a program with "
             "no `Return` compiles to `entry() -> None` and has no measurement "
             "record."
         )
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
index 6b5b265dc..ea81246af 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
@@ -2139,7 +2139,7 @@ def __init__(self, x, y) -> None:
 
 class TestScratchEffectS1:
     """Scratch-ancilla effect: `ResourceEffect.SCRATCH`
-    + converter detection + the mandatory R4 reset-first validator + O2.
+    + converter detection + the mandatory reset-first validator.
 
     This stage does NOT lower scratch in Guppy (the internal-allocation
     lowering lands later); until then Guppy must
@@ -2191,7 +2191,7 @@ def test_scratch_detected_excluded_from_out_bindings(self) -> None:
         ast = slr_to_ast(prog)
         call = next(s for s in ast.body if isinstance(s, BlockCall))
         # Scratch `a` is detected as a single-qubit arg and stays in
-        # arg_bindings (O2: the 5e.2 alias guard still applies)...
+        # arg_bindings (the alias guard still applies)...
         assert any(isinstance(a, SingleQubitArg) for a in call.arg_bindings)
         # ...but is NOT live-preserved, so it is absent from out_bindings.
         assert call.out_bindings == (
@@ -2317,7 +2317,7 @@ def __init__(self, a) -> None:
 
     def test_scratch_inside_control_flow_rejected(self) -> None:
         """Conservative scope: a scratch slot touched inside control
-        flow cannot be linearized for the R4 analysis -> reject loudly.
+        flow cannot be linearized for the reset-first analysis -> reject loudly.
         """
         from pecos.slr import CReg, Main, QReg, Repeat, Return
         from pecos.slr.ast import slr_to_ast
@@ -2348,7 +2348,7 @@ def __init__(self, a, out) -> None:
             slr_to_ast(prog)
 
     def test_scratch_aliased_to_other_input_rejected(self) -> None:
-        """O2: scratch stays in arg_bindings, so the 5e.2 cross-input
+        """Scratch stays in arg_bindings, so the cross-input
         aliasing guard still rejects a scratch slot aliased to another
         qubit input.
         """
@@ -2918,7 +2918,7 @@ def test_color488_syn_extract_bare_routes_and_runs(self) -> None:
 
 class TestScratchCheck1FlagS5ProductionLockIn:
     """`Check1Flag` converted (`a`, `flag`: scratch; the body's
-    `PZ(a, flag)` split into `PZ(a); PZ(flag)` per O1 option (a)).
+    `PZ(a, flag)` split into `PZ(a); PZ(flag)`).
     Steane `SynExtractFlagged` reuses ancilla+flag slots across 6
     Check1Flag calls -- it must route every one through a BlockCall,
     compile (12 internal allocs, no LinearityError), and run.
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_deprecation_warnings.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_deprecation_warnings.py
index b5e231838..c18847ebe 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_deprecation_warnings.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_deprecation_warnings.py
@@ -11,7 +11,7 @@
 
 """Hard-contract tests for the v2 output model.
 
-S3 removed the `CReg(result=...)` kwarg, the `RegisterDecl.is_result`
+Removed the `CReg(result=...)` kwarg, the `RegisterDecl.is_result`
 field, and the v1 implicit return of result-flagged CRegs. These tests
 pin those removals as hard contracts: the old knobs now raise, and a
 program must use an explicit `Return(...)` to produce any output.
@@ -29,7 +29,7 @@
 
 
 class TestCRegResultKwargRemoved:
-    """S3: the `CReg(result=...)` kwarg is gone -> hard `TypeError`."""
+    """The `CReg(result=...)` kwarg is gone -> hard `TypeError`."""
 
     def test_creg_result_false_raises_type_error(self) -> None:
         with pytest.raises(TypeError):
@@ -45,7 +45,7 @@ def test_creg_without_result_still_constructs(self) -> None:
 
 
 class TestRegisterDeclIsResultRemoved:
-    """S3: the `RegisterDecl.is_result` field is gone -> hard `TypeError`."""
+    """The `RegisterDecl.is_result` field is gone -> hard `TypeError`."""
 
     def test_register_decl_is_result_raises_type_error(self) -> None:
         with pytest.raises(TypeError):
@@ -59,7 +59,7 @@ def test_register_decl_without_is_result_still_constructs(self) -> None:
 
 
 class TestNoImplicitReturn:
-    """S3: no `Return(...)` means no output (the v1 implicit path is gone)."""
+    """No `Return(...)` means no output (the v1 implicit path is gone)."""
 
     def test_no_return_compiles_to_main_returning_none(self) -> None:
         prog = Main(
diff --git a/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py b/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py
index 41b0c0651..2128487f4 100644
--- a/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py
+++ b/python/quantum-pecos/tests/slr_tests/pecos/regression/random_cases/test_slr_phys.py
@@ -153,8 +153,8 @@ def test_control_flow_qir() -> None:
     # classical-comparison structure.
     qir = SlrConverter(prog).qir()
     # `If(m == 0)` and `If(m < m_hidden)` lower to icmp + i64 packs.
-    assert "icmp" in qir, "B1 If(m == 0) must lower to an icmp"
-    assert "or i64" in qir, "B1 whole-CReg pack must emit OR_i (zext c[i] << i)"
+    assert "icmp" in qir, "If(m == 0) must lower to an icmp"
+    assert "or i64" in qir, "whole-CReg pack must emit OR_i (zext c[i] << i)"
 
 
 @pytest.mark.optional_dependency
@@ -172,7 +172,7 @@ def test_plus_qir() -> None:
         Return(m, n, o),
     )
     qir = SlrConverter(prog).qir()
-    assert "add i64" in qir, "B1 m + n must lower to an i64 add"
+    assert "add i64" in qir, "m + n must lower to an i64 add"
 
     # End-to-end: m=2, n=2, o=m+n=4. Pure-classical + Clifford only,
     # so the program executes through qir_to_qis + Stim.
@@ -220,7 +220,7 @@ def test_minus_qir() -> None:
         Return(m, n, o),
     )
     qir = SlrConverter(prog).qir()
-    assert "sub i64" in qir, "B1 m - n must lower to an i64 sub"
+    assert "sub i64" in qir, "m - n must lower to an i64 sub"
 
     import qir_qis
     import selene_sim
@@ -250,7 +250,7 @@ def test_steane_qir_bc() -> None:
     The bitcode builds (no longer fails loud on classical-variable
     lowering)."""
     bc = SlrConverter(telep("X", "X")).qir_bc()
-    assert bc, "qir_bc must return non-empty bitcode for Steane telep post-B1"
+    assert bc, "qir_bc must return non-empty bitcode for Steane telep"
 
 
 @pytest.mark.optional_dependency

From 54ad3231ff1048fe61210c496bc49fd129b8b6c1 Mon Sep 17 00:00:00 2001
From: Ciaran Ryan-Anderson <ciaranra@gmail.com>
Date: Fri, 22 May 2026 10:25:15 -0600
Subject: [PATCH 136/136] Strip milestone Phase/iter references from comments
 and messages, keeping the two-phase BlockCall algorithm labels

---
 .../src/pecos/slr/ast/codegen/guppy.py        | 20 +++++++++----------
 python/quantum-pecos/src/pecos/slr/misc.py    |  4 ++--
 .../ast_guppy/test_block_call_smoke.py        |  2 +-
 .../tests/slr_tests/ast_guppy/test_print.py   |  8 ++++----
 .../ast_guppy/test_qeclib_selene_corpus.py    |  4 ++--
 5 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
index f04ac40a4..948d2616f 100644
--- a/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
+++ b/python/quantum-pecos/src/pecos/slr/ast/codegen/guppy.py
@@ -350,7 +350,7 @@ def _generate_main(self, program: Program) -> list[str]:
         )
         self._reject_child_allocators()
 
-        # Phase 1 Print AST-level validators (run before emission so failures
+        # Print AST-level validators (run before emission so failures
         # point at the source program, not the generated Guppy).
         self._validate_print_paths(program.body)
         self._validate_print_inline_creg_assignment(program)
@@ -400,7 +400,7 @@ def _validate_block_decl(self, decl: BlockDecl) -> None:
                 msg = (
                     f"BlockDecl {decl.name!r} input {inp.name!r}: only array[qubit, N], "
                     f"bare qubit, and bare bit inputs are supported "
-                    f"iter 5c (got {type(inp.type_expr).__name__})"
+                    f"(got {type(inp.type_expr).__name__})"
                 )
                 raise GuppyCodegenError(msg)
             if is_bit:
@@ -862,8 +862,8 @@ def _validate_print_paths(self, body: tuple[Statement, ...]) -> None:
         If, both `then_body` and `else_body` (recursively) must emit the
         same ordered sequence of Print events. `Repeat(n)` and static-bound
         `For(name, start, stop[, step])` multiply inner signatures by the
-        static trip count. Non-static `For` and `While` reject Prints in
-        Phase 1 since the trip count is not statically known.
+        static trip count. Non-static `For` and `While` reject Prints
+        since the trip count is not statically known.
 
         Side effect: raises `GuppyCodegenError` if any validation fails.
         """
@@ -901,7 +901,7 @@ def _collect_print_path_signature(
                         "Print path-signature mismatch across If branches:\n"
                         f"  Then: {then_sig}\n"
                         f"  Else: {else_sig}\n"
-                        "Phase 1 requires symmetric Print emission across all branches of an "
+                        "Symmetric Print emission is required across all branches of an "
                         "If/Elif chain. Either add the missing Print(s) to the lighter branch, "
                         "or move the Print outside the If."
                     )
@@ -916,7 +916,7 @@ def _collect_print_path_signature(
                     trip = self._static_for_trip_count(stmt)
                     if trip is None:
                         msg = (
-                            "Print inside non-static `For` is not supported in Phase 1. "
+                            "Print inside non-static `For` is not supported. "
                             "Use `Repeat(n)` or `For(name, start, stop)` with literal int "
                             "start/stop/step, or move the Print outside the For body."
                         )
@@ -926,7 +926,7 @@ def _collect_print_path_signature(
                 inner = self._collect_print_path_signature(stmt.body, print_op_cls)
                 if inner:
                     msg = (
-                        "Print inside `While` is not supported in Phase 1 (no static trip "
+                        "Print inside `While` is not supported (no static trip "
                         "count). Move the Print outside the While body."
                     )
                     raise GuppyCodegenError(msg)
@@ -946,7 +946,7 @@ def _static_for_trip_count(self, stmt: ForStmt) -> int | None:
         """Compute static trip count for a `For(name, start, stop[, step])`.
 
         Returns the integer trip count when start/stop/step are all integer
-        literals; returns None otherwise (Phase 1 then rejects Print in the
+        literals; returns None otherwise (Print is then rejected in the
         loop body via `_collect_print_path_signature`).
         """
         start = self._static_int(stmt.start)
@@ -1068,7 +1068,7 @@ def _check_print_inline_read(self, op, assigned: set[tuple[str, int]], inline_cr
             reg = op.value
             if reg not in inline_cregs:
                 return
-            # Reject whole-CReg Print of an inline CReg outright in Phase 1.
+            # Reject whole-CReg Print of an inline CReg outright.
             # The user-stated `CReg(name, size)` size is lost during inline-from-
             # Measure inference (only Measure-targeted bit indices contribute to
             # the inferred RegisterDecl.size). Emitting `result(tag, c)` for the
@@ -1077,7 +1077,7 @@ def _check_print_inline_read(self, op, assigned: set[tuple[str, int]], inline_cr
             # CReg is no longer inline and whole-CReg Print is allowed) or per-bit
             # `Print(c[i], ...)` calls.
             msg = (
-                f"Print(whole-CReg) of inline CReg {reg!r} is rejected in Phase 1. "
+                f"Print(whole-CReg) of inline CReg {reg!r} is rejected. "
                 "Whole-register Print can silently shrink an inline CReg because the "
                 "original `CReg(name, size)` size is lost during inline-from-Measure "
                 f"inference. Declare {reg!r} as a positional in `Main(...)` (then whole-"
diff --git a/python/quantum-pecos/src/pecos/slr/misc.py b/python/quantum-pecos/src/pecos/slr/misc.py
index 2bffdfca6..46bf87a4e 100644
--- a/python/quantum-pecos/src/pecos/slr/misc.py
+++ b/python/quantum-pecos/src/pecos/slr/misc.py
@@ -106,7 +106,7 @@ class Print(Statement):
     name (CReg name, or ``f"{reg}_{index}"`` for a Bit).
 
     Args:
-        value: A CReg or Bit (CReg element). Phase 1 supports these only.
+        value: A CReg or Bit (CReg element). Only these are supported.
             Expression values (e.g. ``c[0] ^ c[1]``), SymbolicBit, and other
             types are rejected at construction time.
         tag: Explicit tag string overriding the derived name. Must match
@@ -139,7 +139,7 @@ def __init__(self, value, *, tag: str | None = None, namespace: str = "result")
             msg = (
                 f"Print(value, ...) requires a CReg or Bit value; got {type(value).__name__}. "
                 "Expression values (e.g. c[0] ^ c[1]) are deferred and must be passed with explicit tag=...; "
-                "Phase 1 supports CReg and Bit only."
+                "Only CReg and Bit values are supported."
             )
             raise TypeError(msg)
 
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
index ea81246af..a6e9eb4b1 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_block_call_smoke.py
@@ -1177,7 +1177,7 @@ def test_qubit_bundle_asymmetric_unpack_order(self) -> None:
 
     def test_qubit_bundle_cross_input_alias_rejected_pre_consume(self) -> None:
         """A slot referenced by two distinct
-        quantum arg_bindings must raise a clean GuppyCodegenError in Phase 1
+        quantum arg_bindings must raise a clean GuppyCodegenError
         (pre-consume), not a mid-Phase-2 LinearityError with the tracker
         half-mutated.
         """
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
index 06083fcf4..fbcad676d 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_print.py
@@ -9,7 +9,7 @@
 # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 # specific language governing permissions and limitations under the License.
 
-"""Phase 1 behavioral tests for `Print(value, *, tag=None, namespace="result")`.
+"""Behavioral tests for `Print(value, *, tag=None, namespace="result")`.
 
 Print lowers to Guppy's `result(name, value)` and surfaces in Selene's parsed
 result dict under the key `f"{namespace}.{tag}"`. Tests verify:
@@ -330,7 +330,7 @@ def test_two_prints_same_tag_become_event_list(self) -> None:
 class TestPathSignatureValidator:
     """Reject asymmetric Print emission across If/Elif branches.
 
-    Phase 1 requires that the ordered sequence of Print events along every
+    The validator requires that the ordered sequence of Print events along every
     conditional path is identical. Selene's parsed-result dict expects
     rectangular tag emission per shot; asymmetric emission triggers a
     register-count mismatch at runtime, so the AST validator fails fast.
@@ -615,13 +615,13 @@ def test_print_inline_bit_with_only_other_bit_measured_rejected(self) -> None:
             SlrConverter(prog).hugr()
 
     def test_whole_inline_creg_print_rejected_outright(self) -> None:
-        """Phase 1 rejects whole-CReg Print of an inline CReg unconditionally.
+        """Whole-CReg Print of an inline CReg is rejected unconditionally.
 
         Even when every inferred bit has been Measure-assigned, whole-CReg
         Print of an inline CReg silently shrinks the register relative to the
         user's CReg(name, size) intent -- inline-from-Measure inference only
         sees Measure-targeted indices, so the inferred RegisterDecl.size can
-        be smaller than what the user wrote. Phase 1 fail-fast: require
+        be smaller than what the user wrote. Fail-fast: require
         explicit Main(...) declaration or per-bit Print.
         """
         inline = CReg("inline", 2)
diff --git a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qeclib_selene_corpus.py b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qeclib_selene_corpus.py
index 29dabb2f4..e8e968e41 100644
--- a/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qeclib_selene_corpus.py
+++ b/python/quantum-pecos/tests/slr_tests/ast_guppy/test_qeclib_selene_corpus.py
@@ -51,8 +51,8 @@
 | `Check1Flag` | qeclib/generic/check_1flag.py | live_preserved data; scratch ancilla/flag; live_preserved out/flag |
 | `transversal_tq` (CX) | qeclib/generic/transversal.py | both registers: live_preserved (no internal measurements) |
 | Steane CX/CY/CZ | qeclib/steane/gates_tq/transversal_tq.py | both registers: live_preserved (converted iters 1+2) |
-| Steane X/Y/Z | qeclib/steane/gates_sq/paulis.py | single register: live_preserved (converted iter 3) |
-| Steane H | qeclib/steane/gates_sq/hadamards.py | single register: live_preserved (converted iter 4) |
+| Steane X/Y/Z | qeclib/steane/gates_sq/paulis.py | single register: live_preserved |
+| Steane H | qeclib/steane/gates_sq/hadamards.py | single register: live_preserved |
 
 """