### wai-quantum: simulator scale-out, the state vector on the fabric's members

- **Placement** (`engine::fabric`): a job's new `fabric` field says where the `statevector` method's state runs:
  `auto` (the default), `cpu`, `accelerator`, a member's id or key, or a list of members, a power of two of them,
  the state split by its top qubits into one partition on each. The CUDA, HIP and OpenCL members' dense f64 state
  vectors (`quantum_fabric::sv64`) are discovered once per process, compiled and certified against the CPU on the
  pinned corpus; only a member certified bit-exact is placed, so a placed job's answers are the CPU's byte for
  byte. **`auto` places on the CPU** on every host until a member is measured faster than the CPU: with one launch
  per gate and the state copied to the device and back, a whole job took about as long either way, or longer on the
  GPU, between 18 and 22 qubits on the fleet's GPUs. A member runs a job only when the job asks for one:
  `accelerator` takes the first certified member that holds the state, GPUs first, and one that fails during the run
  hands the job to the next, the receipt listing each that failed (`fell_back_from`). A placement the host cannot
  honour is refused with the new code `J013`, never made elsewhere. A job that does not ask has the plan and result
  it always had, on every host; the pinned digests are unchanged.
- **The fabric's receipt in the job's**: a placed result, or one whose job asked for a placement, carries `fabric`
  (the kernel, the placement asked, the member or each partition's, its certificate's parity tier, digest and
  corpus, and the energy, unmetered with the reason), sealed by the job's receipt; its provenance's `computer`
  names the members. New optional members of `wai.quantum.job-request/1`, `wai.quantum.job-result/1` and
  `wai.quantum.provenance/1`, and `fabric_members` in `wai.quantum.tools/1`.
- **Several devices on one node** (`quantum_fabric::sv64::run_split`): each partition runs the launches the CPU
  plans on its own amplitudes, each runner on a thread of its own; a gate on a partition qubit first has that qubit
  exchanged with a local one through the host's copy of the state. Held bit for bit to the CPU's state vector over
  the pinned corpus at every partition count a case admits and on wide states with exchanges, on CPU partitions in
  every container. On the fleet: a laptop GPU by CUDA and by OpenCL, the CPU by OpenCL and the CPU reference,
  one state split four ways over them; an integrated GPU by HIP and by OpenCL; and each GPU beside the CPU and split
  over itself, each giving the CPU's answers byte for byte. Each member states the most qubits it holds (25 on every GPU
  here), and a state or partition past it is refused before anything runs.
- **Members' runs from a given state**: `CudaSv::run_launches`, `HipSv::run_launches` and
  `OpenClSv::run_launches`, with `max_qubits`, each refusing a state or a launch outside what it holds.
- **Surfaces**: `wai-quantum run --fabric` (repeatable) and `wai-quantum fabric [--json]`, the command line's
  `cuda`, `hip` and `opencl` features; `fabric` in both MCP servers' job tools and `list_fabric` on the command
  line's; the job service reads `fabric` and places on its CPU. The generated agent docs carry it.
- **CI**: `tests/fabric_placement.rs` on jetson-hub (CUDA and OpenCL) and framework-128gb (HIP and OpenCL) in the
  hardware workflows, each with its declared members and a split over them, and absent where there is no device;
  the split and the planner's refusals in the containers.
- **Stabilizer-rank Clifford+T** (`quantum_stabrank`, the method `stabilizer_rank`): a T gate is a sum of two
  Clifford gates of equal weight, so a circuit with `t` T and T† gates is a sum of `2^t` stabilizer states, each run
  exactly on the phased tableau, whose new `PhasedTableau::amplitudes` gives every amplitude of a stabilizer state
  exactly from one reduction. Every term is counted as a whole number (`ExactSum`), so the sum does not depend on
  how the branches are split between threads; an expectation value is the amplitude `⟨0|U†PU|0⟩`. The exact mode's
  terms grow as `2^t` (`4^t` for an expectation value); the sampled mode (`terms`, or `epsilon`, at `confidence`)
  draws branches uniformly and states the bound `sqrt((sec²(π/8)^t − 1) / (terms · (1 − confidence)))` on each
  value with its confidence, computed from the T count, the terms and the confidence. `Program::clifford_t` lowers
  `t`, `tdg`, `p`, `rz`, `rx` and `ry` at odd multiples of π/4, `cp` at odd multiples of π/2, `ccz` and `ccx` with
  the global phase kept exactly. Held to the dense state vector by every amplitude and by fidelity, never by hash.
  `auto` takes it for amplitudes or expectation values past the dense state vector when its branches fit one job's
  work, so it is chosen by the T count; it reaches the methods list, both MCP servers, the service and the Studio
  (its plain name in English and Simplified Chinese, the views page rebuilt in the CI image) by the same name. The result's accuracy, amplitudes and expectation values gain optional `t_count`, `terms`, `bound` and
  `confidence` (`wai.quantum.job-result/1`), and the class `estimate` now also covers a bound with the probability it
  holds.

