@@ -18,9 +18,10 @@ Entry conventions:
 - 2026-09-20 #397 (second review) — A REPORT MUST NOT CONTRADICT THE READING BESIDE IT, and the shape could not arise before this cycle. `classify`'s `conjunction-or-initial` fork offers exactly two readings and its detail says which it took ("it is read as an initial"). Where the rest of the parse then roles that letter SUFFIX, the fork resolved to NEITHER branch: `JOHN QUINCY SMITH I` carried the connective-or-initial beside a `suffix-or-name` saying the same token reads as a generational suffix, and `john smith i`, `HENRY I`, `SMITH, JOHN I`, `JOSEP CAROD I ROVIRA III` and `abdul e i` were the same. `i` is the first word that is both a MARKED connective and suffix vocabulary, so no parse before #397 could reach it — which is why the rule is written down now rather than having been.
   DECIDED: the report is WITHDRAWN where the role is SUFFIX or TITLE, in `_pipeline/_assemble.py`, the one place that sees final roles and the ambiguity list together — and beside a withdrawal that was already there, for a report whose referents did not survive assembly. That is the narrow reading of mechanisms.md#AMBIGUITY-AT-THE-DECISION-SITE rather than an exception to it: classify still owns the fork and still takes it where it is taken; what goes is a report whose subject the parse went on to read as something else. Emitting later was the alternative and was rejected as more invasive for the same answer — the fork's inputs (the case class, the own-words span) live in classify and moving the emitter moves them.
   MEASURED: over the review's 43,925-name grid under eight configurations, 9,806 rows on 1,637 distinct names lose exactly one `conjunction-or-initial` and nothing else — no report of any other kind moves and none is gained. On the deduped corpus-union-cases population the only name affected is `JOHN QUINCY SMITH I`, a row this round added, so the ledger's three-name `fix(#397) the Catalan link reports a connective-or-initial in a one-case name` rule is untouched: all three of its names role the letter MIDDLE and all three still report. The invariant is `tests/v2/test_properties.py::test_no_report_contradicts_the_reading_beside_it`, which states it twice — no connective-or-initial on a token roled SUFFIX or TITLE, and no token named by two reports whose details assert different readings — and fails on 8,204 rows at `dc3bdf9c`, 0 here.
