rig-parts 1.65.0 → 1.66.0

package/README.md

@@ -272,7 +272,7 @@ Use the graph's node classes and the host's `/object_info` when checking the ada
 ```sh
 rig-parts inputs --source painting.png --config config.json --out inputs   # st_input_full.png; the config needs assemble.rig_scale
 #    See-through on st_input_full.png (external, or `rig-parts comfy seethrough`) -> layers/full
-rig-parts layers layers/full                      # every layer: box, opaque px, depth, plausibility figures; WARN lines
+rig-parts layers layers/full                      # drawn(a>8)/opaque(a>=250) boxes, CORE body-group height in input-canvas px, WARNs
 rig-parts propose --head-box --full layers/full --canvas 1664x2432
 #    -> seethrough.head_box into config.json
 rig-parts inputs --source painting.png --config config.json --out inputs   # now st_input_head.png too
@@ -291,7 +291,8 @@ rig-parts propose --parts work/rig --source painting.png --out work
 #       (limbs only with --keypoints, constraints only with --cloth, turn only with --full/--head;
 #       a limbs block left out is refused next)
 rig-parts propose --parts work/rig --source painting.png --out work --from-config config.json
-#    -> LINT lines; exit 1 while any remain
+#    -> LINT lines; exit 1 while any remain (takes --parts, --source, --out, --from-config and optional --keypoints [--person] only;
+#       proposes nothing, so --full, --head, --cloth, --write-config, --wrist-snap, --grid-rule, --only-missing and --compare are refused)
 rig-parts build --config config.json --source painting.png --full layers/full --head layers/head --out out --loop
 #    -> read out/check/check.json; every FAIL line names what has to change
 ```
@@ -333,7 +334,7 @@ agent skill.
 | `inputs --source <png> --config <json> --out <dir>` | the two images See-through is fed: the painting on a white square, and the head box's crop once the config has one |
 | `comfy paint --config --out [--host]` | optional: generate the painting on a ComfyUI box from the config's `generation` block |
 | `comfy seethrough --image --out [--host]` | optional: run the ComfyUI See-through wrapper on one image and write the form `layers` reads |
