sloplint 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2530123f6520e2abc31a875cc53787cc4492669c2bc7919c5ab19fa3541601a1
-  data.tar.gz: 61b2542547165a0f8e632c2ce89a679386edc8bbde24a71f92f69091603bf6e8
+  metadata.gz: 846ce6e663bb01d1dd3e054f328eaccb423745aeb34def94b8ce33253d960c23
+  data.tar.gz: f165880bb800c66a57d88ffd7e9876c4426a7607a6f4b68582d8f0365c728956
 SHA512:
-  metadata.gz: 607445e1bdb23eacb5d460b01e72d1ebb140136974c7988ebdd023c7db4cccfd4540e1e4ddb68031938fe936d73d173c52d0818d3573ea045cbbc0b7db46696c
-  data.tar.gz: 55faafabedfbde617ea5cfed7e3ac89a3e7e82f24521346b21b6ddc3fe0a775e41dd1bfeacc5860326fcfaa7ab006316a9b9ab6b09fbe956678cf6de172a71c5
+  metadata.gz: ef1d295149a0b032fc000795316d385331a679aa246dcf4177c902a4589745e91f63d728e7a5b6ceb0c5323902c3079b1e588580f5bbbc08e07f9a19d2560a00
+  data.tar.gz: bd0530c68b5dac9587580b79fffdd52bfed59ab847c18ecd1e3a164c906cd6f745cb7409278283876b3dcdf5ba7309459b422e047cc73c2406984569b6215bfa

data/CHANGELOG.md

@@ -3,7 +3,52 @@
 All notable changes to this project are documented here. Format loosely
 follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
-## [0.1.0] - Unreleased
+## [0.2.0] - 2026-07-28
+
+- `is-real-and-not` and `worth-naming` move from `warning` to `info`. Both
+  patterns match on surface form alone and can't tell the AI cadence from an
+  unrelated sentence that happens to share it: "is real, and/but/not" fires on
+  any predicate-adjective sentence regardless of what follows the conjunction
+  ("my debt to my senses is real and constant" -- Emerson), and "worth naming"
+  collapses the AI meta-signpost with the plain sense of a thing worth
+  mentioning ("the only thing worth naming to do that" -- Emerson). Probed
+  against a 1.06M-word corpus (Austen, Melville, Madison, Thoreau, Emerson);
+  the other 19 rules still at `warning` were probed too and held up clean.
+- `puffery-words`' bare `nestled` matched the literal verb as often as the
+  puffery sense -- a head nestled against a shoulder, a kitten nestled into a
+  blanket. It now requires a following in/among/between, the shape the
+  travel-brochure cliché actually takes ("nestled in the hills").
+- New rule `not-x-but-y` (`structure`, `info`): the bare corrective "is not A
+  but B" with no escalation word, comma before "but" or none. Ships at `info`
+  because the line between a corrective and an ordinary concession is
+  syntactic, and a pattern can only approximate it — a concession with an
+  elided subject ("was not perfect but got us there") still gets through.
+- New rule `no-x-no-y-frag` (`rhetorical-tic`, `info`): the "no X, no Y"
+  cadence built from sentence fragments ("No fluff. No filler.") rather than
+  commas. `info`, not `warning`, because two short "no" sentences in a row is
+  also just writing.
+- `not-just-x-but-y` now also catches "not because A, but because B" and the
+  escalation words `merely`, `simply`, and `solely` alongside `just`/`only`.
+  It keeps `warning`: the escalation word is a deliberate authorial move.
+- Both `not-…-but-…` rules now stop at a paragraph break, so an unpunctuated
+  heading or list item no longer joins up with the next paragraph's "But …".
+- `no-x-no-y-frag` links must begin a sentence, so an ordinary sentence can no
+  longer donate its tail to a chain ("There was no bread. No milk either." is
+  one sentence and one fragment, not a chain), and the link separator is
+  capped at two spaces so a code span blanked by `--markdown` cannot weld two
+  distant fragments together.
+- `sloplint explain` no longer breaks its aligned fixture block when a fixture
+  contains a newline; those are escaped as `\n`.
+- Notes carry a new `context` field: the match bracketed inside ~40 characters
+  of surrounding prose. Human output shows it in place of the bare match, which
+  told you nothing when the match was a single word or a lone em dash. `excerpt`
+  is unchanged and still the bare match.
+- New rule `em-dash` (`structure`, `info`): flags every em dash, not just
+  paragraphs dense with them.
+- `em-dash-overuse` (3+ em dashes in one paragraph) is now `warning`, up from
+  `info`.
+
+## [0.1.0] - 2026-07-24
 
 First public release.
 

data/README.md

