@rig-c/core 2.82.1 → 2.82.2

package/README.md

@@ -26,7 +26,7 @@ name. Both remain published alongside it with the same product files.
 
 <p align="center"><em>Fourteen part PNGs drawn from scratch for this repo, one rig spec, one motion spec — the assembly,
 the breathing and the wave are all rigc-compiled Spine animations, rendered with
-<code>rigc render</code>. A <a href="https://raw.githubusercontent.com/rig-c/core/main/assets/rigc-demo@2x.gif">2x version</a> (1200x810) sits beside it.</em></p>
+<code>rigc render</code>. A <a href="https://raw.githubusercontent.com/rig-c/core/main/assets/rigc-demo@2x.gif">2x assembly film</a> (1200x810) sits beside it.</em></p>
 
 Loose part PNGs and two small JSON files in; **Spine 4.3 skeleton data out** — a
 `skeleton.json` and a `skeleton.atlas` that load in any Spine runtime and **import
@@ -44,7 +44,7 @@ installed.
 | a compiled rig and a question about its geometry | `rigc inspect` | one picture of its bones, axes, mesh edges and hulls, one bone's weights, the triangles folded over, the draw order, a world grid or a declared axis over the art — at the setup pose, one time or a sheet of several, zoomed to a bone or a slot, or beside a second build on one transform — and a legend that puts every mark back in world units |
 | a compiled rig | `rigc preview` | one self-contained `.html` that plays it in Spine's own web player |
 | two to four compiled rigs | `rigc vote` | one ballot page a human picks from, and the answer checked into a ledger |
-| a picture of a key pose | `rigc pose` | where each loose part PNG sits in it, in spec coordinates — the movement between two poses is then yours to key ([docs/MOTION.md](docs/MOTION.md)) |
+| a picture of a key pose | `rigc pose` | where each loose part PNG sits in it, in spec coordinates — the movement between two poses is then yours to key ([the motion recipe](docs/MOTION.md)) |
 | the same picture, and a rig | `rigc chainfit` | the parts `pose` refuses because something is drawn over them — read through the candidate's own draw order and hierarchy, with the share of each part the answer was measured on |
 
 Everything in that table needs Bun and this package — `preview` and `vote` also
@@ -54,8 +54,8 @@ reference art, no art pipeline, no server.
 ### Depth-driven rigging
 
 Explicit depth, which a drawing alone does not state, makes facial features
