### neural-conformance: the trained vector is trained and coded on generated pictures, and every vector has a licence record

- **`photo` is generated content.** It coded a third-party picture with no recorded licence for
  redistribution, and its decoder was trained on pictures the corpus did not record. Now its decoder is
  trained on, and its latent codes, dead-leaves pictures that `tools/wai_int_synth_real.py` generates
  from a seed. The vector keeps its name, its shape (a 96 × 8 × 8 int8 latent, a four-layer decoder,
  128 × 128 RGB), its payload format and its capability; its weights, latent and digests are new.
- **`tools/wai_int_synth_real.py` reads no image file.** `picture()` writes each picture from a seed in
  integer arithmetic only, a SplitMix64 stream per picture, so a seed gives the same pictures on every
  machine and every Python: a vertical gradient between two colours, 400 discs painted back to front with
  power-law radii, colours and a linear shading, then noise of ±2. The coded picture is stream 0 of seed
  20261104 and the training pictures are streams 1 to 512, so the decoder never sees the picture it
  codes. Training runs on the CPU, seeded from the same seed, with deterministic algorithms, four threads
  and seeded batches; two runs on one host gave byte-identical files. Its loss is taken before the
  output's clamp: clamped, a decoder whose first outputs fall below 0 gets no gradient and stays black,
  which it did on these pictures. Each layer's weight scale is now chosen so that its shift carries its
  calibrated activation scale exactly; rounding the shift alone left each layer's gain off by up to √2.
  Two runs with the same settings, whose float decoders both reconstruct the coded picture at 18.46 dB,
  lost 3.73 dB in the integer decode the earlier way and 0.44 dB this way.
  `--picture-only` writes one picture, and `--check` regenerates the picture a vector codes from the seed
  in its `meta.json` and requires its reference decode, whose SHA-256 must be the corpus's digest for the
  vector, to reconstruct it at the PSNR `meta.json` records: 18.02 dB, where the same decode scores 8.5
  to 9.5 dB against the training pictures of streams 1 to 5. `--check` also requires the vector's record
  in `licences.json` to state the seed, the coded picture's stream and the training streams `meta.json`
  records, and those training streams to leave out the coded picture's. `--picture-only` and `--check`
  need only the Python standard library. CI runs `--check` on the macOS leg of the conformance
  workflow, and the step after it runs it on a copy whose record gives the training pictures as streams
  1 to 64 and requires it to fail.
- **Regenerated through their generators:** `vectors/photo/` (`int_synth.json`, `latent.bin`,
  `ref_rgb.bin`, `meta.json`) by the tool; `expected_hashes.json` and `sha256.json` by
  `wai_int_synth_vectors gen`, which checked the Rust decode against the tool's integer forward to
  max|Δ| = 0 and left `gradient`, `bloom` and `facade` unchanged; the photo set's certificate and lowered
  graph in `ops-conformance/certificates/` and `index.json`, whose note for the set now says how it was
  made, by `wai-verify vectors gen`; and the demo's byte copies in `wai-web/demo/int_synth/`, whose
  page's menu and README now give the vector's PSNR and say its picture is generated. The set
  still meets `acc64` and fails `acc32` at node 6, `convT.acc`; the wai-ops workflow names its new
  certificate and the new accumulator of the node's witness.
- **Licence records.** `neural-conformance/licences.json` (`wai-corpus-licences/1`) records each
  vector's licence as an SPDX identifier, whether its content is generated here or a third-party input,
  the generator and its input or the source, and, for a trained vector, the same of its training data.
  Every vector is Apache-2.0. `scripts/check-wai-corpus-licences.py`, a step of the repository checks on
  every change, fails on a vector without a record (a directory under `vectors/` or a name in either hash
  manifest), a record for no vector, a licence outside its list of licences that permit redistribution,
  a record that leaves out what its content needs, a trained vector without a training record, and an
  unknown member. `scripts/check-wai-corpus-licences-selftest.sh`, the step before it, builds a scratch
  corpus and shows the check fails each of those ways. CONTRIBUTING (*Corpus content*) states the record.
- **Records kept.** The sink-energy tables measured on the earlier `photo` name its latent by its SHA-256
  in their `procedure.txt`; they are records of those runs and are unchanged. `int_video`'s `video_real`
  is in another corpus and is unchanged; `wai-rs/tests/vectors/README.md` still states that it codes a
  third-party picture.
- **Breaking:** `wire:corpus:wai/neural-conformance/expected_hashes.json`: the `photo` vector is retrained and recoded on generated pictures, so a reader built against the old vector's bytes, weights, digests or PSNR disagrees with the new one.
- **Breaking:** `wire:corpus:wai/neural-conformance/sha256.json`: the `photo` vector is retrained and recoded on generated pictures, so a reader built against the old vector's bytes, weights, digests or PSNR disagrees with the new one.
- **Breaking:** `wire:corpus:wai/neural-conformance/vectors/photo/int_synth.json`: the `photo` vector is retrained and recoded on generated pictures, so a reader built against the old vector's bytes, weights, digests or PSNR disagrees with the new one.
- **Breaking:** `wire:corpus:wai/neural-conformance/vectors/photo/latent.bin`: the `photo` vector is retrained and recoded on generated pictures, so a reader built against the old vector's bytes, weights, digests or PSNR disagrees with the new one.
- **Breaking:** `wire:corpus:wai/neural-conformance/vectors/photo/meta.json`: the `photo` vector is retrained and recoded on generated pictures, so a reader built against the old vector's bytes, weights, digests or PSNR disagrees with the new one.
- **Breaking:** `wire:corpus:wai/neural-conformance/vectors/photo/ref_rgb.bin`: the `photo` vector is retrained and recoded on generated pictures, so a reader built against the old vector's bytes, weights, digests or PSNR disagrees with the new one.
- **Breaking:** `wire:corpus:wai/ops-conformance/certificates/index.json`: the operator certificate for `wai.neural.int_synth` certifies the retrained decoder, so its digest, its record and its packed weights are new.
- **Breaking:** `wire:corpus:wai/ops-conformance/certificates/wai.neural.int_synth/50868e72f5f1599569c413ed1f67ab8610fa0b3c17919162cbf370f49275125c.json`: the operator certificate for `wai.neural.int_synth` certifies the retrained decoder, so its digest, its record and its packed weights are new.
- **Breaking:** `wire:corpus:wai/ops-conformance/certificates/wai.neural.int_synth/50868e72f5f1599569c413ed1f67ab8610fa0b3c17919162cbf370f49275125c/synth.whg1`: the operator certificate for `wai.neural.int_synth` certifies the retrained decoder, so its digest, its record and its packed weights are new.
