sloplint 0.6.0 → 0.8.0

data/lib/sloplint/rules.rb

@@ -6,12 +6,14 @@ module Sloplint
   # count_group: a Regexp scanned over the matched text to tally items; when set,
   #   the Note carries `count` and the message may interpolate %{count}.
   # skip: Regexps that, if they match the matched text, drop the note (exclusions).
-  # default_on: false keeps a noisy rule out of the default run (still selectable).
+  # severity: what the construct costs the prose -- "error", "warning", "info".
+  # confidence: how likely a match is a false positive -- "high", "medium", "low".
+  #   A "low" rule stays out of the default run; --strict or its own id turns it on.
   Rule = Data.define(
-    :id, :category, :severity, :pattern, :message, :suggestion,
-    :examples_bad, :examples_ok, :count_group, :skip, :rationale, :default_on
+    :id, :category, :severity, :confidence, :pattern, :message, :suggestion,
+    :examples_bad, :examples_ok, :count_group, :skip, :rationale
   ) do
-    def initialize(count_group: nil, skip: [], rationale: nil, default_on: true, **rest)
+    def initialize(count_group: nil, skip: [], rationale: nil, **rest)
       super
     end
   end
@@ -53,12 +55,41 @@ 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(
       id: "no-x-no-y",
-      category: "rhetorical-tic",
+      category: "cadence",
       severity: "warning",
+      confidence: "high",
       # Comma chains only: "no fluff, no filler, no jargon". The comma is the
       # evidence -- it makes the parallelism deliberate. Fragment chains split
       # by sentence punctuation are a separate, quieter rule (no-x-no-y-frag),
@@ -75,10 +106,11 @@ module Sloplint
     ),
     Rule.new(
       id: "no-x-no-y-frag",
-      category: "rhetorical-tic",
-      severity: "info",
+      category: "cadence",
+      severity: "warning",
+      confidence: "medium",
       # The same cadence built from sentence fragments: "No fluff. No filler."
-      # Ships at info, not warning, because the shape is genuinely ambiguous --
+      # Medium confidence, because the shape is genuinely ambiguous --
       # two short "no" sentences in a row is also just writing ("No one moved.
       # No one spoke."). The agent reading the flag decides; see rationale.
       #
@@ -118,8 +150,9 @@ module Sloplint
     ),
     Rule.new(
       id: "thats-the-whole",
-      category: "rhetorical-tic",
+      category: "closer",
       severity: "warning",
+      confidence: "high",
       # The nouns are WHOLE_CLOSERS. "value" and "fix" are the closers agents
       # write in technical prose ("That's the whole fix"), where the
       # contraction keeps them out of is-the-whole-x, which sees only "is".
@@ -169,8 +202,9 @@ module Sloplint
     ),
     Rule.new(
       id: "is-the-whole-x",
-      category: "rhetorical-tic",
-      severity: "info",
+      category: "closer",
+      severity: "warning",
+      confidence: "medium",
       # The generic form of thats-the-whole: a subject, then "is the whole /
       # real / actual / entire N" with N from a closed abstract list. "That
       # periodicity is the whole tell.", "Consistency is the real test." The
@@ -187,7 +221,7 @@ module Sloplint
       # "cost" because "the real deal", "the real thing" and "the whole cost"
       # are idioms or quantities. The noun may not run on into a compound
       # ("problem-solver"). Gaps may cross a hard-wrapped newline but never
-      # a paragraph break. Ships at info because "the real question" and
+      # a paragraph break. Medium confidence: "the real question" and
       # "the whole point" are also how people talk.
       pattern: /(?<![\w'’-])
                 (?!(?:that|this)#{WRAP_GAP}+(?:is)#{WRAP_GAP}+(?:the)#{WRAP_GAP}+(?:whole)#{WRAP_GAP}+(?:#{WHOLE_CLOSERS})(?![\w'’-]))
@@ -236,8 +270,9 @@ module Sloplint
     ),
     Rule.new(
       id: "bare-equative",
-      category: "rhetorical-tic",
-      severity: "info",
+      category: "closer",
+      severity: "warning",
+      confidence: "medium",
       # A sentence that opens on an abstract head noun and equates it with
       # something: "The tell here is the periodicity.", "The problem is not
       # the tool.", "The lesson is the handoff." The head noun list is closed
@@ -251,8 +286,8 @@ module Sloplint
       # answer is a mess"), a pointing complement ("the same", "the one",
       # "the first"), and a proper noun ("the Slack thread") are all out.
       # Gaps may cross a hard-wrapped newline but never a paragraph break.
-      # Ships at info: "The problem is the cost" is how people write too, at
-      # about four per million words on Hacker News; it is the density that
+      # Medium confidence: "The problem is the cost" is how people write too,
+      # at about four per million words on Hacker News; it is the density that
       # tells.
       pattern: /(?:^|(?<=[.!?])[ \t]{1,2})(?:[-*+•][ \t]+|\d+[.)][ \t]+)?\KThe(?:[ \t]|\r?\n(?!\s*\n))+
                 (?:tell|point|question|problem|issue|lesson|difference|trick|move|risk|goal|reason|pattern|insight|takeaway|shift|bet|catch|gap|bottleneck|failure|mistake|secret|magic|challenge|tension|trap)(?:[ \t]|\r?\n(?!\s*\n))+
@@ -293,9 +328,9 @@ module Sloplint
     ),
     Rule.new(
       id: "epistrophe",
-      category: "rhetorical-tic",
+      category: "cadence",
       severity: "info",
-      default_on: false,
+      confidence: "low",
       # Two clauses that end on the same two-word phrase, the second closing
       # the sentence: "built for one desk, and almost no job is done at one
       # desk." Two backreferences catch the repeat, one per word, so the
@@ -343,10 +378,95 @@ 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: "cadence",
+      severity: "info",
+      confidence: "low",
+      # 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",
+      category: "cadence",
       severity: "warning",
+      confidence: "high",
       pattern: /\b(?:did\s+not|didn't)\s+[\w'-]+(?:,?\s+(?:and\s+)?(?:did\s+not|didn't)\s+[\w'-]+)+/i,
       message: '"did not X, did not Y" chain (%{count} items) reads as AI cadence.',
       suggestion: "Cut the chain or make it one plain sentence.",
@@ -357,8 +477,9 @@ module Sloplint
     ),
     Rule.new(
       id: "from-x-to-y-chain",
-      category: "rhetorical-tic",
+      category: "cadence",
       severity: "warning",
+      confidence: "high",
       # Two or more "from X to Y" spans in a row, comma-separated: "from
       # private notes to shared files, from personal memory to team context".
       # Each span is "from", one to three words, "to", one to three words; the
@@ -433,8 +554,9 @@ module Sloplint
     ),
     Rule.new(
       id: "one-x-one-y",
-      category: "rhetorical-tic",
+      category: "cadence",
       severity: "warning",
+      confidence: "high",
       # Three or more "one X" items in a comma chain that stands on its own:
       # "One owner, one repository, one weekly prune." or, after a colon,
       # "the setup is narrow: one reviewer, one queue, one deadline". The
@@ -504,8 +626,9 @@ module Sloplint
     ),
     Rule.new(
       id: "and-what-it-should",
-      category: "rhetorical-tic",
+      category: "closer",
       severity: "warning",
+      confidence: "high",
       # The elliptical tail: "List what the assistant knows about the client,
       # and what it should." The second "what" clause borrows its verb from the
       # first and ends on a bare modal or a negated auxiliary, so the sentence
@@ -551,8 +674,9 @@ module Sloplint
     ),
     Rule.new(
       id: "abstract-lives-in",
-      category: "rhetorical-tic",
-      severity: "info",
+      category: "puffery",
+      severity: "warning",
+      confidence: "medium",
       # An abstraction given an address: "the craft that lives between the two
       # desks", "its context lives in a folder nobody else can open", "the
       # value sits in the follow-up". The subject list is closed and abstract,
@@ -568,7 +692,7 @@ module Sloplint
       # lies in the assumption") and "resides in" are ordinary English for
       # where a fault or an authority is, at any register.
       #
-      # Ships at info. The same shape states where information literally is
+      # Medium confidence. The same shape states where information literally is
       # ("the knowledge lives in our heads", "the instructions live in the
       # README"), and a sample of pre-2022 Hacker News biased toward the
       # construction turns up a few of those per million words, all human.
@@ -611,8 +735,9 @@ module Sloplint
     ),
     Rule.new(
       id: "the-x-is-the-x",
-      category: "rhetorical-tic",
-      severity: "warning",
+      category: "cadence",
+      severity: "error",
+      confidence: "high",
       # The repeated-head equative: "the reason it holds up is the reason the
       # other half happens", "the problem with A is the problem with B". The
       # same abstract head noun sits on both sides of the copula, caught by a
@@ -674,8 +799,9 @@ module Sloplint
     ),
     Rule.new(
       id: "same-determiner-chain",
-      category: "rhetorical-tic",
+      category: "cadence",
       severity: "info",
+      confidence: "medium",
       # The quiet cousin of one-x-one-y and no-x-no-y: three or more items in
       # a comma chain that all open on the same determiner or quantifier,
       # caught with a backreference: "every faculty, every thought, every
@@ -736,8 +862,9 @@ module Sloplint
     ),
     Rule.new(
       id: "dont-verb-it",
-      category: "rhetorical-tic",
+      category: "false-correction",
       severity: "warning",
+      confidence: "high",
       pattern: /\b(?:don't|do\s+not)\s+(\w+)\s+it\b[^.!?]*[.!?]\s*\1\s+it\b/i,
       message: '"Don\'t X it. X it Y." reframing is a stock LLM move.',
       suggestion: "Drop the fake reframe and state the claim once.",
@@ -747,8 +874,9 @@ module Sloplint
     ),
     Rule.new(
       id: "sit-with-that",
-      category: "rhetorical-tic",
+      category: "reader-address",
       severity: "warning",
+      confidence: "high",
       # Two branches. The deictic object is the tic anywhere in a sentence, so
       # "sit with that/this/it" needs no anchor. Anything else needs the
       # sentence-initial imperative, which is where the tic lives and where the
@@ -775,12 +903,13 @@ module Sloplint
                  "The object does not matter: the tic is telling the reader to dwell instead " \
                  "of giving them something to dwell on. The sentence-initial imperative does " \
                  "flag the plain companion sense (\"Sit with the baby while I run out\"), " \
-                 "which is accepted -- hence warning, not error."
+                 "which is accepted."
     ),
     Rule.new(
       id: "hold-onto-that",
-      category: "rhetorical-tic",
+      category: "reader-address",
       severity: "warning",
+      confidence: "high",
       # Sentence-initial imperative only. Past tense and subordinate clauses
       # ("she held on to that letter", "if you hold onto that phrase") are a
       # different construction, not the tell. Everything AFTER that/this is
@@ -806,8 +935,9 @@ module Sloplint
     ),
     Rule.new(
       id: "cleanly",
-      category: "rhetorical-tic",
-      severity: "info",
+      category: "self-rating",
+      severity: "warning",
+      confidence: "medium",
       # The bare adverb was the whole rule, and the engineering idioms were
       # flagged on purpose. Technical prose says that was the wrong call: a
       # patch that applies cleanly, a build that compiles cleanly and a gear
@@ -823,7 +953,7 @@ module Sloplint
       # parts. The clause-final form ("the objection breaks down cleanly, and
       # neither half survives") is the same tell and is left out.
       #
-      # The frame is not the sense, and this rule ships at info because of it.
+      # The frame is not the sense, and the confidence here is medium because of it.
       # "The argument splits cleanly into two parts" and "the gear retracted
       # cleanly into the well" are one pattern apart only in their subject,
       # and a regex cannot see the subject -- the same limit that keeps the
@@ -858,8 +988,9 @@ module Sloplint
     ),
     Rule.new(
       id: "clean-count",
-      category: "rhetorical-tic",
+      category: "self-rating",
       severity: "warning",
+      confidence: "high",
       # Needs a partition noun. The bare count reaches the laundry: Ulysses
       # has "four clean strokes", Jane Eyre "two clean tuckers".
       pattern: /\b(?:two|three|four|five|six|seven|2|3|4|5|6|7)\s+
@@ -885,16 +1016,17 @@ module Sloplint
     ),
     Rule.new(
       id: "cleanest-x",
-      category: "rhetorical-tic",
-      severity: "warning",
+      category: "self-rating",
+      severity: "error",
+      confidence: "high",
       # Noun list only. "The cleanest way to install the driver" and "the
       # cleanest cut of meat" are ordinary English, so "way" is admitted only
       # 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.',
@@ -914,15 +1046,16 @@ module Sloplint
     ),
     Rule.new(
       id: "clean-x",
-      category: "rhetorical-tic",
-      severity: "info",
-      # The quiet half of cleanest-x, at info because the positive degree is
-      # where ordinary usage lives. "A clean separation of concerns" is
+      category: "self-rating",
+      severity: "warning",
+      confidence: "medium",
+      # The quiet half of cleanest-x, at medium confidence because the positive
+      # degree is where ordinary usage lives. "A clean separation of concerns" is
       # standard engineering English, so "separation" stays out of the list;
       # "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.',
@@ -939,13 +1072,14 @@ module Sloplint
         "The report gives a clean bill of health."
       ],
       rationale: "'Clean' in front of an idea is evaluation, not description -- it says the " \
-                 "writer approves, and nothing about the idea. It ships at info because the " \
-                 "same words carry a plain sense a regex cannot separate from the tic."
+                 "writer approves, and nothing about the idea. The same words carry a plain " \
+                 "sense a regex cannot separate from the tic."
     ),
     Rule.new(
       id: "you-already-know",
-      category: "rhetorical-tic",
+      category: "reader-address",
       severity: "warning",
+      confidence: "high",
       pattern: /\byou\s+already\s+know\b/i,
       message: '"You already know…" is a stock LLM rhetorical setup.',
       suggestion: "Just make the point; don't tell the reader they know it.",
@@ -955,8 +1089,9 @@ module Sloplint
     ),
     Rule.new(
       id: "is-the-entire",
-      category: "rhetorical-tic",
+      category: "closer",
       severity: "warning",
+      confidence: "high",
       pattern: /\bis\s+the\s+entire\s+(?:point|game|thing|business\s+model|deal|story)\b/i,
       message: '"X is the entire point/game/…" is an LLM emphasis tic.',
       suggestion: "State the point plainly without the superlative frame.",
@@ -966,8 +1101,9 @@ module Sloplint
     ),
     Rule.new(
       id: "the-entire-is",
-      category: "rhetorical-tic",
+      category: "closer",
       severity: "warning",
+      confidence: "high",
       pattern: /\bthe\s+entire\s+(?:point|game|thing|business\s+model|deal|story)\s+is\b/i,
       message: '"The entire point/game/… is" is an LLM emphasis tic.',
       suggestion: "State the point plainly without the superlative frame.",
@@ -977,8 +1113,9 @@ module Sloplint
     ),
     Rule.new(
       id: "is-real-and-not",
-      category: "rhetorical-tic",
-      severity: "info",
+      category: "false-concession",
+      severity: "warning",
+      confidence: "medium",
       pattern: /\bis\s+real,?\s+(?:and|but|not)\b/i,
       message: '"The X is real, and…" is a stock LLM concession move.',
       suggestion: "Drop the 'is real, and' scaffolding; assert the point directly.",
@@ -997,10 +1134,110 @@ 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: "cadence",
+      severity: "info",
+      confidence: "medium",
+      # 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",
+      category: "self-rating",
       severity: "warning",
+      confidence: "high",
       # Same reveal, three nouns. "honest answer" and "honest version" join
       # "punchline" because they do the identical job: rate the sentence as
       # the candid one before the reader gets it. "short version" was tried
@@ -1025,8 +1262,9 @@ module Sloplint
     ),
     Rule.new(
       id: "worth-naming",
-      category: "rhetorical-tic",
-      severity: "info",
+      category: "self-rating",
+      severity: "warning",
+      confidence: "medium",
       # Widened to optionally include a trailing "names" so the "naming
       # names" idiom is part of the matched text -- skip: checks the matched
       # text itself, and the tighter /\bworth\s+naming\b/ never captured
@@ -1063,8 +1301,9 @@ module Sloplint
     ),
     Rule.new(
       id: "worth-saying-plainly",
-      category: "rhetorical-tic",
+      category: "self-rating",
       severity: "warning",
+      confidence: "high",
       # Two branches, both sentence-initial.
       #
       # First: evaluative adjective + speech verb + manner adverb, all three
@@ -1116,8 +1355,9 @@ module Sloplint
     ),
     Rule.new(
       id: "not-nothing",
-      category: "rhetorical-tic",
+      category: "false-concession",
       severity: "warning",
+      confidence: "high",
       # Two branches: spelled-out copula with an optional captured subject, and
       # the contracted "X's not nothing". The optional subject + skip: is the
       # load-bearing idiom -- skip: only sees matched text, so the personal
@@ -1171,8 +1411,9 @@ module Sloplint
 
     Rule.new(
       id: "exact-exactly",
-      category: "rhetorical-tic",
+      category: "self-rating",
       severity: "info",
+      confidence: "medium",
       # Rewritten after 2.2M words of technical prose left ~111 of 125 hits
       # false. The shape was the problem, not the entries: the pattern matched
       # "exact" everywhere and subtracted an allow-list, and an open pattern
@@ -1278,8 +1519,9 @@ module Sloplint
     ),
     Rule.new(
       id: "load-bearing",
-      category: "rhetorical-tic",
+      category: "borrowed-metaphor",
       severity: "warning",
+      confidence: "high",
       # Two guards, both structural, over the same noun list so they can't
       # drift apart. Forward: a physical building part right after it is the
       # literal sense, checked with a negative lookahead. Backward: the
@@ -1328,8 +1570,9 @@ module Sloplint
     ),
     Rule.new(
       id: "intersection-of",
-      category: "rhetorical-tic",
+      category: "borrowed-metaphor",
       severity: "warning",
+      confidence: "high",
       # "at" is not load-bearing -- "explores the intersection of art and
       # technology" is the same move -- so the anchor is "the intersection of"
       # and the two guards carry the whole burden of separating the literal
@@ -1415,8 +1658,9 @@ module Sloplint
     ),
     Rule.new(
       id: "impact-verb",
-      category: "rhetorical-tic",
+      category: "borrowed-metaphor",
       severity: "warning",
+      confidence: "high",
       # "impact" and "impacts" are also nouns, so they only count as verbs
       # behind an auxiliary or a subject pronoun. One optional pronoun may sit
       # between the auxiliary and the verb ("does this impact the date");
@@ -1520,10 +1764,11 @@ module Sloplint
     Rule.new(
       id: "impact-noun-vague",
       category: "puffery",
-      severity: "warning",
+      severity: "error",
+      confidence: "high",
       # Only the puffed shapes: an intensity adjective, or make/have plus an
-      # article. "the impact of X" is left to impact-noun-bare, which sits at
-      # info because it is the standard word in research prose. "positive" and
+      # article. "the impact of X" is left to impact-noun-bare, which takes the
+      # bare form because it is the standard word in research prose. "positive" and
       # "negative" stay out of the adjective list on purpose -- they name a
       # direction, which is more than the intensity words do. "statistically"
       # is pulled into the match as an optional leading word so skip: can see
@@ -1571,8 +1816,9 @@ module Sloplint
     ),
     Rule.new(
       id: "impact-noun-bare",
-      category: "rhetorical-tic",
-      severity: "info",
+      category: "borrowed-metaphor",
+      severity: "warning",
+      confidence: "medium",
       # Two shapes, each needing its own anchor: a measuring verb in front, or
       # "of" behind. That is what keeps the collision sense clear without a
       # list of collision verbs -- "the impact crushed the front bumper" has
@@ -1609,14 +1855,15 @@ module Sloplint
         "Torque the bolts with an impact wrench.",
         "Will the impact be permanent?"
       ],
-      rationale: "This one sits at info because 'the impact of X on Y' is the ordinary word in " \
-                 "research and policy writing, not a tell. Elsewhere it postpones the sentence: " \
-                 "the writer announces that an effect exists and stops before naming it."
+      rationale: "'The impact of X on Y' is the ordinary word in research and policy writing, " \
+                 "not a tell. Elsewhere it postpones the sentence: the writer announces that " \
+                 "an effect exists and stops before naming it."
     ),
     Rule.new(
       id: "thats-how-x",
-      category: "rhetorical-tic",
+      category: "closer",
       severity: "warning",
+      confidence: "high",
       pattern: /(?:\A|[.!?]\s+|\n\s*\n)\s*(?:that|this)(?:'s| is)\s+how\b/i,
       message: '"That\'s how…" opening a sentence is a stock LLM aphorism closer.',
       suggestion: "Cut the closer, or replace it with the concrete result you mean.",
@@ -1632,8 +1879,9 @@ module Sloplint
     ),
     Rule.new(
       id: "announced-takeaway",
-      category: "rhetorical-tic",
+      category: "self-rating",
       severity: "warning",
+      confidence: "high",
       pattern: /(?:\A|[.!?]\s+|\n\s*\n)\s*(?:here'?s\s+)?the\s+(?:loop|pattern|trick|lesson|takeaway|playbook|framing|insight|kicker)\b[^.!?\n]{0,60}:/i,
       message: "Colon-led takeaway label announces the lesson before making it.",
       suggestion: "Give the observation first; let the reader decide it's the takeaway.",
@@ -1649,8 +1897,9 @@ module Sloplint
     ),
     Rule.new(
       id: "is-is",
-      category: "rhetorical-tic",
+      category: "cadence",
       severity: "warning",
+      confidence: "high",
       # No anchor needed -- the doubled copula alone scored 0 across ~1.9M words.
       # The comma is allowed because "What it is, is a mystery" grates the same
       # way. Sentence and clause punctuation still block the weld ("what it is.
@@ -1685,8 +1934,9 @@ module Sloplint
 
     Rule.new(
       id: "earns-its-place",
-      category: "rhetorical-tic",
+      category: "self-rating",
       severity: "warning",
+      confidence: "high",
       # The possessive is the narrowing. "earned a place on the team" and
       # "earn a place in the final" are ordinary; "earns its place" is the
       # metaphor, a thing paying for the room it takes up.
@@ -1710,8 +1960,9 @@ module Sloplint
     ),
     Rule.new(
       id: "does-a-lot-of-work",
-      category: "rhetorical-tic",
+      category: "self-rating",
       severity: "warning",
+      confidence: "high",
       # Two arms, both narrowed away from the ordinary sense.
       #
       # "a lot of work" needs a locative ("here", "in that sentence") because
@@ -1743,8 +1994,9 @@ module Sloplint
     ),
     Rule.new(
       id: "failure-mode-here",
-      category: "rhetorical-tic",
+      category: "borrowed-metaphor",
       severity: "warning",
+      confidence: "high",
       # "here" is the whole narrowing, and it is doing a lot -- the bare "the
       # failure mode is" is ordinary engineering writing about real systems,
       # where the phrase means what it says. The deictic is what marks the
@@ -1770,8 +2022,9 @@ module Sloplint
     ),
     Rule.new(
       id: "thats-the-tension",
-      category: "rhetorical-tic",
+      category: "closer",
       severity: "warning",
+      confidence: "high",
       # Sentence-initial, only two nouns, and the noun must end the clause.
       #
       # "tradeoff" and "catch" were tried and cut: both are ordinary English
@@ -1804,8 +2057,9 @@ module Sloplint
     ),
     Rule.new(
       id: "right-up-until",
-      category: "rhetorical-tic",
+      category: "closer",
       severity: "warning",
+      confidence: "high",
       # The intensifier is the tell, not the reversal. "It works until it
       # doesn't" is an old human idiom and stays clean; stacking "right up"
       # in front of it is the model's version, and the two together are two
@@ -1830,8 +2084,9 @@ module Sloplint
     ),
     Rule.new(
       id: "two-things-true",
-      category: "rhetorical-tic",
-      severity: "warning",
+      category: "false-concession",
+      severity: "error",
+      confidence: "high",
       # Closed phrase, no anchor needed. The optional "both" and the optional
       # "at once" tail are the two ways the sentence is padded; the count word
       # is fixed at two, because "three things can be true" is someone
@@ -1856,8 +2111,9 @@ module Sloplint
     ),
     Rule.new(
       id: "notice-what-there",
-      category: "rhetorical-tic",
+      category: "reader-address",
       severity: "warning",
+      confidence: "high",
       # The self-referential half of the attention cue: the sentence points
       # at the writing rather than at anything in the world. Two frames, both
       # sentence-initial -- "notice what X did there" and the bare "read that
@@ -1885,8 +2141,9 @@ module Sloplint
     ),
     Rule.new(
       id: "notice-what",
-      category: "rhetorical-tic",
+      category: "reader-address",
       severity: "info",
+      confidence: "medium",
       # The ambiguous half of the pair, and it ships at info because the
       # sentence-initial imperative is also how people point at something
       # real: "Notice what happens around Q3", "Notice what is not on the
@@ -1917,8 +2174,9 @@ module Sloplint
     ),
     Rule.new(
       id: "none-of-this-is-to-say",
-      category: "rhetorical-tic",
-      severity: "warning",
+      category: "false-concession",
+      severity: "error",
+      confidence: "high",
       # Only the "none of" form. Every neighbouring phrasing is ordinary
       # English by an order of magnitude -- "which is not to say", "this is
       # not to say", "that's not to say" -- and admitting any of them would
@@ -1944,10 +2202,11 @@ module Sloplint
     ),
     Rule.new(
       id: "if-im-being-honest",
-      category: "rhetorical-tic",
-      severity: "info",
+      category: "false-concession",
+      severity: "warning",
+      confidence: "medium",
       # The "being honest" frame only. Plain "to be honest" and "I'll be
-      # honest" are how people talk and are excluded. info, not warning:
+      # honest" are how people talk and are excluded. Medium confidence:
       # writers really do say this out loud.
       pattern: /\bif\s+(?:I['’]?m|I\s+am|we['’]?re|we\s+are)\s+(?:being\s+)?honest\b
                 |\bhonestly,\s+the\s+(?:answer|truth)\b/ix,
@@ -1969,8 +2228,9 @@ module Sloplint
     ),
     Rule.new(
       id: "honestly",
-      category: "rhetorical-tic",
+      category: "self-rating",
       severity: "warning",
+      confidence: "high",
       # The manner adverb, the way "cleanly" is the manner adverb: hung on a
       # subject that cannot be honest. Two guards, no verb list.
       #
@@ -2020,8 +2280,9 @@ module Sloplint
     ),
     Rule.new(
       id: "honest-x",
-      category: "rhetorical-tic",
+      category: "self-rating",
       severity: "warning",
+      confidence: "high",
       # The noun list is short on purpose, and the words left out are the
       # point. "An honest answer", "an honest assessment" and "an honest
       # account" are ordinary English about people -- six hits between them in
@@ -2035,8 +2296,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: [
@@ -2064,8 +2324,9 @@ module Sloplint
     ),
     Rule.new(
       id: "most-honest-x",
-      category: "rhetorical-tic",
-      severity: "warning",
+      category: "self-rating",
+      severity: "error",
+      confidence: "high",
       # The superlative frame carries the tell on its own, so this noun list is
       # wider than honest-x's -- "the most honest assessment" is self-ranking
       # in a way "an honest assessment" is not. The list still has to keep out
@@ -2073,9 +2334,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.',
@@ -2099,14 +2361,14 @@ module Sloplint
     ),
     Rule.new(
       id: "genuinely",
-      category: "rhetorical-tic",
+      category: "self-rating",
       severity: "info",
+      confidence: "low",
       # Off by default. There is no narrowing here: the word is ordinary
       # English at every frequency we measured, and the difference between
       # the tell and the real use is whether a contrast exists in the
       # surrounding argument, which no regex can see. Selectable when a
       # writer wants every occurrence listed back to them.
-      default_on: false,
       pattern: /\bgenuinely\b/i,
       message: '"Genuinely" asserts sincerity instead of earning it (heuristic; high false-positive).',
       suggestion: "Cut the adverb. If the sentence needs it, the claim is doing the work.",
@@ -2126,10 +2388,78 @@ 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: "false-correction",
+      severity: "warning",
+      confidence: "high",
+      # 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",
-      severity: "info",
+      category: "false-concession",
+      severity: "warning",
+      confidence: "medium",
       # Three narrowings, and the rule needs all of them. "and" is required:
       # bare "that's fine" is a reply people write constantly. The match must
       # open a sentence and close it, so the concessive clause -- "and that's
@@ -2153,8 +2483,9 @@ module Sloplint
     ),
     Rule.new(
       id: "and-nothing-else",
-      category: "rhetorical-tic",
+      category: "closer",
       severity: "warning",
+      confidence: "high",
       # This rule is deliberately wide, and the cost is known. There is no verb
       # list and no imperative requirement, so the only narrowing is structural
       # -- which means the pattern cannot tell a leaked instruction from the
@@ -2212,8 +2543,9 @@ module Sloplint
     ),
     Rule.new(
       id: "nothing-else-frag",
-      category: "rhetorical-tic",
+      category: "closer",
       severity: "warning",
+      confidence: "high",
       # The same exclusion as its own sentence: "Return the JSON. Nothing
       # else." Built on the no-x-no-y-frag template -- the fragment must start
       # at a sentence boundary and the separator is at most two spaces or one
@@ -2249,18 +2581,18 @@ module Sloplint
         # letter guard is there to exclude.
         "and so on; nothing more."
       ],
-      rationale: "The fragment form of the same leaked instruction, and it reads the same way: " \
-                 "a second sentence that only says the first one was complete. It ships at " \
-                 "warning rather than info because the capital letter and the whole-sentence " \
-                 "requirement keep it off the continuation sense, which is where ordinary prose " \
-                 "puts the phrase: one hit in 1.92M words of public-domain prose and one in " \
-                 "461k words of pre-2022 Hacker News."
+      rationale: "The fragment form of the same leaked instruction, and it reads the same " \
+                 "way: a second sentence that only says the first one was complete. The " \
+                 "capital letter and the whole-sentence requirement keep it off the " \
+                 "continuation sense, which is where ordinary prose puts the phrase: one hit " \
+                 "in 1.92M words of public-domain prose and one in 461k words of pre-2022 " \
+                 "Hacker News."
     ),
-    # ── puffery ───────────────────────────────────────────────────────────
     Rule.new(
       id: "puffery-words",
       category: "puffery",
-      severity: "warning",
+      severity: "error",
+      confidence: "high",
       # "nestled" alone is the literal verb as often as the puffery sense --
       # a head nestling against a shoulder, a kitten nestling into a blanket
       # -- so it requires a following in/among/between, the same shape the
@@ -2296,7 +2628,8 @@ module Sloplint
     Rule.new(
       id: "stands-serves-as",
       category: "puffery",
-      severity: "info",
+      severity: "warning",
+      confidence: "medium",
       pattern: /\b(?:stands|serves)\s+as\b|\bis\s+a\s+(?:testament|reminder)\s+to\b/i,
       message: '"stands/serves as", "is a testament/reminder to" is puffed AI framing.',
       suggestion: "Say what it does, not what it 'stands as'.",
@@ -2307,7 +2640,8 @@ module Sloplint
     Rule.new(
       id: "vital-role",
       category: "puffery",
-      severity: "warning",
+      severity: "error",
+      confidence: "high",
       pattern: /\bplays?\s+a\s+(?:vital|crucial|pivotal|significant|key|central)\s+role\b/i,
       message: '"plays a vital/crucial/… role" is a stock AI puffery phrase.',
       suggestion: "State the specific role or effect instead.",
@@ -2318,7 +2652,8 @@ module Sloplint
     Rule.new(
       id: "underscores-highlights",
       category: "puffery",
-      severity: "info",
+      severity: "warning",
+      confidence: "medium",
       # "underscored/underscoring" are unambiguously the verb and flag bare.
       # "underscore/underscores" is also the character noun (a leading
       # underscore, snake_case docs), so those forms require a following
@@ -2359,15 +2694,16 @@ module Sloplint
         "Numbers accept underscores\n\nThe next section covers floats."
       ],
       rationale: "Models reach for 'underscore' as an all-purpose emphasis verb -- findings " \
-                 "underscore, outages underscore -- asserting significance without earning it. " \
-                 "Sincere journalistic and academic use exists, hence info: a flag means the " \
-                 "move is present, not that it's slop. The character noun never takes the " \
-                 "verb's frame and stays out."
+                 "underscore, outages underscore -- asserting significance without earning " \
+                 "it. Sincere journalistic and academic use exists: a flag means the move is " \
+                 "present, not that it's slop. The character noun never takes the verb's " \
+                 "frame and stays out."
     ),
     Rule.new(
       id: "rich-tapestry",
       category: "puffery",
-      severity: "warning",
+      severity: "error",
+      confidence: "high",
       pattern: /\brich\s+tapestry\b|\btapestry\s+of\b/i,
       message: '"rich tapestry"/"tapestry of" is a signature AI cliché.',
       suggestion: "Cut the metaphor; name the actual things.",
@@ -2376,11 +2712,11 @@ module Sloplint
       rationale: "'tapestry of' is one of the most reliable single-phrase model tells."
     ),
 
-    # ── structure ─────────────────────────────────────────────────────────
     Rule.new(
       id: "not-just-x-but-y",
-      category: "structure",
+      category: "false-correction",
       severity: "warning",
+      confidence: "high",
       # Two branches, both anchored on an explicit escalation word. (1) The
       # copula escalation: "is not just/only/merely/simply/solely A … but B".
       # (2) "not because A, but because B". The escalation word is what makes
@@ -2424,10 +2760,11 @@ module Sloplint
     ),
     Rule.new(
       id: "not-x-but-y",
-      category: "structure",
-      severity: "info",
+      category: "false-correction",
+      severity: "warning",
+      confidence: "medium",
       # The bare corrective: "is not A but B", no escalation word, comma or no
-      # comma. Ships at info because the line between a corrective ("not an
+      # comma. Medium confidence, because the line between a corrective ("not an
       # accident but a strategy") and an ordinary concession ("not warm but the
       # fire helped") is syntactic, and a regex cannot see syntax. What is here
       # is a set of cheap narrowings that cut the worst of the noise: A is
@@ -2441,7 +2778,8 @@ module Sloplint
       # ("was not warm but the fire helped") or a bare lexical verb ("was not
       # perfect but got us there"), because neither is distinguishable from the
       # corrective by surface form. That is the cost of the rule and the reason
-      # it is info: the agent reading the flag has the context to judge, and
+      # its confidence is medium: the agent reading the flag has the context
+      # to judge, and
       # should. Do not chase these by growing the B-list -- every word added
       # silently narrows recall with nothing pinning it.
       pattern: /(?:\bis|\bare|\bwas|\bwere|\bisn['’]t|\baren['’]t|\bwasn['’]t|\bweren['’]t|
@@ -2488,15 +2826,16 @@ module Sloplint
                  "escalation word dropped, and models reach for it constantly. It is the " \
                  "noisiest rule in the catalog by design: a loose version scored 174 hits " \
                  "before narrowing, cut to 15 here -- but not all 15 are correctives. Some " \
-                 "are concessions with an elided subject (Walden's " \
-                 "'It was not lonely, but made all the earth lonely beneath it'), which no " \
-                 "surface pattern can tell apart from the real thing. Hence info: a flag here " \
-                 "means 'this has the shape', not 'this is slop'."
+                 "are concessions with an elided subject (Walden's 'It was not lonely, but " \
+                 "made all the earth lonely beneath it'), which no surface pattern can tell " \
+                 "apart from the real thing. A flag here means 'this has the shape', not " \
+                 "'this is slop'."
     ),
     Rule.new(
       id: "isnt-x-its-y",
-      category: "structure",
-      severity: "info",
+      category: "false-correction",
+      severity: "warning",
+      confidence: "medium",
       # The corrective with the conjunction dropped: one clause rejects a
       # description, the next supplies the replacement through a second copula
       # ("It isn't the tool. It's the habit."). Every copula tense is covered,
@@ -2512,7 +2851,8 @@ module Sloplint
       # guards cut a loose version from 19 hits to 4 over 889k words of
       # 19th-century fiction.
       #
-      # What survives is the reason for info. An adjective outside the list
+      # What survives is the reason the confidence is medium. An adjective
+      # outside the list
       # still slips through, and some hits are the same shape written by a
       # person -- "was not the wife; it was the children" is Conan Doyle. A flag
       # here says the sentence has the frame, not that a model wrote it.
@@ -2584,13 +2924,14 @@ module Sloplint
                  "one, so the sentence sounds like a correction while correcting nobody. It " \
                  "is 'not A but B' with the conjunction dropped and the second half promoted " \
                  "to its own clause, which is the form models reach for most. Ordinary prose " \
-                 "contrasts two things this way too, so the rule ships at info: it reports " \
-                 "the shape, not a verdict."
+                 "contrasts two things this way too, so the rule reports the shape, not a " \
+                 "verdict."
     ),
     Rule.new(
       id: "not-by-x-but-by-y",
-      category: "structure",
-      severity: "info",
+      category: "false-correction",
+      severity: "warning",
+      confidence: "medium",
       # The corrective built on a repeated preposition: "not by A, but by B",
       # "not from A but from B". The copula rules above cannot see it because
       # nothing precedes "not" but the verb or a dash, so the anchor here is
@@ -2631,22 +2972,28 @@ module Sloplint
         "We won not by luck\n\nBut by then it hardly mattered."
       ],
       rationale: "The 'not A but B' corrective with the copula swapped for a repeated " \
-                 "preposition, which is how a model corrects a claim about means or " \
-                 "cause ('not by luck, but by design'). People write it too -- Thoreau " \
-                 "and Melville both lean on it -- so the rule ships at info. It reports " \
-                 "the shape; a human reader decides whether it earned its place."
+                 "preposition, which is how a model corrects a claim about means or cause " \
+                 "('not by luck, but by design'). People write it too -- Thoreau and Melville " \
+                 "both lean on it -- and the rule reports the shape; a human reader decides " \
+                 "whether it earned its place."
     ),
     Rule.new(
       id: "rule-of-three",
-      category: "structure",
+      category: "cadence",
       severity: "info",
-      default_on: false,
+      confidence: "low",
       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
@@ -2660,8 +3007,9 @@ module Sloplint
     # CLAUDE.md: some tells can't be regexes; this was one.
     Rule.new(
       id: "everyone-nobody",
-      category: "structure",
+      category: "cadence",
       severity: "warning",
+      confidence: "high",
       # The comma-spliced antithesis on quantifier subjects: "Everyone wants
       # the dashboard, nobody maintains it." One clause opens on
       # everyone/everybody, the other on nobody/no one/none or "one N"
@@ -2733,8 +3081,9 @@ module Sloplint
     ),
     Rule.new(
       id: "np-fragment-and",
-      category: "structure",
-      severity: "info",
+      category: "cadence",
+      severity: "warning",
+      confidence: "medium",
       # A whole sentence that is two noun phrases and an "and": "A named owner
       # and a quarterly review." It is the fix half of a model's
       # problem-then-fix pair, with the verb left for the reader to supply.
@@ -2745,7 +3094,7 @@ module Sloplint
       # anywhere in it, contractions included, so "A man and a woman were
       # there." and "A man and a woman aren't here." never match.
       #
-      # Ships at info, and this is why: a lexical verb is invisible to the
+      # Medium confidence, and this is why: a lexical verb is invisible to the
       # pattern, so "A car and a truck collided." has the same shape and
       # flags. The corpora say that sentence is rare (one hit in 1.25M words
       # of public-domain prose, most of it narrative), but it is a complete
@@ -2788,8 +3137,9 @@ module Sloplint
     ),
     Rule.new(
       id: "quip-question",
-      category: "structure",
+      category: "reader-address",
       severity: "info",
+      confidence: "medium",
       # The verbless question that opens a pitch: "No invite?", "New to the
       # tool?", "Still stuck?", "Ready to start?". It must start a sentence,
       # open on one of a short list of words, run one to four more words, and
@@ -2835,8 +3185,9 @@ module Sloplint
     ),
     Rule.new(
       id: "mic-drop-closer",
-      category: "structure",
+      category: "cadence",
       severity: "info",
+      confidence: "medium",
       # The kicker: a sentence of at least sixty characters, then a closer of
       # two to eight words that ends the paragraph and opens on a quantifier
       # ("Nothing here needs a new login.", "Most teams end up
@@ -2859,7 +3210,7 @@ module Sloplint
       # position." The quantifiers carry the tell; the demonstratives are
       # ordinary, and no examples_bad used one.
       #
-      # Ships at info, and the rationale says why: people end paragraphs this
+      # Medium confidence, and the rationale says why: people end paragraphs this
       # way too, at about 150 per million words on Hacker News. One is
       # nothing. A draft where most paragraphs end this way is the tell, and
       # an agent that sees the flag repeat should read the family as a
@@ -2872,7 +3223,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,10 +3266,96 @@ 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: "bare-auxiliary-closer",
+      category: "cadence",
+      severity: "info",
+      confidence: "medium",
+      # 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. 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",
+      category: "cadence",
       severity: "info",
+      confidence: "medium",
       # Three consecutive sentences of thirty characters or fewer, each
       # opening on a letter and closing on a full stop, with no quotation
       # mark or digit in any of them: "Nobody used it. A named owner. Then a
@@ -3055,8 +3492,9 @@ module Sloplint
     ),
     Rule.new(
       id: "em-dash",
-      category: "structure",
+      category: "punctuation",
       severity: "info",
+      confidence: "medium",
       pattern: /—/,
       message: "Em dash — an AI punctuation tell.",
       suggestion: "Recast with a comma, parentheses, or a separate sentence.",
@@ -3075,8 +3513,9 @@ module Sloplint
     ),
     Rule.new(
       id: "em-dash-overuse",
-      category: "structure",
+      category: "punctuation",
       severity: "warning",
+      confidence: "high",
       pattern: /—(?:[^\n]|\n(?!\s*\n))*—(?:[^\n]|\n(?!\s*\n))*—/,
       message: "Three or more em dashes in one paragraph — an AI punctuation tell.",
       suggestion: "Recast with commas, parentheses, or separate sentences.",
@@ -3098,8 +3537,9 @@ module Sloplint
 
     Rule.new(
       id: "question-isnt",
-      category: "structure",
-      severity: "info",
+      category: "false-correction",
+      severity: "warning",
+      confidence: "medium",
       # The resolving clause is required, so a plain rhetorical question never
       # matches. "The real question is" is ordinary English and is excluded by
       # the adjacency of "question" to the negated copula.
@@ -3125,8 +3565,9 @@ module Sloplint
     ),
     Rule.new(
       id: "less-about-more-about",
-      category: "structure",
-      severity: "info",
+      category: "false-correction",
+      severity: "warning",
+      confidence: "medium",
       # The full frame is required at both ends. Bare "less about" and bare
       # "more about" are ordinary English on their own, and the subject slot
       # is limited to the pronouns so that a sentence with a real subject --
@@ -3152,8 +3593,9 @@ module Sloplint
     ),
     Rule.new(
       id: "trailing-significance-participle",
-      category: "structure",
-      severity: "warning",
+      category: "puffery",
+      severity: "error",
+      confidence: "high",
       # The verb list is closed and short on purpose. Wikipedia's "signs of AI
       # writing" names eight watch words for this construction; half of them
       # did not survive probing. In 1.85M words of pre-2022 Hacker News and
@@ -3228,11 +3670,103 @@ 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."
     ),
-    # ── hedging ───────────────────────────────────────────────────────────
     Rule.new(
-      id: "vague-attribution",
-      category: "hedging",
+      id: "trailing-restatement",
+      category: "closer",
       severity: "warning",
+      confidence: "low",
+      # 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."
+    ),
+    Rule.new(
+      id: "vague-attribution",
+      category: "false-concession",
+      severity: "error",
+      confidence: "high",
       pattern: /\bsome\s+(?:critics|experts|observers|scholars|analysts)\s+(?:argue|say|believe|contend|maintain)\b|\bit\s+is\s+widely\s+(?:regarded|considered|seen|believed|acknowledged)\b|\bmany\s+would\s+argue\b/i,
       message: "Vague attribution ('some critics argue', 'it is widely…') — an AI hedging tell.",
       suggestion: "Name the source, or drop the appeal to unnamed authority.",