-shift by different amounts during a small head turn: [`gallery/portrait`](https://github.com/rig-c/core/tree/main/gallery/portrait)
-uses per-part depths, while [`gallery/look`](https://github.com/rig-c/core/tree/main/gallery/look)
+shift by different amounts during a small head turn: [the portrait depth example](https://github.com/rig-c/core/tree/main/gallery/portrait)
+uses per-part depths, while [the mesh-depth look example](https://github.com/rig-c/core/tree/main/gallery/look)
 samples a depth map at the mesh vertices.
 With [`@rig-c/parts`' depth fields](https://github.com/rig-c/parts/blob/main/docs/AUTHORING.md#per-layer-depth-sheets-773),
 See-through's per-layer sheets are bound explicitly with `near` and `zScale`,
@@ -106,7 +106,7 @@ it cuts both ways:
 
 ### Licensing, stated plainly
 
-See [NOTICE.md](NOTICE.md) for licensing and third-party terms.
+See [the licensing notice](NOTICE.md) for licensing and third-party terms.
 
 The problem rigc is aimed at is narrow. An agent asked to author a rig has no way
 to tell whether it succeeded: Spine's JSON parser accepts a great deal of nonsense
@@ -190,7 +190,7 @@ reference frames this project renders from them, which **are** committed, each
 example's own `license.txt` beside them under the redistribution grant those files
 carry; the images stay **non-commercial only**. The reasoning is in
 [`bench/reference/README.md`](https://github.com/rig-c/core/blob/main/bench/reference/README.md)
-and the terms in [NOTICE.md](NOTICE.md). It needs a clone and `bun run
+and the terms in [the reference-image notice](NOTICE.md). It needs a clone and `bun run
 fetch-examples`, and says so by name when the corpus is absent. `check` is not one
 of them: it reads whatever frames you point it at, so it runs from the installed
 package on pictures of your own — which is what *Where to go next* below tells you
@@ -446,7 +446,7 @@ origin and tip in world units and in pixels, so a position read off the picture
 straight back into the spec. [AUTHORING §13](docs/AUTHORING.md#13-asking-the-picture-a-question--rigc-inspect)
 maps each question to its view.
 
-**`render`** writes PNG frames and a contact sheet; **`preview`** writes a playable HTML file — see [AUTHORING §0](docs/AUTHORING.md#0-the-loop).
+**`render`** writes PNG frames and a contact sheet; **`preview`** writes a playable HTML file — see [the render and preview reference](docs/AUTHORING.md#0-the-loop).
 
 **7. Let someone choose.** Sooner or later you will have two builds that both pass
 the gate and no instrument that can separate them. `vote` puts them in one page
@@ -466,7 +466,7 @@ that does not belong to it. See
 
 **Where to go next.**
 
-- 📘 **[docs/AUTHORING.md](docs/AUTHORING.md)** is the real guide — both files
+- 📘 **[the authoring guide](docs/AUTHORING.md)** is the real guide — both files
   field by field, the emission rules, every named failure mapped to the file that
   has to change, and §8–§9 for reproducing a shot you were given as pictures. It
   ships inside the npm package too, at
@@ -490,11 +490,11 @@ that does not belong to it. See
   it, so a figure is read against that rather than against a number from a page;
   AUTHORING.md §9.2 says what the two halves of that bound are and why the floor
   is not zero.
-- [docs/LADDER.md](https://github.com/rig-c/core/blob/main/docs/LADDER.md) is the benchmark: the same job, from a brief
+- [the benchmark ladder](https://github.com/rig-c/core/blob/main/docs/LADDER.md) is the benchmark: the same job, from a brief
   and rendered frames, scored. [docs/PILOT.md](https://github.com/rig-c/core/blob/main/docs/PILOT.md) is how to run an
   agent through it and score what comes back.
 - 🤖 **Handing the authoring to an AI agent?**
-  [docs/PROMPTING.md](docs/PROMPTING.md) is the operator's page — the six prompt
+  [the prompting guide](docs/PROMPTING.md) is the operator's page — the six prompt
   clauses a measured pilot run paid for, and what you can leave unsaid.
 
 ## See what you built, and let someone choose
@@ -514,7 +514,7 @@ a rig compiles green, because green says nothing at all about the picture.
 conditions, <code>rigc pose</code> reads where every part sits in each picture, two
 candidate in-betweenings are compiled from the same pair — and a real
 <code>rigc vote</code> ballot picks the winner, because the movement between the poses
-is the one thing no instrument here will grade. A <a href="https://raw.githubusercontent.com/rig-c/core/main/assets/rigc-keypose@2x.gif">2x version</a> (1200x810) sits beside it.</em></p>
+is the one thing no instrument here will grade. A <a href="https://raw.githubusercontent.com/rig-c/core/main/assets/rigc-keypose@2x.gif">2x key-pose film</a> (1200x810) sits beside it.</em></p>
 
 Three properties of `vote` are worth stating, because they are what make its ledger
 usable by the next agent rather than by a reader: **a tie is a recorded outcome, not a
@@ -525,7 +525,7 @@ anywhere; and **every line carries a reason code** from a closed enumeration tha
 enforced, so *"tie, because this one is better"* is refused.
 
 🎞️ **Authoring the movement those pages show you** — key poses, in-betweening, and how
-to spread candidates so a ballot informs — is [docs/MOTION.md](docs/MOTION.md).
+to spread candidates so a ballot informs — is [the motion authoring guide](docs/MOTION.md).
 
 📐 **`rigc pose --images parts/ --frame poseA.png` runs the other way.** Every command
 above takes something you authored and tells you about it; this one takes a **picture
@@ -568,7 +568,7 @@ while <code>gaze</code> and <code>turn</code> return to rest, so the hand-offs m
 differing pixels — and the composing is the consumer's. Authorable on plain Spine 4.3, no
 plugin, no runtime patch; what the turn costs is authoring rather than runtime capability,
 and that cost is one stated expression per key. Compiled and rendered entirely by the
-published package. A <a href="https://raw.githubusercontent.com/rig-c/core/main/assets/rigc-scene@2x.gif">2x version</a> (1200x810) sits beside it.</em></p>
+published package. A <a href="https://raw.githubusercontent.com/rig-c/core/main/assets/rigc-scene@2x.gif">2x portrait film</a> (1200x810) sits beside it.</em></p>
 
 🎞️ **How the three films on this page were made** is kept with them, one directory per
 film in [`films/`](https://github.com/rig-c/core/tree/main/films) — a `run.sh` that
@@ -582,32 +582,34 @@ material, like the gallery: a clone runs them.
 
 | Command | Does |
 | --- | --- |
-| `build` | Compile, gate and write the rig. [Reference](docs/AUTHORING.md#0-the-loop). |
-| `validate` | Re-gate artifacts already on disk. [Reference](docs/AUTHORING.md#0-the-loop). |
-| `repack` | Repack a build from its output. [Reference](docs/AUTHORING.md#0-the-loop). |
-| `ingest` | Read a skeleton back into specs. [Reference](docs/AUTHORING.md#0-the-loop). |
-| `split` | Separate disconnected mesh pieces. [Reference](docs/AUTHORING.md#0-the-loop). |
-| `explain` | Print the compiled rig as a table. [Reference](docs/AUTHORING.md#0-the-loop). |
-| `render` | Write PNG frames and a contact sheet. [Reference](docs/AUTHORING.md#0-the-loop). |
-| `preview` | Write a playable HTML preview. [Reference](docs/AUTHORING.md#0-the-loop). |
-| `vote` | Make a ballot and record its answer. [Reference](docs/AUTHORING.md#0-the-loop). |
-| `pose` | Read part placements from a picture. [Reference](docs/AUTHORING.md#0-the-loop). |
-| `chainfit` | Read occluded parts through a candidate rig. [Reference](docs/AUTHORING.md#0-the-loop). |
-| `diff` | Compare two skeletons structurally. [Reference](docs/AUTHORING.md#0-the-loop). |
-| `bonedist` | Measure per-bone world-transform distance. [Reference](docs/AUTHORING.md#0-the-loop). |
-| `check` | Compare a candidate against reference pictures. [Reference](docs/AUTHORING.md#0-the-loop). |
-| `bench` | Run a rung of the benchmark ladder. [Reference](docs/AUTHORING.md#0-the-loop). |
-| `guide` | Read a named failure or guide section. [Reference](docs/AUTHORING.md#0-the-loop). |
-| `skills install` | Install the packaged agent skills. [Reference](docs/AUTHORING.md#0-the-loop). |
-| `review` | Hand a build to the review package. [Reference](docs/AUTHORING.md#0-the-loop). |
-
-### Starting from a skeleton you already have
-
-See [INGEST: Starting from a skeleton you already have](docs/INGEST.md#starting-from-a-skeleton-you-already-have) for the ingest-and-rebuild loop.
-
-### The editor round trip — for a licence holder, never in CI
-
-See [INGEST: The editor round trip](docs/INGEST.md#the-editor-round-trip--for-a-licence-holder-never-in-ci) for the licensed-editor workflow.
+| `build` | Compile, gate and write the rig. [`build` in the CLI reference](docs/AUTHORING.md#cmd-build) |
+| `validate` | Re-gate artifacts already on disk. [`validate` in the CLI reference](docs/AUTHORING.md#cmd-validate) |
+| `repack` | Repack a build from its output. [`repack` in the CLI reference](docs/AUTHORING.md#cmd-repack) |
+| `ingest` | Read a skeleton back into specs. [`ingest` in the CLI reference](docs/AUTHORING.md#cmd-ingest) |
+| `split` | Separate disconnected mesh pieces. [`split` in the CLI reference](docs/AUTHORING.md#cmd-split) |
+| `explain` | Print the compiled rig as a table. [`explain` in the CLI reference](docs/AUTHORING.md#cmd-explain) |
+| `render` | Write PNG frames and a contact sheet. [`render` in the CLI reference](docs/AUTHORING.md#cmd-render) |
+| `preview` | Write a playable HTML preview. [`preview` in the CLI reference](docs/AUTHORING.md#cmd-preview) |
+| `vote` | Make a ballot and record its answer. [`vote` in the CLI reference](docs/AUTHORING.md#cmd-vote) |
+| `pose` | Read part placements from a picture. [`pose` in the CLI reference](docs/AUTHORING.md#cmd-pose) |
+| `chainfit` | Read occluded parts through a candidate rig. [`chainfit` in the CLI reference](docs/AUTHORING.md#cmd-chainfit) |
+| `diff` | Compare two skeletons structurally. [`diff` in the CLI reference](docs/AUTHORING.md#cmd-diff) |
+| `bonedist` | Measure per-bone world-transform distance. [`bonedist` in the CLI reference](docs/AUTHORING.md#cmd-bonedist) |
+| `check` | Compare a candidate against reference pictures. [`check` in the CLI reference](docs/AUTHORING.md#cmd-check) |
+| `bench` | Run a rung of the benchmark ladder. [`bench` in the CLI reference](docs/AUTHORING.md#cmd-bench) |
+| `guide` | Read a named failure or guide section. [`guide` in the CLI reference](docs/AUTHORING.md#cmd-guide) |
+| `skills install` | Install the packaged agent skills. [`skills install` in the CLI reference](docs/AUTHORING.md#cmd-skills-install) |
+| `review` | Hand a build to the review package. [`review` in the CLI reference](docs/AUTHORING.md#cmd-review) |
+
+### Existing skeletons and the editor
+
+<a id="starting-from-a-skeleton-you-already-have"></a>
+<a id="the-editor-round-trip--for-a-licence-holder-never-in-ci"></a>
+
+For a skeleton you already have, [the ingest-and-rebuild loop](docs/INGEST.md#starting-from-a-skeleton-you-already-have)
+turns a Spine 4.3 export into rig and motion specs, then checks that rebuilding them reproduces it.
+For a licence holder, [the editor round trip](docs/INGEST.md#the-editor-round-trip--for-a-licence-holder-never-in-ci)
+imports a build into the Spine editor and checks the export against that build with the gate, structural diff and rendered frames; it never runs in CI.
 
 ## Documentation
 
@@ -625,7 +627,7 @@ See [INGEST: The editor round trip](docs/INGEST.md#the-editor-round-trip--for-a-
 | 🧬 [GENERATIONS.md](https://github.com/rig-c/core/blob/main/docs/GENERATIONS.md) | **Spine data from another generation.** Why a 3.8–4.2 file read as 4.3 fails in silence, the policy that follows (detect from `skeleton.spine`, never guess, play on the matching runtime), what `A16` and `ingest` do with such a file, and the editor as the migration path. Repository material |
 | 📓 [CASES.md](https://github.com/rig-c/core/blob/main/docs/CASES.md) | **converting a Live2D model to Spine, and verifying the conversion.** The method — the source's own player headless, parts from its texture along the drawables, motion baked as deform keys, reference frames first, `check` — run once end to end on two Live2D sample models with no editor and no converter, and verified against the source's renderer and Spine's own runtime: the three instruments, the two rigc defects verifying it led to and v1.2.1 fixed, and where the method stops. Figures only — the models' licence keeps every asset out. Repository material |
 | 🗺️ [ROADMAP.md](https://github.com/rig-c/core/blob/main/ROADMAP.md) | where this is going, and where it has been. What 1.0 had to mean before the number was claimed, and what it was claimed on — conditions rather than a feature list, because direction here comes from what users hit |
-| 📐 [CLAUDE.md](https://github.com/rig-c/core/blob/main/CLAUDE.md) | **the doctrine** — why the validator's messages are the product, why nothing reaches disk before green, why no number is ever invented, and what a change has to keep. [CONTRIBUTING.md](https://github.com/rig-c/core/blob/main/CONTRIBUTING.md) calls it worth ten minutes before a first patch. Repository material |
+| 📐 [CLAUDE.md](https://github.com/rig-c/core/blob/main/CLAUDE.md) | **the doctrine** — why the validator's messages are the product, why nothing reaches disk before green, why no number is ever invented, and what a change has to keep. [the contribution guide](https://github.com/rig-c/core/blob/main/CONTRIBUTING.md) calls it worth ten minutes before a first patch. Repository material |
 
 [Dated survey](https://github.com/rig-c/core/blob/main/docs/SURVEY_2026-08-22.md).
 
@@ -649,7 +651,7 @@ attributability is **measured** to be capped below the bar reads down when every
 observable about it is independently verified strict. Every other rung and the
 graduation exam pass on the clause itself. Recompiling a stored candidate reproduces its
 record **to the digit within one gate**; across an instrument change the digits move,
-and [docs/LADDER.md](https://github.com/rig-c/core/blob/main/docs/LADDER.md) records
+and [the gate re-inspection ledger](https://github.com/rig-c/core/blob/main/docs/LADDER.md) records
 where. The standing figures quoted above are from its *gate-v2.4 re-inspection*, which
 is the current sweep.
 
@@ -668,13 +670,13 @@ a from-zero run is a tooling-progress measurement rather than a re-climb, which
 why the certification above is scoped to tool + guide + protocol. One of those
 attempts states the residual in its own words: *"in motion it is not at editor
 quality."* All six, with their verdicts, are in
-[docs/LADDER.md](https://github.com/rig-c/core/blob/main/docs/LADDER.md).
+[the from-zero attempt records](https://github.com/rig-c/core/blob/main/docs/LADDER.md).
 
 The whole dossier — the yardstick, `diff` and `check` and what neither of them can
 see, every rung, the run viewer, the 50 assertions and the selftest behind them — is
 [docs/BENCHMARK.md](https://github.com/rig-c/core/blob/main/docs/BENCHMARK.md).
 Live rung status is
-[docs/LADDER.md](https://github.com/rig-c/core/blob/main/docs/LADDER.md).
+[recorded in the ladder ledger](https://github.com/rig-c/core/blob/main/docs/LADDER.md).
 
 ## Contributing
 

package/docs/AUTHORING.md

@@ -120,27 +120,27 @@ commands take it and what its default is.
 
 | Command | Does |
 | --- | --- |
-| `build --rig … --motion … --out …` | compiles, gates, and **writes only if the gate is green**. `--images <dir>` says where the rig spec's `image` names resolve, `--manifest` adds measured art, and `--copy-images` copies every page PNG into `--out` so the directory is self-contained, with `skeleton.images` pointing at it so the editor's import finds the parts |
+| `build --rig … --motion … --out …` | compiles, gates, and **writes only if the gate is green**. `--images <dir>` says where the rig spec's `image` names resolve, `--manifest` adds measured art, and `--copy-images` copies every page PNG into `--out` so the directory is self-contained, with `skeleton.images` pointing at it so the editor's import finds the parts <a id="cmd-build"></a> |
 | `build … --pack` | the same build with every part arranged onto **shared** atlas pages, written into `--out` — losslessly, and gated a second time as the pair that ships. `--page-size`, `--padding`, `--page-edges` and `--pack-shape` tune it — `--pack-shape polygon` lets a neighbour sit inside a mesh's rectangle where its hull is not, and with `--page-edges free` costs 12–56 times `rect`'s pack (3–11 s against 0.2–0.3 s on 90–144 parts over two to four pages; past 5 s from about 60 parts, a second or so below 45 on one page — AUTHORING §0.1) |
 | `build … --atlas-in <file.atlas>` | the same build with every part resolved to a **region of an existing pack** instead of a loose PNG; a name the atlas lacks, a size the spec disagrees with or a rectangle off its page is refused by name |
-| `validate <dir>` | re-gates artifacts already on disk |
-| `repack <dir> --out <dir>` | a packed build **repacked from its own output** — `skeleton.json`, `skeleton.atlas` and the pages, with no parts kept — under the packing flags `build --pack` takes, so a packer improvement reaches a build whose parts are gone. Every region is lifted off its page, the skeleton read back with `ingest`, and `build --pack` run over the lifted parts with the same gate; it writes only after every region is shown pixel-identical to the input's, the skeleton byte-identical and the gate green, and refuses by name an atlas it cannot lift exactly. A skeleton the rebuild does not reproduce byte for byte — a build written before 2.2.0, whose header box was its stage — is refused naming every differing path, and written, every path printed, only under `--accept-skeleton-differences`. `--stage-box <slot>` reads the stage from the box a build carries for it (`skeleton.stageBox`), the one way the three files alone carry the stage exactly ([AUTHORING §0.4](../docs/AUTHORING.md)) |
+| `validate <dir>` | re-gates artifacts already on disk <a id="cmd-validate"></a> |
+| `repack <dir> --out <dir>` | a packed build **repacked from its own output** — `skeleton.json`, `skeleton.atlas` and the pages, with no parts kept — under the packing flags `build --pack` takes, so a packer improvement reaches a build whose parts are gone. Every region is lifted off its page, the skeleton read back with `ingest`, and `build --pack` run over the lifted parts with the same gate; it writes only after every region is shown pixel-identical to the input's, the skeleton byte-identical and the gate green, and refuses by name an atlas it cannot lift exactly. A skeleton the rebuild does not reproduce byte for byte — a build written before 2.2.0, whose header box was its stage — is refused naming every differing path, and written, every path printed, only under `--accept-skeleton-differences`. `--stage-box <slot>` reads the stage from the box a build carries for it (`skeleton.stageBox`), the one way the three files alone carry the stage exactly ([AUTHORING §0.4](../docs/AUTHORING.md)) <a id="cmd-repack"></a> |
 | `repack <dir> --out <dir> --keep-pages` | **`skeleton.model.json` alone, for the pages already in place** — for a player that reads the document beside an atlas and pages that already shipped. The same read and stage rules, then `build --atlas-in` over the input atlas in place of the lift and the pack; it writes the document, and nothing else, only after its `pages` are shown to state the atlas as it stands, the rebuilt skeleton byte-identical to the one on disk (so `spine.sha256` names it — no acceptance flag here) and the gate green. `--out` is usually the build's own directory and must not already hold a `skeleton.model.json`; a page or region line the document has no field for is refused by name ([AUTHORING §0.4](../docs/AUTHORING.md)) |
-| `ingest <skeleton.json> --out <dir>` | `build` run backwards: reads a Spine 4.3 skeleton and writes the rig spec and motion spec that **rebuild it**, plus a findings report naming everything it could not carry. a skeleton that declares no stage is carried as declaring none, `--stage x,y,w,h` adds a box to one — and is refused, rather than ignored, beside one that declares a box — and `--images <dir>` writes the spec's own images directory — the opposite direction from `build --images`, which overrides it — so the rebuild carries no flag at all |
-| `split --rig … --motion … --slot <name> --out <dir>` | the answer to a mesh refused because its triangles are **several pieces that share no vertex** — two legs after the triangles bridging them were deleted. It reads the two specs and writes them back into an absent or empty `--out` with one mesh per piece: piece 1 stays in the slot, piece k gets a new slot `<slot>_<k>` after it, each with the original's uvs and weights unchanged, its triangles renumbered outline first where the hull rule needs it, and every deform key re-sliced to the new indices — plus `split.json`, where every original vertex and triangle went. One piece is said so and nothing is written; what it cannot carry is refused by name ([AUTHORING §3.4.11](../docs/AUTHORING.md)) |
-| `explain --rig … --motion …` | the compiled rig as a table — every bone with its resolved parent, the slots in draw order, every timeline key by key. Writes nothing. What to reach for when a rig compiles and still looks wrong |
-| `render --candidate <dir>` | PNG frames plus a contact sheet, in `render/`, one directory per set: `<anim>@<fps>fps/` rather than `<anim>/` at any rate but the default — `--fps 24` writes `<anim>@24fps/`, and the default 12 writes `<anim>/`. `--hide <slot,…>` or `--slot <slot,…>` draws part of the rig on the **same grid** as the whole, so the two frames overlay and the difference is the part; `frames.json` records the subset and `check` refuses such a set as a reference. `--geometry` adds a `geometry.json` per set: every frame's bone world transforms and skinned attachment vertices, with the rest geometry, on the frames' own grid. `--folds` adds a `folds.json` per set and prints one line per mesh with a triangle turned over against the setup pose: the frames, the worst frame's count and which triangles, their world box and their setup-pose area. `--pass-through <cloth>:<leg>` adds a `pass-through.json` per set and prints the frames where a cloth drawn over a leg has its side inside the leg's drawn outline, with the depth and the world box — a reading, not a gate. `--seam <slot>:<slot>` adds a `seam.json` per set and prints, per pair, the frames where two slots that meet open background inside the joint (a gap) or show the overlap band of one past the other (a ghost), with the worst frame's cell count and world box; `ghostA` and `ghostB` partition the same ghost by which named pair member drew it, each with its own frames, spans and worst; `gapOpen` and `gapCovered` partition `gap` by zero versus positive rendered alpha from the whole skeleton, including faint and clipped drawings ([AUTHORING §8.8](../docs/AUTHORING.md#88-where-two-slots-stop-meeting--render---seam)) — a reading, not a gate; the exit status never moves. `--overlaps` adds an `overlaps.json` per set and prints one `OVERLAP "<under>" under "<over>"` line per pair of slots where the one drawn later covers the earlier one and the motion moves it — the frames, and the most pixels covered and the frame of them — with an outline plate per covered frame; the render reports what was drawn, and the draw-order key is the author's remedy — a reading, not a gate. `--extremes` adds `extremes.json` and a native six-panel `extremes.png` (setup, geometry-pair min/max and three premultiplied RGBA diffs with a legend), plus one `EXTREMES` line per set. Per-channel minima/maxima and the farthest original-vertex geometry pair are distinct readings; valid channel extrema survive a geometry/image SKIP, with channel refusals reported separately; still or uncomparable geometry reports a named SKIP without changing render exit status. `--extremes-only` writes the same `extremes.json` and readable `extremes.png` bytes while skipping ordinary frame rasterization/encoding, `contact.png` and `frames.json`; it implies `--extremes` and takes no other diagnostic or sheet output flags. Look at min, max and diff before a person does ([AUTHORING §8.11](../docs/AUTHORING.md#811-min-max-and-diff-before-a-person-looks--render---extremes)). `--angle-range <bone>:<relative-to>` prints how far one bone turns against another over each set: the lowest and highest angle and the frames they fall on — a reading, not a gate. `--viewport <x,y,w,h>` or `--viewport-from <frames.json>` draws over a given box instead of a fitted one, so two builds land on one pixel grid; a slot that reaches past it is named by set and frame, and `frames.json` records it. `--environment <schedule.json>` draws the rig under the wind and gravity its physics answers, in time — the same frames on the core and on spine-core; an inspection of the response the rig states, not a scene. `--sheet [--sheet-format json-hash] [--page-edges pot\|free]` also packs each set's straight-alpha transparent frames into `sheet.png` + `sheet.json` (TexturePacker JSON Hash with a shared world-origin `anchor` and `2`-px clamped edge extrusion, verified through `pixi.js@8.22.0` and `phaser@3.90.0` by `tools/sheet_readers.ts`) and `sheet-manifest.json` (`rigc-sheet/1`), leaving diagnostic `f####.png` and `contact.png` unchanged ([AUTHORING §8.10](../docs/AUTHORING.md#810-sprite-sheets-from-a-render--render---sheet)) — a self-contained sprite object per animation set; when animations play and how a scene is composed remains the consumer's |
-| `preview --candidate <dir>` | one self-contained `.html` that plays it, headed by the line `validate <dir>` prints for it and the rigc version — a refused candidate is still previewed, and its header says so in the gate's words. Repeat `--candidate` for one page with a pane per candidate, in the order given; a green `build` ends by naming this command for its own `--out` |
-| `vote --candidate a --candidate b` | one `.html` that asks a human which; `vote --record <file>` checks the answer into `votes.jsonl` |
-| `pose --images <dir> --frame <png>` | reads part placements **out of** a picture |
-| `chainfit --candidate <dir> --images <dir> --frame <png>` | reads the parts `pose` refuses, through the candidate's own draw order and hierarchy: masked residuals over **visible** pixels, one hinge per child instead of four degrees of freedom, and the `rotate` key value each answer implies. A bone with two or more anchored descendants is **determined** rather than searched, and the residual that over-determination leaves is reported |
-| `diff <candidate.json> <reference.json>` | structural comparison of two skeletons, one ratio per measure and deliberately no combined score |
-| `bonedist --candidate … --reference … --bones …` | per-frame, per-bone world-transform distance against another skeleton — the ladder's stage 3, run on its own. `--bones <correspondence.json \| identity>` is required rather than defaulted: a candidate is entitled to its own bone names, so the pairing is stated |
-| `check --candidate <dir> --frames <dir> [--out <dir>]` | the candidate against reference pictures — the only instrument here that can see a *wrong animation*. `--out` also writes, for every frame the table lists, the picture its figures came from: reference, candidate, difference and overlay at native size |
-| `bench <rung> --candidate <dir>` | one rung of the benchmark ladder |
-| `guide <RULE>` / `guide §<n>[.<m>[.<k>]] [--all]` | the guide's row for the rule a failure line names — every `FAIL` line, `vote --record` refusal, `ingest` finding and coded compile error ends with ` (see rigc guide <RULE>)`; only legacy uncoded library errors point at `§5.1` — or a section's heading, own prose and subsection index, read from the installed `docs/AUTHORING.md` when it runs. `--all` includes the subsection bodies; a leaf prints its full text either way. Sizes describe full ledger spans. `--all` with a rule is refused, exit 2; an unknown name is refused with the nearest real ones, exit 1 |
-| `skills install [--dir …] [--copy]` | links every agent skill the package ships into `.agents/skills` (or `--dir`) as relative symlinks, or copies them with `--copy` — where Codex, Gemini CLI and Antigravity look. A second run has nothing to do; an entry already there that is not this command's is refused by name and nothing is written |
-| `review <dir> […]` | the human review of a build, handed to the `rig-review` bin of `@rig-c/review` installed beside the package; rigc does not depend on it and never installs it. `rigc review <dir> [--reference <video>] [--animation <name>] [--compare <dir>]` is `rig-review open <dir> …` with those flags 1:1 and prints the loopback URL to give a person; a first argument that is one of review's own words (`open`, `check`, `feedback`, `control`, `strip`, `compare`) or starts with `-` (`--help`, `--`) is handed over untouched. stdout is review's byte for byte, stderr review's plus the launcher's own refusals, the exit code review's. Refused by name, exit 2, before the bin starts: `REVIEW_OUTPUT_MISSING <path>` (the target is not a directory); `REVIEW_NOT_INSTALLED` with two lines, `bun add -d @rig-c/review` and `bunx @rig-c/review open <dir> …` carrying the flags given — the same on a terminal and off, with nothing installed or written; `REVIEW_BUN_TOO_OLD: Bun <found>, @rig-c/review needs <required>`, the floor read off the installed package's `engines.bun`; and an empty argument (`""`) under a Bun that drops one (Bun 1.2.0, measured by a probe), `rigc review: argument N is empty, and Bun <version>, the Bun running this, drops an empty argument when it starts a process — …`. docs/AUTHORING.md lists every line |
+| `ingest <skeleton.json> --out <dir>` | `build` run backwards: reads a Spine 4.3 skeleton and writes the rig spec and motion spec that **rebuild it**, plus a findings report naming everything it could not carry. a skeleton that declares no stage is carried as declaring none, `--stage x,y,w,h` adds a box to one — and is refused, rather than ignored, beside one that declares a box — and `--images <dir>` writes the spec's own images directory — the opposite direction from `build --images`, which overrides it — so the rebuild carries no flag at all <a id="cmd-ingest"></a> |
+| `split --rig … --motion … --slot <name> --out <dir>` | the answer to a mesh refused because its triangles are **several pieces that share no vertex** — two legs after the triangles bridging them were deleted. It reads the two specs and writes them back into an absent or empty `--out` with one mesh per piece: piece 1 stays in the slot, piece k gets a new slot `<slot>_<k>` after it, each with the original's uvs and weights unchanged, its triangles renumbered outline first where the hull rule needs it, and every deform key re-sliced to the new indices — plus `split.json`, where every original vertex and triangle went. One piece is said so and nothing is written; what it cannot carry is refused by name ([AUTHORING §3.4.11](../docs/AUTHORING.md)) <a id="cmd-split"></a> |
+| `explain --rig … --motion …` | the compiled rig as a table — every bone with its resolved parent, the slots in draw order, every timeline key by key. Writes nothing. What to reach for when a rig compiles and still looks wrong <a id="cmd-explain"></a> |
+| `render --candidate <dir>` | PNG frames plus a contact sheet, in `render/`, one directory per set: `<anim>@<fps>fps/` rather than `<anim>/` at any rate but the default — `--fps 24` writes `<anim>@24fps/`, and the default 12 writes `<anim>/`. `--hide <slot,…>` or `--slot <slot,…>` draws part of the rig on the **same grid** as the whole, so the two frames overlay and the difference is the part; `frames.json` records the subset and `check` refuses such a set as a reference. `--geometry` adds a `geometry.json` per set: every frame's bone world transforms and skinned attachment vertices, with the rest geometry, on the frames' own grid. `--folds` adds a `folds.json` per set and prints one line per mesh with a triangle turned over against the setup pose: the frames, the worst frame's count and which triangles, their world box and their setup-pose area. `--pass-through <cloth>:<leg>` adds a `pass-through.json` per set and prints the frames where a cloth drawn over a leg has its side inside the leg's drawn outline, with the depth and the world box — a reading, not a gate. `--seam <slot>:<slot>` adds a `seam.json` per set and prints, per pair, the frames where two slots that meet open background inside the joint (a gap) or show the overlap band of one past the other (a ghost), with the worst frame's cell count and world box; `ghostA` and `ghostB` partition the same ghost by which named pair member drew it, each with its own frames, spans and worst; `gapOpen` and `gapCovered` partition `gap` by zero versus positive rendered alpha from the whole skeleton, including faint and clipped drawings ([AUTHORING §8.8](../docs/AUTHORING.md#88-where-two-slots-stop-meeting--render---seam)) — a reading, not a gate; the exit status never moves. `--overlaps` adds an `overlaps.json` per set and prints one `OVERLAP "<under>" under "<over>"` line per pair of slots where the one drawn later covers the earlier one and the motion moves it — the frames, and the most pixels covered and the frame of them — with an outline plate per covered frame; the render reports what was drawn, and the draw-order key is the author's remedy — a reading, not a gate. `--extremes` adds `extremes.json` and a native six-panel `extremes.png` (setup, geometry-pair min/max and three premultiplied RGBA diffs with a legend), plus one `EXTREMES` line per set. Per-channel minima/maxima and the farthest original-vertex geometry pair are distinct readings; valid channel extrema survive a geometry/image SKIP, with channel refusals reported separately; still or uncomparable geometry reports a named SKIP without changing render exit status. `--extremes-only` writes the same `extremes.json` and readable `extremes.png` bytes while skipping ordinary frame rasterization/encoding, `contact.png` and `frames.json`; it implies `--extremes` and takes no other diagnostic or sheet output flags. Look at min, max and diff before a person does ([AUTHORING §8.11](../docs/AUTHORING.md#811-min-max-and-diff-before-a-person-looks--render---extremes)). `--angle-range <bone>:<relative-to>` prints how far one bone turns against another over each set: the lowest and highest angle and the frames they fall on — a reading, not a gate. `--viewport <x,y,w,h>` or `--viewport-from <frames.json>` draws over a given box instead of a fitted one, so two builds land on one pixel grid; a slot that reaches past it is named by set and frame, and `frames.json` records it. `--environment <schedule.json>` draws the rig under the wind and gravity its physics answers, in time — the same frames on the core and on spine-core; an inspection of the response the rig states, not a scene. `--sheet [--sheet-format json-hash] [--page-edges pot\|free]` also packs each set's straight-alpha transparent frames into `sheet.png` + `sheet.json` (TexturePacker JSON Hash with a shared world-origin `anchor` and `2`-px clamped edge extrusion, verified through `pixi.js@8.22.0` and `phaser@3.90.0` by `tools/sheet_readers.ts`) and `sheet-manifest.json` (`rigc-sheet/1`), leaving diagnostic `f####.png` and `contact.png` unchanged ([AUTHORING §8.10](../docs/AUTHORING.md#810-sprite-sheets-from-a-render--render---sheet)) — a self-contained sprite object per animation set; when animations play and how a scene is composed remains the consumer's <a id="cmd-render"></a> |
+| `preview --candidate <dir>` | one self-contained `.html` that plays it, headed by the line `validate <dir>` prints for it and the rigc version — a refused candidate is still previewed, and its header says so in the gate's words. Repeat `--candidate` for one page with a pane per candidate, in the order given; a green `build` ends by naming this command for its own `--out` <a id="cmd-preview"></a> |
+| `vote --candidate a --candidate b` | one `.html` that asks a human which; `vote --record <file>` checks the answer into `votes.jsonl` <a id="cmd-vote"></a> |
+| `pose --images <dir> --frame <png>` | reads part placements **out of** a picture <a id="cmd-pose"></a> |
+| `chainfit --candidate <dir> --images <dir> --frame <png>` | reads the parts `pose` refuses, through the candidate's own draw order and hierarchy: masked residuals over **visible** pixels, one hinge per child instead of four degrees of freedom, and the `rotate` key value each answer implies. A bone with two or more anchored descendants is **determined** rather than searched, and the residual that over-determination leaves is reported <a id="cmd-chainfit"></a> |
+| `diff <candidate.json> <reference.json>` | structural comparison of two skeletons, one ratio per measure and deliberately no combined score <a id="cmd-diff"></a> |
+| `bonedist --candidate … --reference … --bones …` | per-frame, per-bone world-transform distance against another skeleton — the ladder's stage 3, run on its own. `--bones <correspondence.json \| identity>` is required rather than defaulted: a candidate is entitled to its own bone names, so the pairing is stated <a id="cmd-bonedist"></a> |
+| `check --candidate <dir> --frames <dir> [--out <dir>]` | the candidate against reference pictures — the only instrument here that can see a *wrong animation*. `--out` also writes, for every frame the table lists, the picture its figures came from: reference, candidate, difference and overlay at native size <a id="cmd-check"></a> |
+| `bench <rung> --candidate <dir>` | one rung of the benchmark ladder <a id="cmd-bench"></a> |
+| `guide <RULE>` / `guide §<n>[.<m>[.<k>]] [--all]` | the guide's row for the rule a failure line names — every `FAIL` line, `vote --record` refusal, `ingest` finding and coded compile error ends with ` (see rigc guide <RULE>)`; only legacy uncoded library errors point at `§5.1` — or a section's heading, own prose and subsection index, read from the installed `docs/AUTHORING.md` when it runs. `--all` includes the subsection bodies; a leaf prints its full text either way. Sizes describe full ledger spans. `--all` with a rule is refused, exit 2; an unknown name is refused with the nearest real ones, exit 1 <a id="cmd-guide"></a> |
+| `skills install [--dir …] [--copy]` | links every agent skill the package ships into `.agents/skills` (or `--dir`) as relative symlinks, or copies them with `--copy` — where Codex, Gemini CLI and Antigravity look. A second run has nothing to do; an entry already there that is not this command's is refused by name and nothing is written <a id="cmd-skills-install"></a> |
+| `review <dir> […]` | the human review of a build, handed to the `rig-review` bin of `@rig-c/review` installed beside the package; rigc does not depend on it and never installs it. `rigc review <dir> [--reference <video>] [--animation <name>] [--compare <dir>]` is `rig-review open <dir> …` with those flags 1:1 and prints the loopback URL to give a person; a first argument that is one of review's own words (`open`, `check`, `feedback`, `control`, `strip`, `compare`) or starts with `-` (`--help`, `--`) is handed over untouched. stdout is review's byte for byte, stderr review's plus the launcher's own refusals, the exit code review's. Refused by name, exit 2, before the bin starts: `REVIEW_OUTPUT_MISSING <path>` (the target is not a directory); `REVIEW_NOT_INSTALLED` with two lines, `bun add -d @rig-c/review` and `bunx @rig-c/review open <dir> …` carrying the flags given — the same on a terminal and off, with nothing installed or written; `REVIEW_BUN_TOO_OLD: Bun <found>, @rig-c/review needs <required>`, the floor read off the installed package's `engines.bun`; and an empty argument (`""`) under a Bun that drops one (Bun 1.2.0, measured by a probe), `rigc review: argument N is empty, and Bun <version>, the Bun running this, drops an empty argument when it starts a process — …`. docs/AUTHORING.md lists every line <a id="cmd-review"></a> |
 
 `diff`, `bonedist`, `check` and `bench` measure against something you were given; the
 first three work on any reference you have, and `bench` is a repository workflow that needs a clone
@@ -12026,7 +12026,7 @@ ambiguous one ends with a sentence saying which reading its figures support:
 
 - **below the floor** — a 40x28 part of one flat colour, cut from a plain block it fits anywhere inside:
 
-  > part is 40x28 px (span 40 frame px, opaque 1) with texture 0, detail 0; 17 candidate(s), best 0.0000, next 0.0000, spread 0.0000 — below the measured floor (AUTHORING §11.5: detail 0.5, measured from 24 px up): pose placed 7% of the measured parts this plain, so this part is too plain for pose to tell its placements apart; that says nothing about whether the cut is right
+  > part is 40x28 px (span 40 frame px, opaque 1) with texture 0, detail 0; 34 candidate(s), best 0.0000, next 0.0000, spread 0.0000 — below the measured floor (AUTHORING §11.5: detail 0.5, measured from 24 px up): pose placed 7% of the measured parts this plain, so this part is too plain for pose to tell its placements apart; that says nothing about whether the cut is right
 
 - **above the floor** — a 200x150 black-and-white checker the frame does not hold:
 
@@ -12034,7 +12034,7 @@ ambiguous one ends with a sentence saying which reading its figures support:
 
 - **above the floor, one size in two places** — two copies of an 18x34 checker 0.6 of its span and 6° apart, the shape a left/right pair cut from one drawing reads as:
 
-  > part is 18x34 px (span 36.2 frame px, opaque 1) with texture 0.0221, detail 0.752; 14 candidate(s), best 0.0160, next 0.0162, spread 0.0002 — above the measured floor (AUTHORING §11.5: detail 0.5, measured from 24 px up), so size and texture do not explain this; every placement in the margin is at the best's scale (within 0.30%, bar 2%) and in another place (the nearest 0.62 span(s) away, bar 0.45), which is the part — or a near-copy, such as a left/right pair cut from one drawing — drawn more than once: read the placements as an unordered set and order it across frames (MOTION.md §2.2 🔀); a --rotation window that excludes one place chooses the answer rather than measuring it
+  > part is 18x34 px (span 36.2 frame px, opaque 1) with texture 0.0221, detail 0.752; 40 candidate(s), best 0.0160, next 0.0162, spread 0.0002 — above the measured floor (AUTHORING §11.5: detail 0.5, measured from 24 px up), so size and texture do not explain this; every placement in the margin is at the best's scale (within 0.30%, bar 2%) and in another place (the nearest 0.62 span(s) away, bar 0.45), which is the part — or a near-copy, such as a left/right pair cut from one drawing — drawn more than once: read the placements as an unordered set and order it across frames (MOTION.md §2.2 🔀); a --rotation window that excludes one place chooses the answer rather than measuring it
 
 Read the figures, not only the verdict. *Below* says plainness alone explains the
 failure: the cut may be right, and `pose` cannot tell. *Above* says it does not,
@@ -12124,6 +12124,22 @@ two anchors — and only 3 had it ranked under the old cutoff of three. The fine
 took the grid from 185 to 227 trials found and those misses from 65 to 14, for about
 10–14% more CPU over the grid (615 s of user time before it, 678 s and 704 s on two runs after).
 
+For repeated parts, an independent coverage lane also keeps up to five **new**
+places per rung. It uses the same fields and stride, but bounds suppression by
+half the material box's **short** side at that rung's scale: a long thin part's
+half-length cannot erase a different nearby position. Positions already covered
+by the original lane do not consume that extra budget. The coverage lane keeps
+its coarse pool through the first finer, rotation-regridded level before comparing
+scales together; only then does it narrow to the usual refinement budget. Both
+completed pools use the same full-resolution objective, dedupe and ambiguity
+margin. More coverage can expose an ambiguity; it does not prove that every
+visible copy, or every subpixel placement, will be recovered. Public repeated-part
+controls hold the final reported position, rotation and scale, not merely a coarse
+seed. The programmatic `coarsePolicy: 'legacy-only'` seam reproduces the original
+search for those negative controls; the CLI uses short-support coverage. An unknown
+runtime `coarsePolicy` is refused by name with the supplied value and both accepted
+policies; omit it to use the current search.
+
 The refinement then polishes each place down the pyramid, and at full resolution a
 polish that has stopped tries its scale **up by half a coarse rung** (2^(1/6)), re-fits
 the position there, and restarts if that scores better; fifteen places survive each

package/docs/INGEST.md

@@ -1405,11 +1405,11 @@ rigc pose
   ..    ground  rgb(232, 232, 232) over 100% of the border ring
   ..    parts   …/packed-only  (1 png)
   ..    search  scale 0.5–2 in 7 step(s) · rotation -180°–180° in 24 step(s) of 15° · refuse above residual 0.25
-  PLACE  3-timing-and-spacing.png  x=  324.3  y=  188.3  rot=  -91.6°  scale=0.630  residual=0.2085  unexplained= 30%
+  PLACE  3-timing-and-spacing.png  x=  324.6  y=  189.8  rot=  -91.1°  scale=0.625  residual=0.2080  unexplained= 29%
                                    found on a 14x7 anchor grid, step 4 at 16x reduction
 ```
 
-⚠️ **`residual=0.2085` is *under* the default 0.25 refusal bar**, so nothing refused
+⚠️ **`residual=0.2080` is *under* the default 0.25 refusal bar**, so nothing refused
 it, and `PLACE` rather than `AMBIG` means nothing flagged it either. With the same frame
 and the two real loose parts, the answer is what it should be:
 
@@ -1424,7 +1424,7 @@ rigc pose
   ..    ground  rgb(232, 232, 232) over 100% of the border ring
   ..    parts   …/examples/3-timing-and-spacing/images  (2 png)
   ..    search  scale 0.3–0.6 in 4 step(s) · rotation -180°–180° in 24 step(s) of 15° · refuse above residual 0.25
-  PLACE  pendulum.png  x=  319.3  y=  214.6  rot=  -88.9°  scale=0.411  residual=0.0428  unexplained=  7%
+  PLACE  pendulum.png  x=  319.4  y=  214.4  rot=  -88.9°  scale=0.412  residual=0.0421  unexplained=  7%
                        found on a 28x13 anchor grid, step 2 at 16x reduction
   PLACE  square.png    x=  437.1  y=  343.1  rot=    0.0°  scale=0.410  residual=0.0334  unexplained=  4%
                        found on a 113x51 anchor grid, step 2 at 4x reduction

package/docs/MOTION.md

@@ -818,20 +818,22 @@ rigc pose
                    found on a 20x25 anchor grid, step 4 at 2x reduction
   PLACE  flag.png  x=  104.7  y=  156.1  rot=   84.3°  scale=0.955  residual=0.0135  unexplained=  0%
                    found on a 40x50 anchor grid, step 2 at 2x reduction
-  AMBIG  post.png  x=   79.9  y=  149.0  rot=   -0.1°  scale=0.971  residual=0.0593  unexplained= 16%
+  AMBIG  post.png  x=   80.0  y=  148.6  rot=   -0.1°  scale=0.982  residual=0.0587  unexplained= 16%
                    found on a 14x17 anchor grid, step 6 at 2x reduction
-                   alt 2: x=   79.0  y=  141.7  rot=   -0.5°  scale=0.691  residual=0.0687  unexplained= 25%
-                   ambiguous: part is 14x96 px (span 93.2 frame px, opaque 1) with texture 0.0146, detail 1.406; 43 candidate(s), best 0.0593, next 0.0687, spread 0.0095 — above the measured floor (AUTHORING §11.5: detail 0.5, measured from 24 px up), so size and texture do not explain this; either the frame holds more than one place this part fits, or every candidate missed the true one — a narrower --scale or --rotation window around what you know of the part tells the two apart
+                   alt 2: x=   78.7  y=  164.0  rot=   -0.6°  scale=0.573  residual=0.0612  unexplained= 19%
+                   alt 3: x=   79.0  y=  141.7  rot=   -0.5°  scale=0.691  residual=0.0687  unexplained= 25%
+                   alt 4: x=   78.4  y=  135.5  rot=   -0.5°  scale=0.500  residual=0.0702  unexplained= 23%
+                   ambiguous: part is 14x96 px (span 94.3 frame px, opaque 1) with texture 0.0146, detail 1.406; 50 candidate(s), best 0.0587, next 0.0612, spread 0.0025 — above the measured floor (AUTHORING §11.5: detail 0.5, measured from 24 px up), so size and texture do not explain this; either the frame holds more than one place this part fits, or every candidate missed the true one — a narrower --scale or --rotation window around what you know of the part tells the two apart
 ```
 
-⚠️ **The post came back `AMBIG`: a best at scale 0.971 and an alternate at 0.691, 7.3 px
-higher, trailing it by a spread of 0.0095.** That is §2.2's caveat in the open. The post
+⚠️ **The post came back `AMBIG`: a best at scale 0.982 and its next alternate at 0.573,
+15.4 px lower, trailing it by a spread of 0.0025.** That is §2.2's caveat in the open. The post
 is a long part with most of its area in one colour, so a shrunken copy sitting inside the
 real post explains those pixels nearly as well, and the report's own `ambiguous:` line
 says size and texture do not account for how close the two come. The report cannot say
-which one is true, and it says so: it names both and asks for a narrower window. The
+which one is true, and it says so: it names the alternatives and asks for a narrower window. The
 picture can. The arm and the flag read 0.970 and 0.955, so the picture is at the art's
-own resolution, and a post at 0.69 would be drawn at about 0.7 of the size of everything
+own resolution, and a post at 0.573 would be drawn at about 0.6 of the size of everything
 bolted to it. ⇒ Narrow, and say so:
 
 ```bash
@@ -861,12 +863,19 @@ rigc pose
   ..    search  scale 0.85–1.2 in 2 step(s) · rotation -180°–180° in 24 step(s) of 15° · refuse above residual 0.25
   PLACE  arm.png   x=  102.5  y=   94.8  rot=  -18.3°  scale=0.974  residual=0.0305  unexplained=  4%
                    found on a 20x25 anchor grid, step 4 at 2x reduction
-  PLACE  flag.png  x=  137.4  y=   86.0  rot=   -6.6°  scale=0.956  residual=0.0134  unexplained=  0%
+  PLACE  flag.png  x=  137.4  y=   86.0  rot=   -6.4°  scale=0.958  residual=0.0134  unexplained=  0%
                    found on a 40x50 anchor grid, step 2 at 2x reduction
   PLACE  post.png  x=   80.0  y=  148.0  rot=    0.0°  scale=0.995  residual=0.0394  unexplained=  9%
                    found on a 14x17 anchor grid, step 6 at 2x reduction
 ```
 
+The worked derivation and recipe below keep their recorded rounded authoring inputs:
+pose A as printed here, and pose B with the flag at screen rotation −6.6° and scale
+0.956. The current rerun above reads −6.4° and 0.958 for that flag. The 0.2° rotation
+and 0.002 scale differences are changes in the estimator's reading; the fixed inputs
+used to derive this worked rig and its motion are stated here so that the recipe does
+not silently change with a rerun.
+
 Three things to read out of that pair, none of which is a score:
 
 - **Scale.** All six readings sit in 0.956–0.995, a spread of about 4 %. The one part
@@ -887,7 +896,8 @@ Three things to read out of that pair, none of which is a score:
 
 ### 3. Convert, and derive the rig
 
-`cropToSpineY(y, 200) = 200 − y` and `screenToSpineDegrees(d) = −d`, both from
+For those recorded authoring inputs, `cropToSpineY(y, 200) = 200 − y` and
+`screenToSpineDegrees(d) = −d`, both from
 [`src/transform.ts`](../src/transform.ts) (§2.2 — do not open-code either):
 
 | | pose A, Spine world | pose B, Spine world |
@@ -1042,8 +1052,8 @@ which is which is worth being able to point at:
 
 | Key | Where it came from |
 | --- | --- |
-| arm `t: 0` = −61.9, flag `t: 0` = −22.2 | **given** — pose A, converted. Untouched, per §3.6 |
-| arm `t: 0.55` = 18.3, flag `t: 0.55` = −11.7 | **given** — pose B. The flag's is `6.6 − 18.3`: both world rotations converted first, then differenced, because a child's track carries a **local** rotation under a rotated parent |
+| arm `t: 0` = −61.9, flag `t: 0` = −22.2 | **given** — the recorded pose A reading, converted. Untouched, per §3.6 |
+| arm `t: 0.55` = 18.3, flag `t: 0.55` = −11.7 | **given** — the recorded pose B reading. The flag's is `6.6 − 18.3`: both world rotations converted first, then differenced, because a child's track carries a **local** rotation under a rotated parent |
 | arm `t: 0.07` = −66.4 | §3.6 — 4.5° against an 80° excursion (5.6 %), at 13 % of the duration |
 | arm `t: 0.32` = 24.7 | §3.8 — 6.4° past the end value (8 %), at 58 % of the duration |
 | flag `t: 0.09`, `t: 0.47` | §3.7 — the flag's extreme lands at 85 % of the duration against the arm's 58 %, an offset of **+27 %**, the middle of its row's band, and it drags the other way first. Not the top of the band: at 35 % (`t: 0.51`) the crossing and the settle below would share 0.04 s, and the 24 fps render would still show the flag at its extreme one frame before the last |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rig-c/core",
-  "version": "2.82.1",
+  "version": "2.82.2",
   "description": "AI-authored 2D rigging and animation, verified before it is written. rigc compiles a rig spec into skeleton data in the Spine 4.3 format, gates it with named assertions held to a spine-core round trip's verdicts, and emits nothing that fails. Ships as an agent skill.",
   "type": "module",
   "bin": {

package/src/pose.ts

@@ -835,6 +835,8 @@ export interface PoseOptions {
    * stride fraction in force in `search.coarse.strideFraction`.
    */
   coarseGrid?: PoseCoarseGrid;
+  /** Historical-search control for instruments; the CLI uses short-support coverage. */
+  coarsePolicy?: 'legacy-only' | 'short-support';
 }
 
 /** A search candidate as the trace states it: where the part image's centre would land, frame pixels. */
@@ -900,6 +902,8 @@ export interface PoseTrace {
   levels: PoseTraceLevel[];
   /** Per part, every candidate that reached the report, with its every-pixel residual, best first. */
   measured: { part: string; candidates: PoseTraceCandidate[] }[];
+  /** The independent coverage lane; `levels` retains the original lane's pyramid. */
+  supplemental?: { part: string; levels: PoseTraceLevel[] }[];
 }
 
 // ---------------------------------------------------------------------------
@@ -1388,8 +1392,15 @@ function coarseCellResidual(level: Level, s: Samples, scale: number, rotDeg: num
  * exactly two such cells — and the accepted list then keeps them apart so the
  * refinement budget is not spent twice on one hill.
  */
-function localMinima(field: CoarseField, radius: number, keep: number): Candidate[] {
-  const found: Candidate[] = [];
+export function poseCoarseMinima(
+  field: CoarseField,
+  radius: number,
+  keep: number,
+  support = Infinity,
+  covered: readonly Candidate[] = [],
+  observation?: { accepted: number; covered: number; spacingChecks?: number },
+): Candidate[] {
+  const found: { candidate: Candidate; gx: number; gy: number }[] = [];
   for (let gy = 0; gy < field.rows; gy++) {
     for (let gx = 0; gx < field.cols; gx++) {
       const here = field.residual[gy * field.cols + gx];
@@ -1400,7 +1411,7 @@ function localMinima(field: CoarseField, radius: number, keep: number): Candidat
           const nx = gx + dx;
           const ny = gy + dy;
           if (nx < 0 || ny < 0 || nx >= field.cols || ny >= field.rows) continue;
-          if (field.residual[ny * field.cols + nx] < here) {
+          if (hypot2(dx * field.stride, dy * field.stride) <= support && field.residual[ny * field.cols + nx] < here) {
             minimal = false;
             break;
           }
@@ -1408,23 +1419,45 @@ function localMinima(field: CoarseField, radius: number, keep: number): Candidat
       }
       if (!minimal) continue;
       const cell = gy * field.cols + gx;
-      found.push({
+      found.push({ gx, gy, candidate: {
         cx: gx * field.stride + field.stride / 2,
         cy: gy * field.stride + field.stride / 2,
         rotDeg: field.rotDeg[cell],
         scale: field.scale,
         residual: here,
-      });
+      } });
     }
   }
-  found.sort((a, b) => a.residual - b.residual);
-  const accepted: Candidate[] = [];
-  for (const cand of found) {
-    if (accepted.length >= keep) break;
-    if (accepted.some((a) => hypot2(a.cx - cand.cx, a.cy - cand.cy) <= radius * field.stride)) continue;
-    accepted.push(cand);
+  found.sort((a, b) => a.candidate.residual - b.candidate.residual);
+  const spacing = Math.min(radius * field.stride, support);
+  const gridRadius = spacing / field.stride;
+  const bucketSpan = Math.max(1, Math.floor(gridRadius));
+  const reach = Math.ceil(gridRadius / bucketSpan);
+  const accepted = new Map<string, Candidate[]>();
+  const novel: Candidate[] = [];
+  for (const entry of found) {
+    if (novel.length >= keep) break;
+    const cand = entry.candidate;
+    const bx = Math.floor(entry.gx / bucketSpan), by = Math.floor(entry.gy / bucketSpan);
+    let overlaps = false;
+    for (let y = by - reach; y <= by + reach && !overlaps; y++) {
+      for (let x = bx - reach; x <= bx + reach && !overlaps; x++) {
+        for (const a of accepted.get(`${x}:${y}`) ?? []) {
+          if (observation !== undefined) observation.spacingChecks = (observation.spacingChecks ?? 0) + 1;
+          if (hypot2(a.cx - cand.cx, a.cy - cand.cy) <= spacing) { overlaps = true; break; }
+        }
+      }
+    }
+    if (overlaps) continue;
+    const key = `${bx}:${by}`, bucket = accepted.get(key) ?? [];
+    bucket.push(cand);
+    accepted.set(key, bucket);
+    if (observation !== undefined) observation.accepted++;
+    if (covered.some((b) => hypot2(cand.cx - b.cx, cand.cy - b.cy) <= support)) {
+      if (observation !== undefined) observation.covered++;
+    } else novel.push(cand);
   }
-  return accepted;
+  return novel;
 }
 
 /**
@@ -1859,6 +1892,9 @@ export function partFiles(imagesDir: string, exclude: string): string[] {
 // ---------------------------------------------------------------------------
 
 export function estimatePose(options: PoseOptions): PoseReport {
+  if (options.coarsePolicy !== undefined && options.coarsePolicy !== 'legacy-only' && options.coarsePolicy !== 'short-support') {
+    throw new PoseError(`coarsePolicy ${JSON.stringify(options.coarsePolicy)}: expected "short-support" or "legacy-only" — omit it for the current search`);
+  }
   const framePath = resolve(options.framePath);
   if (!existsSync(framePath)) throw new PoseError(`no pose frame at ${framePath}`);
   let frame: Plate;
@@ -1959,6 +1995,7 @@ export function estimatePose(options: PoseOptions): PoseReport {
         { min: scaleMin, max: scaleMax },
         rotationBounds,
         options.coarseGrid ?? COARSE_GRID,
+        options.coarsePolicy ?? 'short-support',
         options.trace,
       ),
     );
@@ -1977,6 +2014,7 @@ function placePart(
   scaleBounds: { min: number; max: number },
   rotationBounds: { min: number; max: number; wraps: boolean },
   coarseGrid: PoseCoarseGrid,
+  coarsePolicy: 'legacy-only' | 'short-support',
   trace?: PoseTrace,
 ): PosePart {
   const scaleMin = scaleBounds.min;
@@ -2114,11 +2152,23 @@ function placePart(
   const stride = Math.max(1, Math.round(spanAtCoarse * coarseGrid.strideFraction));
   const coarseSamples = samplesFor(coarse.reduction, COARSE_SAMPLES);
   let candidates: Candidate[] = [];
+  const supplementalSeeds: Candidate[] = [];
   let grid = { reduction: coarse.reduction, cols: 0, rows: 0, stride };
   for (const scale of scales) {
     const field = coarseScan(coarse, coarseSamples, scale, searchRotations, stride);
     grid = { reduction: coarse.reduction, cols: field.cols, rows: field.rows, stride };
-    candidates.push(...localMinima(field, coarseGrid.suppressionCells, coarseGrid.minimaPerScale));
+    const legacy = poseCoarseMinima(field, coarseGrid.suppressionCells, coarseGrid.minimaPerScale);
+    candidates.push(...legacy);
+    if (coarsePolicy === 'short-support') {
+      // An isotropic half-LONG-span neighborhood can suppress another position
+      // along a thin part. Its inscribed material disk supplies a rotation-free
+      // bound, in level pixels, derived from the actual rung scale (issue #1649).
+      const support = thickness * scale / (2 * coarse.reduction);
+      const extra = poseCoarseMinima(field, coarseGrid.suppressionCells, coarseGrid.minimaPerScale, support, legacy);
+      // Charge the independent budget AFTER excluding already represented
+      // positions; charging it first spends its slots on seeds then discarded.
+      supplementalSeeds.push(...extra);
+    }
   }
   base.coarse = grid;
   candidates.sort((a, b) => a.residual - b.residual);
@@ -2140,147 +2190,159 @@ function placePart(
   // that arm is one half of the two-identical-limbs answer the whole instrument
   // exists to report. Re-gridding the ladder at the first level with real detail
   // brought it back at +35.
-  const branchLevel = Math.max(0, coarseIndex - 1);
-  /** How many rotations survive the re-grid at the branch level, per position. */
-  const BRANCH_ROTATIONS = 3;
-  let rotStep = rotationFree ? 0 : COARSE_ROTATION_STEP / 2;
-  for (let li = coarseIndex; li >= 0; li--) {
-    const level = levels[li];
-    const plate = plates[li];
-    const smooth = li !== coarseIndex;
-    const branch = li === branchLevel;
-    const keep = li === coarseIndex ? scales.length * coarseGrid.minimaPerScale : REFINE_CANDIDATES;
-    const s = samplesFor(level.reduction, li === 0 ? POLISH_SAMPLES : REFINE_SAMPLES);
-    // The coarse pass only sampled every `stride` pixels, so entering the
-    // refinement the anchor can be half a stride out; the first polish gets a
-    // step big enough to cross that rather than a step that assumes a pixel.
-    const step = { translate: li === coarseIndex ? Math.max(1.5, stride) : 1.5, rotate: rotStep, scale: 0.08 };
-    const floor =
-      li === 0 ? { translate: 0.05, rotate: 0.1, scale: 0.001 } : { translate: 0.25, rotate: 0.5, scale: 0.01 };
-    const seeds: Candidate[] = [];
-    for (const start of candidates.slice(0, keep)) {
-      if (branch && !rotationFree) {
-        const grid: Candidate[] = [];
-        for (const rotDeg of searchRotations) {
-          const probe: Candidate = { ...start, rotDeg, residual: 0 };
-          probe.residual = residualAt(level, plate, s, probe, smooth);
-          grid.push(probe);
+  const refineLane = (initial: Candidate[], supplemental = false, levelTrace?: PoseTraceLevel[]): Candidate[] => {
+    let candidates = initial;
+    const branchLevel = Math.max(0, coarseIndex - 1);
+    /** How many rotations survive the re-grid at the branch level, per position. */
+    const BRANCH_ROTATIONS = 3;
+    let rotStep = rotationFree ? 0 : COARSE_ROTATION_STEP / 2;
+    for (let li = coarseIndex; li >= 0; li--) {
+      const level = levels[li];
+      const plate = plates[li];
+      const smooth = li !== coarseIndex;
+      const branch = li === branchLevel;
+      // Coarse scale scores are not comparable. Give the coverage pool its
+      // first detailed/rotation-regridded reading before ranking scales together.
+      const keep = li === coarseIndex || (supplemental && li === branchLevel) ? scales.length * coarseGrid.minimaPerScale : REFINE_CANDIDATES;
+      const s = samplesFor(level.reduction, li === 0 ? POLISH_SAMPLES : REFINE_SAMPLES);
+      // The coarse pass only sampled every `stride` pixels, so entering the
+      // refinement the anchor can be half a stride out; the first polish gets a
+      // step big enough to cross that rather than a step that assumes a pixel.
+      const step = { translate: li === coarseIndex ? Math.max(1.5, stride) : 1.5, rotate: rotStep, scale: 0.08 };
+      const floor =
+        li === 0 ? { translate: 0.05, rotate: 0.1, scale: 0.001 } : { translate: 0.25, rotate: 0.5, scale: 0.01 };
+      const seeds: Candidate[] = [];
+      for (const start of candidates.slice(0, keep)) {
+        if (branch && !rotationFree) {
+          const grid: Candidate[] = [];
+          for (const rotDeg of searchRotations) {
+            const probe: Candidate = { ...start, rotDeg, residual: 0 };
+            probe.residual = residualAt(level, plate, s, probe, smooth);
+            grid.push(probe);
+          }
+          grid.sort((a, b) => a.residual - b.residual);
+          // One position and one scale throughout, so this dedupe is a spread over
+          // rotation alone: an angle within 25 degrees of one already kept is the
+          // same basin under a slightly different name.
+          seeds.push(...dedupe(grid, 1, 25, Infinity).slice(0, BRANCH_ROTATIONS));
+          continue;
         }
-        grid.sort((a, b) => a.residual - b.residual);
-        // One position and one scale throughout, so this dedupe is a spread over
-        // rotation alone: an angle within 25 degrees of one already kept is the
-        // same basin under a slightly different name.
-        seeds.push(...dedupe(grid, 1, 25, Infinity).slice(0, BRANCH_ROTATIONS));
-        continue;
+        seeds.push(start);
       }
-      seeds.push(start);
-    }
-    const paths = seeds.map((): { start: number; steps: PoseTraceStep[] } => ({ start: 0, steps: [] }));
-    candidates = seeds.map((seed, i) =>
-      polish(level, plate, s, seed, step, floor, smooth, scaleBounds, rotationBounds, li === 0 ? POLISH_SCALE_ESCAPES : [], trace === undefined ? undefined : paths[i]),
-    );
-    const polished = candidates.slice();
-    candidates.sort((a, b) => a.residual - b.residual);
-    // ⚠️ Eight branches that walked to one optimum are one candidate, not eight —
-    // and the radius has to scale with the PART rather than be a pixel count.
-    // Narrowing by residual alone lets near-copies of the best hill fill the
-    // budget and crowd the SECOND hill out, which is exactly the answer this
-    // instrument exists to keep: with a fixed one-pixel radius the fixture lost
-    // one of its two identical arms.
-    candidates = dedupe(candidates, Math.max(1, (0.2 * span * scaleReference) / level.reduction), 5, 1.03);
-    if (trace !== undefined) {
-      const ou = part.width / 2 - anchorX;
-      const ov = part.height / 2 - anchorY;
-      const said = (c: Candidate): PoseTraceCandidate => {
-        const cos = Math.cos(c.rotDeg * DEG) * c.scale;
-        const sin = Math.sin(c.rotDeg * DEG) * c.scale;
-        return {
-          x: c.cx * level.reduction + ou * cos - ov * sin,
-          y: c.cy * level.reduction + ou * sin + ov * cos,
-          rotationDeg: normaliseDegrees(c.rotDeg),
-          scale: c.scale,
-          residual: c.residual,
-        };
-      };
-      let probeResidual: number | null = null;
-      if (trace.probe !== undefined) {
-        const q = trace.probe;
-        const cos = Math.cos(q.rotationDeg * DEG) * q.scale;
-        const sin = Math.sin(q.rotationDeg * DEG) * q.scale;
-        const at: Candidate = {
-          cx: (q.x - (ou * cos - ov * sin)) / level.reduction,
-          cy: (q.y - (ou * sin + ov * cos)) / level.reduction,
-          rotDeg: q.rotationDeg,
-          scale: q.scale,
-          residual: 0,
+      const paths = seeds.map((): { start: number; steps: PoseTraceStep[] } => ({ start: 0, steps: [] }));
+      candidates = seeds.map((seed, i) =>
+        polish(level, plate, s, seed, step, floor, smooth, scaleBounds, rotationBounds, li === 0 ? POLISH_SCALE_ESCAPES : [], trace === undefined ? undefined : paths[i]),
+      );
+      const polished = candidates.slice();
+      candidates.sort((a, b) => a.residual - b.residual);
+      // ⚠️ Eight branches that walked to one optimum are one candidate, not eight —
+      // and the radius has to scale with the PART rather than be a pixel count.
+      // Narrowing by residual alone lets near-copies of the best hill fill the
+      // budget and crowd the SECOND hill out, which is exactly the answer this
+      // instrument exists to keep: with a fixed one-pixel radius the fixture lost
+      // one of its two identical arms.
+      candidates = dedupe(candidates, Math.max(1, (0.2 * span * scaleReference) / level.reduction), 5, 1.03);
+      if (trace !== undefined && levelTrace !== undefined) {
+        const ou = part.width / 2 - anchorX;
+        const ov = part.height / 2 - anchorY;
+        const said = (c: Candidate): PoseTraceCandidate => {
+          const cos = Math.cos(c.rotDeg * DEG) * c.scale;
+          const sin = Math.sin(c.rotDeg * DEG) * c.scale;
+          return {
+            x: c.cx * level.reduction + ou * cos - ov * sin,
+            y: c.cy * level.reduction + ou * sin + ov * cos,
+            rotationDeg: normaliseDegrees(c.rotDeg),
+            scale: c.scale,
+            residual: c.residual,
+          };
         };
-        probeResidual = residualAt(level, plate, s, at, smooth);
+        let probeResidual: number | null = null;
+        if (trace.probe !== undefined) {
+          const q = trace.probe;
+          const cos = Math.cos(q.rotationDeg * DEG) * q.scale;
+          const sin = Math.sin(q.rotationDeg * DEG) * q.scale;
+          const at: Candidate = {
+            cx: (q.x - (ou * cos - ov * sin)) / level.reduction,
+            cy: (q.y - (ou * sin + ov * cos)) / level.reduction,
+            rotDeg: q.rotationDeg,
+            scale: q.scale,
+            residual: 0,
+          };
+          probeResidual = residualAt(level, plate, s, at, smooth);
+        }
+        levelTrace.push({
+          part: name,
+          level: li,
+          reduction: level.reduction,
+          keep,
+          seeds: seeds.map(said),
+          starts: paths.map((p) => p.start),
+          paths: paths.map((p) => p.steps),
+          polished: polished.map(said),
+          out: candidates.map(said),
+          probeResidual,
+          coarseRotations:
+            li === coarseIndex
+              ? {
+                  ladder: searchRotations.slice(),
+                  residuals: seeds.map((seed) =>
+                    searchRotations.map((rotDeg) => coarseCellResidual(level, coarseSamples, seed.scale, rotDeg, seed.cx, seed.cy)),
+                  ),
+                }
+              : null,
+        });
+      }
+      if (li > 0) {
+        candidates = candidates.map((c) => ({ ...c, cx: c.cx * 2, cy: c.cy * 2 }));
+        // A rotation-free part keeps its step at zero all the way down, so the
+        // polish never touches an angle that means nothing and the report's 0° is
+        // the placeholder it says it is rather than a wandered-to number.
+        if (!rotationFree) rotStep = Math.max(1, rotStep / 2);
       }
-      trace.levels.push({
-        part: name,
-        level: li,
-        reduction: level.reduction,
-        keep,
-        seeds: seeds.map(said),
-        starts: paths.map((p) => p.start),
-        paths: paths.map((p) => p.steps),
-        polished: polished.map(said),
-        out: candidates.map(said),
-        probeResidual,
-        coarseRotations:
-          li === coarseIndex
-            ? {
-                ladder: searchRotations.slice(),
-                residuals: seeds.map((seed) =>
-                  searchRotations.map((rotDeg) => coarseCellResidual(level, coarseSamples, seed.scale, rotDeg, seed.cx, seed.cy)),
-                ),
-              }
-            : null,
-      });
-    }
-    if (li > 0) {
-      candidates = candidates.map((c) => ({ ...c, cx: c.cx * 2, cy: c.cy * 2 }));
-      // A rotation-free part keeps its step at zero all the way down, so the
-      // polish never touches an angle that means nothing and the report's 0° is
-      // the placeholder it says it is rather than a wandered-to number.
-      if (!rotationFree) rotStep = Math.max(1, rotStep / 2);
     }
-  }
 
-  // The one rotation family the translation scan cannot see: a part that is its
-  // own mirror after a quarter or a half turn sits in the SAME place at more than
-  // one angle, so the field records only whichever won. Probe them explicitly.
-  //
-  // 🚨 Only the turns the window contains, and this is the other half of #719's
-  // measurement. A quarter turn off is a SEED, not a ladder rung — so under
-  // `--rotation -5,5` it entered the answer from outside a window the report was
-  // calling the search, and the candidate who ran the exam read `rot=91.2°`
-  // under `rotation -5°–5°`. A caller who bounds the rotation has said the part
-  // is not a quarter turn over; the honest response is not to look there rather
-  // than to look and report it.
-  if (!rotationFree && candidates.length > 0) {
-    const primary = candidates[0];
-    const s = samplesFor(1, POLISH_SAMPLES);
-    for (const turn of [90, 180, 270]) {
-      const turned = primary.rotDeg + turn;
-      if (!rotationBounds.wraps && (turned < rotationBounds.min - 1e-9 || turned > rotationBounds.max + 1e-9)) continue;
-      candidates.push(
-        polish(
-          levels[0],
-          plates[0],
-          s,
-          { ...primary, rotDeg: turned },
-          { translate: 1.5, rotate: 4, scale: 0.04 },
-          { translate: 0.05, rotate: 0.1, scale: 0.001 },
-          true,
-          scaleBounds,
-          rotationBounds,
-          [],
-        ),
-      );
+    // The one rotation family the translation scan cannot see: a part that is its
+    // own mirror after a quarter or a half turn sits in the SAME place at more than
+    // one angle, so the field records only whichever won. Probe them explicitly.
+    //
+    // 🚨 Only the turns the window contains, and this is the other half of #719's
+    // measurement. A quarter turn off is a SEED, not a ladder rung — so under
+    // `--rotation -5,5` it entered the answer from outside a window the report was
+    // calling the search, and the candidate who ran the exam read `rot=91.2°`
+    // under `rotation -5°–5°`. A caller who bounds the rotation has said the part
+    // is not a quarter turn over; the honest response is not to look there rather
+    // than to look and report it.
+    if (!rotationFree && candidates.length > 0) {
+      const primary = candidates[0];
+      const s = samplesFor(1, POLISH_SAMPLES);
+      for (const turn of [90, 180, 270]) {
+        const turned = primary.rotDeg + turn;
+        if (!rotationBounds.wraps && (turned < rotationBounds.min - 1e-9 || turned > rotationBounds.max + 1e-9)) continue;
+        candidates.push(
+          polish(
+            levels[0],
+            plates[0],
+            s,
+            { ...primary, rotDeg: turned },
+            { translate: 1.5, rotate: 4, scale: 0.04 },
+            { translate: 0.05, rotate: 0.1, scale: 0.001 },
+            true,
+            scaleBounds,
+            rotationBounds,
+            [],
+          ),
+        );
+      }
+      candidates.sort((a, b) => a.residual - b.residual);
     }
-    candidates.sort((a, b) => a.residual - b.residual);
-  }
+
+    return candidates;
+  };
+  const baselineCandidates = refineLane(candidates, false, trace?.levels);
+  supplementalSeeds.sort((a, b) => a.residual - b.residual);
+  const extraTrace: PoseTraceLevel[] | undefined = trace === undefined ? undefined : [];
+  if (trace !== undefined && extraTrace !== undefined) (trace.supplemental ??= []).push({ part: name, levels: extraTrace });
+  candidates = [...baselineCandidates, ...refineLane(supplementalSeeds, true, extraTrace)];
 
   // Measured at full resolution over every pixel, then de-duplicated: two
   // candidates that walked to the same optimum are one answer, not two.