@@ -40,20 +40,25 @@ cat draft.md | sloplint check --markdown -o json -
 The human-readable form drops `-o json`:
 
 ```
-$ echo "A rich tapestry of vibrant cultures. That's exactly the point." | sloplint check -
--:1:3: warning rich-tapestry  "rich tapestry"/"tapestry of" is a signature AI cliché.
-    excerpt: rich tapestry
+$ printf 'The report is a rich tapestry of vibrant detail.\nThat is exactly the point I keep making about it.\n' | sloplint check -
+-:1:17: warning rich-tapestry  "rich tapestry"/"tapestry of" is a signature AI cliché.
+    excerpt: The report is a [rich tapestry] of vibrant detail. That is exactly the…
+    why: 'tapestry of' is one of the most reliable single-phrase model tells.
     fix: Cut the metaphor; name the actual things.
 
--:1:20: warning puffery-words  Wikipedia-style puffery word/phrase — a common AI tell.
-    excerpt: vibrant
+-:1:34: warning puffery-words  Wikipedia-style puffery word/phrase — a common AI tell.
+    excerpt: The report is a rich tapestry of [vibrant] detail. That is exactly the point I…
+    why: Travel-brochure adjectives and phrases that models reach for and careful writers avoid.
     fix: Replace with a concrete, specific detail or cut it.
 
--:1:38: warning exactly-the  "exactly the point/kind/problem/…" is an overused LLM emphasis tic.
-    excerpt: That's exactly the point
+-:2:9: warning exactly-the  "exactly the point/kind/problem/…" is an overused LLM emphasis tic.
+    excerpt: …tapestry of vibrant detail. That is [exactly the point] I keep making about it.
+    why: 'exactly the X' is a model intensifier that a careful writer rarely leans on.
     fix: Drop 'exactly the'; state the point without the intensifier.
 ```
 
+The brackets mark the match; the rest is there so you can see what you're fixing without opening the file — including *why*, so an agent doesn't have to run `explain` separately to decide whether a flag is worth acting on.
+
 ## Commands
 
 ```
@@ -79,7 +84,7 @@ no-x-no-y  (rhetorical-tic, warning)
 
 "No X, no Y" chain (%{count} items) reads as AI cadence.
 
-Why: LLMs love asyndetic negation triplets. A careful writer rarely stacks three.
+Why: Asyndetic negation chains are a signature model cadence, near-absent from human prose at any length -- 24 hits in 1.02M words across Austen, Melville, Madison, Thoreau, and Emerson combined. A careful writer occasionally stacks two (and, rarely, more), but a model reaches for the pattern constantly.
 Fix: Cut the chain or make it one plain sentence.
 
 Flags:    No fluff, no filler, no jargon.
@@ -100,12 +105,14 @@ One match is one note. JSON output is an array of these, or an object keyed by p
   "category": "rhetorical-tic",
   "message": "\"No X, no Y\" chain (3 items) reads as AI cadence.",
   "excerpt": "No fluff, no filler, no jargon",
+  "context": "The report was blunt. [No fluff, no filler, no jargon]. Nothing held back at all.",
   "count": 3,
+  "rationale": "Asyndetic negation chains are a signature model cadence, near-absent from human prose at any length -- 24 hits in 1.02M words across Austen, Melville, Madison, Thoreau, and Emerson combined. A careful writer occasionally stacks two (and, rarely, more), but a model reaches for the pattern constantly.",
   "suggestion": "Cut the chain or make it one plain sentence."
 }
 ```
 
-`line` and `column` are 1-indexed and point at the start of the match. `count` appears only when the rule tallies items (a "no X, no Y" chain, a "did not, did not" chain). `suggestion` is a short fix hint.
+`line` and `column` are 1-indexed and point at the start of the match. `excerpt` is the bare match; `context` is the same match bracketed inside about 40 characters of surrounding prose, which is what you want when the match is a single word or a lone em dash. A match already 40 characters long carries its own context, so `context` returns it alone rather than padding it further. `count` appears only when the rule tallies items (a "no X, no Y" chain, a "did not, did not" chain). `rationale` is why the pattern is a tell — the same text `sloplint explain` prints — so an agent deciding whether an `info` flag is worth acting on doesn't have to run `explain` separately to find out. `suggestion` is a short fix hint.
 
 ## Exit codes
 