-- 2026-10-08 #626 — A REPORT NAMES THE FIELD ITS WORD LANDS IN. Five of assign's reports worded the field from the role the word held at assign (`read as a given name`), and two rules still move a word after that: H1 moves a lone unit behind a title to the family, and P6's attachment takes a trailing name word into the family at the end of a name read family-first. So `Attorney General of Minnesota` reported 'General of Minnesota' "read as a given name by convention" with the unit in the family (since 2.3.0, #491's join clause), and `Kim Min Do` under FAMILY_FIRST told the caller 'Do' was "read as a middle name" with 'Do' in the family (this cycle, since #289 made the Title-case 'Do' a name word). #614's second review had fixed one instance of the class (`Freiherr von Berg Ma`) by moving its report to the stage that knows the outcome.
-  DECIDED: the DECISION stays at its site and the WORDING of the field moves to assemble, the one place that knows final roles (the same reasoning as the 2026-09-20 withdrawal above). An emitter whose detail names a field writes the sentence up to the field and hands the rest as `PendingAmbiguity.field_tail`; assemble joins them around `FIELD_READING` of the first referent's final role. All five such emitters in assign use it, including the three that were right on every measured input (H4's all-suffix name, O5's lone word, the leading ambiguous particle), so no later rule can make them wrong. A placeholder in the detail was declined: token text can carry any characters, and a name containing the placeholder would corrupt its own report. Reports worded at a site whose field is fixed (a comma's credential reading, P6's own attachment report) keep their literal wording.
-  MEASURED 2026-10-08 on master (26cdb891), each report's field phrase compared against its tokens' final roles: over a generated grid of 51,835 names (the corpus names plus heads × trailing words, comma shapes and random runs) under all three orders, 2,689 of 66,208 field claims named the wrong field, in two emitters, title-or-name's join branch (1,575) and the trailing peel's picks (1,114); on the tree, 0. Fingerprint against master, over the differential corpora, the case-table names and a generated comma grid (13,090 names) under six policies (the three orders, `lenient_comma_suffixes=False`, a `/` suffix delimiter and `CapsSuffixes.OFF`): no role, kind, initials or rendering moves; 40 details change, every one `read as a given name` → `read as a family name` on title-or-name, ten names under each of the four given-first policies. Pinned by `test_a_report_names_the_field_its_word_lands_in` in tests/v2/test_cases.py over every case row under all three orders, whose recorded control is 10 failures on master.
+- 2026-10-08 #626 — A REPORT NAMES THE FIELD ITS WORD LANDS IN. Six of assign's reports worded the field from the role the word held at assign (`read as a given name`), and three rules in post_rules still move a word after that: H1 moves the name behind a title to the family, P1's family-first fold takes the particle run and one unit and lays the rest out by the order, and P6's attachment takes a trailing name word into the family at the end of a name read family-first. So `Attorney General of Minnesota` reported 'General of Minnesota' "read as a given name by convention" with the unit in the family (since 2.3.0, #491's join clause); `Kim Min Do` under FAMILY_FIRST told the caller 'Do' was "read as a middle name" with 'Do' in the family, and `de Kim Ma` under FAMILY_FIRST said 'Ma' was a middle name with 'Ma' the given name (both this cycle, since #289 made the Title-case word a name word); and `, Ma Dr.` said 'Ma' after the comma was "read as the given name" with 'Ma' in the family (this cycle, since #316's trailing title walk left the comma's word to H1). #614's second review had fixed one instance of the class (`Freiherr von Berg Ma`) by moving its report to the stage that knows the outcome.
+  DECIDED: the DECISION stays at its site and the WORDING of the field moves to assemble, the one place that knows final roles (the same reasoning as the 2026-09-20 withdrawal above). An emitter whose detail names a field a later rule could change writes the sentence up to the field and hands the rest as `PendingAmbiguity.field_tail` (`""` where the field ends the sentence); assemble joins them around `FIELD_READING` of the first referent's final role. All six such emitters in assign use it -- H4's all-suffix name, title-or-name's join clause, O5's lone word, the trailing peel's picks, the leading ambiguous particle and the comma report on the word after a family comma -- including those right on every measured input, so no later rule can make them wrong. A report in a name emptied for want of content is withdrawn rather than shipped half-worded (no emitter reaches that today). A placeholder in the detail was declined: token text can carry any characters, and a name containing the placeholder would corrupt its own report. Reports worded where the field is settled keep their literal wording: a comma's credential reading, the suffix run's and the numeral fork's, H4's "the name" and P6's own "joins the family". The comma report's given-side wording moves from "the given name" to "a given name" with the rest.
+  MISSED, then caught in review: the first draft converted five emitters and its grid had no empty-head comma with a trailing title, the shape AGENTS.md's comma sweep already asks for; four of the review's five readers found the sixth emitter on `, Ma Dr.`. The draft also named only H1 and P6 as movers; P1's fold was found by stepping the stages.
+  MEASURED 2026-10-08, each report's field phrase compared against its tokens' final roles. RECIPE: texts are the 1,536 names of `tools/differential/corpus*.jsonl` and 347 `tests/v2/cases.py` texts (the rows that existed at #614 and are not corpus names; the whole table moves the totals by a few claims), plus every head in {'John', 'John Smith', 'John Q. Smith', 'Mary Ann Smith', 'John van Smith', 'Juan de la Vega', 'John van', 'anh van', 'Jan Freiherr von Berg', 'Freiherr von Berg', 'Freiherr St', 'St', 'Dr. St', 'Freiherr', 'Dr.', 'Mr. and Mrs.', 'Attorney General of', 'abdul salam', 'Juan y Garcia', 'Jane Doe nee van der Berg', 'Dr. John Smith', 'JOHN SMITH', 'john smith', 'Smith', 'de Mesnil', 'Dr. de Mesnil', 'Kim Min', 'Kim Min Jun', 'Ortega y Gasset', 'van', 'Do', ''} followed by one or two words drawn from {PhD, MA, Ma, DO, Do, do, vd, mc, Jr, III, V, V., VI, X.Y.Z., Ph. D., Esq., Prof., Sir, Ed, van, and, Jones, ba, John, Smith, Minnesota, de, St, Freiherr}, `{head}, {word}`, `Smith, {head} {word}`, `{word}, {head}`, `, {w1} {w2}` and `(Bob), {w1} {w2}` for every pair of those words, and 20,000 random head-plus-three-or-four-word draws (seed 626) -- 53,517 texts; each parsed under the three orders; a claim is a match of `(reads? as|joins) (<phrase>)` for the phrases `_FIELD_CLAIMS` in tests/v2/test_cases.py lists plus "the given name", and it is wrong when its tokens' roles are not among the fields the phrase names. On master (26cdb891) 2,725 of 89,092 claims were wrong, in three emitters: title-or-name's join clause (1,575), the trailing peel's picks (1,114) and the comma report (36); on the tree, 0. The comparator is master, which words the field at assign; the tree words it at assemble. Fingerprint against master over the differential corpora, master's case-table names and a seeded comma grid (13,090 names) under six policies (the three orders, `lenient_comma_suffixes=False`, a `/` suffix delimiter and `CapsSuffixes.OFF`): no role, kind, initials or rendering moves; the details that change are 6,395 comma reports on 1,086 names reworded from "the given name" to "a given name", 85 on 15 names now naming the family they land in, and 40 title-or-name join reports on 10 names now naming the family. Pinned by `test_a_report_names_the_field_its_word_lands_in` in tests/v2/test_cases.py, over every case row under all three orders except the locale rows (a row with its own policy only as declared), whose recorded control is 11 failures on master, and by `test_the_field_sweep_sees_the_claims_it_checks`, which records how many claims that sweep checks.
 
 ### A2 — the empty name
 
 
@@ -1,7 +1,8 @@
 """Not a stage: converts the final ParseState into a public ParsedName.
 
 Consumes: tokens (all roles set), dropped, ambiguities (by index;
-a report naming a field is worded from its word's final role, #626).
+one carrying ``field_tail`` is worded from its word's final role,
+#626).
 Produces: a validated ParsedName -- the constructor re-checks every
 invariant (span order/bounds, ambiguity subset), so a pipeline bug
 that would produce an invalid result dies HERE, not in a renderer
@@ -114,7 +115,13 @@ def assemble(state: ParseState) -> ParsedName:
                         for t in materialized)):
             continue
         detail = pending.detail
-        if pending.field_tail is not None and materialized:
+        if pending.field_tail is not None:
+            # A report naming a field, in a name emptied above (no
+            # emitter of one reaches that today: every referent is a
+            # name word): no field is left to name, so it goes rather
+            # than ship the sentence's first half.
+            if not materialized:
+                continue
             detail = (f"{detail}{FIELD_READING[materialized[0].role]}"
                       f"{pending.field_tail}")
         ambiguities.append(Ambiguity(pending.kind, detail, materialized))
 
@@ -363,9 +363,10 @@ def _assign_main(seg_idx: int, state: ParseState,
     #
     # Every bare ambiguous acronym the FINAL peel had to resolve is one
     # coin-flip each, in either direction, so the report collects
-    # rather than overwrites. Deferred to after assignment because the
-    # wording reads the role back, and which role "not peeled" means
-    # depends on name_order. (The roman-numeral fork needs no such
+    # rather than overwrites. Deferred to after assignment because what
+    # a pick is declined as depends on the role it took, and which role
+    # "not peeled" means depends on name_order; the field itself is
+    # worded by assemble (#626). (The roman-numeral fork needs no such
     # deferral and is reported here.)
     #
     # Read once in group, after P3's connective joins and ahead of the
@@ -456,8 +457,9 @@ def _assign_main(seg_idx: int, state: ParseState,
         # `suffix-or-name`" (history: decisions.md#H4) -- only the
         # word made into a name reports, and no name piece survived
         # the peel, so the carve-out above made the first post-nominal
-        # the name. Its field is worded by assemble, as every report
-        # naming one is: see the particle emitter below.
+        # the name. Its field is worded by assemble, as every assign
+        # report naming a field a later rule could change is: see the
+        # particle emitter below.
         if peeled.names == 0 and field_undecided:
             text = " ".join(tokens[i].text for i in head)
             ambiguities.append(PendingAmbiguity(
@@ -551,8 +553,9 @@ def _assign_main(seg_idx: int, state: ParseState,
             # the loops above read `order`, which is _effective_order's
             # answer and not necessarily name_order's (a script_orders
             # entry overrides it), and a later rule may still move the
-            # word -- P6's attachment, H1's swap -- as it did to every
-            # report worded here before #626 ('Kim Min Do' under
+            # word -- H1's move behind a title, P1's family-first fold,
+            # P6's attachment -- as it did to three of the reports
+            # worded at assign before #626 ('Kim Min Do' under
             # FAMILY_FIRST was told 'Do' was a middle name).
             token = tokens[head[0]]
             ambiguities.append(PendingAmbiguity(
@@ -853,11 +856,13 @@ def assign(state: ParseState) -> ParseState:
         if state.pieces[1] and len(state.pieces[1][0]) == 1:
             i = state.pieces[1][0][0]
             if not tokens[i].tags.isdisjoint(_AMBIGUOUS_CREDENTIAL_TAGS):
+                # the field is assemble's to word: with nothing before
+                # the comma and a title after the word, H1 moves it to
+                # the family (', Ma Dr.', #626's review)
                 ambiguities.append(PendingAmbiguity(
                     AmbiguityKind.SUFFIX_OR_NAME,
                     f"{tokens[i].text!r} after the comma is also an "
-                    f"ordinary name word; read as the given name",
-                    (i,)))
+                    f"ordinary name word; read as ", (i,), field_tail=""))
         # Segment 1 is read before segment 0's wholly-family pass. It
         # consumes piece tags and text only -- nothing segment 0's
         # read writes. (A title standing after the comma behind a whole
 
@@ -132,11 +132,13 @@ class PendingAmbiguity:
     after tokenize set ``indices`` directly and leave ``origin`` None.
 
     ``field_tail`` is for a report that names the field its word was
-    read into. A later stage may still move the word (P6's attachment,
-    H1's swap), so the emitter writes ``detail`` up to the field and
-    the rest of its sentence here, and assemble joins them around the
-    FIELD_READING of the first referent's final role -- the one place
-    that knows it (#626).
+    read into. post_rules may still move the word (H1's move behind a
+    title, P1's family-first fold, P6's attachment), so the emitter
+    writes ``detail`` up to the field and the rest of its sentence
+    here -- ``""`` where the field ends the sentence, which is why
+    assemble tests ``is not None`` -- and assemble joins them around
+    the FIELD_READING of the first referent's final role, the one
+    place that knows it (#626). Until then ``detail`` is a fragment.
     """
 
     kind: AmbiguityKind
@@ -152,6 +154,9 @@ class PendingAmbiguity:
     Role.MIDDLE: "a middle name", Role.FAMILY: "a family name",
     Role.SUFFIX: "a suffix", Role.NICKNAME: "a nickname",
     Role.MAIDEN: "a maiden name"})
