Scope the semicolon exemption to the sentence its list lives in

[ptr727]

Fixes #570.

The defect

scripts/prose_lint.py judged the semicolon exemption over the whole span, which for a Markdown bullet is the entire list item:

listish = span.count(';') > 1 or ':' in span.split(';')[0]
if listish and ',' in span:
    continue

A colon anywhere before the first semicolon therefore marked the whole bullet a list, and every semicolon later in it was exempt however plainly it joined two independent clauses. The colon and the semicolon did not have to be near each other, or related at all.

Measured over the 32 Markdown files in the gate's scope, the exemption was covering 62 spans holding 120 semicolons across 9 files while the rule reported 0 of them, reproducing the issue's figures exactly. That is the shape GOVERNANCE.md "Verification Discipline" names: a pattern that silently matches less still exits zero.

The fix

The sentence is the unit, because that is where a list lives. sentences() splits a span at its sentence boundaries and each one is judged on its own, so a genuine enumeration keeps its separators while an independent clause later in the same bullet is still examined.

The boundary reuses the run-on rule's guards, so an initial, an abbreviation, and a dotted identifier end nothing. It also accepts a terminator that closes inside emphasis or a bracket: reading a bare . left .** and .) joining a bullet's every sentence back into one span, which would have left the defect in place for exactly the bullets it appears in.

The colon arm was measured before being kept. The issue asked whether a colon should confer the exemption at all. Dropping it reported 14 further lines, and reading them, they are genuine colon-introduced lists whose items carry commas, which is the standard use GOVERNANCE.md names, for example Match the heading style: title case with short bind words (a, an, the, of); hyphenated compounds capitalize both parts. So the arm is scoped rather than removed.

Both spellings of the bullet-opener colon are now dropped. LABEL_COLON matched **Label**: only, so **Label:** still announced a list it never announced. One line tree-wide was affected, and it is a splice.

Verdict diff, old against new on the same tree

	before	after
semicolon findings, whole tree	20	64
Previously reported, now silent		0
Every other rule		byte-identical

The 44 newly reported sit in 33 lines across 7 files. Per GOVERNANCE.md, existing prose is corrected as each file is next edited rather than swept, and the issue itself asks that the exemption be fixed and proven before anything acts on the work list, so no prose is changed here. The measured list goes to #519.

Tests

Six cases added to TestSemicolon2, each one proving a decision rather than restating the code:

• a colon in an earlier sentence no longer exempts a later splice, the issue's own example
• a sentence closing inside emphasis or a bracket still ends, so .** and .) split
• a series in one sentence does not exempt the next
• a colon-introduced list whose items carry commas stays exempt, which is why the arm was kept
• - **D3:** and - **D3**: are one construct
• an abbreviation does not end a sentence, since splitting at e.g. would cut a list in half

All 253 script tests pass. markdownlint, editorconfig-checker, repo_gate.py, spec/validate.py and the diff-scoped prose gate are clean, and ruff reports nothing new against the pre-change baseline.

Two corrections found while auditing the surfaces that describe this gate

• OPERATIONS.md claimed DEFAULT_RULES omits comment-wrap and comment-case, which it has not since they were added. The real difference is the exit code, not the coverage.
• The TODO.md backlog figure read 534 against a measured 520 before this change, so it is refreshed to 559 with a note that a gate fix moves it as readily as a prose fix does.

Fleet effect

.github/actions/prose-gate reads prose_lint.py from hub develop for every non-main run, so once this merges, fleet PRs gate on the corrected rule against their changed lines immediately.

🤖 Generated with Claude Code

[Copilot]

Pull request overview

This PR fixes an accuracy hole in the Markdown semicolon prose gate by scoping the “list exemption” to the sentence that contains the potential list, rather than applying it across an entire bullet/list-item span. This restores the intended behavior where a colon-introduced list in one sentence does not silently exempt unrelated clause-joining semicolons later in the same bullet.

Changes:

• Update scripts/prose_lint.py to split Markdown spans into sentences (with Markdown-friendly sentence boundaries) and apply the list-exemption logic per sentence.
• Expand the bullet label-colon stripping to treat both **Label**: and **Label:** as the same opener, preventing false “list announcement” detection.
• Add targeted regression tests and update operational/docs text to reflect the corrected behavior and current gate semantics.

Reviewed changes

Copilot reviewed 5 out of 5 changed files in this pull request and generated no comments.

Show a summary per file

File	Description
TODO.md	Refreshes prose backlog metrics and adds a reference link for issue #570.
scripts/test_prose_lint.py	Adds regression tests covering sentence-scoped exemptions and both label-colon spellings.
scripts/README.md	Updates documentation of the semicolon rule to match the new sentence-scoped behavior and label-colon handling.
scripts/prose_lint.py	Implements sentence-level splitting for semicolon exemptions and broadens LABEL_COLON matching.
OPERATIONS.md	Corrects the description of DEFAULT_RULES vs CI invocation behavior and clarifies sentence-split invocation gaps.