-| `layers <dir \| layers.json \| file.psd>` | print every layer of a decomposition: draw order, name, tag group, box, size, opaque pixels, depth, and its translucent, background and area figures; a `WARN` line for a layer `--propose-plan` will leave out |
+| `layers <dir \| layers.json \| file.psd>` | keep the existing columns (`opaque_px` still means alpha >8) and append source-alpha boxes `drawn(a>8)` / `opaque(a>=250)` with exclusive right/bottom; name absent boxes, report the existing body-group union height at **CORE_ALPHA (>=250)** in **input-canvas px**, and show its >8 union separately; no anatomical height, ownership/erosion or painting registration is inferred ([units and rig-scale guidance](docs/AUTHORING.md#4-the-command-order)) |
 | `sheet --source <png> --layers <path>… --out <png>` | a labelled contact sheet of the painting and every layer or part |
 | `assemble --propose-plan … [--write-config <config>]` | propose `assemble.plan` and `extend_below_crop` from the two runs, leaving out an implausible layer with a note naming the rule, naming in a note any full-run body no planned part covers, and naming every layer no row takes with why (empty, taken from the other run only, a plausibility rule; `nose`, never planned, with the row that lets `propose` read the head's pitch) |
 | `assemble --source --full --head --config --out [--seam] [--project]` | merge the two runs into rig-space parts, `parts.json`, the recomposite and its error map, and list the uncovered holes |
@@ -341,7 +342,7 @@ agent skill.
 | `propose --parts --source --out [--compare <config>] [--write-config <config> [--only-missing]]` | propose bones, meshes, regions and an idle; draw the overlay; print, per bone, which check read it or that none did and why (its role, its kind of segment), and write `basis.json` beside the proposal — what each bone rests on (a joint, a part's mask, a ratio, other bones) and, with `--compare`, whether the config's bone differs |
 | `propose … --keypoints <file> [--person <id>]` | read a posed figure's joints from one explicit file (space, image size, people, each joint observed, occluded or missing, its source): a joint with a position places the neck, hip, chest or a sleeve chain as given, a note says how every joint was used or which rule stood in, and LINT reads the torso and sleeves along the joints instead of by screen y ([AUTHORING §3](docs/AUTHORING.md)) |
 | `propose … --grid-rule figure\|part` | how each drafted lattice's spacing is chosen: `figure` (the default) one spacing for the figure, round(H / 37) rig px, a part already coarser keeping its own, with a note on its calibration and cost; `part` the reference's rule, a tenth of the part's short side (the oracle examples are proposed under it) |
-| `propose … --from-config <config>` | draw and LINT the config's current bones (by the joints too, given `--keypoints`) |
+| `propose --parts --source --out --from-config <config> [--keypoints <file> [--person <id>]]` | draw and LINT the config's current bones (by the joints too, given `--keypoints`); proposes nothing, so takes only these flags (not `--full`, `--head`, `--cloth`, `--write-config`, `--wrist-snap`, `--grid-rule`, `--only-missing` or `--compare`) |
 | `compare --left <file> --right <file> [--map <bonemap.json>]` | compare two skeletons — a config, a proposal or a `rig.json` — bone by bone: origin, parent, tip, length and direction per pair, the bones neither side pairs, the required ones missing, and each side's roles read off the spec; no frame is guessed, and nothing pairs by resemblance (`propose --compare` reads origins only) |
 | `rig --config --parts --out [--idle-keys ctl\|direct]` | author `rig.json` + `motion.json`, written only after rig-c's gate is green; each mesh is in the mode its config entry names — `grid` (the lattice, what `propose` writes), `contour` (the traced outline with declared interior points) or `auto` (the contour mesh at alpha 1 and above, reduced and locally refined by rig-c's `reduceMesh` under the author's declared bounds, written only when its motion against the unreduced source on the idle passes the author's `motion` bounds through rig-c's `compareMeshesInMotion`; [AUTHORING §3](docs/AUTHORING.md)); every chain link is turned along its chain and carries its `length`, so a physics constraint added later has a lever, with every offset under it in the turned frame so nothing moves; `--idle-keys` says whether the idle's keys on mesh-driving bones go through `<bone>_ctl` parents (default) or stay on the bones with `invariants.idleDrivesMeshes` declared; the config's `constraints` go to rigc as written, and a two-bone ik over keyed links needs `--idle-keys direct` (on `rig` or `build`) |
 | `check --rig --out [--parts] [--source] [--requirements]` | build packed, gated under `rig-play`, render the idle, measure seam, loop and the six judgement lines (mesh texture stretch among them, from the idle's `render --geometry`), and report the recomposite's holes from `parts.json`; on a rig spec with no `parts.json` or no `idle` (a merged rig, issue #77) the gate still runs and every line that needs the missing input says SKIP by name; `--source <painting.png>` adds `SETUP_POSE_VS_SOURCE`, the setup pose against the painting by assemble's recomposite figures; `--requirements <scene.json>` measures what a scene declares of the motion — a contact, a follow fraction, an aim, a joint range, a mesh's stretch, the seam between two parts over the motion — each against the author's own bar, from rig-c's posed frames, one line each, PASS, FAIL or NOT MEASURABLE (AUTHORING §7, *Declared requirements*) |

package/cli.ts

@@ -28,7 +28,7 @@ import { GUIDE_DOC, type GuideAnswer, guideRule, guideSection } from './src/guid
 import { proposeHeadBox } from './src/headbox.ts';
 import { makeInputs } from './src/inputs.ts';
 import { idleKeysOf, isIdleKeys } from './src/rig.ts';
-import { depthSkipLine, exportLayers, figuresPhrase, hiddenLayerLine, implausibleRules, layerFigures, type LayerSet, layerSetDiff, pct, readLayers, readWrapperLayers, ruleSummary, templateLayerNames, templatePsdBytes, times } from './src/layers.ts';
+import { bodyCoreBox, bodyOpaqueBox, CORE_ALPHA, depthSkipLine, exportLayers, figuresPhrase, hiddenLayerLine, implausibleRules, layerCoreBox, layerFigures, layerOpaqueBox, type LayerSet, layerSetDiff, type OpaqueBox, OPAQUE_ALPHA_ABOVE, pct, readLayers, readWrapperLayers, ruleSummary, templateLayerNames, templatePsdBytes, times } from './src/layers.ts';
 import { checkImageSize, choosePerson, KEYPOINTS_SPEC, loadKeypoints, type RigJoints, toRigJoints } from './src/keypoints.ts';
 import { basisLines, branchSqueezeLine, checkProposal, compare, compareLines, DEFAULT_GRID_RULE, draftTurn, drawLandmarks, FIGURE_GRID_DIVISOR, FRINGE_STEP_PX, GRID_RULES, type GridRule, HIP_MIN_FRACTION, type DraftLintFinding, lint, lintLine, type PartSet, PROPOSAL_CONFIG_SECTIONS, proposalAsConfig, proposeWithBasis, readPartSet, serializeProposal, withTurn, WRIST_ON_PART_PX } from './src/propose.ts';
 import { BASIS_FILE, BASIS_SPEC, basisFile, basisLine, coverageLines, legChainChoice, serializeBasis } from './src/diagnostics.ts';
@@ -79,6 +79,11 @@ usage:
       where something covers it: listed apart, never drawn, never a part. An
       input with no depth (a PSD, or depth_median null on every layer, whose
       manifest order is then the draw order) prints one SKIP depth line.
+      Trailing boxes name both source-alpha cuts: drawn(a>8), and opaque
+      (a>=250, CORE_ALPHA). The legacy opaque_px still counts alpha above 8.
+      Right/bottom are exclusive, in INPUT-CANVAS px; absent boxes are named.
+      The body-group union height uses alpha >=250, with the >8 union shown
+      separately: no cleanup, ownership, anatomical height or painting map.
       Refuses, by name, a missing file, an unknown tag, a PNG whose
       size is not its box, and anything else outside the input contract —
       never a WARN.
@@ -268,9 +273,10 @@ usage:
 
   rig-parts propose --parts <dir> --source <painting.png> --out <dir> --from-config <config.json>
       Draw the config's CURRENT bones instead (<out>/render/landmarks_config.png
-      and _head) and LINT them (by the joints too, given --keypoints), with the
-      coverage lines after them; no ${BASIS_FILE}, as nothing is proposed.
-      Exits 1 when any LINT line is printed.
+      and _head) and LINT them (by the joints too, given --keypoints [--person]), with the
+      coverage lines after them; no ${BASIS_FILE}, as nothing is proposed (takes
+      --parts, --source, --out, --from-config and optional --keypoints [--person]
+      only). Exits 1 when any LINT line is printed.
 
   rig-parts propose … --write-config <config.json>
       Without --cloth, update an existing config with the whole proposal's
@@ -416,7 +422,8 @@ usage:
   rig-parts mesh-stats --config <config.json> --parts <dir>
       Print the vertices and triangles of every mesh the config states, as the
       rig stage would make them from the parts in --parts (the directory
-      holding parts.json and parts/<name>.png), and their total, in seconds:
+      holding parts.json and parts/ — work/rig from assemble --out work, or
+      out from build --out out), and their total, in seconds:
       the rig stage's own mesh construction, without rigc, without assemble
       and without check (issue #566). One line per mesh in parts.json's order,
       "mesh-stats: <part> — <mode> <V> vertices, <T> triangles" (mode lattice,
@@ -993,10 +1000,29 @@ function printLayerTable(set: LayerSet): void {
   const head = ['order', 'name', 'group', 'left,top', 'right,bottom', 'size', 'opaque_px', 'depth', 'translucent', 'background', 'area'];
   const widths = head.map((h, i) => Math.max(h.length, ...rows.map((r) => r[i].length)));
   const line = (cells: string[]): string => `  ${cells.map((c, i) => c.padEnd(widths[i])).join('  ')}`.trimEnd();
-  console.log(line(head));
-  for (const r of rows) console.log(line(r));
+  // Keep every legacy line byte-for-byte as a prefix; size the trailing fields separately.
+  const legacy = [line(head), ...rows.map(line)];
+  const legacyWidth = Math.max(...legacy.map(l => l.length));
+  const drawn = `drawn(a>${OPAQUE_ALPHA_ABOVE})`;
+  const opaque = `opaque(a>=${CORE_ALPHA})`;
+  const boxes = set.layers.map(l => [layerOpaqueBox(l), layerCoreBox(l)] as const);
+  const opaqueHead = [drawn, opaque].flatMap(label => [`${label}_left,top`, `${label}_right,bottom`, `${label}_size`]);
+  const opaqueRows = boxes.map(pair => pair.flatMap(b => b === null ? ['none', 'none', 'none'] : [`${b.left},${b.top}`, `${b.right},${b.bottom}`, `${b.right - b.left}x${b.bottom - b.top}`]));
+  const opaqueWidths = opaqueHead.map((h, i) => Math.max(h.length, ...opaqueRows.map(r => r[i].length)));
+  for (const [i, cells] of [opaqueHead, ...opaqueRows].entries()) {
+    console.log(`${legacy[i].padEnd(legacyWidth)}  ${cells.map((c, j) => c.padEnd(opaqueWidths[j])).join('  ')}`.trimEnd());
+  }
   const painted = set.layers.filter((l) => l.opaquePx > 0).length;
   console.log(`  ${set.layers.length} layer(s): ${painted} with opaque pixels, ${set.layers.length - painted} with none`);
+  console.log(`  source-alpha boxes: ${drawn}, ${opaque}; legacy opaque_px remains alpha > ${OPAQUE_ALPHA_ABOVE}; INPUT-CANVAS px; right/bottom exclusive`);
+  for (const [i, [drawnBox, coreBox]] of boxes.entries()) {
+    if (drawnBox === null) console.log(`  layer "${set.layers[i].name}": no ${drawn} box (no pixels with alpha > ${OPAQUE_ALPHA_ABOVE})`);
+    if (coreBox === null) console.log(`  layer "${set.layers[i].name}": no ${opaque} box (no pixels with alpha >= ${CORE_ALPHA})${drawnBox === null ? '' : `; ${drawn} box is present`}`);
+  }
+  const bodyBounds = (body: OpaqueBox | null): string => body === null ? 'none; height unavailable INPUT-CANVAS px' : `${body.left},${body.top} to ${body.right},${body.bottom}; size ${body.right - body.left}x${body.bottom - body.top}; height ${body.bottom - body.top} INPUT-CANVAS px`;
+  console.log(`  body-group union [${opaque}]: ${bodyBounds(bodyCoreBox(set))}; source alpha >= ${CORE_ALPHA} only, not an owned/eroded core or anatomical height`);
+  console.log(`  body-group union [${drawn}]: ${bodyBounds(bodyOpaqueBox(set))}; source alpha > ${OPAQUE_ALPHA_ABOVE} only; not an anatomical height`);
+  console.log('  body-group population: drawn group=body (includes hair/head/wings/objects; excludes face/headwear, author and hidden art); before cleanup, resampling or painting registration');
   // Issue #256: a layer the author made is said to be one, so it never reads as See-through's. None, no line.
   for (const l of set.layers) if (l.tag.group === 'author') console.log(`  ${authorLayerLine(l.name)}`);
   // Issue #359: a hidden-art layer is listed apart, never in the drawn table. None, no line.
@@ -1351,11 +1377,12 @@ function cmdPropose(args: string[]): number {
   }
   // Issue #671: --only-missing adds entries to an existing config for the parts it attaches by neither section; it
   // belongs to the ordinary proposal's --write-config alone.
+  const fromConfigTakes = '(takes --parts, --source, --out, --from-config and optional --keypoints [--person] only)';
   if (onlyMissing) {
     const mode = 'propose --parts … --write-config <config.json> --only-missing';
     if (headBox) return usage(`--only-missing belongs to ${mode}; --head-box writes seethrough.head_box only`);
     if (!flags.has('--parts')) return usage(`--only-missing belongs to ${mode}; give --parts <dir>, the parts the entries are drafted from`);
-    if (flags.has('--from-config')) return usage(`--only-missing belongs to ${mode}; --from-config proposes nothing`);
+    if (flags.has('--from-config')) return usage(`--only-missing belongs to ${mode}; --from-config proposes nothing ${fromConfigTakes}`);
     if (flags.has('--cloth')) return usage(`--only-missing belongs to ${mode}; --cloth writes a new config with the recipe's entries spliced in`);
     if (!flags.has('--write-config')) return usage(`--only-missing belongs to ${mode}; give --write-config <config.json>, the existing config the entries are added to`);
   }
@@ -1400,17 +1427,17 @@ function cmdPropose(args: string[]): number {
     if (partsArg === undefined) return usage('propose needs --parts <dir>, the directory holding parts.json and parts/');
     if (source === undefined) return usage('propose needs --source <painting.png>, drawn under the overlay');
     if (out === undefined) return usage('propose needs --out <dir>');
-    if (flags.has('--from-config') && flags.has('--compare')) return usage('--from-config and --compare are two modes; give one');
+    if (flags.has('--from-config') && flags.has('--compare')) return usage(`--from-config and --compare are two modes; give one (--from-config ${fromConfigTakes.slice(1, -1)})`);
     if (flags.has('--person') && !flags.has('--keypoints')) return usage('--person names a person in the --keypoints file; give --keypoints <file>');
     // Issue #251: the See-through runs the turn control's depths are read from; without them nothing is drafted.
-    if (flags.has('--from-config') && (flags.has('--full') || flags.has('--head'))) return usage('--full and --head draft the turn control while proposing; --from-config proposes nothing');
+    if (flags.has('--from-config') && (flags.has('--full') || flags.has('--head'))) return usage(`--full and --head draft the turn control while proposing; --from-config proposes nothing ${fromConfigTakes}`);
     // Issue #199: a declared tolerance for a wrist on no handwear part. Whole px above the built-in one: the distance is
     // counted in whole px, so a fraction would bind what its floor binds, and a value at or under the built-in binds nothing.
     const snapArg = flags.get('--wrist-snap');
     let wristSnap: number | null = null;
     if (snapArg !== undefined) {
       if (!flags.has('--keypoints')) return usage('--wrist-snap binds a wrist joint to a handwear part; give --keypoints <file>');
-      if (flags.has('--from-config')) return usage('--wrist-snap binds a wrist while proposing; --from-config proposes nothing');
+      if (flags.has('--from-config')) return usage(`--wrist-snap binds a wrist while proposing; --from-config proposes nothing ${fromConfigTakes}`);
       if (!/^[0-9]+$/.test(snapArg) || Number(snapArg) <= WRIST_ON_PART_PX) {
         return usage(`--wrist-snap ${snapArg} is not an integer above ${WRIST_ON_PART_PX}, the px within which a wrist already holds a part`);
       }
@@ -1418,15 +1445,15 @@ function cmdPropose(args: string[]): number {
     }
     // Issue #265: the drafted lattice's spacing; the figure's unless the reference's per-part rule is asked for.
     const ruleArg = flags.get('--grid-rule');
-    if (ruleArg !== undefined && flags.has('--from-config')) return usage('--grid-rule chooses the drafted spacing; --from-config proposes nothing');
+    if (ruleArg !== undefined && flags.has('--from-config')) return usage(`--grid-rule chooses the drafted spacing; --from-config proposes nothing ${fromConfigTakes}`);
     if (ruleArg !== undefined && !(GRID_RULES as readonly string[]).includes(ruleArg)) return usage(`--grid-rule ${ruleArg}; one of ${GRID_RULES.join(', ')} is required`);
     const gridRule = (ruleArg ?? DEFAULT_GRID_RULE) as GridRule;
     // Issue #364: the cloth and hair recipe, read from a config's cloth block; without it nothing changes.
     const clothArg = flags.get('--cloth');
-    if (clothArg !== undefined && flags.has('--from-config')) return usage('--cloth drafts trees while proposing; --from-config proposes nothing');
+    if (clothArg !== undefined && flags.has('--from-config')) return usage(`--cloth drafts trees while proposing; --from-config proposes nothing ${fromConfigTakes}`);
     // Issue #537: the --cloth config's own text with what its recipe drafts spliced in, beside proposal.json.
     const writeArg = flags.get('--write-config');
-    if (writeArg !== undefined && flags.has('--from-config')) return usage('--write-config writes what the recipe drafts into its config; --from-config proposes nothing');
+    if (writeArg !== undefined && flags.has('--from-config')) return usage(`--write-config writes what the recipe drafts into its config; --from-config proposes nothing ${fromConfigTakes}`);
     // Issue #571: the config the recipe is changed from; an entry equal to its recipe's draft is the recipe's, not a hand edit.
     const fromArg = flags.get('--from');
     if (fromArg !== undefined && writeArg === undefined) return usage('--from names the config the recipe is changed from, for --write-config; give --write-config <out.json>');
@@ -1434,7 +1461,7 @@ function cmdPropose(args: string[]): number {
     if (writeArg !== undefined && clothArg !== undefined) {
       const ours = ['proposal.json', BASIS_FILE, 'render/landmarks.png', 'render/landmarks_head.png'].map((f) => resolve(out, f));
       if (existsSync(writeArg) || ours.includes(resolve(writeArg))) {
-        throw new PartsError([{ code: 'PROPOSE_WRITE_CONFIG_FRESH', object: writeArg, detail: existsSync(writeArg) ? 'exists; the config is written to a new file, never over the --cloth config or an earlier one' : `is a file this run writes under ${out}; name another file` }]);
+        throw new PartsError([{ code: 'PROPOSE_WRITE_CONFIG_FRESH', object: writeArg, detail: existsSync(writeArg) ? 'exists; the config is written to a new file, never over the --cloth config or an earlier one (unlike assemble --propose-plan and propose without --cloth, which update an existing --config in place)' : `is a file this run writes under ${out}; name another file` }]);
       }
       separateConfigWriteTarget({ path: resolve(writeArg) }, ours, 'PROPOSE_WRITE_CONFIG_FRESH');
     }
@@ -1642,7 +1669,7 @@ function cmdAssemble(args: string[]): number {
   const [source, full, config] = ['--source', '--full', '--config'].map((f) => flags.get(f) as string);
   const head = flags.get('--head') ?? null;
   const writePath = flags.get('--write-config');
-  if (writePath !== undefined && resolve(writePath) !== resolve(config)) return usage('--write-config must name the same file as --config for assemble --propose-plan');
+  if (writePath !== undefined && resolve(writePath) !== resolve(config)) return usage('--write-config must name the same file as --config for assemble --propose-plan (assemble --propose-plan updates --config in place; only propose --cloth --write-config writes to a new file)');
   let staged: StagedConfigWrite | null = null;
   try {
     if (propose) {

package/docs/AUTHORING.md

@@ -282,8 +282,14 @@ costs nothing a bar reads (`demo`, tips 371 px apart: 1.050 for the pair, as for
 alone), and on one mass with the two chains close it squeezes the lattice between them
 (issue #314: tips 39 px apart, an edge at 0.065 of its rest length). Whether the hair is one
 mass is not something the proposer can read off the opaque shape — both chains always hang
-on the one `back hair` part — so the draft is unchanged and the squeeze is measured instead,
-by the lint above.
+on the one `back hair` part — but their lattice and motion are readable. A fresh draft now
+uses the squeeze reading above (issue #751): when an opposed pair fails and reversing the
+second chain's signs passes the unchanged bar, it drafts that passing sign and adds a
+`shared-mesh chain signs` note with both figures and the reason. Magnitudes and timing
+stay unchanged. Every shared pair is re-read; an alternative introducing a new or worse
+finding is not adopted. When no measured alternative passes, the draft and LINT remain.
+Already-clean and unread pairs are unchanged. `propose --from-config` only observes the
+supplied config: it still prints the original LINT and never rewrites its amplitudes.
 
 **A posed figure: `propose --keypoints`.** Without joints the proposer reads the
 torso by screen y: the hip 0.14 face heights below `bottomwear`'s top edge (or below
@@ -1834,8 +1840,8 @@ that crosses the region with no point of it inside to split at — is still stop
 
 The package proposes no expression and keys nothing but the idle; what it gives is a rig whose
 face is bones (`eye_r`, `eye_l`, `brow_r`, `brow_l`, `mouth` on `reference-sample`) and one door for
-animations you write over them, `motion.animations_from` (the row above, issues #183 and #569).
-Name a file in rig-c's motion-spec shape, its path relative to the directory `config.json` sits
+animations you write over them, `motion.animations_from` (the `motion.animations_from` row in the §3 field table above, issues #183 and #569).
+Name a file in rig-c's motion-spec shape whose top-level keys are `"spec"` (`"rigc-motion/1"`) and `"animations"` (plus optional `"note"` / `"<name>_note"` strings and `"x-<name>"` records; any other top-level key — rig-c's `easings`, `groups`, `setup`, `physics`, `mix`, `archetype` and `cut` included — is refused by `CONFIG_KEY_KNOWN`), its path relative to the directory `config.json` sits
 in — not the working directory:
 
 ```jsonc
@@ -1867,8 +1873,8 @@ same shape over the face bones, and `examples/demo/animations.json` holds seven
   defines `curve` as four numbers per value channel: absolute control-point
   `[time, value, time, value]`, not normalized graph handles. The first chest key above
   shapes its span to the next key. A key carries `ease` or `curve`, never both, and
-  the final key carries neither. Top-level motion fields are a separate contract:
-  `animations_from` supplies `spec` and `animations`, not a second setup or easing table.
+  the final key carries neither. Top-level motion fields are a separate contract (the `motion.animations_from` row in the §3 field table):
+  `animations_from` accepts only `spec` and `animations` at the top level (plus `note` / `<name>_note` and `x-<name>`), refusing rig-c's `easings`, `groups`, `setup`, `physics`, `mix`, `archetype` and `cut` with `CONFIG_KEY_KNOWN` (`known: spec, animations`); tracks inside `animations` may use the easings `shut` and `open` and the groups `eyes` and `brows` that `motion.json` already holds.
 - **Key times strictly increase within a track, and the last is at `duration`** — rig-c's rule
   (its AUTHORING §4.5, "`t` is in seconds and must strictly increase"; R7: no key past the
   declared duration, and a duration more than a frame longer than the last key is refused).
@@ -2091,7 +2097,7 @@ fragment below, cut to the bust:
 
 A region adds vertices: its `spacing` is finer than the mesh's, and every one of them is a
 triangle more for the runtime to skin. Before the first build, count them:
-`rig-parts mesh-stats --config config.json --parts work/rig` (issue #566; `work` is step 7's `assemble --out`, §4) runs the rig stage's own
+`rig-parts mesh-stats --config config.json --parts work/rig` (issue #566; `--parts` is the directory holding `parts.json` and `parts/`: `work/rig` from step 7's `assemble --out work`, or `out` from `build --out out`, not `work` itself — §4) runs the rig stage's own
 mesh construction over the assembled parts, without rigc, without `check`, and prints one line
 per mesh — `mesh-stats: topwear — contour 320 vertices, 568 triangles` on `reference-sample` —
 and the total, `mesh-stats: total 1908 triangles over 6 mesh(es)`, the counts the build's
@@ -2311,8 +2317,8 @@ chain, a constraint or a track added by hand survives a `--write-config`. An ent
 recipe re-drafts or removes that the author changed by hand (it equals neither draft) is
 not dropped: the run is refused, `PROPOSE_WRITE_CONFIG_CONFLICT`, naming the entry
 (`config.constraints[40] "skirt0a_0_physics"` in CL207), the first field the hand edit holds and
-what the draft writes there, every conflict at once and nothing written; take the draft
-by removing the hand edit, or leave the recipe out for that part. **A changed recipe
+what the draft writes there, every conflict at once and nothing written; to take the recipe's draft,
+remove the hand-edited track, bone or constraint from `config.<section>` (or revert the hand edit) and run `propose --cloth` again, or leave the recipe out for that part. **A changed recipe
 (issue #571).** The draft of the recipe as it stood before a change is neither of the
 two drafts, so a config holding that draft untouched would read as hand-edited at every
 entry the change moves (29 refusals on the public `wind` example with
@@ -2780,6 +2786,66 @@ full loader before its assemble stage writes anything.
    files, not the art (§6, *Reading the inputs*). A `WARN` line is about the art: a
    layer See-through made that is not plausibly part of the figure, which step 6
    leaves out (§6, *Plausibility*). It refuses nothing.
+   The trailing `drawn(a>8)_left,top`, `drawn(a>8)_right,bottom`, `drawn(a>8)_size`
+   and `opaque(a>=250)_left,top`, `opaque(a>=250)_right,bottom`,
+   `opaque(a>=250)_size` columns give two boxes of each drawn layer's original
+   source alpha, in **input-canvas px**, beside the unchanged manifest/layer box.
+   All original columns stay as read: legacy `opaque_px` still counts **alpha >8**.
+   The second box uses the existing **alpha >=CORE_ALPHA (250)** cut, shared with
+   assemble's opaque ownership, projection and seam logic. Only that alpha cut is
+   applied here: no owner clipping, projection-core erosion, ghost cleanup or
+   rig resampling. Alpha 249 is drawn but not CORE; 250 and 251 meet both cuts.
+   Add the reader's `left,top` to a PNG-local pixel; right and bottom are exclusive,
+   so one painted pixel has a 1x1 box. `none` and a line naming the layer say that
+   it has no box at that threshold. A fully transparent layer has neither box;
+   a layer with drawn support but no CORE support is explicitly named as such.
+   Hidden art remains listed apart and is never drawn.
+
+   **Body-group union (issue #757).** The summary unions exactly the drawn layers
+   whose reader tag has `group === 'body'`: the existing body tags include front
+   and back hair, head, neck/neckwear, topwear, handwear (including its sides),
+   bottomwear, legwear, footwear, tail, wings and objects, plus the derived
+   `hand-r/l` and `drape-r/l`. Face, eyes, headwear and the other head-group tags,
+   author layers and hidden art do not contribute. A tag classifies a layer; it
+   does not prove anatomical identity. The main height line uses **alpha >=250**;
+   the raw **alpha >8** union is printed separately and can span the whole input
+   canvas because of boundary support. Each union's height is `bottom - top`,
+   never a sum of layer heights, and an empty union has height unavailable.
+   This is a per-layer thresholded-mask union (OR), not RGBA-over compositing:
+   overlapping source alpha below the applicable cut cannot accumulate into it:
+   two alpha-8 layers do not become drawn support, and two alpha-249 layers do not
+   become CORE support. Neither union is an anatomical height or the height of
+   the final assembled parts. A head-run
+   reading is still only that input's body-group union.
+
+   **Units before choosing `assemble.rig_scale`.** `layers` reads one input and
+   knows no painting size or full/head role or registration. For scale guidance,
+   run `layers` on the **full run** and use its **alpha >=250** body-group extent
+   as the source reference, with the mapping below when it is known. At the
+   [public task-01 input pin](https://github.com/rig-c/exam/tree/131e80f794830238520aae8709db7155719813db/tasks/01-build/inputs),
+   the full-run source CORE union is 911 input-canvas px tall; the head-run 964
+   is a crop extent and is not the full scale reference. These input roles are
+   supplied by that fixture's contract, not inferred by this CLI from a file name.
+   The CLI prints generic body-group unions, without a figure-height or rig-scale
+   advice line. Only with a known full-run
+   mapping from `inputs` can its coordinates be converted: for painting `w x h`,
+   square side `L = max(w,h)`, run resolution `R`, and padding
+   `padX = floor((L-w)/2)`, `padY = floor((L-h)/2)`, a run point maps to painting
+   `(x*L/R-padX, y*L/R-padY)`. This is `checkGeometry`'s `fullK = L/R` and the
+   full `runMap` before rig scale; the mapped vertical extent is `height*L/R`.
+   It is an affine extent, not a newly resampled or clipped painting-pixel mask.
+   For an artist's single run at one file pixel per painting pixel, the raw
+   file's height needs no scale conversion; assemble's internal square padding
+   only translates it. A separately generated head crop has its own crop map
+   and cannot supply a full-body height. Contact-sheet tiles resize independently
+   and preserve no common placement, so their pixels are not measurement inputs.
+   The 1,100–1,200 rig-px advice in §3 uses the union of assembled parts' boxes,
+   the `H` of `propose`'s `mesh spacing:` note. Ghost cleanup, the run-to-rig
+   resampling and the chosen parts can change the bounds and threshold coverage:
+   the analytic conversion above does not measure that final `H`. Instead,
+   use a known painting-space extent for scale guidance and inspect the parts
+   after assembly. Do not substitute this tag-group union for anatomy or assume
+   its input pixels are painting pixels. `layers` performs no registration.
 4. `rig-parts propose --head-box --full inputs/layers/full --canvas <W>x<H> --write-config config.json`
    saves `seethrough.head_box` in the existing config. `<W>x<H>` is the original
    painting's size, not the padded square's. The existing optional `--no-back-hair`
@@ -2864,11 +2930,14 @@ full loader before its assemble stage writes anything.
    For a posed figure (seated, reclining), add `--keypoints keypoints.json` (and
    `--person <id>` when the file holds more than one person): the joints it gives
    place the neck, hip, chest and sleeves (§3, *A posed figure*).
-8. Correct, then `rig-parts propose … --from-config config.json` to redraw the
+8. Correct, then `rig-parts propose --parts work/rig --source inputs/painting.png --out work --from-config config.json` to redraw the
    config's own bones and LINT them — every chain link against its mesh's art, and
    the single bones `hip` and `chest` against each other and the figure (a config
    without them prints a `note:` that those lines did not run); repeat until it
-   prints no LINT line (exit 0). Add the same `--keypoints` to lint by the joints.
+   prints no LINT line (exit 0). Add the same `--keypoints` (and `--person`) to lint by the joints;
+   `--from-config` proposes nothing and takes `--parts`, `--source`, `--out`, `--from-config` and
+   optional `--keypoints` (`--person`) only (not `--full`, `--head`, `--cloth`, `--write-config`,
+   `--wrist-snap`, `--grid-rule`, `--only-missing` or `--compare`).
    Config from here on: the `full` row.
    `rig-parts compare --left work/proposal.json --right config.json` says what the
    correction changed, bone by bone: each origin, parent, tip, length and direction
@@ -2986,9 +3055,11 @@ a saved draft still needs validation.
 
 ### Counting the triangles before a build (`mesh-stats`, issue #566)
 
-`rig-parts mesh-stats --config config.json --parts work/rig` prints the vertices and triangles of
-every mesh the config states and their total, against the parts `assemble` wrote (step 7's
-`work/rig`, or a `build --out` directory, which holds `parts.json` and `parts/` itself), in seconds.
+`rig-parts mesh-stats --config config.json --parts work/rig` (after `assemble --out work`) or
+`rig-parts mesh-stats --config config.json --parts out` (after `build --out out`) prints the
+vertices and triangles of every mesh the config states and their total, against the parts
+`assemble` wrote (`--parts` is the directory holding `parts.json` and `parts/`: step 7's
+`work/rig` from `assemble --out work`, or `out` from `build --out out` — not `work` itself), in seconds.
 It is the rig stage's mesh construction itself — the same function the rig stage writes
 `mesh_report.json` from — run without rigc, without `check` and without writing a file, so a
 config can be tuned to a triangle budget before the first build and between builds:
@@ -3140,7 +3211,7 @@ one of them occluded, so nothing shows it at rest; paint it there if the face wi
 move off it (`AS245`).
 
 **Saving proposed config fields (`--write-config`, issue #356).** The flag is a
-valued destination path. Its modes have different ownership:
+valued destination path with two destination rules — **in place on an existing regular config** without `--cloth` (and for `assemble --propose-plan`, `--write-config` must name `--config` itself; §4, step 6), versus **a new file** for `propose --cloth --write-config` (`PROPOSE_WRITE_CONFIG_FRESH`, never over the `--cloth` config or an earlier one; §3, *The config written*). Its modes have different ownership:
 
 | proposal mode | destination | fields written |
 | --- | --- | --- |
@@ -3170,14 +3241,12 @@ loader validates the candidate after unresolved entries have been skipped with a
 naming the part, reference and reason; a skipped entry gets no plan row, and a part of any
 other origin gets no plan row; nothing missing keeps the bytes and mtime; stderr names each added row and entry. It is a usage error with `--head-box`, `--cloth`
 or `--from-config`, or without `--parts` or `--write-config`.
-All four modes use one file-writing adapter. Fresh cloth output keeps its
-already-checked splice text and intentional partial-config contract; the full
-loader is not imposed on it. Publication links the complete same-directory
+All four modes use one file-writing adapter, split between the two destination
+rules above: without `--cloth`, `--write-config` updates an existing regular config in place (`CONFIG_FILE_PRESENT` when absent) so the stage's loader (§4, *What each step requires of the config*) validates a same-directory candidate in place before replacement, and for `assemble --propose-plan` `--write-config` must name `--config` itself (a different `--write-config` destination for `assemble --propose-plan` is a usage error, §4 step 6); with `--cloth`, `propose --cloth <input.json> --write-config <out.json>` writes to a new file (`PROPOSE_WRITE_CONFIG_FRESH` when the path exists) because it splices the recipe's drafted entries into `--cloth`'s own text the way `mesh-draft` writes its config, keeping its already-checked splice text and intentional partial-config contract without imposing the full loader on it (§3, *The config written*). Publication links the complete same-directory
 staged file into a destination that must still be absent, so an intervening
 creator is refused without overwrite. Removing the staged temporary happens
 after publication: if that cleanup fails, `CONFIG_WRITE_FAILED` may accompany
-an already-published complete config. Inspect both named paths before retrying. A different
-`--write-config` destination for `assemble --propose-plan` is a usage error.
+an already-published complete config. Inspect both named paths before retrying.
 For ordinary and cloth proposals, the destination must be separate from all four
 artifacts under `--out`: `proposal.json`, `basis.json`, `render/landmarks.png` and
 `render/landmarks_head.png`. Matching paths, directory-symlink aliases and
@@ -3190,7 +3259,7 @@ existing hardlinks are refused before artifact output; the ordinary mode names
 | --- | --- | --- | --- |
 | `layers` | the table, then one `author-made: layer "author:<label>" — …` line per layer the author made (group `author` in the table; §5, *A layer the author made*), then the `WARN` lines | every tag the plan will need has opaque pixels; one `face` in the head run; `0 WARN line(s)` | a run whose layer PNG is not its box's size (`LAYERS_PNG_MATCHES_BBOX`); a `WARN  PLAN_LAYER_…` line (§6, *Plausibility*) |
 | `sheet` of both runs | the tile list (and the sheet, if you can see) | eyes, irises, lashes and brows as left/right pairs in the head run | a head box that cut off an ornament: move `head_box`, re-run the head crop |
-| `assemble` | one line per part — its counts (`op=` opaque, `vis=` visible, `src=` taken / candidates, `unproj=` visible but not projected, `drift=<n> (<p>% of core)`, `merged=`, `seam=`; *parts.json*, below). `drift=` is `refused_drift_px` in rig px and its share of the part's candidates, `projected_core_px`, which it is a subset of (issue #314); no bar reads either. On the four public examples the share runs to 94.5 % (`scarf` `hair_back`, 479 of 507) and the count to 26,472 (`scarf` `topwear`, 22.3 %), and the seam override repaints refused top-most pixels afterwards, so a large count says where See-through's colour was not taken, not that the part is unlike the painting: the `drift:` line below is the one that names a body of them another part holds. Then the `pixels:` totals (opaque = visible + occluded; taken; visible but not projected), then `recomposite vs source: mean \|d\|, within 8, error px > 40, uncovered error px`, then `uncovered holes (8-connected): N` and the largest five as `uncovered hole K: <px> px at x,y wxh (between "<part>" <px> px, …)`, then one `uncovered: <n> of the <N> uncovered error px lie on the full run's "<tag>", in a body of <px> px at x,y wxh; <the rule that left it out>` line per full-run layer the plan does not take from the full run whose uncovered error holds a body (5x5-opened, 8-connected, at least 150 full-run px in rig px), then one `drift: "<part>" refuses <n> px of <run>:<tag> (its colour more than 90 off the painting, max channel), in a body of <px> px at x,y wxh (…); by the plan's draw order "<holder>" holds <px> px of it (…), "<holder>" drawn in front of "<part>"` line per part whose drift refusals hold a body (the same opening and bar) that another part holds in the draw order — that layer is not what the painting shows there (none on the five public paintings), then, per subset alternate set, one `LINT set "<set>" <part>: <layer part> holds <n> islands (8-connected, alpha above 8)[, and <s> speck(s) under 1 % of the largest (<f> px), each with the island nearest it], kept the one under <joints> (<k> px), dropped <m> (<d> px)` line per limb part cut from a layer of more than one island when the set names one limb side of it (issue #588; issue #608: a joint taken to the nearest island reads `<bone> [x, y] (<e> px off it, within its cap's radius <r>)`, and a part that lost no pixel `dropped none`), then one `LINT set "<set>" <part>: <layer part> holds <limb> and <other limb> in one island (8-connected, alpha above 8), split by the nearest segment line at the set's bones: kept <k> px (<share>), gave <m> px (<share>) to <other limb>; <b> px in the overlap band (nearer one line than the other by 0.5 px or less) went to the limb drawn in front, <bk> kept and <bg> given` line per limb part cut from a layer of one island that a limb the set does not carry also takes (issue #609; k, m and b count the part's pixels above alpha 8, each share of the part's pixels before the split, 3 places) and one `LINT set "<set>" <part>: <n> px under <base part> excluded` line per subset alternate set's limb part and base part drawn over it that the set does not replace which took a pixel (issue #587, `assemble.alternates` above; none on the public examples, which declare no alternate set); and look at `render/recomposite_error_rig.png`. Between the part lines and the totals, one `author-made: part "<part>" (<run>:author:<label>) — …` line per part from a layer the author made (below, *A layer the author made*), then one `cut: "<part>" opaque <n> = "<part>" <kept> + "<piece>" <taken> …` line per part an `assemble.cuts` entry cut (below; it ends `; under <n> px filled, <m> px left empty` when a cut of that part has `under`), then — with `config.limbs` (issue #349) — one `limb cut: "<part>" opaque <n> = "<segment part>" <px> + …` line per part a limb takes and one `limb cap:` line per joint, its cap's pixels from the cap image, from the layer and missing, and its box (under `cap_shape: "ball"`, issue #579, then the lower half's pixels written, left as painted and missing), followed on a short cap by one `LINT "<part>" cap at [x, y] … short_px left <n>, right <m>: no layer gives them …` line (issue #557) — from the upper segment where it gave a pixel (under `cap_shape: "disc"` always), under `edge: "feather"` the pixels faded, under `cut_band` the line the cut was placed on and the stroke pixels it and the joint line cross (issue #360) (§3, *Limbs: cut at their joints*), then one `fringe pushed back: "<part>" <px> px, where the painting shows "<holder>" <px> px, …` line per part whose fringe was cleared (below) | on the examples: `reference-sample` 0.83 / 98.0 % / 4,359 / 1,185, 259 holes, the largest 94 px; `reference-demo` 2.34 / 95.8 % / 10,340 / 1,564, 453 holes, the largest 70 px (default rule) — many slivers along part edges, no hole a region could hide | one large hole: part of the figure is in no layer — a plan entry is missing, hair left the head crop sideways (reference-demo's `hair_back` is taken from the full run for that reason), or See-through split one garment into two and left the space between them in neither (a skirt as two trouser legs); the `between` parts say where. When neither run holds it at all, an `assemble.patches` entry cuts it from the painting (below) |
+| `assemble` | one line per part — its counts (`op=` opaque, `vis=` visible, `src=` taken / candidates, `unproj=` visible but not projected, `drift=<n> (<p>% of core)`, `merged=`, `seam=`; *parts.json*, below). `drift=` is `refused_drift_px` in rig px and its share of the part's candidates, `projected_core_px`, which it is a subset of (issue #314); no bar reads either. On the four public examples the share runs to 94.5 % (`scarf` `hair_back`, 479 of 507) and the count to 26,472 (`scarf` `topwear`, 22.3 %), and the seam override repaints refused top-most pixels afterwards, so a large count says where See-through's colour was not taken, not that the part is unlike the painting: the `drift:` line below is the one that names a body of them another part holds. Then the `pixels:` totals (opaque = visible + occluded; taken; visible but not projected), then `recomposite vs source: mean \|d\|, within 8, error px > 40, uncovered error px`, then `uncovered holes (8-connected): N` and the largest five as `uncovered hole K: <px> px at x,y wxh (between "<part>" <px> px, …)`, then one `uncovered: <n> of the <N> uncovered error px lie on the full run's "<tag>", in a body of <px> px at x,y wxh; <the rule that left it out>` line per full-run layer the plan does not take from the full run whose uncovered error holds a body (5x5-opened, 8-connected, at least 150 full-run px in rig px), then one `drift: "<part>" refuses <n> px of <run>:<tag> (its colour more than 90 off the painting, max channel), in a body of <px> px at x,y wxh (…); by the plan's draw order "<holder>" holds <px> px of it (…)[, "<holder>" drawn in front of "<part>"][; the painting is within 90 of "<behind>" (<px> px at alpha >= 250, drawn behind "<part>")]; informational: no gate reads this. Swapping the plan order of the parts named here can clear it (when only the front one differs from the painting) or move it to the other part (when both do): swap, rebuild and read this line again; if it moves, removing it needs different input layers. At rest, the seam pass repaints the holder's pixels that pass its rule from the painting` line per part whose drift refusals hold a body (the same opening and bar) that another part holds in the draw order or that a part drawn behind it matches within 90 of the painting (issues #255, #351, #758) — that layer is not what the painting shows there; no gate reads this line, swapping the plan order of the parts named here can clear it (when only the front one differs from the painting) or move it to the other part (when both do) — swap, rebuild and read this line again, and if it moves, removing it needs different input layers — and at rest the seam pass repaints the holder's pixels that pass its rule from the painting (none on the five public paintings), then, per subset alternate set, one `LINT set "<set>" <part>: <layer part> holds <n> islands (8-connected, alpha above 8)[, and <s> speck(s) under 1 % of the largest (<f> px), each with the island nearest it], kept the one under <joints> (<k> px), dropped <m> (<d> px)` line per limb part cut from a layer of more than one island when the set names one limb side of it (issue #588; issue #608: a joint taken to the nearest island reads `<bone> [x, y] (<e> px off it, within its cap's radius <r>)`, and a part that lost no pixel `dropped none`), then one `LINT set "<set>" <part>: <layer part> holds <limb> and <other limb> in one island (8-connected, alpha above 8), split by the nearest segment line at the set's bones: kept <k> px (<share>), gave <m> px (<share>) to <other limb>; <b> px in the overlap band (nearer one line than the other by 0.5 px or less) went to the limb drawn in front, <bk> kept and <bg> given` line per limb part cut from a layer of one island that a limb the set does not carry also takes (issue #609; k, m and b count the part's pixels above alpha 8, each share of the part's pixels before the split, 3 places) and one `LINT set "<set>" <part>: <n> px under <base part> excluded` line per subset alternate set's limb part and base part drawn over it that the set does not replace which took a pixel (issue #587, `assemble.alternates` above; none on the public examples, which declare no alternate set); and look at `render/recomposite_error_rig.png`. Between the part lines and the totals, one `author-made: part "<part>" (<run>:author:<label>) — …` line per part from a layer the author made (below, *A layer the author made*), then one `cut: "<part>" opaque <n> = "<part>" <kept> + "<piece>" <taken> …` line per part an `assemble.cuts` entry cut (below; it ends `; under <n> px filled, <m> px left empty` when a cut of that part has `under`), then — with `config.limbs` (issue #349) — one `limb cut: "<part>" opaque <n> = "<segment part>" <px> + …` line per part a limb takes and one `limb cap:` line per joint, its cap's pixels from the cap image, from the layer and missing, and its box (under `cap_shape: "ball"`, issue #579, then the lower half's pixels written, left as painted and missing), followed on a short cap by one `LINT "<part>" cap at [x, y] … short_px left <n>, right <m>: no layer gives them …` line (issue #557) — from the upper segment where it gave a pixel (under `cap_shape: "disc"` always), under `edge: "feather"` the pixels faded, under `cut_band` the line the cut was placed on and the stroke pixels it and the joint line cross (issue #360) (§3, *Limbs: cut at their joints*), then one `fringe pushed back: "<part>" <px> px, where the painting shows "<holder>" <px> px, …` line per part whose fringe was cleared (below) | on the examples: `reference-sample` 0.83 / 98.0 % / 4,359 / 1,185, 259 holes, the largest 94 px; `reference-demo` 2.34 / 95.8 % / 10,340 / 1,564, 453 holes, the largest 70 px (default rule) — many slivers along part edges, no hole a region could hide | one large hole: part of the figure is in no layer — a plan entry is missing, hair left the head crop sideways (reference-demo's `hair_back` is taken from the full run for that reason), or See-through split one garment into two and left the space between them in neither (a skirt as two trouser legs); the `between` parts say where. When neither run holds it at all, an `assemble.patches` entry cuts it from the painting (below) |
 | `propose` | `note:` lines, `LINT` lines, the `coverage` lines, `landmarks.png`, `basis.json` | no LINT line: every chain link lies on its mesh's art, and the hip is below the chest and the figure's top quarter; the `coverage:` summary says how many bones that verdict covers — a `not checked` bone was read by no check (its line says why), and a `ratio` or `fallback` bone in `basis.json` is a guess | a link off the art (a bone on the background) — move it onto the layer; `LINT <link> at … runs to … N degrees off the head's down axis …` — a fringe link that does not lean with the head (§3, the fringe in the head's frame): move it along the lock it drives; `LINT <bone> under <parent>: amplitude <a> below the link above's <b> in the keyed chain …` — under `--cloth`, a keyed sibling the recipe left the only keyed child of its parent, which `CHAIN_LAG` would refuse (issue #572, §3 *A keyed sibling left behind*): raise the field it names to `<b>` or more in size; `LINT hairback_… on mesh '<part>' (side <r\|l>): <N> tree(s) for <M> visible hair mass(es) (mass 0 columns x=<minX>..<maxX>, y=<minY>..<maxY>; …)` — back-hair cloth trees whose count does not match the side's visible hair masses (`max(1, floor(w / (4 * grid)) + 1)` per mass) or whose link or tip leaves its mass's column range (issues #445, #461): omit `chains` on `cloth."back hair"` or draft trees per visible hair mass inside its columns; `LINT <a_limb> and <b_limb> on <part> (<from>) cross at [x, y] with no per-limb split: …` — two limbs sharing one layer cross in an X without a per-limb split (issue #446): declare `config.limbs.<covering>.split` (`{ "line": [[x, y], …] }` or `{ "edge": "painting" }`, §3 *Which limb*); `LINT foot_<s> at [x, y], the <s>_ankle joint and leg_<s>1's tip, lies on none of leg_<s>'s art within 1 px along its joint line (the nearest of it on that line is the pixel [x, y], D px from the joint): …` — an ankle keypoint off its leg's art on the line `assemble` sizes the ankle's cap by (issue #517): `propose` drafts every leg without its ankle cut, the shoe layer stays one part, and nothing is moved onto the art; move that ankle keypoint onto the leg's or the shoe's art and re-run `propose` (`(the line crosses none of it)` when no art lies on that line at all); `LINT stop on <chain> (<firstLink> at [x0, y0]) against <against> (at [ax, ay]) places <chain>_touch at [tx, ty], above <firstLink>'s root (rest R deg, \|rest\| + outward B deg): …` — a stop's contact point `<chain>_touch` lies above `links[0]`'s root in rig px or pushes `\|rest\| + outward` past `180°` (issue #447, §2 `stops`): stop against the descending limb bone below `firstLink`, set `links` to start at a link below `<chain>_touch`, or omit the stop on a rising limb; `LINT hip at [x, y] is not below chest at [x, y]: …` or `LINT hip at [x, y] is above 0.25 of the figure height (figure y T..B, so hip y must be at least L): a hip at the shoulders` — move `hip` down to the waist (and `chest` between it and the neck); a `hanging strand … -- no chain proposed` note — that strand hangs stiff until you add a chain down the x and rows it names (§3); a `no blink: …` or `blink without brows: …` note — the idle will not blink (or its brows will not drop), because no part came from an `eyewhite` (or `eyebrow`) layer; the note names the tags looked for; a `no eyewhite part for eye_<s> …` note — the iris and lash parts it names ride `head` and do not blink, because no `eyewhite-<s>` part made that side's eye bone: take the eyewhite from the other run, or keep them on `head`; a `no face part: face box derived from …` note (always the first) — `head`, `neck` and every face-height scale come from a box guessed off the hair and neck (§3): check `head` and `neck` on `landmarks_head.png` and move them; when it adds `the blink shuts the eyes over no face part`, read `BLINK_NO_HOLE` after `check` — an eye with no face under it can open a hole (the `reference-sample` with only its face removed: 587 px). Under `--keypoints`: the `lint rule set:` line first (joints, or screen and why), then the joint notes — `missing: the rule "…" placed bone X instead` is a bone still guessed; `not used — …` names why an arm's joints did not place its sleeve (for a wrist on no part, the nearest part and the `--wrist-snap` that would bind it); a `wrist snap: …` note is a wrist bound past 15 px by the flag — check that chain's tip on `landmarks.png`; a `one handwear part holds both wrists` note is two chains on one mesh — cut the part with `assemble.cuts` to separate them; `LINT chest at … is not between the neck joint …`, `LINT hip at … is not past chest …`, `LINT hip at … is nearer the neck joint …` and `LINT <chain><i> at … does not advance from <s>_shoulder toward <s>_wrist` are the joint-frame lines: move that bone between, past or along the joints they name |
 | `compare` | one line per pair (origin, parent, tip, length, direction — or SKIP and why), then the per-row summary, the unmapped bones of each side, `required:`, each side's roles and the `controls:` line | proposal against the config you corrected: the rows you changed and no others. Config against the `rig.json` `build` writes for it: measured on both examples, every origin within 6.19e-7 px (the rig's offsets are written to 6 places) and every chain link's tip and length within 4.99e-4 px (`length` is written to 3), printed to three places as `0.000` (a signed figure as `+0.000` or `-0.000`); `parent … is the right's ancestor at depth 2, <bone>_ctl between` for every keyed mesh bone, no `DIFFERENT` and no `NOT MAPPED` | `parent DIFFERENT: left a, right b` — a bone hangs from another parent than the other side's; `frames not related` — a rig with no stage (`skeleton.width`/`height`), two configs at different `rig_scale`: the distance rows SKIP, so declare the frame in a `--map` file if the author knows it; `FAIL  STRUCTURE_REQUIRED_PRESENT` — a bone the map requires is missing through its pairs |
 | `rig` (inside `build`) | one line per mesh: vertices, triangles, bones, influences, `cover`; the `bones` line; the `idle keys` line; then rigc's gate lines (with A15's declared SKIP under `--idle-keys direct`); in `rig.json`, each chain link's (or its `_ctl`'s) `length` and `rotation` | `cover 1.00000` on every mesh, both gate summaries `0 failed` (the compile and the packed pages); every link's `length` the distance to the next link and `rotation` its direction (Spine degrees, counter-clockwise, y up, local to the parent), every offset under it — a child bone's `x, y`, a weight's bind `x, y`, a region's `x, y` — in that turned frame, and a region on a link carrying `rotation` that turns it back upright. Nothing moved: `flattenRig` (`src/rig.ts`) turns every offset back and gives the unturned numbers | `RIG_LATTICE_ONE_LOOP`: change that mesh's `grid` |
@@ -3843,8 +3912,8 @@ says why each requirement exists and what breaks without it.
 | <a id="PROPOSE_FIGURE_LAYER"></a>`PROPOSE_FIGURE_LAYER` | with `--keypoints` (issue #577): a limb is drafted from the figure layer (no handwear or legwear part over 500 px for it), and two or more `topwear` parts each hold every joint and the trunk bones' origins within 15 px with the same opaque px in the 31x31 squares about them, so nothing says which is the figure; or the only `topwear` parts that hold them are named by a cloth recipe (`config.cloth.<tag>.part` or `.parts`, issue #631), whose mesh a limb would take (§3, *A figure of one material*) | leave the others out of `assemble.plan`, or give the arms and legs their own handwear and legwear layers; for a recipe's part, take it out of the recipe |
 | <a id="PROPOSE_CLOTH_DRAFTED"></a>`PROPOSE_CLOTH_DRAFTED` | with `--cloth` (issue #364): the config's `cloth` block holds a recipe for a tag the proposer drafts no chain on — no part has that tag, or every `back hair` part ends above the shoulders (a bun bone, no chain). A `bottomwear` recipe with no `bottomwear` part names every `topwear` part shaped like a skirt (issue #402) | leave that recipe out, or assemble the layer it is for, or declare the named part in `cloth.bottomwear.part` |
 | <a id="PROPOSE_CLOTH_PART"></a>`PROPOSE_CLOTH_PART` | with `--cloth` (issues #402, #437): `cloth.bottomwear.part` (a string) names no part, a part or cut piece whose source is not `topwear` (a `bottomwear` part takes the recipe by its tag already), or a target whose box ends above the hip + 0.25 face heights, the topwear rule's waist line; or `cloth.<tag>.parts` (or `part` as a list, issue #437) names a part not in `parts.json`, a part no link of the drafted tree crosses (`spanCrosses == 0`), or parts out of root-to-tip depth order along the chain | name the `topwear` part or its cut skirt piece that holds the skirt (or leave `part` out), or list only parts in `parts.json` that the drafted tree links cross in root-to-tip order |
-| <a id="PROPOSE_WRITE_CONFIG_FRESH"></a>`PROPOSE_WRITE_CONFIG_FRESH` | with `--cloth … --write-config` (issues #537, #356): the out path exists or collides with one of the four artifacts under `--out` — `proposal.json`, `basis.json`, `render/landmarks.png`, `render/landmarks_head.png` — including directory-symlink and hardlink aliases; the config is written to a new file, never over the `--cloth` config or an earlier one | name a file that does not exist yet, beside the `--cloth` config and separate from all four artifact paths and their aliases |
-| <a id="PROPOSE_WRITE_CONFIG_CONFLICT"></a>`PROPOSE_WRITE_CONFIG_CONFLICT` | with `--write-config` (issue #552): an entry of `bones`, `constraints` or `motion.tracks` the recipe re-drafts or removes was changed by hand in the `--cloth` config — it equals neither the draft with the recipe nor the draft without it — so the write would drop the hand edit; the object is the entry (`config.constraints[40] "skirt0a_0_physics"` in CL207), the detail names the first field the hand edit holds and what the draft writes there. With `--from <previous config>` (issue #571) an entry equal to the previous recipe's draft is the recipe's too, and the conflict is an entry that equals neither the draft, the draft without the recipe, nor the previous recipe's draft: the detail says so and reads the first differing field against the previous recipe's draft. Also a name the config states twice where the recipe drafts it. Every conflict is named at once and nothing is written | take the draft by removing the hand edit (or the entry), or leave the recipe out for that part (its `cloth` block); state a name once |
+| <a id="PROPOSE_WRITE_CONFIG_FRESH"></a>`PROPOSE_WRITE_CONFIG_FRESH` | with `--cloth … --write-config` (issues #537, #356): the out path exists or collides with one of the four artifacts under `--out` — `proposal.json`, `basis.json`, `render/landmarks.png`, `render/landmarks_head.png` — including directory-symlink and hardlink aliases; the config is written to a new file, never over the `--cloth` config or an earlier one (unlike `assemble --propose-plan` and `propose` without `--cloth`, which update an existing `--config` in place; §4, *Saving proposed config fields*) | name a file that does not exist yet, beside the `--cloth` config and separate from all four artifact paths and their aliases |
+| <a id="PROPOSE_WRITE_CONFIG_CONFLICT"></a>`PROPOSE_WRITE_CONFIG_CONFLICT` | with `--write-config` (issue #552): an entry of `bones`, `constraints` or `motion.tracks` the recipe re-drafts or removes was changed by hand in the `--cloth` config — it equals neither the draft with the recipe nor the draft without it — so the write would drop the hand edit; the object is the entry (`config.constraints[40] "skirt0a_0_physics"` in CL207), the detail names the first field the hand edit holds and what the draft writes there. With `--from <previous config>` (issue #571) an entry equal to the previous recipe's draft is the recipe's too, and the conflict is an entry that equals neither the draft, the draft without the recipe, nor the previous recipe's draft: the detail says so and reads the first differing field against the previous recipe's draft. Also a name the config states twice where the recipe drafts it. Every conflict is named at once and nothing is written | to take the recipe's draft, remove the hand-edited track, bone or constraint from `config.<section>` (or revert the hand edit) and run `propose --cloth` again, or leave the recipe out for that part (its `cloth` block); state a name once |
 | <a id="PROPOSE_WRITE_CONFIG_SPLICE"></a>`PROPOSE_WRITE_CONFIG_SPLICE` | with `--write-config` (issue #537): the `--cloth` config's text with the drafted sections spliced in does not parse to that config with them set, and the message names the first key that moved — the text states a key twice, so the splice lands on the first and the parse keeps the last | state each key once in the `--cloth` config |
 | <a id="PROPOSE_CLOTH_BACK_HAIR_CHAINS"></a>`PROPOSE_CLOTH_BACK_HAIR_CHAINS` | with `--cloth` (issues #390, #445, #461): `cloth."back hair".chains` exceeds what the narrower side's opaque width at the eye-line root row holds at the part's mesh grid (`max(1, min(floor(w_r / grid), floor(w_l / grid)))`), or places a tree root outside the 15 px dilated art mask of the `back hair` part (e.g. an inner twin-tail root over the face where the hair has no pixel); the message names the part, each side's root-row width, the grid spacing, and any off-art root with its pixel alpha | lower `cloth."back hair".chains` to at most the max fit named in the message, or omit `chains` so `propose --cloth` derives the tree count per visible hair mass on each side from its root-row width |
 | <a id="PROPOSE_ACCESSORY_BODY"></a>`PROPOSE_ACCESSORY_BODY` | an accessory has nothing above its pendant rows to hang its bone on | that part's plan entry, or author its bones by hand |
@@ -3855,7 +3924,7 @@ says why each requirement exists and what breaks without it.
 | <a id="KEYPOINTS_JOINT_KNOWN"></a><a id="KEYPOINTS_JOINT_STATE"></a><a id="KEYPOINTS_POSITION_STATED"></a><a id="KEYPOINTS_POSITION_INSIDE"></a>`KEYPOINTS_JOINT_KNOWN`, `KEYPOINTS_JOINT_STATE`, `KEYPOINTS_POSITION_STATED`, `KEYPOINTS_POSITION_INSIDE` | a joint name outside body-18, a state outside observed / occluded / missing, an observed joint with no `at` or a missing one with one, or a position outside the `width`x`height` image | that joint |
 | <a id="KEYPOINTS_PERSON_UNIQUE"></a><a id="KEYPOINTS_PERSON_CHOSEN"></a>`KEYPOINTS_PERSON_UNIQUE`, `KEYPOINTS_PERSON_CHOSEN` | two people share an id; or the file holds more than one person and no `--person` names one, or `--person` names none of them (the message lists the ids) | `--person <id>` |
 | <a id="KEYPOINTS_IMAGE_SIZE"></a>`KEYPOINTS_IMAGE_SIZE` | the file's `width`x`height` is not the `--source` painting's | a file measured on this painting |
-| <a id="PARTS_FILE_PRESENT"></a><a id="PARTS_IS_JSON"></a><a id="PARTS_KEY_KNOWN"></a><a id="PARTS_FIELD_PRESENT"></a><a id="PARTS_FIELD_TYPE"></a><a id="PARTS_NAME_UNIQUE"></a><a id="PARTS_FROM_KNOWN"></a><a id="PARTS_CUT_FROM_KNOWN"></a><a id="PARTS_BOX_INSIDE_RIG"></a><a id="PARTS_COUNTS_ADD_UP"></a><a id="PARTS_HOLES_LARGEST_FIRST"></a><a id="PARTS_HOLE_PART_KNOWN"></a><a id="PARTS_SINGLE_RUN_PAD"></a>`PARTS_*` (`PARTS_FILE_PRESENT`, `PARTS_IS_JSON`, `PARTS_KEY_KNOWN`, `PARTS_FIELD_PRESENT`, `PARTS_FIELD_TYPE`, `PARTS_NAME_UNIQUE`, `PARTS_FROM_KNOWN`, `PARTS_CUT_FROM_KNOWN`, `PARTS_BOX_INSIDE_RIG`, `PARTS_COUNTS_ADD_UP`, `PARTS_HOLES_LARGEST_FIRST`, `PARTS_HOLE_PART_KNOWN`, `PARTS_SINGLE_RUN_PAD`) | the `parts.json` read is not assemble's contract (`PARTS_COUNTS_ADD_UP`: `visible_px + occluded_px` is not `opaque_px`, `visible_not_projected_px` is above `visible_px`, or the `recomposite` block's figures disagree — more uncovered than error pixels, a hole larger than its box, the wrong number of holes listed, listed areas that do not sum to `uncovered_error_px`; the last two codes are the block's order and its border names; `PARTS_SINGLE_RUN_PAD`: the `single_run_pad` block's margins are not the centring, its file is not smaller than its square, or `rig_size` is not the file at the scale, issue #366 — §5) | re-run assemble; do not edit `parts.json` |
+| <a id="PARTS_FILE_PRESENT"></a><a id="PARTS_IS_JSON"></a><a id="PARTS_KEY_KNOWN"></a><a id="PARTS_FIELD_PRESENT"></a><a id="PARTS_FIELD_TYPE"></a><a id="PARTS_NAME_UNIQUE"></a><a id="PARTS_FROM_KNOWN"></a><a id="PARTS_CUT_FROM_KNOWN"></a><a id="PARTS_BOX_INSIDE_RIG"></a><a id="PARTS_COUNTS_ADD_UP"></a><a id="PARTS_HOLES_LARGEST_FIRST"></a><a id="PARTS_HOLE_PART_KNOWN"></a><a id="PARTS_SINGLE_RUN_PAD"></a>`PARTS_*` (`PARTS_FILE_PRESENT`, `PARTS_IS_JSON`, `PARTS_KEY_KNOWN`, `PARTS_FIELD_PRESENT`, `PARTS_FIELD_TYPE`, `PARTS_NAME_UNIQUE`, `PARTS_FROM_KNOWN`, `PARTS_CUT_FROM_KNOWN`, `PARTS_BOX_INSIDE_RIG`, `PARTS_COUNTS_ADD_UP`, `PARTS_HOLES_LARGEST_FIRST`, `PARTS_HOLE_PART_KNOWN`, `PARTS_SINGLE_RUN_PAD`) | the `parts.json` read is not assemble's contract (`PARTS_FILE_PRESENT`: no `parts.json` under `--parts`, which names the directory holding `parts.json` and `parts/` — `work/rig` from `assemble --out work`, or `out` from `build --out out`; `PARTS_COUNTS_ADD_UP`: `visible_px + occluded_px` is not `opaque_px`, `visible_not_projected_px` is above `visible_px`, or the `recomposite` block's figures disagree — more uncovered than error pixels, a hole larger than its box, the wrong number of holes listed, listed areas that do not sum to `uncovered_error_px`; the last two codes are the block's order and its border names; `PARTS_SINGLE_RUN_PAD`: the `single_run_pad` block's margins are not the centring, its file is not smaller than its square, or `rig_size` is not the file at the scale, issue #366 — §5) | pass the directory holding `parts.json` and `parts/` (`work/rig` or `out`), or re-run assemble; do not edit `parts.json` |
 
 ### compare
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rig-parts",
-  "version": "1.65.0",
+  "version": "1.66.0",
   "description": "AI-authored 2D character parts from one anime painting and its See-through layer decomposition: measured parts, weighted-mesh rig specs, verified through rig-c before anything is written. A CLI for agents that cannot see the image.",
   "type": "module",
   "bin": {

package/skills/rig-parts/SKILL.md

@@ -125,7 +125,7 @@ under that.
 6. Correct against `render/landmarks.png` and `note:` lines; a
    `coverage … not checked` line is a bone no check read (the line says why),
    and `basis.json` beside the proposal says what each bone rests on — check
-   the `ratio` bones and any with a `fallback` first. `propose …
+   the `ratio` bones and any with a `fallback` first. `rig-parts propose --parts work/rig --source <painting> --out work
    --from-config config.json` (with the same `--keypoints`) until it prints no
    `LINT` line. `rig-parts compare
    --left work/proposal.json --right config.json` lists what the correction changed,

package/src/assemble.ts

@@ -102,7 +102,7 @@
 import { sourceLimbTarget, nearestTargetPart } from './limbownership.ts';
 import { type ArmSplit, type BoneEntry, type CharacterConfig, type ControlSkeleton, controlSkeletonOf, type Cut, type EarlyConfig, type Extend, type Limb, type Patch, type PlanEntry, type Run, type SeeThrough } from './config.ts';
 import { type Problem, refuseIfAny } from './errors.ts';
-import { figuresPhrase, implausibleRules, type Layer, type LayerFigures, layerFigures, type LayerSet, NEAR_WHITE_MIN, OPAQUE_ALPHA_ABOVE, ruleSummary } from './layers.ts';
+import { CORE_ALPHA, figuresPhrase, implausibleRules, type Layer, type LayerFigures, layerFigures, type LayerSet, NEAR_WHITE_MIN, OPAQUE_ALPHA_ABOVE, ruleSummary } from './layers.ts';
 import { padToSquare, squarePad } from './inputs.ts';
 import { type CapRecord, type LimbRecord, PAINTING_RUN, type PartRecord, type PartsFile, type RecompositeRecord, type SceneRecord, type SingleRunPad } from './parts.ts';
 import { assignCrossedLimbs, assignOverlappingHands, type BonePlace, bonePlaces, capBox, coveredRadius, type CutPlacement, featherWeight, halfWidthAbout, inDisc, jointLine, type JointLine, jointOffsets, limbPolyline, limbRun, luma601, nearestLimb, nearestOnLine, offLineFigure, pastJoint, placeCut, polylineDist2, segmentOf } from './limbs.ts';
@@ -133,8 +133,6 @@ const f32 = Math.fround;
 // the reference's constants, each named once
 // ---------------------------------------------------------------------------
 
-/** Alpha at or above this is "opaque" for ownership, projection cores and the seam override. `>= 250`, not `== 255`: See-through leaves alpha-254 speckle. */
-export const CORE_ALPHA = 250;
 /** A ghost component is kept when its area is at least this many pixels … */
 export const GHOST_MIN_AREA = 40;
 /** … and at least this fraction of the layer's largest component. */
@@ -160,7 +158,7 @@ export const CROP_PROBE_ALPHA = 128;
 /** Alpha at or above this in a later plan part keeps `growRim`'s ring off the pixel. */
 export const FRONT_ALPHA = 128;
 /** A painting pixel whose min channel is above this is "near-white" (the faithful rim and seam guard). Defined beside the layer reader, which applies the same test to a layer's colour (`layerFigures`). */
-export { NEAR_WHITE_MIN };
+export { CORE_ALPHA, NEAR_WHITE_MIN };
 /** The seam override acts where the flat composite differs from the painting by more than this, max channel. */
 export const SEAM_LIMIT = 60;
 /** `--propose-plan` drops a tag with fewer run-space opaque pixels than this after ghost clean-up. */
@@ -5214,7 +5212,13 @@ export function driftBodies(part: string, from: string, refused: Mask, minPx: nu
  * `drift: "topwear" refuses 196 px of full:topwear (its colour more than 90
  * off the painting, max channel), in a body of 196 px at 16,12 14x14 (at
  * least 150 px past a 5x5 opening); by the plan's draw order "face" holds 196
- * px of it (the top-most part at alpha >= 250), drawn in front of "topwear"`.
+ * px of it (the top-most part at alpha >= 250), "face" drawn in front of
+ * "topwear"; informational: no gate reads this. Swapping the plan order of the
+ * parts named here can clear it (when only the front one differs from the
+ * painting) or move it to the other part (when both do): swap, rebuild and read
+ * this line again; if it moves, removing it needs different input layers. At
+ * rest, the seam pass repaints the holder's pixels that pass its rule from the
+ * painting`.
  * When `behind` is non-empty (issue #351), names the part(s) drawn behind
  * `part` whose colour is within `DRIFT_LIMIT` of the painting.
  */
@@ -5230,7 +5234,8 @@ export function driftLine(d: DriftBodies): string {
       : '';
   return (
     `drift: "${d.part}" refuses ${d.refusedPx} px of ${d.from} (its colour more than ${DRIFT_LIMIT} off the painting, max channel), in ${held} (at least ${fmtPx(d.minPx)} px past a ${BODY_KERNEL}x${BODY_KERNEL} opening); ` +
-    `by the plan's draw order ${d.holders.map((h) => `"${h.part}" holds ${h.px} px`).join(', ')} of it (the top-most part at alpha >= ${CORE_ALPHA})${frontClause}${behindClause}`
+    `by the plan's draw order ${d.holders.map((h) => `"${h.part}" holds ${h.px} px`).join(', ')} of it (the top-most part at alpha >= ${CORE_ALPHA})${frontClause}${behindClause}; ` +
+    "informational: no gate reads this. Swapping the plan order of the parts named here can clear it (when only the front one differs from the painting) or move it to the other part (when both do): swap, rebuild and read this line again; if it moves, removing it needs different input layers. At rest, the seam pass repaints the holder's pixels that pass its rule from the painting"
   );
 }
 

package/src/check.ts

@@ -7168,6 +7168,7 @@ function tipLine(inp: FullInputs, geometryPath: string, frames: number, problems
       const carry = breathCarrier(inp.rig, inp.motion, p.name, geometryPath, frames, { art, box: p, stage: inp.stage, shown, toward: rises ? 'up' : 'down', root: t.root, tip: t.tip });
       if (carry !== null) rows[rows.length - 1] = { ...rows[rows.length - 1], carried_by: carry.bone, breath_rig_px: round3(carry.breath), root_without_breath_rig_px: round3(carry.root), tip_without_breath_rig_px: round3(carry.tip) };
       const offChain = carry === null && round3(t.tip) > 0 ? offChainClause(inp.rig, inp.motion, p.name) : null;
+      const misplaced = rises || carry !== null || offChain !== null ? null : chainRootsBelowArtClause(inp.rig, inp.motion, p, inp.stage, readGeometry(geometryPath, frames)?.setupBones);
       const why =
         carry === null
           ? `the chain's amplitudes do not grow toward the tip, or the mesh is not weighted to the chain${offChain === null ? '' : `; ${offChain}`}`
@@ -7177,7 +7178,7 @@ function tipLine(inp: FullInputs, geometryPath: string, frames: number, problems
       problems.push({
         code: 'CHECK_TIP_OVER_ROOT',
         object: `part "${p.name}", box ${p.x},${p.y} ${p.w}x${p.h} rig px, posed by the idle's geometry${rises ? ', declared rises' : ''}`,
-        detail: `the art in its ${tipHalf} half travels ${round3(t.tip)} rig px and in its ${rootHalf} half ${round3(t.root)} rig px (ratio ${ratio ?? 'undefined: nothing moves'}); a ratio >= ${TIP_RATIO_FLOOR} is required — ${why}`,
+        detail: `the art in its ${tipHalf} half travels ${round3(t.tip)} rig px and in its ${rootHalf} half ${round3(t.root)} rig px (ratio ${ratio ?? 'undefined: nothing moves'}); a ratio >= ${TIP_RATIO_FLOOR} is required — ${misplaced ?? why}`,
       });
     }
   }
@@ -7236,6 +7237,24 @@ function offChainClause(rig: Record<string, unknown>, motion: Record<string, unk
   return `it is weighted off the chain to ${list} — drop the segment on ${drop} in \`meshes.${part}.segments\`, or grow the chain's amplitudes toward the tip`;
 }
 
+/** #752: a failing hanging part whose carrying pivots all sit below its art needs their placement named, not larger angles. */
+export function chainRootsBelowArtClause(
+  rig: Record<string, unknown>, motion: Record<string, unknown>, part: Pick<PartRecord, 'name' | 'y' | 'h'>,
+  stage: StageBox, setupBones: unknown,
+): string | null {
+  const { found } = chainsCarrying(rig, motion, part.name);
+  if (found.length === 0 || !Array.isArray(setupBones)) return null;
+  const origins = new Map(setupBones.filter(isRecord).filter((b) => typeof b.name === 'string' && typeof b.worldX === 'number' && typeof b.worldY === 'number').map((b) => [String(b.name), { x: b.worldX as number, y: b.worldY as number }]));
+  const roots = found.map((chain) => {
+    const at = origins.get(chain[0]);
+    return at === undefined ? null : { chain, x: at.x - stage.x, y: cropToSpineY(at.y - stage.y, stage.height) };
+  });
+  if (roots.some((r) => r === null || !Number.isFinite(r.x) || !Number.isFinite(r.y) || r.y <= part.y + part.h)) return null;
+  const placed = roots.filter((r): r is NonNullable<typeof r> => r !== null);
+  const list = placed.map((r) => `${r.chain.join(' > ')} at crop [${round3(r.x)}, ${round3(r.y)}]`).join('; ');
+  return `the carrying chains' roots are below the art: ${list}; the part's crop y range is ${part.y}..${part.y + part.h} — re-place these chains' \`bones\` \`points\` / \`tip\` across this art, rooting them in its upper half (y ${part.y}..${part.y + part.h / 2}) and ending in its lower half (y ${part.y + part.h / 2}..${part.y + part.h}); \`propose\` on these assembled parts drafts those positions; increasing amplitudes leaves the root positions unchanged`;
+}
+
 /**
  * The bones a part's attachments are bound to in the default skin (issue #231): a mesh's weights, or its slot's
  * bone for an attachment that carries no weights.

package/src/clothconfig.ts

@@ -157,10 +157,11 @@ function entryEdits(
       V === null
         ? `it holds ${held} where ${draftSays}`
         : `it equals neither the draft, the draft without the recipe, nor the previous recipe's draft: it holds ${held} where ${prev === undefined ? 'the previous recipe\'s draft has no such entry' : `the previous recipe's draft writes ${field === null ? shown(prev) : fieldOf(prev, field)}`} and ${draftSays}`;
+    const kind = section === 'motion.tracks' ? 'track' : section === 'bones' ? 'bone' : 'constraint';
     conflicts.push({
       code: 'PROPOSE_WRITE_CONFIG_CONFLICT',
       object: `config.${section}[${i}] "${k}"`,
-      detail: `${section} entry "${k}" is the recipe's, and it was changed by hand: ${says}, so the write would drop the hand edit; take the draft by removing the hand edit (or the entry), or leave the recipe out for that part (its config.cloth block)`,
+      detail: `${section} entry "${k}" is the recipe's, and it was changed by hand: ${says}, so the write would drop the hand edit; to take the recipe's draft, remove the hand-edited ${kind} "${k}" from config.${section} (or revert the hand edit) and run propose --cloth again, or leave the recipe out for that part (its config.cloth block)`,
     });
   };
   for (const k of [...owned, ...removed]) {
@@ -288,7 +289,7 @@ export function clothConfigEdits(drafted: Proposal, plain: Proposal, input: unkn
     conflicts.push({
       code: 'PROPOSE_WRITE_CONFIG_CONFLICT',
       object: where,
-      detail: `${path.join('.')} is the previous recipe's, the recipe now leaves it to the draft without the recipe, and it was changed by hand: it equals neither the draft nor the previous recipe's draft: it holds ${field === null ? shown(mine) : at(mine, field)} where the previous recipe's draft writes ${c === undefined ? 'no such entry' : field === null ? shown(c) : at(c, field)} and the draft writes ${b === undefined ? 'no such entry' : field === null ? shown(b) : at(b, field)}, so the write would drop the hand edit; take the draft by removing the hand edit (or the entry), or keep the recipe for that part (its config.cloth block)`,
+      detail: `${path.join('.')} is the previous recipe's, the recipe now leaves it to the draft without the recipe, and it was changed by hand: it equals neither the draft nor the previous recipe's draft: it holds ${field === null ? shown(mine) : at(mine, field)} where the previous recipe's draft writes ${c === undefined ? 'no such entry' : field === null ? shown(c) : at(c, field)} and the draft writes ${b === undefined ? 'no such entry' : field === null ? shown(b) : at(b, field)}, so the write would drop the hand edit; to take the draft, remove the hand-edited ${path.join('.')} (or revert the hand edit) and run propose --cloth again, or keep the recipe for that part (its config.cloth block)`,
     });
   };
   const prevKeys = (section: string, have: readonly string[]): string[] => {

package/src/layers.ts

@@ -41,6 +41,8 @@ import { BODY_TAGS, HEAD_TAGS, HIDDEN_NAME_RULE, type LayerTagReading, layerTagR
 
 /** Alpha strictly above this counts as painted. The reference uses the same cut for its ghost clean-up and its sheets. */
 export const OPAQUE_ALPHA_ABOVE = 8;
+/** Alpha at or above this is "opaque" for ownership, projection cores and the seam override. `>= 250`, not `== 255`: See-through leaves alpha-254 speckle. */
+export const CORE_ALPHA = 250;
 /**
  * A pixel whose min channel is above this is "near-white". The assemble stage's
  * rim and seam guard apply it to the painting (`src/assemble.ts` re-exports it
@@ -100,6 +102,66 @@ export interface LayerSet {
   hidden: HiddenLayer[];
 }
 
+/** Bounds in input-canvas pixels, with exclusive right/bottom boundaries. */
+export interface OpaqueBox {
+  left: number;
+  top: number;
+  right: number;
+  bottom: number;
+}
+
+function alphaBox(layer: Pick<Layer, 'pixels' | 'left' | 'top'>, includes: (alpha: number) => boolean): OpaqueBox | null {
+  const p = layer.pixels;
+  let left = p.width;
+  let top = p.height;
+  let right = 0;
+  let bottom = 0;
+  for (let y = 0; y < p.height; y++) {
+    for (let x = 0; x < p.width; x++) {
+      if (!includes(p.data[(y * p.width + x) * 4 + 3])) continue;
+      left = Math.min(left, x);
+      top = Math.min(top, y);
+      right = Math.max(right, x + 1);
+      bottom = Math.max(bottom, y + 1);
+    }
+  }
+  return right === 0 ? null : { left: layer.left + left, top: layer.top + top, right: layer.left + right, bottom: layer.top + bottom };
+}
+
+/** Original alpha above the legacy painted-pixel cut (>8), before cleanup or resampling. */
+export function layerOpaqueBox(layer: Pick<Layer, 'pixels' | 'left' | 'top'>): OpaqueBox | null {
+  return alphaBox(layer, alpha => alpha > OPAQUE_ALPHA_ABOVE);
+}
+
+/** Original alpha at or above CORE_ALPHA; not an owned, eroded or resampled projection core. */
+export function layerCoreBox(layer: Pick<Layer, 'pixels' | 'left' | 'top'>): OpaqueBox | null {
+  return alphaBox(layer, alpha => alpha >= CORE_ALPHA);
+}
+
+function bodyBox(set: LayerSet, readBox: (layer: Layer) => OpaqueBox | null): OpaqueBox | null {
+  let union: OpaqueBox | null = null;
+  for (const layer of set.layers) {
+    if (layer.tag.group !== 'body') continue;
+    const box = readBox(layer);
+    if (box === null) continue;
+    union = union === null ? box : {
+      left: Math.min(union.left, box.left), top: Math.min(union.top, box.top),
+      right: Math.max(union.right, box.right), bottom: Math.max(union.bottom, box.bottom),
+    };
+  }
+  return union;
+}
+
+/** Source >8 union of the reader's existing drawn body group, not an anatomical silhouette. */
+export function bodyOpaqueBox(set: LayerSet): OpaqueBox | null {
+  return bodyBox(set, layerOpaqueBox);
+}
+
+/** Source >=CORE_ALPHA union of the same body group; no ownership, erosion or cleanup. */
+export function bodyCoreBox(set: LayerSet): OpaqueBox | null {
+  return bodyBox(set, layerCoreBox);
+}
+
 function opaque(r: Raster): number {
   let n = 0;
   for (let i = 3; i < r.data.length; i += 4) if (r.data[i] > OPAQUE_ALPHA_ABOVE) n++;

package/src/parts.ts

@@ -515,7 +515,7 @@ export function writeParts(path: string, file: PartsFile): void {
 }
 
 export function readParts(path: string): PartsFile {
-  if (!existsSync(path)) refuseIfAny([{ code: 'PARTS_FILE_PRESENT', object: path, detail: 'no such file' }]);
+  if (!existsSync(path)) refuseIfAny([{ code: 'PARTS_FILE_PRESENT', object: path, detail: 'no such file; --parts names the directory holding parts.json and parts/ (work/rig from assemble --out work, or out from build --out out)' }]);
   let raw: unknown;
   try {
     raw = JSON.parse(readFileSync(path, 'utf8'));

package/src/propose.ts

@@ -3494,12 +3494,46 @@ export function proposeWithBasis(
   }
   const constrained = clothConstraints.length === 0 ? {} : { constraints: clothConstraints };
   return {
-    proposal: { bones, meshes, regions, ...drafted, motion: blink === undefined ? { duration: IDLE_SECONDS, tracks: idleTracks } : { duration: IDLE_SECONDS, tracks: idleTracks, blink }, ...constrained, proposed_rig_scale: P.rigScale, notes },
+    proposal: draftPassingChainSigns(P, { bones, meshes, regions, ...drafted, motion: blink === undefined ? { duration: IDLE_SECONDS, tracks: idleTracks } : { duration: IDLE_SECONDS, tracks: idleTracks, blink }, ...constrained, proposed_rig_scale: P.rigScale, notes }),
     basis: { frame, bones: records },
     draftLint: [...jointsOffArt, ...radii],
   };
 }
 
+/**
+ * Issue #751: a fresh draft need not leave a measured, passing sign choice to its author.
+ * The supplied-config lint never calls this. The reader and bar are unchanged; an
+ * unread or still-failing alternative stays a LINT, not a guessed correction.
+ */
+export function draftPassingChainSigns(P: PartSet, proposal: Proposal): Proposal {
+  const images = new Map(P.recs.filter((p) => P.images.has(p.name)).map((p) => [p.name, { x: p.x, y: p.y, image: P.images.get(p.name) as Raster }]));
+  const key = (f: { mesh: string; a: { chain: string }; b: { chain: string } }): string => JSON.stringify([f.mesh, f.a.chain, f.b.chain]);
+  let current = proposal;
+  let reading = chainSqueezes(current, images);
+  const initial = reading.findings;
+  for (const original of initial) {
+    const finding = reading.findings.find((f) => key(f) === key(original));
+    if (finding === undefined || finding.turned === null || !Number.isFinite(finding.turned) || finding.turned > TEXTURE_STRETCH_CEILING) continue;
+    const candidate: Proposal = {
+      ...current,
+      motion: { ...current.motion, tracks: current.motion.tracks.map((t) => 'chain' in t && t.chain === finding.b.chain ? { ...t, amps: t.amps.map((a) => -a) } : t) },
+    };
+    // A track can be shared by other pairs/meshes. Accept no new or worsened
+    // finding, and do not turn a previously readable pair into an unread one.
+    const after = chainSqueezes(candidate, images);
+    if (JSON.stringify(after.unread) !== JSON.stringify(reading.unread) || after.findings.some((f) => {
+      const before = reading.findings.find((old) => key(old) === key(f));
+      return key(f) === key(finding) || before === undefined || f.both.severity > before.both.severity;
+    })) continue;
+    current = {
+      ...candidate,
+      notes: [...current.notes, `shared-mesh chain signs: ${finding.a.chain} and ${finding.b.chain} on mesh ${pyRepr(finding.mesh)} were opposed; drafted one sign by reversing ${finding.b.chain}'s amplitudes, keeping their magnitudes and timing: squeeze ${pyFixed(finding.both.severity, 3)} -> ${pyFixed(finding.turned, 3)} (<= ${TEXTURE_STRETCH_CEILING}, check's TEXTURE_STRETCH bar); all shared pairs re-read without a new or worsened finding`],
+    };
+    reading = after;
+  }
+  return current;
+}
+
 /**
  * The note the `figure` grid rule writes (issue #265): the spacing and where it came from, per lattice part its own
  * spacing and the one drafted, what it costs and what it was calibrated on.

package/src/rig.ts

@@ -648,7 +648,8 @@ export interface TurnRow {
  * the control {@link TURN_BONE} under `root` at its origin, nothing keying it;
  * for each part `config.turn.depths` lists, in parts.json order, a leaf twin of
  * every bone the part's slots bind (its region's bone, a blink.still piece's
- * bone, a mesh's slot bone and every bone its weights name) — an identity child,
+ * bone, a mesh's slot bone and every bone its weights name), in `bones`
+ * declaration order (issue #746) — an identity child,
  * x 0, y 0, no rotation, so its world transform is its bone's exactly and every
  * idle key, physics step or constraint on the bone reaches it — the part's
  * slots and weights moved onto the twins, and one transform constraint per part
@@ -672,7 +673,7 @@ export interface TurnRow {
  * constraint. A name the turn needs that is taken is refused by name
  * (`RIG_TURN_NAME_FREE`).
  */
-function applyTurn(
+export function applyTurn(
   turn: TurnSpec,
   order: readonly string[],
   bones: RigBone[],
@@ -681,8 +682,21 @@ function applyTurn(
   constraints: readonly ConfigConstraint[],
   frontSlots: ReadonlySet<string> = new Set(),
   slotFamilies: ReadonlyMap<string, readonly string[]> = new Map(),
+  stops: ReadonlyArray<{ links: readonly string[] }> | null = null,
+  orderByDeclaration: boolean = true,
 ): { constraints: Array<Record<string, unknown>>; detached: DetachedRule[]; rows: TurnRow[] } {
   const problems: Problem[] = [];
+  const undrawn = new Map<string, string>();
+  for (const s of stops ?? []) for (const l of s.links) undrawn.set(`${l}_d`, l);
+  const boneOrder = new Map(bones.map((b, i) => [b.name, i * 2]));
+  const orderOf = (b: string): number => {
+    const direct = boneOrder.get(b);
+    if (direct !== undefined) return direct;
+    const base = undrawn.get(b);
+    const baseIdx = base === undefined ? undefined : boneOrder.get(base);
+    if (baseIdx === undefined) throw new Error(`applyTurn: bound bone "${b}" is not in bones`);
+    return baseIdx + 1;
+  };
   const taken = new Set(bones.map((b) => b.name));
   const transforms = new Set(constraints.filter((c) => c.type === 'transform').map((c) => c.name));
   if (taken.has(TURN_BONE)) problems.push({ code: 'RIG_TURN_NAME_FREE', object: `bone "${TURN_BONE}"`, detail: 'is the control the rig stage adds for config.turn, and the rig already has a bone of that name; rename it' });
@@ -702,6 +716,8 @@ function applyTurn(
       bind(sl.bone);
       for (const att of Object.values(skin[sl.name] ?? {})) if ('type' in att) for (const v of att.weights) for (const w of v) bind(w.bone);
     }
+    for (const b of bound) orderOf(b);
+    if (orderByDeclaration) bound.sort((a, b) => orderOf(a) - orderOf(b));
     for (const b of bound) {
       const twin = turnTwin(f.part, b);
       if (taken.has(twin)) problems.push({ code: 'RIG_TURN_NAME_FREE', object: `bone "${twin}"`, detail: `is the twin that carries part "${f.part}" on "${b}" under config.turn, and the rig already has a bone of that name; rename it` });
@@ -1259,6 +1275,7 @@ export function buildRig(
   maxLoopPasses: number = ONE_LOOP_PASSES,
   idleKeys: IdleKeys = DEFAULT_IDLE_KEYS,
   reduce: Reducer = runReduction,
+  turnOrderByDeclaration: boolean = true,
 ): RigOutput {
   // Generated bands have a fixed one-pixel lattice, with their axial weights
   // below; config never supplies a second mesh policy for the same source.
@@ -2835,7 +2852,7 @@ export function buildRig(
   // ---- the turn control (issue #251) -------------------------------------
   // Only when the config has `turn`: every other build adds nothing here, so no byte moves.
   if (cfg.turn !== undefined) refuseIfAny(turnRiderProblems(cfg.turn, cfg, parts.parts));
-  const turned = cfg.turn === undefined ? null : applyTurn(cfg.turn, parts.parts.map((p) => p.name), bones, rebound, skin, cfg.constraints ?? [], declaredFront, slotFamilies);
+  const turned = cfg.turn === undefined ? null : applyTurn(cfg.turn, parts.parts.map((p) => p.name), bones, rebound, skin, cfg.constraints ?? [], declaredFront, slotFamilies, stops, turnOrderByDeclaration);
   for (const row of turned?.rows ?? []) for (const t of row.twins) layoutAlias(explicitLayout.plan, t.bone, t.twin);
   // issue #536: every row names the bones the emitted attachment binds, read once the turn and the stops have
   // rebound the weights; a rig with neither rebinds nothing, so this reads back the names each row already holds.

package/tools/configwrite.ts

@@ -45,7 +45,7 @@ export function readConfigWriteTarget(path: string): ConfigWriteTarget {
   const target = resolve(path);
   let stat: ReturnType<typeof lstatSync>;
   try { stat = lstatSync(target); }
-  catch (error) { return refusal('CONFIG_FILE_PRESENT', target, `cannot read the existing config: ${error instanceof Error ? error.message : String(error)}`); }
+  catch (error) { return refusal('CONFIG_FILE_PRESENT', target, `cannot read the existing config: ${error instanceof Error ? error.message : String(error)}; without --cloth, --write-config updates an existing config in place (only propose --cloth --write-config writes to a new file)`); }
   if (!stat.isFile()) return refusal('CONFIG_FIELD_TYPE', target, 'is not a regular file (symlinks are not replaced); --write-config updates an existing config file in place');
   let original: string;
   try { original = readFileSync(target, 'utf8'); }
@@ -133,7 +133,7 @@ export function stageConfigWrite(target: ConfigWriteTarget | FreshConfigWrite, p
       if (error instanceof Error && 'code' in error && error.code === 'ENOENT') return;
       return ioFailure(path, 'checking the fresh destination failed', error);
     }
-    refusal('PROPOSE_WRITE_CONFIG_FRESH', path, 'exists; the config is written to a new file, never over the --cloth config or an earlier one');
+    refusal('PROPOSE_WRITE_CONFIG_FRESH', path, 'exists; the config is written to a new file, never over the --cloth config or an earlier one (unlike assemble --propose-plan and propose without --cloth, which update an existing --config in place)');
   };
   if (fresh) freshAbsent();
   const temp = join(dirname(path), `.${basename(path)}.rig-parts-${randomBytes(8).toString('hex')}.tmp`);
@@ -182,7 +182,7 @@ export function stageConfigWrite(target: ConfigWriteTarget | FreshConfigWrite, p
           // refuses an intervening creator atomically; rename would overwrite it.
           try { (files.publish ?? linkSync)(temp, path); }
           catch (error) {
-            if (error instanceof Error && 'code' in error && error.code === 'EEXIST') refusal('PROPOSE_WRITE_CONFIG_FRESH', path, 'exists; the config is written to a new file, never over the --cloth config or an earlier one');
+            if (error instanceof Error && 'code' in error && error.code === 'EEXIST') refusal('PROPOSE_WRITE_CONFIG_FRESH', path, 'exists; the config is written to a new file, never over the --cloth config or an earlier one (unlike assemble --propose-plan and propose without --cloth, which update an existing --config in place)');
             throw error;
           }
           cancel();