Design: images only runners hold, moved by the swarm (refs #94) 3e3cc9475ab3

#### 8.1.1 Images only runners hold (oxygenflow#94, oxygenhub#342)

Until now an image had to be sent to the hub (`flow rootfs push`) before any

runner but the one that imported it could take its jobs: the hub hands out

the manifest, and placement offers a job to a runner that fetches only when

the hub holds its image. On 2026-10-25 the Rust image was re-pinned and not

pushed, and for a day every Rust job queued on the one runner that had

imported it while the others sat idle.

- **Runners say what they hold.** A claim already lists the images a runner

  holds. When the hub keeps no manifest for one of them, the claim's answer

  asks for it (`send_manifests`), and the runner sends the manifest alone

  (`PUT /flow/images/{hash}/held`, a few MB even for a 14 GB image): no

  chunks.

- **The hub keeps it as peer-held.** It checks the manifest is well formed

  and names the hash it is filed under, and records the image as held by

  runners, not by itself: it cannot read the image to check it. A pushed

  image (`flow rootfs push`, verified whole) replaces a peer-held record.

- **Trust still comes from the hashes.** The pipeline pins the image's hash;

  a fetcher asks for the manifest by that hash, checks every chunk against

  its name, and checks the assembled image against the pin before it keeps

  it (`jet::images::assemble`). A wrong manifest can make a fetch fail; it

  cannot change what a job runs. Only runner tokens may send one.

- **Placement counts peers.** A job whose image the hub holds only as

  peer-held goes to a runner that fetches only when a runner of the same

  swarm site holds the image, and says so when none does ("held only by

  earth-1, in another site").

- **The hub is no seed for it.** The announce answer says whether the hub

  holds the chunks (`seed`); when it does not, the fetcher asks peers only,

  and a fetch with no peer left fails with that reason rather than after

  the hub refused chunk after chunk.