@@ -9,3 +9,4 @@
 - 2026-10-18 (Derek), #718 — THE DECLINED NUMERAL REPORTS TOO, BOTH DIRECTIONS AS S4'S FORK DOES. The count's first form reported only the generation, so `John V` read family V in silence while `Jack Ma` reports keeping its family; Derek: report both, as `Jack Ma` does. A declined numeral is a pick of the walk, and its branches are taken in three places, so three sites report it (mechanisms.md#AMBIGUITY-AT-THE-DECISION-SITE): assign where it stays a lone name word (`John V` — "read as a family name rather than a generational suffix"), the particle chain where it joins the run (`Freiherr von Richthofen V`), and a maiden clause that keeps it as its last word (`John née Jones Smith V`, `abdul nee Smith V`). Each wording is its own, since the acronym pick's ("both a post-nominal and an ordinary name") misdescribes a numeral.
   ONE STAND-DOWN, FOUND BY INV10 rather than designed. In a one-case name the connective `i` reaches the fork as a letter classify has already reported as `conjunction-or-initial`, read as an initial, and the new report put a second report on the same token: 138 rows of the connective grid (measured on this branch with the `reported_as_initial` check out of assign's numeral report, a dated snapshot) in tests/v2/test_properties.py (`AND ROVIRA I`, `HENRY I`) tripped INV10's kind pair. The two reports did not contradict each other — both read the letter as a name word — but they named one reading twice, so the numeral's report stands down where the initial reading is already reported, the shape of rules/S7's "a member its own capitals already made the credential reports nothing new". The guard was left untouched: its kind pair still means "two readings" everywhere else, and narrowing it to suit this change would have retaken its recorded control. `HENRY I` therefore reports `conjunction-or-initial` alone, and moved in test_assemble's contrast list from the withdrawn side to the side where the fork resolved to a name word.
 - 2026-10-18, #718 review — THE COUNT IS NOT ASKED IN THE GIVEN PART AFTER A FAMILY COMMA. The code review's grid (family-comma and empty-head shapes behind a title-particle, about 558,000 parses) found 2,880 parses where the first form moved a numeral from the suffix into the given or family name with no report: `Smith, Freiherr von Berg V` read given 'von Berg V', `, Freiherr von V` family 'von V', `Smith, St van V` given 'van V', where `Smith, von V` and `Smith, Freiherr John V` kept suffix V. The cause was not a choice: assign's walk over that part never counts the numeral (rules/S4: the given part's trailing slot "is read without it (S5)"), but the particle chain's bound there asks `tail_reading`, which the count had reached, so the chain took a word assign would have read as the suffix. The bound now reads with the count off (`trailing_run_start`, `count_numeral=False`), and all four read as they did on master (2.2.0 onward, since #424; 1.4.0 read the numeral into the name). The class is the one the AGENTS.md gotcha on group-side predictors of the given part names, met from the other side: the predictor did not change, the peel it asks did. The S4 analogue, `Smith, Freiherr von Berg Ma` → given 'von Berg Ma', is master's reading and is left alone here.
+- 2026-10-18, #718's PR review — TWO OF THE THREE REPORT SITES ARE ONE, AND THE CLAUSE ASKS THE CASE. The test-coverage review mutated each new emitter out in a copy of the tree. Removing the particle chain's numeral report moved no field and no kind — assign's pick loop reported the same `suffix-or-name`, worded from the final role ('read as a family name') — so the chain's branch was only choosing a sentence, and it is gone: a declined numeral stays one of the read's picks, and assign alone reports it, the decision having been the read's and not the chain's. The maiden clause's stand-down on a letter already reported as an initial could not fire at all (classify reads no connective inside a clause), so that call is gone too. And the clause's report on a numeral its take gave up did not ask the case: `Jane Doe nee Smith vi` and `x` reported where every other path had gone silent, the drift mechanisms.md#ONE-PREDICATE-PER-QUESTION names; the take now asks `numeral_settled_by_case` as assign does, `VI` still reporting beside them. Five rows the first draft labelled `fix(#718)` read field for field as 1.4.0 does and are `parity`, as are the two Freiherr rows added here; a restored 1.4.0 reading is parity by the table's own definition (rules/S4's `bare_surname_is_not_a_credential` is the precedent).
@@ -51,6 +51,11 @@ S10. Rationale: a roman numeral ending a name is its generation,
       "john v"                    →  family=""
       "john smith v"              →  ambiguities=()
       "john i"                    →  family="i"
+      "john i"                    →  ambiguities=("conjunction-or-initial",)
+    Accepted: inside a maiden marker's clause the connective is not
+    read (M2), so a one-case `i` there is the suffix word the
+    vocabulary lists, as `v` is.
+      "john nee smith i"          →  suffix="i"
     Accepted: a numeral with another suffix word behind it is not
     the last word of the name and is read as any word there is, so a
     one-letter numeral before a credential is the family name.
 
@@ -59,7 +59,8 @@
 particle out of that position) -- whatever role name_order assigns --
 and, since #613, at P6's attachment after a family comma where the run
 holds an ambiguous particle ("Beethoven, Ludwig van").
