re0-order

Move the items of a named listing into one order a reader can name, changing nothing but their positions.

Goal

A listing carries meaning when related items sit together along one clear axis; items appended where they happened to be written blur that. re0-order realigns the set under one principle a reader can name, moving items and changing nothing else. It acts on a list, table, catalog, set of sections, or enum the human named, or one inside a scope they named or a pipeline they invoked passes on. The result lands in place: in the listing itself and in every copy that mirrors it.

Workflow

1. Pin the listing and its items: the ordered set in focus, inside the scope the human gave.
2. Name the one principle that makes the order most meaningful, from workflow or lifecycle sequence, dependency, grouping by kind, severity, frequency, alphabetical. If a latent order already exists, surface it and complete it instead of imposing a new one. When it is unclear whether the current order is deliberate, surface that call to the human and let them decide; move nothing until they do.
3. Put kin next to each other, then sequence those clusters by that one principle.
4. When the principle is a measured count (how often each item is used, how often it is searched), read each count from the record the listing serves and use it as a starting order, never as the sort key itself. Lead with the item the others are reached through, keep kin together even when their counts differ, let the reading or working order a newcomer follows decide the rest, and let the count settle only what that order leaves open. Name each place the result departs from the count and why.
5. Move items into the new order in place. Reword nothing; add nothing; remove nothing.
6. Apply the identical order everywhere the set is mirrored, translated copies and second surfaces included. To find the mirrors, search the repository for two or three of the set's items, by identifier where items have one and otherwise by a distinctive phrase, and for files that call themselves copies of this one, such as translations. Every hit holding the same set is a mirror and part of the listing the human named.

Rules

• Reorder only: never reword, add, remove, split, or merge an item. Those are other reflexes.
• Use one principle a reader can name; never blend incompatible sorts in one listing.
• Before sorting by that principle, place every item that another item depends on before it, and keep every precedence the human stated; a dependency constrains the sort and is never a second principle. An item that produces knowledge (research, a survey, a measurement) is depended on by every plan or build it would inform even when none of them names it, so it goes before them; its breadth or open end never sends it to the back, since what it finds late is work redone.
• Respect a deliberate order: when the current sequence already encodes a real principle, complete and tidy it rather than replacing it, and surface the call when unclear.
• Act only inside the scope a human named or that a pipeline they invoked passes on. Never choose a listing yourself; its order is the human's call, and a reorder reflex choosing its own target churns what nobody asked to move.
• Mirrored copies of one set get the same order.
• Edit safely: assert each item exists before moving it and report a MISS rather than dropping it silently; edit unicode-safe; script a large structural move instead of sweeping by hand.

Verification

Before finishing, confirm:

1. A reader can name the ordering principle from the result alone.
2. Every original item remains; only positions changed; nothing was reworded, added, or removed. Save the listing before the move and run node scripts/same-set.mjs <before-file> <after-file> [--json]: each non-blank line is an item, exit 0 means the same multiset, exit 1 names the added, removed or changed items, exit 2 is a usage error.
3. Kin are adjacent and the sequence follows the one principle end to end.
4. Every mirrored copy carries the identical order. Run the same script with --mirror <file> once per copy: it compares the items the copy shares with the after file and, on exit 1, names the first divergence.