rig-parts 1.59.0 → 1.60.1

package/NOTICE.md

@@ -119,7 +119,7 @@ redistributed.
   `allowDifferentLicense: false`: generated images may be used commercially and
   the model must be credited, which this line does.
 
-The [parts-examples](https://github.com/rig-c/parts-examples) README records
+The [rig-c/examples](https://github.com/rig-c/examples) README records
 both, beside each character's generation record.
 
 ### Models named by the optional painting graph

package/README.md

@@ -30,7 +30,7 @@ The painting was generated for this repository with a public checkpoint (Hassaku
 (Illustrious) v1.3 Style A, by Ikena, Fair AI Public License 1.0-SD) and no LoRA, on a
 pose that holds the hands apart, then given one hand-detailer pass; its generation
 record, See-through layers and licence are in
-<a href="https://github.com/rig-c/parts-examples">parts-examples</a>.
+<a href="https://github.com/rig-c/examples">rig-c/examples</a>.
 See-through ran twice, once on the whole figure and once on a square head crop.
 Then one command: <code>rig-parts build --loop --lead-in 3</code>. The proposer's bones, meshes,
 regions and motion were used as proposed but for one correction, written in the
@@ -209,7 +209,7 @@ head run on `st_input_head.png` is what gives the eyes more pixels
 four, and `rig-parts comfy` is only a convenience for that route: every
 stage after See-through reads files, whichever route wrote them. On the two
 reference examples each run took 171–199 s through the wrapper, and on the demo 179 s (each run's
-`meta.json`, in [parts-examples](https://github.com/rig-c/parts-examples)).
+`meta.json`, in [rig-c/examples](https://github.com/rig-c/examples)).
 
 ### The two images See-through is fed: `inputs`
 
@@ -338,7 +338,7 @@ agent skill.
 | `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 |
 | `propose --head-box --full <run> --canvas WxH [--no-back-hair] [--write-config <config>]` | propose `seethrough.head_box` from the full run, held inside the painting; `--no-back-hair` leaves the back-hair layer out of that proposal |
-| `propose --parts --source --out [--compare <config>] [--write-config <config>]` | 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 --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`) |
@@ -385,6 +385,17 @@ runs. Its already-checked splice text may be a partial config; it is not passed
 through the full-config loader. If removing the staged temporary fails after
 publication, the error may accompany an already-published complete config.
 `--from <previous.json>` retains the previous-recipe comparison.
+With `--only-missing` (issue #671), an ordinary proposal's `--write-config` adds
+only `meshes.<part>` or `regions.<part>` for each proposed part the config
+attaches by neither, entry by entry, and, for a part the 1.37.0 arm split makes
+(`full:drape-<s>`, `full:hand-<s>`) that `assemble.plan` does not name, its plan
+row beside the arm's row; every existing row and entry and every other byte
+stays as read, and nothing else of the proposal is written. The candidate passes
+the full loader first, so an entry on a bone the config does not declare is
+refused naming the part and the bone; nothing missing leaves bytes and mtime
+untouched. It is the upgrade path for a config proposed before the 1.37.0 arm
+split ([MIGRATION](docs/MIGRATION.md#after-1370-merged-arm-layers-are-split-issue-490)),
+and a usage error with `--head-box`, `--cloth` or `--from-config`.
 `--from-config` proposes nothing and cannot be combined with `--write-config`.
 [AUTHORING §4](docs/AUTHORING.md#4-the-command-order) describes all four modes.
 

package/cli.ts

@@ -279,6 +279,24 @@ usage:
       keeps the original bytes and mtime. A changed source, an artifact alias
       or a failed write is refused by name. Change lines go to stderr.
 
+  rig-parts propose --parts <dir> --source <painting.png> --out <dir> --write-config <config.json> --only-missing
+      Add to the existing config only what it lacks for the parts it attaches
+      by neither meshes.<part> nor regions.<part> (issue #671: a config proposed
+      before 1.37.0 meets the drape_<s> and hand_<s> parts the arm split makes,
+      issue #490; docs/MIGRATION.md). A part from full:drape-<s> or
+      full:hand-<s> that assemble.plan does not name gains its plan row where
+      assemble's rewrite puts it: the drape just before the full run's
+      handwear-<s> row, the hand just after it. Each part then gains its entry
+      as the proposal drafts it. Each row and entry is spliced in alone; every
+      existing row and entry and every other byte stays as read, and nothing
+      else of the proposal (bones, motion, …) is written. An unplanned part of
+      any other origin gets no row. The full config loader validates the
+      candidate first, so an added entry on a bone the config does not declare
+      is refused naming the part and the bone, and nothing is written. Nothing
+      missing keeps the bytes and mtime. One change line per added row and
+      entry goes to stderr. A usage error with --head-box, --cloth or
+      --from-config, or without --parts or --write-config.
+
   rig-parts propose --head-box --full <dir | layers.json | file.psd> --canvas <W>x<H> [--no-back-hair]
                          [--write-config <config.json>]
       Propose seethrough.head_box (source px, square) from the full run's
@@ -642,7 +660,15 @@ usage:
       the default (AUTHORING §6, The world the readings are taken in). One
       environment: line names the path, the step count and the sha256's first
       16 hex; check.json's environment holds path (as given), sha256 and
-      steps. Without the flag no key and no render argument moves.
+      steps. Without the flag no environment provenance key is written.
+      Physics rigs with readable declared seam pairs also report independent
+      default wind [1, 0] and still wind [0, 0], gravity [0, 1], under
+      SEAM_OVER_MOTION.worlds: gap/ghost maximum and worst frame only;
+      dir points to retained raw seam renders relative to check.json. No
+      new bar or warning, and the custom reading is unchanged. No wind
+      response or no band is SKIP; no pair or animation gives no worlds.
+      Nonphysics output is unchanged. In rig-play environment(null) returns
+      to the default world, not still air (AUTHORING, Physics seam environments).
 
   rig-parts loop --frames <dir> --out <file.png | file.gif> [--palette]
       Encode a frame set rigc render wrote (its --out directory, or the set
@@ -984,7 +1010,7 @@ const TAKES = {
   layers: { valued: ['--export', '--template', '--canvas'], switches: [] },
   sheet: { valued: ['--source', '--layers', '--out', '--cell', '--cols'], switches: [] },
   rig: { valued: ['--config', '--parts', '--out', '--idle-keys', '--page-edges', '--pack-shape'], switches: [] },
-  propose: { valued: ['--parts', '--source', '--out', '--from-config', '--compare', '--full', '--head', '--canvas', '--keypoints', '--person', '--wrist-snap', '--grid-rule', '--cloth', '--write-config', '--from'], switches: ['--head-box', '--no-back-hair'] },
+  propose: { valued: ['--parts', '--source', '--out', '--from-config', '--compare', '--full', '--head', '--canvas', '--keypoints', '--person', '--wrist-snap', '--grid-rule', '--cloth', '--write-config', '--from'], switches: ['--head-box', '--no-back-hair', '--only-missing'] },
   compare: { valued: ['--left', '--right', '--map'], switches: [] },
   check: { valued: ['--rig', '--out', '--parts', '--source', '--page-edges', '--pack-shape', '--requirements', '--set', '--environment'], switches: ['--seam-pairs', '--keep-stills', '--all-sets'] },
   loop: { valued: ['--frames', '--out'], switches: ['--palette'] },
@@ -1306,12 +1332,18 @@ function cmdPropose(args: string[]): number {
   const flags = new Map<string, string>();
   let headBox = false;
   let noBackHair = false;
+  let onlyMissing = false;
   for (let i = 0; i < args.length; i++) {
     const flag = args[i];
     if (flag === '--head-box') {
       headBox = true;
       continue;
     }
+    if (flag === '--only-missing') {
+      if (onlyMissing) return usage('--only-missing is given twice');
+      onlyMissing = true;
+      continue;
+    }
     if (flag === '--no-back-hair') {
       if (noBackHair) return usage('--no-back-hair is given twice');
       noBackHair = true;
@@ -1324,6 +1356,16 @@ function cmdPropose(args: string[]): number {
     flags.set(flag, value);
     i++;
   }
+  // 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.
+  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('--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`);
+  }
   let staged: StagedConfigWrite | null = null;
   try {
     if (headBox) {
@@ -1480,7 +1522,7 @@ function cmdPropose(args: string[]): number {
     })();
     const bfile = basisFile(P, prop, basis, cfg === null || cmpPath === undefined ? null : { where: cmpPath, config: cfg });
     const img = drawLandmarks(P, painting, prop.bones, 'PROPOSAL - CORRECT ME');
-    if (target !== null) staged = stageConfigWrite(target, { kind: 'proposal', proposal: prop, sections: PROPOSAL_CONFIG_SECTIONS });
+    if (target !== null) staged = stageConfigWrite(target, onlyMissing ? { kind: 'proposal-missing', proposal: prop, parts: P.recs } : { kind: 'proposal', proposal: prop, sections: PROPOSAL_CONFIG_SECTIONS });
     else if (written !== null) staged = stageConfigWrite({ kind: 'fresh', path: written.at, text: written.text });
     mkdirSync(render, { recursive: true });
     writeFileSync(join(out, 'proposal.json'), serializeProposal(prop));

package/docs/AUTHORING.md

@@ -2888,9 +2888,10 @@ valued destination path. Its modes have different ownership:
 | `propose --head-box` | existing regular config | `seethrough.head_box` |
 | `assemble --propose-plan` | existing regular config; must name `--config` itself | `assemble.plan`, `assemble.extend_below_crop` |
 | ordinary `propose --parts` without `--cloth` | existing regular config | each present `PROPOSAL_CONFIG_SECTIONS` value: `bones`, `meshes`, `regions`, `limbs`, `motion`, `constraints`, `turn`, `proposed_rig_scale` |
+| ordinary `propose --parts … --only-missing` (issue #671) | existing regular config | only `meshes.<part>` or `regions.<part>`, as the proposal drafts it, for each proposed part the config attaches by neither, and an `assemble.plan` row for such a part from `full:drape-<s>` / `full:hand-<s>` the plan does not name (the drape just before the full run's `handwear-<s>` row, the hand just after it); added row by row and entry by entry, every existing row and entry and every other byte as read |
 | `propose --cloth <input.json>` | new file | the recipe's edits spliced into the cloth config; §3, *The config written*, gives entry ownership, hand-edit conflicts and `--from <previous.json>` |
 
-For the first three modes, each selected field replaces its whole value; other
+For the first three modes (not `--only-missing`), each selected field replaces its whole value; other
 fields and optional proposal sections not emitted are retained. Changed whole
 values are spliced into the original text through `splicedEdits`, preserving
 untouched bytes. `notes` stays in the proposal. The stage's loader validates a same-directory candidate before
@@ -2903,6 +2904,13 @@ of the proposing command. A refusal leaves the target config unchanged. The
 writer lists changes on stderr, keeping the existing head-box and plan JSON on
 stdout. Without the flag, no config is changed. `--from-config` proposes nothing
 and refuses this flag; `--from` belongs to the cloth mode only.
+`--only-missing` (issue #671) is the upgrade path for a config proposed before a stage
+made a part it never named — the 1.37.0 arm split's `drape_<s>` and `hand_<s>`
+([MIGRATION](MIGRATION.md#after-1370-merged-arm-layers-are-split-issue-490)): the same
+loader validates the candidate, so an added region on a bone the config does not
+declare is refused naming the part and the bone (`CONFIG_NAME_RESOLVES`); 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
@@ -3591,7 +3599,7 @@ says why each requirement exists and what breaks without it.
 
 | rule | means | change |
 | --- | --- | --- |
-| <a id="RIG_PART_PRESENT"></a><a id="RIG_PART_ATTACHED"></a>`RIG_PART_PRESENT`, `RIG_PART_ATTACHED` | a `meshes`/`regions` key that is not in `parts.json`, a part with neither, or a `painting:` part with a mesh | the config and the plan must name the same parts; a patch is a region |
+| <a id="RIG_PART_PRESENT"></a><a id="RIG_PART_ATTACHED"></a>`RIG_PART_PRESENT`, `RIG_PART_ATTACHED` | a `meshes`/`regions` key that is not in `parts.json`, a part with neither, or a `painting:` part with a mesh | the config and the plan must name the same parts; a patch is a region. A `drape_<s>` or `hand_<s>` from `full:drape-<s>` / `full:hand-<s>` is the 1.37.0 arm split's (issue #490), new to a config proposed before it: the detail names [MIGRATION](MIGRATION.md#after-1370-merged-arm-layers-are-split-issue-490), whose remedy is `propose … --write-config <config> --only-missing` (the two plan rows and the two entries) |
 | <a id="RIG_PNG_PRESENT"></a><a id="RIG_PNG_MATCHES_BOX"></a><a id="RIG_PART_HAS_ART"></a>`RIG_PNG_PRESENT`, `RIG_PNG_MATCHES_BOX`, `RIG_PART_HAS_ART` | a part's PNG is missing, the wrong size, or has no art pixel | re-run assemble |
 | <a id="RIG_NAME_RESOLVES"></a><a id="RIG_SEGMENT_DEFINED"></a><a id="RIG_CHAIN_POINTS"></a>`RIG_NAME_RESOLVES`, `RIG_SEGMENT_DEFINED`, `RIG_CHAIN_POINTS` | a segment names an undeclared bone, a bone with no `tip` and no next link, or a chain too short to make a link | that bone's `tip`, or write the segment out as `[bone, [x0,y0], [x1,y1]]` |
 | <a id="RIG_INFLUENCES_KEPT"></a>`RIG_INFLUENCES_KEPT` | a mesh's declared `influences` leaves a vertex with no bone: every capped share is under 0.03 (at or under it, for the continuous floor). The largest of k shares is at least 1/k, so this needs 34 or more kept bones; the default cap of 4 never reaches it (issue #284). The detail names the first vertex, how many more, and its largest share | declare `maxInfluences` 33 or less, or name fewer bones in `segments` |
@@ -3888,7 +3896,7 @@ measured). `build --loop` encodes a product and takes none. One line,
 `environment: <path>, rigc-environment/1, <n> step(s), sha256 <16 hex>`, says which
 schedule, and `check.json` carries `environment` — `path` as the command line gave it,
 the `sha256` of the bytes read, `steps` — after `pack_mode`; without the flag neither
-is written and no render argument moves.
+is written; the physics seam reference worlds below are separate probes.
 
 The world before the first step is the runtime's, so a still schedule is the one that
 states it: `{ "t": 0, "wind": [1, 0], "gravity": [0, 1] }` reads what a run without the
@@ -3900,6 +3908,8 @@ wind (1, 0), then (40, 0) from 0.5 s, reads `TEXTURE_STRETCH` 32.181 (FAIL, `hai
 triangle 258), two meshes folding under `ANIMATIONS_DO_NOT_FOLD` (FAIL; none without the
 flag) and 8 `CLOTH_SETTLES` warnings for 9 (selftest `CK515`).
 
+**Physics seam environments** (issue #591). Default: wind [1, 0], gravity [0, 1]. Still: wind [0, 0], gravity [0, 1]. In rig-play, environment(null) returns to Default; still air requires an explicit wind [0, 0]. For a physics rig with readable declared pairs and animations, SEAM_OVER_MOTION adds optional `worlds.default` and `worlds.still` readings. They are informational raw gap/ghost cell counts (including cells below the warning floor), never new bars or warnings; neither changes PASS, exit status or the bar count. Each world records its vectors, status and rows; each row names its pair, animation, drawn/banded frames and gap/ghost maximum and worst frame, cell size and world box. Per-frame hits are not embedded in check.json. A rendered world's `dir` is relative to check.json (`seam_motion/default` or `seam_motion/still`): it retains the complete rigc render, including frames.json, frame images and each animation's seam.json with all raw hits. The directories are published with check.json only after the readings are validated; scratch is removed, and an unrendered SKIP has no directory reference. The original reading and any custom `--environment` schedule keep their existing meaning; the two reference worlds are independent of that schedule. A rig with no wind response reports Still as SKIP with its reason; no band is SKIP, never a measured zero. With no readable declared pair or animation no worlds block is written. Only existing declared pairs are read: neighbouring limb segments and explicit seam requirements; thigh/hem pairs are not inferred. Nonphysics output stays byte-identical, with no extra key, line or render. Reference renders start physics at frame 0 at 12 fps; they do not certify a composed player scene or another sampling rate. Malformed sidecars or renderer failures remain named refusals.
+
 ### compose
 
 Every refusal below is collected with the others and printed at once, under
@@ -4748,7 +4758,7 @@ is built (`CK83`–`CK85`, `RQ30`–`RQ35`).
 
 | step | reference-sample | reference-demo | source |
 | --- | --- | --- | --- |
-| painting (GPU) | 20.2 s | 18.3 s | `generation.json` `elapsed_s`, in [parts-examples](https://github.com/rig-c/parts-examples) |
+| painting (GPU) | 20.2 s | 18.3 s | `generation.json` `elapsed_s`, in [rig-c/examples](https://github.com/rig-c/examples) |
 | See-through full run (GPU) | 194.9 s | 198.5 s | `inputs/layers/full/meta.json` `elapsed_s` |
 | See-through head run (GPU) | 170.9 s | 171.4 s | `inputs/layers/head/meta.json` `elapsed_s` |
 | `build` (CPU, user + sys) | 14.6 s | 30.7 s | measured with `/usr/bin/time -p` on an Apple M4 machine under other load, rigc's child processes included; wall clock 12.7 s and 27.5 s |

package/docs/MIGRATION.md

@@ -342,6 +342,76 @@ What to do: nothing. A warning names the pair, the animation, the frames and the
 an opening that is not intended wants a cap that covers the turn, or a motion that bends
 less.
 
+## After 1.37.0: merged arm layers are split (issue #490)
+
+Issue #490 splits a full-run `handwear-<s>` layer that See-through merged — the sleeve,
+the bare hand at `<s>_wrist`, and an overgarment drape reaching more than a forearm's
+length below the wrist, the drape's colour at least 80 off the sleeve's — into
+`drape-<s>`, `handwear-<s>` and `hand-<s>`, whenever the config carries
+`generation.control.skeleton` (the wrist and the forearm are read off it). `assemble`
+rewrites a plan's lone `full` `handwear-<s>` row into three: `drape_<s>` behind, the
+row's own part (the sleeve, which keeps `handwear-<s>`), and `hand_<s>` in front.
+
+Who is affected: a config proposed before 1.37.0 whose plan takes `handwear-<s>` from
+the full run and that carries `generation.control.skeleton` — and only where that layer
+is a merged arm run; a config whose arm layer holds the sleeve alone builds as before.
+Its `meshes` and `regions` never named the two new parts, so `rig` refuses each by name
+(issue #671):
+
+```
+RIG_PART_ATTACHED: part "drape_r" — is in parts.json and has neither a config.meshes nor a config.regions entry; exactly one is required — the full run's merged arm layer was split into this part (issue #490, from 1.37.0), …
+```
+
+| change | before | after |
+| --- | --- | --- |
+| `assemble.plan` as `assemble` reads it, a lone `["<name>", "full", "handwear-<s>"]` row over a merged arm run | the row | `["drape_<s>", "full", "drape-<s>"]`, the row, `["hand_<s>", "full", "hand-<s>"]` |
+| `parts.json` | one part holding sleeve, hand and drape | `drape_<s>` (`full:drape-<s>`), the sleeve part (`full:handwear-<s>`), `hand_<s>` (`full:hand-<s>`) |
+| `rig` on a config without entries for them | — | `RIG_PART_ATTACHED` for each, the detail naming this entry and `--only-missing` |
+| `propose … --write-config <config> --only-missing` | — | new (issue #671): adds only the plan rows and entries the config lacks for them |
+
+What to do, keeping every entry you tuned — one command, after `assemble` has written
+the split parts:
+
+```
+rig-parts propose --parts <work/rig> --source <painting> --out <dir> --write-config config.json --only-missing
+```
+
+For each part the config attaches by neither `meshes` nor `regions`, it adds what is
+missing and nothing else (issue #671):
+
+- a part from `full:drape-<s>` or `full:hand-<s>` that `assemble.plan` does not name gains
+  its plan row where `assemble` rewrites it: `["drape_<s>", "full", "drape-<s>"]` just
+  before the row that takes `handwear-<s>` from the full run, `["hand_<s>", "full",
+  "hand-<s>"]` just after it. `assemble` then takes the plan as written and makes the
+  same `parts.json` byte for byte. The config loader reads `meshes` and `regions` against
+  the parts the plan makes, so the entries need the rows;
+- the part gains `meshes.<part>` or `regions.<part>` as the proposal drafts it.
+
+Every existing plan row, every existing entry, every other section and every other byte
+stays as read, each addition is spliced in alone, and stderr names each row and entry
+added. The full loader reads the result before it replaces the file: an entry on a bone
+your config does not declare is refused naming the part and the bone, and nothing is
+written. A second run with nothing missing changes no byte.
+
+Or by hand, the same four additions: the two plan rows above, and a region for each part.
+`propose` drafts both as regions: `hand_<s>` on the tip link of `sleeve_<s>` where it
+drafts a sleeve chain (a handwear part over 500 px, or the arm drafted from
+`--keypoints`; its note reads `hand_<s> (full:hand-<s>): split hand -> region on
+sleeve_<s>2, the tip link of sleeve_<s>` for a three-link chain); otherwise `hand_<s>`,
+like `drape_<s>` always, rides the trunk bone by its box's centre height — `head` above
+the neck line, `chest` above the hip, else `hip` (its note reads `drape_<s>
+(full:drape-<s>): no rule -> region on hip`). Confirm against the notes `propose` prints
+for your parts; the bone must be one your config declares.
+
+**An alternate set made before 1.37.0** that covers the split sleeve (a set over the part
+that takes `handwear-<s>`) still covers only that part. The split made `hand_<s>` and
+`drape_<s>` parts of their own, so while the set is active the base draws them beside the
+set's own sleeve art, which still holds the hand it was painted with. `check --set` then
+fails the set's seam (`CHECK_SEAM_WITHIN_BAR`, issue #671); its detail names the parts and
+this entry. What to do: add them to the set's `hides`, for example `"hides": ["hand_r",
+"drape_r"]`, or only `hand_<s>` if the set's painting still shows the base drape. This is
+a judgement on the set's own art, so `--only-missing` does not write it.
+
 ## After 1.38.0: cloth that comes to rest on the idle
 
 Issue #501 reads every physics chain by its tip on the idle `check` renders (physics on,

package/docs/PAINTING.md

@@ -140,7 +140,7 @@ one way that passes `painting`: the `generation` block and the pose file of seed
 and chosen to be the next public example — a character for a wind demo, where hair
 and cloth move by physics under a side gust. It is the public example `wind`: its
 painting, See-through layers and generation record are in
-[parts-examples](https://github.com/rig-c/parts-examples) (`wind/`), and its config,
+[rig-c/examples](https://github.com/rig-c/examples) (`wind/`), and its config,
 proposal and build are [`examples/wind`](../examples/wind/README.md). The block:
 
 ```json
@@ -350,4 +350,4 @@ To paint one without the character drifting, repaint only the limb:
 
 `comfy paint` does not run an inpainting graph; the demo's hand-detailer pass is
 the same idea at hand scale (a masked repaint on the same checkpoint, recorded
-beside its painting in parts-examples).
+beside its painting in rig-c/examples).

package/docs/STABILITY.md

@@ -56,7 +56,7 @@ defaults are the help's too, and none is guessed from the art.
 | `comfy` | `seethrough`: `--image`, `--out`; optional `--resolution`, `--steps`, `--seed`, `--prefix`, `--offload`, `--lama`, `--nf4`, `--host`, `--wait`, `--timeout`, `--poll` |
 | `assemble` | `--propose-plan` with `--source`, `--full`, `--config`, optional `--head`, `--write-config` (must name `--config` itself, issue #356); or `--source`, `--full`, `--config`, `--out`, optional `--head` (without it, one run: issue #359), `--seam` (near-white, silhouette), `--project` (core, visible), `--alt` (repeatable `<name>=<source>:<full>[:<head>]`, issue #454) |
 | `propose` | `--head-box` with `--full`, `--canvas`; optional `--no-back-hair`, `--write-config` (existing config, issue #356) |
-| `propose` | `--parts`, `--source`, `--out`; optional `--compare` or `--from-config` (one of them), `--keypoints`, `--person` and `--wrist-snap` (each with `--keypoints`), `--full`, `--head` (the turn control's depths; not with `--from-config`), `--grid-rule` (`figure` or `part`, the drafted lattice's spacing; not with `--from-config`), `--cloth` (a config whose `cloth` block is the recipe, issue #364; not with `--from-config`), `--write-config` (existing config for an ordinary proposal, issue #356; a new file with `--cloth`, issue #537; not with `--from-config` — additive: without it nothing `propose` writes changes), `--from` (the config the recipe is changed from, only with `--write-config`, issue #571 — additive: without it nothing `--write-config` writes changes) |
+| `propose` | `--parts`, `--source`, `--out`; optional `--compare` or `--from-config` (one of them), `--keypoints`, `--person` and `--wrist-snap` (each with `--keypoints`), `--full`, `--head` (the turn control's depths; not with `--from-config`), `--grid-rule` (`figure` or `part`, the drafted lattice's spacing; not with `--from-config`), `--cloth` (a config whose `cloth` block is the recipe, issue #364; not with `--from-config`), `--write-config` (existing config for an ordinary proposal, issue #356; a new file with `--cloth`, issue #537; not with `--from-config` — additive: without it nothing `propose` writes changes), `--from` (the config the recipe is changed from, only with `--write-config`, issue #571 — additive: without it nothing `--write-config` writes changes), `--only-missing` (only with `--parts` and `--write-config`, not with `--cloth` or `--from-config`, issue #671 — additive: without it nothing `--write-config` writes changes) |
 | `compare` | `--left`, `--right`; optional `--map` |
 | `rig` | `--config`, `--parts`, `--out`; optional `--idle-keys` (ctl, direct), `--page-edges` (pot, free), `--pack-shape` (rect, polygon) |
 | `check` | `--rig`, `--out`; optional `--parts`, `--source`, `--page-edges`, `--pack-shape`, `--requirements`, `--seam-pairs`, `--keep-stills`, `--set` or `--all-sets` (issue #454), `--environment` (issue #538, additive) |
@@ -200,12 +200,12 @@ every number) are AUTHORING §3's tables, and the loader refuses any other by na
 | `parts.json`, `parts/<name>.png` | `assemble`, `build` | one record per part: `from` (`<run>:<tag>` with a See-through v3 tag, `<run>:author:<label>` for a layer the author made — issue #256, read by no role rule — or `painting:<name>` for a patch), `cut_from` on a cut's piece only (the plan part it was cut from, issue #230), `limb` on a limb segment's part only (issue #349: `name`, `segment`, `of`, `bone`, and below a joint `joint`, `range` when the config segment declares one (issue #360), and `cap` — `at`, `width`, `radius`, `box`, `layer_px`, `image_px` with a cap image, `image_layer` after it when that image was a hidden-art layer — issue #359, `<run>:<layer>:hidden` — `missing_px`, `short_px` (`left`, `right`) after it only when `missing_px` is above 0 (issue #557, additive), `excluded_px` after them only on a subset set's limb part whose cap the set exclusion took a pixel of (issue #603, additive: each pixel taken out of the count it was in, so the cap's counts are the written PNG's), then `shape` and `upper_px` under the segment's `cap_shape` — `upper_px` without the shape only when the upper segment gave a pixel (issue #557, additive) — and after them `lower_px`, `lower_kept_px` and `lower_missing_px` under `cap_shape: "ball"` (issue #579, additive), and `edge`, `feather_radius` and `feathered_px` under its `edge`, and `cut_band`, `cut_offset`, `cut_at`, `cut_crossed`, `joint_crossed`, `band_px` and `stroke_luma_max` (when the band has a split) under its `cut_band`, issue #360), the box `x`, `y`, `w`, `h` (rig px), the pixel counts `src/parts.ts` documents (`opaque_px`, `visible_px`, `occluded_px`, `projected_core_px`, `source_px_taken`, `visible_not_projected_px`, `refused_drift_px`, `merged_px` — on a subset set's limb part counted after the set exclusion, issue #603 — `seam_override_px`, and `fringe_pushed_back` when not empty); `rig_size`, `scale_rig_per_source`, `ghost_px`, `recomposite`, and `scene` (`figure_alpha_above`, `figure_px`, `figure_mask`) under `config.scene` only, with the figure's mask `figure_rig.png` beside the recomposite (issue #242); `single_run_pad` (`file_size`, `side`, `left`, `top`) last, only for one run whose file is not the `seethrough.resolution` square (issue #366) |
 | `rig/rig.json`, `rig/motion.json`, `rig/images/` | `rig`, `build`, `compose` | rig-c's rig spec and motion spec, `spec` `rigc-rig/1` and `rigc-motion/1`: the format is rig-c's, and this package writes only what rig-c's parser accepts; a bone carries `inherit` only where config.bones declares one, rig-c's mode name as written (issue #348) |
 | `rig/mesh_report.json` | `rig`, `build` | one row per mesh: `part`, `vertices`, `triangles`, `hull`, `bones` (the sorted names the attachment's weights bind in the written `rig.json`, in every mode — since 1.49.1 (issue #536) a rig with `turn` or `stops` names the twins and `<link>_d` bones there, where the row named the segment bones they replace: a fix of a wrong name, not a format change; a rig with neither writes the bytes it wrote), `max_influences`, `mean_influences`, `art_coverage`, then `grid` (a lattice); `mode` "contour" with `params`, `contour`, `regions` (`params.maxEdge` and `contour.outlineCut` only when the mesh declares `contour.maxEdge`; `params.bridges` and `contour.bridges` — `islands`, `units`, `joins`, and `faint` only when an island was left out as faint — only when it declares `contour.bridges`); or `mode` "influence" with `influence` (as declared), `reach` (`farthest`, `at`, `nearest`, `capped`, `widest`) and `lattice` (rig-c's `SegmentsLatticeReport`: `cols`, `rows`, `artCells`, `keptCells`, `passes`, `islands`) (issue #378); or `mode` "auto" with `settings`, `source`, `result`, `residuals`, `worst_residual`, `worst_region`, `motion_amplitude`, `termination`, `weights`, `regions`, `deformation`, `quality_report` (rig-c's `mesh-quality-report/1` document whole), `motion_report`, and, only when they apply, `stray_cleared` (after `source`, when `source.stray` is declared), `skinning_residual` and `replay` (`AutoMeshReport` in `src/rig.ts`); in every mode, `exponent` when the mesh declares one (after `grid`, or after `mode`); `influences`, as declared, when a lattice or contour mesh declares it (after `exponent`, or where `exponent` would be); `stray` and `stray_cleared` when a lattice mesh declares `stray` (after `influences`, or where `influences` would be); `ribs` when a contour or auto mesh declares them (after `exponent`, or after `mode`), and then `contour.ribs` (`source.contour.ribs` in the automatic mode) |
-| `check/check.json` and the rest of `check/` | `check`, `build`, `compose` | the reference's fields in its order (`gate_spine_html_green`, `rigc_entry`, `pack_mode`, `environment` after it under `--environment` only (issue #538, additive: `path` as given, `sha256`, `steps`), `loop_max_diff`, the seam figures — `seam_mean`, `seam_px_over_40`, `seam_px_over_80` and, from issue #216, `seam_frame_scale`, the frame scale the bar divides the count by), `loop_physics` after `loop_max_diff` when the rig declares a physics constraint, `seam_border` after the seam figures when `parts.json` declares a scene (issue #242), `seam_pairs` after the seam figures when the seam bar fails or `--seam-pairs` asks (each row's picture under `check/seam/`; `--keep-stills` leaves the setup-pose still and its `frames.json` under `check/setup_still/`), then the judgement lines (`BREATH_VISIBLE`, `BLINK_NO_HOLE`, `CHAIN_LAG`, `TIP_OVER_ROOT`, `STILL_REGIONS_DARK`, `TEXTURE_STRETCH`), `ANIMATIONS_DO_NOT_FOLD` after them when `motion.json` holds an animation, the idle included — on every rig with an idle since issue #333 (issues #320, #363: `status`, `animations`, `fps`, `physics_left_out`, `folding` — each `animation`, `slot`, `attachment`, `frames`, `worst_frame`, `worst_triangles`, `triangles`, `physics_on`, `physics_off`, `physics_constraints`, `declared`, `line` — `folding_undeclared`, `declared_not_folding`, `bar`), `FEET_STAY_LEVEL` after it when a `footwear` part rides a bone that hangs from another and `motion.json` holds an animation (issue #348: `status`, `reason` on a SKIP only, `animations`, `fps`, `physics_left_out`, `bar_degrees`, `bar`, `feet` — each `part`, `bone`, `hangs_from`, `status`, `frames_posed`, `worst`), `LIMB_ONE_BONE` after it (and after `STRESS_OFF_CHAIN` where that is written) when `parts.json` holds a limb segment's part (issue #349: `status`, `parts` — each `part`, `limb`, `bone`, `status`, `others`), `SEAM_OVER_RANGE` after it when a limb record carries a `range` (issue #360: `status`, `frame_scale`, `physics_left_out`, `bar` — `mean`, `rig_px_over_40`, `level` — and `joints`, each `part`, `limb`, `segment`, `joint`, `bone`, `range`, `at`, `radius`, `under_px`, `status`, `poses` — each `degrees`, `status`, `mean`, `px_over_40`, `px_over_80`, `rig_px_over_40`, and `step_px` (`left`, `right`) only on a joint whose cap record carries `short_px` (issue #557, additive) — and `unread` on a joint not read), `SEAM_OVER_MOTION` after it when `parts.json` holds a limb segment or `--requirements` a `seam` (issue #493, a warning and not a bar: `status` — `WARN`, `CLEAR` or `SKIP` — `reason` on a SKIP only, `fps`, `floor`, `pairs` — each `pair`, `a`, `b`, `declared`, and `unread` on a pair not read — `animations`, `warnings`, `rows` — each `pair`, `animation`, `status`, `drawn`, `banded`, `opens`, `px`, `max_px`, `under_floor`), `CLOTH_SETTLES` after it when the rig declares a physics constraint and has an idle (issue #501, a warning and not a bar: `status` — `WARN` or `CLEAR` — `fps`, `frames`, `duration`, `floor_rig_px_per_s`, `floor`, `levers`, `warnings`, `rows` — each `tip`, `root`, `links`, `point`, `settles_at`, `max_rig_px_per_s`, `min_rig_px_per_s`), `RECOMPOSITE_HOLES` (its first figure `declared_scene` when `parts.json` declares a scene), `SETUP_POSE_VS_SOURCE`, `skipped`, `config` under `build` only (issue #607, additive: `path` as `--config` was typed, `sha256` of the bytes the build read; `check` and `compose` read no config and write none), a `requirements` block under `--requirements` (or `build`'s `config.requirements`) — `file` first from issue #556, additive: `path` as typed or declared, `sha256`, `keys` — and `PASS`; `check/build/skeleton.json`, `.atlas` and `.png` are the packed artifact rig-c writes |
+| `check/check.json` and the rest of `check/` | `check`, `build`, `compose` | the reference's fields in its order (`gate_spine_html_green`, `rigc_entry`, `pack_mode`, `environment` after it under `--environment` only (issue #538, additive: `path` as given, `sha256`, `steps`), `loop_max_diff`, the seam figures — `seam_mean`, `seam_px_over_40`, `seam_px_over_80` and, from issue #216, `seam_frame_scale`, the frame scale the bar divides the count by), `loop_physics` after `loop_max_diff` when the rig declares a physics constraint, `seam_border` after the seam figures when `parts.json` declares a scene (issue #242), `seam_pairs` after the seam figures when the seam bar fails or `--seam-pairs` asks (each row's picture under `check/seam/`; `--keep-stills` leaves the setup-pose still and its `frames.json` under `check/setup_still/`), then the judgement lines (`BREATH_VISIBLE`, `BLINK_NO_HOLE`, `CHAIN_LAG`, `TIP_OVER_ROOT`, `STILL_REGIONS_DARK`, `TEXTURE_STRETCH`), `ANIMATIONS_DO_NOT_FOLD` after them when `motion.json` holds an animation, the idle included — on every rig with an idle since issue #333 (issues #320, #363: `status`, `animations`, `fps`, `physics_left_out`, `folding` — each `animation`, `slot`, `attachment`, `frames`, `worst_frame`, `worst_triangles`, `triangles`, `physics_on`, `physics_off`, `physics_constraints`, `declared`, `line` — `folding_undeclared`, `declared_not_folding`, `bar`), `FEET_STAY_LEVEL` after it when a `footwear` part rides a bone that hangs from another and `motion.json` holds an animation (issue #348: `status`, `reason` on a SKIP only, `animations`, `fps`, `physics_left_out`, `bar_degrees`, `bar`, `feet` — each `part`, `bone`, `hangs_from`, `status`, `frames_posed`, `worst`), `LIMB_ONE_BONE` after it (and after `STRESS_OFF_CHAIN` where that is written) when `parts.json` holds a limb segment's part (issue #349: `status`, `parts` — each `part`, `limb`, `bone`, `status`, `others`), `SEAM_OVER_RANGE` after it when a limb record carries a `range` (issue #360: `status`, `frame_scale`, `physics_left_out`, `bar` — `mean`, `rig_px_over_40`, `level` — and `joints`, each `part`, `limb`, `segment`, `joint`, `bone`, `range`, `at`, `radius`, `under_px`, `status`, `poses` — each `degrees`, `status`, `mean`, `px_over_40`, `px_over_80`, `rig_px_over_40`, and `step_px` (`left`, `right`) only on a joint whose cap record carries `short_px` (issue #557, additive) — and `unread` on a joint not read), `SEAM_OVER_MOTION` after it when `parts.json` holds a limb segment or `--requirements` a `seam` (issue #493, a warning and not a bar: `status` — `WARN`, `CLEAR` or `SKIP` — `reason` on a SKIP only, `fps`, `floor`, `pairs` — each `pair`, `a`, `b`, `declared`, and `unread` on a pair not read — `animations`, `warnings`, `rows` — each `pair`, `animation`, `status`, `drawn`, `banded`, `opens`, `px`, `max_px`, `under_floor`; issue #591 adds optional `worlds` on physics rigs with readable declared pairs and animations: `default` and `still`, each `wind`, `gravity`, `status` (`REPORTED` or `SKIP`), `reason` on SKIP, `dir` only when rendered (relative to check.json: `seam_motion/default` or `seam_motion/still`, the complete retained render with frames.json and each animation's raw seam.json), and `rows` — pair, animation, status, drawn, banded, `gap` and `ghost`, each `max_px` and `worst` only; worst carries `index`, `px`, `cell`, `box`. Per-frame hits stay in the raw sidecars. These raw reference readings add no bar or warning and leave the custom environment reading unchanged), `CLOTH_SETTLES` after it when the rig declares a physics constraint and has an idle (issue #501, a warning and not a bar: `status` — `WARN` or `CLEAR` — `fps`, `frames`, `duration`, `floor_rig_px_per_s`, `floor`, `levers`, `warnings`, `rows` — each `tip`, `root`, `links`, `point`, `settles_at`, `max_rig_px_per_s`, `min_rig_px_per_s`), `RECOMPOSITE_HOLES` (its first figure `declared_scene` when `parts.json` declares a scene), `SETUP_POSE_VS_SOURCE`, `skipped`, `config` under `build` only (issue #607, additive: `path` as `--config` was typed, `sha256` of the bytes the build read; `check` and `compose` read no config and write none), a `requirements` block under `--requirements` (or `build`'s `config.requirements`) — `file` first from issue #556, additive: `path` as typed or declared, `sha256`, `keys` — and `PASS`; `check/build/skeleton.json`, `.atlas` and `.png` are the packed artifact rig-c writes |
 | `layers.json`, `<index>_<name>.png` | `layers --export` | the wrapper form `layers` reads (issue #359): `width`, `height`, then `layers` — each `name`, `filename`, `left`, `top`, `right`, `bottom`, `depth_median` (the input's own; `null` for a PSD, the manifest's order then being the draw order) — drawn layers in draw order, then the hidden-art layers; a PNG's name is its index and its layer's name, and the manifest, not the file name, says which layer it is |
 | the template `.psd` | `layers --template` | one empty layer per name `templateLayerNames` (`src/layers.ts`) holds, bottom first; the same canvas writes the same bytes |
 | `proposal.json`, `render/landmarks*.png` | `propose` | the config's four rig sections, `constraints` with `--cloth` (issue #364: a physics constraint per tree link named `<bone>_physics`, a dangling end's `<bone>_translate`, and a skirt swing's transforms `<swing>_<tree>`), `turn` with `--full`/`--head`, `proposed_rig_scale` (issue #354), and `notes` |
 | `basis.json` | `propose` | spec `spine-parts-basis/1` |
-| an existing config named by `--write-config` | `propose --head-box`, `assemble --propose-plan`, ordinary `propose` | issue #356, additive: `assemble --propose-plan` must update `--config` itself; only the selected proposed fields are replaced by whole-value text splices, preserving untouched bytes; absent optional proposal sections and other fields remain; the stage loader validates before atomic replacement, relative paths keep their base, an unchanged update preserves bytes and mtime, and stderr lists changes; no multi-artifact transaction is promised |
+| an existing config named by `--write-config` | `propose --head-box`, `assemble --propose-plan`, ordinary `propose` | issue #356, additive: `assemble --propose-plan` must update `--config` itself; only the selected proposed fields are replaced by whole-value text splices, preserving untouched bytes; absent optional proposal sections and other fields remain; the stage loader validates before atomic replacement, relative paths keep their base, an unchanged update preserves bytes and mtime, and stderr lists changes; no multi-artifact transaction is promised; with `--only-missing` (issue #671) only a `meshes.<part>` or `regions.<part>` entry for a proposed part the config attaches by neither is added, and an `assemble.plan` row for such a part the 1.37.0 arm split makes that the plan does not name, every existing row and entry and every other byte as read |
 | a new `--write-config` file | `propose --cloth … --write-config` | complete checked splice text published without overwrite; an intervening creator is refused, while cleanup failure after publication may leave the complete new file present; intentional partial configs retain their existing contract; the `--cloth` config read, byte for byte, but for the entries the recipe drafts (issue #537), measured against the same parts drafted without it: `meshes.<part>` and `regions.<part>` for each part the recipe moves, and `bones`, `constraints` and `motion.tracks` entry by entry by name (issue #552) — an entry the recipe drafts replaced or inserted, one it replaces removed, every other entry kept with its bytes and its place, and a hand edit to an entry the recipe owns refused by name (`PROPOSE_WRITE_CONFIG_CONFLICT`) rather than dropped; a section the input lacks is inserted; with `--from <previous config>` (issue #571) an entry equal to the previous recipe's draft is the recipe's as well |
 | `config.json`, `mesh_draft.json` | `mesh-draft` | `config.json` is the config read, byte for byte, but for each drafted part's `meshes` entry; `mesh_draft.json` is spec `rig-parts-mesh-draft/1`: `rules`, `lattice_check`, `draft_check`, `figure_overdraw`, and per lattice part `part`, `mode`, `lattice`, `candidate` (with `bridges` — `units`, `joins` of `span` and `area_px2`, `area_px2`, `overdraw`, and `faint` only when an island was left out as faint — only when the candidate is a bridged one, issue #326), `delta` (under `--more-triangles` only), `readings`, `gate` (each line's `reading`, `pass`, `text`, `margin`), `note`; and `not_compared` (issue #307), only when the config holds an `auto` or `contour` entry: per such entry, in config order, `part`, `mode` and `note` — the part was neither drafted nor compared, and a config of lattices alone writes no such key |
 | `rig.json`, `motion.json`, `mesh_report.json`, `images/`, `remesh.json` | `remesh` | the input revision's files, `rig.json` and `mesh_report.json` with the part's attachment and row replaced (under `--delta` the row is the input's with its counts, `bones` and influences recomputed and `mode` "delta"), every other file byte for byte; `remesh.json` is spec `rig-parts-remesh/1`: `request` (`part`, `mesh`, `mesh_sha256`, `idle_keys`, `page_edges`, `pack_shape`; under `--delta`, issue #526: `part`, `delta` — the mesh edit as read — `delta_sha256`, `ops`, `applied` — `moved`, `added`, `removed`, `constrained` — `idle_keys`, `page_edges`, `pack_shape`), `versions` (`parts`, `rigc`), `input` (`rig` — `path`, `bytes`, `sha256` per file — `config_sha256`, `parts_json_sha256`), `baseline` (`reproduced`, `not_compared`; under `--delta` `reproduced` holds one sentence: no config is built, the input is the baseline), `target` (`before`, `after`: `vertices`, `triangles`, `hull`), `preserved` (`identical`, `spliced`), `revision` (per file as `input.rig`), `check` (`input`, `revision`: `pass`, `measured`, `not_met`, `skipped`, `physics`, then `line` and `status` — issue #541, additive, the spec stays `rig-parts-remesh/1`: `line` is the last line `check` prints on that tree, byte for byte, and `status` every block's status as that tree's `check.json` records it, by name in the file's order — `gate`, `loop` and `seam` read from their figures, every other block its own `status`, a block the file does not write absent; `scope`) |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rig-parts",
-  "version": "1.59.0",
+  "version": "1.60.1",
   "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/src/build.ts

@@ -1719,7 +1719,7 @@ export function sweepCheckLines(line: SweepLine, steps: ReadonlyMap<string, { le
  * read nothing of (its SKIP) or the line could not read. A SKIP with nothing declared prints its reason alone.
  */
 export function motionSeamLines(line: MotionSeamLine, plant: MotionSeamPlant = {}): string[] {
-  if (line.status === 'SKIP' && line.rows.length === 0 && line.pairs.every((p) => p.unread === undefined)) return [`${MOTION_SEAM_LINE}: SKIP — ${String(line.reason)}`];
+  if (line.worlds === undefined && line.status === 'SKIP' && line.rows.length === 0 && line.pairs.every((p) => p.unread === undefined)) return [`${MOTION_SEAM_LINE}: SKIP — ${String(line.reason)}`];
   const read = `${line.pairs.length} declared pair(s) in ${line.animations.length} animation(s) (${line.animations.join(', ')}), read by rigc render --seam at ${line.fps} fps on the build as played`;
   const head =
     line.status === 'SKIP'
@@ -1731,6 +1731,20 @@ export function motionSeamLines(line: MotionSeamLine, plant: MotionSeamPlant = {
     ...line.rows.filter((r) => r.status === 'skip').map((r) => `seam "${r.pair}" in "${r.animation}": SKIP — rigc read no band on any of the ${r.drawn} frame(s) both slots draw, so there is no seam to read`),
     ...(plant.silent === true ? [] : line.rows.filter((r) => r.opens.length > 0).map(motionSeamWarnText)),
     ...line.rows.filter((r) => r.opens.length === 0 && r.under_floor.length > 0).map((r) => `seam "${r.pair}" in "${r.animation}": under the floor — rigc names ${r.under_floor.length} frame(s) open ${frameRuns(r.under_floor)}, each opening one cell thick`),
+    ...(line.worlds === undefined ? [] : (['default', 'still'] as const).flatMap(name => {
+      const w = line.worlds?.[name];
+      if (w === undefined) return [];
+      const label = 'seam world "' + name + '"';
+      const header = label + ' wind [' + w.wind.join(', ') + '], gravity [' + w.gravity.join(', ') + ']: ' + w.status +
+        (w.status === 'SKIP' ? ' — ' + String(w.reason) : ' — raw gap/ghost cell counts, informational, not judged') +
+        (w.dir === undefined ? '' : '; raw render: ' + w.dir);
+      return [header, ...w.rows.map(r => {
+        const head = label + ' "' + r.pair + '" in "' + r.animation + '": ';
+        if (r.status === 'skip') return head + 'SKIP — rigc read no band';
+        const at = (kind: typeof r.gap) => kind.worst === null ? 'none' : 'frame ' + kind.worst.index + ' (t = ' + kind.worst.index / line.fps + 's)';
+        return head + 'gap ' + r.gap.max_px + ' cell(s), worst ' + at(r.gap) + '; ghost ' + r.ghost.max_px + ' cell(s), worst ' + at(r.ghost);
+      })];
+    })),
   ];
 }
 

package/src/check.ts

@@ -78,8 +78,8 @@
  * `TIME_SLACK`, issue #244).
  */
 import { createHash } from 'node:crypto';
-import { copyFileSync, cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
-import { basename, delimiter, dirname, join, resolve } from 'node:path';
+import { copyFileSync, cpSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { basename, delimiter, dirname, isAbsolute, join, relative, resolve } from 'node:path';
 import { measureRecomposite, type RecompositeFigures, recompositeRecord, scenePhrase, sourceInRig } from './assemble.ts';
 import { type BoneTransform, computeExactFrameTransforms, cropToSpineY, normaliseDegrees, toBoneLocal } from './coords.ts';
 import { capBox, inDisc } from './limbs.ts';
@@ -128,7 +128,7 @@ import {
   type WorldBox,
 } from './instruments.ts';
 import { type AlternatePartsRecord, FRONT_SUFFIX, type LimbRecord, type PartRecord, type PartsFile, readParts } from './parts.ts';
-import { poseRigBonesForDrawn, type RigBone, SETS_FILE } from './rig.ts';
+import { ARM_SPLIT_MIGRATION, poseRigBonesForDrawn, type RigBone, SETS_FILE } from './rig.ts';
 import { turnTwin } from './turn.ts';
 import {
   aimLine,
@@ -160,7 +160,7 @@ import {
 } from './requirements.ts';
 import { RIG_BONE_INHERIT, type RigSpec as RigcRigSpec } from 'rig-c/src/rig.ts';
 import { expandStops } from 'rig-c/src/stop.ts';
-import { ENVIRONMENT_SPEC, EnvironmentError, readEnvironmentSchedule } from 'rig-c/src/environment.ts';
+import { ENVIRONMENT_SPEC, EnvironmentError, environmentResponse, readEnvironmentSchedule } from 'rig-c/src/environment.ts';
 import { alphaComposite } from './raster/composite.ts';
 import { readPng, writePng } from './raster/png.ts';
 import { newFloatImage, newRaster, type Raster } from './raster/types.ts';
@@ -1280,6 +1280,29 @@ export function setPlacements(parts: PartsFile, alt: AlternatePartsRecord, slotO
   return out;
 }
 
+/**
+ * Issue #671: why a set made before 1.37.0 can fail its seam after #490's arm
+ * split. The set covers a side's sleeve (a part from `full:handwear-<s>`), and
+ * the split made that side's `hand_<s>` / `drape_<s>` parts of their own, which
+ * the set neither covers nor hides, so the base hand is drawn as well as the
+ * hand inside the set's own sleeve art. Returns the hint for the set's seam
+ * refusal, or null when nothing of the kind applies.
+ */
+export function armSplitSetHint(parts: PartsFile, alt: AlternatePartsRecord): string | null {
+  const from = new Map(parts.parts.map((p) => [p.name, p.from]));
+  const covered = new Set(Object.keys(alt.slots).map((n) => (n.endsWith(FRONT_SUFFIX) ? n.slice(0, -FRONT_SUFFIX.length) : n)));
+  const hidden = new Set(alt.hides ?? []);
+  const open: string[] = [];
+  for (const side of ['r', 'l']) {
+    if (![...covered].some((n) => from.get(n) === `full:handwear-${side}`)) continue;
+    for (const p of parts.parts) {
+      if ((p.from === `full:hand-${side}` || p.from === `full:drape-${side}`) && !covered.has(p.name) && !hidden.has(p.name)) open.push(p.name);
+    }
+  }
+  if (open.length === 0) return null;
+  return ` — the set covers a sleeve whose merged arm layer 1.37.0 split (issue #490), and it neither covers nor hides ${open.map((n) => `"${n}"`).join(', ')}, so the base draws ${open.length === 1 ? 'that part' : 'those parts'} beside the set's own art; a set made before 1.37.0 hides it: add ${open.map((n) => `"${n}"`).join(', ')} to the set's hides (see ${ARM_SPLIT_MIGRATION})`;
+}
+
 /**
  * The flat stack of parts for an alternate set (issue #454), in the order
  * {@link setPlacements} gives: with `slotOrder`, a front part (issue #664) is
@@ -3512,6 +3535,7 @@ export const MOTION_SEAM_LINE = 'SEAM_OVER_MOTION';
 
 /** The seam reading's scratch build and renders, under `--out`; removed before the stage returns. */
 const MOTION_SEAM_SCRATCH = '_seam_motion';
+const MOTION_SEAM_DIR = 'seam_motion';
 
 /** rig-c's seam reading: the file it writes in each set's directory, and its format tag. */
 export const SEAM_READING_FILE = 'seam.json';
@@ -3561,6 +3585,8 @@ export interface MotionSeamLine {
   /** Rows with a frame over the floor: the WARN lines. */
   warnings: number;
   rows: MotionSeamRow[];
+  /** Physics-only reference worlds (issue #591); do not participate in warnings or bars. */
+  worlds?: MotionSeamWorlds;
 }
 
 /**
@@ -3617,7 +3643,109 @@ export interface MotionSeamPlant {
   silent?: true;
 }
 
-type SeamHitRead = { index: number; px: number; cell: number; box: [number, number, number, number] };
+
+/** One raw opening, in rigc cells; its frame time is index / the line's fps. */
+export interface MotionSeamHit {
+  index: number;
+  px: number;
+  cell: number;
+  box: [number, number, number, number];
+}
+export interface MotionSeamWorldKind {
+  max_px: number;
+  worst: MotionSeamHit | null;
+}
+/** Raw gap and ghost readings, including cells under the warning floor. */
+export interface MotionSeamWorldRow {
+  pair: string;
+  animation: string;
+  status: 'read' | 'skip';
+  drawn: number;
+  banded: number;
+  gap: MotionSeamWorldKind;
+  ghost: MotionSeamWorldKind;
+}
+export interface MotionSeamWorld {
+  wind: [number, number];
+  gravity: [number, number];
+  status: 'REPORTED' | 'SKIP';
+  reason?: string;
+  /** Complete rigc render directory, relative to check.json; absent when not rendered. */
+  dir?: string;
+  rows: MotionSeamWorldRow[];
+}
+export interface MotionSeamWorlds {
+  default: MotionSeamWorld;
+  still: MotionSeamWorld;
+}
+
+/** No callback and no output for nonphysics; a wind no constraint answers is not measured. */
+export function motionSeamWorlds(physics: boolean, answersWind: boolean, read: (world: 'default' | 'still') => MotionSeamWorldRow[]): MotionSeamWorlds | undefined {
+  if (!physics) return undefined;
+  const world = (wind: [number, number], rows: MotionSeamWorldRow[], reason?: string): MotionSeamWorld => {
+    const measured = rows.some(r => r.status === 'read');
+    return { wind, gravity: [0, 1], status: measured ? 'REPORTED' : 'SKIP',
+      ...(measured ? {} : { reason: reason ?? 'rigc read no band on any frame of any declared pair in any animation' }), rows };
+  };
+  return {
+    default: world([1, 0], read('default')),
+    still: answersWind ? world([0, 0], read('still')) : world([0, 0], [], 'no physics constraint answers wind; still air is not separately measurable'),
+  };
+}
+
+/** The same validated sidecars as the warning, retaining the raw gap and ghost cells. */
+export function readMotionSeamWorldRows(dir: string, animations: readonly string[], fps: number, pairs: readonly MotionSeamPair[]): MotionSeamWorldRow[] {
+  const rows: MotionSeamWorldRow[] = [];
+  readMotionSeams(dir, animations, fps, pairs, {}, rows);
+  return rows;
+}
+
+
+/** Publish complete validated render directories with check.json; roll back if its writer fails. */
+export function publishMotionSeamWorlds(out: string, scratch: string, worlds: MotionSeamWorlds, publishCheck: () => void): void {
+  const problems: Problem[] = [];
+  const names = (['default', 'still'] as const).filter(name => worlds[name].dir !== undefined);
+  for (const name of names) {
+    const world = worlds[name];
+    const home = join(scratch, name);
+    if (world.dir !== MOTION_SEAM_DIR + '/' + name) problems.push({ code: 'FRAMES_SIDECAR', object: 'seam world ' + name, detail: 'raw directory reference must be ' + MOTION_SEAM_DIR + '/' + name });
+    const manifest = readJson(join(home, 'frames.json'), problems);
+    const sets = manifest !== null && Array.isArray(manifest.sets) ? manifest.sets.filter(isRecord) : [];
+    for (const animation of new Set(world.rows.map(row => row.animation))) {
+      const set = sets.find(item => item.animation === animation);
+      const rawDir = set !== undefined && typeof set.dir === 'string' ? set.dir : null;
+      const at = rawDir === null ? null : resolve(home, rawDir);
+      const rel = at === null ? '..' : relative(home, at);
+      if (rawDir === null || isAbsolute(rawDir) || at === null || isAbsolute(rel) || /^\.\.(?:[\\/]|$)/.test(rel) || !existsSync(join(at, SEAM_READING_FILE))) {
+        problems.push({ code: 'FRAMES_SIDECAR', object: home, detail: 'animation ' + JSON.stringify(animation) + ' raw dir ' + JSON.stringify(rawDir) + ' must be relative, stay inside its render directory and hold seam.json' });
+      }
+    }
+  }
+  refuseIfAny(problems);
+  const stage = join(scratch, '_publish');
+  const previous = join(scratch, '_previous');
+  const kept = join(out, MOTION_SEAM_DIR);
+  const check = join(out, 'check.json');
+  const previousCheck = existsSync(check) ? readFileSync(check) : null;
+  mkdirSync(out, { recursive: true });
+  mkdirSync(stage, { recursive: true });
+  for (const name of names) renameSync(join(scratch, name), join(stage, name));
+  const hadPrevious = existsSync(kept);
+  if (hadPrevious) renameSync(kept, previous);
+  try {
+    renameSync(stage, kept);
+    publishCheck();
+  } catch (err) {
+    rmSync(kept, { recursive: true, force: true });
+    if (hadPrevious) renameSync(previous, kept);
+    if (previousCheck === null) rmSync(check, { force: true });
+    else writeFileSync(check, previousCheck);
+    throw err;
+  }
+  rmSync(previous, { recursive: true, force: true });
+}
+
+type SeamHitRead = MotionSeamHit;
 
 /**
  * The rows of one `rigc render --seam` run over every animation: `frames.json`
@@ -3626,7 +3754,7 @@ type SeamHitRead = { index: number; px: number; cell: number; box: [number, numb
  * file that is missing, a file that is not the animation's or not at the rate
  * asked, a pair out of the flag's order, and a field of the wrong shape.
  */
-export function readMotionSeams(dir: string, animations: readonly string[], fps: number, pairs: readonly MotionSeamPair[], plant: MotionSeamPlant = {}): MotionSeamRow[] {
+export function readMotionSeams(dir: string, animations: readonly string[], fps: number, pairs: readonly MotionSeamPair[], plant: MotionSeamPlant = {}, worldRows?: MotionSeamWorldRow[]): MotionSeamRow[] {
   const problems: Problem[] = [];
   const bad = (object: string, detail: string): void => {
     problems.push({ code: 'FRAMES_SIDECAR', object, detail });
@@ -3663,6 +3791,7 @@ export function readMotionSeams(dir: string, animations: readonly string[], fps:
         return;
       }
       const over = new Map<number, number>();
+      const kinds: Record<'gap' | 'ghost', MotionSeamWorldKind> = { gap: { max_px: 0, worst: null }, ghost: { max_px: 0, worst: null } };
       for (const kind of ['gap', 'ghost'] as const) {
         const k = p[kind];
         const frames = isRecord(k) && Array.isArray(k.frames) ? k.frames.map(hitOf) : null;
@@ -3670,8 +3799,12 @@ export function readMotionSeams(dir: string, animations: readonly string[], fps:
           bad(`${at} ${kind}`, 'is not { frames: [{ index, px, cell, box }…], spans, worst } as rigc-seam/1 writes it');
           return;
         }
-        for (const h of frames as SeamHitRead[]) if (plant.noFloor === true || openingOverFloor(h)) over.set(h.index, Math.max(over.get(h.index) ?? 0, h.px));
+        const hits = frames as SeamHitRead[];
+        const worst = hits.reduce<MotionSeamHit | null>((best, h) => best === null || h.px > best.px || (h.px === best.px && h.index < best.index) ? h : best, null);
+        kinds[kind] = { max_px: worst?.px ?? 0, worst };
+        for (const h of hits) if (plant.noFloor === true || openingOverFloor(h)) over.set(h.index, Math.max(over.get(h.index) ?? 0, h.px));
       }
+      worldRows?.push({ pair: want.pair, animation, status: p.status, drawn: p.drawn, banded: p.banded, gap: kinds.gap, ghost: kinds.ghost });
       const opens = [...over.keys()].sort((x, y) => x - y);
       rows.push({
         pair: want.pair,
@@ -4047,13 +4180,15 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
   const seamDir = join(out, SEAM_DIR);
   const keptDir = join(out, STILL_DIR);
   const foldDir = join(out, FOLD_SCRATCH);
-  for (const d of [buildDir, idleDir, stillDir, isoDir, loopDir, seamDir, keptDir, foldDir]) rmSync(d, { recursive: true, force: true });
+  const seamMotionDir = join(out, MOTION_SEAM_SCRATCH);
+  for (const d of [buildDir, idleDir, stillDir, isoDir, loopDir, seamDir, keptDir, foldDir, seamMotionDir]) rmSync(d, { recursive: true, force: true });
   const written: string[] = [];
   const write = (name: string, data: string): void => {
     writeFileSync(join(out, name), data);
     written.push(name);
   };
 
+  try {
   // 1. build, packed, under the policy profile
   const build = rigc(['build', '--rig', inp.rigPath, '--motion', inp.motionPath, '--out', buildDir, ...packedBuildArgs(mode)]);
   const gateHtml = buildGateLines(build.out);
@@ -4406,15 +4541,38 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
     else if (animationNames.length === 0) motionSeam = motionSeamLine(pairs, [], fps, [], 'motion.json holds no animation to read the declared pairs in');
     else if (read.length === 0) motionSeam = motionSeamLine(pairs, animationNames, fps, []);
     else {
-      const seamMotionDir = join(out, MOTION_SEAM_SCRATCH);
       rmSync(seamMotionDir, { recursive: true, force: true });
-      try {
+      {
         const list = read.map((p) => `${p.a}:${p.b}`).join(',');
-        const r = measured(['render', '--candidate', buildDir, '--seam', list, '--fps', String(fps), '--max', String(FOLD_RENDER_MAX), '--out', seamMotionDir]);
+        const activeDest = stripped === null ? seamMotionDir : join(seamMotionDir, env === null ? 'default' : 'active');
+        const renderedWorlds = new Set<'default' | 'still'>();
+        const r = measured(['render', '--candidate', buildDir, '--seam', list, '--fps', String(fps), '--max', String(FOLD_RENDER_MAX), '--out', activeDest]);
         if (r.status !== 0) refuseIfAny(rigcFailed(`render --seam ${list} --fps ${fps}`, r, r.out.split('\n').filter((l) => l.includes('FAIL') || l.includes('rigc:'))));
-        motionSeam = motionSeamLine(pairs, animationNames, fps, readMotionSeams(seamMotionDir, animationNames, fps, read));
-      } finally {
-        rmSync(seamMotionDir, { recursive: true, force: true });
+        const activeWorldRows: MotionSeamWorldRow[] = [];
+        motionSeam = motionSeamLine(pairs, animationNames, fps, readMotionSeams(activeDest, animationNames, fps, read, {}, stripped !== null && env === null ? activeWorldRows : undefined));
+        if (stripped !== null) {
+          const response = environmentResponse(readFileSync(join(buildDir, 'skeleton.json'), 'utf8'));
+          motionSeam.worlds = motionSeamWorlds(true, response.wind.length > 0, world => {
+            if (world === 'default' && env === null) { renderedWorlds.add(world); return activeWorldRows; }
+            const dest = join(seamMotionDir, world);
+            const args = ['render', '--candidate', buildDir, '--seam', list, '--fps', String(fps), '--max', String(FOLD_RENDER_MAX), '--out', dest];
+            if (world === 'still') {
+              const schedule = join(seamMotionDir, 'still.json');
+              writeFileSync(schedule, JSON.stringify({ spec: ENVIRONMENT_SPEC, steps: [{ t: 0, wind: [0, 0] }] }));
+              args.push('--environment', schedule);
+            }
+            // These reference worlds are independent of the caller's --environment.
+            const rendered = rigc(args);
+            if (rendered.status !== 0) refuseIfAny(rigcFailed('render --seam (' + world + ' reference world)', rendered, rendered.out.split('\n').filter(l => l.includes('FAIL') || l.includes('rigc:'))));
+            const rows = readMotionSeamWorldRows(dest, animationNames, fps, read);
+            renderedWorlds.add(world);
+            return rows;
+          });
+          for (const world of renderedWorlds) {
+            const reading = motionSeam.worlds?.[world];
+            if (reading !== undefined) reading.dir = MOTION_SEAM_DIR + '/' + world;
+          }
+        }
       }
     }
   }
@@ -4447,6 +4605,8 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
   let blink: JudgementLine = skip(lacking);
   let sourceRead: ReportedLine | null = null;
   const setsFigures: Record<string, SetCheckFigures> = {};
+  // Issue #671: a failing set's hint, read with its seam; never written to check.json.
+  const setHints = new Map<string, string>();
   if (inp.parts !== null || inp.source !== null) {
     try {
       mkdirSync(stillDir, { recursive: true });
@@ -4518,6 +4678,10 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
             const altMean = round3(altSeam.mean);
             const altScale = round6(altStillSet.viewport.scale);
             const altFailed = seamFails(altMean, altSeam.over40, altScale);
+            if (altFailed) {
+              const hint = armSplitSetHint(inp.parts, alt);
+              if (hint !== null) setHints.set(alt.name, hint);
+            }
             let altPairs: SeamPairRow[] | null = null;
             if (seamPairsAsked || altFailed) {
               const placed = setPlacements(inp.parts, alt, rigSlotOrder).map(({ name, png, box }) => ({ name, from: box.from, x: box.x, y: box.y, image: readPng(join(inp.partsDir, `${png}.png`)) }));
@@ -4653,7 +4817,8 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
           `mean |d| ${setFig.seam_mean}/255 and ${setFig.seam_px_over_40} frame px over ${SEAM_PX_LEVEL} (${setFig.seam_px_over_80} over ${SEAM_PX_LEVEL_HIGH}) at frame scale ${setFig.seam_frame_scale}, ${seamRigPxText(setFig.seam_px_over_40, setFig.seam_frame_scale)} rig px (the count / s²); mean <= ${SEAM_MEAN_BAR.toFixed(1)} and <= ${SEAM_PX_BAR} rig px over ${SEAM_PX_LEVEL} are required` +
           (worst === null
             ? `; no pixel is over ${SEAM_PX_LEVEL}, so the mean alone fails and there is no pair to name`
-            : `; worst of ${(setFig.seam_pairs as SeamPairRow[]).length} pair(s): ${seamPairText(worst)}`),
+            : `; worst of ${(setFig.seam_pairs as SeamPairRow[]).length} pair(s): ${seamPairText(worst)}`) +
+          (setHints.get(setName) ?? ''),
       });
     }
   }
@@ -4662,7 +4827,9 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
   problems.unshift(...barProblems);
   problems.push(...foldProblems, ...levelProblems, ...stressProblems, ...limbProblems, ...sweepProblems, ...reqProblems);
   figures.PASS = problems.length === 0;
-  write('check.json', `${JSON.stringify(figures, null, 1)}\n`);
+  const publishCheck = (): void => write('check.json', `${JSON.stringify(figures, null, 1)}\n`);
+  if (motionSeam.worlds === undefined) publishCheck();
+  else publishMotionSeamWorlds(out, seamMotionDir, motionSeam.worlds, publishCheck);
   const bars: CheckReport['bars'] = { measured: ['gate'], skipped: [] };
   const tally = (bar: string, reason: string | null): void => {
     if (reason === null) bars.measured.push(bar);
@@ -4701,6 +4868,9 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
     cloth,
     ...(sweepSteps.size === 0 ? {} : { sweepSteps }),
   };
+  } finally {
+    rmSync(seamMotionDir, { recursive: true, force: true });
+  }
 }
 
 // ---------------------------------------------------------------------------

package/src/config.ts

@@ -2997,9 +2997,10 @@ function checkRegions(c: Check, v: Json, bones: Set<string>): void {
     return;
   }
   for (const [part, bone] of Object.entries(v as Record<string, Json>)) {
-    if (typeof bone !== 'string' || !bones.has(bone)) {
-      c.fail('CONFIG_NAME_RESOLVES', `config.regions.${part}`, `is ${show(bone)}; a bone name is required`);
-    }
+    if (typeof bone !== 'string') c.fail('CONFIG_NAME_RESOLVES', `config.regions.${part}`, `is ${show(bone)}; a bone name is required`);
+    // Issue #671: the part and the bone by name, so an entry `propose --only-missing` drafted on a bone the config
+    // does not declare says which.
+    else if (!bones.has(bone)) c.fail('CONFIG_NAME_RESOLVES', `config.regions.${part}`, `names the bone ${show(bone)} for the part "${part}", which config.bones does not declare; a declared bone is required`);
   }
 }
 

package/src/configwrite.ts

@@ -2,7 +2,9 @@
  * The three config updates proposed by the CLI (issue #356). Pure JSON merge:
  * no file reads/writes and no substitute for the stage's existing validator.
  * A present proposal section replaces that whole field; an absent optional
- * section is retained. The caller supplies the proposer's own section tuple,
+ * section is retained. `proposal-missing` (issue #671, `--only-missing`) instead
+ * adds only the `meshes` / `regions` entries of proposed parts the config attaches
+ * by neither, one edit per entry, and leaves every existing entry as it is. The caller supplies the proposer's own section tuple,
  * avoiding a second policy list or a runtime import of the proposer graph.
  */
 import type { PlanProposal } from './assemble.ts';
@@ -16,10 +18,14 @@ export interface ConfigObject { [key: string]: ConfigJson }
 export type ConfigWritePatch =
   | { kind: 'head-box'; head_box: HeadBoxProposal['head_box'] }
   | { kind: 'assemble-plan'; plan: PlanProposal['plan']; extend_below_crop: PlanProposal['extend_below_crop'] }
-  | { kind: 'proposal'; proposal: Proposal; sections: typeof PROPOSAL_CONFIG_SECTIONS };
+  | { kind: 'proposal'; proposal: Proposal; sections: typeof PROPOSAL_CONFIG_SECTIONS }
+  /** Issue #671 (`--only-missing`): only `meshes.<part>` / `regions.<part>` for a proposed part the config attaches by neither. */
+  | { kind: 'proposal-missing'; proposal: Proposal; parts: ReadonlyArray<{ name: string; from: string }> };
 export interface ConfigWriteChange {
   path: string;
   kind: 'added' | 'replaced' | 'removed';
+  /** The value written, where the path alone does not say it (an array element added, issue #671). */
+  value?: string;
 }
 export interface ConfigWriteResult {
   config: ConfigObject;
@@ -111,7 +117,49 @@ export function mergeConfigProposal(raw: unknown, patch: ConfigWritePatch): Conf
       }
       break;
     }
-    default: return refuse('write-config', 'has no supported operation; head-box, assemble-plan or proposal is required');
+    case 'proposal-missing': {
+      // Issue #671: a config proposed before a part existed (the #490 arm split's drape_<s> and hand_<s>) gains its
+      // plan row (split parts only) and an entry for that part alone, entry by entry, in the section the proposal drafts
+      // it in. A part the config already attaches, by either section, keeps its entry as written; nothing else of the
+      // proposal is read.
+      const attached = (part: string): boolean => (object(config.meshes) && own(config.meshes, part)) || (object(config.regions) && own(config.regions, part));
+      for (const section of ['meshes', 'regions'] as const) {
+        if (config[section] !== undefined && !object(config[section])) return refuse(`config.${section}`, 'is not an object; an object of part entries is required before an entry is added to it');
+      }
+      const added: ConfigWriteChange[] = [];
+      // The #490 split's parts the plan does not name, each row where `mergedArmSplitPlan` puts it: the drape just
+      // before the full run's handwear-<s> row, the hand just after it. A part of any other origin is not planned here.
+      const assemble = config.assemble;
+      const plan = object(assemble) && Array.isArray(assemble.plan) ? assemble.plan : null;
+      if (plan !== null) {
+        const row = (e: ConfigJson): [string, string, string] | null =>
+          Array.isArray(e) && e.length === 3 && e.every((x) => typeof x === 'string') ? (e as [string, string, string]) : null;
+        for (const part of patch.parts) {
+          const m = /^full:(drape|hand)-([rl])$/.exec(part.from);
+          if (m === null) continue;
+          if (plan.some((e) => { const r = row(e); return r !== null && (r[0] === part.name || (r[1] === 'full' && r[2] === `${m[1]}-${m[2]}`)); })) continue;
+          const arm = plan.findIndex((e) => { const r = row(e); return r !== null && r[1] === 'full' && r[2] === `handwear-${m[2]}`; });
+          if (arm < 0) continue;
+          const at = m[1] === 'drape' ? arm : arm + 1;
+          const value: ConfigJson = [part.name, 'full', `${m[1]}-${m[2]}`];
+          plan.splice(at, 0, value);
+          edits.push({ path: ['assemble', 'plan', at], value, insert: true, inline: true });
+          added.push({ path: `assemble.plan[${at}]`, kind: 'added', value: JSON.stringify(value) });
+        }
+      }
+      for (const section of ['meshes', 'regions'] as const) {
+        for (const [part, entry] of Object.entries(patch.proposal[section])) {
+          if (attached(part)) continue;
+          const value = clone(entry, field(`proposal.${section}`, part));
+          if (!object(config[section])) config[section] = {};
+          (config[section] as ConfigObject)[part] = value;
+          edits.push({ path: [section, part], value });
+          added.push({ path: field(section, part), kind: 'added' });
+        }
+      }
+      return { config, changes: added, edits };
+    }
+    default: return refuse('write-config', 'has no supported operation; head-box, assemble-plan, proposal or proposal-missing is required');
   }
   return { config, changes: changes(before, config), edits };
 }

package/src/meshdraft.ts

@@ -589,6 +589,11 @@ export interface ConfigEdit {
   path: readonly (string | number)[];
   value: unknown;
   insert?: boolean;
+  /**
+   * With `insert` (issue #671): in an array written on one line, the element goes in as `JSON.stringify(value)`
+   * beside its neighbours on that line, so a one-line plan stays one line; elsewhere it changes nothing.
+   */
+  inline?: boolean;
 }
 
 /** The span at `path`, or null where the path does not resolve (a key absent, or a step that is not an object). */
@@ -607,10 +612,18 @@ function indentAt(text: string, at: number): string {
 }
 
 /** An element inserted into the array at `arrayPath` before its element `index` (at its length: after the last). */
-function insertElement(text: string, arrayPath: readonly (string | number)[], index: number, value: unknown): string {
+function insertElement(text: string, arrayPath: readonly (string | number)[], index: number, value: unknown, inline = false): string {
   const arr = spanOrNull(text, arrayPath);
   if (arr === null || text[arr.start] !== '[') throw new Error(`splicedEdits: ${arrayPath.join('.') || 'the document'} is not an array`);
   const next = spanOrNull(text, [...arrayPath, index]);
+  if (inline && !text.slice(arr.start, arr.end).includes('\n')) {
+    const body = JSON.stringify(value);
+    if (next !== null) return `${text.slice(0, next.start)}${body},${text.slice(next.start)}`;
+    const last = index > 0 ? spanOrNull(text, [...arrayPath, index - 1]) : null;
+    if (index > 0 && last === null) throw new Error(`splicedEdits: ${arrayPath.join('.')} has no element ${index - 1}`);
+    if (last === null) return `${text.slice(0, arr.start + 1)}${body}${text.slice(arr.end - 1)}`;
+    return `${text.slice(0, last.end)},${body}${text.slice(last.end)}`;
+  }
   if (next !== null) {
     // Before the element: the new one takes its line, and the old one follows on a line of its own at the same indent.
     const indent = indentAt(text, next.start);
@@ -626,11 +639,11 @@ function insertElement(text: string, arrayPath: readonly (string | number)[], in
 }
 
 /** One edit on `text`; every byte it does not name is the input's. */
-function spliceOne(text: string, path: readonly (string | number)[], value: unknown, insert = false): string {
+function spliceOne(text: string, path: readonly (string | number)[], value: unknown, insert = false, inline = false): string {
   const step = path[path.length - 1];
   if (insert) {
     if (typeof step !== 'number') throw new Error(`splicedEdits: an insert names an array index; ${path.join('.')} does not`);
-    return insertElement(text, path.slice(0, -1), step, value);
+    return insertElement(text, path.slice(0, -1), step, value, inline);
   }
   const at = spanOrNull(text, path);
   if (value === undefined) {
@@ -694,7 +707,7 @@ function firstMoved(got: unknown, want: unknown, path: readonly string[]): strin
  */
 export function splicedEdits(text: string, edits: readonly ConfigEdit[]): { text: string; moved: string | null } {
   let out = text;
-  for (const e of edits) out = spliceOne(out, e.path, e.value, e.insert === true);
+  for (const e of edits) out = spliceOne(out, e.path, e.value, e.insert === true, e.inline === true);
   const want = JSON.parse(text) as Record<string, unknown>;
   for (const e of edits) {
     let o: Record<string | number, unknown> | unknown[] = want;

package/src/rig.ts

@@ -185,6 +185,11 @@ import { DISTANCE_EXPONENT, type FloorForm, type Influence, influences, type Inf
 /** Transparent pixels added round every part image — the reference's `PAD`. */
 export const PAD = 4;
 
+/** Issue #671: the MIGRATION entry for 1.37.0's arm split (#490), by its heading's anchor. */
+export const ARM_SPLIT_MIGRATION = 'docs/MIGRATION.md#after-1370-merged-arm-layers-are-split-issue-490';
+/** Issue #671: the command that adds only what a config lacks for the arm split's parts: their plan rows and their entries. */
+export const ARM_SPLIT_REMEDY = 'rig-parts propose --parts <parts> --source <painting> --out <dir> --write-config <config> --only-missing';
+
 /**
  * The places a bone's rotation and every local offset (a bone's `x, y`, a
  * weight's bind `x, y`, a region's `x, y` and `rotation`) are written to.
@@ -1401,6 +1406,11 @@ export function buildRig(
   }
 
   // ---- parts ↔ config ----------------------------------------------------
+  // Issue #671: a part 1.37.0's arm split (#490) makes from the full run is new to a config proposed before it.
+  const armSplitHint = (from: string): string =>
+    /^full:(drape|hand)-[rl]$/.test(from)
+      ? ` — the full run's merged arm layer was split into this part (issue #490, from 1.37.0), which a config proposed before 1.37.0 does not name; see ${ARM_SPLIT_MIGRATION}, and add only its plan row and entry with: ${ARM_SPLIT_REMEDY}`
+      : '';
   const where = (part: string): string => `parts.json holds ${parts.parts.length} part(s): ${parts.parts.map((p) => p.name).join(', ')}`;
   for (const part of Object.keys(cfg.meshes)) if (!byPart.has(part)) fail('RIG_PART_PRESENT', `config.meshes.${part}`, `names the part "${part}", which is not in parts.json; ${where(part)}`);
   for (const [part, bone] of Object.entries(cfg.regions)) {
@@ -1421,7 +1431,7 @@ export function buildRig(
   for (const p of parts.parts) {
     const inM = p.name in cfg.meshes;
     const inR = p.name in cfg.regions;
-    if (!inM && !inR) fail('RIG_PART_ATTACHED', `part "${p.name}"`, 'is in parts.json and has neither a config.meshes nor a config.regions entry; exactly one is required');
+    if (!inM && !inR) fail('RIG_PART_ATTACHED', `part "${p.name}"`, `is in parts.json and has neither a config.meshes nor a config.regions entry; exactly one is required${armSplitHint(p.from)}`);
     if (inM && inR) fail('RIG_PART_ATTACHED', `part "${p.name}"`, 'has both a config.meshes and a config.regions entry; exactly one is required');
     else if (inM && readFrom(p.from)?.run === PAINTING_RUN) {
       fail('RIG_PART_ATTACHED', `part "${p.name}"`, `is a painting patch (${p.from}) and has a config.meshes entry; a patch is a region — config.regions.${p.name} names its bone`);

package/tools/configwrite.ts

@@ -199,5 +199,5 @@ export function stageConfigWrite(target: ConfigWriteTarget | FreshConfigWrite, p
 }
 /** Print to stderr so proposal JSON on stdout remains machine-readable. */
 export function configWriteLines(target: ConfigWriteTarget, changes: readonly ConfigWriteChange[]): string[] {
-  return changes.length === 0 ? [`config ${target.path}: unchanged`] : changes.map((c) => `config ${target.path}: ${c.kind} ${c.path}`);
+  return changes.length === 0 ? [`config ${target.path}: unchanged`] : changes.map((c) => `config ${target.path}: ${c.kind} ${c.path}${c.value === undefined ? '' : ` ${c.value}`}`);
 }