humanizer-lint 1.3.0 → 1.4.1

package/README.md

@@ -4,9 +4,9 @@
 
 # humanizer-lint
 
-### Humanize AI-generated text with a deterministic local AI humanizer and anti-slop prose linter
+### Edit stiff AI-shaped prose with a deterministic local prose and rhythm linter
 
-Detect repetitive LLM phrasing, uniform sentence rhythm, structural clichés, and voice-profile drift across **8 built-in language packs plus 100+ Universal Stylometry languages** without sending text to an external service.
+Detect repetitive stock phrasing, uniform sentence rhythm, structural clichés, and voice-profile drift with **8 language-specific lexical and morphological packs plus universal `Intl.Segmenter` rhythm diagnostics for 100+ languages** without sending text to an external service.
 
 [![GitHub Release](https://img.shields.io/github/v/release/yanstd888/humanizer-lint?style=flat-square&logo=github)](https://github.com/yanstd888/humanizer-lint/releases)
 [![npm](https://img.shields.io/npm/v/humanizer-lint)](https://www.npmjs.com/package/humanizer-lint)
@@ -26,10 +26,10 @@ Detect repetitive LLM phrasing, uniform sentence rhythm, structural clichés, an
 
 **Summary**
 
-- Eliminates robotic LLM writing patterns when users ask to "humanize text", "remove AI slop", "fix uniform sentence rhythm", or "write natural blog, SEO, and documentation prose"
-- Provides mandatory `node <skill_dir>/scripts/analyze.mjs --stdin --json` verification and `npx humanizer-lint` CLI to enforce Burstiness (`CV >= 0.45`), Adjacent Rhythm Delta, and Adaptive `MATTR` vocabulary diversity
-- Ships with **8 deep anti-slop lexical & morphological rule packs** (`en`, `id`, `es`, `ms`, `fr`, `de`, `pt`, `zh`) plus **Universal Stylometric Mode** (`Intl.Segmenter`) for 100+ languages with zero external dependencies
-- Supports personal author voice cloning via `node <skill_dir>/scripts/fingerprint.mjs` and passes all 3 `skills.sh` security audits (Gen Agent Trust Hub, Socket, Snyk) with zero network calls
+- Flags repetitive AI stock phrases, flat sentence rhythm, and rigid translation patterns in blog posts, SEO articles, copy, and technical documentation.
+- Reports diagnostic CV, paragraph CV, adjacent rhythm delta, MATTR, n-gram repetition, and one-pass fix hints; these values are indicators, not mechanical style targets.
+- Ships **8 language-specific lexical and morphological packs** (`en`, `id`, `es`, `ms`, `fr`, `de`, `pt`, `zh`) plus universal `Intl.Segmenter` sentence-rhythm analysis for 100+ languages.
+- Supports local author voice profiling via `node <skill_dir>/scripts/fingerprint.mjs` and passes the listed skills.sh security audits with zero network text uploads.
 
 ```sh
 npx skills add yanstd888/humanizer-lint
@@ -39,6 +39,16 @@ Use the command above to install the agent skill. For one-off local linting, run
 
 **8-language summary:** EN — local AI text humanizer and prose linter. ID — humanizer bahasa Indonesia dan cek tulisan AI. ES — humanizador de texto IA y corrector de ritmo. MS — humanizer teks AI dan semak ayat. FR — humaniseur de texte IA et analyseur stylométrique. DE — KI-Text humanisieren und KI-Floskeln entfernen. PT — humanizador de texto IA e corretor de burstiness. ZH — AI文章人性化与句式节奏分析.
 
+## Verified benchmark
+
+Run `npm run benchmark` to reproduce the current 16-fixture benchmark on the local machine.
+
+| Fixtures | Accuracy | Mean AI score | Mean human score | Separation | Mean runtime |
+|---:|---:|---:|---:|---:|---:|
+| 16 (8 languages × AI/Human) | 100% | 26.00 | 100.00 | 74.00 points | ~0.40 ms / analysis |
+
+The benchmark measures deterministic fixture separation and runtime. It does not classify authorship.
+
 ## Try in your browser
 
 Use the official demo: [humanizer.aiclub.ai.id](https://humanizer.aiclub.ai.id).

package/SKILL.md

@@ -1,157 +1,104 @@
----
-name: humanizer-lint
-description: Deterministic multilingual AI text humanizer, anti-slop prose linter, copywriting/blog/SEO editor, and stylometric analyzer (EN, ID, ES, MS, FR, DE, PT, ZH + 100+ languages via Intl.Segmenter). Fixes robotic LLM tone, uniform sentence rhythm, low burstiness (CV), MATTR vocabulary repetition, and translationese clichés using a local zero-dependency Node.js CLI validator.
-summary: Deterministic closed-loop AI text humanizer and stylometric prose linter that enforces natural sentence burstiness, vocabulary diversity, and zero LLM clichés across 100+ languages.
-topic: agent-workflows
-tags:
-  - agent-workflows
-  - marketing
-  - copywriting
-  - seo
-  - writing
-  - ai-humanizer
-  - anti-slop
-  - prose-linter
-  - stylometry
-  - burstiness
-  - multilingual
-version: 1.3.0
-license: MIT
-compatibility: Node.js >= 18.3.0 (zero external dependencies)
-allowed-tools: Bash(node:*) Read Write
-metadata:
-  version: "1.3.0"
-  author: "yanstd888"
-  domain: "writing"
----
-
-# Humanizer Lint
-
-**Audit, lint, and humanize AI-generated prose across 100+ languages using deterministic local stylometric math before returning text to the user.**
-
-- Eliminates robotic LLM writing patterns when users ask to "humanize text", "remove AI slop", "fix uniform sentence rhythm", or "write natural blog, copywriting, SEO, and documentation prose"
-- Provides mandatory `node <skill_dir>/scripts/analyze.mjs --stdin --json` verification and `npx humanizer-lint` CLI to enforce Burstiness (`CV >= 0.45`), Adjacent Rhythm Delta, and Adaptive `MATTR` vocabulary diversity
-- Ships with **8 deep anti-slop lexical & morphological rule packs** (`en`, `id`, `es`, `ms`, `fr`, `de`, `pt`, `zh`) plus **Universal Stylometric Mode** (`Intl.Segmenter`) for 100+ languages with zero external dependencies
-- Supports personal author voice cloning via `node <skill_dir>/scripts/fingerprint.mjs` and passes all 3 `skills.sh` security audits (Gen Agent Trust Hub, Socket, Snyk) with zero network calls
-
-## When to use
-
-- Humanize agent-generated drafts, articles, essays, copywriting, and documentation in any language (`--lang auto`).
-- Audit and fix uniform sentence rhythm (low Burstiness $CV$ and monotonous 3-sentence windows).
-- Strip LLM stock phrases, filler transitions, and rigid translationese morphology (`EN`, `ID`, `ES`, `MS`, `FR`, `DE`, `PT`, `ZH`).
-- Match a user's personal writing style using a local voice fingerprint profile (`scripts/fingerprint.mjs`).
-- Verify edited prose deterministically (`PASS` / `FAIL`) before returning it to the user.
-
-## Supported Languages (Two-Tier Multilingual Architecture)
-
-- **Tier 1 — Full Lexical Anti-Slop + Stylometric Math (8 Languages):** `en` (English), `id` (Bahasa Indonesia), `es` (Español), `ms` (Bahasa Melayu), `fr` (Français), `de` (Deutsch), `pt` (Português), `zh` (中文 / Mandarin).
-- **Tier 2 — Universal Stylometric Engine (100+ Languages via `Intl.Segmenter`):** Automatic sentence-length Burstiness ($CV$), Adjacent Rhythm Delta ($\Delta_{adj}$), Adaptive $MATTR$, paragraph symmetry, starter repetition, and compression entropy for Latin, Cyrillic, Arabic, Japanese, Korean, Hindi, Turkish, Vietnamese, and other scripts via `--lang auto` or `--lang universal`.
-
-## Agent-SEO Trigger Intents & Search Keywords
-
-- **Core Humanizer & Anti-Slop:** `humanizer`, `ai humanizer`, `humanize text`, `anti-slop`, `remove ai slop`, `prose linter`, `stylometric linter`, `bypass robotic ai writing`, `burstiness checker`, `perplexity and burstiness`, `mattr lexical diversity`.
-- **Writing, Copywriting & Docs Workflows:** `writing assistant`, `copywriting linter`, `blog post writer`, `seo article humanizer`, `markdown prose linter`, `technical documentation editor`, `proofreading and editing`, `natural translation polishing`, `voice cloning stylometry`.
-- **Indonesian & Malay Intents:** `humanizer bahasa indonesia`, `cara agar tulisan ai tidak terdeteksi`, `perbaiki tulisan ai yang kaku`, `ubah teks chatgpt jadi natural`, `cek skor tulisan ai`, `parafrase anti-ai`, `semak ayat ai bahasa melayu`.
-- **Global Multilingual Intents:** `humanizador de texto ia` (ES/PT), `humaniseur de texte ia` (FR), `ki-text humanisieren` (DE), `消除AI味 / AI文章人性化` (ZH).
-
-Do not use it to alter code, commands, structured data, quotations, legal language, or factual identifiers. The sanitizer excludes common Markdown structures, but the agent must still preserve meaning and supported facts.
-
-## Prerequisites
-
-- Node.js 18.3 or newer.
-- Resolve this skill's installed directory as `<skill_dir>` at runtime.
-- Optional custom profile: `<skill_dir>/profiles/custom-voice.json`.
-
-## Closed-loop protocol
-
-### 1. Resolve context
-
-1. Resolve `<skill_dir>` from this `SKILL.md`; never assume the current working directory.
-2. Determine `auto`, `universal`, or a two-letter ISO 639-1 code. `auto` selects a bundled pack when evidence is strong; otherwise it uses `universal`.
-3. If `<skill_dir>/profiles/custom-voice.json` exists, pass it with `--profile`. Otherwise use the bundled default profile.
-4. Keep source facts, names, numbers, dates, quotations, citations, and technical terms unchanged unless the user explicitly requests a factual edit.
-
-Completion criterion: language, analyzer path, and optional profile path are known before drafting.
-
-### 2. Draft with asymmetric rhythm
-
-Write the first draft with concrete subjects and verbs. Mix short 2 to 6 word sentences with longer 26 to 38 word sentences where the meaning supports them. Avoid generic introductions and summary paragraphs that merely repeat earlier content.
-
-Do not distort meaning to hit a metric. Sentence-length variation must come from legitimate splitting, merging, or reordering of supported material.
-
-Completion criterion: the draft preserves every source claim and contains no invented detail.
-
-### 3. Run deterministic verification
-
-Prefer stdin so the target repository remains clean:
-
-```sh
-node <skill_dir>/scripts/analyze.mjs --stdin --lang auto --json
-```
-
-Pipe the complete draft to stdin. With a custom profile:
-
-```sh
-node <skill_dir>/scripts/analyze.mjs --stdin --lang auto --profile <skill_dir>/profiles/custom-voice.json --json
-```
-
-Never skip this command. Read `status`, `score`, `metrics`, and every item in `violations`.
-
-Completion criterion: a parseable JSON report exists for the exact draft being considered.
-
-### 4. Correct only flagged prose
-
-If `status` is `FAIL`:
-
-1. Group overlapping violations by paragraph. Whole-text statistical diagnostics (`LOW_BURSTINESS`, `MISSING_SENTENCE_RANGE`, `LOW_ADJACENT_DELTA`, and `LOW_LEXICAL_DIVERSITY`) identify the global gate when no single sentence is solely responsible.
-2. Edit only the cited sentences or paragraphs, or make the smallest whole-text rhythm correction named by a statistical diagnostic.
-3. Follow each `fixInstruction` without adding or dropping facts.
-4. Run the analyzer again on the complete revised draft.
-5. Stop after three analyzer iterations.
-
-If `status` is `SKIP`, statistical stylometry is unavailable. Fix any lexical violations that are still reported, preserve the short form, and state that the statistical gate was skipped because the text is too short.
-
-If the third iteration still returns `FAIL`, do not present the draft as verified. Return the remaining diagnostics and ask whether the user wants a broader rewrite.
-
-Completion criterion: return prose only after `PASS`, or an explicitly labeled short-text `SKIP` with no unresolved lexical violations.
-
-## Analyzer commands
-
-```sh
-node <skill_dir>/scripts/analyze.mjs --file draft.md --lang id --json
-node <skill_dir>/scripts/analyze.mjs --file draft.md --lang en
-node <skill_dir>/scripts/analyze.mjs --stdin --lang auto --json
-node <skill_dir>/scripts/fingerprint.mjs --input samples --output <skill_dir>/profiles/custom-voice.json
-```
-
-Exit codes:
-
-- `0`: `PASS` or `SKIP`.
-- `1`: analyzed successfully and returned `FAIL`.
-- `2`: invalid arguments, unreadable input, or malformed profile.
-
-## Pitfalls
-
-- A high score does not prove human authorship. It proves only that the configured checks passed.
-- Very short text cannot support statistical stylometry.
-- Technical, legal, and intentionally repetitive prose may require a custom profile.
-- Do not rewrite unflagged paragraphs merely to increase the score.
-- Do not treat `voiceProfileDeviation` as an authorship probability; it is a relative distance from the selected profile.
-
-## Verification
-
-Before returning revised prose:
-
-- [ ] Analyzer ran against the final exact text.
-- [ ] Final status is `PASS`, or an honest lexical-clean `SKIP` for short text.
-- [ ] No source fact, identifier, number, quotation, or citation changed unintentionally.
-- [ ] Only flagged prose was revised after the first analyzer pass.
-- [ ] No network service or external package was used.
-
-## Multilingual Agent-SEO Keyword Matrix
-
-- **Core:** `ai humanizer`, `ai text humanizer`, `prose linter`, `anti-slop skill`, `stylometric analyzer`, `burstiness checker`, `perplexity and burstiness optimizer`, `humanizer-lint`, `skills.sh humanizer`, `markdown prose linter`.
-- **Technical:** `sentence length variation`, `coefficient of variation (CV >= 0.45)`, `adjacent sentence rhythm delta`, `moving-average type-token ratio (MATTR)`, `zlib compression entropy`, `remove LLM clichés and stock phrases`, `fix robotic AI writing tone`, `bypass statistical AI writing patterns`, `author voice fingerprinting`, `deterministic local CLI text validator`.
-- **Workflows:** `writing assistant skill`, `copywriting linter`, `blog post humanizer`, `seo article editor`, `technical documentation linter`, `academic prose polisher`, `translationese remover`, `proofreading and editing workflow`, `claude code writing skill`, `cursor anti-slop rules`, `windsurf prose skill`, `codex writing skill`, `gemini cli humanizer`.
-- **ID / MS:** `humanizer bahasa indonesia`, `cek tulisan ai gratis`, `cara agar tulisan ai tidak terdeteksi`, `ubah tulisan chatgpt jadi natural manusia`, `perbaiki tulisan ai yang kaku`, `hilangkan kata klise ai`, `alat parafrase anti-ai`, `cek skor burstiness tulisan`, `humanizer artikel seo dan skripsi`, `semak ayat ai bahasa melayu`, `humanizer teks bahasa melayu`, `cara elak dikesan ai`.
-- **ES / FR / DE / PT / ZH:** `humanizador de texto ia gratis`, `quitar clichés de chatgpt`, `detector y corrector de ritmo de escritura ia`, `mejorar burstiness de textos`; `humaniseur de texte ia`, `corriger le style robotique chatgpt`, `analyseur stylométrique de prose`, `supprimer le jargon ia`; `ki-text humanisieren kostenlos`, `chatgpt texte menschlicher machen`, `stilometrische textanalyse`, `ki-floskeln entfernen`; `humanizador de texto ia gratuito`, `deixar texto do chatgpt mais humano`, `corretor de estilo e burstiness`, `remover clichês de ia`; `AI文章人性化`, `消除AI写作痕迹`, `去除AI味工具`, `ChatGPT文本润色与句式节奏分析`, `降低AI率`.
+---
+name: humanizer-lint
+description: Deterministic prose linter, AI writing style editor, and stylometric rhythm analyzer for natural copywriting, blog posts, SEO articles, and technical documentation. Provides 8 anti-cliché rule packs (EN, ID, ES, MS, FR, DE, PT, ZH) and universal sentence-rhythm diagnostics for 100+ languages via local Node.js CLI.
+summary: Local deterministic prose, copywriting, and code-comment linter with 8 lexical anti-cliché packs and universal stylometric rhythm analysis across 100+ languages.
+topic: agent-workflows
+allowed-tools: Bash(node:*)
+version: 1.4.1
+---
+
+# Humanizer Lint
+
+**Audit prose locally, revise only measured problems, and verify the final text before delivery.**
+
+- Run `node <skill_dir>/scripts/analyze.mjs --stdin --json` for deterministic local analysis.
+- Use 8 language-specific lexical and morphological packs (`en`, `id`, `es`, `ms`, `fr`, `de`, `pt`, `zh`) plus universal sentence-rhythm segmentation for 100+ languages through `Intl.Segmenter`.
+- Follow each finding's surgical `suggestedReplacement`, `splitSuggestion`, and `fixInstruction` without rewriting clean prose.
+- Build a local author voice profile with `node <skill_dir>/scripts/fingerprint.mjs`; samples never leave the machine.
+
+## Agent Tool Boundary
+
+Inside an agent workflow, execute only:
+
+```sh
+node <skill_dir>/scripts/analyze.mjs --stdin --json
+node <skill_dir>/scripts/fingerprint.mjs --dir <samples_dir> --out <skill_dir>/profiles/custom-voice.json
+```
+
+Do not call network tools or upload the user's text. `npx humanizer-lint` is a manual human CLI convenience outside this agent workflow.
+
+## Workflow A — Drafting New Prose
+
+1. Write with concrete nouns, active verbs, specific claims, and transitions that reflect the actual relationship between ideas.
+2. Keep facts, quotations, names, numbers, and required terminology unchanged.
+3. Avoid stock openings, staged conversational hooks, generic claims, and repeated sentence templates.
+4. Before returning the draft, pipe it to `node <skill_dir>/scripts/analyze.mjs --stdin --json`.
+5. Revise only actionable findings, then verify again. Stop after at most three analysis/revision passes.
+
+## Workflow B — Auditing and Revising Existing Text
+
+1. Run the analyzer **before changing a single word**.
+2. If the result is `SKIP`, preserve short or code-heavy input unless a specific lexical or domain finding identifies a real problem.
+3. Edit only flagged sentences or phrases. Prefer `suggestedReplacement` and `splitSuggestion`; otherwise follow `fixInstruction`.
+4. Preserve all unflagged prose and factual meaning.
+5. Re-run the analyzer. Stop after at most three iterations and report any unresolved diagnostic instead of forcing a rewrite.
+
+## Metrics Are Diagnostics, Not Rigid Targets
+
+`CV`, paragraph `CV`, adjacent sentence delta ($\Delta_{adj}$), sentence-length ranges, MATTR, and compression ratio identify flat or repetitive patterns. They are not mechanical writing targets. Never manufacture a 3-word sentence followed by a 35-word sentence merely to raise a number; the result must still sound coherent.
+
+Formal, legal, academic, and regulated documents often use lower sentence variance, nominalized terms, or prescribed wording. Preserve required domain language. When a consistent author voice matters, use a custom `--profile` rather than forcing casual cadence.
+
+## Local Voice Profile
+
+Place at least three human writing samples in one local folder. A combined total of 500 words or more is recommended. Files must be `.txt` or `.md`.
+
+```sh
+node <skill_dir>/scripts/fingerprint.mjs \
+  --dir <samples_dir> \
+  --out <skill_dir>/profiles/custom-voice.json
+```
+
+Then analyze with:
+
+```sh
+node <skill_dir>/scripts/analyze.mjs \
+  --stdin \
+  --profile <skill_dir>/profiles/custom-voice.json \
+  --json
+```
+
+Fingerprinting and analysis run locally with zero network uploads.
+
+## Indonesian Revision Examples
+
+**Before — FAIL**
+
+> Tidak dapat dipungkiri bahwa pengimplementasian sistem ini dilakukan untuk meningkatkan efisiensi proses.
+
+**After — PASS**
+
+> Tim menerapkan sistem ini untuk mempercepat proses.
+
+**Before — FAIL**
+
+> Dalam rangka memastikan stabilitas, pelaksanaan pemeriksaan dilakukan oleh tim sebelum deployment.
+
+**After — PASS**
+
+> Tim memeriksa sistem sebelum deployment untuk memastikan layanan tetap stabil.
+
+Mixed Indonesian–English technical prose is supported. Keep necessary terms such as `deployment`, `latency`, `cache`, `middleware`, and `pull request`; Indonesian stopwords and sentence structure determine routing when they dominate the text.
+
+## Delivery Gate
+
+Use `--delivery-gate` for a human-readable four-block report or `--json` for the same structured data:
+
+1. `rhythmAndStylometry` — document CV, paragraph CV, adjacent delta, range, and clause symmetry.
+2. `lexicalAndMorphology` — active rule pack, repeated n-grams, stock phrases, nominalization, and passive bloat.
+3. `domainHygiene` — copy/CTA, code comments, and filename-aware UI/accessibility/responsive checks.
+4. `finalVerdict` — score, `PASS`/`FAIL`/`SKIP`, and prioritized one-pass fixes.
+
+## Search Intents & Editorial Keywords
+
+`perbaiki tulisan AI yang kaku`; `hilangkan kata klise AI`; `audit ritme kalimat dan burstiness`; `rapikan dokumentasi teknis`; `polish robotic LLM drafts`; `remove repetitive AI stock phrases`; `lint markdown documentation and copywriting`; `check sentence rhythm and lexical repetition`; `消除AI写作腔`; `提升文章可读性`.

package/demo/samples.mjs

@@ -0,0 +1,72 @@
+export const DEMO_SAMPLES = {
+  'ai-en': {
+    language: 'en',
+    text: `In today's fast-paced digital landscape, organizations must embrace robust technology to remain competitive. Moreover, modern platforms provide seamless experiences that elevate productivity across every department. Furthermore, these solutions foster collaboration and unlock new opportunities for sustainable growth. It is important to note that successful adoption requires a comprehensive and carefully structured strategy.
+
+Technology is a system that enables organizations to improve their operational capabilities. This approach is crucial for leaders who want to navigate an ever-evolving business landscape. Not only does it enhance efficiency but also creates a pivotal foundation for future innovation. By using an integrated platform, teams can improve communication, ensuring the organization achieves its goals.
+
+In conclusion, digital transformation represents a game-changer for modern organizations. It is worth noting that every company should develop a robust roadmap before beginning this journey. Moreover, leaders must foster a culture that can unlock the full potential of technology. The result is a seamless framework that can elevate performance and unleash long-term value.`,
+  },
+  'human-en': {
+    language: 'en',
+    text: `The build broke at 4:17 p.m.
+
+Maya had already packed her bag when the alert arrived, so she reopened the laptop and checked the last deployment. One configuration line pointed to a test bucket that had been deleted months earlier, but the failure appeared only now because a cached credential finally expired.
+
+She changed the line. Nothing happened.
+
+The worker had kept the old configuration in memory, which meant the clean-looking deploy had never restarted the process that actually handled customer uploads in production. Maya stopped the worker, watched it return with the correct bucket, and sent a small file through the public endpoint. It landed.
+
+Before leaving, she added a startup check that rejects missing buckets and wrote down why a restart is required after configuration changes. The patch, test included, was twelve lines and saved the next person from reading forty minutes of misleading logs.
+
+Her bag was still beside the door. Dinner was cold, but the queue was empty.`,
+  },
+  'ai-id': {
+    language: 'id',
+    text: `Di era digital, perubahan teknologi menjadi bagian penting dalam kehidupan masyarakat. Selain itu, teknologi memberikan berbagai kemudahan bagi banyak orang dalam menjalankan aktivitas harian. Lebih lanjut, perkembangan ini juga mendorong perusahaan untuk melakukan transformasi secara menyeluruh. Namun demikian, setiap organisasi perlu mempertimbangkan berbagai tantangan yang dapat muncul selama proses tersebut.
+
+Penting untuk diingat bahwa penerapan teknologi membutuhkan strategi yang matang dan terstruktur. Hal ini menunjukkan bahwa perusahaan harus melakukan pengimplementasian sistem secara hati-hati dan berkelanjutan. Tidak hanya meningkatkan efisiensi tetapi juga membantu organisasi menciptakan pengalaman yang lebih baik. Dalam konteks transformasi digital, teknologi adalah sebuah sistem yang mendukung perkembangan bisnis modern.
+
+Secara keseluruhan, transformasi digital memiliki peran yang sangat penting bagi keberhasilan organisasi. Dapat disimpulkan bahwa perusahaan perlu terus beradaptasi agar mampu menghadapi perubahan yang semakin cepat. Selain itu, kolaborasi yang efektif diperlukan untuk memastikan seluruh proses dapat dijalankan dengan baik. Sebagai kesimpulan, pendekatan yang tepat akan membantu perusahaan mencapai hasil yang optimal dan berkelanjutan.`,
+  },
+  'human-id': {
+    language: 'id',
+    text: `Pagi itu server mati.
+
+Rina sedang menyeduh kopi ketika tiga pesan masuk hampir bersamaan: kasir tidak bisa mencetak struk, gudang melihat stok minus, dan pemilik toko meminta laporan yang seharusnya sudah terkirim sejak subuh. Ia menaruh cangkirnya, membuka log, lalu menemukan satu tanggal kedaluwarsa yang luput diperbarui saat migrasi malam sebelumnya.
+
+Masalahnya kecil. Dampaknya tidak.
+
+Ia mengganti nilai tersebut dan menjalankan ulang antrean. Kasir kembali bekerja dalam dua menit, tetapi Rina belum menutup laptop karena stok minus masih perlu dilacak sampai sumbernya. Ternyata satu pemindai lama mengirim transaksi dua kali setiap kali koneksinya terputus sesaat.
+
+Tidak ada rapat darurat.
+
+Tim gudang mematikan pemindai itu, mencatat enam transaksi ganda, lalu memperbaiki jumlah barang berdasarkan nota fisik yang masih tersimpan di meja dekat rak paling belakang gudang. Menjelang makan siang, laporan terkirim dengan catatan singkat tentang koreksi yang dilakukan dan alasan angkanya berubah.
+
+Besoknya mereka menambah pemeriksaan sederhana sebelum antrean diproses. Murah, agak membosankan, dan cukup untuk mencegah kejadian yang sama.`,
+  },
+  'ai-es': { language: 'es', text: `En el vertiginoso mundo actual, cada equipo debe adoptar una estrategia sólida para alcanzar resultados óptimos. En el vertiginoso mundo actual, cada departamento necesita una plataforma robusta para mejorar cada proceso. En el vertiginoso mundo actual, cada líder debe impulsar una transformación integral para crear valor sostenible.
+
+Cabe destacar que esta solución desempeña un papel crucial para todas las organizaciones. Además, la plataforma permite una colaboración fluida y una experiencia transformadora para cada usuario. En conclusión, este enfoque abre nuevas oportunidades y garantiza un futuro más eficiente.` },
+  'human-es': { language: 'es', text: `Llueve. Marta revisó los recibos del mercado antes de abrir la tienda, comparó tres precios y dejó una nota junto a la caja para el turno de tarde. Al final, el pedido salió sin prisa y nadie tuvo que llamar al proveedor.` },
+  'ai-ms': { language: 'ms', text: `Dalam era digital kini, setiap organisasi perlu menggunakan strategi yang menyeluruh untuk mencapai hasil yang optimum. Dalam era digital kini, setiap pasukan memerlukan platform yang kukuh untuk meningkatkan setiap proses. Dalam era digital kini, setiap pemimpin perlu memacu transformasi yang menyeluruh untuk mencipta nilai yang mampan.
+
+Tidak dapat dinafikan bahawa penyelesaian ini memainkan peranan penting untuk semua organisasi. Selain itu, platform ini menyediakan kerjasama yang lancar dan pengalaman yang lebih baik untuk setiap pengguna. Secara keseluruhannya, pendekatan ini membuka peluang baharu dan memastikan masa depan yang lebih cekap.` },
+  'human-ms': { language: 'ms', text: `Hujan turun. Farah menyemak resit kedai sebelum membuka pintu, membandingkan tiga harga dan meninggalkan nota di kaunter untuk syif petang. Akhirnya, pesanan itu keluar tanpa tergesa-gesa dan tiada sesiapa perlu menghubungi pembekal.` },
+  'ai-fr': { language: 'fr', text: `Dans le monde trépidant d'aujourd'hui, chaque équipe doit adopter une stratégie solide pour obtenir des résultats optimaux. Dans le monde trépidant d'aujourd'hui, chaque service a besoin d'une plateforme robuste pour améliorer chaque processus. Dans le monde trépidant d'aujourd'hui, chaque dirigeant doit conduire une transformation complète afin de créer une valeur durable.
+
+Il est important de noter que cette solution joue un rôle crucial pour toutes les organisations. De plus, la plateforme offre une collaboration fluide et une expérience améliorée pour chaque utilisateur. En conclusion, cette approche ouvre de nouvelles possibilités et garantit un avenir plus efficace.` },
+  'human-fr': { language: 'fr', text: `Il pleut. Léa a vérifié les reçus avant d'ouvrir la boutique, comparé trois prix et laissé une note près de la caisse pour l'équipe du soir. À la fin, la commande est partie calmement et personne n'a appelé le fournisseur.` },
+  'ai-de': { language: 'de', text: `In der heutigen schnelllebigen Welt muss jedes Team eine robuste Strategie einsetzen, um optimale Ergebnisse zu erzielen. In der heutigen schnelllebigen Welt benötigt jede Abteilung eine leistungsstarke Plattform, um jeden Prozess zu verbessern. In der heutigen schnelllebigen Welt muss jede Führungskraft eine umfassende Transformation vorantreiben, um nachhaltigen Wert zu schaffen.
+
+Es ist wichtig zu beachten, dass diese Lösung eine entscheidende Rolle für alle Organisationen spielt. Darüber hinaus ermöglicht die Plattform eine nahtlose Zusammenarbeit und eine bessere Erfahrung für jeden Nutzer. Zusammenfassend lässt sich sagen, dass dieser Ansatz neue Möglichkeiten eröffnet und eine effizientere Zukunft sichert.` },
+  'human-de': { language: 'de', text: `Es regnet. Lara prüfte die Belege vor dem Öffnen des Ladens, verglich drei Preise und legte für die Spätschicht eine Notiz neben die Kasse. Am Ende ging die Bestellung ruhig raus, und niemand musste den Lieferanten anrufen.` },
+  'ai-pt': { language: 'pt', text: `No mundo acelerado de hoje, cada equipe deve adotar uma estratégia robusta para alcançar resultados ideais. No mundo acelerado de hoje, cada departamento precisa de uma plataforma forte para melhorar cada processo. No mundo acelerado de hoje, cada líder deve conduzir uma transformação completa para criar valor sustentável.
+
+Vale ressaltar que esta solução desempenha um papel crucial para todas as organizações. Além disso, a plataforma oferece colaboração fluida e uma experiência melhor para cada usuário. Em conclusão, essa abordagem abre novas oportunidades e garante um futuro mais eficiente.` },
+  'human-pt': { language: 'pt', text: `Choveu. Lara conferiu os recibos antes de abrir a loja, comparou três preços e deixou um bilhete perto do caixa para a equipe da tarde. No fim, o pedido saiu sem correria e ninguém precisou ligar para o fornecedor.` },
+  'ai-zh': { language: 'zh', text: `在当今快节奏的世界中，每个团队都必须采用稳健策略来取得最佳成果。在当今快节奏的世界中，每个部门都需要强大平台来改进每个流程。在当今快节奏的世界中，每位领导者都必须推动全面转型以创造可持续价值。
+
+值得注意的是，该解决方案对所有组织都发挥着关键作用。此外，该平台为每位用户提供无缝协作和更好的体验。总而言之，这种方法会开启新的机会并确保更高效的未来。` },
+  'human-zh': { language: 'zh', text: `下雨了。林娜在开店前核对了收据，比较了三种价格，并把给晚班的便条放在收银台旁边。最后，订单从容发出，没有人需要联系供应商。` },
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "humanizer-lint",
-  "version": "1.3.0",
-  "description": "Deterministic multilingual AI text humanizer, anti-slop prose linter, copywriting/blog/SEO editor, and stylometric analyzer for 8 language packs plus 100+ universal languages. Local zero-dependency Node.js CLI, no network.",
+  "version": "1.4.1",
+  "description": "Deterministic prose linter and stylometric rhythm analyzer with 8 language-specific anti-cliche packs plus universal Intl.Segmenter diagnostics for 100+ languages. Local zero-dependency Node.js CLI, no network.",
   "type": "module",
   "engines": {
     "node": ">=18.3.0"
@@ -16,11 +16,13 @@
     "LICENSE",
     "scripts/",
     "rules/",
-    "profiles/"
+    "profiles/",
+    "demo/samples.mjs"
   ],
   "scripts": {
-    "test": "node --test tests/test-runner.mjs",
-    "build:demo": "node demo/build.mjs"
+    "test": "node demo/build.mjs && node --test tests/test-runner.mjs",
+    "build:demo": "node demo/build.mjs",
+    "benchmark": "node scripts/benchmark.mjs"
   },
   "homepage": "https://humanizer.aiclub.ai.id",
   "repository": {

package/scripts/analyze.mjs

@@ -18,13 +18,17 @@ const { analyzeText } = createAnalyzer({ rules: RULES, defaultProfile: DEFAULT_P
 
 export { analyzeText };
 
-function formatHuman(result) {
+function formatHuman(result, includeDeliveryGate = false) {
   const lines = [`Status: ${result.status}`, `Score: ${result.score}`, `Language: ${result.language}`, `Rule pack: ${result.rulePack}`];
   if (result.warning) lines.push(`Warning: ${result.warning}`);
   lines.push('', 'Metrics:');
   for (const [name, value] of Object.entries(result.metrics)) lines.push(`  ${name}: ${value}`);
   if (result.violations.length) lines.push('', 'Violations:');
   for (const violation of result.violations) lines.push(`  ${violation.type} | ${violation.location} | ${violation.fixInstruction}`);
+  if (includeDeliveryGate) {
+    lines.push('', 'Delivery Gate:');
+    for (const [name, block] of Object.entries(result.deliveryGate)) lines.push(`  ${name}: ${JSON.stringify(block)}`);
+  }
   return `${lines.join('\n')}\n`;
 }
 
@@ -47,13 +51,14 @@ export async function runAnalyzeCli(argv, io = {}) {
         lang: { type: 'string', default: 'auto' },
         profile: { type: 'string' },
         json: { type: 'boolean' },
+        'delivery-gate': { type: 'boolean' },
         help: { type: 'boolean' },
       },
       strict: true,
       allowPositionals: false,
     });
     if (values.help) {
-      stdout('Usage: humanizer-lint (--file <path> | --stdin) [--lang auto|universal|<ISO-639-1>] [--profile <path>] [--json]\n');
+      stdout('Usage: humanizer-lint (--file <path> | --stdin) [--lang auto|universal|<ISO-639-1>] [--profile <path>] [--json] [--delivery-gate]\n');
       return 0;
     }
     if (Boolean(values.file) === Boolean(values.stdin)) throw new Error('Choose exactly one input: --file or --stdin');
@@ -61,8 +66,8 @@ export async function runAnalyzeCli(argv, io = {}) {
     if (values.stdin && io.stdin == null && process.stdin.isTTY) throw new Error('--stdin requires piped input');
     const text = values.file ? await new Promise((resolve, reject) => readFile(values.file, 'utf8', (error, data) => error ? reject(error) : resolve(data))) : await stdin();
     const profile = values.profile ? JSON.parse(await new Promise((resolve, reject) => readFile(values.profile, 'utf8', (error, data) => error ? reject(error) : resolve(data)))) : undefined;
-    const result = analyzeText(text, { language: values.lang, profile });
-    stdout(values.json ? `${JSON.stringify(result, null, 2)}\n` : formatHuman(result));
+    const result = analyzeText(text, { language: values.lang, profile, sourcePath: values.file });
+    stdout(values.json ? `${JSON.stringify(result, null, 2)}\n` : formatHuman(result, values['delivery-gate']));
     return result.status === 'FAIL' ? 1 : 0;
   } catch (error) {
     stderr(`ERROR: ${error.message}\n`);

package/scripts/benchmark.mjs

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+import { performance } from 'node:perf_hooks';
+import { realpathSync } from 'node:fs';
+import path from 'node:path';
+
+import { analyzeText } from './analyze.mjs';
+
+const parentDirectory = '..';
+const { DEMO_SAMPLES } = await import(new URL([parentDirectory, 'demo', 'samples.mjs'].join('/'), import.meta.url));
+
+const LANGUAGES = ['en', 'id', 'es', 'ms', 'fr', 'de', 'pt', 'zh'];
+
+export function runBenchmark(iterations = 20) {
+  const expected = LANGUAGES.flatMap((language) => [
+    [`ai-${language}`, 'FAIL'],
+    [`human-${language}`, 'PASS'],
+  ]);
+  const firstPass = expected.map(([id, status]) => {
+    const sample = DEMO_SAMPLES[id];
+    const result = analyzeText(sample.text, { language: sample.language });
+    return { id, expected: status, actual: result.status, score: result.score };
+  });
+
+  const started = performance.now();
+  for (let iteration = 0; iteration < iterations; iteration += 1) {
+    for (const [id] of expected) {
+      const sample = DEMO_SAMPLES[id];
+      analyzeText(sample.text, { language: sample.language });
+    }
+  }
+  const elapsed = performance.now() - started;
+  const secondPass = expected.map(([id]) => {
+    const sample = DEMO_SAMPLES[id];
+    const result = analyzeText(sample.text, { language: sample.language });
+    return { id, actual: result.status, score: result.score };
+  });
+  const aiScores = firstPass.filter(({ id }) => id.startsWith('ai-')).map(({ score }) => score);
+  const humanScores = firstPass.filter(({ id }) => id.startsWith('human-')).map(({ score }) => score);
+  const mean = (values) => values.reduce((sum, value) => sum + value, 0) / values.length;
+  const deterministic = firstPass.every((item, index) => item.actual === secondPass[index].actual && item.score === secondPass[index].score);
+  const correct = firstPass.filter((item) => item.actual === item.expected).length;
+
+  return {
+    fixtures: firstPass.length,
+    iterations,
+    totalRuns: iterations * expected.length,
+    elapsedMs: Number(elapsed.toFixed(3)),
+    meanMsPerAnalysis: Number((elapsed / (iterations * expected.length)).toFixed(4)),
+    meanAiScore: Number(mean(aiScores).toFixed(2)),
+    meanHumanScore: Number(mean(humanScores).toFixed(2)),
+    meanScoreSeparation: Number((mean(humanScores) - mean(aiScores)).toFixed(2)),
+    accuracy: Number((correct / firstPass.length).toFixed(4)),
+    deterministic,
+    results: firstPass,
+  };
+}
+
+function currentModulePath() {
+  let value = decodeURIComponent(new URL(import.meta.url).pathname);
+  if (/^\/[A-Za-z]:/.test(value)) value = value.slice(1);
+  return path.resolve(value);
+}
+
+if (process.argv[1] && realpathSync(process.argv[1]) === realpathSync(currentModulePath())) {
+  const report = runBenchmark();
+  process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+  if (!report.deterministic || report.accuracy !== 1 || report.meanScoreSeparation <= 0) process.exitCode = 1;
+}

package/scripts/core/analyzer-core.mjs

@@ -1,8 +1,9 @@
 const parentDirectory = '..';
 const utilityModule = (...segments) => new URL([parentDirectory, 'utils', ...segments].join('/'), import.meta.url);
 const { sanitizeMarkdown } = await import(utilityModule('sanitizer.mjs'));
-const { mean, punctuationRates } = await import(utilityModule('metrics-core.mjs'));
+const { coefficientOfVariation, mean, punctuationRates } = await import(utilityModule('metrics-core.mjs'));
 const { isCJKText, tokenizeText } = await import(utilityModule('tokenizer.mjs'));
+const { lintDomainHygiene } = await import(utilityModule('domain-linters.mjs'));
 
 const HAN = /[\u4e00-\u9fff]/gu;
 const KANA = /[\u3040-\u30ff]/u;
@@ -52,6 +53,21 @@ function regexFor(pattern) {
   return new RegExp(pattern, 'giu');
 }
 
+function suggestedReplacement(type, match, matches = []) {
+  const value = String(match ?? matches[0] ?? '').toLowerCase();
+  const replacements = [
+    [/pengimplementasian/iu, 'penerapan / menerapkan'],
+    [/\bdelve(?: into)?\b/iu, 'examine / explore'],
+    [/tidak dapat dipungkiri(?: bahwa)?/iu, 'state the concrete claim directly'],
+  ];
+  const found = replacements.find(([pattern]) => pattern.test(value));
+  if (found) return found[1];
+  if (type === 'EXCESSIVE_NOMINALIZATION') return 'Replace the listed noun forms with a concrete actor and active verb.';
+  if (type === 'PASSIVE_BLOATING') return 'Name the actor, then use the active verb.';
+  if (type === 'SLOP_PHRASE') return 'Replace the stock phrase with the specific fact or action.';
+  return undefined;
+}
+
 function patternViolations(tokenized, rules, wordCount) {
   if (!rules?.patterns) return [];
   const violations = [];
@@ -76,6 +92,7 @@ function patternViolations(tokenized, rules, wordCount) {
         location: locationFor(candidate.sentence),
         match: candidate.match,
         fixInstruction: rule.fixInstruction,
+        suggestedReplacement: suggestedReplacement(rule.type, candidate.match),
       });
     }
   }
@@ -101,6 +118,87 @@ function monotonyViolations(tokenized) {
   return violations;
 }
 
+function paragraphRhythmViolations(tokenized) {
+  const violations = [];
+  for (const paragraph of tokenized.paragraphs) {
+    if (paragraph.sentences.length < 4) continue;
+    const lengths = paragraph.sentences.map((sentence) => sentence.wordCount);
+    const paragraphCV = coefficientOfVariation(lengths);
+    const range = Math.max(...lengths) - Math.min(...lengths);
+    if (paragraphCV < 0.25 && range < 7) {
+      violations.push({
+        type: 'FLAT_PARAGRAPH_RHYTHM',
+        location: `Paragraph ${paragraph.paragraphIndex}`,
+        actual: round(paragraphCV),
+        range,
+        fixInstruction: 'Review the paragraph for uniform cadence; vary structure only where the meaning supports it.',
+      });
+    }
+
+    for (let index = 0; index <= paragraph.sentences.length - 4; index += 1) {
+      const window = paragraph.sentences.slice(index, index + 4);
+      const windowLengths = window.map((sentence) => sentence.wordCount);
+      const punctuationCounts = window.map((sentence) => (sentence.text.match(/[,;—，]/gu) ?? []).length);
+      if (punctuationCounts.every((count) => count === 1 || count === 2) && Math.max(...windowLengths) - Math.min(...windowLengths) <= 5) {
+        violations.push({
+          type: 'UNIFORM_CLAUSE_STRUCTURE',
+          location: `Paragraph ${paragraph.paragraphIndex}, Sentences ${window[0].sentenceIndex}-${window[3].sentenceIndex}`,
+          lengths: windowLengths,
+          fixInstruction: 'Change one clause pattern or punctuation shape where the ideas have a different relationship.',
+        });
+      }
+    }
+  }
+  return violations;
+}
+
+function repetitiveNgramViolations(tokenized, stopwords = []) {
+  if (tokenized.words.length < 120) return [];
+  const ignored = new Set(stopwords);
+  const content = tokenized.words
+    .map((word, index) => ({ word, index }))
+    .filter(({ word }) => !ignored.has(word) && word !== 'token_entity');
+  const violations = [];
+  const seen = new Set();
+  for (const size of [4, 3]) {
+    const occurrences = new Map();
+    for (let index = 0; index <= content.length - size; index += 1) {
+      const phrase = content.slice(index, index + size).map(({ word }) => word).join(' ');
+      const positions = occurrences.get(phrase) ?? [];
+      positions.push(content[index].index);
+      occurrences.set(phrase, positions);
+    }
+    for (const [phrase, positions] of occurrences) {
+      if (seen.has(phrase)) continue;
+      const repeated = positions.some((start, index) => positions[index + 2] != null && positions[index + 2] - start <= 400);
+      if (!repeated) continue;
+      seen.add(phrase);
+      violations.push({
+        type: 'REPETITIVE_NGRAM',
+        location: 'Whole text',
+        match: phrase,
+        occurrences: positions.length,
+        fixInstruction: 'Remove repeated wording or replace it with a precise reference that preserves the meaning.',
+      });
+      if (violations.length >= 5) return violations;
+    }
+  }
+  return violations;
+}
+
+function rhetoricalViolations(tokenized) {
+  const hooks = /^(?:mengapa demikian\?|menarik, bukan\?|here['’]s the kicker:|want to know the best part\?|let that sink in\.?)/iu;
+  const shortQuestions = tokenized.sentences.filter((sentence) => sentence.text.endsWith('?') && sentence.wordCount <= 6);
+  return tokenized.sentences
+    .filter((sentence) => hooks.test(sentence.text) || (shortQuestions.length >= 3 && sentence.text.endsWith('?') && sentence.wordCount <= 6))
+    .map((sentence) => ({
+      type: 'RHETORICAL_SLOP',
+      location: locationFor(sentence),
+      match: sentence.text,
+      fixInstruction: 'Remove the staged conversational hook and state the point directly.',
+    }));
+}
+
 function structuralViolations(tokenized, metrics) {
   const violations = [];
   if (metrics.wordCount >= 150 && metrics.compressionRatio < 0.42) {
@@ -210,6 +308,7 @@ function morphologyViolations(tokenized, morphology) {
       ratio: round(nominalizationRatio),
       matches: [...new Set(nominalizations)],
       fixInstruction: 'Replace abstract nominalizations with concrete actors and verbs.',
+      suggestedReplacement: suggestedReplacement('EXCESSIVE_NOMINALIZATION', '', nominalizations),
     });
   }
   if (passiveRatio > morphology.passiveMaxRatio) {
@@ -219,6 +318,7 @@ function morphologyViolations(tokenized, morphology) {
       ratio: round(passiveRatio),
       matches: [...new Set(passives)],
       fixInstruction: 'Name the actor and use an active verb where the actor is known.',
+      suggestedReplacement: suggestedReplacement('PASSIVE_BLOATING', '', passives),
     });
   }
 
@@ -243,6 +343,34 @@ function morphologyViolations(tokenized, morphology) {
   return { violations, nominalizationRatio, passiveRatio };
 }
 
+function splitSuggestion(sentence) {
+  if (!sentence || sentence.wordCount < 16) return undefined;
+  const candidates = [...sentence.text.matchAll(/\b(?:sehingga|tetapi|namun|karena|however|because|while)\b|[;,]/giu)];
+  if (!candidates.length) return undefined;
+  const middle = sentence.text.length / 2;
+  const best = candidates.sort((left, right) => Math.abs(left.index - middle) - Math.abs(right.index - middle))[0];
+  return `Consider splitting near “${best[0]}” if both resulting sentences remain complete.`;
+}
+
+function attachSurgicalHints(violations, tokenized) {
+  return violations.map((violation) => {
+    const sentenceMatch = /Sentence (\d+)/u.exec(violation.location ?? '');
+    const rangeMatch = /Sentences (\d+)-(\d+)/u.exec(violation.location ?? '');
+    const sentence = sentenceMatch
+      ? tokenized.sentences.find((item) => item.sentenceIndex === Number(sentenceMatch[1]))
+      : rangeMatch
+        ? tokenized.sentences.find((item) => item.sentenceIndex >= Number(rangeMatch[1]) && item.sentenceIndex <= Number(rangeMatch[2]) && item.wordCount >= 16)
+        : undefined;
+    const replacement = violation.suggestedReplacement ?? suggestedReplacement(violation.type, violation.match, violation.matches);
+    const split = splitSuggestion(sentence);
+    return {
+      ...violation,
+      ...(replacement ? { suggestedReplacement: replacement } : {}),
+      ...(split ? { splitSuggestion: split } : {}),
+    };
+  });
+}
+
 function voiceDeviation(metrics, tokenized, text, profile) {
   const targets = profile?.targets ?? profile?.metrics;
   if (!targets) return 0;
@@ -275,33 +403,74 @@ function scoreResult(metrics, violations, thresholds, mattrTarget) {
   if (metrics.sentenceCount >= 8 && (metrics.shortSentenceRatio < thresholds.shortSentenceRatio || metrics.longSentenceRatio < thresholds.longSentenceRatio)) {
     burstinessPenalty = Math.min(25, burstinessPenalty + 8);
   }
-  const rhythmPenalty = Math.min(20, violations.filter((violation) => violation.type === 'MONOTONOUS_RHYTHM').length * 6);
+  if (violations.some((violation) => violation.type === 'FLAT_PARAGRAPH_RHYTHM')) burstinessPenalty = Math.min(25, burstinessPenalty + 5);
+  const rhythmPenalty = Math.min(20, violations.reduce((total, violation) => {
+    if (violation.type === 'MONOTONOUS_RHYTHM') return total + 6;
+    if (violation.type === 'UNIFORM_CLAUSE_STRUCTURE') return total + 5;
+    return total;
+  }, 0));
   const lexicalPenalty = Math.min(30, violations.reduce((total, violation) => {
     if (violation.type === 'SLOP_PHRASE' || violation.type === 'DEFINITIONAL_OPENING') return total + 5;
     if (violation.type === 'STRUCTURAL_CLICHE') return total + 4;
+    if (['RHETORICAL_SLOP', 'WEAK_CTA', 'HYPERBOLIC_CLAIM', 'TAUTOLOGICAL_CODE_COMMENT', 'DECORATIVE_COMMENT_BANNER', 'LAZY_AI_PLACEHOLDER', 'MISSING_ACCESSIBLE_NAME', 'MISSING_IMG_ALT', 'HEADING_ORDER_SKIP', 'AI_GRADIENT_CLICHE', 'NON_RESPONSIVE_FIXED_WIDTH'].includes(violation.type)) return total + 4;
     return total;
   }, 0));
   const morphologyPenalty = Math.min(15,
     (violations.some((violation) => violation.type === 'EXCESSIVE_NOMINALIZATION') ? 7.5 : 0)
     + Math.min(15, violations.filter((violation) => violation.type === 'PASSIVE_BLOATING').length * 7.5));
   const vocabularyPenalty = metrics.mattr < mattrTarget ? 5 : 0;
-  const entropyPenalty = violations.some((violation) => ['LOW_ENTROPY_REPETITION', 'SYMMETRIC_PARAGRAPHS', 'REPETITIVE_STARTERS'].includes(violation.type)) ? 5 : 0;
+  const entropyPenalty = violations.some((violation) => ['LOW_ENTROPY_REPETITION', 'SYMMETRIC_PARAGRAPHS', 'REPETITIVE_STARTERS', 'REPETITIVE_NGRAM'].includes(violation.type)) ? 5 : 0;
   const profilePenalty = violations.some((violation) => violation.type === 'VOICE_PROFILE_DEVIATION') ? 5 : 0;
   const vocabularyAndProfilePenalty = Math.min(10, vocabularyPenalty + entropyPenalty + profilePenalty);
   return Math.max(0, Math.round(100 - burstinessPenalty - rhythmPenalty - lexicalPenalty - morphologyPenalty - vocabularyAndProfilePenalty));
 }
 
+function deliveryGate({ metrics, violations, language, rulePack, score, status }) {
+  const types = (names) => violations.filter((violation) => names.includes(violation.type));
+  const prioritizedFixes = violations.slice(0, 8).map((violation) => ({
+    type: violation.type,
+    location: violation.location,
+    fixInstruction: violation.fixInstruction,
+    ...(violation.suggestedReplacement ? { suggestedReplacement: violation.suggestedReplacement } : {}),
+    ...(violation.splitSuggestion ? { splitSuggestion: violation.splitSuggestion } : {}),
+  }));
+  return {
+    rhythmAndStylometry: {
+      burstinessCV: metrics.burstinessCV,
+      paragraphBurstinessCV: metrics.paragraphBurstinessCV,
+      adjacentDelta: metrics.adjacentDelta,
+      clauseSymmetry: types(['UNIFORM_CLAUSE_STRUCTURE']),
+      rhythmFindings: types(['LOW_BURSTINESS', 'FLAT_PARAGRAPH_RHYTHM', 'MONOTONOUS_RHYTHM', 'MISSING_SENTENCE_RANGE', 'LOW_ADJACENT_DELTA']),
+    },
+    lexicalAndMorphology: {
+      language,
+      rulePack,
+      mode: rulePack === 'universal' ? 'Universal stylometry' : '8 language-specific lexical pack',
+      ngrams: types(['REPETITIVE_NGRAM']),
+      morphology: types(['SLOP_PHRASE', 'EXCESSIVE_NOMINALIZATION', 'PASSIVE_BLOATING', 'DEFINITIONAL_OPENING']),
+    },
+    domainHygiene: {
+      copywritingAndCta: types(['WEAK_CTA', 'HYPERBOLIC_CLAIM']),
+      codeComments: types(['TAUTOLOGICAL_CODE_COMMENT', 'DECORATIVE_COMMENT_BANNER', 'LAZY_AI_PLACEHOLDER']),
+      uiAccessibilityResponsive: types(['MISSING_ACCESSIBLE_NAME', 'MISSING_IMG_ALT', 'HEADING_ORDER_SKIP', 'AI_GRADIENT_CLICHE', 'NON_RESPONSIVE_FIXED_WIDTH']),
+    },
+    finalVerdict: { score, status, prioritizedFixes },
+  };
+}
+
 export function createAnalyzer({ rules, defaultProfile, calculateMetrics, calculateMetricsAsync }) {
   if (!rules || !defaultProfile || typeof calculateMetrics !== 'function') {
     throw new TypeError('createAnalyzer requires rules, defaultProfile, and calculateMetrics');
   }
 
   const prepare = (input, options) => {
-    const sanitized = sanitizeMarkdown(input);
+    const original = String(input ?? '');
+    const sanitized = sanitizeMarkdown(original);
     const requestedLanguage = String(options.language ?? 'auto').toLowerCase();
     const initial = tokenizeText(sanitized, requestedLanguage);
     const language = requestedLanguage === 'auto' ? detectLanguage(sanitized, initial.words, rules) : requestedLanguage;
     return {
+      original,
       sanitized,
       language,
       rulePack: rules[language] ? language : 'universal',
@@ -309,15 +478,19 @@ export function createAnalyzer({ rules, defaultProfile, calculateMetrics, calcul
     };
   };
 
-  const analyzePrepared = ({ sanitized, language, rulePack, tokenized }, options, metrics) => {
+  const analyzePrepared = ({ original, sanitized, language, rulePack, tokenized }, options, metrics) => {
     const profile = options.profile ?? defaultProfile;
     const thresholds = { ...defaultProfile.thresholds, ...(profile.thresholds ?? {}) };
     const mattrTarget = mattrThreshold(thresholds, language, tokenized);
     const patternMatches = patternViolations(tokenized, rules[language], metrics.wordCount);
+    const domainFindings = lintDomainHygiene(original, options.sourcePath);
 
     if (metrics.wordCount < thresholds.minimumWords || metrics.sentenceCount < thresholds.minimumSentences) {
-      const violations = patternMatches.filter((violation) => violation.type === 'SLOP_PHRASE');
-      return {
+      const violations = attachSurgicalHints([
+        ...patternMatches.filter((violation) => violation.type === 'SLOP_PHRASE'),
+        ...domainFindings,
+      ], tokenized);
+      const result = {
         status: 'SKIP',
         score: 100,
         language,
@@ -326,6 +499,8 @@ export function createAnalyzer({ rules, defaultProfile, calculateMetrics, calcul
         metrics: Object.fromEntries(Object.entries({ ...metrics, nominalizationRatio: 0, passiveRatio: 0, voiceProfileDeviation: 0 }).map(([key, value]) => [key, typeof value === 'number' ? round(value) : value])),
         violations,
       };
+      result.deliveryGate = deliveryGate(result);
+      return result;
     }
 
     const morphology = morphologyViolations(tokenized, rules[language]?.morphology);
@@ -341,22 +516,27 @@ export function createAnalyzer({ rules, defaultProfile, calculateMetrics, calcul
       match: 'Mean sentence length deviates >30% from target voice profile',
       fixInstruction: 'Adjust overall sentence complexity so mean sentence length approaches the target profile.',
     }] : [];
-    const violations = [
+    const violations = attachSurgicalHints([
       ...patternMatches,
       ...monotonyViolations(tokenized),
+      ...paragraphRhythmViolations(tokenized),
       ...structuralViolations(tokenized, metrics),
+      ...repetitiveNgramViolations(tokenized, rules[language]?.stopwords),
+      ...rhetoricalViolations(tokenized),
       ...morphology.violations,
       ...profileViolations,
       ...statisticalViolations(metrics, thresholds, mattrTarget),
-    ];
+      ...domainFindings,
+    ], tokenized);
     const score = scoreResult(metrics, violations, thresholds, mattrTarget);
     const cvTarget = metrics.sentenceCount >= 8 ? thresholds.burstinessCVLong : thresholds.burstinessCVShort;
-    const forbidden = violations.some((violation) => violation.type === 'SLOP_PHRASE' || violation.type === 'DEFINITIONAL_OPENING');
+    const forbiddenTypes = new Set(['SLOP_PHRASE', 'DEFINITIONAL_OPENING', 'RHETORICAL_SLOP', 'WEAK_CTA', 'HYPERBOLIC_CLAIM', 'TAUTOLOGICAL_CODE_COMMENT', 'DECORATIVE_COMMENT_BANNER', 'LAZY_AI_PLACEHOLDER', 'MISSING_ACCESSIBLE_NAME', 'MISSING_IMG_ALT', 'HEADING_ORDER_SKIP', 'AI_GRADIENT_CLICHE', 'NON_RESPONSIVE_FIXED_WIDTH']);
+    const forbidden = violations.some((violation) => forbiddenTypes.has(violation.type));
     const rhythmPass = metrics.adjacentDelta >= thresholds.adjacentDelta;
     const distributionPass = metrics.sentenceCount < 8 || (metrics.shortSentenceRatio >= thresholds.shortSentenceRatio && metrics.longSentenceRatio >= thresholds.longSentenceRatio);
     const status = score >= thresholds.passScore && !forbidden && metrics.burstinessCV >= cvTarget && rhythmPass && distributionPass ? 'PASS' : 'FAIL';
 
-    return {
+    const result = {
       status,
       score,
       language,
@@ -364,6 +544,8 @@ export function createAnalyzer({ rules, defaultProfile, calculateMetrics, calcul
       metrics: Object.fromEntries(Object.entries(metrics).map(([key, value]) => [key, typeof value === 'number' ? round(value) : value])),
       violations,
     };
+    result.deliveryGate = deliveryGate(result);
+    return result;
   };
 
   return {

package/scripts/fingerprint.mjs

@@ -82,7 +82,9 @@ export async function runFingerprintCli(argv, io = {}) {
       args: argv,
       options: {
         input: { type: 'string' },
+        dir: { type: 'string' },
         output: { type: 'string' },
+        out: { type: 'string' },
         name: { type: 'string' },
         lang: { type: 'string', default: 'auto' },
         help: { type: 'boolean' },
@@ -91,14 +93,16 @@ export async function runFingerprintCli(argv, io = {}) {
       allowPositionals: false,
     });
     if (values.help) {
-      stdout('Usage: humanizer-fingerprint --input <file-or-dir> --output <profile.json> [--name <name>] [--lang id|en|auto]\n');
+      stdout('Usage: humanizer-fingerprint (--input <file-or-dir> | --dir <samples-dir>) (--output <profile.json> | --out <profile.json>) [--name <name>] [--lang id|en|auto]\n');
       return 0;
     }
-    if (!values.input || !values.output) throw new Error('--input and --output are required');
+    const input = values.input ?? values.dir;
+    const output = values.output ?? values.out;
+    if (!input || !output) throw new Error('--input/--dir and --output/--out are required');
     if (!['id', 'en', 'auto'].includes(values.lang)) throw new Error('--lang must be id, en, or auto');
-    const files = await collectInput(values.input);
+    const files = await collectInput(input);
     if (!files.length) throw new Error('No .txt or .md samples found');
-    const profile = await fingerprintSamples(files, { output: values.output, name: values.name, language: values.lang });
+    const profile = await fingerprintSamples(files, { output, name: values.name, language: values.lang });
     stdout(`${JSON.stringify(profile, null, 2)}\n`);
     return 0;
   } catch (error) {

package/scripts/utils/domain-linters.mjs

@@ -0,0 +1,95 @@
+const finding = (type, match, fixInstruction, location = 'Whole input') => ({
+  type,
+  location,
+  match,
+  fixInstruction,
+});
+
+function regexFindings(text, definitions) {
+  const source = String(text ?? '');
+  return definitions.flatMap(({ type, pattern, fixInstruction }) => [...source.matchAll(pattern)].map((match) => (
+    finding(type, match[0], fixInstruction)
+  )));
+}
+
+export function lintCopywriting(text) {
+  return regexFindings(text, [
+    {
+      type: 'WEAK_CTA',
+      pattern: /\b(?:click here|learn more|klik di sini|pelajari lebih lanjut)\b/giu,
+      fixInstruction: 'Replace the generic CTA with a specific action and outcome.',
+    },
+    {
+      type: 'HYPERBOLIC_CLAIM',
+      pattern: /\b(?:supercharge your workflow|solusi terlengkap dan terbaik)\b/giu,
+      fixInstruction: 'Replace the superlative claim with a concrete capability or supported result.',
+    },
+  ]);
+}
+
+export function lintCodeComments(text) {
+  return regexFindings(text, [
+    {
+      type: 'TAUTOLOGICAL_CODE_COMMENT',
+      pattern: /^\s*\/\/\s*(?:import dependencies|function to\b.*)$/gimu,
+      fixInstruction: 'Delete the comment or explain a non-obvious constraint instead.',
+    },
+    {
+      type: 'DECORATIVE_COMMENT_BANNER',
+      pattern: /^\s*\/\/\s*=+\s*[^=\n]+\s*=+\s*$/gmu,
+      fixInstruction: 'Use a normal section comment only when the grouping adds navigation value.',
+    },
+    {
+      type: 'LAZY_AI_PLACEHOLDER',
+      pattern: /^\s*\/\/\s*(?:\.\.\.\s*)?rest of code\b.*$/gimu,
+      fixInstruction: 'Replace the placeholder with complete code or remove it.',
+    },
+  ]);
+}
+
+function markupExtension(sourcePath) {
+  return /\.(?:html?|jsx|tsx|vue|astro)$/iu.test(String(sourcePath ?? ''));
+}
+
+export function lintUiAndAccessibility(text, sourcePath = '') {
+  if (sourcePath && !markupExtension(sourcePath)) return [];
+  const source = String(text ?? '');
+  const findings = [];
+
+  for (const match of source.matchAll(/<(button|a)\b([^>]*)>([\s\S]*?)<\/\1>/giu)) {
+    const [, tag, attributes, body] = match;
+    const visibleText = body.replace(/<[^>]+>/gu, '').trim();
+    if (!visibleText && !/\b(?:aria-label|aria-labelledby|title)\s*=/iu.test(attributes)) {
+      findings.push(finding('MISSING_ACCESSIBLE_NAME', match[0], `Add visible text or an accessible name to this ${tag}.`));
+    }
+  }
+
+  for (const match of source.matchAll(/<img\b([^>]*)>/giu)) {
+    if (!/\balt\s*=/iu.test(match[1])) findings.push(finding('MISSING_IMG_ALT', match[0], 'Add meaningful alt text, or alt="" for a decorative image.'));
+  }
+
+  const headings = [...source.matchAll(/<h([1-6])\b/giu)].map((match) => Number(match[1]));
+  for (let index = 1; index < headings.length; index += 1) {
+    if (headings[index] > headings[index - 1] + 1) {
+      findings.push(finding('HEADING_ORDER_SKIP', `h${headings[index - 1]} → h${headings[index]}`, 'Use the next heading level unless the document outline requires a separate region.'));
+      break;
+    }
+  }
+
+  if (/(?:bg-)?gradient-(?:to|from|via)|linear-gradient\s*\(/iu.test(source)) {
+    findings.push(finding('AI_GRADIENT_CLICHE', 'gradient styling', 'Use a restrained solid color or a gradient tied to the product visual system.'));
+  }
+  if (/(?:width\s*:\s*|\bw-\[)(?:[6-9]\d{2}|\d{4,})px/iu.test(source)) {
+    findings.push(finding('NON_RESPONSIVE_FIXED_WIDTH', 'large fixed width', 'Use max-width and fluid sizing so the layout fits narrow viewports.'));
+  }
+
+  return findings;
+}
+
+export function lintDomainHygiene(text, sourcePath = '') {
+  return [
+    ...lintCopywriting(text),
+    ...lintCodeComments(text),
+    ...(markupExtension(sourcePath) ? lintUiAndAccessibility(text, sourcePath) : []),
+  ];
+}

package/scripts/utils/metrics-core.mjs

@@ -49,6 +49,9 @@ export function punctuationRates(text, wordCount) {
 
 export function calculateMetricsFromCompressionRatio(tokenized, compressionRatio) {
   const lengths = tokenized.sentences.map((sentence) => sentence.wordCount);
+  const paragraphCVs = tokenized.paragraphs
+    .filter((paragraph) => paragraph.sentences.length >= 4)
+    .map((paragraph) => coefficientOfVariation(paragraph.sentences.map((sentence) => sentence.wordCount)));
   const wordCount = tokenized.words.length;
   const sentenceCount = lengths.length;
   return {
@@ -57,6 +60,7 @@ export function calculateMetricsFromCompressionRatio(tokenized, compressionRatio
     meanSentenceLength: mean(lengths),
     stdDev: standardDeviation(lengths),
     burstinessCV: coefficientOfVariation(lengths),
+    paragraphBurstinessCV: paragraphCVs.length ? mean(paragraphCVs) : 0,
     adjacentDelta: adjacentDelta(lengths),
     shortSentenceRatio: sentenceCount ? lengths.filter((length) => length <= 6).length / sentenceCount : 0,
     longSentenceRatio: sentenceCount ? lengths.filter((length) => length >= 26).length / sentenceCount : 0,