@@ -121,15 +128,17 @@ An unknown id or category in `--select`/`--ignore` is a usage error (exit 2, nam
 
 ## The rule catalog
 
-24 rules across four categories. `sloplint rules` prints them; `sloplint rules --json` gives an agent the enumerable form.
+27 rules across four categories. `sloplint rules` prints them; `sloplint rules --json` gives an agent the enumerable form.
 
-- **rhetorical-tic** (15) the cadence patterns: `no-x-no-y`, `thats-the-whole`, `thats-how-x`, `announced-takeaway`, `exactly-the`, `you-already-know`, `sit-with-that`, `thats-not-nothing`, and more.
+- **rhetorical-tic** (16) the cadence patterns: `no-x-no-y`, `no-x-no-y-frag`, `thats-the-whole`, `thats-how-x`, `announced-takeaway`, `exactly-the`, `you-already-know`, `sit-with-that`, `thats-not-nothing`, and more.
 - **puffery** (5) Wikipedia's "signs of AI writing": `puffery-words` (vibrant, nestled, groundbreaking, in the heart of), `rich-tapestry`, `vital-role`, `stands-serves-as`, `underscores-highlights`.
-- **structure** (3) `not-just-x-but-y`, `em-dash-overuse` (three or more em dashes in a paragraph), and `rule-of-three`.
+- **structure** (5) `not-just-x-but-y`, `not-x-but-y` (the bare corrective), `em-dash` (any em dash), `em-dash-overuse` (three or more in one paragraph), 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.
 
+Some tells come in a confident form and an ambiguous one, and those ship as a pair rather than as one rule stretched over both. `no-x-no-y` wants the comma chain a writer clearly authored; `no-x-no-y-frag` takes the same cadence built from sentence fragments, which ordinary prose also produces, and ships at `info`. Same with `not-just-x-but-y` and `not-x-but-y`. The quiet half is still worth flagging — an agent that reads the rationale can judge — but it should not carry the same weight as the half we're sure about.
+
 One rule ships **off by default**: `rule-of-three` flags three parallel comma items closing a sentence, which humans do all the time, so it false-positives. It runs only when you name it: `sloplint check --select rule-of-three -`.
 
 ### Markdown handling
@@ -142,20 +151,23 @@ Rules are data, not code. Each is a `Data.define` object in `lib/sloplint/rules.
 
 ```ruby
 Rule.new(
-  id:           "no-x-no-y",
-  category:     "rhetorical-tic",
-  severity:     "warning",
-  pattern:      /\bno\s+[\w'-]+,\s+no\s+[\w'-]+(?:,?\s+(?:and\s+)?no\s+[\w'-]+)*/i,
-  message:      '"No X, no Y" chain (%{count} items) reads as AI cadence.',
-  suggestion:   "Cut the chain or make it one plain sentence.",
-  count_group:  /\bno\b/i,                     # optional: a regex tallied over the match
-  skip:         [/real estate/i],              # optional: drop the note if these match
-  examples_bad: ["No fluff, no filler, no jargon."],
-  examples_ok:  ["No parking on Sundays."],
-  rationale:    "Asyndetic negation chains are a signature model cadence, rare in human prose."
+  id:           "rule-id",
+  category:     "rhetorical-tic",              # or puffery, structure, hedging
+  severity:     "warning",                     # or info
+  pattern:      /.../i,
+  message:      "What the reader sees. %{count} interpolates the tally.",
+  suggestion:   "One short fix hint.",
+  count_group:  /.../i,                        # optional: a regex tallied over the match
+  skip:         [/.../i],                      # optional: drop the note if these match
+  default_on:   false,                         # optional: runs only when named in --select
+  examples_bad: ["A sentence the rule must flag."],
+  examples_ok:  ["A sentence it must leave alone."],
+  rationale:    "Why this is a tell, and what it costs when it's wrong."
 )
 ```
 
+`rationale` is not decoration. `sloplint explain` prints it, and that is what an agent reads to decide whether a flag is worth acting on — so it should say what the pattern is, how it was probed, and where it's known to be weak.
+
 Adding a rule is one entry plus its fixtures. `rules_spec.rb` iterates the catalog and asserts every `examples_bad` produces at least one note and every `examples_ok` produces none, so a rule without fixtures, or one whose regex is too greedy, fails the suite.
 
 ## Development

data/docs/SPEC.md

@@ -26,6 +26,31 @@ trust a flag instead of second-guessing it), and no overlap with tools that
 already do general prose well. When a rule is borderline, ask the test again and
 cut it if the answer is soft.
 
+## Provenance: what may be committed
+
+Finding rules means reading a great deal of other people's writing: slop in the
+wild to spot a tell, careful human prose to check a candidate against. Reading it
+is fine. Committing it is not. A regex carries nothing of the text it came from,
+so the source never needs to enter the repository.
+
+- **No corpus is committed**, on either side. Collection notes stay out of the
+  repo.
+- **`examples_bad` are written, not lifted.** When a real sentence is the only
+  illustration on hand, rewrite it until it carries the pattern without carrying
+  the original wording.
+- **`examples_ok` may quote real prose, public domain only**, with the source
+  named in a comment. The Moby-Dick and Federalist No. 44 fixtures are the model.
+  A common idiom or a title is not a quotation and needs no such treatment.
+- **`rationale:` states frequencies, not quotations.** "24 hits in 1.02M words"
+  is the form.
+- **A reference corpus of human prose must be public domain.** Copyrighted text
+  can't be redistributed, so a corpus built from it can't live in the repo, and
+  neither can the false-positive check that depends on it.
+
+This repository is MIT-licensed, so anything committed is redistributable by
+anyone. Writing the fixtures ourselves also means nobody's prose gets held up as
+a specimen of slop, which is reason enough on its own.
+
 ## Prior art we're borrowing from
 
 - **proselint** — subcommand CLI (`check`, `version`, `dump-config`), `--output-format full|json|compact`, LSP-style diagnostics (line/column/severity/code/message), config file, clean exit codes. We copy this shape.
@@ -145,14 +170,28 @@ path when multiple files are scanned).
   "rule": "no-x-no-y",
   "category": "rhetorical-tic",
   "message": "\"No X, no Y\" chain (3 items) reads as AI cadence.",
-  "excerpt": "No fluff, no filler, no jargon.",
+  "excerpt": "No fluff, no filler, no jargon",
+  "context": "The report was blunt. [No fluff, no filler, no jargon]. Nothing held back at all.",
   "count": 3,
+  "rationale": "Asyndetic negation chains are a signature model cadence, near-absent from human prose at any length -- 24 hits in 1.02M words across Austen, Melville, Madison, Thoreau, and Emerson combined. A careful writer occasionally stacks two (and, rarely, more), but a model reaches for the pattern constantly.",
   "suggestion": "Cut the chain or make it one plain sentence."
 }
 ```
 
 - `line`/`column` are 1-indexed, pointing at the start of the match.
+- `excerpt` is the bare match, nothing else. It is what `column` points at.
+- `context` is the match bracketed inside ~40 characters of surrounding prose,
+  whitespace collapsed, with `…` on any end that was cut. It exists because a
+  bare `excerpt` says nothing useful when the match is one word or a lone em
+  dash. A match already 40 characters long carries its own context, so `context`
+  returns it alone rather than padding it out further. The window is sliced from
+  the text as written, so `--markdown` still shows real code and URLs here even
+  though they were blanked before matching.
 - `count` present when the rule counts items (the "badge" in the examples).
+- `rationale` is the same text `sloplint explain` prints under `Why:` — why the
+  pattern reads as a tell. `check` carries it on every note so an agent acting
+  on an `info` flag (or deciding whether to) doesn't have to shell out to
+  `explain` first; that's the whole point of the field.
 - `suggestion` is a short fix hint; agents may use it, humans see it too.
 
 ## Rule model
@@ -211,7 +250,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", em-dash overuse
+- `structure` — rule-of-three, "not just X but Y", 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
@@ -224,7 +263,8 @@ false-positive risk, which none has demonstrated.
 
 | id | catches | notes |
 |----|---------|-------|
-| `no-x-no-y` | 2+ "no …" items in a row | counts items |
+| `no-x-no-y` | 2+ comma-separated "no …" items in a row | counts items |
+| `no-x-no-y-frag` | the same cadence as sentence fragments ("No fluff. No filler.") | counts items; `info` |
 | `thats-the-whole` | "that/this is the whole point/game/thing…" | |
 | `did-not-x-did-not-y` | 2+ "did not …"/"didn't …" in a row | counts items |
 | `dont-verb-it` | "Don't call it X. Call it Y." (negated verb+it, same verb+it) | |
@@ -232,16 +272,16 @@ false-positive risk, which none has demonstrated.
 | `you-already-know` | "you already know" (+ the answer / standalone) | |
 | `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" |
+| `is-real-and-not` | "the X is real, and/not…", "is the real … and it" | skip "real estate/time"; `info` |
 | `the-punchline-is` | "the punchline is/:/?" | |
-| `worth-naming` | "worth naming", "it's worth naming that…", "Worth naming:" | skip "naming names" |
+| `worth-naming` | "worth naming", "it's worth naming that…", "Worth naming:" | skip "naming names"; `info` |
 | `thats-not-nothing` | "that/this/it/which is not nothing" | |
 
 ### puffery (Wikipedia: Signs of AI writing)
 
 Single flat rule per word-cluster, matched as whole words:
 
-- `puffery-words` — boasts a, vibrant, rich (history/cultural/tapestry), nestled, in the heart of (gated to a place object), groundbreaking, renowned, diverse array, breathtaking, natural beauty, stands as a testament, indelible mark, deeply rooted.
+- `puffery-words` — boasts a, vibrant, rich (history/cultural/tapestry), nestled (gated to a following in/among/between, so the literal verb — a head nestled against a shoulder — doesn't count), in the heart of (gated to a place object), groundbreaking, renowned, diverse array, breathtaking, natural beauty, stands as a testament, indelible mark, deeply rooted.
 - `stands-serves-as` — "stands as / serves as", "is a testament/reminder to".
 - `vital-role` — "plays a (vital/crucial/pivotal/significant/key) role".
 - `underscores-highlights` — "underscores/highlights/emphasizes its (importance/significance)".
@@ -249,9 +289,11 @@ Single flat rule per word-cluster, matched as whole words:
 
 ### structure
 
-- `not-just-x-but-y` — "not just X, but (also) Y", "not only … but".
+- `not-just-x-but-y` — copula + "not just/only/merely/simply/solely X … but (also) Y", plus "not because X, but because Y". Requires the escalation word.
+- `not-x-but-y` — the bare corrective "is not X but Y" with no escalation word; `info`, because the corrective/concession distinction is syntactic and the pattern can only approximate it.
 - `rule-of-three` — three parallel comma items ending a sentence (heuristic; `info` severity, off by default via `--select` since it false-positives).
-- `em-dash-overuse` — >N em dashes per paragraph (default N=2); `info`.
+- `em-dash` — any em dash; `info`.
+- `em-dash-overuse` — 3+ em dashes in one paragraph; `warning`.
 
 ### hedging
 
@@ -274,7 +316,7 @@ This is a first-class requirement, not an afterthought.
   # Recommended for agents:
   cat FILE | sloplint check --markdown -o json -
   # exit 0 = clean, 1 = notes found, >1 = error
-  # each note: {path,line,column,severity,rule,message,excerpt,suggestion}
+  # each note: {path,line,column,severity,rule,category,message,excerpt,context,rationale,suggestion}
   ```
 
 - Every option has a full-sentence help string (no telegraphic fragments).
@@ -306,3 +348,7 @@ RSpec (dev dependency), run via `rake spec`.
 - Non-English. Languages other than English are a v2 conversation.
 - ML/embedding-based detection. This is a regex linter on purpose — fast,
   explainable, zero-dependency. Statistical detection is a different product.
+- Scraped corpora. Platform terms prohibit automated collection, and finding a
+  repeated shape needs hundreds of samples rather than millions, so collection
+  stays manual. Analysis is offline development work either way; the shipped
+  runtime stays regex plus stdlib.

data/lib/sloplint/cli.rb

@@ -142,12 +142,20 @@ module Sloplint
         Why: #{rule.rationale}
         Fix: #{rule.suggestion}
 
-        Flags:    #{rule.examples_bad.join("\n          ")}
-        Does not: #{rule.examples_ok.join("\n          ")}
+        Flags:    #{fixture_list(rule.examples_bad)}
+        Does not: #{fixture_list(rule.examples_ok)}
       TXT
       0
     end
 
+    # One fixture per line, aligned under the label. Fixtures may contain
+    # newlines (a chain that survives a hard wrap, one that dies at a paragraph
+    # break), so escape them rather than letting a fixture break the block --
+    # `explain` is parsed by agents, and a stray newline reads as end-of-list.
+    def fixture_list(examples)
+      examples.map { |e| e.gsub("\r", '\r').gsub("\n", '\n') }.join("\n          ")
+    end
+
     # ── helpers ─────────────────────────────────────────────────────────────
     # Ids/categories in refs that match no rule in the catalog. nil (no --select
     # or --ignore given) passes through as no unknowns.
@@ -180,7 +188,7 @@ module Sloplint
           # Recommended for agents:
           cat FILE | sloplint check --markdown -o json -
           # exit 0 = clean, 1 = notes found, >1 = error
-          # each note: {path,line,column,severity,rule,category,message,excerpt,suggestion}
+          # each note: {path,line,column,severity,rule,category,message,excerpt,context,rationale,suggestion}
 
           usage: sloplint [-o full|json] <command> [args]
 

data/lib/sloplint/engine.rb

@@ -6,15 +6,18 @@ module Sloplint
   # One match = one Note. See docs/SPEC.md "Note".
   Note = Data.define(
     :path, :line, :column, :severity, :rule, :category,
-    :message, :excerpt, :count, :suggestion
+    :message, :excerpt, :context, :count, :rationale, :suggestion
   )
 
   module Engine
+    CONTEXT_CHARS = 40
+
     module_function
 
     # text: the source. rules: which Rule objects to run. markdown: blank code/URLs first.
     # path: label carried into each Note (e.g. filename or "-" for stdin).
     def scan(text, rules: RULES, markdown: false, path: "-")
+      source = text
       text = blank_markdown(text) if markdown
       line_starts = line_starts_for(text)
       notes = []
@@ -31,13 +34,40 @@ module Sloplint
             path: path, line: line, column: column,
             severity: rule.severity, rule: rule.id, category: rule.category,
             message: message, excerpt: matched.gsub(/\s+/, " ").strip,
-            count: count, suggestion: rule.suggestion
+            context: context_for(source, m),
+            count: count, rationale: rule.rationale, suggestion: rule.suggestion
           )
         end
       end
       notes.sort_by { |n| [n.line, n.column] }
     end
 
+    # The match plus ~CONTEXT_CHARS either side, bracketed, whitespace collapsed.
+    # A bare `excerpt` is useless for a rule whose match is one character -- see
+    # em-dash, where the note said only "—" and you had to open the file and
+    # count to the column to learn anything.
+    #
+    # Truncated ends get an ellipsis and are trimmed back to a word boundary so
+    # the window doesn't open mid-word. A match already CONTEXT_CHARS long
+    # carries its own context; padding it just makes an em-dash-overuse span
+    # (which can run a whole paragraph) longer for no gain, so those return the
+    # match alone.
+    #
+    # source is the PRE-blanking text. blank_markdown replaces each non-newline
+    # char with one space, so offsets are identical either way, but a window
+    # over blanked text shows code and URLs as a run of spaces. Offsets here are
+    # character offsets (MatchData#begin), matching the char-based line_starts_for.
+    def context_for(source, match)
+      return "[#{match[0].gsub(/\s+/, " ").strip}]" if match[0].length >= CONTEXT_CHARS
+
+      b, e = match.begin(0), match.end(0)
+      pre  = source[[b - CONTEXT_CHARS, 0].max...b]
+      post = source[e, CONTEXT_CHARS].to_s
+      pre  = "…#{pre.sub(/\A\S*\s+/, "")}" if b > CONTEXT_CHARS
+      post = "#{post.sub(/\s+\S*\z/, "")}…" if e + CONTEXT_CHARS < source.length
+      "#{pre}[#{match[0]}]#{post}".gsub(/\s+/, " ").strip
+    end
+
     # 1-indexed line and column for a char offset into text. Binary-searches a
     # precomputed line_starts table (see line_starts_for) so a scan with many
     # notes doesn't re-walk the prefix from offset 0 for every single one --

data/lib/sloplint/output.rb

@@ -12,9 +12,10 @@ module Sloplint
 
       notes.map do |n|
         head = "#{n.path}:#{n.line}:#{n.column}: #{n.severity} #{n.rule}  #{n.message}"
-        excerpt = "    excerpt: #{n.excerpt}"
+        excerpt = "    excerpt: #{n.context}"
+        why = "    why: #{n.rationale}"
         fix = "    fix: #{n.suggestion}"
-        [head, excerpt, fix].join("\n")
+        [head, excerpt, why, fix].join("\n")
       end.join("\n\n")
     end
 

data/lib/sloplint/rules.rb

@@ -22,6 +22,10 @@ module Sloplint
       id: "no-x-no-y",
       category: "rhetorical-tic",
       severity: "warning",
+      # 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),
+      # because periods are not an authorial choice the way commas are.
       pattern: /\bno\s+[\w'-]+,\s+no\s+[\w'-]+(?:,?\s+(?:and\s+)?no\s+[\w'-]+)*/i,
       message: '"No X, no Y" chain (%{count} items) reads as AI cadence.',
       suggestion: "Cut the chain or make it one plain sentence.",
@@ -33,6 +37,51 @@ module Sloplint
                  "Madison, Thoreau, and Emerson combined. A careful writer occasionally stacks " \
                  "two (and, rarely, more), but a model reaches for the pattern constantly."
     ),
+    Rule.new(
+      id: "no-x-no-y-frag",
+      category: "rhetorical-tic",
+      severity: "info",
+      # The same cadence built from sentence fragments: "No fluff. No filler."
+      # Ships at info, not warning, 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.
+      #
+      # Two structural guards keep it from reporting chains that are not in the
+      # text at all. A link must START a sentence, so an ordinary sentence
+      # cannot donate its tail ("There was no bread." + "No milk either." is
+      # one sentence and one fragment, not a chain). And the separator is at
+      # most two spaces, so a blanked-out code span or URL under --markdown
+      # cannot silently weld two distant fragments together. Links may cross a
+      # hard-wrapped newline (\r\n included) but never a paragraph break.
+      pattern: /(?:^|(?<=[.;!?])[ \t]{1,2})\K
+                no[ \t]+[\w'-]+(?:[ \t]+[\w'-]+)?[ \t]*[.;!]
+                (?:(?:[ \t]{1,2}|\r?\n(?!\s*\n)[ \t]*)
+                   (?:and[ \t]+)?no[ \t]+[\w'-]+(?:[ \t]+[\w'-]+)?[ \t]*[.;!])+/ix,
+      message: '"No X. No Y." fragment chain (%{count} items) reads as AI cadence.',
+      suggestion: "Cut the chain or make it one plain sentence.",
+      count_group: /\bno\b/i,
+      examples_bad: [
+        "No fluff. No filler. No jargon.",
+        "No fees; no contracts; no hidden charges.",
+        # Hard-wrapped Markdown: the chain survives one newline.
+        "No fluff.\nNo filler."
+      ],
+      examples_ok: [
+        "No parking on Sundays.",
+        # A link must start a sentence, so this donates no tail.
+        "There was no bread. No milk either.",
+        "Say no more. No worries.",
+        # Two fragments split by a paragraph break never chain.
+        "No answer.\n\nNo one was home when we finally arrived."
+      ],
+      rationale: "The fragment form of the same cadence, and the weaker signal of the two: the " \
+                 "comma chain is one authored sentence, while this is just short sentences in " \
+                 "sequence, which human prose also does. It scored 1 hit in a 744k-word " \
+                 "five-book probe (Hamilton's 'no common coin; no common judicatory', itself " \
+                 "the chain in question), so it is rare in careful writing -- but a deliberate " \
+                 "staccato run ('No one moved. No one spoke.') has the identical shape and is " \
+                 "not a tell. Treat a flag here as a question, not a verdict."
+    ),
     Rule.new(
       id: "thats-the-whole",
       category: "rhetorical-tic",
@@ -114,7 +163,7 @@ module Sloplint
     Rule.new(
       id: "is-real-and-not",
       category: "rhetorical-tic",
-      severity: "warning",
+      severity: "info",
       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.",
@@ -126,7 +175,12 @@ module Sloplint
       # phrasing it could plausibly have been guarding against.
       examples_bad: ["The risk is real, and it is growing."],
       examples_ok: ["This is real leather.", "This is real estate, and it is expensive."],
-      rationale: "'X is real, and/but/not' is a model both-sidesing cadence."
+      rationale: "The pattern requires nothing about what follows the conjunction, so it fires " \
+                 "on any 'is real' sentence that happens to continue with and/but/not, concession " \
+                 "or not. Emerson's 'my debt to my senses is real and constant' is two predicate " \
+                 "adjectives, not a both-sidesing move -- the AI cadence and the plain sentence " \
+                 "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: "the-punchline-is",
@@ -142,7 +196,7 @@ module Sloplint
     Rule.new(
       id: "worth-naming",
       category: "rhetorical-tic",
-      severity: "warning",
+      severity: "info",
       # 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
@@ -153,7 +207,12 @@ module Sloplint
       skip: [/naming names/i],
       examples_bad: ["One tension is worth naming here."],
       examples_ok: ["It's worth reading twice.", "It's worth naming names in this report."],
-      rationale: "'worth naming' is a model signpost that a human would simply skip."
+      rationale: "'worth naming' collapses two senses a regex can't tell apart: the AI " \
+                 "meta-signpost announcing a point is coming ('One tension is worth naming " \
+                 "here') and the plain sense of a thing worth calling or mentioning, which " \
+                 "careful writers use too -- Emerson's 'the only thing worth naming to do that' " \
+                 "is the latter, not the former. A flag here means the phrase is present, not " \
+                 "which sense it's in."
     ),
     Rule.new(
       id: "thats-not-nothing",
@@ -218,7 +277,11 @@ module Sloplint
       id: "puffery-words",
       category: "puffery",
       severity: "warning",
-      pattern: /\b(?:boasts\s+a\b|vibrant|nestled|
+      # "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
+      # travel-brochure cliché actually takes ("nestled in the hills").
+      pattern: /\b(?:boasts\s+a\b|vibrant|nestled\b(?:\s+\S+){0,2}?\s+(?:in|among|between)\b|
                   in\s+the\s+heart\s+of\s+(?:the\s+\w+|downtown\b|(?-i:[A-Z])\w+)|
                   groundbreaking|renowned|diverse\s+array|breathtaking|
                   natural\s+beauty|indelible\s+mark|deeply\s+rooted|
@@ -227,7 +290,8 @@ module Sloplint
       suggestion: "Replace with a concrete, specific detail or cut it.",
       examples_bad: [
         "The vibrant city, nestled in the heart of the valley.",
-        "A boutique hotel in the heart of Paris."
+        "A boutique hotel in the heart of Paris.",
+        "A cottage nestled snugly among the pines."
       ],
       examples_ok: [
         "The city sits at the north end of the valley.",
@@ -235,7 +299,12 @@ module Sloplint
         # place-description cliché — the narrow trigger requires a definite
         # or proper noun object, which this lacks.
         "You cannot sit motionless in the heart of these perils.",
-        "helpless Ahab, even in the heart of such a whirlpool as that"
+        "helpless Ahab, even in the heart of such a whirlpool as that",
+        # Austen, Emma: "nestled" as the physical verb, not the scene-setting
+        # adjective -- no following in/among/between, so the narrowed trigger
+        # leaves it alone.
+        "He had nestled down his head most conveniently.",
+        "The kitten nestled into the blanket."
       ],
       rationale: "Travel-brochure adjectives and phrases that models reach for and careful " \
                  "writers avoid."
@@ -290,14 +359,29 @@ module Sloplint
       id: "not-just-x-but-y",
       category: "structure",
       severity: "warning",
+      # 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
+      # these safe to ship at warning -- it is a deliberate authorial move, not
+      # a shape ordinary prose falls into. The bare corrective without it
+      # ("is not A but B") is a separate, quieter rule: not-x-but-y.
+      #
+      # Interior spans stop at a paragraph break so a heading or list item
+      # cannot join up with the next paragraph's "But …".
       pattern: /(?:\bis|\bare|\bwas|\bwere|\bisn['’]t|\baren['’]t|\bwasn['’]t|\bweren['’]t|
                   \bit['’]s|\bthat['’]s|\bthis\s+is|\bthese\s+are|\bthose\s+are)
-                 \s+not\s+(?:just|only)\b[^.!?]*?\bbut\b(?:\s+also\b)?/ix,
-      message: '"X is not just A, but B" is a stock AI escalation structure.',
+                 \s+not\s+(?:just|only|merely|simply|solely)\b
+                 (?:[^.!?\n]|\n(?!\s*\n))*?\bbut\b(?:\s+also\b)?
+                |
+                \bnot\s+because\b(?:[^.!?;\n]|\n(?!\s*\n)){1,60}?\bbut\s+because\b/ix,
+      message: '"not just A, but B" is a stock AI escalation structure.',
       suggestion: "Make the claim once; drop the 'not just… but' frame.",
       examples_bad: [
         "It's not just fast, but genuinely reliable.",
-        "This is not just a tool, but a partner in your workflow."
+        "This is not just a tool, but a partner in your workflow.",
+        "It is not merely fast but reliable.",
+        "The issue is not solely technical but cultural.",
+        "She stayed not because it was easy, but because it was hers."
       ],
       examples_ok: [
         "He is not tired.",
@@ -305,12 +389,87 @@ module Sloplint
         # phrases, not a copula predicating two things of one subject.
         "This power ought not only to be established, but ought to be established.",
         "Not only that, but they looked embarrassed.",
-        "not just to acquire users, but to build something people love."
+        "not just to acquire users, but to build something people love.",
+        # A paragraph break ends the span; the next paragraph's "but" is not B.
+        "He left not because of the noise\n\nbut because of the smell."
       ],
       rationale: "'X is not just A, but B' predicates two things of the same subject through a " \
                  "copula, which is the specific shape models overuse. Correlative 'not only… " \
                  "but' joining two verb phrases or clauses, without a preceding copula, is " \
-                 "ordinary and common in formal human prose."
+                 "ordinary and common in formal human prose; requiring the escalation word " \
+                 "keeps those out. 'not because… but because' scored 2 hits in a 744k-word " \
+                 "five-book probe (Austen, Melville, Hamilton/Madison, Thoreau, Emerson)."
+    ),
+    Rule.new(
+      id: "not-x-but-y",
+      category: "structure",
+      severity: "info",
+      # 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
+      # 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
+      # capped at one word after an optional article, "so" is excluded to spare
+      # the archaic "not so deep but that", degree words ("quite", "very") are
+      # excluded because they open concessives, and B may not be a pronoun,
+      # possessive, demonstrative, auxiliary, or quantifier.
+      #
+      # Those guards are a filter, not a decision procedure. They still let
+      # through a concession whose second clause opens with a noun phrase
+      # ("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
+      # 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|
+                  \bit['’]s|\bthat['’]s|\bthis\s+is|\bthese\s+are|\bthose\s+are)
+                 \s+not\s+
+                 (?!so\b|just\b|only\b|merely\b|simply\b|solely\b|even\b|yet\b|quite\b|very\b
+                   |too\b|all\b|always\b|enough\b)
+                 (?:a\s+|an\s+|the\s+)?[\w'’-]+
+                 ,?(?:[ \t]|\r?\n(?!\s*\n))+but(?:[ \t]|\r?\n(?!\s*\n))+
+                 (?:rather(?:[ \t]|\r?\n(?!\s*\n))+)?
+                 (?!also\b|that\b|this\b|these\b|those\b|they\b|it\b|he\b|she\b|we\b|you\b|i\b
+                   |his\b|her\b|their\b|its\b|my\b|your\b|our\b|there\b|then\b|still\b|now\b
+                   |is\b|was\b|are\b|were\b|has\b|had\b|have\b|will\b|would\b|could\b|should\b
+                   |may\b|might\b|must\b|can\b|to\b|as\b|if\b|when\b|because\b|not\b|no\b|never\b
+                   |nor\b|neither\b|every\w*\b|nobody\b|none\b|some\b|somebody\b|someone\b
+                   |anyone\b|anybody\b|anything\b|nothing\b|many\b|most\b|few\b)
+                 (?:a\s+|an\s+|the\s+)?[\w'’-]+/ix,
+      message: '"not A but B" is the bare AI corrective frame.',
+      suggestion: "Make the claim once; drop the 'not… but' frame.",
+      examples_bad: [
+        "The delay was not an accident but a strategy.",
+        "The delay was not an accident, but a strategy.",
+        "The problem is not misconduct but tone.",
+        "It's not a bug but a feature.",
+        "That's not an accident but a strategy."
+      ],
+      examples_ok: [
+        # Comma concessive with a pronoun subject: a contrast, not a correction.
+        "He was not handsome, but he was kind.",
+        # B-side pronoun: concession that continues the sentence.
+        "The results are not conclusive but they point in the right direction.",
+        # Archaic "not so X but that", common in 19th-century prose.
+        "The stream is not so deep but that we may ford it.",
+        # A capped at one word: multi-word predicates stay unflagged.
+        "The evening was not particularly warm but everyone stayed late.",
+        # B-side possessive, with the comma allowed.
+        "The house was not large, but its garden ran clear to the river.",
+        # Bare "every" on the B side, not just "everyone"/"everything".
+        "It is not a bug but every case differs.",
+        # A paragraph break ends the frame.
+        "The result was not final\n\nBut the team moved on anyway."
+      ],
+      rationale: "The bare 'is not A but B' corrective is the 'not just… but' move with the " \
+                 "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 in a " \
+                 "744k-word five-book probe, and the narrowings here cut that to 15 -- 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'."
     ),
     Rule.new(
       id: "rule-of-three",
@@ -335,9 +494,29 @@ module Sloplint
     # expensive rule in the catalog at 65% of scan time on 1MB. Per
     # CLAUDE.md: some tells can't be regexes; this was one.
     Rule.new(
-      id: "em-dash-overuse",
+      id: "em-dash",
       category: "structure",
       severity: "info",
+      pattern: /—/,
+      message: "Em dash — an AI punctuation tell.",
+      suggestion: "Recast with a comma, parentheses, or a separate sentence.",
+      examples_bad: [
+        "It was — surprisingly — the best option.",
+        "The fix is simple — do less."
+      ],
+      examples_ok: [
+        # Hyphen in a compound modifier -- not the U+2014 this rule targets.
+        "The state-of-the-art model shipped on time.",
+        # En dash (U+2013) in a range: a different character entirely.
+        "See pages 12–18 for the full account."
+      ],
+      rationale: "Models reach for the em dash by default; humans use it too, but far less " \
+                 "often."
+    ),
+    Rule.new(
+      id: "em-dash-overuse",
+      category: "structure",
+      severity: "warning",
       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.",
@@ -353,8 +532,8 @@ module Sloplint
         # paragraph, even though the raw text has four dashes total.
         "It was — I think — a fine choice.\n\nAnother option — entirely separate — came up too."
       ],
-      rationale: "Heavy em-dash interjection is a strong model tell; two is fine, three signals " \
-                 "slop."
+      rationale: "Three or more em dashes packed into one paragraph is a denser interjection " \
+                 "habit than most human writing settles into."
     ),
 
     # ── hedging ───────────────────────────────────────────────────────────

data/lib/sloplint/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sloplint
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Benjamin Jackson
@@ -81,7 +81,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.2
+rubygems_version: 4.0.17
 specification_version: 4
 summary: Flag the rhetorical tics and puffery that mark AI-generated prose.
 test_files: []