RubyGems - sloplint - Versions diffs - 0.6.0 → 0.7.0 - Mend

sloplint 0.6.0 → 0.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d0d26e3bebafd7184f09aa41f70d1013e8ca6d9f460d4e0229815c18db08263a
-  data.tar.gz: 944923cfab5a213d08a5367bae1dfd75fb4fc71aa9a004fbb59806b5dace1376
+  metadata.gz: 33eff57c67530d0745b1ba5009a97128929a73ec27ae09afaba8d9057f0f997b
+  data.tar.gz: 3b76104840a3c2ab471651cbdf18dd4a9027707aaf100bc901430c7f9e121216
 SHA512:
-  metadata.gz: 19ad341fcb7a415b737bc4e1fdd3f355d4b6bd91429209477b4ac4605a2f18b7372bf1791e34e9e0e69b6d50b17a02abf959981b7bd32b5345a30ebc3151cb87
-  data.tar.gz: 9f0732fe535cc7753ed2b8380687575c4b109b5f9be31409e1d207c9ccb3b7ffbcb69a833427e68bb73c905369b47dd920ce7dd7162e456a61dd7a07c468c853
+  metadata.gz: 4d1a47eae97395fa37dd1fa50b9a4894ccae70064d15542abdce0197cf715956d23c6ba75bee7bb4f56bc6ada8986485aff5bb1e06c9ecbb1ac6b763705588e1
+  data.tar.gz: cb1ba2ed058855336b71bdc6e10a743e021a5d5d85e0207b8e0564b0fcd9076c9c45eb021eee6fc15a4eac92709b3440ebb6e1487da3c8981853ff37ebd01419

data/CHANGELOG.md CHANGED Viewed

@@ -3,6 +3,72 @@
 All notable changes to this project are documented here. Format loosely
 follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
