rig-parts 1.57.1 → 1.59.0

package/NOTICE.md

@@ -122,6 +122,28 @@ redistributed.
 The [parts-examples](https://github.com/rig-c/parts-examples) README records
 both, beside each character's generation record.
 
+### Models named by the optional painting graph
+
+**[observed 2026-10-22]** In `src/graphs.ts`, the intended OpenPose ControlNet is
+[xinsir/controlnet-openpose-sdxl-1.0](https://huggingface.co/xinsir/controlnet-openpose-sdxl-1.0/blob/23f966cd5cfdd3f7729c903e243d87152162d2b7/README.md).
+That revision's card declares `license: apache-2.0`. Its
+[`diffusion_pytorch_model.safetensors`](https://huggingface.co/xinsir/controlnet-openpose-sdxl-1.0/blob/23f966cd5cfdd3f7729c903e243d87152162d2b7/diffusion_pytorch_model.safetensors)
+is the source for the host-local name `controlnet-openpose-sdxl-1.0.safetensors`.
+The graph uses that name only when `generation.control` is configured and
+`generation.control.model` is absent; a configured model filename replaces it.
+The local filename alone does not identify or verify the installed weights.
+
+**[observed 2026-10-22]** The graph always names `4x-AnimeSharp.pth` for model
+upscaling, followed by Lanczos resizing. The source is
+[Kim2091/AnimeSharp at `7696d95`](https://huggingface.co/Kim2091/AnimeSharp/blob/7696d95ced82b0c1f2a41f6ac73336133f0a90e1/4x-AnimeSharp.pth),
+and the [creator's card at that revision](https://huggingface.co/Kim2091/AnimeSharp/blob/7696d95ced82b0c1f2a41f6ac73336133f0a90e1/README.md)
+declares CC BY-NC-SA 4.0, including its NonCommercial condition. rig-parts ships
+neither model and grants no additional rights to their weights. These observations
+record the models' declared terms; they do not assign a blanket licence to output
+images. The existing upscaler selection is unchanged. Whether to require explicit
+selection is the separate, deferred owner decision in
+[#428](https://github.com/rig-c/parts/issues/428).
+
 ## 4. Behaviour reimplemented, not code copied
 
 The raster operations in `src/raster/` reproduce the documented behaviour of

package/README.md

@@ -1,7 +1,10 @@
 # rig-parts
 
 **AI-authored 2D character rigs from one anime painting, verified before they
-are written.** rig-parts takes a single character painting and the layers
+are written.** rig-parts generates no images. The painting and See-through layers
+come from models the user runs on their GPU or a web demo; this package ships no
+weights. The optional `comfy` adapter drives the user's own ComfyUI host and models.
+rig-parts takes a single character painting and the layers
 [See-through](https://github.com/shitagaki-lab/see-through) decomposed it into,
 merges them into measured rig-space parts, authors weighted meshes, bone chains
 and a looping idle over them in [rig-c](https://github.com/rig-c/core)'s
@@ -168,11 +171,19 @@ rig-parts at what it wrote:
 
 | Route | Where | Output rig-parts reads |
 | --- | --- | --- |
-| Hugging Face Space | [24yearsold/see-through-demo](https://huggingface.co/spaces/24yearsold/see-through-demo) (ZeroGPU; upstream states 1-2 extractions a day for a registered user) | the `.psd` it produces |
+| Hugging Face Space | [24yearsold/see-through-demo](https://huggingface.co/spaces/24yearsold/see-through-demo) (ZeroGPU) | the `.psd` it produces; upload `st_input_full.png`, the white-padded square from `inputs`, for the full run, and `st_input_head.png` for the separate head run |
 | ModelScope demo | [ljsabc/See-Through](https://modelscope.cn/studios/ljsabc/See-Through), linked from the upstream README | the `.psd` it produces |
 | Upstream CLI | `python inference/scripts/inference_psd.py --srcp <image> --save_to_psd` in a checkout of [shitagaki-lab/see-through](https://github.com/shitagaki-lab/see-through) | the `.psd` in `workspace/layerdiff_output/` |
 | ComfyUI wrapper | [jtydhr88/ComfyUI-See-through](https://github.com/jtydhr88/ComfyUI-See-through) on your own ComfyUI box; the optional `comfy` adapter (`rig-parts comfy seethrough`) drives it | the `layers.json` + PNGs it writes |
 
+Use the square `inputs` outputs on the Space too. Its [app calls `apply_layerdiff`](https://huggingface.co/spaces/24yearsold/see-through-demo/blob/049a1ab07908e404aad03f73431dd1a98f88202c/app.py#L110-L118),
+which [calls `center_square_pad_resize`](https://huggingface.co/spaces/24yearsold/see-through-demo/blob/049a1ab07908e404aad03f73431dd1a98f88202c/common/utils/inference_utils.py#L78-L83).
+That [preprocessing function](https://huggingface.co/spaces/24yearsold/see-through-demo/blob/049a1ab07908e404aad03f73431dd1a98f88202c/common/utils/cv.py#L254-L274)
+pads a non-square upload before resizing; the centre-crop reported in
+[#356](https://github.com/rig-c/parts/issues/356) is not the current source path.
+`st_input_full.png` supplies the explicit white padding that rig-parts maps back
+to the original painting. This is a source inspection, not a new demo run.
+
 **The head run is needed on every route that was read.** See-through's model
 already separates the head in a second stage of its own: it crops the head the
 first stage found, runs the face tags on that crop at the same `resolution`, and
@@ -217,10 +228,10 @@ commands drive it; nothing else in the pipeline needs one:
 
 ```sh
 rig-parts comfy paint --config config.json --out <dir> --host http://<box>:8188
-rig-parts comfy seethrough --image st_input_full.png --out layers/full --host http://<box>:8188 --offload
+rig-parts comfy seethrough --image st_input_full.png --out layers/full --host http://<box>:8188
 ```
 
-`comfy paint` generates `painting_<seed>.png` from the config's inline
+`comfy paint` asks the user's models to generate `painting_<seed>.png` from the config's inline
 `generation` block — checkpoint, LoRAs, sampler, and an optional OpenPose
 control skeleton it draws itself — and records the prompts verbatim beside it.
 `comfy seethrough` runs the [ComfyUI-See-through](https://github.com/jtydhr88/ComfyUI-See-through)
@@ -230,6 +241,32 @@ the graph is checked against the box's `/object_info`, so a missing node class
 or model is refused by name, and the adapter waits for an empty queue rather
 than queueing behind someone else's job.
 
+The painting graph uses `4x-AnimeSharp.pth`, then Lanczos resizing. The
+[creator's card](https://huggingface.co/Kim2091/AnimeSharp/blob/7696d95ced82b0c1f2a41f6ac73336133f0a90e1/README.md)
+declares CC BY-NC-SA 4.0. When `generation.control` is set, the intended OpenPose
+ControlNet is [xinsir/controlnet-openpose-sdxl-1.0](https://huggingface.co/xinsir/controlnet-openpose-sdxl-1.0/blob/23f966cd5cfdd3f7729c903e243d87152162d2b7/README.md),
+whose card declares Apache-2.0. Install its `diffusion_pytorch_model.safetensors`
+on the host as `controlnet-openpose-sdxl-1.0.safetensors`, or select its installed
+filename with `generation.control.model`. A filename alone does not verify the
+weights. [NOTICE](NOTICE.md#models-named-by-the-optional-painting-graph) pins the
+sources and records their declared terms; those declarations do not assign a
+blanket licence to output images. The graph's automatic upscaler selection is
+unchanged; the owner decision is tracked separately in [#428](https://github.com/rig-c/parts/issues/428).
+
+`--offload` selects the wrapper's CUDA group-offload path on the **ComfyUI host**:
+its [LayerDiff and depth loaders](https://github.com/jtydhr88/ComfyUI-See-through/blob/98d754bf04f668647919ab750eccb0e0640faa81/nodes.py#L395-L475)
+call `enable_group_offload('cuda', ...)`. Omit it for a local Mac/MPS host. A Mac
+running this CLI may pass it to a remote CUDA host. This describes that offload
+path; it is not a claim that the remaining model stack has been verified on MPS.
+
+The [wrapper README at `98d754b`](https://github.com/jtydhr88/ComfyUI-See-through/blob/98d754bf04f668647919ab750eccb0e0640faa81/README.md#L22-L28)
+describes a combined Decompose node and names `24yearsold/seethroughv0.0.1_marigold`
+for depth. The shipped `workflows/seethrough.json` instead sends
+`SeeThrough_GenerateLayers`, `SeeThrough_GenerateDepth` and `SeeThrough_PostProcess`,
+and selects `layerdifforg/seethroughv0.0.1_marigold`, matching the wrapper's
+[implemented depth default](https://github.com/jtydhr88/ComfyUI-See-through/blob/98d754bf04f668647919ab750eccb0e0640faa81/nodes.py#L82-L85).
+Use the graph's node classes and the host's `/object_info` when checking the adapter.
+
 ## The loop, for an agent
 
 ```sh
@@ -261,8 +298,10 @@ rig-parts build --config config.json --source painting.png --full layers/full --
 
 At each step the config holds only what that step reads; the one table of what
 that is, step by step, is [docs/AUTHORING.md §4](docs/AUTHORING.md#4-the-command-order).
-The selftest runs this block in order, command by command, on each fetched example,
-from a config holding only what the first step reads (`RL01`). On `demo` the
+The command-order controls exercise the hand-copy route above on each fetched
+example from a config holding only what the first step reads (`RL01`). The optional
+`--write-config` forms below save the proposed fields; `RL01` does not exercise
+that flag. On `demo` the
 proposal pasted uncorrected stops at the last step, naming its `bottomwear` on
 `CHECK_TIP_OVER_ROOT` — the correction its tracked config records there, the two outer
 skirt chains moved (issue #227, [its README](examples/demo/README.md)); on `scarf`,
@@ -296,10 +335,10 @@ agent skill.
 | `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 |
 | `sheet --source <png> --layers <path>… --out <png>` | a labelled contact sheet of the painting and every layer or part |
-| `assemble --propose-plan …` | 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 --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` | propose `seethrough.head_box` from the full run, held inside the painting |
-| `propose --parts --source --out [--compare <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 --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 … --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`) |
@@ -322,10 +361,40 @@ fields, the files a build writes and their spec ids, the environment, and what t
 package relies on in rig-c — and what is not, is [docs/STABILITY.md](docs/STABILITY.md).
 Coming from 0.16.0: [docs/MIGRATION.md](docs/MIGRATION.md).
 
+`--write-config <config.json>` saves the three proposals above into an existing
+regular config file: `seethrough.head_box`, `assemble.plan` plus
+`assemble.extend_below_crop`, or the present config sections of an ordinary
+proposal. For `assemble --propose-plan`, the destination must name `--config`
+itself; a different destination is a usage error. Other fields and absent optional
+sections remain; proposal notes are not copied. Changed whole values are spliced
+into the original text, preserving untouched bytes. Stage loaders validate the candidate, including `proposed_rig_scale`,
+before atomic replacement. Relative paths keep the config's directory as their
+base. Changes are listed on stderr; the head-box and plan JSON on stdout remain.
+An identical update leaves bytes and mtime untouched. Without the flag no config
+is changed. This commits the config file, not a transaction across the proposal
+artifacts.
+
+With `--cloth <config.json>`, the flag requires a **new** destination and applies
+the recipe's entry ownership: recipe-owned entries are spliced into the cloth
+config while hand entries and unrelated text survive; conflicts are refused.
+The destination must also be separate from all four artifacts under `--out`:
+`proposal.json`, `basis.json`, `render/landmarks.png`, `render/landmarks_head.png`.
+Aliases, including directory symlinks and hardlinks, count as collisions too.
+Fresh output is published without overwriting a file created while the command
+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.
+`--from-config` proposes nothing and cannot be combined with `--write-config`.
+[AUTHORING §4](docs/AUTHORING.md#4-the-command-order) describes all four modes.
+
 ## What it does not do
 
 These are limits of the approach, stated so nobody reads more into a green run:
 
+- **rig-parts generates no images.** The painting and See-through layers are made
+  by models the user runs on their GPU or a web demo. No weights ship here; the
+  optional `comfy` adapter drives the user's own ComfyUI host and models.
 - **One depth value per layer.** See-through gives each layer a single depth, so a
   layer that is in front of another in one place and behind it in another is drawn
   right in the still (the painting's own pixels are projected onto it) and wrong once
@@ -354,7 +423,10 @@ These are limits of the approach, stated so nobody reads more into a green run:
   file of joints comes from any pose
   estimator or a hand; this package does not estimate a pose itself, and its
   keypoint support has been measured on generated figures and on files read off the
-  examples' own configs, never on an estimator's output.
+  examples' own configs, and on one reported estimator output: RTMPose whole-body
+  through rtmlib on one painting built green with the estimated file unedited
+  ([#356](https://github.com/rig-c/parts/issues/356)). That is one measurement,
+  not an estimator success rate; it has not been re-run here.
 - **The proposer reads tags, not pictures.** A swinging element painted inside another
   layer (a sash tail in the skirt), hair that is none of the shapes it knows, and
   whether an accessory swings are the corrector's to add. The one accessory shape it

package/cli.ts

@@ -20,6 +20,7 @@ import { type AlternateCliInput, assembleStage, build, checkStage, ERROR_MAP_FIL
 import { ACCEPTABLE_BARS, DEFAULT_PACK_SHAPE, DEFAULT_PAGE_EDGES, findRigc, PACK_SHAPES, rigcRunnerAt, type PackShape, PAGE_EDGES, type PageEdges, PARTS_HOME_SENTENCE, RIGC_GEOMETRY_VERSION, rigcRanClause, type RigcRunner, NO_PARTS_SENTENCE, SEAM_MEAN_BAR, SOURCE_SENTENCE, SEAM_PX_BAR, SEAM_PX_LEVEL, SPINEBOY_YARDSTICK, TEXTURE_STRETCH_CEILING } from './src/check.ts';
 import { ComfyClient, resolveHost, runPainting, runSeeThrough } from './src/comfy/index.ts';
 import { type CharacterConfig, loadClothConfig, loadConfig, loadEarlyConfig, loadPaintConfig } from './src/config.ts';
+import { configWriteLines, readConfigWriteTarget, separateConfigWriteTarget, stageConfigWrite, type StagedConfigWrite } from './tools/configwrite.ts';
 import { failLine, guidePointer, PartsError } from './src/errors.ts';
 import { GUIDE_DOC, type GuideAnswer, guideRule, guideSection } from './src/guide.ts';
 import { proposeHeadBox } from './src/headbox.ts';
@@ -27,8 +28,8 @@ 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 { 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, proposalAsConfig, proposeWithBasis, readPartSet, serializeProposal, withTurn, WRIST_ON_PART_PX } from './src/propose.ts';
-import { BASIS_FILE, BASIS_SPEC, basisFile, basisLine, coverageLines, serializeBasis } from './src/diagnostics.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';
 import { BEND_DEGREES, BEND_WORST_SHARE, DUST_MAX_PX, DUST_MAX_SHARE, IDLE_BOUND_PX, MESH_DRAFT_REPORT, MESH_DRAFT_SPEC, meshDraftStage, MORE_TRIANGLES_FLAG, relativeConfigPaths, TOLERANCE_FIGURE_DIVISOR } from './src/meshdraft.ts';
 import { meshStatsStage } from './src/meshstats.ts';
 import { chainsLeftBehind, clothConfigEdits, editPaths, plainCount, previousCount, writtenClothConfig } from './src/clothconfig.ts';
@@ -269,13 +270,24 @@ usage:
       coverage lines after them; no ${BASIS_FILE}, as nothing is proposed.
       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
+      present config sections, including proposed_rig_scale; notes stay in the
+      proposal. Absent optional sections and all other fields are kept. The
+      full config loader validates a same-directory candidate before atomic
+      replacement; relative paths resolve beside the config. An equal update
+      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 --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
       layers for a painting of WxH px (portrait or landscape: the full run is
       mapped back through the pad inputs added), held inside the painting; a
       shift is printed when one was needed. When "back hair" contributes, prints
       the box without it and how much of the side and area it took;
-      --no-back-hair leaves "back hair" out of the box.
+      --no-back-hair leaves "back hair" out of the box. --write-config updates
+      only seethrough.head_box in an existing config through the layers loader.
 
   rig-parts compare --left <file> --right <file> [--map <bonemap.json>]
       Compare two skeletons bone by bone. Each file is a config, a proposal.json
@@ -697,7 +709,7 @@ usage:
       ${DEFAULT_PROJECT_RULE}.
 
   rig-parts assemble --propose-plan --source <painting.png> --full <dir|psd>
-                       [--head <dir|psd>] --config <config.json>
+                       [--head <dir|psd>] --config <config.json> [--write-config <config.json>]
       Print {plan, extend_below_crop, notes} for config.assemble, from the two
       runs. A layer \`layers\` WARNs about (PLAN_LAYER_TRANSLUCENT,
       PLAN_LAYER_BACKGROUND, PLAN_LAYER_OVERSIZED) is not proposed, and a note
@@ -709,7 +721,8 @@ usage:
       config.seethrough.resolution and config.assemble.rig_scale — the rest of
       the config need not exist yet. With no --head, the one run is held as
       assemble holds it and every row is written from it, and the first note
-      says so.
+      says so. --write-config must name --config itself; it updates the whole
+      assemble.plan and assemble.extend_below_crop through the assemble loader.
 
   rig-parts inputs --source <painting.png> --config <config.json> --out <dir>
       Cut the two images See-through is fed: <out>/st_input_full.png (the
@@ -975,7 +988,7 @@ const TAKES = {
   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'] },
-  assemble: { valued: ['--source', '--full', '--head', '--config', '--out', '--seam', '--project', '--alt'], switches: ['--propose-plan'] },
+  assemble: { valued: ['--source', '--full', '--head', '--config', '--out', '--seam', '--project', '--alt', '--write-config'], switches: ['--propose-plan'] },
   'comfy seethrough': { valued: ['--image', '--out', '--resolution', '--steps', '--seed', '--prefix', '--host', '--wait', '--timeout', '--poll'], switches: ['--offload', '--lama', '--nf4'] },
   'comfy paint': { valued: ['--config', '--out', '--seeds', '--seed0', '--host', '--wait', '--timeout', '--poll'], switches: [] },
   inputs: { valued: ['--source', '--config', '--out'], switches: [] },
@@ -1267,7 +1280,7 @@ function parseCanvas(v: string): { w: number; h: number } | null {
   return m === null ? null : { w: Number(m[1]), h: Number(m[2]) };
 }
 
-function printLint(P: PartSet, spec: { bones: CharacterConfig['bones']; meshes: CharacterConfig['meshes']; regions: CharacterConfig['regions']; motion: CharacterConfig['motion']; constraints?: CharacterConfig['constraints'] }, joints?: RigJoints, drafted: readonly DraftLintFinding[] = []): number {
+function printLint(P: PartSet, spec: { bones: CharacterConfig['bones']; meshes: CharacterConfig['meshes']; regions: CharacterConfig['regions']; motion: CharacterConfig['motion']; constraints?: CharacterConfig['constraints']; limbs?: CharacterConfig['limbs']; notes?: readonly string[] }, joints?: RigJoints, drafted: readonly DraftLintFinding[] = []): number {
   const res = lint(P, spec, joints, drafted);
   // Under --keypoints only: which rule set read the torso and the chains, and on what basis.
   if (res.basis !== undefined) for (const l of basisLines(res.basis)) console.log(l);
@@ -1285,7 +1298,7 @@ function printLint(P: PartSet, spec: { bones: CharacterConfig['bones']; meshes:
   }
   console.log(`${res.findings.length} LINT line(s) over ${Object.keys(spec.meshes).length - res.unknownMeshes.length} mesh(es) and the hip`);
   // Issue #86: after every line above, which check read each bone, or why none did.
-  for (const l of coverageLines(res.coverage)) console.log(l);
+  for (const l of coverageLines(res.coverage, legChainChoice(P, spec, joints))) console.log(l);
   return res.findings.length;
 }
 
@@ -1311,17 +1324,24 @@ function cmdPropose(args: string[]): number {
     flags.set(flag, value);
     i++;
   }
+  let staged: StagedConfigWrite | null = null;
   try {
     if (headBox) {
-      const stray = [...flags.keys()].filter((f) => f !== '--full' && f !== '--canvas');
-      if (stray.length > 0) return usage(`--head-box takes --full and --canvas only; got ${stray.join(', ')}`);
+      const stray = [...flags.keys()].filter((f) => f !== '--full' && f !== '--canvas' && f !== '--write-config');
+      if (stray.length > 0) return usage(`--head-box takes --full, --canvas and optional --write-config only; got ${stray.join(', ')}`);
       const full = flags.get('--full');
       const canvasArg = flags.get('--canvas');
       if (full === undefined) return usage('--head-box needs --full <dir | layers.json | file.psd>, the full run\'s layers');
       if (canvasArg === undefined) return usage('--head-box needs --canvas <W>x<H>, the painting\'s size in px');
       const canvas = parseCanvas(canvasArg);
       if (canvas === null) return usage(`--canvas ${canvasArg} is not <W>x<H> in integer px`);
+      const target = flags.has('--write-config') ? readConfigWriteTarget(flags.get('--write-config') as string) : null;
       const r = proposeHeadBox(readLayers(full), canvas, { backHair: !noBackHair });
+      if (target !== null) {
+        staged = stageConfigWrite(target, { kind: 'head-box', head_box: r.head_box });
+        staged.commit();
+        for (const line of configWriteLines(target, staged.changes)) console.error(line);
+      }
       console.log(`rig-parts propose --head-box: ${full}`);
       console.log(`  painting ${canvas.w}x${canvas.h}; head layers ${r.layers.map(([n, c]) => `${n} ${c} px`).join(', ')}`);
       if (r.shift[0] !== 0 || r.shift[1] !== 0) {
@@ -1372,16 +1392,21 @@ function cmdPropose(args: string[]): number {
     // 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 && clothArg === undefined) return usage('--write-config writes the --cloth config with what its recipe drafts spliced in; give --cloth <config.json>');
     // 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>');
-    if (writeArg !== undefined) {
-      const ours = ['proposal.json', BASIS_FILE].map((f) => resolve(out, f));
+    if (fromArg !== undefined && clothArg === undefined) return usage('--from names a previous cloth recipe; give --cloth <config.json>');
+    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` }]);
       }
+      separateConfigWriteTarget({ path: resolve(writeArg) }, ours, 'PROPOSE_WRITE_CONFIG_FRESH');
     }
+    // The existing cloth writer keeps its fresh-file, per-entry splice contract.
+    // Without --cloth, #356 updates only an existing config through the stage loader.
+    const target = writeArg === undefined || clothArg !== undefined ? null : readConfigWriteTarget(writeArg);
+    if (target !== null) separateConfigWriteTarget(target, [join(out, 'proposal.json'), join(out, BASIS_FILE), join(out, 'render', 'landmarks.png'), join(out, 'render', 'landmarks_head.png')]);
     const cloth = clothArg === undefined ? null : loadClothConfig(clothArg).cloth;
     const previousCloth = fromArg === undefined ? null : loadClothConfig(fromArg).cloth;
     const partsDir = existsSync(partsArg) && statSync(partsArg).isFile() ? dirname(partsArg) : partsArg;
@@ -1455,14 +1480,16 @@ 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 });
+    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));
     writeFileSync(join(out, BASIS_FILE), serializeBasis(bfile));
     writePng(join(render, 'landmarks.png'), img.full);
     if (img.head !== null) writePng(join(render, 'landmarks_head.png'), img.head);
-    if (written !== null) {
-      mkdirSync(dirname(written.at), { recursive: true });
-      writeFileSync(written.at, written.text);
+    if (staged !== null) {
+      staged.commit();
+      if (target !== null) for (const line of configWriteLines(target, staged.changes)) console.error(line);
     }
     console.log(`wrote proposal.json (${prop.bones.length} bone entries, ${Object.keys(prop.meshes).length} meshes) and render/landmarks.png (+_head) under ${out}`);
     for (const n of prop.notes) console.log(`note: ${n}`);
@@ -1484,7 +1511,12 @@ function cmdPropose(args: string[]): number {
     if (cfg !== null) for (const l of compareLines(compare(prop.bones, cfg.bones))) console.log(l);
     return EXIT_OK;
   } catch (err) {
+    if (staged !== null) {
+      try { staged.abort(err); } catch (combined) { return printRefusal(combined); }
+    }
     return printRefusal(err);
+  } finally {
+    staged?.cancel();
   }
 }
 
@@ -1566,6 +1598,7 @@ function cmdAssemble(args: string[]): number {
   // --head is optional (issue #359): without it the full run is the one run, and it must hold the face.
   for (const f of ['--source', '--full', '--config']) if (!flags.has(f)) return usage(`assemble needs ${f}`);
   if (propose && (flags.has('--out') || flags.has('--seam') || flags.has('--project') || alts.length > 0)) return usage('--propose-plan prints to the console; it takes none of --out, --seam, --project, --alt');
+  if (!propose && flags.has('--write-config')) return usage('--write-config belongs to assemble --propose-plan');
   if (!propose && !flags.has('--out')) return usage('assemble needs --out <dir>');
   const seam = flags.get('--seam') ?? DEFAULT_SEAM_RULE;
   if (!(SEAM_RULES as readonly string[]).includes(seam)) return usage(`--seam ${seam}; one of ${SEAM_RULES.join(', ')} is required`);
@@ -1573,13 +1606,22 @@ function cmdAssemble(args: string[]): number {
   if (!(PROJECT_RULES as readonly string[]).includes(project)) return usage(`--project ${project}; one of ${PROJECT_RULES.join(', ')} is required`);
   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');
+  let staged: StagedConfigWrite | null = null;
   try {
     if (propose) {
+      const target = writePath === undefined ? null : readConfigWriteTarget(writePath);
       const src = readSource(source);
       const runs = readRuns(full, head);
       const g = proposeFields(loadEarlyConfig(config, 'layers'), runs.single ? { w: src.width, h: src.height } : null);
       const geometry = { sourceW: src.width, sourceH: src.height, ...g };
       const proposal = runs.single ? proposeSinglePlan(runs.full, geometry) : proposePlan(runs.full, runs.head, geometry);
+      if (target !== null) {
+        staged = stageConfigWrite(target, { kind: 'assemble-plan', plan: proposal.plan, extend_below_crop: proposal.extend_below_crop });
+        staged.commit();
+        for (const line of configWriteLines(target, staged.changes)) console.error(line);
+      }
       console.log(JSON.stringify(proposal, null, 2));
       return EXIT_OK;
     }
@@ -1591,7 +1633,12 @@ function cmdAssemble(args: string[]): number {
     );
     return EXIT_OK;
   } catch (err) {
+    if (staged !== null) {
+      try { staged.abort(err); } catch (combined) { return printRefusal(combined); }
+    }
     return printRefusal(err);
+  } finally {
+    staged?.cancel();
   }
 }