+# every role a referent can hold, or a new one is a KeyError at the
+# first parse whose report lands in it
+assert FIELD_READING.keys() == set(Role)
 
 
 @dataclass(frozen=True, slots=True)
 
@@ -8233,11 +8233,29 @@ def _check_cjk_shape_purity(self) -> None:
          "Kim Min Do",
          {"given": "Kim", "middle": "Min", "family": "Do"},
          ambiguities=("suffix-or-name",), classification="fix(#289)",
-         notes="#626: under both family-first orders the order sweep "
-               "reads P6 attaching the Title-case 'Do' to the family "
-               "after assign read it as a name word ('Do Kim' under "
-               "FAMILY_FIRST); the report was worded at assign and "
-               "said 'middle'. 1.4.0 read suffix 'Do'"),
+         notes="#626: under FAMILY_FIRST the order sweep reads P6 "
+               "attaching the Title-case 'Do' to the family ('Do Kim') "
+               "after assign read it as a middle name; the report was "
+               "worded at assign and said 'middle'. Under "
+               "FAMILY_FIRST_GIVEN_LAST nothing moves it: given 'Do'. "
+               "1.4.0 read suffix 'Do'"),
+    Case("a_pick_the_family_first_fold_moves_is_reported_where_it_lands",
+         "de Kim Ma", {"family": "de Kim", "given": "Ma"},
+         ambiguities=("suffix-or-name",), classification="fix(#289)",
+         policy=Policy(name_order=FAMILY_FIRST),
+         notes="#626's review: P1's family-first fold takes the particle "
+               "run and one name unit, and lays the rest out by the "
+               "order, so 'Ma', which assign read as a middle name, "
+               "lands in the given name -- a third rule moving a "
+               "reported word after assign. 2.3.0 read suffix 'Ma'"),
+    Case("a_comma_report_h1_moves_is_reported_in_the_family",
+         ", Ma Dr.", {"title": "Dr.", "family": "Ma"},
+         ambiguities=("suffix-or-name",), classification="fix(#316)",
+         notes="#626's review: with nothing before the comma, the comma "
+               "report on 'Ma' was worded 'the given name' at assign, "
+               "and H1 then moved it to the family behind the trailing "
+               "title. The empty-head comma shape AGENTS.md's sweep "
+               "paragraph asks for; 1.4.0 read first 'Ma', suffix 'Dr.'"),
     Case("lone_joined_unit_carrying_collision_set_title_vocabulary",
          "Smith and King", {"given": "Smith and King"},
          ambiguities=("title-or-name",),