+## [0.7.0] - 2026-09-15
+### Added
+- `--strict` runs the full catalog, including the five rules that ship off
+  by default. Before this, the only way to turn one on was to name it in
+  `--select`, which also turned off every other rule unless you listed
+  those too. `--ignore` still subtracts on top of `--strict`, and
+  `--select` is unchanged.
+- `ellipsis-closer` (structure, info) flags the long-sentence-then-short-closer
+  kicker `mic-drop-closer` catches, but built on the opposite verb shape: the
+  closer's verb phrase is elided down to a bare auxiliary with no object,
+  "The agent did." rather than a quantifier plus a full verb. No subject list
+  is needed — the tell is the missing verb, not the subject — so "That",
+  "This" and "It" are not excluded the way `mic-drop-closer` excludes them.
+  A negative lookahead drops a closer that still holds a wh-word, since that
+  marks a subordinate clause with its own complement rather than an elided
+  one. Reuses `mic-drop-closer`'s long-sentence prefix.
+- `actually-not-x`: the adverb and a trailing "…, not X" in one clause, as in
+  "The disclosure actually covered two incidents, not one". Either marker
+  alone is ordinary technical English and neither is matched on its own; the
+  tell is the two of them doubled up, correcting an alternative the reader was
+  never offered. The narrowing is structural, not a word list: the comma in
+  front of "not" has to be the first comma of its clause and has to follow a
+  word, so a fronted setup ("Despite the name, …") and a parenthetical both
+  drop it. Nothing crosses a line break, so two rows of a table cannot weld
+  into one correction.
+- `real-x-real-y` (rhetorical-tic, info) flags the same "real" used twice
+  attributively in one sentence, in front of two different nouns: "it can
+  trigger real API calls or hold real credentials". Bare "real" is an
+  ordinary word, so the narrowing is the repetition itself, not a noun
+  list. A hyphen on either side takes it out ("real-time", "non-real"), a
+  backreference requires the second noun to differ from the first, and a
+  short closed list drops the fixed senses of this register (real time,
+  real-world, real numbers, real user monitoring, real estate, real money).
+- `phrase-echo` (rhetorical-tic, info, off by default) flags a three-word
+  phrase that comes back within a few hundred words, the model reusing a
+  phrase it has just minted. Each word must be four characters or more and
+  lowercase-led, and one of them six letters with nothing but letters, so "in
+  order to", "couldn't have been" and "New York City" never match. The window
+  does not cross into a list item or a table row. Off by default: a term of
+  art repeats because it must, and in reference prose the pattern fires on
+  names by the thousand per million words.
+- `trailing-restatement` (structure, info, off by default) flags the tail
+  that says the sentence again in other words: ", which means …", ", which
+  is to say …", ", meaning …", and four participles that hang a result off
+  the sentence (", making it easier", ", allowing us to", ", giving them
+  more", ", leaving you with"). The connective is all a pattern can see, and the
+  same connective states a real consequence in careful prose, so the rule
+  runs only when selected.
+### Fixed
+- `check`'s options now work without the command word: `sloplint --markdown -`
+  and `sloplint --strict -` scan, as the README has said `sloplint -` does.
+  Before, the global parser rejected any option it did not own with
+  `invalid option`, so `check` had to be spelled out whenever an option
+  came first. An option no command knows still exits 2.
+- `--markdown` now blanks `<!-- -->` comment blocks along with fenced code,
+  inline code and URLs. Planning notes kept in comments never render, so
+  every rule that fired inside one was a permanent false positive.
+- `rule-of-three`'s message, rationale, README and SPEC entries said it
+  flagged three parallel comma items. The pattern requires single words in
+  the closing two slots, so a triad of phrases never matched; the text now
+  says that.
 ## [0.6.0] - 2026-09-08
 The catalog grows from 50 rules to 75, and sloplint ships as a Claude Code

data/README.md CHANGED Viewed

@@ -60,7 +60,7 @@ The recipe sloplint is built around, and the one an agent should use:
 cat draft.md | sloplint check --markdown -o json -
 ```
-`--markdown` blanks out code and URLs first, `-o json` emits the machine-readable form, and `-` reads stdin. Exit 0 means clean, 1 means notes found, anything higher is an error. `check` is the default command, so `sloplint draft.md`, `sloplint -`, and a bare `sloplint` with piped stdin all scan.
+`--markdown` blanks out code, HTML comments, and URLs first, `-o json` emits the machine-readable form, and `-` reads stdin. Exit 0 means clean, 1 means notes found, anything higher is an error. `check` is the default command, so `sloplint draft.md`, `sloplint -`, and a bare `sloplint` with piped stdin all scan.
 The human-readable form drops `-o json`:
@@ -98,9 +98,10 @@ version      print the sloplint version
 `check` takes files as arguments, or `-` (or nothing) to read stdin, and these options:
-- `--markdown` skips fenced code, inline code, and URLs before scanning. Off by default so it never silently eats prose.
+- `--markdown` skips fenced code, inline code, HTML comments, and URLs before scanning. Off by default so it never silently eats prose.
 - `--select IDS` runs only these rules. Accepts comma-separated rule ids or category names.
 - `--ignore IDS` skips these rules. Same id-or-category form.
+- `--strict` runs every rule, including the five that are off by default. `--ignore` still applies on top.
 `explain` is the command an agent calls to decide whether a flag is worth acting on:
@@ -154,11 +155,11 @@ An unknown id or category in `--select`/`--ignore` is a usage error (exit 2, nam
 ## The rule catalog
-75 rules across four categories. `sloplint rules` prints them; `sloplint rules --json` gives an agent the enumerable form.
+80 rules across four categories. `sloplint rules` prints them; `sloplint rules --json` gives an agent the enumerable form.
-- **rhetorical-tic** (53) the cadence patterns: `no-x-no-y`, `no-x-no-y-frag`, `from-x-to-y-chain` ("from guessing to measuring, from hoping to knowing"), `one-x-one-y` ("one reviewer, one queue, one deadline"), `same-determiner-chain` (any other repeated determiner, at `info`), `and-what-it-should` (the elliptical tail: "…, and what it should."), `abstract-lives-in` ("the value sits in the follow-up", at `info`), `the-x-is-the-x` ("the problem with A is the problem with B"), `bare-equative` ("The lesson is the handoff.", at `info`), `thats-the-whole`, `is-the-whole-x` (the same closer on any subject: "Consistency is the real test.", at `info`), `thats-how-x`, `announced-takeaway`, `exact-exactly`, `load-bearing`, `intersection-of`, `you-already-know`, `sit-with-that`, `hold-onto-that`, `cleanly`, `clean-count`, `cleanest-x`, `clean-x`, `not-nothing`, `is-is` (doubled copula), `if-im-being-honest` (the candor preamble, from slopwash.com's "false intimacy"), `and-nothing-else` (the trailing "…, and nothing else"), `honestly`, `honest-x`, `most-honest-x` (the honesty family, built the same way as the four `clean` rules above), `impact-verb` ("the outage impacted four thousand accounts"), `impact-noun-bare` ("the impact of X", at `info` because research prose uses it straight), and more.
+- **rhetorical-tic** (56) the cadence patterns: `no-x-no-y`, `no-x-no-y-frag`, `from-x-to-y-chain` ("from guessing to measuring, from hoping to knowing"), `one-x-one-y` ("one reviewer, one queue, one deadline"), `same-determiner-chain` (any other repeated determiner, at `info`), `and-what-it-should` (the elliptical tail: "…, and what it should."), `abstract-lives-in` ("the value sits in the follow-up", at `info`), `the-x-is-the-x` ("the problem with A is the problem with B"), `bare-equative` ("The lesson is the handoff.", at `info`), `thats-the-whole`, `is-the-whole-x` (the same closer on any subject: "Consistency is the real test.", at `info`), `thats-how-x`, `announced-takeaway`, `exact-exactly`, `load-bearing`, `intersection-of`, `you-already-know`, `sit-with-that`, `hold-onto-that`, `cleanly`, `clean-count`, `cleanest-x`, `clean-x`, `not-nothing`, `is-is` (doubled copula), `if-im-being-honest` (the candor preamble, from slopwash.com's "false intimacy"), `and-nothing-else` (the trailing "…, and nothing else"), `honestly`, `honest-x`, `most-honest-x` (the honesty family, built the same way as the four `clean` rules above), `impact-verb` ("the outage impacted four thousand accounts"), `impact-noun-bare` ("the impact of X", at `info` because research prose uses it straight), and more.
 - **puffery** (6) five from Wikipedia's "signs of AI writing" — `puffery-words` (vibrant, nestled, groundbreaking, in the heart of), `rich-tapestry`, `vital-role`, `stands-serves-as`, `underscores-highlights` — plus `impact-noun-vague` ("a significant impact", "make an impact").
-- **structure** (15) `everyone-nobody` (the comma-spliced antithesis: "Everyone wants the dashboard, nobody maintains it."), `np-fragment-and` (the verbless "A named owner and a quarterly review.", at `info`), `quip-question` (the verbless "No invite?", at `info`), `mic-drop-closer` (the short quantifier-led sentence that ends a paragraph after a long one, at `info`; a draft full of them is a warning), `short-run` (three sentences of thirty characters or fewer in a row, at `info`, same caveat), `not-just-x-but-y`, `not-x-but-y` (the bare corrective), `isnt-x-its-y` (the same corrective split across two clauses: "It isn't the tool. It's the habit."), `not-by-x-but-by-y` (the corrective on a repeated preposition: "not by luck, but by design"), `em-dash` (any em dash), `em-dash-overuse` (three or more in one paragraph), `question-isnt` (the corrective frame in interrogative dress), `less-about-more-about`, `trailing-significance-participle` (the "…, showcasing its importance" clause), and `rule-of-three`.
+- **structure** (17) `everyone-nobody` (the comma-spliced antithesis: "Everyone wants the dashboard, nobody maintains it."), `np-fragment-and` (the verbless "A named owner and a quarterly review.", at `info`), `quip-question` (the verbless "No invite?", at `info`), `mic-drop-closer` (the short quantifier-led sentence that ends a paragraph after a long one, at `info`; a draft full of them is a warning), `ellipsis-closer` (the same shape, but the closer's verb is elided down to a bare auxiliary: "The agent did.", at `info`), `short-run` (three sentences of thirty characters or fewer in a row, at `info`, same caveat), `not-just-x-but-y`, `not-x-but-y` (the bare corrective), `isnt-x-its-y` (the same corrective split across two clauses: "It isn't the tool. It's the habit."), `not-by-x-but-by-y` (the corrective on a repeated preposition: "not by luck, but by design"), `em-dash` (any em dash), `em-dash-overuse` (three or more in one paragraph), `question-isnt` (the corrective frame in interrogative dress), `less-about-more-about`, `trailing-significance-participle` (the "…, showcasing its importance" clause), `trailing-restatement` (the "…, which means …" tail that says the sentence again, off by default), and `rule-of-three`.
 - **hedging** (1) `vague-attribution`: "some critics argue," "it is widely regarded."
 Severity is `warning` for strong tells, `info` for weak or contextual ones. No rule currently ships at `error`; the tier is reserved for a pattern with essentially zero false-positive risk, and none has earned that yet.
@@ -167,11 +168,11 @@ Some tells come in a confident form and an ambiguous one, and those ship as a pa
 `and-nothing-else` and `nothing-else-frag` are a pair of the same shape, but both ship at `warning`. That is a deliberate exception: the fragment half carries a capital letter and a whole-sentence requirement that the comma half has no equivalent of, so it is the *narrower* of the two rather than the quieter one.
-Three rules ship **off by default**, and they run only when you name them: `sloplint check --select rule-of-three -`. `rule-of-three` flags three parallel comma items closing a sentence, which humans do all the time. `genuinely` flags every occurrence of the word; as an intensifier it rates the writer's sincerity, but it still does real work when it draws a contrast, and nothing in the sentence separates the two. `epistrophe` flags two clauses ending on the same phrase, a named figure that careful writers use on purpose and that, on Hacker News, is mostly plain phrase reuse.
+Five rules ship **off by default**. They run when you name them — `sloplint check --select rule-of-three -` — or when you pass `--strict`, which turns the whole catalog on. `rule-of-three` flags three single words in a comma series closing a sentence, which humans do all the time; the closing two items must be single words, so a triad of phrases does not match, because a regex cannot tell one from an ordinary list. `genuinely` flags every occurrence of the word; as an intensifier it rates the writer's sincerity, but it still does real work when it draws a contrast, and nothing in the sentence separates the two. `epistrophe` flags two clauses ending on the same phrase, a named figure that careful writers use on purpose and that, on Hacker News, is mostly plain phrase reuse. `trailing-restatement` flags the "…, which means …" tail and the participles that hang a result off the sentence ("…, making it easier"); the connective is visible and the restatement is not, so a real consequence flags the same way. `phrase-echo` flags a three-word phrase that comes back within a few hundred words; a term of art comes back because it must, and the pattern cannot tell one from a phrase the writer coined.
 ### Markdown handling
-`--markdown` replaces fenced code, inline code, and URLs with same-length whitespace before scanning, so line and column stay correct. Without it, sloplint treats the whole file as prose and will flag text inside your code fences. Pass `--markdown` whenever the input is Markdown.
+`--markdown` replaces fenced code, inline code, HTML comments, and URLs with same-length whitespace before scanning, so line and column stay correct. Without it, sloplint treats the whole file as prose and will flag text inside your code fences. Pass `--markdown` whenever the input is Markdown.
 ## Adding a rule

data/docs/SPEC.md CHANGED Viewed

@@ -138,9 +138,10 @@ global options:
 check options:
   paths ...            files to scan; "-" or no paths reads stdin
-  --markdown           skip fenced/inline code spans
+  --markdown           skip fenced/inline code spans, HTML comments, and URLs
   --select IDS         only run these rules (comma-separated ids or categories)
   --ignore IDS         skip these rules
+  --strict             run every rule, including the off-by-default ones
 ```
 `check` is the default command. A first argument that is not a command name is
@@ -165,7 +166,7 @@ Three codes carry the contract. A crash just exits nonzero on its own.
 Empty or whitespace-only input is exit 2, like a mistyped rule id: a scan of
 nothing must not report as a clean scan. The text is tested before
-`--markdown` blanks code and URLs, so a file that holds only a fenced code
+`--markdown` blanks code, HTML comments, and URLs, so a file that holds only a fenced code
 block still exits 0. Only when every source is empty.
 ## Note (the diagnostic object)
@@ -262,7 +263,7 @@ Categories (for `--select`/`--ignore` by group):
 - `rhetorical-tic` — the cadence patterns (the user's list below)
 - `puffery` — Wikipedia "words to watch" (boasts, vibrant, nestled, tapestry…)
-- `structure` — rule-of-three, "not just X but Y", "the question isn't X, it's Y", "less about X more about Y", the trailing significance participle, em dash, em-dash overuse
+- `structure` — rule-of-three, "not just X but Y", "the question isn't X, it's Y", "less about X more about Y", the trailing significance participle, the trailing restatement, em dash, em-dash overuse
 - `hedging` — vague attribution ("some critics argue", "it is widely regarded")
 Severities: `warning` for strong tells, `info` for weak/contextual ones. No
@@ -298,6 +299,7 @@ false-positive risk, which none has demonstrated.
 | `is-the-entire` | "X is the entire point/game/business model" | |
 | `the-entire-is` | "the entire point/game/… is" (flip of above) | |
 | `is-real-and-not` | "the X is real, and/not…", "is the real … and it" | skip "real estate/time"; `info` |
+| `real-x-real-y` | the same "real" used twice attributively in one sentence, in front of two different nouns: "real API calls … real credentials" | needs no noun list -- narrowed by requiring two attributive uses of the intensifier naming two different things; a hyphen on either side of "real" (real-time, non-real) takes it out of the running; a closed list drops the fixed senses (real time, real-world, real numbers/roots, real user (monitoring), real estate, real money) and the function words that continue a predicative "is real" |
 | `the-punchline-is` | "the punchline is/:/?", "the honest answer/version is" | "short version" left out; ordinary writing |
 | `worth-naming` | "worth naming/flagging/separating/spelling out" | skip "naming names"; yields to the rule below when a manner adverb follows; `info` |
 | `worth-saying-plainly` | "it's worth saying plainly / better put bluntly…", plus the bare "Put plainly," / "Said bluntly," | sentence-initial; the bare branch drops "simply"/"clearly" so "put simply" and "simply put" stay clean |
@@ -323,7 +325,9 @@ false-positive risk, which none has demonstrated.
 | `honest-x` | "an honest comparison", "the honest framing" | short noun list; "answer", "assessment", "account" excluded as ordinary; superlative yielded to the rule below |
 | `most-honest-x` | "the most honest framing", "the most honest way to put it" | wider noun list than `honest-x`; no human nouns, so "the most honest person" stays out |
 | `genuinely` | any "genuinely" | off by default; no narrowing holds |
+| `actually-not-x` | "actually" and a trailing "…, not X" in one clause | the comma before "not" must be the first comma of the clause and must follow a word, so a fronted setup ("Despite the name, …") and a parenthetical both drop it; never crosses a line break; bare "actually" and "not actually" both left out |
 | `epistrophe` | two clauses ending on the same two-word phrase, the second closing the sentence | two backreferences, so the phrase may be hard-wrapped; no article-led phrase, second word 4+ letters, second clause 5–60 chars with no internal punctuation and capped whitespace; off by default; `info` |
+| `phrase-echo` | the same three words again within about 400 words | backreference in a lookahead, so the match is the first occurrence; each word 4+ characters and lowercase-led, one of them 6+ letters with nothing but letters, so function-word runs, contractions, proper nouns and Title Case headings are out; a repeat that opens on a quote mark, backtick, emphasis marker or hyphen is out; the gap crosses paragraph breaks but not a list item, a table row or 80+ non-word characters; off by default; `info` |
 | `and-thats-fine` | "And that's fine/okay." as a whole sentence | "and" required; must open and close the sentence |
 | `and-nothing-else` | trailing ", and nothing else/more/further", ", and no more" | tail must close the sentence; comma required; bare "no more" needs "and"; "?" excluded |
 | `nothing-else-frag` | the same exclusion as a fragment: "Nothing else." | sentence-initial capital; semicolon excluded; must be the whole sentence; "No more." left out |
@@ -350,11 +354,13 @@ Single flat rule per word-cluster, matched as whole words:
 - `np-fragment-and` — a whole sentence made of two noun phrases and an "and", opening on A/An/One at a sentence start or after a list marker ("A named owner and a quarterly review."). One to three words a side, no auxiliary or modal anywhere (contractions included); a lexical verb is invisible, so "A car and a truck collided." flags, which is why it ships at `info`.
 - `quip-question` — the verbless opening question ("No invite?", "New to the tool?", "Still stuck?"): sentence-initial, one of a short list of opening words, one to four more words, no auxiliary or contraction, closing on the question mark; "Need" and "Want" are left out as elided verbs; `info`, because people ask the same shape in conversation.
 - `mic-drop-closer` — a sentence of 60+ characters, then a paragraph-final closer of two to eight words opening on a **quantifier** (Nothing, Most, None, Everything, Everyone, Nobody, Then, Neither, Both): "Nothing here needs a new login."; `info`. The bare demonstratives (That, This, It) were in the list and are out: procedural writing ends a step with one as a matter of course ("This completes the roughing operations."). A blank line or the end of the text must follow the closer; both sentences may be hard-wrapped; whitespace runs in the long sentence are capped so blanked Markdown cannot make it, and the long-sentence prefix is an atomic group so an unpunctuated stretch cannot send it into catastrophic backtracking. The note points at the closer. One means nothing; a draft where it repeats is the tell.
+- `ellipsis-closer` — the same long-sentence-then-short-closer shape as `mic-drop-closer`, but the tell sits in the verb rather than the subject: the closer's verb phrase is elided down to a bare auxiliary with no object, "The agent did."; `info`. No subject list is needed — a one-to-three word subject runs straight into a bare `did/does/do/was/were/is/are/had/has/can/could/would/will/should/might/must` (contracted forms included) and a period, and the closer must be the last thing in the paragraph, same as `mic-drop-closer`, so a closing quotation mark after the period excludes quoted dialogue the same way `short-run` excludes it. A negative lookahead drops a closer that still holds "what", "that", "which", "who", "why" or "how", since those introduce a subordinate clause supplying its own complement rather than an elided one ("Nobody knew who did." asks who did it). Reuses `mic-drop-closer`'s long-sentence prefix rather than a second copy of it. One means nothing; a draft where it repeats is the tell.
 - `short-run` — three consecutive sentences of thirty characters or fewer, each letter-led and closing on a full stop, no quotation marks or digits, no lone-letter labels (either case, though a possessive is not one) or abbreviations, starting at a real sentence boundary (never on a wrap continuation), crossing a hard wrap but not a paragraph break; `info`. A list marker may open a run but never sit inside one, so consecutive bullets are a list — the marker set covers glyphs, the literal "o" plain-text documents use as a bullet, and numbered and lettered items. Two whole-run exclusions keep document furniture out, each a property of the run rather than of any sentence in it: three single-word sentences in a row is a citation line ("Natl. Inst. Stand. Technol."), and three lowercase-led sentences in a row is transcribed speech ("we all get gas. we go to divert to Albany."). One single-word sentence is the archetypal kicker and stays, and a run that reaches a capital anywhere is prose, so identifier-initial writing ("npm was slow. git blame helped. We moved on.") is untouched. One is a question; a draft that repeats it is the tell.
 - `question-isnt` — "the question isn't/is not (whether|if|how|what|why|who) X, it's/but Y"; `info`. The resolving clause is required, so a plain rhetorical question never matches; "the real question is" is excluded.
 - `less-about-more-about` — "it's/this is/that's less about X (and) more about Y", also "… than about Y"; `info`. Both halves of the frame are required, and the subject slot is limited to the pronouns.
 - `trailing-significance-participle` — comma plus a participle from a closed verb list (highlighting, showcasing, reinforcing, shaping, enhancing, cementing, solidifying, embodying, fostering, facilitating, signalling), the clause a model hangs off a sentence to say what a fact means. Guards drop gerund lists and "signalling to". `driving`, `representing`, `reflecting`, `marking`, `contributing`, `illustrating`, `demonstrating`, `emphasising`, `echoing` and `affirming` stay out: humans write them in the same position, usually with a person as the subject, and the pattern cannot see the subject. `underscoring` is left to `underscores-highlights`.
-- `rule-of-three` — three parallel comma items ending a sentence (heuristic; `info` severity, off by default via `--select` since it false-positives).
+- `trailing-restatement` — comma plus "which means", "which is to say", or "meaning" opening on one of a closed set of determiners and pronouns; or one of four participle frames with a pronoun object and a closing word ("making it easier", "allowing us to", "giving them more", "leaving you with"). The closer on "making" is a comparative that ends the clause or leads into "to", "for" or "than". Nothing before the comma is inspected, so a gloss ("_ma_, which means hand") matches; the bare participles ("leaving the door open") never do. Off by default: the pattern sees the connective, not whether the tail restates the head. `info`.
+- `rule-of-three` — three single-word comma items ending a sentence (heuristic; `info` severity, off by default; runs under `--select` or `--strict` since it false-positives).
 - `em-dash` — any em dash; `info`.
 - `em-dash-overuse` — 3+ em dashes in one paragraph; `warning`.
@@ -364,8 +370,8 @@ Single flat rule per word-cluster, matched as whole words:
 ## Markdown handling
-`--markdown` blanks out fenced code (```` ``` ````), inline code (`` ` ``), and
-URLs before scanning, replacing them with same-length whitespace so line/column
+`--markdown` blanks out fenced code (```` ``` ````), inline code (`` ` ``), HTML
+comments (`<!-- -->`), and URLs before scanning, replacing them with same-length whitespace so line/column
 stay correct. Off by default (plain-text mode) so it never silently eats prose.
 ## Agent-first help text

data/lib/sloplint/cli.rb CHANGED Viewed

@@ -19,7 +19,14 @@ module Sloplint
       opts = { format: "full" }
       parser = global_parser(opts, out:)
       # Split global options from the subcommand and its args.
-      parser.order!(argv)
+      begin
+        parser.order!(argv)
+      rescue OptionParser::InvalidOption => e
+        # `check` is the default command, so its options are accepted before
+        # any command word: `sloplint --markdown -`. The global parser does not
+        # know them, so put the option back and let check's parser judge it.
+        argv.unshift("check", *e.args)
+      end
       return 0 if opts[:help_shown] || opts[:version_shown]
       command = argv.shift
@@ -46,15 +53,17 @@ module Sloplint
     # ── check ───────────────────────────────────────────────────────────────
     def cmd_check(argv, opts, out:, err:, stdin:)
       markdown = false
+      strict = false
       select = nil
       ignore = nil
       p = OptionParser.new do |o|
         o.banner = "usage: sloplint check [options] [paths...]  (\"-\" or no paths = stdin)"
         o.on("-o", "--output-format FORMAT", %w[full json],
              "Output format: 'full' or 'json' (may also be given before the command).") { |v| opts[:format] = v }
-        o.on("--markdown", "Skip fenced/inline code spans and URLs before scanning.") { markdown = true }
+        o.on("--markdown", "Skip fenced/inline code spans, HTML comments, and URLs before scanning.") { markdown = true }
         o.on("--select IDS", "Only run these rules (comma-separated rule ids or category names).") { |v| select = v.split(",").map(&:strip) }
         o.on("--ignore IDS", "Skip these rules (comma-separated rule ids or category names).") { |v| ignore = v.split(",").map(&:strip) }
+        o.on("--strict", "Run every rule, including the ones that are off by default.") { strict = true }
       end
       p.order!(argv)
@@ -65,7 +74,7 @@ module Sloplint
         return 2
       end
-      rules = select_rules(select, ignore)
+      rules = select_rules(select, ignore, strict)
       paths = argv.empty? ? ["-"] : argv
       by_path = paths.reject { |x| x == "-" }.size > 1
@@ -190,9 +199,11 @@ module Sloplint
     # --select/--ignore accept rule ids or category names. Default set excludes
     # default_on:false rules unless they are explicitly selected.
-    def select_rules(select, ignore)
+    def select_rules(select, ignore, strict = false)
       rules = if select
         RULES.select { |r| select.include?(r.id) || select.include?(r.category) }
+      elsif strict
+        RULES
       else
         RULES.select(&:default_on)
       end

data/lib/sloplint/engine.rb CHANGED Viewed

@@ -14,7 +14,7 @@ module Sloplint
     module_function
-    # text: the source. rules: which Rule objects to run. markdown: blank code/URLs first.
+    # text: the source. rules: which Rule objects to run. markdown: blank code, HTML comments and URLs first.
     # path: label carried into each Note (e.g. filename or "-" for stdin).
     def scan(text, rules: RULES, markdown: false, path: "-")
       source = text
@@ -95,14 +95,13 @@ module Sloplint
       starts
     end
-    # Replace fenced code, inline code, and URLs with same-length whitespace so
-    # line/column stay correct. Newlines are preserved.
+    # Replace fenced code, HTML comments, inline code, and URLs with same-length
+    # whitespace so line/column stay correct. Newlines are preserved. One pass
+    # with one alternation, so whichever construct opens first is the one that
+    # gets consumed: a `<!--` quoted inside backticks is inline code, and a
+    # backtick inside a comment is part of the comment.
     def blank_markdown(text)
-      blank = lambda { |s| s.gsub(/[^\n]/, " ") }
-      text
-        .gsub(/```.*?```/m) { |s| blank.call(s) }   # fenced code
-        .gsub(/`[^`\n]*`/) { |s| blank.call(s) }    # inline code
-        .gsub(%r{https?://\S+}) { |s| blank.call(s) } # bare URLs
+      text.gsub(/```.*?```|<!--.*?-->|`[^`\n]*`|https?:\/\/\S+/m) { |s| s.gsub(/[^\n]/, " ") }
     end
   end
 end

data/lib/sloplint/rules.rb CHANGED Viewed

@@ -53,6 +53,35 @@ module Sloplint
   # letter is a letter.
   WHOLE_CLOSERS = /point|game|thing|deal|story|ballgame|ball#{WRAP_GAP}+game|(?:value|fix)(?=[^[:word:][:space:]'’-]|#{WRAP_GAP}+(?:[^[:word:][:space:]*_`"'‘“(\[{~]|\d+[.)][ \t])|#{WRAP_GAP}*(?:\z|#{PARA_BREAK}|(?:of|to|for|in|on|at|with|here|there|behind|right|though|now|anyway|really|from|over|after|and|but|so|as|that|which|if|when|because|since|unless|until|once|while|where|i|we|you|he|she|it|they|the|a|an|this|these|those|every|any|my|our|your|his|her|their|its)\b))/i
+  # Nouns that only ever name the writer's own construction -- never a
+  # concrete object, a person, or an idiom -- and that all four of
+  # clean-x, cleanest-x, honest-x and most-honest-x already matched before
+  # this constant existed. "comparison" and "through-line" read the same way
+  # but are each missing from one rule's original list (clean-x never had
+  # "comparison", cleanest-x never had "through-line"), so both stay out of
+  # this constant and inline in the three rules that carry them -- putting
+  # either one here would add a match the fourth rule never had.
+  WRITERS_OWN_CONSTRUCTION_NOUNS = "framing|formulation|mapping|abstraction"
+  # A sentence of at least sixty characters, ending in sentence-ending
+  # punctuation followed by one or two spaces -- the setup mic-drop-closer's
+  # kicker needs before it looks for the closer. The atomic group (?>...) is
+  # load-bearing against catastrophic backtracking; see the comment on
+  # mic-drop-closer's pattern for the incident that made it necessary.
+  SENTENCE_OF_SIXTY_CHARACTERS_ENDING_IN_PUNCTUATION_AND_SPACE =
+    /(?:^|(?<=[.!?])[ \t]{1,2})(?>(?:[^.!?\n\s]|(?<![ \t])[ \t]{1,2}(?![ \t])|\r?\n(?!\s*\n)[ \t]*){60,})[.!?][ \t]{1,2}/
+  # real-x-real-y interpolates this fragment after each of its two "real"s, so
+  # a later narrowing can only ever apply to both at once -- two copies typed
+  # out separately could drift, one gaining an exception the other never
+  # sees. Function words that only ever continue a predicative "is real",
+  # then the fixed senses common in this register that are never the
+  # doubled-intensifier tell: real time, real-world, the math sense (real
+  # numbers/roots), real user (monitoring), real estate, real money.
+  REAL_X_REAL_Y_EXCLUDED_NEXT_WORD =
+    "and|but|or|nor|yet|too|enough|itself|indeed|which|that|here|there|so" \
+    "|time|world|numbers?|roots?|money|estate|user"
   RULES = [
     # ── rhetorical-tic ────────────────────────────────────────────────────
     Rule.new(
@@ -343,6 +372,90 @@ module Sloplint
                  "which is why the rule is off by default; when selected, several in a " \
                  "draft should be read as a warning."
     ),
+    Rule.new(
+      id: "phrase-echo",
+      category: "rhetorical-tic",
+      severity: "info",
+      default_on: false,
+      # The same three words again a few paragraphs on. Three consecutive
+      # words, each four characters or more and lowercase-led, one of them
+      # six letters with nothing but letters, and the same three again
+      # within about 400 words. That is the whole defence, and it is
+      # structural: length drops the function-word runs, the all-letters
+      # word drops the contractions and hyphenated compounds that would
+      # otherwise pass on characters alone, case drops the names and
+      # headings. The gaps inside the phrase are capped at two spaces, as
+      # in epistrophe, so a code span blanked by --markdown cannot weld two
+      # words into a phrase.
+      #
+      # The window is a lazy walk of word steps in an atomic group, so
+      # nothing backtracks, and it counts Unicode words, since `\w` is
+      # ASCII in Ruby. Each gap in the walk is capped at 80 non-word
+      # characters and refuses to cross into a list item or a table row:
+      # a blanked code fence, a rule of dashes or a bullet is a wall, not a
+      # step. The repeat sits in a lookahead so the match, and the excerpt,
+      # is the first occurrence alone rather than the whole span; the
+      # suggestion says so. The repeat may not open on a quote mark, a
+      # backtick, an emphasis marker, a hyphen or a table bar: a quoted
+      # self-repeat is deliberate, and "re-shared" is not "shared". One
+      # backreference per word so either occurrence may be hard-wrapped.
+      #
+      # Off by default: in reference prose the rate runs to thousands per
+      # million words, all of it terms of art and running epithets.
+      pattern: /(?<![\p{Word}'’-])
+                (?=(?:[\w'’-]+(?:[ \t ]{1,2}|\r?\n(?![ \t ]*\r?\n)[ \t ]{0,4})){0,2}[a-z]{6,}(?![\w'’-]))
+                ([a-z][\w'’-]{3,})(?:[ \t ]{1,2}|\r?\n(?![ \t ]*\r?\n)[ \t ]{0,4})
+                ([a-z][\w'’-]{3,})(?:[ \t ]{1,2}|\r?\n(?![ \t ]*\r?\n)[ \t ]{0,4})
+                ([a-z][\w'’-]{3,})\b
+                (?=(?>(?:(?!\r?\n[ \t]*(?:[-*+•|]|\d+[.)])[ \t])\P{Word}){1,80}\p{Word}+){0,400}?
+                   (?:(?!\r?\n[ \t]*(?:[-*+•|]|\d+[.)])[ \t])[^\p{Word}"“‘'`*|-]){1,80}
+                   \1(?:[ \t ]{1,2}|\r?\n(?![ \t ]*\r?\n)[ \t ]{0,4})
+                   \2(?:[ \t ]{1,2}|\r?\n(?![ \t ]*\r?\n)[ \t ]{0,4})
+                   \3\b)/x,
+      message: "Three-word phrase that comes back within a few hundred words -- a model reusing its own output.",
+      suggestion: "This is the first use and the repeat is ahead. Reword the repeat, unless the phrase is a term the reader needs to see again.",
+      examples_bad: [
+        "The shortest honest answer that came out of the review was a list.\n\nWhen you write back, the shortest honest answer you can send is the list.",
+        "We keep a shared review checklist in the repo, and it is short. Everyone who opens a pull request edits the shared review checklist first.",
+        # A hard-wrapped first occurrence.
+        "We keep a shared review\nchecklist in the repo. Everyone edits the shared review checklist first.",
+        # The last word inside the window.
+        "We keep a shared review checklist. #{"word " * 399}The shared review checklist is short."
+      ],
+      examples_ok: [
+        # Function words fall out on length.
+        "In order to ship we cut scope, and in order to ship again we cut it more.",
+        # Four-letter words alone are not enough; one word must be six letters, letters only.
+        "It would have been better, and it would have been faster.",
+        "It couldn't have been worse, and it couldn't have been better.",
+        "We saw every top-ten list here, and every top-ten list there.",
+        # Proper nouns and Title Case headings fall out on case.
+        "Grand Central Station has one, and Grand Central Station wants two.",
+        "Incident Response Plan\n\nThe Incident Response Plan covers the first hour.",
+        # The repeat is beyond the window, in words, in non-ASCII words, or past a wall of dashes.
+        "We keep a shared review checklist. #{"word " * 400}The shared review checklist is short.",
+        "We keep a shared review checklist. #{"слово " * 400}The shared review checklist is short.",
+        "We keep a shared review checklist.\n\n#{"-" * 100}\n\nThe shared review checklist is short.",
+        # A quoted repeat is deliberate, whatever the quote mark.
+        "The shared review checklist is new. He wrote \"shared review checklist\" on the board.",
+        "The shared review checklist is new. He wrote 'shared review checklist' on the board.",
+        "The shared review checklist is new. He wrote `shared review checklist` on the board.",
+        # A different word form is a different phrase, and so is a hyphenated compound.
+        "The shared review checklist grew, and then both shared review checklists grew.",
+        "The auto-generated review checklist was long. The hand-generated review checklist was longer.",
+        "We use a shared review checklist daily. Nobody re-shared review checklist edits.",
+        # A run of spaces where --markdown blanked a code span does not weld a phrase.
+        "We keep a shared          review checklist here. Everyone edits the shared review checklist first.",
+        # List items and table rows are furniture, not prose.
+        "- shared review checklist covers pull requests\n- shared review checklist covers deploys",
+        "1. Update the shared config file.\n2. Restart the shared config file watcher.",
+        "| Task | Status |\n|---|---|\n| A | needs manual review |\n| B | needs manual review |"
+      ],
+      rationale: "A model reuses a phrase it has just minted because its own recent output is " \
+                 "the likeliest continuation, so the same three words turn up again a few " \
+                 "paragraphs on, doing no new work. Terms of art repeat too, and the pattern " \
+                 "cannot tell a coined phrase from a name, so the rule is off by default."
+    ),
     Rule.new(
       id: "did-not-x-did-not-y",
       category: "rhetorical-tic",
@@ -892,9 +1005,9 @@ module Sloplint
       # in front of a speech verb, and the concrete-capable nouns (cut, line,
       # version, split) are left out entirely.
       pattern: /\bcleanest\s+(?:\w+\s+){0,2}
-                 (?:framing|formulation|statement|account|argument|idea|definition|summary
-                   |reading|take|point|story|explanation|distinction|comparison|mapping
-                   |abstraction)\b
+                 (?:#{WRITERS_OWN_CONSTRUCTION_NOUNS}|comparison
+                   |statement|account|argument|idea|definition|summary
+                   |reading|take|point|story|explanation|distinction)\b
                 |\bcleanest\s+way\s+to\s+(?:say|put|frame|state|describe|phrase|express
                    |think\s+about)\b/ix,
       message: '"The cleanest framing/way to put it…" ranks your own claim for the reader.',
@@ -922,7 +1035,7 @@ module Sloplint
       # "break" is admitted only in "clean break between", never bare, because
       # "make a clean break with the past" is an idiom and not a tell.
       pattern: /\b(?:a|the|one)\s+(?:\w+\s+)?clean\s+(?:\w+\s+)?
-                 (?:abstraction|distinction|framing|formulation|mapping|through-line
+                 (?:#{WRITERS_OWN_CONSTRUCTION_NOUNS}|distinction|through-line
                    |story|answer|argument|split|divide)\b
                 |\bclean\s+(?:line|break|split)\s+between\b/ix,
       message: '"A clean abstraction / clean framing" praises the idea instead of showing it.',
@@ -997,6 +1110,104 @@ module Sloplint
                  "are three words apart and identical on the surface. An agent reading the flag " \
                  "has the rest of the sentence to judge; the pattern alone doesn't."
     ),
+    Rule.new(
+      id: "real-x-real-y",
+      category: "rhetorical-tic",
+      severity: "info",
+      # Ships at info, not warning: the only two hits the probe found in
+      # 1.28M words were both false positives, and one corpus of one
+      # register is thin evidence next to honestly, which sits at warning
+      # on 9.7M words across two. A doubled "real" is also defensible on
+      # its own ("No real financial loss, but a real failure") in a way
+      # the warning rules around it are not. The agent reading the flag
+      # decides.
+      #
+      # "If it can trigger real API calls or hold real credentials, it needs
+      # the same rigor." -- the same intensifier, said twice in one sentence,
+      # each time in front of a different noun. Bare "real" is an ordinary
+      # word (a real number, real time, a real problem) and cannot be flagged
+      # on its own; the narrowing here is repetition, not a noun list --
+      # requiring two attributive uses in one sentence, naming two different
+      # things, is what tells the doubled intensifier apart from plain
+      # English, and it needs no list of nouns to do it.
+      #
+      # "Attributive" is enforced by requiring "real" to run straight into
+      # the word it modifies: a space, then a letter, with no comma or
+      # conjunction between. That already keeps the predicative use out
+      # ("The risk is real, and it is growing" -- its own rule, above) since
+      # a predicate "real" is followed by punctuation or "and", never
+      # directly by the next noun.
+      #
+      # A hyphen touching "real" on either side takes it out of the running:
+      # "real-time" and "real-world" are compounds, one modifier, not two
+      # independent uses of the intensifier, and "non-real" is a negation,
+      # not the intensifier at all. (?<!-) and (?!-) drop all three.
+      #
+      # The second "real" must name a word the first one didn't -- a
+      # backreference, so "a real risk ... that real risk" (the same thing,
+      # referred to twice) is ordinary reference, not the tic. Two mentions
+      # only look alike when they're both new: two different real things.
+      #
+      # The closed list after each "real" (REAL_X_REAL_Y_EXCLUDED_NEXT_WORD,
+      # above) is the handful of fixed senses that are common in this
+      # register and are never the tell, plus the function words that only
+      # ever continue a predicative "is real". This gives up "real user"
+      # outside "real user monitoring" and any doubled "real name"/"real
+      # names" pairing that differs only by a plural -- known, deliberate
+      # recall losses rather than a growing list.
+      #
+      # The gap between the two "real"s crosses a hard-wrapped line the same
+      # way WRAP_GAP does (a newline is fine unless it opens a paragraph
+      # break, PARA_BREAK, since a non-breaking space alone on the line in
+      # between still reads as a blank line to the editors that emit one),
+      # but never a sentence-ending mark, so the two "real"s must fall in
+      # one sentence.
+      pattern: /
+        (?<!-)\breal(?!-)[ \t]+
+        (?!(?:#{REAL_X_REAL_Y_EXCLUDED_NEXT_WORD})\b)
+        (?>([a-z][\w'’-]*))\b
+        (?:(?!\breal\b)[^.!?\n]|(?!#{PARA_BREAK})\r?\n){1,200}?
+        (?<!-)\breal(?!-)[ \t]+
+        (?!(?:#{REAL_X_REAL_Y_EXCLUDED_NEXT_WORD})\b)
+        (?!\1\b)
+        (?>[a-z][\w'’-]*)\b
+      /ix,
+      message: 'Doubled "real" ("real X … real Y") repeats the intensifier for emphasis.',
+      suggestion: "Cut one 'real,' or say what actually makes each thing real -- a name, a number, a log line.",
+      examples_bad: [
+        "If it can trigger real API calls or hold real credentials, it needs the same rigor.",
+        "The demo used real customer data and exposed real financial records to the whole team.",
+        "This isn't a mockup; it hits a real database and charges a real credit card.",
+        "The incident caused real financial losses and real reputational damage to the company."
+      ],
+      examples_ok: [
+        # The second "real" must name something the first didn't.
+        "The system exposes a real risk, and that real risk must be tracked.",
+        # A hyphen on either side makes it a compound, not two uses.
+        "The dashboard shows real-time metrics and real-time alerts.",
+        # "real world" is on the closed list even unhyphenated.
+        "In the real world this rarely happens, and the real world rewards patience.",
+        # The math sense, both nouns.
+        "The equation has two real roots and no real numbers outside that range.",
+        # "real user" (monitoring) and a hyphenated compound together.
+        "The tool combines real user monitoring with real-time dashboards.",
+        # Two more closed-list nouns.
+        "She invested in real estate and lost real money.",
+        # "non-real" is a negation, not a second use of the intensifier.
+        "The audit flagged real deployment risk but no non-real anomalies.",
+        # Only one "real" in the sentence.
+        "This is a real problem worth solving.",
+        # A paragraph break -- even one where the blank line holds only a
+        # non-breaking space -- ends the sentence; the two paragraphs are
+        # never joined into one hit.
+        "This plan needs real signoff\n \nbefore it touches real production data."
+      ],
+      rationale: "\"Real\" is the plainest way to say a thing isn't fake or hypothetical, and it " \
+                 "only needs saying once a sentence -- naming it again in front of a second noun " \
+                 "doesn't add information, it repeats the reassurance. A person defending a claim " \
+                 "from two directions in the same breath writes the two facts and lets one " \
+                 "\"real\" cover both."
+    ),
     Rule.new(
       id: "the-punchline-is",
       category: "rhetorical-tic",
@@ -2035,8 +2246,7 @@ module Sloplint
       # superlative belongs to most-honest-x alone.
       pattern: /\b(?:an|the|one|this|that)[ \t]+(?:(?!most\b|more\b)\w+[ \t]+)?
                 honest[ \t]+(?:\w+[ \t]+)?
-                (?:comparison|framing|formulation|accounting|abstraction|mapping
-                  |through-line)\b/ix,
+                (?:#{WRITERS_OWN_CONSTRUCTION_NOUNS}|comparison|accounting|through-line)\b/ix,
       message: '"An honest comparison / the honest framing" praises the writing, not the thing.',
       suggestion: "Cut the adjective and make the comparison; the reader decides if it is honest.",
       examples_bad: [
@@ -2073,9 +2283,10 @@ module Sloplint
       # politician" is, so no human nouns go in. Nothing in either corpus
       # matches. "way to" gets its own branch, mirroring cleanest-x.
       pattern: /\bmost[ \t]+honest[ \t]+(?:(?!way\b)\w+[ \t]+){0,2}
-                (?:comparison|framing|formulation|accounting|assessment|appraisal
-                  |reading|account|answer|version|summary|take|signal|abstraction
-                  |mapping|through-line)\b
+                (?:#{WRITERS_OWN_CONSTRUCTION_NOUNS}|comparison
+                  |accounting|assessment|appraisal
+                  |reading|account|answer|version|summary|take|signal
+                  |through-line)\b
                |\bmost[ \t]+honest[ \t]+way[ \t]+to[ \t]+
                 (?:say|put|frame|state|describe|phrase|think[ \t]+about)\b/ix,
       message: '"The most honest framing…" ranks your own claim for the reader.',
@@ -2126,6 +2337,72 @@ module Sloplint
                  "nominally free -- and nothing in the sentence marks which use is which, " \
                  "which is why this one runs only when you ask for it."
     ),
+    Rule.new(
+      id: "actually-not-x",
+      category: "rhetorical-tic",
+      severity: "warning",
+      # Two markers that each correct the reader, doubled up in one clause:
+      # the adverb and the trailing "…, not X". Bare "actually" is not the
+      # tell and is not matched, because "the build actually failed on the
+      # second run" names which run and that is a fact with something behind
+      # it to check.
+      #
+      # The narrowing is one structural constraint, not a word list: the
+      # comma in front of "not" has to be the first comma of its clause and
+      # has to follow a word. A writer correcting an assumption the reader
+      # does hold names it first, and that setup is either a fronted clause
+      # with a comma after it ("Despite the name, …") or a parenthetical
+      # whose closing bracket the comma follows. No earlier comma means
+      # nothing in the clause set the alternative up. A clause starts at the
+      # beginning of the text, at a full stop, question mark, exclamation
+      # mark, semicolon or colon, or at a line break.
+      #
+      # Nothing crosses a line break, so the rule cannot weld two rows of a
+      # table or two items of a list into one correction. The deliberate
+      # misses: a hard-wrapped correction, and a correction whose clause
+      # carries an earlier comma of any kind, an apposition ("The report,
+      # filed late, says the id is actually a byte string, not text.")
+      # included. No pattern tells an apposition from a fronted setup, and
+      # the rule would rather say nothing than guess.
+      pattern: /(?:\A|(?<=[.;:!?\n]))[^.;:!?,\n]{0,200}\K
+                \bactually\b[^.;:!?,\n]{0,120}(?<=[\p{Word}]),[ \t]*not\b/ix,
+      message: '"Actually …, not X" corrects an assumption the text never offered.',
+      suggestion: "State the fact plainly, or name the belief the correction answers.",
+      examples_bad: [
+        "The disclosure actually covered two incidents, not one.",
+        "The identifier is actually a byte string, not text.",
+        "It actually reads the file at startup, not on the first request.",
+        # A colon opens a clause, so the correction after it is still the tell.
+        "Note: the endpoint actually returns two fields, not one."
+      ],
+      examples_ok: [
+        # The bare adverb, which names which run failed. Not matched.
+        "The build actually failed on the second run.",
+        # The setup sits in a fronted clause, so the correction answers
+        # something the reader was given. The earlier comma drops both.
+        "Despite the name, the identifier is actually a byte string, not text.",
+        "Although the name suggests otherwise, it is actually a byte string, not text.",
+        # The correction on its own, with no adverb in front of it.
+        "The run that failed was the second, not the first.",
+        # Negation in front of the adverb with no trailing correction. This
+        # was the other candidate shape; every real instance of it carried
+        # its own setup ("normally reserved but not actually registered"),
+        # so it was rejected, and this fixture pins the rejection.
+        "The provider was not actually billed for the usage.",
+        # The correction's comma closes a parenthesis, and the assumption
+        # being corrected is inside it.
+        "The party actually sending the mail (which we assumed was the relay), not the sender.",
+        # Two rows of a table, not a wrapped sentence. The rule never crosses
+        # a line break, so it cannot join them.
+        "Actually running processes\nThreads, not processes"
+      ],
+      rationale: "The adverb and the trailing \"not X\" both correct the reader, and a writer " \
+                 "needs one or the other, never both. Doubling them marks a contrast against " \
+                 "an alternative the reader was never offered: nothing said one incident, so " \
+                 "\"not one\" answers nobody. The setup can also sit in the sentence before, " \
+                 "which no pattern sees, so a flag on a correction that a previous sentence " \
+                 "genuinely set up is the known cost."
+    ),
     Rule.new(
       id: "and-thats-fine",
       category: "rhetorical-tic",
@@ -2642,11 +2919,17 @@ module Sloplint
       severity: "info",
       default_on: false,
       pattern: /\b[\w'-]+,\s+[\w'-]+,\s+(?:and\s+)?[\w'-]+[.!?]/,
-      message: "Three parallel comma items closing a sentence (heuristic; high false-positive).",
+      message: "Three single words in a comma series closing a sentence (heuristic; high false-positive).",
       suggestion: "Fine in moderation; watch for the AI habit of ending on triplets.",
       examples_bad: ["It was fast, cheap, and simple."],
-      examples_ok: ["We met on Tuesday afternoon."],
-      rationale: "Rule-of-three endings are a model habit, but humans use them too — off by default."
+      examples_ok: [
+        "We met on Tuesday afternoon.",
+        # Phrasal items do not match; the closing two slots take one word each.
+        "It was very fast, very cheap, and very simple."
+      ],
+      rationale: "Rule-of-three endings are a model habit, but humans use them too — off by default. " \
+                 "The closing two items must be single words; a triad of phrases is three ordinary " \
+                 "list items to a regex, so those are left unflagged rather than guessed at."
     ),
     # clause-triad-then was cut. The pattern (comma-clause, comma-clause,
     # "then" clause) had no way to require the clauses actually be parallel
@@ -2872,7 +3155,7 @@ module Sloplint
       # long unpunctuated stretches (the Columbia report has an 864-character
       # one) sent this into catastrophic backtracking, 62 seconds for a 2 KB
       # window and no completion on the 1.1 MB document.
-      pattern: /(?:^|(?<=[.!?])[ \t]{1,2})(?>(?:[^.!?\n\s]|(?<![ \t])[ \t]{1,2}(?![ \t])|\r?\n(?!\s*\n)[ \t]*){60,})[.!?][ \t]{1,2}\K
+      pattern: /#{SENTENCE_OF_SIXTY_CHARACTERS_ENDING_IN_PUNCTUATION_AND_SPACE}\K
                 (?:Nothing|Most|None|Everything|Everyone|Nobody|Then|Neither|Both)
                 (?:,?(?:[ \t]|\r?\n(?!\s*\n))+[\w'’-]+){1,7}[.!?](?=[ \t]*(?:\r?\n[ \t]*(?:\r?\n|\z)|\z))/x,
       message: "A short quantifier-led closer after a long sentence is the AI kicker.",
@@ -2915,6 +3198,90 @@ module Sloplint
                  "where the flag repeats paragraph after paragraph should be read as a " \
                  "warning, and the fix is usually to delete the closer outright."
     ),
+    Rule.new(
+      id: "ellipsis-closer",
+      category: "structure",
+      severity: "info",
+      # The same long-sentence-then-short-closer shape as mic-drop-closer,
+      # but the tell lives in the verb, not the subject. mic-drop-closer's
+      # closer opens on a quantifier and keeps a full verb with its object
+      # ("Nothing here needs a new login."). This one carries no verb at
+      # all: the closer's verb phrase has been elided down to the bare
+      # auxiliary that would have introduced it, and the object it
+      # promised never arrives -- "They found an exposed dashboard and
+      # asked the agent running on it to hand over its own key. The agent
+      # did." Because the tell is the missing verb, this rule needs no
+      # subject list the way mic-drop-closer does, and "That", "This" and
+      # "It" are not excluded here the way they are there: "This completes
+      # the roughing operations." ends on a full verb with an object and
+      # never matches (there is no auxiliary at the sentence's end), while
+      # "This did." would, on the same subject mic-drop-closer had to bar.
+      #
+      # The closer is a one-to-three word subject running straight into the
+      # bare auxiliary and a period, and, same as mic-drop-closer, it must
+      # be the last thing in the paragraph -- a blank line or the end of
+      # the text follows it. A closing quotation mark after the period is
+      # not blank, so quoted dialogue never satisfies this and is excluded
+      # the same way short-run excludes it. A negative lookahead drops any
+      # closer that still holds "what", "that", "which", "who", "why" or
+      # "how", because those mark a subordinate clause supplying its own
+      # complement rather than an elided one: "Nobody knew who did." asks
+      # "who did it", which the subject cap alone does not catch, since
+      # "Nobody knew who" is itself only three words.
+      #
+      # Reuses mic-drop-closer's long-sentence prefix rather than pasting a
+      # second copy of it; see that constant's comment for the atomic group
+      # that keeps the scan linear.
+      #
+      # The negated form is bolted on with "n't" for every auxiliary except
+      # two irregular ones: "can" already ends in n, so its negation is
+      # "can't", not "cann't", and "will" negates to the different stem
+      # "won't" rather than "willn't". Both are spelled out rather than
+      # built by suffix, so the two most common contractions in the list
+      # are not silently unmatchable.
+      pattern: /#{SENTENCE_OF_SIXTY_CHARACTERS_ENDING_IN_PUNCTUATION_AND_SPACE}\K
+                (?![^.!?\n]*\b(?:what|that|which|who|why|how)\b)
+                [A-Z][\w'’-]*(?:[ \t]+[\w'’-]+){0,2}[ \t]+
+                (?:(?:did|does|do|was|were|is|are|had|has|could|would|should|might|must)(?:n['’]t)?
+                   |can(?:['’]t)?|will|won['’]t)\.
+                (?=[ \t]*(?:\r?\n[ \t]*(?:\r?\n|\z)|\z))/x,
+      message: "A closer that ends on a bare auxiliary is the AI verb-phrase-ellipsis kicker.",
+      suggestion: "Cut the closer, or say what actually happened.",
+      examples_bad: [
+        "They found an exposed dashboard and asked the agent running on it to hand over its own key. The agent did.",
+        "The team spent three weeks arguing about whether the migration was worth the downtime it would cost the on-call rotation. It wasn't.",
+        "The reviewer asked whether a contractor with read access to the shared drive could still open the finance folder after the offboarding ran. She could.",
+        "He asked whether the on-call engineer had actually paged the second responder before escalating past the fifteen-minute window. She had.",
+        # The two irregular negated forms, pinned so a later rewrite of the
+        # suffix can't quietly drop them again.
+        "They double-checked whether the fallback path could still serve read traffic once the primary region failed over during the drill. It can't.",
+        "The team hoped the migration window would close before the seasonal freight peak began overwhelming the warehouse systems. It won't."
+      ],
+      examples_ok: [
+        # Not the end of the paragraph.
+        "They found an exposed dashboard and asked the agent running on it to hand over its own key. The agent did. We logged the incident and rotated the key within the hour.",
+        # A subordinate clause, not an elided one -- caught by the wh-word guard.
+        "The team spent three weeks arguing about whether the migration was worth the downtime it would cost the on-call rotation. That is what it did.",
+        # No long sentence in front of it.
+        "The agent did.",
+        # A subject longer than three words -- the cap, not the wh-guard, excludes it.
+        "The engineer who had been paged in the middle of the night finally agreed with what the on-call reviewer had been saying for the better part of an hour about the rollback plan. The whole team already did.",
+        # A full verb with an object, not a bare auxiliary.
+        "Each step already passed local review before it reached the pipeline that runs on every push to the shared branch. It worked.",
+        # A bare demonstrative closing a step is how procedural writing ends
+        # a paragraph, and it ends on a full verb, not an auxiliary. Wording
+        # follows Turning and Boring (1919) and Aviation Engines (1917),
+        # both public domain by date; mic-drop-closer carries the same two
+        # examples for the same reason.
+        "The cutting tools are set to the dimensions required for the finished work, and the stops are locked. This completes the roughing operations.",
+        "The magneto is protected from oil and grit by a cover that is easy to remove for service. This means prolonged life for the magneto."
+      ],
+      rationale: "The closer withholds exactly the thing the long setup built toward -- the " \
+                 "verb and its object are gone, and only the bare confirmation that something " \
+                 "happened is left standing. Ships at info: plenty of ordinary writing drops " \
+                 "the verb the same way when it confirms an expectation, and one flag proves " \
+                 "nothing; a draft where it repeats is the tell."
+    ),
     Rule.new(
       id: "short-run",
       category: "structure",
@@ -3228,6 +3595,98 @@ module Sloplint
                  "narrator who never appears. Careful writers put the verb in its own clause " \
                  "with a subject, or leave the significance to the reader."
     ),
+    Rule.new(
+      id: "trailing-restatement",
+      category: "structure",
+      severity: "info",
+      default_on: false,
+      # The restating tail: "…, which means working through the process
+      # rather than around it". A regex sees the connective and not whether
+      # the tail says the head again, and the sentence that prompted the rule
+      # shares no content words between the two, so no overlap test reaches
+      # it either. Hence off by default.
+      #
+      # Three connectives, and four participle frames that make the same
+      # move. Nothing before the comma is inspected: a gloss ("_ma_, which
+      # means hand") and a real tell after a code span or a bold phrase end
+      # on the same characters, so a guard there costs more hits than it
+      # saves. Glosses are a known cost of the rule. The participle
+      # "meaning" must open on one of a closed set of determiners and
+      # pronouns, which keeps out the noun ("meaning of"), the intention
+      # ("meaning to come back") and the bare-noun gloss ("meaning six"); a
+      # gloss that takes an article ("meaning the red stick") gets through.
+      # Each participle frame needs a pronoun object and a closing word,
+      # because the bare participle is ordinary English ("she left, leaving
+      # the door open"). The closer on "making" is a comparative or
+      # (im)possible and must end the clause or lead into "to", "for" or
+      # "than", since "-er" alone is also "wonder", "offer" and "her". These
+      # verbs stay off trailing-significance-participle, whose list is closed
+      # to verbs an event can be the subject of.
+      pattern: /,#{WRAP_GAP}+
+                (?:which#{WRAP_GAP}+means\b
+                  |which#{WRAP_GAP}+is#{WRAP_GAP}+to#{WRAP_GAP}+say\b
+                  |meaning#{WRAP_GAP}+(?:that|the|a|an|this|these|those|it|he|she|we|you|they|there|nothing|every|each|any|all|most|some|your|our|their|its)\b
+                  |making#{WRAP_GAP}+(?:it|them|us|you|the(?:#{WRAP_GAP}+[\w'’-]+){1,2})#{WRAP_GAP}+
+                     (?:[a-z]+er|(?:im)?possible|(?:more|less)(?:#{WRAP_GAP}+[a-z]+)?)
+                     (?=#{WRAP_GAP}+(?:to|for|than)\b|[ \t]*[.,;:!?)]|[ \t]*\r?\n|[ \t]*\z)
+                  |allowing#{WRAP_GAP}+(?:it|them|us|you)#{WRAP_GAP}+to\b
+                  |giving#{WRAP_GAP}+(?:them|us|you)#{WRAP_GAP}+(?:more|less|time|room)\b
+                  |leaving#{WRAP_GAP}+(?:them|us|you)#{WRAP_GAP}+with(?:out)?\b)/ix,
+      message: "Trailing clause that says the sentence again, or hangs a result off it.",
+      suggestion: "Cut the tail, or if it states a real consequence, make it its own sentence.",
+      examples_bad: [
+        "We moved the checks into the build step, which means the errors show up before anyone opens a review.",
+        "The new queue drains in order, which is to say nothing jumps ahead of an older job.",
+        "Every job now records its own start time, meaning the log tells you when the run began.",
+        "He signed at once, meaning he had read it already.",
+        "We rebuilt the parser, making the whole pipeline faster.",
+        "The cache is local now, making it easier to reason about.",
+        "The change is small, making it more robust.",
+        "The lock is per row, making it impossible for two writers to collide.",
+        "The cache now lives beside the worker, allowing us to skip the round trip.",
+        "The report ships on Fridays, giving them more time to read it.",
+        "The old flags are gone, leaving you with one switch to learn.",
+        # Nothing before the comma is inspected.
+        "The flag defaults to `false`, which means nothing is written to disk.",
+        "- **Cache is local**, which means the round trip is gone.",
+        "We fixed the bug (the null check), which means the crash is gone.",
+        # Either gap may hard-wrap.
+        "We moved the checks into the build step,\nwhich means the errors show up first.",
+        "We moved the checks into the build step, which\nmeans the errors show up first."
+      ],
+      examples_ok: [
+        # "meaning" outside the closed set: the bare-noun gloss, the intention, the noun.
+        "They count on with tatisitupe, meaning six.",
+        "It is an old word, meaning caves.",
+        "He left the room, meaning to come back before dark.",
+        "She read on, meaning of the word aside, and let it pass.",
+        "He shrugged, meaning no harm by it.",
+        # The bare participles are ordinary English.
+        "She left the room, leaving the door open.",
+        "Cut the paper around the frame, leaving a margin for pasting.",
+        "He handed over the keys, giving her a nod.",
+        "The lid lifts off, allowing the steam to escape.",
+        # A pronoun object with no closing word, or the wrong one.
+        "Rub down the leather, making it as smooth as possible.",
+        "The crowd parted, making room for more chairs.",
+        "He pulled the cork, giving it time to breathe.",
+        "He shut the door, leaving them to it.",
+        "The porter took the trunk, leaving it with the station master.",
+        # "-er" that is not a comparative, and a comparative that does not close the clause.
+        "The rain kept up all week, making you wonder whether the trip was worth it.",
+        "She turned the coat inside out, making it her own.",
+        "They argued, making the same point over and over.",
+        "The tide turned, making it matter less than before.",
+        # A gerund list.
+        "The work involves cutting, making and sanding the parts.",
+        # A paragraph break is not a comma.
+        "The checks moved into the build step\n\nWhich means the errors show up first."
+      ],
+      rationale: "The tail after the connective says the head again in other words, and a " \
+                 "model adds one whenever a sentence feels short of a point. Careful writers " \
+                 "use the same connective to state a consequence, and the pattern cannot " \
+                 "tell the two apart, so the rule is off by default."
+    ),
     # ── hedging ───────────────────────────────────────────────────────────
     Rule.new(
       id: "vague-attribution",

data/lib/sloplint/version.rb CHANGED Viewed

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 module Sloplint
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 end

metadata CHANGED Viewed

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sloplint
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Benjamin Jackson