-Emits SUFFIX_OR_NAME at these sites: the trailing roman numeral, each
+Emits SUFFIX_OR_NAME at these sites: the trailing roman numeral, taken
+or (since #718) declined for want of words to spare, each
 ambiguous acronym the trailing peel had to resolve, the bare-suffix
 carve-out where an input that is nothing but post-nominal vocabulary
 gets its first word made into the name (H4's suffix half, #491),
@@ -371,8 +372,9 @@ def _assign_main(seg_idx: int, state: ParseState,
     # 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.)
+    # worded by assemble (#626). (The roman-numeral fork's TAKEN branch
+    # needs no such deferral and is reported here; its declined branch
+    # is a pick, #718, and is reported with the others.)
     #
     # Read once in group, after P3's connective joins and ahead of the
     # particle chain, on a main segment of three or more pieces whose
 
@@ -70,8 +70,7 @@
     Peel, TailRead, chain_lead, chain_run_end, is_conj_piece, is_leading_title, is_prefix_piece,
     is_suffix_piece, is_title_piece, join_connectives, joined_tags,
     leading_titles, merge_particle_runs, merge_pieces, peel_walk,
-    read_trailing_run, reported_as_initial, tail_reading,
-    trailing_candidates,
+    read_trailing_run, tail_reading, trailing_candidates,
     trailing_run_start, trailing_start,
     trailing_start_past_titles,
 )
@@ -82,7 +81,7 @@
 import nameparser._pipeline._comma as _comma
 from nameparser._pipeline._vocab import D, PH
 from nameparser._pipeline._vocab import (
-    comma_follows_marker, delimiter_cores,
+    comma_follows_marker, delimiter_cores, numeral_settled_by_case,
 )
 from nameparser._types import AmbiguityKind, Role
 
@@ -333,9 +332,14 @@ def _maiden_take(pieces: Sequence[Sequence[int]],
         # -- the take consumed the run, so the forks the reading called
         # on it are reported here, where assign will never see them
         consumed = {i for j in range(end, len(pieces)) for i in pieces[j]}
-        for piece in (*vpeel.picks, *vpeel.absorbed,
-                      *(() if vpeel.numeral is None
-                        else (vpeel.numeral,))):
+        # rules/S10: "a numeral written in lower case in a name of mixed
+        # case is the generation and reports nothing" -- here as at
+        # assign's numeral report (#718's review)
+        numeral = (() if vpeel.numeral is None
+                   or numeral_settled_by_case(
+                       tokens[vpeel.numeral[0]].text, one_case)
+                   else (vpeel.numeral,))
+        for piece in (*vpeel.picks, *vpeel.absorbed, *numeral):
             if piece[0] in consumed:
                 ambiguities.append(PendingAmbiguity(
                     AmbiguityKind.SUFFIX_OR_NAME,
@@ -352,8 +356,7 @@ def _maiden_take(pieces: Sequence[Sequence[int]],
             f"{word.text!r} ending the maiden name is also a "
             f"post-nominal; the maiden marker's clause keeps it rather "
             f"than reading it as one", tuple(last)))
-    elif (tuple(last) in picked
-          and not reported_as_initial(ambiguities, last[0])):
+    elif tuple(last) in picked:
         # rules/S10: "either reading is reported" -- a numeral the read
         # declined for want of words to spare, which the clause keeps
         ambiguities.append(PendingAmbiguity(
@@ -1115,27 +1118,12 @@ def chain(tail: int) -> None:
                 # the given role the fold then moves ('Freiherr von
                 # Berg Ma' was told 'given name').
                 last = pieces[j - 1]
-                # ...and a numeral S2's read declined (rules/S10, #718),
-                # a pick with no credential tag: the read's picks are
-                # where it is recorded, and `tuple` is C-level, so a
-                # chained name still pays no frame
-                numeral = (j > k + 1 and len(last) == 1
-                           and read is not None
-                           and tuple(last) in read.peel.picks
-                           and tokens[last[0]].tags.isdisjoint(
-                               _AMBIGUOUS_CREDENTIAL_TAGS))
-                if numeral:
-                    if not reported_as_initial(ambiguities, last[0]):
-                        ambiguities.append(PendingAmbiguity(
-                        AmbiguityKind.SUFFIX_OR_NAME,
-                            f"{tokens[last[0]].text!r} is a roman "
-                            f"numeral, but the name has no other word to "
-                            f"spare for it; the particle chain took it "
-                            f"into the name rather than reading it as a "
-                            f"generational suffix",
-                            tuple(last)))
-                    took.add(tuple(last))
-                elif (j > k + 1 and len(last) == 1
+                # A numeral S2's read declined (rules/S10, #718) is not
+                # reported here: it stays one of the read's picks, and
+                # assign words it from the role it ends in ('Freiherr
+                # von Richthofen V', 'a family name'), the chain taking
+                # nothing the read had not already given up
+                if (j > k + 1 and len(last) == 1
                         and not tokens[last[0]].tags.isdisjoint(
                             _AMBIGUOUS_CREDENTIAL_TAGS)
                         and not is_prefix_piece(last, ptags[j - 1],
@@ -1275,9 +1263,10 @@ def chain(tail: int) -> None:
                 # before #614: the join tried on the pieces as it would
                 # leave them, the reading assign runs over each (the
                 # ONE function, _pieces.tail_reading), the suffixes
-                # compared as the peeled pieces themselves -- 'abdul V'
-                # peels the V unjoined and nothing joined, 'abdul Smith
-                # Ma' peels the acronym unjoined and keeps it joined.
+                # compared as the peeled pieces themselves -- 'abdul
+                # Smith V' peels the V unjoined and nothing joined (no
+                # word to spare there, rules/S10), 'abdul Smith Ma'
+                # peels the acronym unjoined and keeps it joined.
                 if read is not None:
                     same_suffixes = True
                     chained = False
 
@@ -1364,9 +1364,10 @@ def particle_tail(seg: Sequence[Sequence[int]],
 
 
 # rules/S10: "a letter already reported as read as an initial reports
-# nothing new" -- the one question the numeral fork's three declined-
-# pick emitters (assign's, the particle chain's and the maiden
-# clause's, #718) all ask, so it has one answer
+# nothing new" -- asked by assign's report of the numeral fork's
+# declined pick (#718). The maiden clause's report on the numeral it
+# keeps cannot meet the case: classify reads no connective inside a
+# clause, so a clause word never carries that report
 def reported_as_initial(ambiguities: Iterable[PendingAmbiguity],
                         index: int) -> bool:
     """Whether classify's connective-or-initial fork already reported
 
@@ -254,14 +254,16 @@ def is_initial_shaped(text: str) -> bool:
 
 # rules/S10: "A roman numeral ending a name written without a comma
 # reads as the generation" -- which the initial veto would otherwise
-# take: V, I and X are suffix vocabulary AND bare capitals, and a bare
-# capital inside a name is a middle initial. Whether a one-letter
+# take: V and I are suffix vocabulary, X a numeral by shape alone, and
+# all three are bare capitals, which inside a name are middle initials. Whether a one-letter
 # numeral has the words to spare is the caller's count (`peel_trailing`).
 def is_trailing_numeral_suffix(text: str, preceding: str) -> bool:
     """assign's roman-numeral fork, shared with group's bound-given
     reserve (#401): a FINAL single-token piece that is a roman numeral
     reads as the suffix when the piece before it does not look like
-    part of an initial run. `preceding` is that piece's first token;
+    part of an initial run -- for a one-letter numeral a necessary
+    condition only, the caller's words-to-spare count deciding
+    (rules/S10, #718). `preceding` is that piece's first token;
     the callers establish that `text` is last and that a name piece
     precedes it.