slopless 0.2.19 → 0.2.21

package/README.md

@@ -2,44 +2,35 @@
 
 [![npm](https://img.shields.io/npm/v/slopless?label=npm)](https://www.npmjs.com/package/slopless)
 [![downloads](https://img.shields.io/npm/dm/slopless)](https://www.npmjs.com/package/slopless)
-[![bundle size](https://img.shields.io/bundlephobia/minzip/slopless?label=minzip)](https://bundlephobia.com/package/slopless)
 [![install size](https://packagephobia.com/badge?p=slopless)](https://packagephobia.com/result?p=slopless)
 [![license](https://img.shields.io/npm/l/slopless)](LICENSE)
 [![node](https://img.shields.io/badge/node-22%2B-brightgreen)](package.json)
 
 [![ci](https://img.shields.io/github/actions/workflow/status/seochecks-ai%2Fslopless/ci.yml?branch=main&label=ci)](/actions/workflows/ci.yml)
-[![scorecard](https://api.scorecard.dev/projects/github.com/seochecks-ai/slopless/badge)](https://scorecard.dev/viewer/?uri=github.com/seochecks-ai/slopless)
 [![socket](https://socket.dev/api/badge/npm/package/slopless)](https://socket.dev/npm/package/slopless)
-[![snyk advisor](https://snyk.io/advisor/npm-package/slopless/badge.svg)](https://snyk.io/advisor/npm-package/slopless)
 
 Catch AI and human slop in English Markdown without calling an LLM. Slopless ships 50+ deterministic textlint rules and a CLI that emits structured JSON findings.
 
 ## What it catches
 
-Given this paragraph (typical LLM prose):
+Given this paragraph of confident-sounding slop:
 
 ```markdown
-In today's rapidly evolving landscape, it's important to note that AI tools
-are revolutionizing how we work - truly transforming workflows in
-unprecedented ways. By harnessing the power of large language models, teams
-can delve into complex challenges, streamline operations, and unlock new
-possibilities. But what does this really mean for you? In essence, the
-future belongs to those who embrace these tools today. Not just to keep up,
-not just to stay competitive, but to thrive.
+Let me be honest: in a world where everyone is racing to ship, most teams
+forget the basics. We do not sell software. We sell outcomes. Everyone knows
+the best products feel effortless. At the end of the day, the future belongs
+to the teams that slow down to think.
 ```
 
-`npx slopless` returns nine findings across seven rules:
+`npx slopless` flags six findings across five rules - structure and rhetoric, not just a word list:
 
 ```
-[slopless/generic-signposting]  it's important to note
-[slopless/prohibited-phrases]   it's important to note
-[slopless/llm-vocabulary]       landscape
-[slopless/llm-vocabulary]       delve
-[slopless/prohibited-words]     delve
-[slopless/prohibited-words]     unlock
-[slopless/prohibited-phrases]   the future belongs to
-[slopless/negation-reframe]     Not just X, not just Y, but Z
-[slopless/flesch-kincaid]       Flesch Reading Ease 56.05 (keep >= 61)
+[slopless/boilerplate-framing]    let me be honest
+[slopless/prohibited-phrases]     in a world where
+[slopless/negation-reframe]       We do not sell software. We sell outcomes.
+[slopless/universalizing-claims]  everyone knows
+[slopless/cliches]                at the end of the day
+[slopless/prohibited-phrases]     the future belongs to
 ```
 
 Full JSON output is the default. See the [Rules](https://github.com/seochecks-ai/slopless/wiki/Rules) page for the complete inventory.
@@ -48,6 +39,7 @@ Full JSON output is the default. See the [Rules](https://github.com/seochecks-ai
 
 ```bash
 npm install -D slopless
+npx slopless --help
 npx slopless install-skill codex
 npx slopless install-skill claude
 ```
@@ -61,10 +53,11 @@ Use the Slopless skill. Check this Markdown, rewrite the prose, and keep iterati
 Loop:
 
 1. Install Slopless.
-2. Install the agent skill for Codex or Claude Code.
-3. Tell the writing agent to use the skill.
-4. Let the agent run Slopless, rewrite, and rerun until the JSON output has no findings.
-5. Profit.
+2. Read the core help (`npx slopless --help`).
+3. Install the agent skill for Codex or Claude Code.
+4. Tell the writing agent to use the skill.
+5. Let the agent run Slopless, rewrite, and rerun until the JSON output has no findings.
+6. Profit.
 
 ## Direct CLI Use
 
@@ -144,6 +137,10 @@ This confirms the tarball you installed was built in the published source reposi
 
 [![Star History Chart](https://api.star-history.com/svg?repos=seochecks-ai/slopless&type=Date)](https://star-history.com/#seochecks-ai/slopless&Date)
 
+## Credits
+
+[Graham Rowe](https://github.com/grahamrowe82/antislop), thanks for giving me new ideas for classes of slop to detect. Your lib is now fully incorporated with your permission.
+
 ---
 
 Developed by [seochecks.ai](https://seochecks.ai) to keep content specific, useful, and recognizably human.

package/dist/adapters/textlint/report.js

@@ -8,6 +8,15 @@ export function emitTextlintReport(context, unitsById, report) {
     const padding = report.range.start === report.range.end
         ? context.locator.at(report.range.start)
         : context.locator.range([report.range.start, report.range.end]);
+    // textlint reads a per-report severity only from a plain reported object, not from a
+    // RuleError instance (kernel: `ruleReportedObject.severity || error`). The reporter sets
+    // report.severity when a policy judges the level (1 = warning, 2 = error); everything else
+    // keeps the default error severity via RuleError.
+    const { severity } = report;
+    if (typeof severity === "number") {
+        context.report(unit.node, { message: report.message, padding, severity });
+        return;
+    }
     context.report(unit.node, new context.RuleError(report.message, {
         padding
     }));

package/dist/presets/everything.js

@@ -1,5 +1,6 @@
 export const everything = {
     rules: {
+        "actually-overuse": true,
         "affirmation-closers": true,
         "artifact-placeholders": true,
         "authority-padding": true,
@@ -50,6 +51,10 @@ export const everything = {
         "sentence-case": true,
         "semantic-thinness": true,
         "significance-density": true,
+        "seo-filler": true,
+        "self-help-cliches": true,
+        "genre-cliches": true,
+        "weasel-attribution": true,
         simplicity: true,
         "skunked-terms": true,
         "softening-language": true,

package/dist/registries/phrases/builtin.js

@@ -0,0 +1,23 @@
+import cliches from "../../rules/phrases/cliches.js";
+import corporateSpeak from "../../rules/phrases/corporate-speak.js";
+import humbleBragger from "../../rules/phrases/humble-bragger.js";
+import jargonFaker from "../../rules/phrases/jargon-faker.js";
+import llmDisclaimer from "../../rules/phrases/llm-disclaimer.js";
+import prohibitedPhrases from "../../rules/phrases/prohibited-phrases.js";
+import redundancy from "../../rules/phrases/redundancy.js";
+import skunkedTerms from "../../rules/phrases/skunked-terms.js";
+import uncomparables from "../../rules/phrases/uncomparables.js";
+import wordiness from "../../rules/phrases/wordiness.js";
+export const phraseBuiltinRules = {
+    cliches,
+    "corporate-speak": corporateSpeak,
+    "humble-bragger": humbleBragger,
+    "jargon-faker": jargonFaker,
+    "llm-disclaimer": llmDisclaimer,
+    "prohibited-phrases": prohibitedPhrases,
+    redundancy,
+    "skunked-terms": skunkedTerms,
+    uncomparables,
+    wordiness
+};
+//# sourceMappingURL=builtin.js.map

package/dist/registries/phrases/families.js

@@ -0,0 +1,14 @@
+import genreCliches from "../../rules/phrases/genre-cliches.js";
+import seoFiller from "../../rules/phrases/seo-filler.js";
+import selfHelpCliches from "../../rules/phrases/self-help-cliches.js";
+import weaselAttribution from "../../rules/phrases/weasel-attribution.js";
+// New slop families added from the corpus-driven expansion. Each is a phrase-list
+// rule (findUnquotedPhraseMatches over a data JSON), screened for low false positives
+// against a multi-topic human corpus.
+export const phraseFamilyRules = {
+    "genre-cliches": genreCliches,
+    "seo-filler": seoFiller,
+    "self-help-cliches": selfHelpCliches,
+    "weasel-attribution": weaselAttribution
+};
+//# sourceMappingURL=families.js.map

package/dist/registries/phrases.js

@@ -1,23 +1,7 @@
-import cliches from "../rules/phrases/cliches.js";
-import corporateSpeak from "../rules/phrases/corporate-speak.js";
-import humbleBragger from "../rules/phrases/humble-bragger.js";
-import jargonFaker from "../rules/phrases/jargon-faker.js";
-import llmDisclaimer from "../rules/phrases/llm-disclaimer.js";
-import prohibitedPhrases from "../rules/phrases/prohibited-phrases.js";
-import redundancy from "../rules/phrases/redundancy.js";
-import skunkedTerms from "../rules/phrases/skunked-terms.js";
-import uncomparables from "../rules/phrases/uncomparables.js";
-import wordiness from "../rules/phrases/wordiness.js";
+import { phraseBuiltinRules } from "./phrases/builtin.js";
+import { phraseFamilyRules } from "./phrases/families.js";
 export const phraseRules = {
-    cliches,
-    "corporate-speak": corporateSpeak,
-    "humble-bragger": humbleBragger,
-    "jargon-faker": jargonFaker,
-    "llm-disclaimer": llmDisclaimer,
-    "prohibited-phrases": prohibitedPhrases,
-    redundancy,
-    "skunked-terms": skunkedTerms,
-    uncomparables,
-    wordiness
+    ...phraseBuiltinRules,
+    ...phraseFamilyRules
 };
 //# sourceMappingURL=phrases.js.map

package/dist/registries/words.js

@@ -1,9 +1,11 @@
+import actuallyOveruse from "../rules/words/actually-overuse.js";
 import hedgeStacking from "../rules/words/hedge-stacking.js";
 import llmVocabularyDensity from "../rules/words/llm-vocabulary-density.js";
 import llmVocabulary from "../rules/words/llm-vocabulary.js";
 import prohibitedWords from "../rules/words/prohibited-words.js";
 import simplicity from "../rules/words/simplicity.js";
 export const wordRules = {
+    "actually-overuse": actuallyOveruse,
     "hedge-stacking": hedgeStacking,
     "llm-vocabulary-density": llmVocabularyDensity,
     "llm-vocabulary": llmVocabulary,

package/dist/reporting/density.js

@@ -0,0 +1,23 @@
+// Density calculation used by the reporter to judge raw detections. Rules emit occurrences
+// only; the reporter hands the occurrence count and the unit word count here, and this
+// module decides whether the density is acceptable, a warning, or an error. It has no rule
+// or textlint knowledge so it stays reusable and unit-testable on its own.
+export const WARNING_SEVERITY = 1;
+export const ERROR_SEVERITY = 2;
+// Occurrences per `wordsPerUnit` words. Below the warning rate (or below the minimum count)
+// there is no finding; above the error rate it is an error; otherwise a warning. A single
+// occurrence never fires when minimumOccurrences is 2 or more.
+export function rateVerdict(occurrences, words, thresholds) {
+    if (occurrences < thresholds.minimumOccurrences || words <= 0) {
+        return undefined;
+    }
+    const perUnit = (occurrences * thresholds.wordsPerUnit) / words;
+    if (perUnit <= thresholds.warningPerUnit) {
+        return undefined;
+    }
+    return {
+        perUnit,
+        severity: perUnit > thresholds.errorPerUnit ? ERROR_SEVERITY : WARNING_SEVERITY
+    };
+}
+//# sourceMappingURL=density.js.map

package/dist/reporting/reports.js

@@ -1,5 +1,6 @@
 import { splitSentences } from "../shared/text/sentences.js";
 import { wordTokens } from "../shared/text/tokens.js";
+import { rateVerdict } from "./density.js";
 function detectionWithin(detection, span) {
     return (detection.group !== undefined &&
         detection.range.start >= span.start &&
@@ -89,6 +90,37 @@ export function densityReports(unit, detections, config) {
         }
     ];
 }
+export function densityRateReports(units, detections, policy, formatMessage) {
+    const reports = [];
+    for (const unit of units) {
+        const unitDetections = detections.filter((detection) => detection.unitId === unit.id);
+        const first = unitDetections[0];
+        const verdict = rateVerdict(unitDetections.length, wordTokens(unit.text).length, {
+            errorPerUnit: policy.errorPerUnit,
+            minimumOccurrences: policy.minimumOccurrences,
+            warningPerUnit: policy.warningPerUnit,
+            wordsPerUnit: policy.wordsPerUnit
+        });
+        if (verdict === undefined || first === undefined) {
+            continue;
+        }
+        const report = {
+            detections: unitDetections,
+            evidence: first.evidence,
+            message: "",
+            metric: {
+                count: unitDetections.length,
+                perUnit: Math.round(verdict.perUnit * 10) / 10
+            },
+            range: unit.sourceRangeFor(first.range),
+            ruleId: first.ruleId,
+            severity: verdict.severity,
+            unitId: unit.id
+        };
+        reports.push({ ...report, message: formatMessage(report) });
+    }
+    return reports;
+}
 export function reportsForPolicy(units, detections, policy, formatMessage) {
     switch (policy.kind) {
         case "one-to-one": {
@@ -137,6 +169,8 @@ export function reportsForPolicy(units, detections, policy, formatMessage) {
                 message: formatMessage(report)
             }));
         }
+        case "density-rate":
+            return densityRateReports(units, detections, policy, formatMessage);
     }
 }
 //# sourceMappingURL=reports.js.map

package/dist/rules/narrative-slop/perception-verb-density.js

@@ -1,11 +1,14 @@
 import { defineTextlintRule } from "../../adapters/textlint/rule.js";
 import { paragraphUnits } from "../../adapters/textlint/units.js";
 import { wordTokens } from "../../shared/text/tokens.js";
+// Dropped the tokens whose dominant sense is non-narrative and which drove the bulk of
+// the human-corpus mis-fires: "see/sees/seeing" (generic: "you can see that"), the present
+// "focus"/"focuses" ("focus on strategy"; narrative "focused"/"focusing" are kept),
+// "peer/peers/peering" (the colleague noun and "peer review"),
+// and the plural nouns "studies"/"notices" ("studies show", "post notices"). The narrative
+// perception verbs - including observe/study/notice/scan, which genuine scene-slop stacks
+// ("she scanned the room, noticed the door, studied his face") - are kept.
 const PERCEPTION_VERBS = new Set([
-    "focus",
-    "focuses",
-    "focused",
-    "focusing",
     "look",
     "looks",
     "looked",
@@ -26,34 +29,26 @@ const PERCEPTION_VERBS = new Set([
     "glances",
     "glanced",
     "glancing",
-    "observe",
-    "observes",
-    "observed",
-    "observing",
-    "scan",
-    "scans",
-    "scanned",
-    "scanning",
-    "peer",
-    "peers",
     "peered",
-    "peering",
     "squint",
     "squints",
     "squinted",
     "squinting",
+    "saw",
+    "focused",
+    "focusing",
+    "observe",
+    "observed",
+    "observing",
     "study",
-    "studies",
     "studied",
     "studying",
     "notice",
-    "notices",
     "noticed",
     "noticing",
-    "see",
-    "sees",
-    "saw",
-    "seeing"
+    "scan",
+    "scanned",
+    "scanning"
 ]);
 const PURPOSE_LOOK_PARTICLES = new Set(["for", "up", "under", "into"]);
 const MAX_PARAGRAPH_TOKENS = 80;

package/dist/rules/orthography/fake-timestamps.js

@@ -3,6 +3,56 @@ import { oneToOneRule } from "../private/textlint-rule-builders.js";
 function isAsciiDigit(character) {
     return character !== undefined && character >= "0" && character <= "9";
 }
+// A timestamp accompanied by a real date (weekday, month, year, or a date label) is a
+// genuine timestamp - an email header, a logged event, a scheduled time - not fabricated
+// AI clock specificity. Skip those.
+const DATE_WORDS = [
+    "january",
+    "february",
+    "march",
+    "april",
+    "june",
+    "july",
+    "august",
+    "september",
+    "october",
+    "november",
+    "december",
+    "monday",
+    "tuesday",
+    "wednesday",
+    "thursday",
+    "friday",
+    "saturday",
+    "sunday"
+];
+const DATE_LABELS = [
+    "date:",
+    "sent:",
+    "received:",
+    "posted",
+    "published",
+    "updated",
+    "timestamp"
+];
+function hasFourDigitYear(text) {
+    for (let i = 0; i + 3 < text.length; i += 1) {
+        const a = text[i];
+        const b = text[i + 1];
+        if (((a === "1" && b === "9") || (a === "2" && b === "0")) &&
+            isAsciiDigit(text[i + 2]) &&
+            isAsciiDigit(text[i + 3])) {
+            return true;
+        }
+    }
+    return false;
+}
+function hasDateContext(sentence) {
+    const lower = sentence.toLocaleLowerCase("en");
+    return (DATE_LABELS.some((label) => lower.includes(label)) ||
+        DATE_WORDS.some((word) => lower.includes(word)) ||
+        hasFourDigitYear(lower));
+}
 function isPeriodMarker(first, second) {
     if (first === undefined || second === undefined) {
         return false;
@@ -56,6 +106,9 @@ function findTimestampMatches(text) {
 function findSentenceTimestampMatches(text) {
     const matches = [];
     for (const sentence of splitSentences(text)) {
+        if (hasDateContext(sentence.text)) {
+            continue;
+        }
         const timestampMatches = findTimestampMatches(sentence.text);
         if (timestampMatches.length === 0) {
             continue;

package/dist/rules/phrases/data/cliches.json

@@ -331,7 +331,6 @@
     "in a pinch",
     "in a word",
     "in hot water",
-    "in the final analysis",
     "in the gutter",
     "in the last analysis",
     "in the nick of time",
@@ -339,7 +338,6 @@
     "in your dreams",
     "innocent bystander",
     "it ain't over till the fat lady sings",
-    "it goes without saying",
     "it takes all kinds",
     "it takes one to know one",
     "it's a small world",
@@ -791,5 +789,43 @@
     "you only live once",
     "you're the boss",
     "young and foolish",
-    "young and vibrant"
+    "young and vibrant",
+    "a watershed moment",
+    "as we move forward",
+    "at a pivotal moment",
+    "beacon of hope",
+    "contributing to the fabric of",
+    "discover the wonders of",
+    "drive engagement",
+    "embrace the journey",
+    "empower individuals to",
+    "everything happens for a reason",
+    "gain a comprehensive understanding",
+    "gain valuable insights",
+    "harness the power of",
+    "has something for everyone",
+    "has transformed the landscape of",
+    "immerse yourself in",
+    "in the not-too-distant future",
+    "leave no stone unturned",
+    "left an indelible mark",
+    "navigate the complexities of",
+    "nestled in the heart of",
+    "offers valuable insights",
+    "plays a pivotal role in shaping",
+    "resonate with audiences",
+    "revolutionized the way we",
+    "rich cultural tapestry",
+    "sheds light on",
+    "significant contributions to the field",
+    "step out of your comfort zone",
+    "the stakes have never been higher",
+    "there is no one-size-fits-all answer",
+    "this changes everything",
+    "thriving ecosystem of",
+    "treasure trove of",
+    "unlock the potential of",
+    "unlock your true potential",
+    "vibrant hub of",
+    "we stand at a crossroads"
 ]

package/dist/rules/phrases/data/corporate-speak.json

@@ -62,5 +62,43 @@
     "ecosystem of partners",
     "innovate at the speed of",
     "reimagine the future of",
-    "built for the enterprise"
+    "built for the enterprise",
+    "10x growth",
+    "30,000-foot view",
+    "agile methodology",
+    "brand storytelling",
+    "core competencies",
+    "cross-functional alignment",
+    "cross-pollination of ideas",
+    "data-driven decisions",
+    "digital transformation",
+    "ducks in a row",
+    "eating your own dog food",
+    "end-to-end solution",
+    "excited to share",
+    "future-proof your",
+    "headwinds",
+    "ideation session",
+    "keep all stakeholders aligned",
+    "learnings",
+    "leverage synergies",
+    "move at the speed of business",
+    "open the kimono",
+    "out-of-the-box thinking",
+    "revolutionizing the way",
+    "rightsizing",
+    "robust ecosystem",
+    "robust pipeline",
+    "run it up the flagpole",
+    "scale our operations",
+    "seamless integration",
+    "stakeholder buy-in",
+    "strategic alignment",
+    "streamline processes",
+    "tailwinds",
+    "talent pipeline",
+    "that's where we come in",
+    "thought leader",
+    "thought leadership",
+    "tiger team"
 ]

package/dist/rules/phrases/data/genre-cliches.json

@@ -0,0 +1,53 @@
+[
+    "a culinary journey",
+    "a feast for the senses",
+    "a must for any itinerary",
+    "a true gem",
+    "after using this for a few weeks",
+    "best-kept secret",
+    "bucket list destination",
+    "bursting with flavor",
+    "bustling streets",
+    "charming village",
+    "city of contrasts",
+    "come hungry",
+    "completely transformed how i",
+    "crystal-clear waters",
+    "escape the crowds",
+    "even picky eaters will love it",
+    "exceeded my expectations",
+    "experience the magic of",
+    "final verdict",
+    "foodie paradise",
+    "great for weeknight dinners",
+    "hands-down the best",
+    "hidden gem",
+    "leave room for dessert",
+    "local cuisine",
+    "local gems",
+    "look no further",
+    "lose yourself in",
+    "my grandmother used to make this",
+    "nestled among",
+    "no product is perfect, but",
+    "off the beaten path",
+    "off the tourist trail",
+    "soak up the atmosphere",
+    "step back in time",
+    "stunning scenery",
+    "tantalizing flavors",
+    "the perfect blend of",
+    "the results speak for themselves",
+    "this dish brings back so many memories",
+    "this place has it all",
+    "this recipe is perfect for",
+    "trust me, you won't be disappointed",
+    "undiscovered paradise",
+    "unparalleled views",
+    "vibrant culture",
+    "what makes this recipe special is",
+    "whether you're a food lover or",
+    "world-class dining",
+    "you won't regret it",
+    "you'll love this"
+]

package/dist/rules/phrases/data/self-help-cliches.json

@@ -0,0 +1,62 @@
+[
+    "a transformative experience",
+    "abundance mindset",
+    "align with your values",
+    "be authentically you",
+    "believe in yourself",
+    "break free from your limitations",
+    "choose yourself",
+    "create the life you want",
+    "deserve success",
+    "do the inner work",
+    "embrace change",
+    "embrace who you are",
+    "embrace your potential",
+    "find your purpose",
+    "growth mindset",
+    "heal your relationship with",
+    "honor your feelings",
+    "inner work",
+    "just stay positive",
+    "life is a journey, not a destination",
+    "live with intention",
+    "live your best life",
+    "live your purpose",
+    "manifest your dreams",
+    "not a destination but a journey",
+    "own your story",
+    "pour into yourself",
+    "practice gratitude",
+    "push past your limits",
+    "put in the work",
+    "radical self-love",
+    "reclaim your power",
+    "self-care is not selfish",
+    "set your intentions",
+    "show up for yourself",
+    "small changes can make a big difference",
+    "start where you are",
+    "stepping into your power",
+    "take control of your health",
+    "tap into your potential",
+    "the best version of yourself",
+    "the power within",
+    "this journey of self-discovery",
+    "thrive, not just survive",
+    "transformative power of",
+    "trust the process",
+    "unleash your potential",
+    "unlock your potential",
+    "where you are meant to be",
+    "you are capable of more than you think",
+    "you are enough",
+    "you are exactly where you need to be",
+    "you can't pour from an empty cup",
+    "you'll get through this",
+    "your authentic self",
+    "your best self",
+    "your best version",
+    "your higher self",
+    "your personal journey",
+    "your wellness journey"
+]

package/dist/rules/phrases/data/seo-filler.json

@@ -0,0 +1,34 @@
+[
+    "as the world continues to evolve",
+    "as we look to the future",
+    "as we navigate",
+    "as we've explored",
+    "has a profound impact",
+    "in an era characterized by",
+    "in an ever-evolving landscape",
+    "in the digital age",
+    "in this comprehensive guide",
+    "in today's competitive landscape",
+    "in today's digital age",
+    "in today's fast-paced",
+    "in today's rapidly evolving landscape",
+    "it is no secret that",
+    "it is vital for",
+    "it's no secret that",
+    "join us as we",
+    "join us as we explore",
+    "let's deep dive",
+    "let's delve into",
+    "more than ever before",
+    "navigating the complexities of",
+    "navigating the world of",
+    "take a deep dive into",
+    "the ultimate guide to",
+    "this guide will cover",
+    "this has never been more important",
+    "we hope this article",
+    "we hope this guide",
+    "welcome to this article",
+    "welcome to this guide",
+    "whether you're a beginner or"
+]

package/dist/rules/phrases/data/skunked-terms.json

@@ -1,10 +1 @@
-[
-    "Thankfully",
-    "bona fides",
-    "deceptively",
-    "decimate",
-    "effete",
-    "fulsome",
-    "hopefully",
-    "impassionate"
-]
+["bona fides", "deceptively", "decimate", "effete", "fulsome", "impassionate"]

package/dist/rules/phrases/data/weasel-attribution.json

@@ -0,0 +1,37 @@
+[
+    "a growing body of evidence suggests",
+    "a growing body of research suggests",
+    "according to health professionals",
+    "according to medical experts",
+    "analysts suggest",
+    "countless studies have shown",
+    "doctors say",
+    "economists say",
+    "health experts say",
+    "industry experts say",
+    "industry insiders say",
+    "industry leaders agree",
+    "it has been demonstrated that",
+    "it is commonly understood that",
+    "it is generally understood that",
+    "it is universally accepted that",
+    "leading experts say",
+    "many experts agree",
+    "many experts believe",
+    "most experts agree",
+    "multiple studies have found",
+    "new research suggests",
+    "new studies show",
+    "numerous studies have shown",
+    "numerous studies suggest",
+    "nutritionists say",
+    "observers have suggested",
+    "psychologists say",
+    "recent research has found",
+    "science confirms",
+    "science tells us",
+    "some researchers argue",
+    "some scientists believe",
+    "some would argue",
+    "the scientific community agrees"
+]

package/dist/rules/phrases/genre-cliches.js

@@ -0,0 +1,17 @@
+import genreCliches from "./data/genre-cliches.json" with { type: "json" };
+import { findUnquotedPhraseMatches } from "../../shared/matchers/phrases.js";
+import { oneToOneRule } from "../private/textlint-rule-builders.js";
+const rule = oneToOneRule({
+    detect: (unit) => findUnquotedPhraseMatches(unit.text, genreCliches).map((match) => ({
+        evidence: match.text,
+        label: match.text,
+        range: { start: match.start, end: match.end }
+    })),
+    family: "phrases",
+    formatMessage: (report) => `Genre cliche found: "${report.evidence}". Replace it with a concrete, specific detail.`,
+    ignoredAncestorTypes: ["Link", "LinkReference"],
+    ruleId: "phrases:genre-cliches",
+    unitKind: "str"
+});
+export default rule;
+//# sourceMappingURL=genre-cliches.js.map

package/dist/rules/phrases/humble-bragger.js

@@ -1,10 +1,8 @@
 import { findPhraseMatches } from "../../shared/matchers/phrases.js";
 import { oneToOneRule } from "../private/textlint-rule-builders.js";
-const HUMBLE_BRAGGER_PHRASES = [
-    "in my experience",
-    "as someone who has",
-    "having worked with"
-];
+// "in my experience" was removed: it is a normal epistemic qualifier (common in Q&A
+// and essays), not credentialing - it was a mis-fire, not a humble-brag.
+const HUMBLE_BRAGGER_PHRASES = ["as someone who has", "having worked with"];
 const rule = oneToOneRule({
     detect: (unit) => findPhraseMatches(unit.text, HUMBLE_BRAGGER_PHRASES).map((match) => ({
         evidence: match.text,

package/dist/rules/phrases/self-help-cliches.js

@@ -0,0 +1,17 @@
+import selfHelpCliches from "./data/self-help-cliches.json" with { type: "json" };
+import { findUnquotedPhraseMatches } from "../../shared/matchers/phrases.js";
+import { oneToOneRule } from "../private/textlint-rule-builders.js";
+const rule = oneToOneRule({
+    detect: (unit) => findUnquotedPhraseMatches(unit.text, selfHelpCliches).map((match) => ({
+        evidence: match.text,
+        label: match.text,
+        range: { start: match.start, end: match.end }
+    })),
+    family: "phrases",
+    formatMessage: (report) => `Self-help cliche found: "${report.evidence}". Replace it with a specific claim.`,
+    ignoredAncestorTypes: ["Link", "LinkReference"],
+    ruleId: "phrases:self-help-cliches",
+    unitKind: "str"
+});
+export default rule;
+//# sourceMappingURL=self-help-cliches.js.map

package/dist/rules/phrases/seo-filler.js

@@ -0,0 +1,17 @@
+import seoFiller from "./data/seo-filler.json" with { type: "json" };
+import { findUnquotedPhraseMatches } from "../../shared/matchers/phrases.js";
+import { oneToOneRule } from "../private/textlint-rule-builders.js";
+const rule = oneToOneRule({
+    detect: (unit) => findUnquotedPhraseMatches(unit.text, seoFiller).map((match) => ({
+        evidence: match.text,
+        label: match.text,
+        range: { start: match.start, end: match.end }
+    })),
+    family: "phrases",
+    formatMessage: (report) => `SEO filler found: "${report.evidence}". Cut the filler and lead with the specific point.`,
+    ignoredAncestorTypes: ["Link", "LinkReference"],
+    ruleId: "phrases:seo-filler",
+    unitKind: "str"
+});
+export default rule;
+//# sourceMappingURL=seo-filler.js.map

package/dist/rules/phrases/weasel-attribution.js

@@ -0,0 +1,21 @@
+import weaselAttribution from "./data/weasel-attribution.json" with { type: "json" };
+import { findUnquotedPhraseMatches } from "../../shared/matchers/phrases.js";
+import { oneToOneRule } from "../private/textlint-rule-builders.js";
+// Vague attribution: "studies show", "experts agree", "a growing body of evidence
+// suggests" with no named source. Slop regardless of author; if the source is real,
+// name it. The phrase list deliberately excludes attributions that are commonly used
+// with a real citation alongside (those were screened out for false positives).
+const rule = oneToOneRule({
+    detect: (unit) => findUnquotedPhraseMatches(unit.text, weaselAttribution).map((match) => ({
+        evidence: match.text,
+        label: match.text,
+        range: { start: match.start, end: match.end }
+    })),
+    family: "phrases",
+    formatMessage: (report) => `Vague attribution found: "${report.evidence}". Name the specific source or cut the claim.`,
+    ignoredAncestorTypes: ["Link", "LinkReference"],
+    ruleId: "phrases:weasel-attribution",
+    unitKind: "str"
+});
+export default rule;
+//# sourceMappingURL=weasel-attribution.js.map

package/dist/rules/syntactic-patterns/contrast/private/negation-reframe-matcher.js

@@ -8,10 +8,15 @@ import { makeMeaningReframe, meaningReframe } from "./meaning-reframe.js";
 import { hasConcreteCorrectionEvidence } from "../../../../shared/matchers/concrete-evidence.js";
 import { splitSentences } from "../../../../shared/text/sentences.js";
 import { wordTokens } from "../../../../shared/text/tokens.js";
+// "not only X but Y" is an additive correlative (it affirms both X and Y), not the
+// replacement reframe this rule targets ("it is not X, it is Y"). It was a dominant
+// false positive ("not only makes rounds harder but can trigger a down round"), so the
+// "only" follower is excluded here.
 const INLINE_NON_CONTRAST_NEGATION_FOLLOWERS = new Set([
     "all",
     "any",
     "every",
+    "only",
     "too"
 ]);
 function inlineNegationContrast(sentence) {

package/dist/rules/syntactic-patterns/generalization/softening-language.js

@@ -82,7 +82,13 @@ function matchSoftening(sentence) {
     const qualifier = containsAny(normalized, QUALIFIER_PATTERNS);
     const variability = containsAny(normalized, VARIABILITY_PATTERNS);
     const reporting = containsAny(normalized, REPORTING_PATTERNS);
-    const quantifier = findQuantifierPair(normalized);
+    // "in some cases"/"in some people" already count as a variability hedge; strip the
+    // matched phrase so its embedded "some cases"/"some people" is not double-counted as a
+    // separate quantifier signal (that self-overlap was the dominant false positive).
+    const quantifierText = variability === undefined
+        ? normalized
+        : normalized.split(variability).join(" ");
+    const quantifier = findQuantifierPair(quantifierText);
     const signalCount = Number(modal !== undefined) +
         Number(qualifier !== undefined) +
         Number(variability !== undefined) +

package/dist/rules/syntactic-patterns/generalization/universalizing-claims.js

@@ -9,6 +9,11 @@ const PREFIXES = [
     "after all, ",
     "in the end, "
 ];
+// Real universalizing claims: a broad human-group subject + a desire/certainty verb
+// ("most people want", "everyone knows", "for many parents ... hope"). The previous
+// vague-quantifier + abstract-noun arm ("many reasons", "some things", "several
+// challenges") was removed: those are ordinary counts, not universalizing claims, and
+// were the dominant false positive.
 const SUBJECT_PATTERNS = [
     ["everyone"],
     ["everybody"],
@@ -82,54 +87,6 @@ const GROUP_BEHAVIOR_GERUNDS = [
     "wondering"
 ];
 const BROAD_GROUP_LEADS = ["many", "most"];
-const VAGUE_QUANTIFIERS = ["a lot of", "many", "several", "some", "various"];
-const ABSTRACT_NOUNS = [
-    "areas",
-    "aspects",
-    "benefits",
-    "challenges",
-    "changes",
-    "concerns",
-    "factors",
-    "impacts",
-    "issues",
-    "outcomes",
-    "reasons",
-    "results",
-    "stakeholders",
-    "themes",
-    "things"
-];
-const ABSTRACT_MODIFIERS = [
-    "important",
-    "key",
-    "major",
-    "meaningful",
-    "notable",
-    "significant",
-    "various"
-];
-const EVIDENCE_MARKERS = [
-    "for example",
-    "including",
-    "such as",
-    "because",
-    "from ",
-    "after ",
-    "before ",
-    "when "
-];
-function hasDigit(text) {
-    for (const character of text) {
-        if (character >= "0" && character <= "9") {
-            return true;
-        }
-    }
-    return false;
-}
-function hasEvidenceMarker(text) {
-    return (hasDigit(text) || EVIDENCE_MARKERS.some((marker) => text.includes(marker)));
-}
 function matchGroupBehavior(words) {
     const [first, subject, third, gerund] = words;
     if (first !== undefined &&
@@ -161,40 +118,6 @@ function matchUniversalizing(sentence) {
             return `${subject.join(" ")} ${verb}`;
         }
     }
-    const vagueQuantifier = matchVagueQuantifierAbstractNoun(words, cleaned);
-    if (vagueQuantifier !== undefined) {
-        return vagueQuantifier;
-    }
-    return undefined;
-}
-function matchVagueQuantifierAbstractNoun(words, text) {
-    if (hasEvidenceMarker(text)) {
-        return undefined;
-    }
-    for (let index = 0; index < words.length; index += 1) {
-        const single = words[index];
-        const twoWord = `${words[index] ?? ""} ${words[index + 1] ?? ""}`;
-        const quantifier = VAGUE_QUANTIFIERS.includes(twoWord)
-            ? twoWord
-            : VAGUE_QUANTIFIERS.find((candidate) => candidate === single);
-        if (quantifier === undefined) {
-            continue;
-        }
-        const nounStart = quantifier.includes(" ") ? index + 2 : index + 1;
-        const first = words[nounStart];
-        const second = words[nounStart + 1];
-        const noun = first !== undefined && ABSTRACT_NOUNS.includes(first)
-            ? first
-            : second !== undefined &&
-                first !== undefined &&
-                ABSTRACT_MODIFIERS.includes(first) &&
-                ABSTRACT_NOUNS.includes(second)
-                ? second
-                : undefined;
-        if (noun !== undefined) {
-            return `${quantifier} ${noun}`;
-        }
-    }
     return undefined;
 }
 const rule = oneToOneRule({

package/dist/rules/syntactic-patterns/lead-ins/boilerplate-framing.js

@@ -62,9 +62,17 @@ const FILLER_OPENERS = [
     "let's be real",
     "here's the deal",
     "here's what's really going on",
-    "when all is said and done",
     "the fact of the matter is",
-    "the bottom line is"
+    "the bottom line is",
+    "here's the truth",
+    "here's where it gets interesting",
+    "in the grand scheme of things",
+    "it is worth considering that",
+    "it's fair to say",
+    "let's be honest",
+    "there are no easy answers",
+    "this is the important part",
+    "we are at an inflection point"
 ];
 function matchEnumerationPreface(words) {
     if (words.some((word) => VAGUE_INTROS.includes(word)) &&
@@ -88,11 +96,16 @@ function matchStarterFrame(words) {
 function matchBoilerplateFraming(sentence) {
     const stripped = cleanSentence(sentence, PREFIXES);
     const words = tokens(stripped);
+    const lowered = stripped
+        .toLocaleLowerCase("en")
+        .replaceAll(String.fromCharCode(0x2019), "'");
     const matches = [];
     if (tokensContainInOrder(words, [["following"], PREVIEW_OBJECTS, PREVIEW_VERBS])) {
         matches.push("following + explore");
     }
-    if (stripped.includes("when it comes to")) {
+    // Opener only: "When it comes to X, ..." is a weak filler lead-in. Mid-sentence
+    // ("... tells us little when it comes to Y") is ordinary usage, not boilerplate.
+    if (lowered.startsWith("when it comes to")) {
         matches.push("when it comes to");
     }
     if (tokensContainInOrder(words, [
@@ -111,9 +124,6 @@ function matchBoilerplateFraming(sentence) {
     if (starter !== undefined) {
         matches.push(starter);
     }
-    const lowered = stripped
-        .toLocaleLowerCase("en")
-        .replaceAll(String.fromCharCode(0x2019), "'");
     const filler = FILLER_OPENERS.find((opener) => lowered.startsWith(opener));
     if (filler !== undefined) {
         matches.push(filler);

package/dist/rules/syntactic-patterns/lead-ins/generic-signposting.js

@@ -3,7 +3,9 @@ import { cleanSentence, containsAny, tokens } from "../../../shared/matchers/pro
 import { oneToOneRule } from "../../private/textlint-rule-builders.js";
 import { matchDiscourseEvaluationFrame } from "./private/discourse-evaluation.js";
 const PREFIXES = ["however, ", "but ", "and ", "so "];
-const TRANSITION_PATTERNS = ["that being said", "as such"];
+// "as such" was removed: it is a normal anaphoric connective ("a registered adviser; as
+// such, it must...") and was the dominant false positive, not a signposting frame.
+const TRANSITION_PATTERNS = ["that being said"];
 const CONSULTATION_PATTERNS = [
     "it's always best to consult",
     "it is always best to consult",

package/dist/rules/syntactic-patterns/llm-artifacts/data/response-wrapper-patterns.json

@@ -6,7 +6,6 @@
         "let's break this down",
         "break this down step by step",
         "break it down step by step",
-        "certainly",
         "feel free to ask",
         "great question",
         "here are a few options",

package/dist/rules/syntactic-patterns/repetition/triple-repeat.js

@@ -156,6 +156,33 @@ const COMMON_OPENERS = new Set([
     "must",
     "shall"
 ]);
+// Enumerators and document-structure openers: list markers ("2.", "b)") and
+// reference words that head TOC entries, headings, and procedural steps. Three
+// sentences opening this way is structure, not repetitive prose, and was a
+// dominant source of false positives in the human-corpus audit.
+const STRUCTURAL_OPENERS = new Set([
+    "chapter",
+    "section",
+    "part",
+    "appendix",
+    "figure",
+    "table",
+    "page",
+    "step",
+    "verse",
+    "item"
+]);
+function isStructuralOpener(opener) {
+    if (STRUCTURAL_OPENERS.has(opener) || opener.length === 1) {
+        return true;
+    }
+    for (const character of opener) {
+        if (character < "0" || character > "9") {
+            return false;
+        }
+    }
+    return true;
+}
 function isWordCharacter(character) {
     return ((character >= "a" && character <= "z") ||
         (character >= "0" && character <= "9") ||
@@ -213,6 +240,7 @@ function findTripleRepeats(text) {
         if (firstOpener === undefined ||
             firstOpener === "" ||
             COMMON_OPENERS.has(firstOpener) ||
+            isStructuralOpener(firstOpener) ||
             firstOpener !== secondOpener ||
             secondOpener !== thirdOpener) {
             continue;

package/dist/rules/words/actually-overuse.js

@@ -0,0 +1,45 @@
+import { defineTextlintRule } from "../../adapters/textlint/rule.js";
+import { documentUnit } from "../../adapters/textlint/units.js";
+import { ERROR_SEVERITY } from "../../reporting/density.js";
+import { wordTokens } from "../../shared/text/tokens.js";
+// The rule only detects occurrences of "actually" - one detection per use, no counting,
+// rate, or severity. The density-rate report policy below lets the reporter judge the
+// occurrences against the document word count and decide none / warning / error.
+// "actually" is a normal contrastive adverb at low frequency; AI overuse shows up as
+// density, which is the reporter's concern, not the detector's. See src/reporting/density.ts.
+const TARGET = "actually";
+const RULE_ID = "words:actually-overuse";
+const rule = defineTextlintRule({
+    detector: {
+        detect: ({ units }) => units.flatMap((unit) => wordTokens(unit.text)
+            .filter((token) => token.normalized === TARGET)
+            .map((token) => ({
+            evidence: TARGET,
+            label: TARGET,
+            range: { end: token.end, start: token.start },
+            ruleId: RULE_ID,
+            unitId: unit.id
+        }))),
+        family: "words",
+        id: RULE_ID
+    },
+    formatMessage: (report) => {
+        const count = report.metric?.["count"] ?? report.detections.length;
+        const perUnit = report.metric?.["perUnit"] ?? 0;
+        const threshold = report.severity === ERROR_SEVERITY
+            ? "above the 2-per-1,000-word error threshold"
+            : "above the 1-per-1,000-word warning threshold";
+        return `"actually" used ${count} times (${perUnit} per 1,000 words), ${threshold}. Cut the filler uses; keep at most about one per 1,000 words.`;
+    },
+    reportPolicy: {
+        errorPerUnit: 2,
+        kind: "density-rate",
+        minimumOccurrences: 2,
+        scope: "document",
+        warningPerUnit: 1,
+        wordsPerUnit: 1000
+    },
+    units: (document) => [documentUnit(document)]
+});
+export default rule;
+//# sourceMappingURL=actually-overuse.js.map

package/dist/rules/words/data/prohibited-words.json

@@ -1,5 +1,4 @@
 [
-    "actually",
     "delve",
     "elevate",
     "leverage",

package/dist/rules/words/llm-vocabulary-density.js

@@ -76,7 +76,6 @@ const LLM_DENSITY_WORDS = new Set([
     "unlock",
     "unlocks",
     "unlocking",
-    "value",
     "workflow",
     "workflows"
 ]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slopless",
-  "version": "0.2.19",
+  "version": "0.2.21",
   "description": "Deterministic textlint rules and CLI for catching prose slop in English Markdown.",
   "keywords": [
     "textlint",