slopless 0.2.18 → 0.2.20

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,
@@ -49,6 +50,11 @@ export const everything = {
         "required-terms": true,
         "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/syntactic-patterns/lead-ins.js

@@ -4,12 +4,14 @@ import genericSignposting from "../../rules/syntactic-patterns/lead-ins/generic-
 import lessonFraming from "../../rules/syntactic-patterns/lead-ins/lesson-framing.js";
 import llmOpeners from "../../rules/syntactic-patterns/lead-ins/llm-openers.js";
 import observerGuidance from "../../rules/syntactic-patterns/lead-ins/observer-guidance.js";
+import significanceDensity from "../../rules/syntactic-patterns/lead-ins/significance-density.js";
 export const leadInRules = {
     "boilerplate-framing": boilerplateFraming,
     "formal-transition-density": formalTransitionDensity,
     "generic-signposting": genericSignposting,
     "lesson-framing": lessonFraming,
     "llm-openers": llmOpeners,
-    "observer-guidance": observerGuidance
+    "observer-guidance": observerGuidance,
+    "significance-density": significanceDensity
 };
 //# sourceMappingURL=lead-ins.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",
@@ -634,6 +632,29 @@
     "spring to life",
     "squeaky wheel gets the grease",
     "stands as a testament to",
+    "serves as a reminder that",
+    "serves as a testament to",
+    "paves the way for",
+    "ushers in a new era",
+    "speaks volumes about",
+    "reflects a broader",
+    "stands as a beacon of",
+    "represents a paradigm shift",
+    "embodies the spirit of",
+    "cements its place as",
+    "leaves an indelible mark",
+    "heralds a new era",
+    "signals a seismic shift",
+    "drives home the point",
+    "brings to the fore",
+    "takes center stage",
+    "reshapes the landscape",
+    "charts a new course",
+    "shines a spotlight on",
+    "amplifies the need for",
+    "redefines the boundaries of",
+    "paints a vivid picture of",
+    "holds the key to",
     "stands out like a sore thumb",
     "start from scratch",
     "stick in the mud",
@@ -768,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

@@ -45,5 +45,60 @@
     "unlock our full potential",
     "unlock their full potential",
     "unlock your full potential",
-    "win-win"
+    "win-win",
+    "secret sauce",
+    "force multiplier",
+    "boil the ocean",
+    "best-of-breed",
+    "go-to-market motion",
+    "bleeding-edge",
+    "drive value",
+    "deliver impact",
+    "move fast and break things",
+    "10x your",
+    "data-driven insights",
+    "actionable insights",
+    "empower your team",
+    "ecosystem of partners",
+    "innovate at the speed of",
+    "reimagine the future of",
+    "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

@@ -49,7 +49,30 @@ const FILLER_OPENERS = [
     "here's the kicker",
     "honestly",
     "frankly",
-    "candidly"
+    "candidly",
+    "truth be told",
+    "if i'm being honest",
+    "if i'm being perfectly honest",
+    "let me level with you",
+    "i'll be straight with you",
+    "i'll be frank",
+    "no sugarcoating",
+    "i won't sugarcoat it",
+    "not to put too fine a point on it",
+    "let's be real",
+    "here's the deal",
+    "here's what's really going on",
+    "the fact of the matter 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)) &&
@@ -73,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, [
@@ -96,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,13 +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 IMPORTANT_TO_PATTERNS = [
-    "it's important to note",
-    "it is important to note",
-    "it's important to remember",
-    "it is important to remember"
-];
-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",
@@ -284,7 +280,6 @@ function matchSignposting(sentence) {
         return { kind: "formulaic-content-setup", signal: formulaicSetup };
     }
     const checks = [
-        ["important-to", IMPORTANT_TO_PATTERNS],
         ["transition", TRANSITION_PATTERNS],
         ["consultation-signpost", CONSULTATION_PATTERNS],
         ["note-signpost", NOTE_PATTERNS],

package/dist/rules/syntactic-patterns/lead-ins/significance-density.js

@@ -0,0 +1,95 @@
+import { splitSentences } from "../../../shared/text/sentences.js";
+import { wordTokens } from "../../../shared/text/tokens.js";
+import { isWhitespace } from "../../../shared/text/whitespace.js";
+import { oneToOneRule } from "../../private/textlint-rule-builders.js";
+// Document-level significance signposting. A single "Notably," or "It's worth noting
+// that" is legitimate (technical and academic writing use them), so this is NOT a
+// per-instance flag. The slop tic is sprinkling several across a short piece: AI prose
+// does this constantly, technical prose almost never (0% of 600 PEP/MDN/RFC docs reach
+// the threshold; ~90% of synthetic marketing slop does). Fires once per document when
+// there are enough sentence-initial significance markers AND they are dense enough.
+const MARKERS = [
+    ["notably"],
+    ["importantly"],
+    ["crucially"],
+    ["significantly"],
+    ["interestingly"],
+    ["remarkably"],
+    ["curiously"],
+    ["tellingly"],
+    ["strikingly"],
+    ["worth", "noting"],
+    ["it's", "worth", "noting"],
+    ["it", "is", "worth", "noting"],
+    ["it's", "important", "to", "note"],
+    ["it", "is", "important", "to", "note"],
+    ["it's", "important", "to", "remember"],
+    ["it", "is", "important", "to", "remember"],
+    ["it", "bears", "mentioning"]
+];
+const MINIMUM_COUNT = 3;
+const MINIMUM_RATE_PER_1000 = 3;
+function markerLength(tokens) {
+    for (const marker of MARKERS) {
+        if (marker.every((word, index) => tokens[index]?.normalized === word)) {
+            return marker.length;
+        }
+    }
+    return 0;
+}
+function countWords(text) {
+    let count = 0;
+    let inWord = false;
+    for (const character of text) {
+        if (isWhitespace(character)) {
+            inWord = false;
+        }
+        else if (!inWord) {
+            count += 1;
+            inWord = true;
+        }
+    }
+    return count;
+}
+const rule = oneToOneRule({
+    detect: (unit) => {
+        const hits = [];
+        for (const sentence of splitSentences(unit.text)) {
+            const tokens = wordTokens(sentence.text);
+            const length = markerLength(tokens);
+            if (length === 0) {
+                continue;
+            }
+            const first = tokens[0];
+            const last = tokens[length - 1];
+            if (first === undefined || last === undefined) {
+                continue;
+            }
+            hits.push({
+                end: sentence.start + last.end,
+                start: sentence.start + first.start
+            });
+        }
+        const words = countWords(unit.text);
+        const rate = words === 0 ? 0 : (hits.length * 1000) / words;
+        const firstHit = hits[0];
+        if (hits.length < MINIMUM_COUNT ||
+            rate < MINIMUM_RATE_PER_1000 ||
+            firstHit === undefined) {
+            return [];
+        }
+        return [
+            {
+                evidence: `${hits.length} significance signposts in ${words} words`,
+                label: "significance-signposting",
+                range: { end: firstHit.end, start: firstHit.start }
+            }
+        ];
+    },
+    family: "syntactic-patterns",
+    formatMessage: (report) => `Significance signposting density: ${report.evidence}. Cut the signposting and lead with the point.`,
+    ruleId: "syntactic-patterns:significance-density",
+    unitKind: "document"
+});
+export default rule;
+//# sourceMappingURL=significance-density.js.map

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",
@@ -19,12 +18,7 @@
         "hope this message finds you well",
         "this is not an exhaustive list"
     ],
-    "paragraphStartsWith": [
-        "it is important to note",
-        "it's important to note",
-        "it is worth noting",
-        "it's worth noting"
-    ],
+    "paragraphStartsWith": [],
     "contains": [
         "want me to delve deeper",
         "would you like me to delve",

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.18",
+  "version": "0.2.20",
   "description": "Deterministic textlint rules and CLI for catching prose slop in English Markdown.",
   "keywords": [
     "textlint",