prose-engine.mjs

Functions

Imports

It imports no other module of this repo. Imported by prose.mjs.

Source

1// GENERATED by update-prose-engine.mjs: do not edit. Change the version there and run it again.
2// avoid-ai-writing-detector@3.38.0, detector/patterns.js (https://github.com/conorbronsdon/avoid-ai-writing), under its licence:
3//
4// MIT License
5//
6// Copyright (c) 2026 Conor Bronsdon
7//
8// Permission is hereby granted, free of charge, to any person obtaining a copy
9// of this software and associated documentation files (the "Software"), to deal
10// in the Software without restriction, including without limitation the rights
11// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12// copies of the Software, and to permit persons to whom the Software is
13// furnished to do so, subject to the following conditions:
14//
15// The above copyright notice and this permission notice shall be included in all
16// copies or substantial portions of the Software.
17//
18// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
24// SOFTWARE.
25
26/**
27 * Avoid AI Writing — detection engine (canonical source of truth)
28 * Implements regex, structural, and stylometric pattern detection. This repo's SKILL.md
29 * catalogs the human-editable pattern rules; this engine is the executable
30 * expression of the regex-detectable subset and extends it with stylometric and
31 * AI-tool-fingerprint detectors that don't make sense as skill prose
32 * (cross-paragraph burstiness, smart-punct signatures, function-word
33 * trigram entropy, low type-token ratio, AI-tool URL parameters,
34 * chatbot citation markup leaks, unfilled placeholders).
35 *
36 * Scoring model:
37 *   Each category has a weight in the ISSUE_WEIGHTS table. Detection runs
38 *   produce raw (possibly duplicate) issues which are then deduplicated by
39 *   (type, text) pair. rawScore is the sum of category weights across the
40 *   deduped list — so the number reflects the same distinct signals the
41 *   user sees in the issue list.
42 *
43 *   Weights are deliberately non-flat across severity tags. Cutoff
44 *   disclaimers (10) and chatbot artifacts (8) weigh more than vague
45 *   attributions (5), even though all three are tagged `critical`, because
46 *   the skill treats them as stronger or weaker AI-origin signals.
47 *
48 *   rawScore is then normalized to 0-100 via `log2(wordCount/50)` so longer
49 *   texts don't accumulate unboundedly on the same density of patterns.
50 */
51
52const AIDetector = (() => {
53  // ═══ Tier 1 pre-pass: normalize bypass tricks ══════════════════════
54  //
55  // Humanizer tools and prompt-injection bypass techniques insert
56  // invisible / lookalike chars to defeat exact-string detectors. Strip
57  // them BEFORE pattern matching so "delve" with a Cyrillic 'е' still
58  // hits the Tier 1 list. Unicode ranges sourced from
59  // It-s-AI/llm-detection/detection/attacks/.
60  //
61  // Tracks what was stripped so the trinary classifier can use
62  // "normalization triggered" as a corroborating AI signal — humans don't
63  // paste ZWSPs into their own writing.
64  const CYRILLIC_LOOKALIKES = {
65    'а': 'a', 'е': 'e', 'о': 'o', 'р': 'p', 'с': 'c', 'х': 'x',
66    'у': 'y', 'к': 'k', 'м': 'm', 'н': 'h', 'в': 'b', 'т': 't',
67    'А': 'A', 'Е': 'E', 'О': 'O', 'Р': 'P', 'С': 'C', 'Х': 'X',
68    'У': 'Y', 'К': 'K', 'М': 'M', 'Н': 'H', 'В': 'B', 'Т': 'T',
69  };
70  const GREEK_LOOKALIKES = { 'ο': 'o', 'Ο': 'O', 'α': 'a', 'Α': 'A', 'ρ': 'p', 'Ρ': 'P' };
71
72  // ─── Source-coordinate mapping (issue #189) ─────────────────────────
73  //
74  // Each entry maps one code unit in the working string to the matching
75  // code unit in the caller's source. Deletion passes copy the entries for
76  // retained characters once, so interleaved or overlapping removals cannot
77  // double-count offsets. Masking and homoglyph replacement keep their input
78  // length and therefore keep the current map unchanged.
79  function identitySourceMap(length) {
80    return Array.from({ length }, (_, index) => index);
81  }
82
83  function appendMapRange(target, source, start, end) {
84    for (let index = start; index < end; index += 1) target.push(source[index]);
85  }
86
87  function remapFindingsToSource(issues, regions, sourceMap) {
88    for (const issue of issues) {
89      if (Number.isInteger(issue.index)) issue.index = sourceMap[issue.index];
90    }
91    for (const region of regions) {
92      region.start = sourceMap[region.start];
93      region.end = sourceMap[region.end - 1] + 1;
94    }
95  }
96
97  const ZERO_WIDTH_RE = /[​-‍⁠]/u;
98  const ZERO_WIDTH_GLOBAL_RE = /[​-‍⁠]/gu;
99  const HOMOGLYPH_RE = /[Ѐ-ӿͰ-Ͽ]/u;
100  const HOMOGLYPH_GLOBAL_RE = /[Ѐ-ӿͰ-Ͽ]/gu;
101  const LATIN_LETTER_RE = /\p{Script=Latin}/u;
102  // Dates, versions and ASCII filenames keep internal dots; prose may hard-wrap.
103  // Other sentence punctuation and Markdown/HTML block starts separate units, even
104  // without a space, so unrelated Russian text cannot hide an English word.
105  const SENTENCE_UNIT_GLOBAL_RE = /(?:[^.!?\r\n]|(?<=[A-Za-z0-9_])\.(?=[A-Za-z0-9_])|\r?\n(?![ \t]*(?:\r?\n|(?:[-*+]|#{1,6}|\d+[.)])\s|[><|]|`{3}|~{3}|(?:-+|(?:\*[ \t]*){3,}|(?:_[ \t]*){3,}|(?:-[ \t]*){3,}|=+)[\t ]*(?:\r?\n|$)|:?-+:?[\t ]*(?:\|[\t ]*:?-+:?[\t ]*)+\|?[\t ]*(?:\r?\n|$))))+/g;
106  // Words are letter runs; a hyphen splits them, so "API-сервис" stays two
107  // words and its Russian half is not swapped.
108  const LETTER_RUN_GLOBAL_RE = /[\p{L}\p{M}]+/gu;
109  const ROLEPLAY_VERBS_RE = /^(?:nods|sighs|laughs|smiles|frowns|shrugs|grins|winks|chuckles|gasps|pauses|thinks|wonders|whispers|shouts|gestures|raises|leans|turns|looks|glances|smirks|blinks|nodding|sighing|laughing|smiling|thinking|gesturing)\b/i;
110  const ROLEPLAY_MARKER_RE = /(?<!\*)\*([^*\n]{1,80}?)\*(?!\*)/gu;
111
112  // A word joiner (U+2060) only counts as a bypass character when it splits a
113  // word: letters on both sides, the shape a humanizer uses to break "delve"
114  // apart. Show-notes and CMS editors insert word joiners next to URLs and
115  // punctuation to control line breaking (#351); those are still stripped so
116  // matching sees clean text, but they are typesetting, not AI evidence.
117  // Neighbours are read past a short adjacent zero-width run, so a doubled
118  // joiner inside a word still counts. The bound keeps a long run linear.
119  const LETTER_END_RE = /\p{L}$/u;
120  const LETTER_START_RE = /^\p{L}/u;
121  const MAX_ZERO_WIDTH_SKIP = 8;
122  function countsAsBypass(chars, i) {
123    if (chars[i] !== '\u2060') return true;
124    let before = i - 1;
125    while (before >= 0 && i - before <= MAX_ZERO_WIDTH_SKIP && ZERO_WIDTH_RE.test(chars[before])) before -= 1;
126    let after = i + 1;
127    while (after < chars.length && after - i <= MAX_ZERO_WIDTH_SKIP && ZERO_WIDTH_RE.test(chars[after])) after += 1;
128    // A two-unit slice lets the Unicode regex see a supplementary-plane letter.
129    return LETTER_END_RE.test(chars.slice(Math.max(0, before - 1), before + 1))
130      && LETTER_START_RE.test(chars.slice(after, after + 2));
131  }
132
133  function normalizeText(text, sourceMap) {
134    const flags = { zeroWidth: 0, homoglyph: 0, roleplay: 0 };
135    let out = text;
136    let map = Array.isArray(sourceMap) ? sourceMap : null;
137
138    // 1. Strip zero-width chars (ZWSP U+200B, ZWNJ U+200C, ZWJ U+200D,
139    //    BOM U+FEFF, word joiner U+2060). Word joiners outside a word are
140    //    stripped without being counted; see countsAsBypass.
141    if (map) {
142      const chars = [];
143      const nextMap = [];
144      for (let i = 0; i < out.length; i += 1) {
145        if (ZERO_WIDTH_RE.test(out[i])) {
146          if (countsAsBypass(out, i)) flags.zeroWidth += 1;
147          continue;
148        }
149        chars.push(out[i]);
150        nextMap.push(map[i]);
151      }
152      out = chars.join('');
153      map = nextMap;
154    } else {
155      out = out.replace(ZERO_WIDTH_GLOBAL_RE, (_, offset, whole) => {
156        if (countsAsBypass(whole, offset)) flags.zeroWidth += 1;
157        return '';
158      });
159    }
160
161    // 2. Swap Cyrillic / Greek Latin-lookalike chars back to Latin so
162    //    pattern matching catches obfuscated tokens. Swapping every а, е, о
163    //    reported thousands of "homoglyph swaps" on plain Russian text, and
164    //    swapping inside ordinary Russian words flagged bilingual technical
165    //    text, so only two word shapes are swapped:
166    //    - mixed-script words ("pаypal", "dеlve"), anywhere;
167    //    - words of two or more letters spelled entirely in lookalike
168    //      letters ("аст" for "act"), when the sentence around them has no
169    //      Russian or Greek in it: every Cyrillic and Greek letter in the
170    //      sentence is a lookalike. Deciding per sentence, not per document,
171    //      keeps Russian padding from hiding such a word in an English
172    //      sentence.
173    //    Sentence punctuation, blank lines and Markdown block starts separate units.
174    //    Internal ASCII-token dots ("07.10", "v1.2", "report.pdf") and a prose
175    //    hard wrap do not end it: cutting there left pieces such as "поста в
176    //    r/StableDiffusion от 07" that looked like Latin text.
177    //    Ordinary Russian words contain non-lookalike letters (з, п, и, л),
178    //    so short Russian words in Russian technical prose ("на Enum",
179    //    "от 07.10") stay put, and one-letter prepositions (с, о, у) are too
180    //    short.
181    //    Known limits, because no letter-level rule separates these from
182    //    real Russian: a fully substituted word inside or next to Russian
183    //    words ("МЕТА поможет", "пароль: аст"), including across prose hard wraps,
184    //    is left alone; a one-letter
185    //    lookalike split off by a hyphen ("а-ct") is left alone; and a short
186    //    Russian sentence spelled only in lookalike letters ("Он сам.") is
187    //    swapped.
188    const lookalikeFor = (m) => CYRILLIC_LOOKALIKES[m] ?? GREEK_LOOKALIKES[m];
189    const swapLookalike = (m) => {
190      const swap = lookalikeFor(m);
191      if (swap) { flags.homoglyph++; return swap; }
192      return m;
193    };
194    const letterCount = (word) => (word.match(/\p{L}/gu) || []).length;
195    const allLookalike = (word) => letterCount(word) >= 2
196      && [...word].every((ch) => lookalikeFor(ch) || !/\p{L}/u.test(ch));
197    out = out.replace(SENTENCE_UNIT_GLOBAL_RE, (unit) => {
198      const scriptLetters = unit.match(HOMOGLYPH_GLOBAL_RE) || [];
199      const onlyLookalikes = scriptLetters.length > 0 && scriptLetters.every((ch) => lookalikeFor(ch));
200      const words = [...unit.matchAll(LETTER_RUN_GLOBAL_RE)];
201      let result = '';
202      let last = 0;
203      words.forEach((match) => {
204        const word = match[0];
205        let next = word;
206        if (HOMOGLYPH_RE.test(word)) {
207          if (LATIN_LETTER_RE.test(word) || (allLookalike(word) && onlyLookalikes)) {
208            next = word.replace(HOMOGLYPH_GLOBAL_RE, swapLookalike);
209          }
210        }
211        result += unit.slice(last, match.index) + next;
212        last = match.index + word.length;
213      });
214      return result + unit.slice(last);
215    });
216
217    // 3. Strip *roleplay-action* markers — paired *...* containing an
218    //    action verb (nods, sighs, laughs, smiles, etc.) anchored to
219    //    the start of the inner phrase. This is the actual chat-model
220    //    artifact shape. Markdown `**bold**` is rejected by the
221    //    lookbehind/lookahead; legitimate multi-word `*italic*` is
222    //    preserved because the verb whitelist is narrow.
223    if (map) {
224      const chars = [];
225      const nextMap = [];
226      const matcher = new RegExp(ROLEPLAY_MARKER_RE.source, ROLEPLAY_MARKER_RE.flags);
227      let cursor = 0;
228      let match;
229      while ((match = matcher.exec(out)) !== null) {
230        if (!ROLEPLAY_VERBS_RE.test(match[1])) continue;
231        chars.push(out.slice(cursor, match.index));
232        appendMapRange(nextMap, map, cursor, match.index);
233        flags.roleplay += 1;
234        cursor = match.index + match[0].length;
235      }
236      chars.push(out.slice(cursor));
237      appendMapRange(nextMap, map, cursor, map.length);
238      out = chars.join('');
239      map = nextMap;
240    } else {
241      out = out.replace(ROLEPLAY_MARKER_RE, (m, inner) => {
242        if (ROLEPLAY_VERBS_RE.test(inner)) {
243          flags.roleplay += 1;
244          return '';
245        }
246        return m;
247      });
248    }
249
250    return map ? { text: out, flags, sourceMap: map } : { text: out, flags };
251  }
252
253  // Terms with legitimate technical meaning that are suppressed when contextMode === 'technical'.
254  // See references/patterns.md and issue #237.
255  const TECHNICAL_EXEMPT = new Set([
256    'robust',
257    'comprehensive',
258    'seamless',
259    'seamlessly',
260    'ecosystem',
261    'leverage',
262    'leverages',
263    'leveraging',
264    'leveraged',
265    'facilitate',
266    'facilitates',
267    'underpin',
268    'underpinning',
269    'underpinnings',
270    'streamline',
271  ]);
272
273  // ─── Tier 1: Always flag ───────────────────────────────────────────
274  const TIER1 = {
275    'delve': 'explore, dig into, look at',
276    'tapestry': 'complex structure, rich history',
277    'paradigm': 'model, approach, framework',
278    'beacon': 'rewrite entirely',
279    'robust': 'strong, reliable, solid',
280    'comprehensive': 'thorough, complete, full',
281    'cutting-edge': 'latest, newest, advanced',
282    'pivotal': 'important, key, critical',
283    'meticulous': 'careful, detailed, precise',
284    'meticulously': 'carefully, precisely',
285    'seamless': 'smooth, easy, without friction',
286    'seamlessly': 'smoothly, easily',
287    'game-changer': 'changes how [X] works',
288    'game-changing': 'changes how [X] works',
289    'nestled': 'is located, sits',
290    'vibrant': 'lively, active',
291    'thriving': 'growing, active',
292    'bustling': 'busy, active',
293    'intricate': 'complex, detailed',
294    'intricacies': 'complexities, details',
295    'ever-evolving': 'changing, growing',
296    'enduring': 'lasting, long-running',
297    'daunting': 'hard, difficult',
298    'holistic': 'complete, full, whole',
299    'holistically': 'completely, fully',
300    'actionable': 'practical, useful, concrete',
301    'impactful': 'effective, significant',
302    'learnings': 'lessons, findings, takeaways',
303    'synergy': 'combined effect, benefit of working together',
304    'synergies': 'combined effect, benefit of working together',
305    'interplay': 'relationship, connection',
306    'symphony': 'coordination, balance',
307    'embrace': 'adopt, accept, use',
308  };
309
310  // Multi-word tier 1 phrases
311  // "features" is copula avoidance only as a verb: "the app features a
312  // dashboard". The plural noun ("three new features", a "Features" heading,
313  // "the features we shipped") is ordinary product and technical writing, and
314  // it is most of what the word does in corpus/ (#351). A verb needs a subject
315  // before it and an object after it, so the word counts as a noun when it
316  // opens a sentence, line or list item; follows a determiner, number,
317  // possessive, quantifier, "of", "or" or a compound modifier; or comes
318  // before punctuation, a line break, a preposition, a conjunction, a pronoun
319  // or a verb.
320  // Singular "this", "that" and "each" cannot determine the plural noun:
321  // here they are subjects ("each features a...") or a relative pronoun.
322  const FEATURES_NOUN_BEFORE_RE = /(?:^|[.!?:;(]\s*|(?:^|\n)[ \t]*(?:[-*+>#]+[ \t]*)?|\b(?:the|a|an|these|those|its|their|our|your|my|his|her|of|or|new|key|main|core|top|other|more|most|many|several|some|all|any|few|no|both|only|about|over|just|free|similar|common|specific|distinct|additional|extra|premium|advanced|basic|best|unique|missing|upcoming|existing|latest|major|minor|useful|important|various|different|certain|such|\d+|two|three|four|five|six|seven|eight|nine|ten|whose)\s+|\w['’]s\s+|\w[-/]\w+\s+)$/i;
323  // "on-device" is an object modifier, not the preposition "on".
324  const FEATURES_NOUN_AFTER_RE = /^(?:[ \t]*(?:[.,;:!?()[\]"'’”\n]|$)|\s+(?:of|for|in|on|at|into|and|or|but|nor|are|were|is|was|be|been|being|that|which|who|whose|like|such|to|from|with|without|than|help|helps|helped|let|allow|make|keep|give|provide|enable|offer|save|protect|ensure|improve|reduce|support|remain|vary|need|unlock|bring|include|includes|included|work|works|worked|will|can|could|should|would|may|might|must|do|did|does|have|has|had|we|you|they|i|it)(?![\w-]))/i;
325  // Bare product objects: "we ship features", "teams build features".
326  // A subject is required so noun subjects such as "the ship"/"the build"
327  // still flag. One optional modifier preserves "we ship GPT-5 features".
328  const FEATURES_NOUN_OBJECT_RE = /\b(?:i|we|you|they|teams?|developers?|engineers?|users?|companies|vendors|the\s+(?:release|update))\s+(?:(?:can|could|will|would|should|must)\s+)?(?:ship|ships|shipped|shipping|build|builds|built|building|add|adds|added|adding)\s+(?:[\w./-]+\s+)?$/i;
329  // Leads that make "which/what features" an indirect question (#384): a question
330  // verb that opens its clause ("Decide which...", "we should check which..."),
331  // or which/what at the start of a sentence or list item. A lead word inside a
332  // noun phrase ("a security check which features...") does not count.
333  const FEATURES_QUESTION_LEAD_RE = /(?:^|[.!?:;]\s*|(?:^|\n)[ \t]*(?:[-*+>#]+[ \t]*)?|(?:^|[.!?:;,]\s*|(?:^|\n)[ \t]*(?:[-*+>#]+[ \t]*)?|\b(?:i|we|you|they|he|she|let['’]?s|to|can|could|should|must|will|would|please|just|then|first|now|and|or|but|so)\s+)(?:decide|decides|deciding|choose|choosing|pick|check|checking|see|know|knowing|learn|find\s+out|figure\s+out|work\s+out|identify|determine|ask|asking|asked|tell\s+(?:me|us|them|you)|show\s+(?:me|us|them|you)|understand|explain|wonder|discover|confirm|consider|evaluate|prioritize|about)\s+)(?:which|what)\s+$/i;
334
335  // A lead word after a determiner is a noun ("a track which features...",
336  // "the review which features..."), not a question verb.
337  const FEATURES_LEAD_AS_NOUN_RE = /\b(?:a|an|the|this|that|these|those|my|our|your|their|its|his|her|each|every)\s+[\w-]+\s+(?:which|what)\s+$/i;
338
339  // Subjects that definitively make "features" a verb, avoiding ambiguity with
340  // plural-noun subjects like "The experimental features" or "Security features".
341  const FEATURES_VERB_SUBJECTS = /\b(?:library|tool|app|application|platform|system|language|service|product|update|release|version|site|website|game|device|model|framework|package|plugin|extension|which|what|that|who|it|he|she)\s+$/i;
342
343  function featuresIsNoun(text, index) {
344    const end = index + 'features'.length;
345    const before = text.slice(Math.max(0, index - 40), index);
346    const after = text.slice(end, end + 40);
347    if (FEATURES_NOUN_OBJECT_RE.test(before)) return true;
348    // A recognizable model/version followed by an object article is a
349    // subject: "GPT-5 features a...", "Windows 11 features a...".
350    // Determiner-led counts ("These 3 features a customer requested") and
351    // the explicit object contexts above remain nouns. This is a bounded
352    // context heuristic, not a grammatical parse of every use of the word.
353    const product = /\b([A-Z][\w]*)(?:[-/]\d[\w.-]*|[ \t]+\d+(?:\.\d+)*)[ \t]+$/.exec(before);
354    if (product && !FEATURES_NOUN_BEFORE_RE.test(`${product[1]} `)
355        && /^\s+(?:a|an|the)(?![\w-])/i.test(after)) return false;
356    // A short comma-delimited aside can precede the verb's article-led
357    // object. Strong noun contexts still take priority over punctuation.
358    if (!FEATURES_NOUN_BEFORE_RE.test(before)
359        && /^[ \t]*,[^,\n]{1,80},\s*(?:a|an|the)(?![\w-])/i.test(text.slice(end, end + 110))) return false;
360
361    // "which/what features" is a noun in an indirect question: right after a
362    // question verb ("Decide which features matter") or at the start of a
363    // sentence ("Which features matter most..."). Every other context falls
364    // through to the checks below unchanged, so relative clauses ("a library
365    // which features dashboards") keep their verb finding (#384).
366    if (FEATURES_QUESTION_LEAD_RE.test(before) && !FEATURES_LEAD_AS_NOUN_RE.test(before)) {
367      // If there is no trailing verb (e.g. end of clause), it's the verb case ("Check what features a dashboard and export tools.").
368      // Look past a compound subject and optional appositive for a trailing verb before returning the verb classification.
369      const match = /^\s+(?:a|an|the)\s+[\w-]+\s*(?:(?:and\b|or\b)\s+(?:a\s+|an\s+|the\s+)?(?:[\w-]+\s+){0,2}[\w-]+\s*)?(?:([,.!?;])|$)/i.exec(after);
370      if (match) {
371        const predicateRe = /\b(?:can|could|should|will|would|may|might|must|is|are|was|were|has|have|had|do|does|did|include|includes|disable|disables|reject|accept|allow|deny|provide|require|use|make|work|help|give|take|need|become|seem|look|show|offer|support|supports|fail|pass|lack|prefer|choose|prevent|stop)\b/i;
372        
373        // If the matched subject ends with a predicate right before the punctuation, 
374        // the predicate was consumed as part of the compound subject.
375        const subjectText = match[0].slice(0, match[1] ? -match[1].length : undefined).trim();
376        const lastWord = subjectText.split(/\s+/).pop();
377        if (predicateRe.test(lastWord)) {
378          return true;
379        }
380
381        if (match[1] === ',') {
382          // If the comma leads into a phrase, limit noun classification to a predicate 
383          // belonging to the article-led subject (after the next comma), excluding predicates inside subordinate clauses.
384          const remainder = text.slice(end + match[0].length, end + 120);
385          // An adverb can sit between the closing comma and the predicate.
386          const remainderPredicateRe = new RegExp(`^[^,]+,\\s*(?:(?:[\\w-]+ly|also|not|never)\\s+){0,2}${predicateRe.source}`, 'i');
387          if (remainderPredicateRe.test(remainder)) {
388            return true;
389          }
390        }
391        return false;
392      }
393      return true;
394    }
395
396    // "The library features support for..." is a verb.
397    // "Security features support for..." is a plural noun subject + verb.
398    if (FEATURES_VERB_SUBJECTS.test(before) && /^\s+support\s+for\b/i.test(after)) {
399      // A nearby quantifier in an earlier clause cannot make a singular pronoun plural.
400      if (/\b(?:it|he|she)\s+$/i.test(before)) return false;
401      const hasPluralDeterminer = /\b(?:these|those|all|some|many|few|various|multiple|several|both)\s+(?:[\w-]+\s+){1,2}$/i.test(before);
402      // Count words modify "features" only when they follow its determiner.
403      // A digit inside a product name ("This Windows 11 app") or a date before
404      // the subject ("In 2024 the library") is not a plural count.
405      const hasPluralCount = /\b(?:the|a|an|this|that|my|our|your|their|its|his|her|each|every)\s+(?:(?:\d{1,2}|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve|thirteen|fourteen|fifteen|sixteen|seventeen|eighteen|nineteen|twenty|dozen)\s+(?:[\w-]+\s+){1,2}|(?!(?:19|20)\d{2}\s)\d{3,}\s+(?!(?:[\w-]+\s+)?(?:app|release|model|version|update)\s+$)(?:[\w-]+\s+){1,2})$/i.test(before);
406      const extendedAfter = text.slice(end, end + 100);
407      // A predicate inside a relative clause modifying the object (e.g. "teams that connect and remain online")
408      // is not coordinated with the main subject. Limit predicate search to the direct prepositional object.
409      const hasPartitivePlural = /\b(?:all|some|many|most|few|several|both|\d+|two|three|four|five|six|seven|eight|nine|ten)\s+of\s+(?:the|my|our|your|their|its|his|her)\s+(?:[\w-]+\s+){1,3}$/i.test(before);
410      const hasPluralPredicate = /^\s+support\s+for(?:(?!\b(?:that|which|who|whom|whose|where|when)\b)[^.?!;]){0,80}?\b(?:and|but|or|nor)\s+(?:are|were|have|do|reject|accept|allow|deny|provide|require|use|make|work|help|give|take|need|become|seem|look|show|include|offer|support|remain|fail|pass|lack|prefer|choose|prevent|stop)\b/i.test(extendedAfter);
411      const hasForObject = /^\s+support\s+for(?:-|\s+)(?:profit|loops?)\b/i.test(after);
412      // Numeric modifiers and plural cues exclude a singular-subject reading:
413      // "The two platform features..." has plural noun "features".
414      // Do not borrow a determiner across a preposition or conjunction:
415      // "a suite of system features" still has plural noun "features".
416      // "that" can introduce a clause and "which" can determine plural nouns.
417      // A relative pronoun needs its own determiner-led subject evidence.
418      const hasUnambiguousSingular = /\b(?:a|an|this|that|every|each|one)\s+(?:(?!(?:of|for|in|with|and|or|which|what|that|who|two|three|four|five|six|seven|eight|nine|ten|multiple|several|many|few|both|various)\b)[\w-]+\s+){1,3}$/i.test(before)
419        || /\b(?:it|he|she)\s+$/i.test(before)
420        || /\b(?:a|an|this|that|each|every|one)\s+[\w-]+\s+(?:which|that|who)\s+$/i.test(before);
421
422      const hasSingularEvidence = hasUnambiguousSingular
423        || /\b(?:the|my|our|your|their|its|his|her)\s+(?:(?!(?:of|for|in|with|and|or|which|what|that|who|two|three|four|five|six|seven|eight|nine|ten|multiple|several|many|few|both|various)\b)[\w-]+\s+){1,3}$/i.test(before)
424        || /\b(?:the|my|our|your|their|its|his|her)\s+[\w-]+\s+(?:which|that|who)\s+$/i.test(before);
425      
426      // Unambiguous singular subjects ("It", "This app") cannot be plural-noun phrases,
427      // so hasForObject ("support for loops") only suppresses ambiguous determiners ("The library").
428      if (!hasPluralDeterminer && !hasPluralCount && !hasPartitivePlural && !hasPluralPredicate && (hasUnambiguousSingular || (!hasForObject && hasSingularEvidence))) {
429        return false;
430      }
431    }
432
433    return FEATURES_NOUN_BEFORE_RE.test(before) || FEATURES_NOUN_AFTER_RE.test(after);
434  }
435
436  const TIER1_PHRASES = [
437    { pattern: /\bdelve\s+into\b/gi, replace: 'explore, dig into' },
438    { pattern: /\blandscape\b/gi, replace: 'field, space, industry', filter: true },
439    { pattern: /\brealm\b/gi, replace: 'area, field, domain' },
440    { pattern: /\btestament\s+to\b/gi, replace: 'shows, proves' },
441    { pattern: /\bleverag(?:e|es|ing|ed)\b/gi, replace: 'use' },
442    { pattern: /\bwatershed\s+moment\b/gi, replace: 'turning point, shift' },
443    { pattern: /\bmarking\s+a\s+pivotal\s+moment\b/gi, replace: 'changing [X], leading to [Y]' },
444    { pattern: /\bthe\s+future\s+looks\s+bright\b/gi, replace: 'cut or say something specific' },
445    { pattern: /\bonly\s+time\s+will\s+tell\b/gi, replace: 'cut or say something specific' },
446    { pattern: /\bdespite\s+challenges[^.]*continues?\s+to\s+thrive\b/gi, replace: 'keeps growing despite [named difficulty], continues to succeed despite [named difficulty]' },
447    { pattern: /\bdeep\s+dive\b/gi, replace: 'look at, examine' },
448    { pattern: /\bdive\s+into\b/gi, replace: 'look at, examine' },
449    { pattern: /\bunpack(?:ing)?\b/gi, replace: 'explain, break down' },
450    { pattern: /\bcomplexities\b/gi, replace: 'problems, details' },
451    { pattern: /\bthought\s+leader(?:ship)?\b/gi, replace: 'expert, authority' },
452    { pattern: /\bbest\s+practices\b/gi, replace: 'what works, proven methods' },
453    { pattern: /\bat\s+its\s+core\b/gi, replace: 'cut, just state it' },
454    { pattern: /\bin\s+order\s+to\b/gi, replace: 'to', clarity: true },
455    { pattern: /\bdue\s+to\s+the\s+fact\s+that\b/gi, replace: 'because', clarity: true },
456    { pattern: /\bserves\s+as\b/gi, replace: 'is', clarity: true },
457    { pattern: /\bfeatures\b/gi, replace: 'has, includes', filter: true, clarity: true, skip: featuresIsNoun },
458    { pattern: /\bboasts\b/gi, replace: 'has', clarity: true },
459    { pattern: /\butiliz(?:e|es|ing|ed)\b/gi, replace: 'use', clarity: true },
460    { pattern: /\bshowcas(?:e|es|ing|ed)\b/gi, replace: 'show, demonstrate' },
461    { pattern: /\bembark(?:s|ing|ed)?\b/gi, replace: 'start, begin' },
462    { pattern: /\bcommenc(?:e|es|ing|ed)\b/gi, replace: 'start, begin', clarity: true },
463    { pattern: /\bascertain(?:s|ing|ed)?\b/gi, replace: 'find out, determine', clarity: true },
464    { pattern: /\bendeavou?r(?:s|ing|ed)?\b/gi, replace: 'effort, attempt, try', clarity: true },
465    { pattern: /\bunderscor(?:es|ing|ed)\b/gi, replace: 'highlights, shows' },
466    // Hyphen required. The unhyphenated "load bearing" is ordinary English —
467    // "the load bearing down on the bridge" — where `bearing` is a participle,
468    // not part of a compound modifier. The tell is always hyphenated.
469    //
470    // Only match an immediately following abstract noun from this seed list.
471    // Unknown nouns, mixed physical/abstract nouns, and predicative uses pass:
472    // precision over recall (#56). Keep the lookahead out of the matched span.
473    { pattern: /\bload-bearing\b(?=[ \t]+(?:assumptions?|claims?|invariants?|premises?|constraints?|dependenc(?:y|ies)|arguments?|abstractions?)\b)/gi, replace: 'essential, critical, or say what breaks if you remove it' },
474  ];
475
476  // ─── Tier 2: Flag in clusters (2+ per paragraph) ──────────────────
477  const TIER2 = {
478    'harness': 'use, take advantage of',
479    'navigate': 'work through, handle',
480    'navigating': 'working through, handling',
481    'foster': 'encourage, support, build',
482    'elevate': 'improve, raise, strengthen',
483    'unleash': 'release, enable, unlock',
484    'streamline': 'simplify, speed up',
485    'empower': 'enable, let, allow',
486    'bolster': 'support, strengthen',
487    'spearhead': 'lead, drive, run',
488    'resonate': 'connect with, appeal to',
489    'resonates': 'connects with, appeals to',
490    'revolutionize': 'change, transform',
491    'facilitate': 'enable, help, allow',
492    'facilitates': 'enables, helps, allows',
493    'underpin': 'support, form the basis of',
494    'nuanced': 'specific, subtle, detailed',
495    'crucial': 'important, key, necessary',
496    'multifaceted': 'having several parts, with several aspects',
497    'ecosystem': 'system, community, network',
498    'myriad': 'many, numerous',
499    'plethora': 'many, a lot of',
500    'encompass': 'include, cover, span',
501    'catalyze': 'start, trigger, accelerate',
502    'reimagine': 'rethink, redesign, rebuild',
503    'galvanize': 'motivate, rally, push',
504    'augment': 'add to, expand, supplement',
505    'cultivate': 'build, develop, grow',
506    'illuminate': 'clarify, explain, show',
507    'elucidate': 'explain, clarify',
508    'juxtapose': 'compare, contrast',
509    'transformative': 'changes how [X] works',
510    'transformation': 'major change, overhaul',
511    'cornerstone': 'foundation, basis, key part',
512    'paramount': 'most important, top priority',
513    'poised': 'ready, set, about to',
514    'burgeoning': 'growing, emerging',
515    'nascent': 'new, early-stage',
516    'quintessential': 'typical, classic, defining',
517    'overarching': 'main, central, broad',
518    'quietly': 'cut, or name the concrete contrast',
519    'underpinning': 'basis, foundation',
520    'underpinnings': 'basis, foundations',
521    'paradigm-shifting': 'changes the basic model, changes how [X] is understood',
522  };
523
524  // Conditional Tier 2 entries: everyday words whose AI tell is a specific
525  // significance collocation, not the word itself. They join a paragraph's
526  // Tier 2 cluster only when the collocation matches — bare uses ("deeply
527  // nested JSON", "cares deeply") never count, because the base rate of
528  // these words in innocent prose is far higher than the rest of the table
529  // and an unconditional entry measurably flags clean human writing.
530  const TIER2_CONDITIONAL = [
531    {
532      word: 'deeply',
533      pattern: /\bdeeply\s+(?:integrated|committed|rooted|personal|human|flawed|resonant|transformative|interconnected|ingrained|embedded|meaningful)\b/i,
534      suggestion: 'cut, or name what specifically runs deep',
535    },
536  ];
537
538  // ─── Tier 3: Flag by density ───────────────────────────────────────
539  const TIER3 = [
540    'significant', 'significantly', 'innovative', 'innovation',
541    'effective', 'effectively', 'dynamic', 'dynamics',
542    'scalable', 'scalability', 'compelling', 'unprecedented',
543    'exceptional', 'exceptionally', 'remarkable', 'remarkably',
544    'sophisticated', 'instrumental',
545    'world-class', 'state-of-the-art', 'best-in-class',
546    // `verbatim` is usually redundant with the verb it modifies ("copies X
547    // verbatim" = "copies X"). It has a genuine term-of-art sense in legal,
548    // research, and QA registers ("verbatim transcript"), so it lives at Tier 3:
549    // density-gated, it only fires on overuse, not on a single legitimate use.
550    'verbatim',
551  ];
552
553  // Multi-word Tier 3 phrases. Density-gated like single Tier 3 words because
554  // these legitimately show up in human crypto/web3/dev writing. Threshold is
555  // intentionally lower than single-word Tier 3 (≥2 occurrences of the same
556  // phrase) — repeating the same multi-word boilerplate is a stronger AI tell
557  // than re-using "significant."
558  const TIER3_PHRASES = [
559    /\bemerging\s+(?:sector|space|category|industry)\b/gi,
560    /\bthe\s+integration\s+of\b/gi,
561    /\bthe\s+intersection\s+of\b/gi,
562    /\bcommunity-?driven\b/gi,
563    /\blong-?term\s+sustainability\b/gi,
564    /\buser\s+engagement\b/gi,
565    /\bdecentralized\s+compute\b/gi,
566    /\b(?:sustainable\s+)?reward\s+emissions?\b/gi,
567    /\btokenized\s+incentive\s+structures?\b/gi,
568    /\bdesigned\s+for\s+long-?term\b/gi,
569  ];
570
571  // O(1) lookup from any token form (hyphenated or dashless) to its canonical
572  // Tier 3 word. Counting originally did nested-loop word matching which was
573  // O(tokens × TIER3) — slow on long pastes.
574  const TIER3_LOOKUP = new Map();
575  for (const word of TIER3) {
576    TIER3_LOOKUP.set(word, word);
577    const dashless = word.replace(/-/g, '');
578    if (dashless !== word) TIER3_LOOKUP.set(dashless, word);
579  }
580
581  // Per-category score weights. Applied to distinct (deduplicated) issues so
582  // the score reflects the same signals the user sees in the issue list.
583  // Non-uniform on purpose: critical rules like cutoff disclaimers (×10) and
584  // chatbot artifacts (×8) weigh more than vague attributions (×5), even
585  // though all three are tagged `critical`.
586  const ISSUE_WEIGHTS = {
587    tier1: 5,
588    // Wordiness, not an AI-frequency marker. Weighted like tier2 so a
589    // clarity fix cannot push a document toward an AI classification.
590    'tier1-clarity': 3,
591    tier2: 3,
592    tier3: 2,
593    transition: 2,
594    chatbot: 8,
595    sycophantic: 8,
596    filler: 2,
597    'generic-conclusion': 3,
598    'lets-construction': 2,
599    'reasoning-artifact': 6,
600    'significance-inflation': 4,
601    'vague-attribution': 5,
602    'hollow-intensifier': 2,
603    // Issue #82 evidence boundary: this style pattern produced no detector hits
604    // in either corpus class, so it has no measured authorship direction. Keep
605    // the finding visible, but do not move authorship scores or probabilities
606    // until a relevant positive evaluation set supports a direction.
607    'emotional-flatline': 0,
608    'lingering-attention': 3,
609    'novelty-inflation': 3,
610    'cutoff-disclaimer': 10,
611    'template-phrase': 3,
612    'false-concession': 2,
613    'rhetorical-question': 2,
614    'confidence-calibration': 2,
615    // Writing-quality guidance whose authorship polarity changes across model
616    // generations. Keep the flag visible without moving authorship outputs.
617    'em-dash': 0,
618    uniformity: 5,
619    formatting: 3,
620    'tier3-phrase': 3,
621    // Structural / cluster signals are deliberately weighted high. Unlike
622    // single-vocabulary hits they're near-dispositive on social-length
623    // posts (a 15-hashtag block, a 6-item bullet-NP list, three distinct
624    // crypto-shill phrases stacked) and would otherwise be suppressed by
625    // the log2(words/50) length divisor on short pastes.
626    'tier3-phrase-cluster': 12,
627    'hashtag-stuff': 12,
628    'bullet-np-list': 10,
629    'hedge-stack': 6,
630    'future-narrative': 12,
631    'real-actual-inflation': 5,
632    // Social endorsement / CTA closer. Weighted like formulaic-opener: a
633    // strong single-hit social tell that the length divisor would
634    // otherwise wash out on a short LinkedIn-length post.
635    'social-cta-closer': 8,
636    // Performed-insight tics: single hits are common in human essays, so
637    // weighted like tier2 vocabulary — density does the classifying.
638    'performed-insight': 3,
639    // Negation chains are a strong single-hit structural tell.
640    'negation-chain': 5,
641    // Negative parallelism ("It's not just X, it's Y"). The frame is also
642    // how people state a real correction, so it is weighted below the
643    // negation chain; the per-piece gate in analyzeText does the rest.
644    'negative-parallelism': 4,
645    'dev-blog-boilerplate': 3,
646    'formulaic-opener': 8,
647    // Speculative scenario opener ("Imagine a world where…"). Weighted like
648    // formulaic-opener: a single strong opener tell the length divisor would
649    // otherwise wash out on a short post.
650    'speculative-opener': 8,
651    // Launch-copy introduction ("Enter X.", "Meet X, your new...").
652    // Weighted like the other single-hit opener tells: strong on the
653    // short launch posts where it actually appears.
654    'launch-intro': 8,
655    // Dramatized crowd contrast. Gated hard on the dismissive verb, so
656    // a hit is meaningful, but the surface shares words with ordinary
657    // narrative — weighted below the opener tells on purpose.
658    'crowd-contrast': 6,
659    // Fake-casual props (stage directions, wink asides). Near-costume
660    // when present; same class as the opener tells on short posts.
661    'fake-casual-prop': 8,
662    'title-case-header': 4,
663    'parenthetical-hedge': 3,
664    'smart-punct-signature': 6,
665    'punct-distribution': 6,
666    'fnword-trigram-entropy': 5,
667    'cross-para-burstiness': 5,
668    'normalization-flag': 9,
669    // Vocabulary-diversity signal (type-token ratio). Weighted modestly
670    // because the threshold (>=200 tokens AND TTR<0.4) is conservative;
671    // it stacks with structural signals to push borderline scores up.
672    'low-ttr': 3,
673    // AI-tool fingerprints. Weighted higher than statistical patterns
674    // because each is a near-definitive single-hit signal — the AI tool
675    // literally left its mark in the text. citation-markup ranks highest
676    // (smoking gun: the literal internal markup of ChatGPT/Grok/etc.),
677    // UTM tracking second (auto-appended by the tool to URLs it writes),
678    // placeholders third (strong but humans use bracketed slots in
679    // templates legitimately and forget them — still a publishing bug
680    // but slightly less definitive AI evidence).
681    'ai-placeholder': 10,
682    'ai-citation-markup': 15,
683    'ai-utm-source': 12,
684    // Curated P2 copyedits, not authorship evidence. Keep them visible in the
685    // issue list without moving the AI score, label, probabilities, or
686    // trinary classification on short documents.
687    'unnecessary-hyphenation': 0,
688  };
689
690  // ─── Transition phrases ────────────────────────────────────────────
691  const TRANSITIONS = [
692    /\bmoreover\b/gi,
693    /\bfurthermore\b/gi,
694    /\badditionally\b/gi,
695    /\bin\s+today'?s\b/gi,
696    /\bin\s+an\s+era\s+where\b/gi,
697    /\bit'?s\s+worth\s+noting\s+that\b/gi,
698    /\bnotably\b/gi,
699    /\bin\s+conclusion\b/gi,
700    /\bin\s+summary\b/gi,
701    /\bto\s+summarize\b/gi,
702    /\bwhen\s+it\s+comes\s+to\b/gi,
703    /\bat\s+the\s+end\s+of\s+the\s+day\b/gi,
704    /\bthat\s+(?:being\s+)?said\b/gi,
705  ];
706
707  // ─── Chatbot artifacts ─────────────────────────────────────────────
708  const CHATBOT_ARTIFACTS = [
709    /\bi\s+hope\s+this\s+helps\b/gi,
710    /\bcertainly!\b/gi,
711    /\babsolutely!\b/gi,
712    /\bgreat\s+question!\b/gi,
713    /\bexcellent\s+point!\b/gi,
714    /\bfeel\s+free\s+to\s+reach\s+out\b/gi,
715    /\blet\s+me\s+know\s+if\s+you\s+need\s+anything\b/gi,
716    /\bin\s+this\s+article,?\s+we\s+will\s+explore\b/gi,
717    /\blet'?s\s+dive\s+in!?\b/gi,
718  ];
719
720  // ─── Sycophantic tone ──────────────────────────────────────────────
721  const SYCOPHANTIC = [
722    /\byou'?re\s+absolutely\s+right\b/gi,
723    /\bthat'?s\s+a\s+really\s+insightful\b/gi,
724    /\bthat'?s\s+a\s+great\s+question\b/gi,
725    /\bexcellent\s+question\b/gi,
726  ];
727
728  // ─── Filler phrases ────────────────────────────────────────────────
729  const FILLERS = [
730    /\bit\s+is\s+important\s+to\s+note\s+that\b/gi,
731    /\bin\s+terms\s+of\b/gi,
732    /\bthe\s+reality\s+is\s+that\b/gi,
733    /\bit'?s\s+important\s+to\s+note\s+that\b/gi,
734  ];
735
736  // ─── Generic conclusions ───────────────────────────────────────────
737  const GENERIC_CONCLUSIONS = [
738    /\bthe\s+future\s+looks\s+bright\b/gi,
739    /\bonly\s+time\s+will\s+tell\b/gi,
740    /\bone\s+thing\s+is\s+certain\b/gi,
741    /\bas\s+we\s+move\s+forward\b/gi,
742  ];
743
744  // ─── "Let's" constructions ─────────────────────────────────────────
745  const LETS_PATTERNS = [
746    /\blet'?s\s+explore\b/gi,
747    /\blet'?s\s+take\s+a\s+look\b/gi,
748    /\blet'?s\s+break\s+this\s+down\b/gi,
749    /\blet'?s\s+examine\b/gi,
750    /\blet'?s\s+(?:consider|discuss|delve|unpack|walk\s+through)\b/gi,
751  ];
752
753  // ─── Reasoning chain artifacts ─────────────────────────────────────
754  const REASONING_ARTIFACTS = [
755    /\blet\s+me\s+think\s+step\s+by\s+step\b/gi,
756    /\bbreaking\s+this\s+down\b/gi,
757    /\bto\s+approach\s+this\s+systematically\b/gi,
758    /\bhere'?s\s+my\s+thought\s+process\b/gi,
759    /\bfirst,?\s+let'?s\s+consider\b/gi,
760    /\bworking\s+through\s+this\s+logically\b/gi,
761  ];
762
763  // NOTE: Acknowledgment loops are judgment-only (#239). The three phrases the
764  // detector matched ("you're asking about", "the question of whether", "to answer
765  // your question") are also how people open an ordinary reply and standard
766  // analytical English. The tell is a restatement that adds nothing, which a
767  // regex cannot see. See detector/CATEGORIES.md §C.
768
769  // ─── Significance inflation ────────────────────────────────────────
770  const SIGNIFICANCE_INFLATION = [
771    /\bmarking\s+a\s+(?:pivotal|significant|important)\s+moment\b/gi,
772    /\ba\s+watershed\s+moment\s+for\b/gi,
773    // Require an inflating word before "in the evolution of" (the bare phrase
774    // is allowed for literal uses like "a key stage in the evolution of the
775    // vertebrate eye"). See issue #212.
776    /\b(?:moment|milestone|chapter|era|turning\s+point|watershed|inflection\s+point|leap|role|new\s+phase)\s+in\s+the\s+evolution\s+of\b/gi,
777    /\ba\s+(?:pivotal|defining)\s+moment\s+in\b/gi,
778  ];
779
780  // ─── Vague attributions ────────────────────────────────────────────
781  const VAGUE_ATTRIBUTIONS = [
782    /\bexperts\s+(?:believe|say|suggest|agree)\b/gi,
783    /\bstudies\s+(?:show|suggest|indicate)\b/gi,
784    /\bresearch\s+(?:shows|suggests|indicates)\b/gi,
785    /\bindustry\s+leaders\s+(?:agree|believe|say)\b/gi,
786  ];
787
788  // ─── Hollow intensifiers ──────────────────────────────────────────
789  const HOLLOW_INTENSIFIERS = [
790    /\bgenuine(?:ly)?\b/gi,
791    /\btruly\b/gi,
792    /\bquite\s+frankly\b/gi,
793    /\bto\s+be\s+honest\b/gi,
794    /\blet'?s\s+be\s+clear\b/gi,
795  ];
796
797  // ─── Emotional flatline ────────────────────────────────────────────
798  // The "interesting (part|thing|aspect|piece)" family is matched in two
799  // shapes: (1) "the most interesting X" inline (the canonical AI list
800  // intro), and (2) bare "Interesting X:" used as a section-header opener,
801  // which is the section-break variant that slipped past v3.3.x.
802  const EMOTIONAL_FLATLINE = [
803    /\bwhat\s+surprised\s+me\s+most\b/gi,
804    /\bi\s+was\s+fascinated\s+to\b/gi,
805    /\bwhat\s+struck\s+me\s+was\b/gi,
806    /\bi\s+was\s+excited\s+to\s+learn\b/gi,
807    /\bthe\s+most\s+interesting\s+(?:part|thing|aspect|piece)\b/gi,
808    // Multiline flag (/m) so `^` matches at every line start, including
809    // position 0 of a pasted text that has no leading newline. The earlier
810    // `(?:^|\n)` form silently missed bare openers at the very start of
811    // input — caught by silent-failure audit 2026-05-16. Leading whitespace
812    // is `[ \t]*`, not `\s*`: with /m every line start is a match attempt,
813    // and a `\s*` that can cross newlines rescans the whole blank run from
814    // each of them, which made a long masked block quadratic (#235).
815    /^[ \t]*interesting\s+(?:part|thing|aspect|piece)(?:\s+of\s+(?:the\s+)?\w+)?\s*:/gim,
816  ];
817
818  // ─── Lingering-attention claims ────────────────────────────────────
819  // The share-post opener that claims duration of attention instead of
820  // saying anything about the thing ("the line I keep coming back to").
821  //
822  // Precision note: the bare verb phrase "I keep coming back to X" is NOT
823  // matched on its own, because it is legitimate whenever a reason follows
824  // ("I keep coming back to Hirschman because it predicts who quits"), and
825  // the reason clause is not reliably detectable by regex. Only the
826  // noun-anchored frame ("the line/quote/bit ... I keep coming back to")
827  // fires, which is the shape that introduces a subject rather than
828  // asserting something about it. The bare form stays a skill-prose
829  // judgment call. See SKILL.md §Lingering-attention claims carve-out.
830  const LINGERING_ATTENTION = [
831    // "the line I keep coming back to", "the one quote that I keep coming back to"
832    // Noun-anchored frame only. "can't stop thinking about" is deliberately
833    // left to its own pattern below rather than folded into this alternation,
834    // so "the line I can't stop thinking about" scores once, not twice.
835    /\b(?:the|that|this)\s+(?:one\s+)?(?:line|quote|bit|part|idea|point|framing|comment|thing)\s+(?:that\s+)?i\s+keep\s+(?:coming\s+back\s+to|thinking\s+about)\b/gi,
836    /\bi\s+can'?t\s+stop\s+thinking\s+about\b/gi,
837    /\bstill\s+thinking\s+about\s+(?:this|that)\s+one\b/gi,
838    /\b(?:been|be)\s+rattling\s+around\s+(?:in\s+)?my\s+(?:head|brain)\b/gi,
839    /\bi'?ve\s+been\s+chewing\s+on\s+(?:this|that)\b/gi,
840  ];
841
842  // ─── Novelty inflation ─────────────────────────────────────────────
843  const NOVELTY_INFLATION = [
844    /\bthe\s+failure\s+mode\s+nobody'?s?\s+naming\b/gi,
845    /\ba\s+problem\s+nobody\s+talks\s+about\b/gi,
846    /\bthe\s+insight\s+everyone'?s?\s+missing\b/gi,
847    /\bwhat\s+nobody\s+tells\s+you\b/gi,
848  ];
849
850  // ─── Cutoff disclaimers ────────────────────────────────────────────
851  // Includes the canonical LLM self-identification phrases — these are
852  // near-dispositive on their own (real humans don't write "as an AI
853  // language model" in first person). Patterns cover the major model
854  // families' default disclaimer language.
855  const CUTOFF_DISCLAIMERS = [
856    /\bas\s+of\s+my\s+last\s+update\b/gi,
857    /\bas\s+of\s+my\s+(?:knowledge\s+)?(?:cut-?off|last\s+training)\b/gi,
858    /\bi\s+don'?t\s+have\s+access\s+to\s+real-?time\s+(?:data|information)\b/gi,
859    /\bbased\s+on\s+available\s+information\b/gi,
860    /\bas\s+an?\s+(?:ai|artificial\s+intelligence|large\s+language|ai\s+language)\s+(?:language\s+)?model\b/gi,
861    /\bi\s+(?:am|'m)\s+an?\s+(?:ai|artificial\s+intelligence|large\s+language)\s+(?:assistant|model)?\b/gi,
862    /\bi\s+cannot\s+(?:provide|give|offer)\s+(?:legal|medical|financial|professional)\s+advice\b/gi,
863    /\bmy\s+training\s+data\s+(?:only\s+)?(?:goes\s+up\s+to|extends\s+to|ends\s+(?:in|at))\b/gi,
864  ];
865
866  // ─── AI-tool fingerprints ──────────────────────────────────────────
867  // Three near-definitive AI-origin signals adapted from
868  // Aboudjem/humanizer-skill P33-P35 (see docs/competitive/audits/
869  // 2026-05-17-aboudjem-humanizer-skill.md). Unlike the statistical
870  // patterns above, single hit on any of these is strong evidence —
871  // the AI tool literally left its fingerprint in the text.
872
873  // Unfilled slot-fill placeholders. Catches the canonical "[Your Name]"
874  // family plus dated stubs and HTML/MD comments with placeholder verbs.
875  const AI_PLACEHOLDERS = [
876    // Directive stubs ("[Your Name]", "[INSERT SOURCE URL]",
877    // "[Describe the specific section]") — verb-led, the user was
878    // told to fill in.
879    /\[(?:Your|Insert|Add|Enter|Describe|Specify|Choose|Pick)[^\]\n]{1,80}\]/gi,
880    // Noun-only template variables common in AI-generated email or
881    // letter boilerplate. Match the bare noun OR noun + qualifier.
882    // Conservative list: only nouns that almost never appear as
883    // bracketed real content (citation refs, code identifiers, etc.
884    // are excluded because they typically contain dots, slashes,
885    // hyphens, or version numbers).
886    /\[(?:Recipient|Sender|Topic|Subject|Salutation|Closing|Position|Department|Project Name|Company Name|Date)(?:\s+[^\]\n]{0,60})?\]/gi,
887    // All-caps directive forms ("[INSERT X]", "[FILL IN]") — the
888    // uppercase tells you it's a slot, not real content.
889    /\[(?:INSERT|FILL\s+IN|ADD|TODO|TBD|PLACEHOLDER)[^\]\n]{0,80}\]/g,
890    // Date stubs.
891    /\b(?:19|20)\d{2}-XX-XX\b/g,
892    /\bXX\/XX\/(?:19|20)\d{2}\b/g,
893    // HTML/Markdown comment placeholders with placeholder verbs.
894    /<!--\s*(?:add|fill\s+in|insert|todo|placeholder)[^>]{0,120}-->/gi,
895  ];
896
897  // Chatbot citation/markup tokens that leak through copy-paste.
898  // `citeturn0search0` / `citeturn0news5` from ChatGPT, contentReference
899  // tokens, oai_citation, attached_file references, grok_card markers.
900  // Each is a near-definitive signature of a specific tool.
901  const AI_CITATION_MARKUP = [
902    /\bcite(?:turn|news|search|navigation)\d+(?:search|turn|news|navigation)\d+/gi,
903    /contentReference\s*\[oaicite:[^\]]+\]\s*\{[^}]*\}/gi,
904    /\boai_citation\b/gi,
905    /\[attached_file:\d+\]/gi,
906    /\bgrok_card\b/gi,
907  ];
908
909  // UTM/tracking parameters auto-appended by AI tools to URLs they
910  // generate. Survives copy-paste even when nothing else does.
911  const AI_UTM_SOURCE = [
912    /[?&]utm_source=(?:chatgpt|openai|copilot|claude|grok|gemini|perplexity)(?:\.com|\.ai)?\b/gi,
913    /[?&]referrer=(?:chatgpt|copilot|grok|claude|gemini|perplexity)\.(?:com|ai)\b/gi,
914  ];
915
916  // ─── Template phrases ──────────────────────────────────────────────
917  const TEMPLATE_PHRASES = [
918    // template-phrase: only vague-praise adjectives. "a first step towards the full API",
919    // "a small step towards cutting our storage bill" stay clean.
920    /\ban?\s+(?:meaningful|significant|major|crucial|important|big|huge|bold|giant|monumental|pivotal|critical|key|vital|massive|tremendous|substantial|decisive|landmark|historic|exciting|transformative)\s+step\s+(?:towards?|forward)\b/gi,
921    /\bwhether\s+you'?re\s+\w+\s+or\s+\w+/gi,
922    /\bi\s+recently\s+had\s+the\s+pleasure\s+of\b/gi,
923  ];
924
925  // ─── False concession ──────────────────────────────────────────────
926  // "While X is impressive, Y remains a challenge" and "Although X has made
927  // strides, Y is still an open question" only read as the AI tell when both
928  // halves are vague: an opener that concedes nothing specific, paired with a
929  // close that names no actual gap. The subject (X) is widened past a single
930  // word — "while the underlying model architecture is impressive" is as
931  // hollow as "while it is impressive" — but stays inside one clause (no
932  // comma or sentence punctuation) so the opener cannot reach across clauses.
933  // The close is required in the same sentence: a bare opener followed by a
934  // concrete, specific continuation ("...at this scale, our write pattern is
935  // append-only, so we moved the hot table to a log-structured store
936  // instead") is ordinary technical writing, not the empty frame. See #211.
937  // "Despite X challenges" is dropped entirely: alone it is too common a
938  // shape in ordinary prose to carry the tell.
939  // The close must also follow a clause separator (comma, semicolon or
940  // colon): without one, "While the model is impressive and remains a
941  // challenge to maintain, we plan to replace it next month" matched both
942  // phrases inside the opening clause and never looked at the concrete main
943  // clause that followed. See #359.
944  // Stop at the next clause separator too: a concrete continuation followed
945  // by a later vague phrase is not the empty two-half frame.
946  const FALSE_CONCESSION_SUBJECT = "[^,;:.!?\\n]{1,60}?";
947  // Known limit: a period inside an abbreviation ("U.S.", "e.g.") ends the
948  // gap the same as a real sentence boundary would, so a close on the far
949  // side of one is deliberately missed to keep that boundary guarantee;
950  // only a comma, semicolon or colon counts as the clause separator #359
951  // requires.
952  const FALSE_CONCESSION_GAP = "[^,;:.!?\\n]{0,80}?[,;:]\\s*[^,;:.!?\\n]{0,80}?";
953  const FALSE_CONCESSION_VAGUE_CLOSE =
954    "(?:remains?\\s+a\\s+challenge" +
955    "|(?:is|are)\\s+still\\s+an?\\s+open\\s+questions?" +
956    "|there\\s+(?:is|are)\\s+still\\s+work\\s+to\\s+do" +
957    "|remains?\\s+unanswered)\\b";
958  const FALSE_CONCESSION = [
959    new RegExp("\\bwhile\\s+" + FALSE_CONCESSION_SUBJECT + "\\s+is\\s+impressive\\b" +
960      FALSE_CONCESSION_GAP + FALSE_CONCESSION_VAGUE_CLOSE, 'gi'),
961    new RegExp("\\balthough\\s+" + FALSE_CONCESSION_SUBJECT + "\\s+has\\s+made\\s+strides\\b" +
962      FALSE_CONCESSION_GAP + FALSE_CONCESSION_VAGUE_CLOSE, 'gi'),
963  ];
964
965  // ─── Rhetorical question openers ───────────────────────────────────
966  const RHETORICAL_QUESTIONS = [
967    /\bbut\s+what\s+does\s+this\s+mean\s+for\b/gi,
968    /\bso\s+why\s+should\s+you\s+care\b/gi,
969    /\bwhat'?s\s+next\?\s*/gi,
970  ];
971
972  // ─── Hedge-stacked predictions ─────────────────────────────────────
973  // Stacks a modal with a hedge adverb: "could potentially create new
974  // opportunities", "may eventually unlock value." Either word alone is
975  // fine; the stack is the tell.
976  const HEDGE_STACK = [
977    // At most one intervening word, and never a negator. The old {0,2} gap
978    // matched ordinary English: "could not possibly" (plain emphatic
979    // negation) and inverted questions like "could a savage possibly" both
980    // fired. Measured on the human-control corpus, 3 of 4 hedge-stack flags
981    // were this over-match. See issue #69.
982    /\b(?:could|may|might)\s+(?:(?!not\b|never\b|hardly\b|scarcely\b|barely\b)\w+\s+)?(?:potentially|eventually|ultimately|possibly|conceivably)\b/gi,
983    /\b(?:potentially|eventually|ultimately)\s+(?:could|may|might)\b/gi,
984  ];
985
986  // ─── Generic future-narrative closers ──────────────────────────────
987  // The "may become one of the most important narratives" template — vague
988  // future significance with no falsifiable claim. Covers narratives /
989  // stories / trends / themes / chapters / movements.
990  const FUTURE_NARRATIVE = [
991    /\b(?:may|could|will|is\s+(?:poised|set)\s+to)\s+become\s+(?:one\s+of\s+)?(?:the\s+)?(?:most\s+)?\w+\s+(?:narratives?|stories|developments?|trends?|movements?|chapters?|themes?|forces?)\b/gi,
992    /\bone\s+of\s+the\s+most\s+important\s+(?:narratives?|stories|trends?|themes?)\s+of\s+the\s+(?:next|coming)\s+\w+\b/gi,
993  ];
994
995  // ─── "Real/actual" adjective inflation ─────────────────────────────
996  // "Real on-chain tokenomics", "actual reward sustainability" — using
997  // real/actual/genuine/true as an empty intensifier on an abstract noun
998  // to imply the rest of the field is fake/superficial.
999  const REAL_ACTUAL_INFLATION = [
1000    /\b(?:real|actual|genuine|true)\s+(?:on-?chain\s+)?(?:tokenomics|economics|utility|adoption|sustainability|impact|revenue|fundamentals|demand|value|innovation|traction)\b/gi,
1001  ];
1002
1003  // ─── Formulaic openers ─────────────────────────────────────────────
1004  // The "In the rapidly evolving world of X, Y has emerged as..." family
1005  // — LLM-default essay openers.
1006  const FORMULAIC_OPENERS = [
1007    /\bin\s+the\s+(?:rapidly\s+|ever-?\s*)?(?:evolving|changing|expanding|growing|shifting)\s+(?:world|landscape|realm|space|field|domain|era)\s+of\b/gi,
1008    /\bin\s+(?:an?|the)\s+(?:digital\s+)?age\s+(?:where|of)\b/gi,
1009    /\bas\s+(?:we|the\s+world|society|industries?)\s+(?:continue|move|navigate|enter)\s+(?:to\s+)?(?:evolve|forward|into|through)\b/gi,
1010    // "has emerged as a leader/force/category" — gated to the inflated
1011    // nouns that signal pseudo-significance, since bare "has emerged as
1012    // a" matches normal English ("Rust has emerged as a serious systems
1013    // language"). Same gating for "has become increasingly".
1014    /\bhas\s+emerged\s+as\s+(?:a|the|one\s+of)\s+(?:leading|key|major|critical|essential|fundamental|pivotal|prominent|dominant|important)\s+\w+/gi,
1015    /\bhas\s+become\s+increasingly\s+(?:important|critical|popular|relevant|prominent|essential)\b/gi,
1016  ];
1017
1018  // ─── Speculative scenario openers ──────────────────────────────────
1019  // "Imagine a world where...", "Picture a future in which...", "Envision
1020  // a world where..." — the LLM habit of opening an argument with a
1021  // hypothetical that lists desirable outcomes instead of making a claim.
1022  // Gated to the world/future/reality object plus where/in-which so it
1023  // stays off instructional "imagine you have an array" (a teaching device
1024  // pointing at a concrete example, not a speculative world) and bare
1025  // "imagine that" asides. "consider a scenario where…" is deliberately
1026  // excluded: that is analytical framing common in technical reasoning,
1027  // not the marketing-opener tell. An optional short comma interrupter
1028  // catches the equally common "Imagine, for a moment, a world where…"
1029  // cadence. Known accepted false positive: fiction openings and staged
1030  // thought experiments match too — the engine has no fiction context
1031  // mode, so that call is left to the skill's carve-out (highlight-only;
1032  // a lone hit cannot flip a document's classification).
1033  const SPECULATIVE_OPENERS = [
1034    /\b(?:imagine|picture|envision)(?:\s*,[^,\n]{1,30},)?\s+a\s+(?:world|future|reality)\s+(?:where|in\s+which)\b/gi,
1035  ];
1036
1037  // ─── Launch-copy dramatic introductions ────────────────────────────
1038  // "Meet Flowdesk, your new favorite treasury dashboard" / "Think
1039  // Notion meets Figma" — the LLM-default product-introduction move
1040  // in launch and announcement copy. Both surfaces are gated to the
1041  // sentence-initial imperative followed by ONE capitalized token of 2
1042  // to 30 characters, which is a recall limit: a two-token product name
1043  // ("Meet North Star", "Think Google Docs meets Microsoft Word") is a
1044  // deliberate miss. The Meet surface additionally requires one of four
1045  // launch-copy heads — "your new favorite", "your new go-to", and
1046  // "the new home/way/standard", the last three only when followed by
1047  // "of" / "to" / "in|for" or by end-of-clause punctuation. Without
1048  // that tail the head noun swallows a compound noun and ordinary prose
1049  // fires: "Meet Rosa, the new home secretary" and "Meet Emma, the new
1050  // way station manager" both matched before the tail was required.
1051  // Bare "Meet Sarah, your new account manager" is how humans introduce
1052  // colleagues, pets, and babies, so that form stays with the skill's
1053  // judgment side. Two surfaces from
1054  // the same family are deliberately NOT detected. "Say hello to X",
1055  // because "Say hello to Grandma." is ordinary human prose. And bare
1056  // "Enter X.", because the sentence-initial capitalized-noun form is
1057  // how UI and doc instructions are written: "Enter Password.", "Enter
1058  // Amount.", "Enter Username — your work email." Dropping the dash
1059  // terminator does not reach the period-terminated class, and neither
1060  // does a field-name denylist, so that surface stays with the skill's
1061  // judgment side and the UI forms are pinned as must-not-fire
1062  // fixtures. The anchors are lookbehinds so adjacent intros each
1063  // count and the reported span starts at the tell itself.
1064  const LAUNCH_INTROS = [
1065    /(?<=^|[.!?]\s|\n)Meet\s+[A-Z][\w'-]{1,29}\s*,\s*(?:your\s+new\s+(?:favorite|go-to)\b|the\s+new\s+(?:home\s+of\b|way\s+to\b|standard\s+(?:in|for)\b|(?:standard|way|home)(?=\s*(?:[.!?,;:\u2013\u2014]|$))))/g,
1066    /(?<=^|[.!?]\s|\n)[Tt]hink\s+[A-Z][\w'-]{1,29}\s+meets\s+[A-Z][\w'-]{1,29}\b/g,
1067  ];
1068
1069  // ─── Dramatized contrast against the crowd ─────────────────────────
1070  // "shipped it in 2022, while everyone else was still debating
1071  // timelines" — a claim propped on an implied lagging crowd. The gate
1072  // is a dismissive verb PLUS the "was still" dramatization marker,
1073  // because bare "while everyone else" is ordinary simultaneity ("she
1074  // read while everyone else watched the movie") and even the
1075  // dismissive verbs are ordinary English in literal use ("others
1076  // debated the amendment" in wire copy). That gate is on this FIRST
1077  // branch only. Its stems are restricted to the -ing form, so the
1078  // adjective ("was still deliberate about the tradeoff"), the passive
1079  // ("was still debated by pundits") and the bare present ("was still
1080  // debates timelines") all stay clean — allowing e/es/ed let all
1081  // three through. The other two branches carry no "was still"
1082  // requirement: they match their own stereotyped wording ("writing
1083  // think-pieces", "playing catch-up"), and the skill entry scopes the
1084  // claim the same way. Verb stems carry explicit inflection tails so
1085  // agent nouns ("the market speculators") and adverbs ("deliberately
1086  // ignored") never match. Measured residue, all accepted: branch one
1087  // fires on ANY literal progressive use of its verbs ("while the
1088  // market was still speculating about the price"), not only on "was
1089  // still debating"; branches two and three fire on literal contrasts
1090  // of their own ("while everyone else wrote think-pieces from
1091  // Washington", "while everyone else played catch-up in the spring").
1092  // Recall is deliberately sacrificed: "was busy debating" without
1093  // "still" stays a miss, per precision-over-recall.
1094  const CROWD_CONTRAST = [
1095    /\bwhile\s+(?:everyone\s+else|the\s+(?:industry|market|competition)|others)\s+(?:was|were|is|are)\s+still\s+(?:busy\s+)?(?:(?:debat|deliberat|hesitat|theoriz|philosophiz|pontificat|speculat|argu)ing|(?:dither|bicker)ing)\b/gi,
1096    /\bwhile\s+(?:everyone\s+else|the\s+(?:industry|market|competition)|others)\s+(?:was\s+|were\s+)?(?:busy\s+)?(?:writing|wrote)\s+think-?\s?pieces\b/gi,
1097    /\bwhile\s+(?:everyone\s+else|the\s+(?:industry|market|competition)|others)\s+(?:was\s+|were\s+|is\s+|are\s+)?(?:still\s+)?play(?:ed|ing|s)?\s+catch[-\s]?up\b/gi,
1098  ];
1099
1100  // ─── Fake-casual props (stage directions and wink asides) ──────────
1101  // The regexable props from the fake-casual register: theatrical
1102  // asterisk stage directions ("*checks notes*", "*chef's kiss*",
1103  // "*mic drop*") and wink asides. Both lists are closed and short, and
1104  // that is a recall limit: exactly six stage directions ("checks
1105  // notes", "chef's kiss", "mic drop", "takes a deep breath", "sips
1106  // coffee|tea", "nervous laughter") and exactly four parentheticals,
1107  // the full (yes|no) x (really|seriously) grid. Neighbours in the same
1108  // register are deliberate misses: "*checks calendar*" and "(yes,
1109  // honestly)" do not fire. The kiss pattern requires the apostrophe —
1110  // making it optional matched the ordinary sentence "At midnight,
1111  // *chefs kiss* their spouses goodbye".
1112  // The rest of the register (one-word verdict closers, label-prefix
1113  // openers, the self-QA volley) needs register judgment and stays
1114  // skill-only — "wild." is a word, not a regex target. "because of
1115  // course …" joins them: a tense gate does not separate the wink from
1116  // the ordinary human grumble, because "The build failed because of
1117  // course it did." is that grumble in the same present-tense-plus-did
1118  // form the wink uses. Under precision-over-recall the surface is
1119  // judgment-only, and the grumble is pinned as a fixture. The kiss
1120  // pattern accepts the curly apostrophe (U+2019) — the form smart
1121  // punctuation and LLMs actually emit. Known accepted false positive:
1122  // a human writer using a wink aside on purpose; the props are
1123  // weighted as a strong single hit, not a classification by
1124  // themselves.
1125  const FAKE_CASUAL_PROPS = [
1126    /\*\s?(?:checks\s+notes|chef['\u2019]s\s+kiss|mic\s+drop|takes\s+a\s+deep\s+breath|sips\s+(?:coffee|tea)|nervous\s+laughter)\s?\*/gi,
1127    /\(\s?(?:yes|no)\s?,\s?(?:really|seriously)\s?\)/gi,
1128  ];
1129
1130  // ─── Performed-insight phrases ─────────────────────────────────────
1131  // Essayist tics that announce profundity instead of delivering it.
1132  // Curated noun/complement lists keep precision high: "the whole family"
1133  // and "sit with him" are ordinary English and must not fire. Adapted
1134  // from Simon Willison's LLM cliché highlighter
1135  // (tools.simonwillison.net/llm-cliche-highlighter).
1136  const PERFORMED_INSIGHT = [
1137    /\bsit(?:s|ting)?\s+with\s+(?:that|this)(?=\s*(?:[.!?,;:)\u2013\u2014\u2019"']|for\s+a\s+(?:moment|minute|second|beat)\b|$))(?:\s+for\s+a\s+(?:moment|minute|second|beat))?/gi,
1138    /\bsit(?:s|ting)?\s+with\s+(?:the|your)\s+(?:discomfort|tension|uncertainty|ambiguity|grief|unease)\b/gi,
1139    /\b(?:that|this|it|which)(?:['\u2019]s|\s+(?:is|was))\s+not\s+nothing\b/gi,
1140    /\byou\s+already\s+know\s+the\s+answer\b/gi,
1141    /\b(?:do\s+not|don['\u2019]t)\s+(?:have\s+to\s+)?take\s+my\s+word\s+for\s+it\b/gi,
1142    /(?<=^|[.!?]\s|\n)Turns\s+out\b/g,
1143    /(?:['\u2019]s|\b(?:is|was|are|were))\s+the\s+(?:whole|entire)\s+(?:point|game|ballgame|trick|pitch|idea|play|business\s+model|value\s+proposition)\b/gi,
1144    /\b(?:that|this)(?:['\u2019]s|\s+(?:is|was))\s+the\s+part\s+(?:that|I|you|we|nobody|no\s+one|most\s+people)\b/gi,
1145    /\bthe\s+only\s+[\w'\u2019-]+\s+that\s+(?:matters|counts)\b/gi,
1146    // "X is dead; long live Y" also names an essay or a literal succession
1147    // announcement. Whether the contrast earns its place needs reading (#351).
1148    /\b(?:that|this)(?:['\u2019]s|\s+(?:is|was))\s+why\s+[^.!?\n]{0,60}\s+mattered\b/gi,
1149  ];
1150
1151  const STAGED_DISCOVERY = [
1152    // Staged discovery: a judgment framed as a twist the writer found ("the recording
1153    // turned out to be the least interesting part"). Superlative + insight noun keeps
1154    // ordinary "turned out to be the most expensive option" clean.
1155    /\b(?:turned|turns|turning)\s+out\s+to\s+be\s+the\s+(?:least|most)\s+(?:interesting|important|surprising|revealing|valuable|useful)\s+(?:part|thing|piece|bit)\b/gi,
1156    // Require a reveal-style continuation; "the real story was covered by..."
1157    // describes a literal story and is not a staged discovery.
1158    /\bthe\s+real\s+story\s+(?:here\s+)?(?:is|was)\b(?=\s+(?:the|that|how|why|what)\b)/gi,
1159  ];
1160
1161  // ─── Negation chains ───────────────────────────────────────────────
1162  // "No fluff, no filler, no jargon" / "It didn't ask, didn't wait" /
1163  // "Don't call it X. Call it Y." Precision guards, in order: the
1164  // "no …" chain must open its sentence (mid-sentence inventories like
1165  // "takes no arguments, no headers, and no body" are factual, not
1166  // rhetorical); the "did not" chain must be comma-joined with the
1167  // subject elided ("I did not sleep. I did not eat" is ordinary
1168  // narration and stays clean); the stop-list keeps idiomatic pairs
1169  // ("no more, no less", "no matter what") from firing. Adapted from
1170  // Simon Willison's LLM cliché highlighter.
1171  const NO_ITEM_STOP = "(?!matter\\b|one\\b|doubt\\b|longer\\b|way\\b|less\\b|more\\b|such\\b|other\\b|means\\b)";
1172  const NO_ITEM_SECOND_STOP = "(?!(?:in|on|at|of|to|for|with|from|by|is|are|was|were|be|been|being|will|would|can|could|should|shall|may|might|must|have|has|had|do|does|did)\\b)";
1173  const NEGATION_CHAIN = [
1174    new RegExp(
1175      "(?<=^|[.!?]\\s|\\n|[:\\u2013\\u2014]\\s)No\\s+" + NO_ITEM_STOP + "[a-z'\u2019-]+(?:\\s+" + NO_ITEM_SECOND_STOP + "[a-z'\u2019-]+)?" +
1176      "(?:\\s*,\\s*(?:and\\s+|or\\s+|just\\s+)?no\\s+" + NO_ITEM_STOP + "[a-z'\u2019-]+(?:\\s+" + NO_ITEM_SECOND_STOP + "[a-z'\u2019-]+)?){2,}",
1177      'gm'
1178    ),
1179    /\b(?:did\s+not|didn['\u2019]t)\s+[a-z]+[^,.;!?\n]{0,20},\s*(?:did\s+not|didn['\u2019]t)\s+[a-z]+/gi,
1180    /\b(?:do\s+not|don['\u2019]t)\s+(?:just\s+)?(\w+)\s+it\b[^.!?\n]{0,60}[.!?;:,][\s'"\u201d\u2019]*(?:just\s+)?\1\s+it\b/gi,
1181  ];
1182
1183  // ─── Negative parallelism ──────────────────────────────────────────
1184  // "It's not just a search index, it's a foundation for trust." A frame is
1185  // a negated copula, a body X, then a restatement: "it / this / that /
1186  // they" + be. The engine splits frames in two (#351):
1187  //
1188  //   reveal    a minimizer (just / merely / simply), then a comma,
1189  //             semicolon, colon, or dash and the restatement ("isn't just
1190  //             raining, it's pouring"). The minimizer-then-upgrade move is
1191  //             the tell itself, so a reveal flags on its own.
1192  //   contrast  the same joined frame without the minimizer ("isn't X, it's
1193  //             Y", "isn't about X, it's about Y", "are not only X, they're
1194  //             Y") and the split-sentence reveal ("isn't just X. It's Y.").
1195  //             A single plain correction ("It isn't raining, it's
1196  //             snowing.") is ordinary English, and references/patterns.md
1197  //             allows one frame per piece, so a contrast flags only when
1198  //             another frame of either kind starts within
1199  //             NP_WINDOW_SENTENCES sentences of it. The stacked cadence is
1200  //             the tell; two unrelated corrections paragraphs apart are
1201  //             ordinary prose. "only" is not a reveal minimizer: the human
1202  //             control corpus holds "fossil fuels are not only bad for our
1203  //             environment, they're a losing bet".
1204  //
1205  // The restated pronoun is the gate. "not only X but (also) Y" and "not X
1206  // but Y" are ordinary correlatives and are not matched: on the human
1207  // control corpus "not only ... but" appeared 16 times in 143k human words
1208  // against 5 in 115k machine words. X is capped at 80 characters with no
1209  // comma or sentence punctuation, so a frame cannot reach across clauses.
1210  const NP_NEG = "(?:\\b(?:is|are|was|were)(?:n['\\u2019]t|\\s+not)|\\b(?:it|this|that|they|he|she|we|you)['\\u2019](?:s|re)\\s+not)";
1211  const NP_MINIMIZER = "(?:just|merely|simply)";
1212  const NP_BODY = "[^,;:.!?\\n\\u2014\\u2013]{1,80}?";
1213  const NP_JOIN = "(?:\\s*[,;:]|\\s*[\\u2014\\u2013]|\\s+--)\\s*";
1214  const NP_RESTATE = "(?:it|this|that|they)(?:['\\u2019](?:s|re)|\\s+(?:is|are|was|were))\\b";
1215  const NEGATIVE_PARALLELISM_REVEAL = [
1216    new RegExp(NP_NEG + "\\s+" + NP_MINIMIZER + "\\s+" + NP_BODY + NP_JOIN + NP_RESTATE, 'gi'),
1217  ];
1218  const NEGATIVE_PARALLELISM_CONTRAST = [
1219    new RegExp(NP_NEG + "\\s+(?!" + NP_MINIMIZER + "\\b)" + NP_BODY + NP_JOIN + NP_RESTATE, 'gi'),
1220    // Split-sentence reveal: the restatement opens the next sentence.
1221    new RegExp(NP_NEG + "\\s+" + NP_MINIMIZER + "\\s+" + NP_BODY + "[.!]\\s+" + NP_RESTATE, 'gi'),
1222  ];
1223  // Two frames pair when their starting sentences are at most this many
1224  // sentences apart: the same sentence, the next, or the one after.
1225  const NP_WINDOW_SENTENCES = 2;
1226  // A blank line in LF, CRLF, or CR-only text.
1227  const NP_PARAGRAPH_BREAK = /(?:\r\n|\r(?!\n)|\n)[ \t]*(?:\r\n|\r|\n)/;
1228
1229  // Reveals always flag. A contrast flags only when some other frame, reveal
1230  // or contrast, starts nearby. Sentence indexes come from the same coarse
1231  // splitter the highlight regions use.
1232  function negativeParallelismIssues(text, reveals, contrasts) {
1233    // Apply the proximity gate to the same distinct frames the caller reports.
1234    const distinctReveals = deduplicateIssues(reveals);
1235    const distinctContrasts = deduplicateIssues(contrasts);
1236    if (distinctContrasts.length === 0 || distinctReveals.length + distinctContrasts.length < 2) return distinctReveals;
1237    const frames = [...distinctReveals, ...distinctContrasts];
1238    const starts = splitSentenceSpans(text).map(([start]) => start);
1239    const sentenceOf = (index) => {
1240      let lo = 0;
1241      let hi = starts.length - 1;
1242      while (lo < hi) {
1243        const mid = (lo + hi + 1) >> 1;
1244        if (starts[mid] <= index) lo = mid;
1245        else hi = mid - 1;
1246      }
1247      return lo;
1248    };
1249    const sentences = frames.map((frame) => sentenceOf(frame.index));
1250    // Paired frames must also share a paragraph: no blank line between them.
1251    const sameParagraph = (a, b) => !NP_PARAGRAPH_BREAK.test(text.slice(Math.min(a, b), Math.max(a, b)));
1252    const paired = distinctContrasts.filter((contrast, c) => {
1253      const i = distinctReveals.length + c;
1254      return sentences.some((other, j) =>
1255        j !== i
1256        && frames[j].index !== contrast.index
1257        && Math.abs(other - sentences[i]) <= NP_WINDOW_SENTENCES
1258        && sameParagraph(frames[j].index, contrast.index));
1259    });
1260    return [...distinctReveals, ...paired].sort((a, b) => a.index - b.index);
1261  }
1262
1263  // ─── Dev-blog boilerplate ──────────────────────────────────────────
1264  // Stock simplicity slogans from developer marketing. Adapted from
1265  // Simon Willison's LLM cliché highlighter.
1266  const DEV_BLOG_BOILERPLATE = [
1267    /\bit\s+just\s+works\b(?!\s+out\b(?![-\s]+of[-\s]+the[-\s]+box\b))/gi,
1268    /\bzero[-\s]config(?:uration)?\b/gi,
1269    /\bsane\s+defaults\b/gi,
1270    /\b(?:hold|fit|fits|holds)\s+in\s+your\s+head\b/gi,
1271  ];
1272
1273  // Function words whose presence MID-title marks the AI section-header shape.
1274  // Word-anchored: without \b the "A" alternative matches inside any word and
1275  // the guard silently degrades to "four tokens".
1276  const FUNCTION_WORD = /\b(?:And|Or|Of|The|In|For|To|A|An)\b/;
1277
1278  // Must accept exactly what TITLE_CASE_HEADER accepts, or the prefix survives
1279  // into the token count and reintroduces the ##-as-token bug.
1280  const MD_HEADING_PREFIX = /^#{1,6}[ \t]+/;
1281
1282  /** Byte ranges covered by fenced code blocks, computed once per scan.
1283   *
1284   * A document that documents Markdown is the normal case for this rule -- a
1285   * fenced `## Heading` example is illustration, not the author's own section
1286   * header, and flagging it makes every docs page flag itself.
1287   *
1288   * This tracks the opening delimiter instead of counting them, because a
1289   * parity count is wrong on the very case the rule exists for. CommonMark
1290   * closes a fence only on the same character at the same length or longer, so
1291   * a four-backtick fence wrapping a three-backtick example -- exactly how you
1292   * document fences -- nests in practice, and counting delimiters inverts on
1293   * it. Up to three spaces of indent are legal. An unclosed fence runs to end
1294   * of document, matching how renderers treat it.
1295   *
1296   * Computed once per scan rather than rescanned per hit: the previous version
1297   * sliced the whole document for every candidate, which is quadratic on a
1298   * heading-dense file. */
1299  function fenceRanges(text) {
1300    const re = /^[ \t]{0,3}(`{3,}|~{3,})([^\n]*)$/gm;
1301    const ranges = [];
1302    let open = null;
1303    let m;
1304    while ((m = re.exec(text)) !== null) {
1305      const marker = m[1];
1306      if (!open) {
1307        open = { char: marker[0], len: marker.length, start: m.index };
1308      } else if (
1309        marker[0] === open.char &&
1310        marker.length >= open.len &&
1311        /^[ \t]*\r?$/.test(m[2])
1312      ) {
1313        ranges.push([open.start, m.index + m[0].length]);
1314        open = null;
1315      }
1316    }
1317    if (open) ranges.push([open.start, text.length]);
1318
1319    return ranges;
1320  }
1321
1322  function inFenceRange(ranges, index) {
1323    return typeof index === 'number' && ranges.some(([a, b]) => index >= a && index < b);
1324  }
1325
1326  function blankRange(chars, start, end) {
1327    for (let i = start; i < end && i < chars.length; i += 1) {
1328      if (chars[i] !== '\n') chars[i] = ' ';
1329    }
1330  }
1331
1332  function inlineCodeRanges(text) {
1333    const runs = [];
1334    for (let i = 0; i < text.length;) {
1335      if (text[i] === '\n') {
1336        runs.push(null);
1337        i += 1;
1338        continue;
1339      }
1340      if (text[i] !== '`') {
1341        i += 1;
1342        continue;
1343      }
1344      const start = i;
1345      while (i < text.length && text[i] === '`') i += 1;
1346      runs.push({ start, end: i, length: i - start });
1347    }
1348
1349    const ranges = [];
1350    let lineStart = 0;
1351    while (lineStart < runs.length) {
1352      let lineEnd = runs.indexOf(null, lineStart);
1353      if (lineEnd === -1) lineEnd = runs.length;
1354      const nextByLength = new Map();
1355      const nextSame = new Array(lineEnd - lineStart);
1356      for (let i = lineEnd - 1; i >= lineStart; i -= 1) {
1357        nextSame[i - lineStart] = nextByLength.get(runs[i].length);
1358        nextByLength.set(runs[i].length, i);
1359      }
1360      for (let i = lineStart; i < lineEnd;) {
1361        const close = nextSame[i - lineStart];
1362        if (close === undefined) {
1363          i += 1;
1364          continue;
1365        }
1366        ranges.push([runs[i].start, runs[close].end]);
1367        i = close + 1;
1368      }
1369      lineStart = lineEnd + 1;
1370    }
1371    return ranges;
1372  }
1373
1374  // Copy of the text with fenced blocks and inline code spans blanked out.
1375  // Index-preserving: each masked character becomes a space and newlines are
1376  // kept, so offsets into the result still address the same position in the
1377  // original. For rules where a character inside code is something the author
1378  // is quoting rather than using — a `#fff` in a CSS sample is not a tag.
1379  // Fences are blanked first so their backticks cannot pair with a later
1380  // inline span and swallow the prose between them.
1381  function maskCode(text) {
1382    const chars = text.split('');
1383    for (const [a, b] of fenceRanges(text)) blankRange(chars, a, b);
1384    // Indented code blocks are deliberately NOT masked. Four spaces is a code
1385    // block only at top level; under a list marker it is a paragraph
1386    // continuation, so blanking it silences real tag blocks. #90 reports
1387    // fences and inline spans, and those are what this masks.
1388    const withoutFences = chars.join('');
1389    for (const [start, end] of inlineCodeRanges(withoutFences)) blankRange(chars, start, end);
1390    return chars.join('');
1391  }
1392
1393  function initialFrontmatterRange(text) {
1394    const lines = [];
1395    const lineRe = /[^\r\n]*(?:\r\n|\n|\r|$)/g;
1396    let match;
1397    while ((match = lineRe.exec(text)) !== null && match[0]) {
1398      const body = match[0].replace(/(?:\r\n|\n|\r)$/, '');
1399      lines.push({ body, start: match.index, end: match.index + body.length });
1400    }
1401
1402    if (lines.length < 3 || !/^---[ \t]*$/.test(lines[0].body.replace(/^\uFEFF/, ''))) return null;
1403
1404    let closingLine = -1;
1405    for (let i = 1; i < lines.length; i += 1) {
1406      if (/^---[ \t]*$/.test(lines[i].body)) {
1407        closingLine = i;
1408        break;
1409      }
1410    }
1411    if (closingLine === -1) return null;
1412
1413    // A pair of thematic breaks can also surround ordinary Markdown prose.
1414    // Require the first substantive line to begin like a YAML mapping entry
1415    // before treating the delimited block as frontmatter. Leading blank lines
1416    // and YAML comments are valid, and the line parser accepts LF, CRLF, or CR.
1417    const yamlKey = /^[ \t]*(?:[A-Za-z0-9_.-]+|"[^"\r\n]+"|'[^'\r\n]+')[ \t]*:/;
1418    const firstContent = lines
1419      .slice(1, closingLine)
1420      .find((line) => line.body.trim() && !/^[ \t]*#/.test(line.body));
1421    if (!firstContent || !yamlKey.test(firstContent.body)) return null;
1422
1423    return { start: 0, end: lines[closingLine].end };
1424  }
1425
1426  // Mask HTML comments in source order while tracking the Markdown constructs
1427  // that protect a literal `<!--`. A comment wins over code delimiters that
1428  // occur inside it; a fence, code span, or top-level indented block that
1429  // starts first wins over comment-looking text inside that code. Each source
1430  // character participates in a bounded number of forward scans.
1431  function maskHtmlCommentsOutsideCode(chars) {
1432    const source = chars.join('');
1433    const lines = source.split('\n');
1434    let offset = 0;
1435    let openFence = null;
1436    let inIndentedBlock = false;
1437    let previousBlank = true;
1438    let listContext = false;
1439    let maskedHtmlComments = 0;
1440    const commentClosings = [];
1441    let closingCursor = 0;
1442
1443    for (let i = 0; i <= source.length - 3; i += 1) {
1444      if (source[i] === '-' && source[i + 1] === '-' && source[i + 2] === '>') {
1445        commentClosings.push(i);
1446      }
1447    }
1448
1449    const backtickRuns = (line) => {
1450      const runs = [];
1451      for (let i = 0; i < line.length;) {
1452        if (line[i] !== '`') {
1453          i += 1;
1454          continue;
1455        }
1456        const start = i;
1457        while (i < line.length && line[i] === '`') i += 1;
1458        runs.push({ start, end: i, length: i - start, next: -1 });
1459      }
1460      const nextByLength = new Map();
1461      for (let i = runs.length - 1; i >= 0; i -= 1) {
1462        runs[i].next = nextByLength.get(runs[i].length) ?? -1;
1463        nextByLength.set(runs[i].length, i);
1464      }
1465      return runs;
1466    };
1467
1468    for (const originalLine of lines) {
1469      const lineEnd = offset + originalLine.length;
1470      let visibleLine = chars.slice(offset, lineEnd).join('');
1471      const fenceMatch = /^[ \t]{0,3}(`{3,}|~{3,})([^\n]*)$/.exec(visibleLine);
1472      let fencedLine = false;
1473
1474      if (openFence) {
1475        fencedLine = true;
1476        if (
1477          fenceMatch
1478          && fenceMatch[1][0] === openFence.char
1479          && fenceMatch[1].length >= openFence.length
1480          && /^[ \t]*\r?$/.test(fenceMatch[2])
1481        ) openFence = null;
1482      } else if (fenceMatch) {
1483        fencedLine = true;
1484        openFence = { char: fenceMatch[1][0], length: fenceMatch[1].length };
1485      }
1486
1487      const indented = /^(?: {4}|\t)\S/.test(visibleLine);
1488      const indentedCode = !fencedLine
1489        && indented
1490        && (inIndentedBlock || (previousBlank && !listContext));
1491
1492      if (!fencedLine && !indentedCode) {
1493        const runs = backtickRuns(visibleLine);
1494        let runIndex = 0;
1495        let cursor = 0;
1496
1497        while (cursor < visibleLine.length) {
1498          while (runIndex < runs.length && runs[runIndex].start < cursor) runIndex += 1;
1499          const commentIndex = visibleLine.indexOf('<!--', cursor);
1500          const run = runs[runIndex];
1501
1502          if (run && (commentIndex === -1 || run.start < commentIndex)) {
1503            if (run.next !== -1) {
1504              cursor = runs[run.next].end;
1505              runIndex = run.next + 1;
1506            } else {
1507              cursor = run.end;
1508              runIndex += 1;
1509            }
1510            continue;
1511          }
1512          if (commentIndex === -1) break;
1513
1514          const openingIndex = offset + commentIndex;
1515          while (
1516            closingCursor < commentClosings.length
1517            && commentClosings[closingCursor] < openingIndex + 2
1518          ) closingCursor += 1;
1519          const closingIndex = commentClosings[closingCursor] ?? -1;
1520          const end = closingIndex === -1 ? source.length : closingIndex + 3;
1521          if (closingIndex !== -1) closingCursor += 1;
1522          blankRange(chars, openingIndex, end);
1523          maskedHtmlComments += 1;
1524          cursor = Math.min(visibleLine.length, end - offset);
1525        }
1526      }
1527
1528      visibleLine = chars.slice(offset, lineEnd).join('');
1529      const layoutChars = visibleLine.split('');
1530      if (fencedLine) {
1531        blankRange(layoutChars, 0, layoutChars.length);
1532      } else {
1533        const inlineRe = /(`+)(?:(?!\1)[^\n])+\1/g;
1534        let inlineMatch;
1535        while ((inlineMatch = inlineRe.exec(visibleLine)) !== null) {
1536          blankRange(layoutChars, inlineMatch.index, inlineMatch.index + inlineMatch[0].length);
1537        }
1538      }
1539      const layoutLine = layoutChars.join('');
1540      const blank = layoutLine.trim() === '';
1541
1542      if (indentedCode) inIndentedBlock = true;
1543      else if (!blank) inIndentedBlock = false;
1544
1545      if (!blank && !indentedCode && !fencedLine) {
1546        if (/^ {0,3}(?:[-*+]|\d{1,9}[.)])(?:\s|$)/.test(layoutLine)) listContext = true;
1547        else if (/^\S/.test(layoutLine)) listContext = false;
1548      }
1549      previousBlank = blank;
1550      offset = lineEnd + 1;
1551    }
1552
1553    return maskedHtmlComments;
1554  }
1555
1556  // Mask source-only Markdown spans while preserving source offsets. The
1557  // detector can then score what a reader sees without making later issue
1558  // indexes or sentence highlights point at the wrong source location.
1559  function maskRenderedMarkdown(text) {
1560    const chars = text.split('');
1561
1562    let maskedFrontmatter = 0;
1563    const frontmatter = initialFrontmatterRange(text);
1564    if (frontmatter) {
1565      blankRange(chars, frontmatter.start, frontmatter.end);
1566      maskedFrontmatter = 1;
1567    }
1568
1569    const maskedHtmlComments = maskHtmlCommentsOutsideCode(chars);
1570
1571    return { text: chars.join(''), maskedFrontmatter, maskedHtmlComments };
1572  }
1573
1574  // Ignore regions (#351): an author can exclude a passage from scoring, such
1575  // as a specimen of AI prose quoted on purpose, by wrapping it in
1576  //   <!-- avoid-ai-writing:ignore-start --> … <!-- avoid-ai-writing:ignore-end -->
1577  // A marker counts only as a whole line: the full comment, at most three
1578  // spaces of indent, nothing else on the line. Starts nest: each start needs
1579  // its own end, and the region runs from the outermost start to its matching
1580  // end. An unclosed start runs to the end of the text; an end with no open
1581  // start is ignored. The region is blanked in place, so offsets still
1582  // address the source.
1583  //
1584  // Markers are found by ONE left-to-right scan rather than a stack of masks,
1585  // because separate masks disagree about who owns overlapping text: a fence
1586  // inside a comment would swallow the comment's `-->`, and a `<pre>` inside
1587  // a comment would open a container. After skipping initial YAML
1588  // frontmatter, the scan recognizes, in order of appearance, an HTML
1589  // comment, a Markdown fence, a top-level indented code line, an inline code
1590  // span, and an HTML <pre>, <code>, <script>, or <style> element. Whichever
1591  // construct opens first owns the text until its own close, so a marker, a
1592  // fence, a tag, or a comment inside another construct is inert. Anything
1593  // unclosed runs to the end of the text: when in doubt, the marker does
1594  // nothing and the prose stays scored. Every character is visited a bounded
1595  // number of times.
1596  const IGNORE_MARKER_LINE_RE = /^ {0,3}<!--[ \t]*avoid-ai-writing:ignore-(start|end)[ \t]*-->[ \t]*$/i;
1597  const MARKER_FENCE_RE = /^ {0,3}(`{3,}|~{3,})(.*)$/;
1598  const HTML_CODE_OPEN_RE = /<(pre|code|script|style)\b[^>]*>/iy;
1599  const HTML_CODE_CLOSE_RE = {
1600    pre: /<\/pre/gi,
1601    code: /<\/code/gi,
1602    script: /<\/script/gi,
1603    style: /<\/style/gi,
1604  };
1605
1606  function findIgnoreMarkers(text) {
1607    const n = text.length;
1608    const markers = [];
1609    const lineEndAt = (from) => {
1610      let i = from;
1611      while (i < n && text[i] !== '\n' && text[i] !== '\r') i += 1;
1612      return i;
1613    };
1614    const nextLineAt = (end) => (text[end] === '\r' && text[end + 1] === '\n' ? end + 2 : end + 1);
1615    const isLineStart = (i) => i === 0 || text[i - 1] === '\n' || (text[i - 1] === '\r' && text[i] !== '\n');
1616
1617    // Backtick runs in [from, to), keyed by start, each with the end of the
1618    // next run of the same length on the line (-1 when unmatched). Built at
1619    // most once per line segment and never rebuilt after a comment or HTML
1620    // element closes mid-line: rebuilding made a long line that alternates
1621    // code spans and <code> elements quadratic. Runs inside a construct the
1622    // scan jumps over are simply never visited.
1623    const backtickRuns = (from, to) => {
1624      const list = [];
1625      for (let i = from; i < to;) {
1626        if (text[i] !== '`') { i += 1; continue; }
1627        const start = i;
1628        while (i < to && text[i] === '`') i += 1;
1629        list.push({ start, end: i, length: i - start, closeEnd: -1 });
1630      }
1631      const nextByLength = new Map();
1632      for (let i = list.length - 1; i >= 0; i -= 1) {
1633        const next = nextByLength.get(list[i].length);
1634        if (next) list[i].closeEnd = next.end;
1635        nextByLength.set(list[i].length, list[i]);
1636      }
1637      return new Map(list.map((run) => [run.start, run]));
1638    };
1639
1640    let pos = 0;
1641    const frontmatter = initialFrontmatterRange(text);
1642    if (frontmatter) pos = frontmatter.end;
1643
1644    let lineEnd = -1;
1645    let runs = null;
1646    let prevBlank = true;
1647    let inIndented = false;
1648    let listContext = false;
1649
1650    while (pos < n) {
1651      if (pos > lineEnd) {
1652        // Entering a new line, or resuming mid-line after a construct that
1653        // spanned lines. Only a true line start gets the line-level checks.
1654        lineEnd = lineEndAt(pos);
1655        runs = null;
1656        if (isLineStart(pos)) {
1657          const line = text.slice(pos, lineEnd);
1658          const blank = line.trim() === '';
1659          const fence = MARKER_FENCE_RE.exec(line);
1660          if (fence && !(fence[1][0] === '`' && fence[2].includes('`'))) {
1661            let close = n;
1662            for (let scan = nextLineAt(lineEnd); scan < n;) {
1663              const end = lineEndAt(scan);
1664              const closing = MARKER_FENCE_RE.exec(text.slice(scan, end));
1665              if (
1666                closing
1667                && closing[1][0] === fence[1][0]
1668                && closing[1].length >= fence[1].length
1669                && closing[2].trim() === ''
1670              ) {
1671                close = end;
1672                break;
1673              }
1674              scan = nextLineAt(end);
1675            }
1676            pos = close;
1677            prevBlank = false;
1678            inIndented = false;
1679            continue;
1680          }
1681          const indented = !blank && /^(?: {4}|\t)/.test(line);
1682          if (indented && (inIndented || (prevBlank && !listContext))) {
1683            inIndented = true;
1684            prevBlank = false;
1685            pos = lineEnd;
1686            continue;
1687          }
1688          if (!blank) {
1689            inIndented = false;
1690            if (/^ {0,3}(?:[-*+]|\d{1,9}[.)])(?:\s|$)/.test(line)) listContext = true;
1691            else if (/^\S/.test(line)) listContext = false;
1692          }
1693          prevBlank = blank;
1694          const marker = IGNORE_MARKER_LINE_RE.exec(line);
1695          if (marker) {
1696            markers.push({ kind: marker[1].toLowerCase(), start: pos, end: lineEnd });
1697            pos = lineEnd;
1698            continue;
1699          }
1700        }
1701      }
1702
1703      const ch = text[pos];
1704      if (ch === '<') {
1705        if (text.startsWith('<!--', pos)) {
1706          const close = text.indexOf('-->', pos + 4);
1707          pos = close === -1 ? n : close + 3;
1708          continue;
1709        }
1710        HTML_CODE_OPEN_RE.lastIndex = pos;
1711        const open = HTML_CODE_OPEN_RE.exec(text);
1712        if (open) {
1713          const closeRe = HTML_CODE_CLOSE_RE[open[1].toLowerCase()];
1714          closeRe.lastIndex = pos + open[0].length;
1715          const close = closeRe.exec(text);
1716          pos = close === null ? n : close.index;
1717          continue;
1718        }
1719      } else if (ch === '`') {
1720        if (!runs) runs = backtickRuns(pos, lineEnd);
1721        const run = runs.get(pos);
1722        if (run && run.closeEnd !== -1) {
1723          pos = run.closeEnd;
1724          continue;
1725        }
1726        pos += run ? run.length : 1;
1727        continue;
1728      }
1729      pos += 1;
1730    }
1731    return markers;
1732  }
1733
1734  function maskIgnoreRegions(text) {
1735    if (!/avoid-ai-writing:ignore-/i.test(text)) return { text, ignoredRegions: 0 };
1736    const chars = text.split('');
1737    let ignoredRegions = 0;
1738    let depth = 0;
1739    let openAt = -1;
1740    for (const marker of findIgnoreMarkers(text)) {
1741      if (marker.kind === 'start') {
1742        if (depth === 0) openAt = marker.start;
1743        depth += 1;
1744      } else if (depth > 0) {
1745        depth -= 1;
1746        if (depth === 0) {
1747          blankRange(chars, openAt, marker.end);
1748          ignoredRegions += 1;
1749        }
1750      }
1751    }
1752    if (depth > 0) {
1753      blankRange(chars, openAt, chars.length);
1754      ignoredRegions += 1;
1755    }
1756    return { text: chars.join(''), ignoredRegions };
1757  }
1758
1759  // Blank the content of double-quoted spans and keep the quote marks, so
1760  // offsets and the curly-quote signal survive. Based on QUOTED_SPAN in
1761  // scripts/self-scan.js minus its single-quote branch: apostrophes in
1762  // contractions and possessives would pair up across ordinary prose. A
1763  // straight quote touching a letter or digit on its outer side is an inch
1764  // mark, not a quotation. Empty `""` pairs are consumed so they cannot
1765  // shift the pairing, and a span never crosses a backtick into code. A
1766  // nested quotation escaped as a pair (`\"…\"`) stays inside the span. A
1767  // lone `\"` still closes it, so a path such as `"C:\Temp\"` cannot run on
1768  // into the next quotation.
1769  const QUOTED_SPAN_RE = /(?<![\p{L}\p{N}])"(?:\\"[^"`\n]{0,300}\\"|[^"`\n]){0,300}"(?![\p{L}\p{N}])|“[^“”`\n]{0,300}”/gu;
1770  function maskQuotedSpans(text) {
1771    let maskedQuotes = 0;
1772    const masked = text.replace(QUOTED_SPAN_RE, (span) => {
1773      // Escaped pairs can chain past the 300-character cap; score those.
1774      // Count code points, as the `u` regex does, so emoji do not trip it.
1775      if (span.length === 2 || [...span].length > 302) return span;
1776      maskedQuotes += 1;
1777      // Keep sentence punctuation so getSentences splits where it did before.
1778      return span[0] + span.slice(1, -1).replace(/[^.!?]/g, ' ') + span[span.length - 1];
1779    });
1780    return { text: masked, maskedQuotes };
1781  }
1782
1783  // A `>` opens a blockquote line when a space, the line end, a letter, a
1784  // nested `>`, an opening double quote, emphasis, a link, or a list marker
1785  // (`- `, `+ `, `1. `) follows it. That covers compact Markdown (`>text`)
1786  // without swallowing comparisons such as `>=5` or `>-1`. A single quote is
1787  // left out, as in the inline quote pass.
1788  const BLOCKQUOTE_LINE_RE = /^\s*>(?:$|[\s\p{L}>"“*_[]|[-+]\s|\d{1,9}[.)]\s)/u;
1789
1790  function maskBlockquotes(text) {
1791    const chars = text.split('');
1792    const lines = [];
1793    const lineRe = /[^\r\n]*(?:\r\n|\n|\r|$)/g;
1794    let match;
1795    while ((match = lineRe.exec(text)) !== null && match[0]) {
1796      const body = match[0].replace(/(?:\r\n|\n|\r)$/, '');
1797      lines.push({ text: body, start: match.index, end: match.index + body.length });
1798    }
1799
1800    let quotedLines = 0;
1801    for (const line of lines) {
1802      if (BLOCKQUOTE_LINE_RE.test(line.text)) {
1803        blankRange(chars, line.start, line.end);
1804        quotedLines += 1;
1805      }
1806    }
1807
1808    return { text: chars.join(''), quotedLines };
1809  }
1810
1811  // Keep the historical deletion behavior for default plain mode. Paragraph-
1812  // scoped rules depend on the surrounding lines being rejoined exactly this
1813  // way, so changing this prepass would change scores for existing callers.
1814  function stripBlockquotes(text, sourceMap) {
1815    const rawLines = text.split(/\r?\n/);
1816    const stripIndexes = new Set();
1817    let blankedLines = 0;
1818    for (let i = 0; i < rawLines.length; i += 1) {
1819      // A bare CR is not split here, so a CR-only document is one element.
1820      // Deleting it would take the unquoted lines after the quote with it,
1821      // so blank each quoted CR-separated line in place instead. Blanking
1822      // keeps the element length, so the offsets below still line up.
1823      if (rawLines[i].includes('\r')) {
1824        rawLines[i] = rawLines[i].split('\r').map((line) => {
1825          if (!BLOCKQUOTE_LINE_RE.test(line)) return line;
1826          blankedLines += 1;
1827          return ' '.repeat(line.length);
1828        }).join('\r');
1829      } else if (BLOCKQUOTE_LINE_RE.test(rawLines[i])) {
1830        stripIndexes.add(i);
1831      }
1832    }
1833    const kept = rawLines
1834      .map((_, index) => index)
1835      .filter((index) => !stripIndexes.has(index));
1836    const result = {
1837      text: kept.map((index) => rawLines[index]).join('\n'),
1838      quotedLines: stripIndexes.size + blankedLines,
1839    };
1840    if (!Array.isArray(sourceMap)) return result;
1841
1842    const lineStarts = [];
1843    let offset = 0;
1844    for (let i = 0; i < rawLines.length; i += 1) {
1845      lineStarts.push(offset);
1846      offset += rawLines[i].length;
1847      if (i < rawLines.length - 1) {
1848        if (text[offset] === '\r') offset += 1;
1849        if (text[offset] === '\n') offset += 1;
1850      }
1851    }
1852
1853    const mapped = [];
1854    for (let i = 0; i < kept.length; i += 1) {
1855      const lineIndex = kept[i];
1856      const start = lineStarts[lineIndex];
1857      appendMapRange(mapped, sourceMap, start, start + rawLines[lineIndex].length);
1858      if (i < kept.length - 1) {
1859        const separatorStart = start + rawLines[lineIndex].length;
1860        const newlineIndex = text[separatorStart] === '\r' ? separatorStart + 1 : separatorStart;
1861        mapped.push(sourceMap[newlineIndex]);
1862      }
1863    }
1864    return { ...result, sourceMap: mapped };
1865  }
1866
1867  function maskTopLevelIndentedCode(chars, { listAware = false } = {}) {
1868    const lines = chars.join('').split('\n');
1869    let offset = 0;
1870    let inBlock = false;
1871    let previousBlank = true;
1872    let listContext = false;
1873    for (let i = 0; i < lines.length; i += 1) {
1874      const line = lines[i];
1875      const indented = /^(?: {4}|\t)\S/.test(line);
1876      const blank = line.trim() === '';
1877      const isCode = indented && (inBlock || (previousBlank && (!listAware || !listContext)));
1878      if (isCode) {
1879        blankRange(chars, offset, offset + line.length);
1880        inBlock = true;
1881      } else if (!blank) {
1882        inBlock = false;
1883      }
1884      if (listAware && !blank && !isCode) {
1885        if (/^ {0,3}(?:[-*+]|\d{1,9}[.)])(?:\s|$)/.test(line)) listContext = true;
1886        else if (/^\S/.test(line)) listContext = false;
1887      }
1888      previousBlank = blank;
1889      offset += line.length + 1;
1890    }
1891  }
1892
1893  function maskYamlFrontmatter(chars) {
1894    const lines = chars.join('').split('\n');
1895    const bare = (line) => line.replace(/\r$/, '');
1896    const first = bare(lines[0]).replace(/^\uFEFF/, '');
1897    if (first !== '---' || lines.length < 2 || /^\s*$/.test(bare(lines[1]))) return;
1898
1899    let closingLine = -1;
1900    for (let i = 1; i < lines.length; i += 1) {
1901      if (bare(lines[i]) === '---') {
1902        closingLine = i;
1903        break;
1904      }
1905    }
1906    if (closingLine === -1) return;
1907
1908    let end = 0;
1909    for (let i = 0; i <= closingLine; i += 1) {
1910      end += lines[i].length;
1911      if (i < lines.length - 1) end += 1;
1912    }
1913    blankRange(chars, 0, end);
1914  }
1915
1916  function maskYamlMetadata(chars) {
1917    const lines = chars.join('').split('\n');
1918    let offset = 0;
1919    let nestedAfterIndent = null;
1920    for (const line of lines) {
1921      const bare = line.replace(/\r$/, '');
1922      // Lowercase keys are the common unfenced-YAML shape. Keeping this
1923      // case-sensitive prevents prose labels such as "Note: ..." from being
1924      // mistaken for metadata and silencing a real copyedit on the line.
1925      const key = bare.match(/^([ \t]*)(?:-[ \t]+)?[a-z_][a-z0-9_.-]*[ \t]*:(.*)$/);
1926      const indentation = (bare.match(/^[ \t]*/) || [''])[0].length;
1927      let shouldMask = false;
1928
1929      if (key) {
1930        shouldMask = true;
1931        nestedAfterIndent = key[2].trim() === '' ? key[1].length : null;
1932      } else if (nestedAfterIndent !== null && bare.trim() !== '' && indentation > nestedAfterIndent) {
1933        shouldMask = true;
1934      } else if (bare.trim() === '') {
1935        nestedAfterIndent = null;
1936      } else {
1937        nestedAfterIndent = null;
1938      }
1939
1940      if (shouldMask) blankRange(chars, offset, offset + line.length);
1941      offset += line.length + 1;
1942    }
1943  }
1944
1945  function maskMarkdownTables(chars) {
1946    const lines = chars.join('').split('\n');
1947    // Tested against the trimmed line: the pattern already allows surrounding
1948    // whitespace, and its adjacent `\s*` groups backtrack quadratically on a
1949    // long whitespace run, so a line of masked comments or blank padding
1950    // cost seconds before it was rejected (#235).
1951    const delimiter = /^\|?\s*:?-{3,}:?\s*(?:\|\s*:?-{3,}:?\s*)+\|?$/;
1952    const rows = new Set();
1953    for (let i = 0; i < lines.length; i += 1) {
1954      const candidate = lines[i].trim();
1955      if (!candidate.includes('---') || !delimiter.test(candidate)) continue;
1956      if (i > 0 && lines[i - 1].includes('|')) rows.add(i - 1);
1957      rows.add(i);
1958      for (let j = i + 1; j < lines.length && lines[j].includes('|'); j += 1) rows.add(j);
1959    }
1960
1961    let offset = 0;
1962    for (let i = 0; i < lines.length; i += 1) {
1963      if (rows.has(i)) blankRange(chars, offset, offset + lines[i].length);
1964      offset += lines[i].length + 1;
1965    }
1966  }
1967
1968  function maskDelimitedQuotes(chars, open, close, apostropheAware = false) {
1969    const isWord = (char) => char !== undefined && /[a-z0-9]/i.test(char);
1970    const isEscaped = (index) => {
1971      let slashes = 0;
1972      for (let i = index - 1; i >= 0 && chars[i] === '\\'; i -= 1) slashes += 1;
1973      return slashes % 2 === 1;
1974    };
1975    let start = -1;
1976    for (let i = 0; i < chars.length; i += 1) {
1977      if (start === -1) {
1978        if (chars[i] === open && !isEscaped(i) && (!apostropheAware || !isWord(chars[i - 1]))) start = i;
1979      } else if (chars[i] === close && !isEscaped(i) && (!apostropheAware || !isWord(chars[i + 1]))) {
1980        blankRange(chars, start, i + 1);
1981        start = -1;
1982      }
1983    }
1984  }
1985
1986  // Additional protected spans for the hyphenation copyedit. Unlike general
1987  // AI-tell matching, this rule must not "correct" a literal spelling in a
1988  // quote, URL, path, filename, command flag, or Markdown blockquote.
1989  function maskHyphenationProtected(text) {
1990    const chars = maskCode(text).split('');
1991    maskTopLevelIndentedCode(chars);
1992    maskYamlFrontmatter(chars);
1993    maskYamlMetadata(chars);
1994    maskMarkdownTables(chars);
1995    maskDelimitedQuotes(chars, '"', '"');
1996    maskDelimitedQuotes(chars, '“', '”');
1997    maskDelimitedQuotes(chars, "'", "'", true);
1998    maskDelimitedQuotes(chars, '‘', '’', true);
1999    const maskMatches = (regex) => {
2000      const source = chars.join('');
2001      let match;
2002      while ((match = regex.exec(source)) !== null) {
2003        blankRange(chars, match.index, match.index + match[0].length);
2004      }
2005    };
2006
2007    maskMatches(/^[ \t]*>[^\n]*$/gm);
2008    maskMatches(/\b(?:https?:\/\/|www\.)[^\s<>]+/gi);
2009    maskMatches(/<[!?/]?[a-z][^<>\n]*>/gi);
2010    maskMatches(/(?<![a-z0-9_-])--?[a-z0-9][a-z0-9-]{0,127}/gi);
2011
2012    // Paths and filenames use bounded components. Besides preventing
2013    // superlinear backtracking on long kebab blobs, the explicit prefix and
2014    // trailing-slash forms cover single-component paths such as C:\\code-base,
2015    // ~/code-base, /code-base, and code-base/.
2016    maskMatches(/(?:[a-z]:[\\/]|\.{1,2}[\\/]|~[\\/]|[\\/])[a-z0-9_.-]{1,255}/gi);
2017    maskMatches(/(?:[a-z]:[\\/]|(?:\.\.?[\\/])?)(?:[a-z0-9_.-]{1,64}[\\/]){1,128}[a-z0-9_.-]{1,64}/gi);
2018    maskMatches(/\b[a-z0-9_.]{0,63}-[a-z0-9_.-]{1,64}[\\/]/gi);
2019    maskMatches(/\b[a-z0-9_.-]{1,64}-[a-z0-9_.-]{1,64}\.[a-z0-9]{1,16}\b/gi);
2020
2021    // Technical identifiers that are distinguishable from ordinary prose:
2022    // selectors, scoped packages, versioned tokens, assignments, and kebab
2023    // names next to an explicit identifier cue. Plain lowercase compounds
2024    // remain visible to the curated copyedit patterns below.
2025    maskMatches(/[.#][a-z_][a-z0-9_.-]{0,63}-[a-z0-9_.-]{1,64}\b/gi);
2026    maskMatches(/@[a-z0-9_.-]{1,64}\/[a-z0-9_.-]{1,64}-[a-z0-9_.-]{1,64}(?:@[^\s,;)\]}]{1,32})?/gi);
2027    maskMatches(/\b[a-z0-9_.-]{1,64}-[a-z0-9_.-]{1,64}@[~^]?v?\d[a-z0-9*_.+-]{0,31}\b/gi);
2028    maskMatches(/\b(?:[a-z0-9_.-]{0,64}\d[a-z0-9_.-]{0,64}-[a-z0-9_.-]{1,64}|[a-z0-9_.-]{1,64}-[a-z0-9_.-]{0,64}\d[a-z0-9_.-]{0,64})\b/gi);
2029    maskMatches(/\b[a-z_][a-z0-9_.]{0,63}(?:-[a-z0-9_.]{1,64}){1,8}(?=[ \t]*[=:])/gi);
2030    maskMatches(/\b[a-z_][a-z0-9_.]{0,63}(?:-[a-z0-9_.]{1,64}){1,8}(?=[ \t]+(?:npm[ \t]+)?(?:package|module|class|selector|config(?:uration)?[ \t]+key|key|identifier|property|setting|token|slug|command|option)\b)/gi);
2031    maskMatches(/\b(?:(?:file(?:name)?|directory|folder|package|module|class|selector|config(?:uration)?[ \t]+key|identifier|property|setting|token|slug|command|option)(?:[ \t]+(?:named|called|is|was))?|key[ \t]+(?:named|called|is|was))[ \t]+(?:@[a-z0-9_.-]{1,64}\/)?[a-z_][a-z0-9_.]{0,63}(?:-[a-z0-9_.]{1,64}){1,8}\b/gi);
2032    maskMatches(/\b(?:npm|pnpm|yarn)[ \t]+(?:add|install)[ \t]+(?:@[a-z0-9_.-]{1,64}\/)?[a-z0-9_.]{1,64}(?:-[a-z0-9_.]{1,64}){1,8}/gi);
2033
2034    return chars.join('');
2035  }
2036
2037  function findUnnecessaryHyphenation(text) {
2038    const scanText = maskHyphenationProtected(text);
2039    const issues = [];
2040    for (const entry of UNNECESSARY_HYPHENATION) {
2041      const regex = new RegExp(entry.pattern.source, entry.pattern.flags);
2042      let match;
2043      while ((match = regex.exec(scanText)) !== null) {
2044        issues.push({
2045          type: 'unnecessary-hyphenation',
2046          text: match[0],
2047          severity: 'medium',
2048          suggestion: typeof entry.suggestion === 'function'
2049            ? entry.suggestion(match[0])
2050            : entry.suggestion,
2051        });
2052      }
2053    }
2054    return issues;
2055  }
2056
2057  // ─── Forms that open with `#` but are not social tags ──────────────
2058  // `#` is overloaded in technical prose and the hashtag rule counts every
2059  // `#word` it sees, so these are subtracted before the threshold applies:
2060  //   #88, #1234         issue and PR references
2061  //   #1a2b3c            CSS hex colours, 6 or 8 chars AND containing a digit
2062  //   #include, #ifndef  C preprocessor directives
2063  // Deliberately NOT carving out 3- and 4-digit hex: #dad, #cafe, #b2b, #e2e,
2064  // #ace, #face and #bad are real tags, and subtracting them cost true
2065  // positives on exactly the stuffed-block shape this rule exists to catch.
2066  // Real palettes are dominated by 6-digit values, so a CSS paragraph still
2067  // lands under the threshold without the short forms.
2068  // `owner/repo#88` and URL fragments need no carve-out: the char before `#`
2069  // is a word char, so the rule's own anchor already rejects them.
2070  // Ambiguous word tags stay counted on purpose. `#general` as a channel and
2071  // `#general` as a tag are the same token, and separating them needs a guess
2072  // that costs more precision on real tag blocks than the carve-out buys.
2073  // Requires at least one digit: #decade, #facade, #deadbeef are a-f words and
2074  // real tags. Every actual palette value in the wild carries a digit.
2075  const HEX_COLOUR = /^(?=[0-9a-f]*\d)(?:[0-9a-f]{6}|[0-9a-f]{8})$/i;
2076  const CPP_DIRECTIVE = /^(?:include|define|undef|if|ifdef|ifndef|elif|else|endif|pragma|error|warning|line)$/;
2077
2078  function isSocialTag(tag) {
2079    return !/^\d+$/.test(tag) && !HEX_COLOUR.test(tag) && !CPP_DIRECTIVE.test(tag);
2080  }
2081
2082  // ─── Title Case Section Headers in non-technical prose ─────────────
2083  // "Strategic Negotiations And Key Partnerships" — every content word
2084  // capitalized. Acceptable in API docs, ML papers, news headlines. Tell
2085  // in marketing/personal/blog prose. Skipped when contextMode is
2086  // 'technical'; runs for general, marketing, and personal.
2087  //
2088  // The optional `#{1,6}` prefix is load-bearing (#62): without it the `^[A-Z]`
2089  // anchor required the line to START with a capital, so `## Benefits And
2090  // Strategic Considerations` never matched — the first character is `#`. The
2091  // rule missed the single most common way a heading is actually written, while
2092  // catching the bare-line form it is usually converted from. Reported by a
2093  // downstream vendoring the detector.
2094  //
2095  // Setext headings (`Title`/`=====`) need no prefix: their text line is bare
2096  // and already matched by this same pattern.
2097  // Interior tokens accept Title Case words, acronyms (`AI`, `API`, `CLI`) and
2098  // the capitalised single-letter words `A` and `I`. The first and last tokens
2099  // stay ordinary `[A-Z][a-z]+` words, which also excludes all-caps banner
2100  // lines (`## HTTP API REFERENCE`) whose leading token is not Title Case.
2101  //
2102  // Separators and trailing whitespace are horizontal only (`[ \t]`), so a
2103  // match can never run past one physical line: `\s` also eats newlines, which
2104  // let two unrelated lines or a blank-line-separated fragment combine into a
2105  // single heading match (GH-291).
2106  const TITLE_CASE_HEADER = /^(?:#{1,6}[ \t]+)?([A-Z][a-z]+(?:[ \t]+(?:[A-Z][a-z]+|A|I|[A-Z]{2,}|and|or|of|the|in|for|to|a|an))+[ \t]+[A-Z][a-z]+)[ \t]*$/gm;
2107
2108  // ─── Parenthetical hedging asides ──────────────────────────────────
2109  // "(and increasingly, X)", "(or more precisely, Y)", "(though to be
2110  // fair, Z)" — pseudo-aside that adds no information but performs
2111  // thoughtfulness. Different from genuine human parentheticals which
2112  // tend to be tangents or clarifications, not hedges.
2113  const PARENTHETICAL_HEDGE = [
2114    /\(\s*(?:and\s+)?(?:increasingly|notably|importantly|crucially|interestingly|perhaps)[,]?\s+[^)]{3,60}\)/gi,
2115    /\(\s*or\s+more\s+(?:precisely|accurately|specifically)[,]?\s+[^)]{3,60}\)/gi,
2116    /\(\s*though\s+to\s+be\s+fair[,]?\s+[^)]{3,60}\)/gi,
2117    /\(\s*at\s+least\s+(?:in\s+)?(?:theory|principle|part)[,]?\s+[^)]{0,60}\)/gi,
2118  ];
2119
2120  // ─── Confidence calibration ────────────────────────────────────────
2121  const CONFIDENCE_CALIBRATION = [
2122    /\binterestingly\b/gi,
2123    /\bsurprisingly\b/gi,
2124    /\bimportantly\b/gi,
2125    /\bsignificantly\b/gi,
2126    /\bcertainly\b/gi,
2127    /\bundoubtedly\b/gi,
2128    /\bwithout\s+a\s+doubt\b/gi,
2129  ];
2130
2131  // ─── Social endorsement / CTA closers ──────────────────────────────
2132  // The curatorial sign-off LLMs append to LinkedIn / X posts that share
2133  // or recommend something — usually a colon teeing up a link. Distinct
2134  // from the bare "worth reading" word-table entry (a single weak word)
2135  // and from infomercial hooks (mid-flow teasers): this is the
2136  // demonstrative-anchored endorsement — "THIS one is worth your time:",
2137  // "do yourself a favor and read this", "thank me later" — that performs
2138  // a recommendation without giving the reader a reason to click.
2139  //
2140  // Precision-first: each pattern carries an anchor so it stays off the
2141  // literal-verb prose a human writes. The demonstrative object ("read
2142  // THIS", not "read the runbook"), the trailing-terminal lookahead on
2143  // "miss this" / "bookmark this" (the closing-line shape, not "miss this
2144  // meeting" / "bookmark this page"), and the sentence-initial lookbehind
2145  // on "thank me later" / "save this for later" (the imperative CTA, not
2146  // "she will thank me later") all exist to suppress false positives on
2147  // ordinary instructional/conversational text. Apostrophe classes admit
2148  // the curly ' (U+2019) because LinkedIn / Word / macOS auto-curl it —
2149  // the straight-only form would miss the canonical "you won't" closer.
2150  const SOCIAL_CTA_CLOSER = [
2151    /\bthis\s+one['’]?s?\s+(?:is\s+)?(?:well\s+|totally\s+|absolutely\s+|definitely\s+|really\s+|truly\s+|easily\s+|more\s+than\s+)?worth\s+(?:your\s+time|the\s+read|a\s+read|every\s+(?:minute|second)|reading|watching|a\s+listen|a\s+watch|a\s+look|it)\b/gi,
2152    /\bthis\s+one['’]?s?\s+(?:is\s+)?a\s+must[-\s]?(?:read|watch|listen|see)\b/gi,
2153    /\b(?:highly|strongly|can['’]?t|cannot)\s+recommend\w*\s+(?:giving\s+)?(?:this|it)\s+(?:one\s+)?a\s+(?:read|listen|watch|look|go)\b/gi,
2154    /\bdo\s+yourself\s+a\s+favou?r\s+and\s+(?:read|watch|check\s+out)\s+(?:this|it)\b/gi,
2155    /\byou\s+(?:really\s+)?(?:won['’]?t|do\s*n['’]?t|will\s+not|do\s+not)\s+want\s+to\s+miss\s+this(?:\s+one)?(?=\s*(?:[:.!\n]|$))/gi,
2156    /(?<=^|[,.!?:\n]\s{0,4})(?:you\s+can\s+)?thank\s+me\s+later\b/gim,
2157    /(?<=^|[.!?:\n]\s{0,4})save\s+this\s+(?:one\s+)?for\s+later\b/gim,
2158    /\bbookmark\s+this(?:\s+(?:one|post|thread))?(?=\s*(?:[:.!\n]|$))/gi,
2159    /\bdo\s*n['’]?t\s+sleep\s+on\s+this\b/gi,
2160    /\btrust\s+me,?\s+(?:on\s+this|you['’]?ll)\b/gi,
2161  ];
2162
2163  // ─── Unnecessary hyphenation (#107) ───────────────────────────────
2164  // Precision-first subclasses only. The general question of whether a
2165  // compound modifier is established English needs editorial judgment and
2166  // remains in SKILL.md; the engine covers only curated open/closed forms and
2167  // compounds whose surrounding syntax makes the unhyphenated form clear.
2168  const UNNECESSARY_HYPHENATION = [
2169    // Welded open noun phrases reported in #107. Match the complete phrase so
2170    // a project-specific spelling of the pair in another role is not swept in.
2171    { pattern: /\bresearch-impact\s+aggregat(?:or|ion)s?\b/g, suggestion: (match) => match.replace('research-impact', 'research impact') },
2172    { pattern: /\bdata-source\s+strateg(?:y|ies)\b/g, suggestion: (match) => match.replace('data-source', 'data source') },
2173    { pattern: /\bPython-package\s+usage\b/g, suggestion: (match) => match.replace('Python-package', 'Python package') },
2174    { pattern: /\bRust-crate\s+usage\b/g, suggestion: (match) => match.replace('Rust-crate', 'Rust crate') },
2175    { pattern: /\bsingle-Project\s+Manifest\b/g, suggestion: (match) => match.replace('single-Project', 'single Project') },
2176    { pattern: /\btotal-downloads\s+figures?\b/g, suggestion: (match) => match.replace('total-downloads', 'total downloads') },
2177    { pattern: /\blife-sciences-native\s+citation\s+count\b/g, suggestion: 'citation count from a life sciences source' },
2178
2179    // Compounds whose standard spelling is closed. Kept as a small curated
2180    // list rather than guessing that every noun-noun pair should close up.
2181    { pattern: /\bcode-base\b/g, suggestion: (match) => match.replace('-', '') },
2182    { pattern: /\bdata-set\b/g, suggestion: (match) => match.replace('-', '') },
2183    { pattern: /\btime-frame\b/g, suggestion: (match) => match.replace('-', '') },
2184    { pattern: /\broad-map\b/g, suggestion: (match) => match.replace('-', '') },
2185
2186    // Attributive-only forms used adverbially or as nouns. The boundary after
2187    // real-time / long-term is intentionally narrow: "real-time analytics"
2188    // and "long-term plan" must not fire.
2189    {
2190      pattern: /\bin\s+real-time(?=\s*(?:[,.!?;:]|$)|\s+(?:(?:across|as|automatically|because|but|continuously|during|dynamically|every|for|from|immediately|instantly|on|simultaneously|through|throughout|until|via|when|while|with|without)\b))/gi,
2191      suggestion: 'in real time',
2192    },
2193    {
2194      pattern: /\b(?:for|over)\s+the\s+long-term(?=\s*(?:[,.!?;:]|$)|\s+(?:across|because|but|by|during|for|from|on|through|throughout|until|via|when|while|with|without)\b)/gi,
2195      suggestion: (match) => match.replace(/long-term/i, 'long term'),
2196    },
2197    {
2198      pattern: /\b(?:functions?|functioned|functioning|operates?|operated|operating|runs?|ran|running|works?|worked|working)\s+out-of-the-box\b/gi,
2199      suggestion: (match) => match.replace(/out-of-the-box/i, 'out of the box'),
2200    },
2201  ];
2202
2203  // ═══ Helpers ═══════════════════════════════════════════════════════
2204
2205  function tokenize(text) {
2206    return text.toLowerCase().match(/[\w'-]+/g) || [];
2207  }
2208
2209  // Moving-average type-token ratio (MATTR; Covington & McFall 2010,
2210  // doi:10.1080/09296171003643098): the share of distinct tokens in each
2211  // run of `size` consecutive tokens, averaged over every such run. Plain
2212  // TTR falls as a text grows, because common words keep recurring while
2213  // new ones arrive more slowly, so a fixed threshold on it measures length.
2214  // The windowed mean does not drift with length, and on a text of exactly
2215  // `size` tokens it equals plain TTR.
2216  function movingAverageTTR(tokens, size) {
2217    const counts = new Map();
2218    let distinct = 0;
2219    const add = (token) => {
2220      const n = (counts.get(token) || 0) + 1;
2221      counts.set(token, n);
2222      if (n === 1) distinct += 1;
2223    };
2224    const drop = (token) => {
2225      const n = counts.get(token) - 1;
2226      if (n === 0) {
2227        counts.delete(token);
2228        distinct -= 1;
2229      } else {
2230        counts.set(token, n);
2231      }
2232    };
2233    for (let i = 0; i < size; i += 1) add(tokens[i]);
2234    let sum = distinct;
2235    for (let i = size; i < tokens.length; i += 1) {
2236      drop(tokens[i - size]);
2237      add(tokens[i]);
2238      sum += distinct;
2239    }
2240    return sum / ((tokens.length - size + 1) * size);
2241  }
2242
2243  function countWords(text) {
2244    return (text.match(/\S+/g) || []).length;
2245  }
2246
2247  function getParagraphs(text) {
2248    return text.split(/\n\s*\n/).filter(p => p.trim().length > 0);
2249  }
2250
2251  function getSentences(text) {
2252    return text.split(/[.!?]+/).filter(s => s.trim().length > 5);
2253  }
2254
2255  function matchPatterns(text, patterns, category, severity) {
2256    const issues = [];
2257    for (const pat of patterns) {
2258      const regex = new RegExp(pat.source, pat.flags);
2259      let match;
2260      while ((match = regex.exec(text)) !== null) {
2261        issues.push({
2262          type: category,
2263          text: match[0],
2264          index: match.index,
2265          severity,
2266          suggestion: null,
2267        });
2268      }
2269    }
2270    return issues;
2271  }
2272
2273  // ═══ Main analysis ═════════════════════════════════════════════════
2274
2275  // Upper bound for one scan. Above this we bail rather than running all
2276  // regex passes over a huge buffer — protects page perf on pasted novels.
2277  const MAX_WORDS = 10000;
2278
2279  // V2 contract defaults so early-exit paths (Empty/tooShort/tooLong)
2280  // still return the same field shape a v2 consumer expects. Without
2281  // this, `result.document_classification === 'AI_ONLY'` is `undefined`
2282  // on edge inputs and fails open.
2283  // UNSCORED is returned on empty / too-short / too-long inputs where
2284  // we declined to score. Distinct from HUMAN_ONLY (which is a positive
2285  // classification) so a caller can't mistake a refused scan for a
2286  // confident human verdict — a 50k-word LLM-generated document is
2287  // not "human", it's just outside our scoring window.
2288  function buildV2Defaults(classification, confidence) {
2289    const probs = classification === 'HUMAN_ONLY'
2290      ? { human: 1, mixed: 0, ai: 0 }
2291      : classification === 'AI_ONLY'
2292        ? { human: 0, mixed: 0, ai: 1 }
2293        : { human: 0.333, mixed: 0.334, ai: 0.333 };
2294    return {
2295      document_classification: classification,
2296      class_probabilities: probs,
2297      confidence_category: confidence,
2298      highlight_sentence_for_ai: [],
2299    };
2300  }
2301
2302  function analyzeText(text, options = {}) {
2303
2304    if (typeof text !== 'string') {
2305      throw new TypeError('analyzeText(text): argument must be a string');
2306    }
2307
2308    const VALID_CONTEXT_MODES = new Set(['general', 'technical', 'marketing', 'personal']);
2309    const requestedMode = options.contextMode === undefined ? 'general' : options.contextMode;
2310    const contextMode = VALID_CONTEXT_MODES.has(requestedMode) ? requestedMode : 'general';
2311    const contextModeFallback = requestedMode !== contextMode ? requestedMode : null;
2312
2313    // Source mode controls which parts of a Markdown file count as prose.
2314    // Plain remains the compatibility default. Rendered Markdown masks only
2315    // initial YAML frontmatter and HTML comments; source-hygiene checks for
2316    // hidden TODO/placeholder comments remain available through plain mode.
2317    const VALID_SOURCE_MODES = new Set(['plain', 'rendered-markdown']);
2318    const requestedSourceMode = options.sourceMode === undefined ? 'plain' : options.sourceMode;
2319    const sourceMode = VALID_SOURCE_MODES.has(requestedSourceMode) ? requestedSourceMode : 'plain';
2320    const sourceModeFallback = requestedSourceMode !== sourceMode ? requestedSourceMode : undefined;
2321    if (!text || text.trim().length === 0) {
2322      return {
2323                ...buildV2Defaults('UNSCORED', 'low'),
2324                    score: 0,
2325                    label: 'Empty',
2326                    issues: [],
2327                    stats: {
2328                        wordCount: 0,
2329                        contextMode,
2330                        contextModeFallback,
2331                        sourceMode,
2332                        sourceModeFallback,
2333                        maskedFrontmatter: 0,
2334                        maskedHtmlComments: 0,
2335                        ignoredRegions: 0,
2336                        quotedLines: 0,
2337                        maskedQuotes: 0,
2338                    },
2339                  tooShort: true,
2340                };
2341              }
2342
2343    // Map each working-string code unit back to the caller's source. Every
2344    // length-changing preprocessing stage composes this map as it removes
2345    // characters, and results are translated before they leave the function.
2346    let sourceMap = identitySourceMap(text.length);
2347
2348    // Context mode selects context-appropriate flagging. Accepted values:
2349    //   'general' (default) — full ruleset
2350    //   'technical' — skip title-case headers; individual prose-only rules
2351    //                 apply their own technical-context gates (only mode
2352    //                 that currently changes scoring)
2353    //   'marketing' — accepted; recorded in stats; scores same as general
2354    //   'personal'  — accepted; recorded in stats; scores same as general
2355    // Invalid values fall back to 'general' with stats.contextModeFallback set.
2356    // Mode validation: an unknown string (e.g. typo "tecnical") would
2357    // otherwise silently downgrade to general-mode behavior. Coerce to
2358    // 'general' and surface the original value in stats for traceability.
2359    let maskedFrontmatter = 0;
2360    let maskedHtmlComments = 0;
2361
2362    // Author-marked ignore regions go first, in every source mode, so no
2363    // later pass sees the excluded passage. Masking keeps the length, so the
2364    // source map needs no update.
2365    const ignored = maskIgnoreRegions(text);
2366    text = ignored.text;
2367    const { ignoredRegions } = ignored;
2368
2369    if (sourceMode === 'rendered-markdown') {
2370      const rendered = maskRenderedMarkdown(text);
2371      text = rendered.text;
2372      maskedFrontmatter = rendered.maskedFrontmatter;
2373      maskedHtmlComments = rendered.maskedHtmlComments;
2374    }
2375
2376    // Pre-pass: mask Markdown blockquotes before scoring. A human
2377    // reacting to AI text by quoting it shouldn't have the quoted block
2378    // counted against their own writing. A single `> ` line counts too
2379    // (#238). Masking instead of deleting keeps later issue and highlight
2380    // offsets aligned with the source file.
2381    const blockquotes = sourceMode === 'rendered-markdown'
2382      ? maskBlockquotes(text)
2383      : stripBlockquotes(text, sourceMap);
2384    text = blockquotes.text;
2385    if (blockquotes.sourceMap) sourceMap = blockquotes.sourceMap;
2386    const { quotedLines } = blockquotes;
2387
2388    // Pre-pass: the inline half of the blockquote escape hatch. Words inside
2389    // a double-quoted span belong to whoever is quoted (#238). Masking runs
2390    // before normalization, as blockquotes do, so bypass characters inside a
2391    // quotation raise no normalization flag. Masking keeps the length, so
2392    // the source map needs no update. The smart-punctuation check below
2393    // reads the unmasked text, because the blanked span would otherwise
2394    // count as a double space.
2395    const unquotedText = normalizeText(text).text;
2396    const quotes = maskQuotedSpans(text);
2397    text = quotes.text;
2398    const { maskedQuotes } = quotes;
2399
2400    // Pre-pass: strip bypass-trick chars before pattern matching so
2401    // "delve" with a Cyrillic 'е' still hits Tier 1. Compose the map while
2402    // deleting characters so later offsets still address the source.
2403    const norm = normalizeText(text, sourceMap);
2404    text = norm.text;
2405    sourceMap = norm.sourceMap;
2406
2407    const wordCount = countWords(text);
2408    // Unsegmented-script check (GH-241): Chinese and Japanese carry no
2409    // inter-word spaces, so word segmentation cannot measure them — a long
2410    // document counts as one \S+ run and would misreport as "Too short",
2411    // while newline-wrapped lines each count as a word and would score
2412    // without segmentation. The check therefore runs before the word gate
2413    // and declines only when CJK characters dominate the non-whitespace
2414    // text, so short English documents with an incidental place name or
2415    // single Han character stay scorable. Unicode script properties cover
2416    // the complete Han, Hiragana, and Katakana repertoires (including
2417    // supplementary-plane and halfwidth forms); Hangul is space-separated
2418    // and segments fine, so it is excluded. Both counts use Unicode mode so
2419    // supplementary characters count as one code point rather than two UTF-16
2420    // code units.
2421    const cjkChars = (text.match(/[\p{Script_Extensions=Han}\p{Script_Extensions=Hiragana}\p{Script_Extensions=Katakana}]/gu) || []).length;
2422    const nonSpaceChars = (text.match(/\S/gu) || []).length;
2423    if (cjkChars > 0 && cjkChars * 2 >= nonSpaceChars) {
2424      return {
2425        ...buildV2Defaults('UNSCORED', 'low'),
2426        score: 0,
2427        label: 'Unsupported script',
2428        issues: [],
2429        stats: { wordCount, cjkChars, reason: 'unsegmented-script document: no inter-word spaces to count', contextMode, contextModeFallback, sourceMode, sourceModeFallback, maskedFrontmatter, maskedHtmlComments, ignoredRegions, quotedLines, maskedQuotes },
2430        unsupportedScript: true,
2431      };
2432    }
2433    if (wordCount < 10) {
2434      return {
2435        ...buildV2Defaults('UNSCORED', 'low'),
2436        score: 0,
2437        label: 'Too short',
2438        issues: [],
2439        stats: { wordCount, contextMode, contextModeFallback, sourceMode, sourceModeFallback, maskedFrontmatter, maskedHtmlComments, ignoredRegions, quotedLines, maskedQuotes },
2440        tooShort: true,
2441      };
2442    }
2443    if (wordCount > MAX_WORDS) {
2444      return {
2445        ...buildV2Defaults('UNSCORED', 'low'),
2446        score: 0,
2447        label: 'Text too long',
2448        issues: [],
2449        stats: { wordCount, contextMode, contextModeFallback, sourceMode, sourceModeFallback, maskedFrontmatter, maskedHtmlComments, ignoredRegions, quotedLines, maskedQuotes },
2450        tooLong: true,
2451      };
2452    }
2453
2454    const tokens = tokenize(text);
2455    const paragraphs = getParagraphs(text);
2456    const sentences = getSentences(text);
2457    const issues = [];
2458    let rawScore = 0;
2459
2460    // ── 1. Tier 1 words ──────────────────────────────────────────
2461    const tier1Found = new Set();
2462    for (const token of tokens) {
2463      if (contextMode === 'technical' && TECHNICAL_EXEMPT.has(token)) continue;
2464      if (Object.hasOwn(TIER1, token) && !tier1Found.has(token)) {
2465        tier1Found.add(token);
2466        issues.push({
2467          type: 'tier1',
2468          text: token,
2469          severity: 'high',
2470          suggestion: TIER1[token],
2471        });
2472      }
2473    }
2474
2475    // Tier 1 multi-word phrases. Adds each distinct phrase (lowercased) to
2476    // `tier1Found` so the same phrase hit multiple times only produces one
2477    // issue — matches the downstream dedup behavior.
2478    for (const phrase of TIER1_PHRASES) {
2479      const regex = new RegExp(phrase.pattern.source, phrase.pattern.flags);
2480      let match;
2481      while ((match = regex.exec(text)) !== null) {
2482        const lower = match[0].toLowerCase();
2483        if (contextMode === 'technical' && TECHNICAL_EXEMPT.has(lower)) continue;
2484        if (phrase.skip && phrase.skip(text, match.index)) continue;
2485        if (tier1Found.has(lower)) continue;
2486        tier1Found.add(lower);
2487        issues.push({
2488          // Clarity-band entries are wordiness edits, not frequency evidence.
2489          // Same fix, weaker claim — see the Tier 1A/1B split in SKILL.md.
2490          type: phrase.clarity ? 'tier1-clarity' : 'tier1',
2491          text: match[0],
2492          severity: phrase.clarity ? 'medium' : 'high',
2493          suggestion: phrase.replace,
2494        });
2495      }
2496    }
2497
2498    // ── 2. Tier 2 clusters ───────────────────────────────────────
2499    let tier2Clusters = 0;
2500    for (const para of paragraphs) {
2501      const paraTokens = tokenize(para);
2502      const found = [];
2503      const suggestions = {};
2504      for (const token of paraTokens) {
2505        if (contextMode === 'technical' && TECHNICAL_EXEMPT.has(token)) continue;
2506        if (Object.hasOwn(TIER2, token) && !found.includes(token)) {
2507          found.push(token);
2508          suggestions[token] = TIER2[token];
2509        }
2510      }
2511      for (const cond of TIER2_CONDITIONAL) {
2512        if (contextMode === 'technical' && TECHNICAL_EXEMPT.has(cond.word)) continue;
2513        if (!found.includes(cond.word) && cond.pattern.test(para)) {
2514          found.push(cond.word);
2515          suggestions[cond.word] = cond.suggestion;
2516        }
2517      }
2518      if (found.length >= 2) {
2519        tier2Clusters++;
2520        for (const word of found) {
2521          issues.push({
2522            type: 'tier2',
2523            text: word,
2524            severity: 'medium',
2525            suggestion: suggestions[word],
2526          });
2527        }
2528      }
2529    }
2530
2531    // ── 3. Tier 3 density ────────────────────────────────────────
2532    const tier3Counts = {};
2533    for (const token of tokens) {
2534      const canonical = TIER3_LOOKUP.get(token);
2535      if (canonical) tier3Counts[canonical] = (tier3Counts[canonical] || 0) + 1;
2536    }
2537    // Flag at 3% of word count, but never below 3 occurrences. Previous
2538    // floor of 1 meant a 50-word text with one "significant" got flagged
2539    // as Tier 3 overuse, which was noise.
2540    const densityThreshold = Math.max(3, Math.floor(wordCount * 0.03));
2541    let tier3Flags = 0;
2542    for (const [word, count] of Object.entries(tier3Counts)) {
2543      if (count >= densityThreshold) {
2544        tier3Flags++;
2545        issues.push({
2546          type: 'tier3',
2547          text: `"${word}" x${count}`,
2548          severity: 'low',
2549          suggestion: `Overused (${count} times in ${wordCount} words)`,
2550        });
2551      }
2552    }
2553
2554    // ── 4–21. Pattern categories ─────────────────────────────────
2555    issues.push(...matchPatterns(text, TRANSITIONS, 'transition', 'medium'));
2556    issues.push(...matchPatterns(text, CHATBOT_ARTIFACTS, 'chatbot', 'critical'));
2557    issues.push(...matchPatterns(text, SYCOPHANTIC, 'sycophantic', 'critical'));
2558    issues.push(...matchPatterns(text, FILLERS, 'filler', 'medium'));
2559    issues.push(...matchPatterns(text, GENERIC_CONCLUSIONS, 'generic-conclusion', 'medium'));
2560    issues.push(...matchPatterns(text, LETS_PATTERNS, 'lets-construction', 'medium'));
2561    issues.push(...matchPatterns(text, REASONING_ARTIFACTS, 'reasoning-artifact', 'critical'));
2562    issues.push(...matchPatterns(text, SIGNIFICANCE_INFLATION, 'significance-inflation', 'high'));
2563    issues.push(...matchPatterns(text, VAGUE_ATTRIBUTIONS, 'vague-attribution', 'critical'));
2564    issues.push(...matchPatterns(text, HOLLOW_INTENSIFIERS, 'hollow-intensifier', 'medium'));
2565    issues.push(...matchPatterns(text, EMOTIONAL_FLATLINE, 'emotional-flatline', 'low'));
2566    issues.push(...matchPatterns(text, LINGERING_ATTENTION, 'lingering-attention', 'medium'));
2567    issues.push(...matchPatterns(text, NOVELTY_INFLATION, 'novelty-inflation', 'medium'));
2568    issues.push(...matchPatterns(text, CUTOFF_DISCLAIMERS, 'cutoff-disclaimer', 'critical'));
2569    issues.push(...matchPatterns(text, AI_PLACEHOLDERS, 'ai-placeholder', 'critical'));
2570    issues.push(...matchPatterns(text, AI_CITATION_MARKUP, 'ai-citation-markup', 'critical'));
2571    issues.push(...matchPatterns(text, AI_UTM_SOURCE, 'ai-utm-source', 'critical'));
2572    issues.push(...matchPatterns(text, TEMPLATE_PHRASES, 'template-phrase', 'high'));
2573    issues.push(...matchPatterns(text, FALSE_CONCESSION, 'false-concession', 'medium'));
2574    issues.push(...matchPatterns(text, RHETORICAL_QUESTIONS, 'rhetorical-question', 'medium'));
2575    issues.push(...matchPatterns(text, HEDGE_STACK, 'hedge-stack', 'high'));
2576    issues.push(...matchPatterns(text, FUTURE_NARRATIVE, 'future-narrative', 'high'));
2577    issues.push(...matchPatterns(text, REAL_ACTUAL_INFLATION, 'real-actual-inflation', 'medium'));
2578    issues.push(...matchPatterns(text, SOCIAL_CTA_CLOSER, 'social-cta-closer', 'high'));
2579    issues.push(...matchPatterns(text, PERFORMED_INSIGHT, 'performed-insight', 'medium'));
2580    const stagedDiscoveryIssues = matchPatterns(text, STAGED_DISCOVERY, 'performed-insight', 'medium');
2581    issues.push(...stagedDiscoveryIssues);
2582    issues.push(...matchPatterns(text, NEGATION_CHAIN, 'negation-chain', 'high'));
2583    // Reveals flag alone; contrasts need a nearby frame. See NEGATIVE_PARALLELISM_*.
2584    issues.push(...negativeParallelismIssues(
2585      text,
2586      matchPatterns(text, NEGATIVE_PARALLELISM_REVEAL, 'negative-parallelism', 'high'),
2587      matchPatterns(text, NEGATIVE_PARALLELISM_CONTRAST, 'negative-parallelism', 'high'),
2588    ));
2589    issues.push(...matchPatterns(text, DEV_BLOG_BOILERPLATE, 'dev-blog-boilerplate', 'medium'));
2590    issues.push(...findUnnecessaryHyphenation(text));
2591
2592    // ── Tier 1 v2: formulaic openers + parenthetical hedges ──────────
2593    issues.push(...matchPatterns(text, FORMULAIC_OPENERS, 'formulaic-opener', 'high'));
2594    issues.push(...matchPatterns(text, SPECULATIVE_OPENERS, 'speculative-opener', 'high'));
2595    issues.push(...matchPatterns(text, LAUNCH_INTROS, 'launch-intro', 'high'));
2596    issues.push(...matchPatterns(text, CROWD_CONTRAST, 'crowd-contrast', 'medium'));
2597    issues.push(...matchPatterns(text, FAKE_CASUAL_PROPS, 'fake-casual-prop', 'high'));
2598    issues.push(...matchPatterns(text, PARENTHETICAL_HEDGE, 'parenthetical-hedge', 'medium'));
2599
2600    // Title-case headers — gated to marketing/personal/general modes
2601    // (technical mode legitimately uses Title Case section headers).
2602    if (contextMode !== 'technical') {
2603      const titleHits = matchPatterns(text, [TITLE_CASE_HEADER], 'title-case-header', 'medium');
2604      // Drop matches that look like proper-noun titles (single line, all
2605      // tokens capitalized incl. function words) — that's headline style,
2606      // not the AI-section-header tell which has mid-sentence "And".
2607      //
2608      // The prefix strip is load-bearing. matchPatterns reports match[0], so a
2609      // Markdown hit arrives as "## Terms Of Service" and `##` counts as a
2610      // token — silently lowering this guard from four content words to three
2611      // for headings only, which is exactly the class it exists to protect.
2612      // "## Terms Of Service", "## Bank Of America" and "## Table Of Contents"
2613      // all flagged as a result: ordinary human headings, on a detector whose
2614      // stated first priority is not firing on human writing.
2615      const filtered = titleHits.filter((h) => {
2616        const title = h.text.replace(MD_HEADING_PREFIX, '');
2617        const tokens = title.trim().split(/\s+/);
2618        if (tokens.length < 4) return false;
2619
2620        // The function word must be MID-title, which is what the comment above
2621        // has always said and what the test never enforced. A leading "The"
2622        // satisfied a bare /\bThe\b/, so ordinary human headings flagged:
2623        // "## The New Security Landscape", "## The Microsoft Approach to
2624        // Identity", "### The Four Keys to a Successful and Secure Modern
2625        // Workplace". Measured across 81 files that provably predate LLMs
2626        // (2018-19 eBooks, 2020 posts): 13 false positives, every one opening
2627        // with "The", against zero on main.
2628        //
2629        // "## Benefits And Strategic Considerations" -- the actual tell, and
2630        // this rule's own fixture -- is untouched: its "And" is interior.
2631        return FUNCTION_WORD.test(tokens.slice(1).join(' '));
2632      });
2633      const fences = filtered.length ? fenceRanges(text) : [];
2634      issues.push(...filtered.filter((h) => !inFenceRange(fences, h.index)));
2635    }
2636
2637    // ── Normalization-trigger flag ───────────────────────────────────
2638    // ZWSPs or homoglyphs in pasted prose are near-dispositive: humans
2639    // don't insert these into their own writing. Single roleplay marker
2640    // can be a false positive on Markdown emphasis (filtered to multi-
2641    // word inner already), so requires ≥2.
2642    if (norm.flags.zeroWidth > 0 || norm.flags.homoglyph >= 2) {
2643      issues.push({
2644        type: 'normalization-flag',
2645        text: `${norm.flags.zeroWidth} zero-width + ${norm.flags.homoglyph} homoglyph swap${norm.flags.homoglyph === 1 ? '' : 's'}`,
2646        severity: 'critical',
2647        suggestion: 'Text contains invisible/lookalike chars typical of AI-humanizer bypass tools. Re-type from your own keyboard.',
2648      });
2649    }
2650    if (norm.flags.roleplay >= 2) {
2651      issues.push({
2652        type: 'normalization-flag',
2653        text: `${norm.flags.roleplay} *roleplay-action* markers stripped`,
2654        severity: 'high',
2655        suggestion: 'Paired *action* markers are a chat-model artifact.',
2656      });
2657    }
2658
2659    // Em dashes in list-item separator position — a bulleted or numbered
2660    // list item opening with a bolded lead term or markdown link, then the
2661    // dash ("- **Term** — desc", "- [label](url) — desc") — are
2662    // definition-list typography, not prose punctuation. Shared by the
2663    // smart-punct signature below and the em-dash frequency check (§22).
2664    // An optional parenthetical or inline-code span may sit between the bold
2665    // lead term and the dash — "- **Lingering-attention claims**
2666    // (`lingering-attention`) — the share-post frame…" is the same definition
2667    // typography as the bare form. Found by the self-scan (see PROOF.md, #67).
2668    const SEPARATOR_DASH_RE = /^\s*(?:[-*+]|\d+[.)])\s+(?:\*\*[^*\n]+\*\*|\[[^\]\n]+\]\([^)\n]*\))(?:[ \t]*(?:\([^)\n]*\)|`[^`\n]+`))?[ \t]*—/gm;
2669
2670    // Keep-a-Changelog version headings (`## [3.21.0] — 2026-07-30`) join a
2671    // label to a value exactly as a list separator does. Deliberately narrow:
2672    // a bracketed or bare semver token, then a dash, then an ISO date, and
2673    // nothing else on the line. Ordinary prose dashes in headings still count,
2674    // because SKILL.md applies the em-dash rule to headings too.
2675    function countVersionHeadingDashes(value) {
2676      let count = 0;
2677      for (const rawLine of value.split(/\r\n|\n|\r/)) {
2678        let end = rawLine.length;
2679        while (end > 0 && (rawLine[end - 1] === ' ' || rawLine[end - 1] === '\t')) end -= 1;
2680        if (!/^\d{4}-\d{2}-\d{2}$/.test(rawLine.slice(Math.max(0, end - 10), end))) continue;
2681        let cursor = end - 10;
2682        while (cursor > 0 && (rawLine[cursor - 1] === ' ' || rawLine[cursor - 1] === '\t')) cursor -= 1;
2683        if (rawLine[cursor - 1] !== '\u2014') continue;
2684        cursor -= 1;
2685        while (cursor > 0 && (rawLine[cursor - 1] === ' ' || rawLine[cursor - 1] === '\t')) cursor -= 1;
2686        const prefix = rawLine.slice(0, cursor);
2687        const heading = /^#{1,6}[ \t]+/.exec(prefix);
2688        if (!heading) continue;
2689        let version = prefix.slice(heading[0].length);
2690        if (version.startsWith('[')) {
2691          if (!version.endsWith(']')) continue;
2692          version = version.slice(1, -1);
2693        } else if (version.endsWith(']')) {
2694          version = version.slice(0, -1);
2695        }
2696        if (version.includes(']')) continue;
2697        if (/^v?\d+\.\d+\.\d+/.test(version)) count += 1;
2698      }
2699      return count;
2700    }
2701
2702    // ── Smart-punctuation co-occurrence signature ────────────────────
2703    // Curly quotes + em-dash + Oxford comma all present + zero typos
2704    // (no double-spaces, no missing apostrophes in common contractions)
2705    // is a near-dispositive paste-from-LLM signature: humans typing
2706    // directly into a textarea don't produce all four. Standalone any of
2707    // these is meaningless — co-occurrence is the signal. Separator-position
2708    // dashes are typography and don't corroborate it.
2709    {
2710      const hasCurly = /[“”‘’]/.test(text);
2711      const totalEmDashes = (text.match(/—/g) || []).length;
2712      const separatorEmDashes = (text.match(SEPARATOR_DASH_RE) || []).length
2713        + countVersionHeadingDashes(text);
2714      const hasEmDash = totalEmDashes > separatorEmDashes;
2715      const oxfordHit = text.match(/\b\w+,\s+\w+,\s+and\s+\w+/g);
2716      const hasOxford = (oxfordHit?.length || 0) >= 1;
2717      const doubleSpaces = (unquotedText.match(/[^.!?]  +/g) || []).length;
2718      const missingApos = /\b(?:dont|wont|cant|isnt|wasnt|shouldnt|wouldnt|couldnt|youre|theyre|its\s+a\s+\w+ing)\b/i.test(text);
2719      const clean = doubleSpaces === 0 && !missingApos;
2720      const signals = [hasCurly, hasEmDash, hasOxford, clean].filter(Boolean).length;
2721      if (signals >= 4 && wordCount >= 80) {
2722        issues.push({
2723          type: 'smart-punct-signature',
2724          text: 'curly-quotes + em-dash + Oxford comma + zero typos',
2725          severity: 'high',
2726          suggestion: 'Smart-punctuation signature consistent with LLM output. Humans typing into textareas rarely produce all four.',
2727        });
2728      }
2729    }
2730
2731    // ── Punctuation distribution mode ────────────────────────────────
2732    // Humans cluster trimodal across paragraphs (some paras heavy, some
2733    // light, some none). AI converges on a normal distribution. We can't
2734    // run a real modality test client-side, but we can flag the AI
2735    // signature: low variance of per-paragraph punctuation density.
2736    // Requires ≥4 paragraphs to be meaningful.
2737    if (paragraphs.length >= 4) {
2738      const densities = paragraphs.map((p) => {
2739        const words = (p.match(/\S+/g) || []).length;
2740        if (words < 5) return null;
2741        const puncts = (p.match(/[,;:—()]/g) || []).length;
2742        return puncts / words;
2743      }).filter((d) => d !== null);
2744      if (densities.length >= 4) {
2745        const mean = densities.reduce((a, b) => a + b, 0) / densities.length;
2746        const variance = densities.reduce((s, d) => s + (d - mean) ** 2, 0) / densities.length;
2747        const cv = mean > 0 ? Math.sqrt(variance) / mean : 0;
2748        // CV < 0.25 across paragraphs means each paragraph has the same
2749        // punctuation density — the AI signature. Humans usually swing
2750        // wider. Threshold derived from stylometry papers (arxiv 2507.00838).
2751        if (cv < 0.25 && mean >= 0.04) {
2752          issues.push({
2753            type: 'punct-distribution',
2754            text: `Punctuation density uniform across paragraphs (CV=${cv.toFixed(2)})`,
2755            severity: 'medium',
2756            suggestion: 'AI text holds punctuation density steady; human writers swing between dense and sparse paragraphs.',
2757          });
2758        }
2759      }
2760    }
2761
2762    // ── Function-word trigram entropy ────────────────────────────────
2763    // POS-trigram entropy is the academic signal; function-word trigram
2764    // entropy approximates it without a tagger (function words ARE the
2765    // closed-class POS classes). AI text has lower entropy because LLM
2766    // sampling collapses onto a narrower set of grammatical templates.
2767    //
2768    // Method: extract function-word indicators per sentence, build
2769    // trigrams over the sequence, compute Shannon entropy. Bins below
2770    // threshold flag.
2771    if (wordCount >= 150) {
2772      const FUNC_WORDS = new Set([
2773        'the','a','an','and','or','but','of','to','in','on','at','by','for','with',
2774        'from','as','is','was','are','were','be','been','being','have','has','had',
2775        'do','does','did','will','would','should','could','may','might','must','can',
2776        'this','that','these','those','it','its','they','them','their','there','here',
2777        'we','our','us','i','you','your','he','she','his','her','him','not','no','so',
2778        'if','then','than','when','where','which','who','what','how','why','because',
2779      ]);
2780      const seq = tokens.map((t) => FUNC_WORDS.has(t) ? t : '_').filter((_, i, arr) => arr[i] !== '_' || (i > 0 && arr[i - 1] !== '_'));
2781      if (seq.length >= 50) {
2782        const trigrams = {};
2783        for (let i = 0; i < seq.length - 2; i++) {
2784          const tg = `${seq[i]}|${seq[i + 1]}|${seq[i + 2]}`;
2785          trigrams[tg] = (trigrams[tg] || 0) + 1;
2786        }
2787        const total = seq.length - 2;
2788        let entropy = 0;
2789        for (const c of Object.values(trigrams)) {
2790          const p = c / total;
2791          entropy -= p * Math.log2(p);
2792        }
2793        // Normalize by log2(distinct trigrams) so entropy ranges roughly
2794        // 0..1 and threshold is interpretable. Empirical threshold: human
2795        // prose ~0.85-0.95 normalized, AI prose ~0.70-0.82.
2796        const distinctCount = Object.keys(trigrams).length;
2797        const normalized = distinctCount > 1 ? entropy / Math.log2(distinctCount) : 1;
2798        if (normalized < 0.82 && total >= 50) {
2799          issues.push({
2800            type: 'fnword-trigram-entropy',
2801            text: `Function-word trigram entropy ${normalized.toFixed(2)} (low)`,
2802            severity: 'medium',
2803            suggestion: 'Grammatical structure is unusually repetitive. AI sampling collapses onto narrower templates than human writing.',
2804          });
2805        }
2806        // Degenerate case: single distinct trigram repeated across the
2807        // whole document is the strongest possible AI signal but the
2808        // normalized fallback returns 1.0 (= "fully human"), inverting
2809        // the signal. Catch it explicitly.
2810        if (distinctCount === 1 && total >= 50) {
2811          issues.push({
2812            type: 'fnword-trigram-entropy',
2813            text: 'Single function-word trigram repeated across document',
2814            severity: 'high',
2815            suggestion: 'Grammatical structure is fully degenerate — every clause uses the same function-word skeleton.',
2816          });
2817        }
2818      }
2819    }
2820
2821    // ── Cross-paragraph burstiness ───────────────────────────────────
2822    // We already check within-paragraph sentence-length uniformity. AI
2823    // is also flat ACROSS paragraphs — every paragraph has roughly the
2824    // same sentence-length variance. Humans vary: terse paras next to
2825    // discursive paras. Measure variance of CV across paragraphs.
2826    if (paragraphs.length >= 4) {
2827      const cvs = paragraphs.map((p) => {
2828        const sents = getSentences(p);
2829        if (sents.length < 3) return null;
2830        const lens = sents.map(countWords);
2831        const m = lens.reduce((a, b) => a + b, 0) / lens.length;
2832        if (m === 0) return null;
2833        const v = lens.reduce((s, l) => s + (l - m) ** 2, 0) / lens.length;
2834        return Math.sqrt(v) / m;
2835      }).filter((c) => c !== null);
2836      if (cvs.length >= 4) {
2837        const cvMean = cvs.reduce((a, b) => a + b, 0) / cvs.length;
2838        const cvVar = cvs.reduce((s, c) => s + (c - cvMean) ** 2, 0) / cvs.length;
2839        const cvStd = Math.sqrt(cvVar);
2840        // Std-of-CV below 0.08 means every paragraph has roughly the same
2841        // internal rhythm — AI signature. Human prose typically swings
2842        // 0.15-0.40 across paragraphs of mixed purpose.
2843        if (cvStd < 0.08 && cvMean < 0.45) {
2844          issues.push({
2845            type: 'cross-para-burstiness',
2846            text: `Sentence-rhythm uniform across paragraphs (σCV=${cvStd.toFixed(2)})`,
2847            severity: 'medium',
2848            suggestion: 'Every paragraph has the same internal rhythm. Humans vary cadence between terse and discursive paragraphs.',
2849          });
2850        }
2851      }
2852    }
2853
2854    // ── Tier 3 multi-word phrase density ─────────────────────────
2855    // Two complementary rules:
2856    //   (a) Per-phrase density — same gating as single-word Tier 3: each
2857    //       phrase fine alone, repetition is the tell. Threshold = 2.
2858    //   (b) Cross-phrase clustering — ≥3 *distinct* boilerplate phrases
2859    //       in one piece. LLMs varying their own boilerplate often use
2860    //       each phrase only once but stack 5-10 across the text. The
2861    //       per-phrase rule misses this; the cluster rule catches it.
2862    // Track non-overlapping match spans so a longer phrase swallowing a
2863    // shorter one (e.g., "designed for long-term sustainability" matches
2864    // both "designed for long-term" AND "long-term sustainability") only
2865    // contributes one distinct hit. Without dedup the cluster threshold
2866    // can be reached by a single sentence stacking overlapping regexes.
2867    const claimedSpans = [];
2868    function spanOverlaps(start, end) {
2869      for (const [s, e] of claimedSpans) {
2870        if (start < e && end > s) return true;
2871      }
2872      return false;
2873    }
2874    let distinctPhrasesHit = 0;
2875    for (const phrase of TIER3_PHRASES) {
2876      const regex = new RegExp(phrase.source, phrase.flags);
2877      const phraseSpans = [];
2878      let phraseMatch;
2879      while ((phraseMatch = regex.exec(text)) !== null) {
2880        const start = phraseMatch.index;
2881        const end = start + phraseMatch[0].length;
2882        if (!spanOverlaps(start, end)) {
2883          phraseSpans.push([start, end, phraseMatch[0]]);
2884        }
2885      }
2886      if (phraseSpans.length === 0) continue;
2887      for (const [s, e] of phraseSpans) claimedSpans.push([s, e]);
2888      distinctPhrasesHit++;
2889      if (phraseSpans.length >= 2) {
2890        issues.push({
2891          type: 'tier3-phrase',
2892          text: `"${phraseSpans[0][2].toLowerCase()}" x${phraseSpans.length}`,
2893          severity: 'medium',
2894          suggestion: `Boilerplate phrase repeated ${phraseSpans.length}× — replace at least one with specifics`,
2895        });
2896      }
2897    }
2898    if (distinctPhrasesHit >= 3) {
2899      issues.push({
2900        type: 'tier3-phrase-cluster',
2901        text: `${distinctPhrasesHit} distinct boilerplate phrases`,
2902        severity: 'high',
2903        suggestion: 'Several stock crypto/web3 phrases stacked in one piece. Rewrite around one specific claim or observation.',
2904      });
2905    }
2906
2907    // ── Hashtag stuffing ─────────────────────────────────────────
2908    // 6+ hashtags in a single post is rare for thoughtful humans and
2909    // near-universal for LLM-generated social posts. Counted globally,
2910    // not per-paragraph, since the trailing hashtag block is the shape
2911    // we care about.
2912    // Match #tag at start of text or after any non-word char (whitespace,
2913    // punctuation, line breaks). URL fragments are already excluded
2914    // because the char immediately before `#` in a URL path is always
2915    // a word char (e.g. `example.com/page#section` — `e` before `#`).
2916    // Earlier char class `[\s\\]` had a literal backslash and silently
2917    // missed hashtags after sentence punctuation; an interim `[\s]` fix
2918    // on origin only caught whitespace-preceded tags.
2919    // Code is masked and non-tag `#` forms are subtracted first — see maskCode
2920    // and isSocialTag. Without them a changelog paragraph citing six issue
2921    // numbers, or a palette listing six hex colours, scored as a tag block.
2922    const hashtagMatches = [...maskCode(text).matchAll(/(?:^|\W)#(\w[\w-]*)/g)]
2923      .filter((m) => isSocialTag(m[1]));
2924    if (hashtagMatches.length >= 6) {
2925      issues.push({
2926        type: 'hashtag-stuff',
2927        text: `${hashtagMatches.length} hashtags`,
2928        severity: 'medium',
2929        suggestion: 'Cut to 2-3 specific tags or none. Long hashtag blocks read as bot output.',
2930      });
2931    }
2932
2933    // ── Bullet list of bare noun phrases ─────────────────────────
2934    // ≥5 consecutive bullet items that are short (≤6 words) and contain
2935    // no finite-verb / modal token. Catches the "Stable mining efficiency
2936    // / Reliable pool connectivity / Optimized RandomX performance ..."
2937    // shape LLMs default to. Markdown bullets, escaped Markdown bullets,
2938    // unicode bullets, and dashes are all matched. Numbered lists are
2939    // excluded — those have a separate "numbered list inflation" rule.
2940    //
2941    // Note: verbRe covers auxiliaries and modals ("was", "will", "can",
2942    // etc.). Regular past-tense verbs ("fixed", "removed") are not
2943    // matched here; instead, the ≤6-word length gate excludes most
2944    // real-world changelog lines, which tend to read "fixed the X that
2945    // was doing Y" (>6 words). Short two-word action items ("* fixed
2946    // bug") would pass both gates — an acceptable trade-off to avoid
2947    // false-negative risk from adjectives ending in -ed ("skilled",
2948    // "advanced") that share the same surface form.
2949    const lines = text.split(/\r?\n/);
2950    const parseBullet = (line) => {
2951      let cursor = 0;
2952      while (cursor < line.length && /\s/.test(line[cursor])) cursor += 1;
2953      if (!['*', '-', '•', '+'].includes(line[cursor])) return null;
2954      cursor += 1;
2955      const spacingStart = cursor;
2956      while (cursor < line.length && /\s/.test(line[cursor])) cursor += 1;
2957      if (cursor === spacingStart) return null;
2958      if (cursor >= line.length) return cursor - spacingStart >= 2 ? '' : null;
2959      return line.slice(cursor).trim();
2960    };
2961    const verbRe = /\b(?:is|are|was|were|has|have|had|will|would|should|must|do|does|did|can|could|may|might|am|been|being)\b/i;
2962    const fenceRe = /^\s*(?:```|~~~)/;
2963    let run = [];
2964    let blankStreak = 0;
2965    let inFence = false;
2966    function flushRun() {
2967      if (run.length >= 5) {
2968        const bareNP = run.filter((it) => {
2969          const wc = (it.match(/\S+/g) || []).length;
2970          return wc > 0 && wc <= 6 && !verbRe.test(it);
2971        });
2972        if (bareNP.length >= 5 && bareNP.length / run.length >= 0.75) {
2973          issues.push({
2974            type: 'bullet-np-list',
2975            text: `${run.length}-item bullet list of bare noun phrases`,
2976            severity: 'high',
2977            suggestion: 'Convert to a prose paragraph or merge items. Long lists of bare adj+noun pairs read as AI scaffolding.',
2978          });
2979        }
2980      }
2981      run = [];
2982      blankStreak = 0;
2983    }
2984    for (const line of lines) {
2985      if (fenceRe.test(line)) {
2986        // Code-fence toggle. Bullets inside fences are CLI flag docs or
2987        // option dumps, not prose AI scaffolding — flush any prose run
2988        // we were tracking and skip until the fence closes.
2989        flushRun();
2990        inFence = !inFence;
2991        continue;
2992      }
2993      if (inFence) continue;
2994      const bullet = parseBullet(line);
2995      if (bullet !== null) {
2996        run.push(bullet);
2997        blankStreak = 0;
2998      } else if (line.trim() === '') {
2999        // A single blank line inside a list is normal Markdown spacing;
3000        // two or more blank lines break the run, since visually-disjoint
3001        // bullet sections shouldn't merge into one logical list.
3002        blankStreak++;
3003        if (blankStreak >= 2) flushRun();
3004      } else {
3005        flushRun();
3006      }
3007    }
3008    flushRun();
3009
3010    // NOTE: "Wall-of-text replies" (SKILL.md) is deliberately NOT a
3011    // detector rule here. A first pass tried "reply-length text, >=4
3012    // sentences, zero newlines" as a structural gate — it broke the
3013    // "repeated Tier 1 phrase does not inflate score linearly" fixture
3014    // and, on reflection, would fire on any ordinary short paragraph
3015    // (a blog intro, a single-paragraph email) since "one paragraph with
3016    // no internal line break" is simply what continuous prose looks
3017    // like, not an AI-specific shape. The tell in SKILL.md depends on
3018    // knowing the text is conversational-reply register in the first
3019    // place, which the engine can't reliably infer from the bytes alone
3020    // (CONTRIBUTING.md: "a signal that fires on most normal prose is not
3021    // worth adding"). Left as an LLM-judgment rule; see CATEGORIES.md §C.
3022
3023    // Confidence calibration is only flagged when it stacks (3+ instances).
3024    // Gating happens pre-dedup on raw match count, since that signals actual
3025    // stacking, not just vocabulary use.
3026    const confIssues = matchPatterns(text, CONFIDENCE_CALIBRATION, 'confidence-calibration', 'low');
3027    if (confIssues.length >= 3) issues.push(...confIssues);
3028
3029    // ── 22. Em dash frequency ────────────────────────────────────
3030    // Match real em dashes, plus `--` only when surrounded by whitespace on at
3031    // least one side (skips CLI flags like --save-dev and YAML `---` blocks).
3032    // Separator-position em dashes (SEPARATOR_DASH_RE above) are excluded
3033    // from the rate. The list marker is required on purpose: a line-initial
3034    // "**Bold lead** — full sentence" outside a list is itself an AI tell
3035    // and still counts, as does a mid-sentence "**bold** — like this"
3036    // splice. Em dash only — the `--` substitute is never carved out.
3037    const rawEmDashCount = (text.match(/—|(?<=\s)--(?=\s|$)|(?<=^|\s)--(?=\s)/gm) || []).length;
3038    const separatorDashCount = (text.match(SEPARATOR_DASH_RE) || []).length
3039      + countVersionHeadingDashes(text);
3040    const emDashCount = rawEmDashCount - separatorDashCount;
3041    const emDashRate = emDashCount / (wordCount / 1000);
3042    if (emDashRate > 1) {
3043      issues.push({
3044        type: 'em-dash',
3045        text: `${emDashCount} em dashes in ${wordCount} words`,
3046        severity: 'medium',
3047        suggestion: 'Replace with commas, periods, or rewrite',
3048      });
3049    }
3050
3051    // ── 23. Sentence length uniformity ───────────────────────────
3052    if (sentences.length >= 5) {
3053      const lengths = sentences.map(s => countWords(s));
3054      const avg = lengths.reduce((a, b) => a + b, 0) / lengths.length;
3055      const variance = lengths.reduce((sum, l) => sum + Math.pow(l - avg, 2), 0) / lengths.length;
3056      const stdDev = Math.sqrt(variance);
3057      const cv = avg > 0 ? stdDev / avg : 0;
3058
3059      if (cv < 0.25 && avg > 10) {
3060        issues.push({
3061          type: 'uniformity',
3062          text: `Sentence lengths cluster around ${Math.round(avg)} words (low variation)`,
3063          severity: 'medium',
3064          suggestion: 'Mix short punchy sentences with longer flowing ones',
3065        });
3066      }
3067    }
3068
3069    // ── Type-token ratio (stylometric — vocabulary diversity) ────
3070    // TTR = distinct word types / total tokens, taken over each 200-token
3071    // window and averaged (movingAverageTTR). Whole-text TTR falls with
3072    // length whoever wrote the text: on the human documents in corpus/ its
3073    // median is 0.63 at 200 tokens, 0.37 at 2,000 and 0.28 at 6,000, so a
3074    // fixed threshold on it flagged every 6,000-word public-domain slice.
3075    // The windowed median stays between 0.62 and 0.64 at every length.
3076    // Within a window, human prose typically sits around 0.50–0.65 for
3077    // English; AI prose tends flatter (0.55–0.75 looks normal, but the
3078    // lower end of the *too-flat* tail at >=200 words is where the signal
3079    // lives — too FEW unique words for the length). This is the simplest
3080    // of the four stylometric signals identified in the May 2026 detection-
3081    // research review: no POS tagger required, no model, pure JS.
3082    //
3083    // Threshold tuning: flag only when the sample is large enough
3084    // that low TTR is meaningfully suspicious (>=200 tokens) AND TTR
3085    // is below 0.40 (very vocabulary-poor). Conservative on purpose;
3086    // false positives on short or topic-narrow human prose are easy
3087    // to trigger and would drown out other signals. The detector-
3088    // research lens flagged TTR as one of four stylometric add-ons.
3089    // One of the other three has since shipped in approximated form:
3090    // `cross-para-burstiness` covers sentence-length burstiness across
3091    // paragraphs. `fnword-trigram-entropy` is a related tagger-free
3092    // signal (it approximates POS-trigram entropy, not one of the
3093    // three). POS-bigram log-odds and function-word z-scores are
3094    // still TODO.
3095    if (tokens.length >= 200) {
3096      const diversity = movingAverageTTR(tokens, 200);
3097      if (diversity < 0.4) {
3098        issues.push({
3099          type: 'low-ttr',
3100          text: `Vocabulary diversity ${(diversity * 100).toFixed(1)}% (distinct words per 200-token window, ${tokens.length} tokens)`,
3101          severity: 'low',
3102          suggestion: 'Text reuses a narrow word set. Vary nouns and verbs deliberately, or check if the topic genuinely warrants the repetition.',
3103        });
3104      }
3105    }
3106
3107    // ── 24. Paragraph length uniformity ──────────────────────────
3108    if (paragraphs.length >= 4) {
3109      const paraLengths = paragraphs.map(p => getSentences(p).length);
3110      const avg = paraLengths.reduce((a, b) => a + b, 0) / paraLengths.length;
3111      const allSimilar = paraLengths.every(l => Math.abs(l - avg) <= 1);
3112      if (allSimilar && avg >= 3) {
3113        issues.push({
3114          type: 'uniformity',
3115          text: `All paragraphs are ~${Math.round(avg)} sentences`,
3116          severity: 'low',
3117          suggestion: 'Vary paragraph length deliberately',
3118        });
3119      }
3120    }
3121
3122    // ── 25. Bold overuse ─────────────────────────────────────────
3123    const boldMatches = text.match(/\*\*[^*]+\*\*/g) || [];
3124    if (boldMatches.length > 3) {
3125      issues.push({
3126        type: 'formatting',
3127        text: `${boldMatches.length} bold phrases`,
3128        severity: 'medium',
3129        suggestion: 'Strip bold from most; restructure to lead with key info',
3130      });
3131    }
3132
3133    // ── Score from the deduped issue list ───────────────────────
3134    // Previously rawScore was accumulated inline per pattern hit, so
3135    // repeated hits of the same phrase (or overlapping matches) inflated
3136    // the score while the displayed issue list was deduplicated. That
3137    // produced the UX regression where a "heavy AI patterns" label sat
3138    // above a list of two items. Now the dedup runs first, then each
3139    // distinct issue contributes its category weight — so the number
3140    // reflects the same signals the user actually sees.
3141    // The staged-discovery phrase can contain the older "the most interesting
3142    // part" flatline match or sentence-initial "Turns out". Report the
3143    // enclosing signal once while leaving unrelated findings intact.
3144    const stagedDiscoverySpans = stagedDiscoveryIssues
3145      .map((issue) => ({ start: issue.index, end: issue.index + issue.text.length }));
3146    const nonOverlappingIssues = issues.filter((issue) =>
3147      (issue.type !== 'emotional-flatline' && issue.type !== 'performed-insight') ||
3148      stagedDiscoveryIssues.includes(issue) ||
3149      !Number.isInteger(issue.index) ||
3150      !stagedDiscoverySpans.some((span) =>
3151        issue.index >= span.start && issue.index + issue.text.length <= span.end
3152      )
3153    );
3154    const deduped = deduplicateIssues(nonOverlappingIssues);
3155    for (const issue of deduped) {
3156      rawScore += ISSUE_WEIGHTS[issue.type] ?? 2;
3157    }
3158
3159    // Scale by text length: longer text gets more chances to trigger.
3160    const lengthFactor = Math.max(1, Math.log2(wordCount / 50));
3161    const normalizedScore = Math.min(100, Math.round(rawScore / lengthFactor));
3162
3163    const label = getLabel(normalizedScore);
3164
3165    // ── Sentence-region smoothing (HMM-style without an HMM) ─────────
3166    // Map each text-bearing issue back to its sentence indexes, then
3167    // merge adjacent flagged sentences into contiguous regions for UI
3168    // highlighting. Borrowed from GPTZero's sentence-highlighting model
3169    // — gives users "this paragraph is AI" rather than scattered hits.
3170    const regions = buildSentenceRegions(text, deduped, sourceMode === 'rendered-markdown');
3171
3172    // Stats derived from the same deduped list so tier counts + patternCount
3173    // sum to `deduped.length`. Previously patternCount subtracted
3174    // `tier2Clusters` (a paragraph count) which produced inconsistent totals.
3175    const tier1Count = deduped.filter((i) => i.type === 'tier1').length;
3176    const tier2Count = deduped.filter((i) => i.type === 'tier2').length;
3177    const tier3Count = deduped.filter((i) => i.type === 'tier3').length;
3178
3179    // ── Trinary classification (GPTZero-shaped) ──────────────────────
3180    // Decouples confidence from AI-proportion. Maps the 0-100 score plus
3181    // structural signals into HUMAN_ONLY / MIXED / AI_ONLY with a
3182    // confidence band. Thresholds are FN-biased: ambiguity routes to
3183    // MIXED, never AI_ONLY. Quote from GPTZero's design principle:
3184    // "biases the detector to prefer making less-harmful false-negative
3185    // errors over false-positive errors."
3186    // Dense-AI-vocab trifecta: ≥5 distinct tier1 hits + ≥2 tier2 cluster
3187    // paragraphs + ≥1 transition phrase, AND ≥150 words. Catches
3188    // saturated ChatGPT prose without firing on dense-jargon human
3189    // technical writing where the tier1 vocabulary (robust,
3190    // comprehensive, leverage, ecosystem) legitimately overlaps with
3191    // systems-programming idiom. Word-count gate prevents short ESL or
3192    // contrived adversarial sentences from tripping the corroborator.
3193    const tier1Distinct = new Set(deduped.filter((i) => i.type === 'tier1').map((i) => (i.text || '').toLowerCase())).size;
3194    const hasTier2Cluster = tier2Clusters >= 2;
3195    const hasTransition = deduped.some((i) => i.type === 'transition');
3196    const denseAIVocab = wordCount >= 150 && tier1Distinct >= 5 && hasTier2Cluster && hasTransition;
3197
3198    const trinary = classifyTrinary({
3199      score: normalizedScore,
3200      issues: deduped,
3201      regions,
3202      normFlags: norm.flags,
3203      wordCount,
3204      denseAIVocab,
3205    });
3206
3207    // Translate both dense issue indexes and half-open highlight boundaries.
3208    // Mapping the region end from its final retained code unit avoids pulling
3209    // a later removed roleplay marker into the highlighted source slice.
3210    remapFindingsToSource(deduped, regions, sourceMap);
3211
3212    return {
3213      // Legacy fields preserved for existing callers.
3214      score: normalizedScore,
3215      label,
3216      issues: deduped,
3217      stats: {
3218        wordCount,
3219        tier1Count,
3220        tier2Count,
3221        tier2Clusters,
3222        tier3Count,
3223        tier3Flags,
3224        patternCount: deduped.length - tier1Count - tier2Count - tier3Count,
3225        contextMode,
3226        contextModeFallback,
3227        sourceMode,
3228        sourceModeFallback,
3229        maskedFrontmatter,
3230        maskedHtmlComments,
3231        ignoredRegions,
3232        normalization: norm.flags,
3233        quotedLines,
3234        maskedQuotes,
3235        unmappedHighlights: regions._unmapped ?? 0,
3236        denseAIVocab,
3237        tier1Distinct,
3238      },
3239      // Trinary API — shape mirrors GPTZero so integrators can swap.
3240      document_classification: trinary.classification,
3241      class_probabilities: trinary.probabilities,
3242      confidence_category: trinary.confidence,
3243      highlight_sentence_for_ai: regions,
3244    };
3245  }
3246
3247  // ═══ Sentence regions + trinary classifier ═════════════════════════
3248
3249  // Coarse sentence spans over the whole text, as [start, end) offsets.
3250  // Produces the same spans as the former /[^.!?]+[.!?]+|\S[^.!?]*$/g scan:
3251  // each span runs from the end of the previous one through the next run of
3252  // terminators, and a trailing fragment with no terminator starts at its
3253  // first non-space character. The regex version backtracked to the end of
3254  // the input at every position of a long terminator-free run, so a document
3255  // that ended in blank lines, or whose masked comments became whitespace,
3256  // cost O(n^2) (#235). This scan touches each character a bounded number
3257  // of times.
3258  const SENTENCE_TERMINATOR_RUN = /[.!?]+/g;
3259  const FIRST_NON_SPACE = /\S/g;
3260  function splitSentenceSpans(text) {
3261    const spans = [];
3262    const length = text.length;
3263    let pos = 0;
3264    while (pos < length) {
3265      SENTENCE_TERMINATOR_RUN.lastIndex = pos;
3266      const run = SENTENCE_TERMINATOR_RUN.exec(text);
3267      if (run === null) {
3268        FIRST_NON_SPACE.lastIndex = pos;
3269        const head = FIRST_NON_SPACE.exec(text);
3270        if (head !== null) spans.push([head.index, length]);
3271        break;
3272      }
3273      if (run.index === pos) {
3274        // Skip the entire bodyless run, not one character at a time: matching
3275        // every remaining suffix would make a long punctuation run quadratic.
3276        // If no later sentence terminator exists, the former regex's trailing
3277        // alternative starts at the LAST terminator of this run.
3278        const runEnd = pos + run[0].length;
3279        SENTENCE_TERMINATOR_RUN.lastIndex = runEnd;
3280        if (SENTENCE_TERMINATOR_RUN.exec(text) === null) {
3281          spans.push([runEnd - 1, length]);
3282          break;
3283        }
3284        pos = runEnd;
3285        continue;
3286      }
3287      const end = run.index + run[0].length;
3288      spans.push([pos, end]);
3289      pos = end;
3290    }
3291    return spans;
3292  }
3293
3294  function buildSentenceRegions(text, issues, trimBoundaryWhitespace = false) {
3295    // Split text into sentences with source offsets preserved so the UI
3296    // can highlight spans accurately. Sentence boundaries are coarse
3297    // (.!?) — fine for highlighting, not for linguistic correctness.
3298    const sentences = [];
3299    for (const [spanStart, spanEnd] of splitSentenceSpans(text)) {
3300      const raw = text.slice(spanStart, spanEnd);
3301      const sentenceText = raw.trim();
3302      if (sentenceText.length < 4) continue;
3303      let start = spanStart;
3304      let end = spanEnd;
3305      if (trimBoundaryWhitespace) {
3306        // trimStart/trimEnd, not `\s*$`: that regex retries from every
3307        // position of a leading whitespace run and was quadratic on a span
3308        // that began with a masked comment block (#235).
3309        start += raw.length - raw.trimStart().length;
3310        end -= raw.length - raw.trimEnd().length;
3311      }
3312      sentences.push({ start, end, text: sentenceText });
3313    }
3314    if (sentences.length === 0) return [];
3315
3316    // Map issue.text back to sentence indexes via substring search. Two
3317    // kinds of issue stay out of the AI-highlight regions. Summary signals
3318    // like "Punctuation density uniform across paragraphs" have no sentence
3319    // anchor — they contribute to the document-level signal but not to
3320    // highlights. Any category with authorship weight 0 is style-only by
3321    // definition, so it belongs in issues[] but never in a field reserved
3322    // for AI sentence highlights.
3323    // Filter by issue TYPE not text-regex: text-based filtering used to
3324    // drop legitimate phrase issues containing "across" / "density".
3325    const NON_HIGHLIGHT_TYPES = new Set([
3326      'punct-distribution',
3327      'cross-para-burstiness',
3328      'fnword-trigram-entropy',
3329      'smart-punct-signature',
3330      'normalization-flag',
3331      'uniformity',
3332      'em-dash',
3333      'formatting',
3334      'tier3',
3335      'tier3-phrase',
3336      'tier3-phrase-cluster',
3337      'hashtag-stuff',
3338      'bullet-np-list',
3339      'unnecessary-hyphenation',
3340    ]);
3341    const hits = sentences.map(() => ({ count: 0, weight: 0 }));
3342    const lowerText = text.toLowerCase();
3343    let unmappedHighlights = 0;
3344    for (const issue of issues) {
3345      if (!issue.text || issue.text.length > 200) continue;
3346      if (NON_HIGHLIGHT_TYPES.has(issue.type)) continue;
3347      if ((ISSUE_WEIGHTS[issue.type] ?? 2) === 0) continue;
3348      const needle = issue.text.toLowerCase();
3349      let idx = 0;
3350      let matched = false;
3351      while ((idx = lowerText.indexOf(needle, idx)) !== -1) {
3352        // Deduplicated verb issues must not highlight skipped noun matches.
3353        // Reuse the same predicate and retain all qualifying verb locations.
3354        if (issue.type === 'tier1-clarity' && needle === 'features' && featuresIsNoun(text, idx)) {
3355          idx += needle.length;
3356          continue;
3357        }
3358        matched = true;
3359        for (let i = 0; i < sentences.length; i++) {
3360          if (idx >= sentences[i].start && idx < sentences[i].end) {
3361            hits[i].count++;
3362            hits[i].weight += ISSUE_WEIGHTS[issue.type] ?? 2;
3363            break;
3364          }
3365        }
3366        idx += needle.length;
3367      }
3368      if (!matched) unmappedHighlights++;
3369    }
3370
3371    // Window-merge contiguous flagged sentences. Allow 1 unflagged
3372    // sentence gap between two flagged ones (the "smoothing" — keeps
3373    // a single boring sentence from breaking what's clearly an AI
3374    // passage). A sentence is "flagged" if it has ≥1 hit.
3375    const regions = [];
3376    let cur = null;
3377    for (let i = 0; i < sentences.length; i++) {
3378      if (hits[i].count > 0) {
3379        if (cur === null) {
3380          cur = { startSentence: i, endSentence: i, start: sentences[i].start, end: sentences[i].end, hitCount: hits[i].count, weight: hits[i].weight };
3381        } else {
3382          cur.endSentence = i;
3383          cur.end = sentences[i].end;
3384          cur.hitCount += hits[i].count;
3385          cur.weight += hits[i].weight;
3386        }
3387      } else if (cur !== null) {
3388        // Allow one-sentence gap.
3389        const next = hits[i + 1];
3390        if (next && next.count > 0) {
3391          cur.endSentence = i;
3392          cur.end = sentences[i].end;
3393          continue;
3394        }
3395        regions.push(finalizeRegion(cur));
3396        cur = null;
3397      }
3398    }
3399    if (cur !== null) regions.push(finalizeRegion(cur));
3400    // Expose the unmapped-highlight count via a non-enumerable property
3401    // so the array length still reads naturally for consumers; the
3402    // analyzer pulls it into stats.unmappedHighlights for diagnostics.
3403    Object.defineProperty(regions, '_unmapped', { value: unmappedHighlights, enumerable: false });
3404    return regions;
3405  }
3406
3407  function finalizeRegion(r) {
3408    // Map cumulative weight inside the region to a 0-1 score. Cap at 20
3409    // weight = 1.0 (matches Heavy threshold density).
3410    const score = Math.min(1, r.weight / 20);
3411    return {
3412      startSentence: r.startSentence,
3413      endSentence: r.endSentence,
3414      start: r.start,
3415      end: r.end,
3416      hitCount: r.hitCount,
3417      score: Math.round(score * 100) / 100,
3418    };
3419  }
3420
3421  // FN-biased: false positives damage trust more than false negatives,
3422  // so MIXED is wide and AI_ONLY requires multiple signals. Quote from
3423  // GPTZero: "biases the detector to prefer making less-harmful
3424  // false-negative errors over false-positive errors."
3425  function classifyTrinary({ score, issues, regions, normFlags, wordCount, denseAIVocab }) {
3426    // Strong corroborators — each is near-dispositive on its own:
3427    //   - cutoff-disclaimer (LLM self-identifies as an AI)
3428    //   - reasoning-artifact + chatbot-artifact co-occurrence
3429    //   - normalization-flag at threshold (≥2 ZWSP or homoglyphs).
3430    //     Threshold parity prevents a single stray ZWSP in copy-paste
3431    //     from Word/Notion from flipping to AI_ONLY at score 0.
3432    //   - denseAIVocab: ≥4 distinct tier1 hits AND ≥1 tier2 cluster AND
3433    //     ≥1 transition phrase — the trifecta that saturated ChatGPT
3434    //     prose triggers without needing whitelisted stylometric hits.
3435    const hasCutoff = issues.some((i) => i.type === 'cutoff-disclaimer');
3436    const hasNormFlag = normFlags.zeroWidth >= 2 || normFlags.homoglyph >= 2;
3437    const hasReasoning = issues.some((i) => i.type === 'reasoning-artifact');
3438    const hasChatbot = issues.some((i) => i.type === 'chatbot');
3439    const strongCorrob =
3440      (hasCutoff ? 1 : 0) +
3441      (hasNormFlag ? 1 : 0) +
3442      (hasReasoning && hasChatbot ? 1 : 0) +
3443      (denseAIVocab ? 1 : 0);
3444
3445    // Weak (stylometric) corroborators — suggestive on their own,
3446    // dispositive in combination. Smart-punct-signature matches
3447    // Word-edited human prose so doesn't count without other support.
3448    const stylometricHits = ['punct-distribution', 'cross-para-burstiness', 'fnword-trigram-entropy']
3449      .filter((t) => issues.some((i) => i.type === t)).length;
3450    const hasSmartPunct = issues.some((i) => i.type === 'smart-punct-signature');
3451    const weakCorrob = (stylometricHits >= 2 ? 1 : 0) + (hasSmartPunct ? 1 : 0);
3452
3453    // Thresholds:
3454    //   score < 15 with no strong → HUMAN_ONLY
3455    //   strong ≥ 1 OR score ≥ 70 → AI_ONLY (lowered from 80; high
3456    //     density of AI vocab is sufficient evidence)
3457    //   score ≥ 40 with any corroborator → AI_ONLY
3458    //   everything else with score ≥ 15 → MIXED
3459    const totalCorrob = strongCorrob + weakCorrob;
3460    let classification;
3461    if (score < 15 && strongCorrob === 0) classification = 'HUMAN_ONLY';
3462    else if (strongCorrob >= 1 || score >= 70) classification = 'AI_ONLY';
3463    else if (score >= 40 && totalCorrob >= 1) classification = 'AI_ONLY';
3464    else classification = 'MIXED';
3465
3466    // Humanizer-flag escalation: presence of bypass-trick chars is
3467    // adversarial signal. If a normalization-flag fired we already
3468    // counted it in strongCorrob → AI_ONLY. Confidence also gets a
3469    // floor of 'medium' in that case (an adversary actively evading
3470    // detection should never read as low-confidence noise).
3471
3472    // Soft probability distribution. Hand-tuned, not calibrated
3473    // against the labeled corpora the repo now samples
3474    // (`scripts/dataset-hc3.js`, `scripts/dataset-raid.js`). Largest
3475    // class is computed as `1 - others` after rounding to guarantee
3476    // sum=1 exactly. Sub-1% drift would otherwise hide in toFixed.
3477    const aiSoft = Math.min(0.97, score / 100 + totalCorrob * 0.06 + strongCorrob * 0.08);
3478    let p;
3479    if (classification === 'HUMAN_ONLY') p = { human: Math.max(0.6, 1 - aiSoft), mixed: Math.min(0.35, aiSoft * 0.8), ai: Math.min(0.1, aiSoft * 0.3) };
3480    else if (classification === 'AI_ONLY') p = { human: Math.max(0.02, 1 - aiSoft - 0.05), mixed: 0.1, ai: aiSoft };
3481    else p = { human: Math.max(0.15, 0.6 - aiSoft * 0.5), mixed: 0.5, ai: aiSoft * 0.7 };
3482    const rawSum = p.human + p.mixed + p.ai;
3483    p.human = +(p.human / rawSum).toFixed(3);
3484    p.mixed = +(p.mixed / rawSum).toFixed(3);
3485    // Assign ai as the remainder so the three values sum to exactly 1.
3486    // Clamp to >= 0 in case rounding pushes human+mixed above 1 (the
3487    // remainder would otherwise show as -0 or -0.001 — surfaces as a
3488    // negative percentage in any UI doing Math.round(p.ai * 100)).
3489    p.ai = Math.max(0, +(1 - p.human - p.mixed).toFixed(3));
3490    const probabilities = p;
3491
3492    // Confidence band:
3493    //   high   — strongCorrob ≥ 2, OR cutoff-disclaimer, OR score < 8 (clean long doc)
3494    //   medium — strongCorrob ≥ 1, OR score ≥ 45 with weak corroborator, OR score < 20
3495    //   low    — everything else
3496    let confidence;
3497    if (strongCorrob >= 2 || hasCutoff || (score < 8 && wordCount >= 100)) confidence = 'high';
3498    else if (strongCorrob >= 1 || (score >= 45 && weakCorrob >= 1) || score < 20) confidence = 'medium';
3499    else confidence = 'low';
3500
3501    return { classification, probabilities, confidence };
3502  }
3503
3504  function getLabel(score) {
3505    if (score === 0) return 'Clean';
3506    if (score <= 15) return 'Minimal AI signals';
3507    if (score <= 35) return 'Some AI patterns';
3508    if (score <= 60) return 'Moderate AI signals';
3509    if (score <= 80) return 'Strong AI signals';
3510    return 'Heavy AI patterns';
3511  }
3512
3513  function getColor(score) {
3514    if (score <= 15) return '#44bb66';
3515    if (score <= 35) return '#88bb44';
3516    if (score <= 60) return '#ddaa00';
3517    if (score <= 80) return '#ff8833';
3518    return '#ff4444';
3519  }
3520
3521  function deduplicateIssues(issues) {
3522    const seen = new Set();
3523    return issues.filter(issue => {
3524      const key = `${issue.type}:${issue.text.toLowerCase()}`;
3525      if (seen.has(key)) return false;
3526      seen.add(key);
3527      return true;
3528    });
3529  }
3530
3531  // ─── Severity labels ──────────────────────────────────────────
3532  const SEVERITY_LABELS = {
3533    critical: 'P0',
3534    high: 'P1',
3535    medium: 'P2',
3536    low: 'P3',
3537  };
3538
3539  const TYPE_LABELS = {
3540    'tier1': 'AI vocabulary',
3541    'tier1-clarity': 'Wordiness',
3542    'tier2': 'Word cluster',
3543    'tier3': 'Overused word',
3544    'transition': 'AI transition',
3545    'chatbot': 'Chatbot artifact',
3546    'sycophantic': 'Sycophantic tone',
3547    'filler': 'Filler phrase',
3548    'generic-conclusion': 'Generic conclusion',
3549    'lets-construction': '"Let\'s" opener',
3550    'reasoning-artifact': 'Reasoning artifact',
3551    'significance-inflation': 'Significance inflation',
3552    'vague-attribution': 'Vague attribution',
3553    'hollow-intensifier': 'Hollow intensifier',
3554    // Keep the public type stable for API consumers; the user-facing name now
3555    // describes the stock framing that the regexes actually match.
3556    'emotional-flatline': 'Stock reaction framing',
3557    'lingering-attention': 'Lingering-attention claim',
3558    'novelty-inflation': 'Novelty inflation',
3559    'cutoff-disclaimer': 'Cutoff disclaimer',
3560    'template-phrase': 'Template phrase',
3561    'false-concession': 'False concession',
3562    'rhetorical-question': 'Rhetorical question',
3563    'confidence-calibration': 'Confidence stacking',
3564    'em-dash': 'Em dash overuse',
3565    'uniformity': 'Rhythm uniformity',
3566    'formatting': 'Formatting',
3567    'tier3-phrase': 'Boilerplate phrase',
3568    'tier3-phrase-cluster': 'Boilerplate cluster',
3569    'hashtag-stuff': 'Hashtag stuffing',
3570    'bullet-np-list': 'Bullet-NP list',
3571    'hedge-stack': 'Hedge-stacked prediction',
3572    'future-narrative': 'Generic future narrative',
3573    'real-actual-inflation': '"Real/actual" inflation',
3574    'social-cta-closer': 'Engagement-bait closer',
3575    'formulaic-opener': 'Formulaic opener',
3576    'speculative-opener': 'Speculative scenario opener',
3577    'launch-intro': 'Launch-copy introduction',
3578    'crowd-contrast': 'Dramatized crowd contrast',
3579    'fake-casual-prop': 'Fake-casual prop',
3580    'title-case-header': 'Title Case header',
3581    'parenthetical-hedge': 'Parenthetical hedge',
3582    'smart-punct-signature': 'Smart-punct signature',
3583    'punct-distribution': 'Punctuation distribution',
3584    'fnword-trigram-entropy': 'Grammar repetition',
3585    'cross-para-burstiness': 'Cross-paragraph rhythm',
3586    'normalization-flag': 'Bypass-trick chars',
3587    'low-ttr': 'Low vocabulary diversity',
3588    'ai-placeholder': 'Unfilled placeholder',
3589    'ai-citation-markup': 'Chatbot citation markup leak',
3590    'ai-utm-source': 'AI-tool URL parameter',
3591    'unnecessary-hyphenation': 'Unnecessary hyphenation',
3592    'performed-insight': 'Performed-insight phrase',
3593    'negation-chain': 'Negation chain',
3594    'negative-parallelism': 'Negative parallelism',
3595    'dev-blog-boilerplate': 'Dev-blog boilerplate',
3596  };
3597
3598  return {
3599    analyzeText,
3600    normalizeText,
3601    getLabel,
3602    getColor,
3603    SEVERITY_LABELS,
3604    TYPE_LABELS,
3605  };
3606})();
3607
3608
3609export default AIDetector;