zero-slop 2.8.9 → 2.8.11

package/README.md

@@ -1,54 +1,60 @@
-# Zero Slop
+<p align="center">
+  <a href="https://zero-slop.ai">
+    <img src="assets/logo/logo-mark-512.png" width="112" alt="Zero Slop">
+  </a>
+</p>
+
+<h1 align="center">Zero Slop</h1>
+
+<p align="center"><strong>Find AI-sounding writing. Keep the source intact.</strong></p>
 
 <p align="center">
-  <img alt="MIT" src="https://img.shields.io/badge/license-MIT-202521">
-  <img alt="tests" src="https://img.shields.io/badge/tests-passing-227B5B">
-  <img alt="dependencies" src="https://img.shields.io/badge/runtime%20dependencies-0-227B5B">
-  <img alt="privacy" src="https://img.shields.io/badge/learning-private-227B5B">
-  <img alt="version" src="https://img.shields.io/badge/version-2.8.9-72528F">
-  <a href="https://hol.org/guard/plugins"><img alt="Listed in the HOL plugin registry" src="https://img.shields.io/badge/HOL%20registry-listed-2C6E8F"></a>
-  <a href="https://github.com/hashgraph-online/awesome-ai-plugins#tools--integrations"><img alt="Listed in awesome-ai-plugins" src="https://img.shields.io/badge/awesome--ai--plugins-listed-2C6E8F"></a>
-  <a href="https://zero-slop.ai/try/"><img alt="This README scores 11.6 out of 100 on the slop score, inside the human range" src="https://img.shields.io/badge/slop%20score-11.6%2F100-0f7d55"></a>
+  Zero Slop finds stock phrasing, mechanical rhythm, vague claims, and canned formatting.<br>
+  Your existing AI assistant edits the draft; local checks guard its names, numbers, links, quotations, code, tables, and paths.
 </p>
 
-Less slop, more pop in your writing.
+<p align="center">
+  <a href="https://zero-slop.ai/try/"><strong>Try it in your browser</strong></a>
+  ·
+  <a href="#install">Install the skill</a>
+  ·
+  <a href="#evidence-and-limits">See the evidence</a>
+  ·
+  <a href="https://github.com/manavmishra/ZeroSlop/releases/latest">Latest release</a>
+</p>
 
-Zero Slop finds stock phrasing, mechanical rhythm, vague claims, and canned
-formatting. Local checks run offline; your existing AI assistant does the editing.
-Score a draft at [zero-slop.ai/try](https://zero-slop.ai/try/); benchmark at
-[zero-slop.ai](https://zero-slop.ai).
+<p align="center">
+  <a href="https://github.com/manavmishra/ZeroSlop/actions/workflows/validate.yml"><img alt="Validate" src="https://github.com/manavmishra/ZeroSlop/actions/workflows/validate.yml/badge.svg"></a>
+  <img alt="Version 2.8.11" src="https://img.shields.io/badge/version-2.8.11-72528F">
+  <a href="https://www.npmjs.com/package/zero-slop"><img alt="npm version" src="https://img.shields.io/npm/v/zero-slop?color=72528F"></a>
+  <a href="https://www.npmjs.com/package/zero-slop"><img alt="npm downloads" src="https://img.shields.io/npm/dm/zero-slop?color=227B5B"></a>
+  <a href="https://github.com/manavmishra/ZeroSlop/stargazers"><img alt="GitHub stars" src="https://img.shields.io/github/stars/manavmishra/ZeroSlop?style=flat&color=b0442a"></a>
+  <a href="LICENSE"><img alt="MIT license" src="https://img.shields.io/badge/license-MIT-202521"></a>
+  <a href="https://hol.org/guard/plugins"><img alt="Listed in the HOL plugin registry" src="https://img.shields.io/badge/HOL%20registry-listed-2C6E8F"></a>
+</p>
 
 ```sh
-npx zero-slop install
+npx skills add manavmishra/ZeroSlop --global
 ```
 
-![Scoring a launch post at 100.0, rewriting it to 9.5, with the 40% figure held by the fact gate](assets/zero-slop-demo.gif)
+<a href="assets/zero-slop-demo.mp4">
+  <picture>
+    <source media="(prefers-reduced-motion: reduce)" srcset="assets/zero-slop-demo-poster.png">
+    <source type="image/webp" srcset="assets/zero-slop-demo.webp">
+    <img src="assets/zero-slop-demo.gif" width="960" alt="Terminal demo: install Zero Slop, ask your AI assistant to edit a draft with /zero-slop, then review the edit and source checks.">
+  </picture>
+</a>
+
+<p align="center"><a href="assets/zero-slop-demo.mp4">Download the 36-second demo</a> · <sub>Reconstructed skill session; hosted outputs vary.</sub></p>
 
-### What it does, on a real draft
+## Before and after
 
 A launch post, as AI wrote it:
 
-> We're thrilled to announce that our team has leveraged cutting-edge AI to deliver a seamless onboarding experience. It's not just a redesign, it's a fundamental reimagining of how users engage with our platform. In today's fast-paced landscape, the ability to iterate quickly is crucial. By harnessing the power of machine learning, we've been able to reduce setup time by 40%. Here's the thing nobody tells you: onboarding is where most products lose their users. We're excited to continue this journey with you.
+> We're thrilled to announce that our team has leveraged cutting-edge machine learning to deliver a seamless onboarding experience, reducing setup time by 40%.
 
-`slopscore.py --explain` on that paragraph, unedited:
-
-```text
-Writing score: 100.0/100  [major rewrite]
-  Flagged phrases : 11 across 83 words
-  Sentence variety: too even
-  Main issues     : canned LinkedIn phrase, promotional language, manufactured
-                    stakes, two-part contrast used as a formula, performed
-                    writer's voice, buzzword used as promotion
-
-  Flagged phrases (11), strongest first:
-    "In today's fast-paced"  manufactured stakes; start where the reader needs to start
-    "We're thrilled to"      canned LinkedIn phrase; say what happened without the stock opening
-    "It's not just a redesign, it's"
-                             two-part contrast used as a formula; state the claim once, plainly
-    "Here's the thing"       performed writer's voice; say the thing plainly
-    'cutting-edge'           promotional language; name what it does; cut the adjectives
-    'leveraged'              buzzword used as promotion; use the plain word
-```
+The scorer rates that draft 99.3/100 and flags four phrases: “We're thrilled
+to,” “leveraged,” “cutting-edge,” and “seamless.”
 
 The rewrite, limited to the draft's stated claims:
 
@@ -59,240 +65,251 @@ Writing score: 9.5/100  [clear]
   Flagged phrases : 0 across 10 words
 ```
 
-## Problem
+The rewrite retains the draft's stated result. See four complete, reproducible pairs in [`examples/`](examples/).
 
-AI-assisted writing often converges on the same constructions: "It's not X. It's Y."
-"Here's the thing nobody tells you." Repeated wording, uniform rhythm, and
-overworked formatting can have the same effect.
+## What can I use it for?
 
-Zero Slop is an Agent Skill and ships no model. Claude, GPT, or another compatible
-model edits; local tools protect names, numbers, quotations, links, code, tables,
-and paths. Your AI compares meaning that word matching cannot judge.
+- Tighten a launch post without losing the release details.
+- Turn a padded product update into a useful changelog.
+- Clean up an email while preserving names, dates, and numbers.
+- Edit a research summary without flattening its qualifications.
+- Gate a folder of generated copy before it ships.
 
-## How to install Zero Slop
+Zero Slop is a writing tool. It does not detect authorship; its score describes the text.
 
-Paste this into Claude Code, Codex, Cursor, OpenCode, Warp, or Zed:
+## Install
 
-```text
-Install the Zero Slop skill globally from https://github.com/manavmishra/ZeroSlop
-```
+To try Zero Slop first, paste a draft into [zero-slop.ai/try](https://zero-slop.ai/try/). The free editor returns the edit, the before-and-after scores, and the exact phrases that triggered the scorer.
 
-Or install it with `npx`:
+The portable installer works with Claude Code, Codex, Cursor, OpenCode, Warp, Zed, and other Agent Skills-compatible tools:
 
 ```sh
 npx skills add manavmishra/ZeroSlop --global
 ```
 
-Or install from npm, which also adds the scoring command:
+Or use the package-specific installer and scoring command:
 
 ```sh
-npx zero-slop install          # add --harness codex|cursor|opencode|zed
-npx zero-slop score draft.md   # score without installing anything
+npx zero-slop install
+npx zero-slop score draft.md
 ```
 
-ChatGPT users can download [`dist/zero-slop-single-file.md`](dist/zero-slop-single-file.md).
-Claude.ai users can upload the [release ZIP](https://github.com/manavmishra/ZeroSlop/releases/latest/download/zero-slop.zip).
+Choose a harness explicitly when needed:
 
-## How to use Zero Slop
+```sh
+npx zero-slop install --harness codex
+# claude | codex | cursor | opencode | zed
+```
+
+| Environment | Fastest route |
+|---|---|
+| Claude Code, Codex, Cursor, OpenCode, Warp, Zed | `npx skills add manavmishra/ZeroSlop --global` |
+| Any assistant with file uploads | Download the [single-file bundle](https://github.com/manavmishra/ZeroSlop/releases/latest/download/zero-slop-single-file.md) |
+| Claude.ai | Upload the [latest skill ZIP](https://github.com/manavmishra/ZeroSlop/releases/latest/download/zero-slop.zip) |
+| ChatGPT or another MCP client | Connect the optional [hosted MCP server](mcp/README.md) |
+
+Once installed, ask your AI assistant to edit a draft:
 
 ```text
 /zero-slop (your writing)
 ```
 
-You get the edited draft, before-and-after scores, and quoted flagged phrases.
-`/zero-slop inspect (your writing)` reviews without rewriting. For a folder,
-`slopscore.py --batch drafts/ --gate 25` fails above the threshold.
+Inspect a draft without changing it:
+
+```text
+/zero-slop inspect (your writing)
+```
+
+Score a file locally:
 
-## Show your score
+```sh
+npx zero-slop score draft.md
+```
 
-The badge above is this README's own, from `npx zero-slop score README.md`.
-Put yours up the same way:
+From a cloned checkout, gate a folder:
 
-```md
-[![Slop score](https://img.shields.io/badge/slop%20score-11.6%2F100-0f7d55)](https://zero-slop.ai/try/)
+```sh
+python3 scripts/slopscore.py --batch drafts/ --gate 25
 ```
 
-Colours are the scorer's bands: `0f7d55` under 25, `b8860b` under 60, `b0502c`
-above.
+Installed checks run locally; editing follows your AI assistant's privacy settings. The optional hosted MCP processes drafts remotely. See its [privacy details](mcp/README.md).
+
+### Prefer one hosted connection? Use the MCP
 
-## The slop that Zero Slop catches
+Connect the [Zero Slop MCP](https://zero-slop.ai/#mcp) once to edit drafts inside your MCP client. Its `deslop` tool returns the edit, before-and-after scores, and review status. Zero Slop requires no account or API key; server updates are managed for you.
+
+```text
+https://mcp.zero-slop.ai/mcp
+```
 
-294 weighted patterns and a 96-term lexicon, including:
+```sh
+# Codex
+codex mcp add zero-slop --url https://mcp.zero-slop.ai/mcp
 
-1. Binary contrasts: "It's not X. It's Y."
-2. Throat-clearing openers: "Here's the thing," "Let me be clear"
-3. Faux-insight setups: "What nobody tells you," "The part everyone misses"
-4. Colon reveals: "The best part: it learns."
-5. Dramatic fragments: "That's it. That's the whole thing."
-6. Superficial analysis: "highlighting the team's commitment to innovation"
-7. Importance puffery: "marks a pivotal moment," "a testament to"
-8. Weasel attribution: "experts agree," "studies show"
-9. Synonym cycling: the agent, the assistant, the tool, all one thing.
-10. Marketing riders: "robust" and "leverage" score only beside a marketing trigger, so a runbook stays quiet.
+# Claude Code
+claude mcp add --transport http zero-slop --scope user https://mcp.zero-slop.ai/mcp
+```
 
-A reading pass covers repeated shapes, crowded statistics, and paragraphs that
-shuffle without loss. [`references/eval.md`](references/eval.md) has all 80 checks.
+Follow the [MCP setup guide](https://zero-slop.ai/#mcp) for ChatGPT and other clients.
 
-Human writing scored 9 to 21 in [`data/corpus/must-not-flag/`](data/corpus/must-not-flag/);
-unedited AI drafts averaged 77 across [`bench/examples.json`](bench/examples.json).
+## What the workflow adds
 
+| A prompt alone | Zero Slop |
+|---|---|
+| “Make this sound human” leaves the target vague. | A 0–100 meter points to exact phrases and structural problems. |
+| One rewrite can quietly alter source details. | A local fact gate checks protected strings before the edit is returned. |
+| The model tends to overcorrect into fragments or forced casualness. | An overcorrection pass checks readability, rhythm, grammar, and voice. |
+| Each session starts from scratch. | Optional, reason-labelled preferences can be learned privately. |
 
-## How it works
+Zero Slop ships no model. Your AI assistant reads and edits the draft in context,
+using Claude, GPT, or another compatible model. The repository supplies the
+workflow and local tools for scoring and source checks.
 
-![Eight editorial roles, a private learning loop, and a separate release review](assets/engine.svg)
+## What it catches
 
-Eight responsibilities form one workflow. They are jobs, not separate models. An
-installed assistant can isolate them.
-The free web editor combines
-the five AI responsibilities into one model response, then runs the scorer and source
-checks locally. It makes at most one live model call and never describes that response
-as independent review. The research supports the checks, not the number eight, which
-is an engineering choice.
+The current scorer combines 294 weighted patterns with a 96-term lexicon. Examples include:
 
-| Role | Who does it | What happens |
-|---|---|---|
-| 1. Scorer | Local tools | Finds the exact phrases behind the writing score, then checks pacing and readability. It also catches overworked formatting. |
-| 2. Interpreter | Your AI assistant | Reads the claims, purpose, audience, structure, and voice before changing anything. |
-| 3. Rewriter | Your AI assistant | Removes stock language and rebuilds order, rhythm, and tone without inventing detail. |
-| 4. Fact gate | Local tools | Rejects any version that changes names, numbers, quotations, links, code, tables, paths, or structure. |
-| 5. Copy desk | Your AI assistant | Corrects grammar, spelling, usage, and consistency in the actual deliverable. |
-| 6. Read-aloud editor | Your AI assistant | Fixes stumbles, repetition, weak transitions, and awkward flow. |
-| 7. Verifier | Local tools and your AI assistant | Compares text with source for facts, meaning, qualifiers, voice, format, structure. In the web editor, source safety is checked locally. |
-| 8. Fresh-eyes finalizer | Your AI assistant | Reads the finished text as a first-time reader and applies only safe polish. Any change receives one final local recheck. |
+- binary contrast formulas: “It's not X. It's Y.”
+- canned openers: “We're thrilled to…” and “Here's the thing…”
+- vague attribution: “experts agree” and “studies show”
+- significance inflation: “marks a pivotal moment” and “a testament to”
+- promotional riders: “robust,” “seamless,” and “leverage” when used as hype
+- repeated sentence shapes, crowded statistics, and overworked formatting
 
-Missed editorial targets do not erase a useful edit or start an open-ended loop. Zero
-Slop permits one targeted repair and one local recheck, then returns the safest
-source-preserving edit with a plain warning. On the website, a failed model call falls
-back to a conservative local edit instead of retrying through more providers.
+Marketing terms are scored in context, so an ordinary technical use of a word need not trigger the same penalty. [`references/eval.md`](references/eval.md) documents all 80 checks.
 
-Studies find
-[predictable wording](https://arxiv.org/abs/2301.11305) and
-[overused vocabulary](https://arxiv.org/abs/2406.07016) in machine text, and authorship
-detectors can [misclassify non-native English](https://arxiv.org/abs/2304.02819). Local
-tools use only Python's standard library.
+Unedited AI drafts averaged 77 in [`bench/examples.json`](bench/examples.json).
+Human writing scored 9 to 21 in
+[`data/corpus/must-not-flag/`](data/corpus/must-not-flag/). These are reference
+points for the scorer, not authorship boundaries.
 
-## Private learning from your edits
+## How it works
 
-Learning starts only when you provide the original output and your edited version.
-Zero Slop does not monitor files, browsers, or publishing tools.
+![Zero Slop's eight editorial responsibilities, private learning loop, and separate release review](assets/engine.svg)
 
-Private data stays under `$ZERO_SLOP_HOME`.
+Eight responsibilities form one workflow. They are jobs, not separate models.
+Research supports the checks, not the number eight, which is an engineering
+choice.
 
-This human-in-the-loop learning never retrains the model. A profile selected by name
-can exempt existing watchlist words; it does not learn cadence, tone, or a complete
-style.
+| Stage | Job |
+|---|---|
+| 1. Scorer | Find exact phrases, pacing problems, readability issues, and overworked formatting. |
+| 2. Interpreter | Read the claims, audience, structure, and voice before editing. |
+| 3. Rewriter | Remove stock language without inventing detail. |
+| 4. Fact gate | Check names, numbers, quotations, links, code, tables, paths, and structure locally. |
+| 5. Copy desk | Fix grammar, usage, spelling, and consistency. |
+| 6. Read-aloud editor | Catch stumbles, repetition, and awkward transitions. |
+| 7. Verifier | Compare the edit with the source for meaning, qualifiers, voice, and format. |
+| 8. Fresh-eyes finalizer | Apply only safe final polish, then run one last local check. |
 
-## What's inside
+The free web editor combines the five AI responsibilities into one response and
+makes at most one live model call. A single response does not provide independent review.
+Any final change receives one final local recheck.
 
-[`SKILL.md`](SKILL.md) has the workflow and [`references/eval.md`](references/eval.md) the
-80 checks. [`scripts/slopscore.py`](scripts/slopscore.py) is the meter and fact gate,
-with [`scripts/register.py`](scripts/register.py) running the reading pass.
-[`bench/README.md`](bench/README.md) documents every benchmark with its limits.
-[zero-slop.ai](https://zero-slop.ai) has the same reference as browsable pages, plus the [benchmark in full](https://zero-slop.ai/benchmark/).
+If a repair still misses the target, Zero Slop returns the safest source-preserving edit with a plain warning. It does not enter an open-ended rewrite loop.
 
-## Testing and limits
+## Evidence and limits
 
-### Against other tools, same model, same drafts
+### Same model, same 18 drafts
 
-The saved replay ran Zero Slop, [avoid-ai-writing](https://github.com/conorbronsdon/avoid-ai-writing),
-[no-ai-slop](https://github.com/petergyang/no-ai-slop) and
-[humanizer](https://github.com/blader/humanizer) over 18 drafts with GPT-5.4, high
-reasoning, and pinned instructions. Zero Slop's outputs came from v2.5.9; later
-releases only rescore those frozen outputs.
+A saved replay ran Zero Slop and three comparable open-source instruction sets over the same drafts with GPT-5.4, high reasoning, and pinned instructions. The outputs are frozen and reproducible.
 
-| Method | Mean writing score ↓ | Passed Zero Slop's local gates | Source check passed | Average length change |
+| Method | Mean writing score ↓ | Passed local gates | Source check passed | Mean length change |
 |---|---:|---:|---:|---:|
 | Original drafts | 76.3 | 0/18 | — | — |
-| Zero Slop | 12.8 | 18/18 | 18/18 | -8.9% |
+| **Zero Slop** | **12.8** | **18/18** | **18/18** | -8.9% |
 | avoid-ai-writing | 23.3 | 15/18 | 18/18 | -14.6% |
 | no-ai-slop | 28.4 | 12/18 | 17/18 | -13.7% |
 | humanizer | 35.4 | 9/18 | 17/18 | -7.2% |
 
-![Fresh same-model editing replay on 18 drafts](assets/bench-search-rewrites.png)
+![Fresh same-model editing replay on 18 drafts, with lower scores better](assets/bench-search-rewrites.png)
 
+This small LLM-reviewed regression study measures repeatable behavior; it does not establish universal writing quality. The drafts, hashes, method versions, prompts, and limitations are in [`bench/README.md`](bench/README.md).
 
+Zero Slop's frozen outputs came from v2.5.9; newer versions only rescore those
+saved outputs. The current scorer matched the prior 84.2% result on the fixed
+38-item editorial panel. These fixed-sample checks are not field accuracy.
 
-![Method-hidden editorial preference on 18 drafts](assets/bench-incumbent-hidden.png)
+<details>
+<summary>More validation</summary>
 
-Two cross-checks: AIStoryHub clean rates and a method-hidden quality ranking.
+- A method-hidden editorial preference replay: [`bench/incumbent-blind-replay/`](bench/incumbent-blind-replay/)
+- External-checker clean rates: [`assets/bench-external-checker.png`](assets/bench-external-checker.png)
+- Method-hidden quality ranking: [`assets/bench-blind-quality.png`](assets/bench-blind-quality.png)
+- Current-model corpus measurements: [`assets/bench-raid-plus.png`](assets/bench-raid-plus.png)
+- Antithesis regression set: [`assets/bench-antithesis.png`](assets/bench-antithesis.png)
 
-![External checker clean rates per method](assets/bench-external-checker.png)
+On the 75 labelled antithesis pairs, the current reading pass reached 91.2% recall across the full set, 100% recall on shapes in reach, and 100% precision. The labels are maintainer-authored and the pairs are constructed, so this is a regression floor rather than field accuracy.
 
-![Method-hidden quality ranking, lower is better](assets/bench-blind-quality.png)
+Local speed measurements cover the checks, with editing time excluded. On one
+Apple silicon Mac, the scorer processed 1,000 documents in a median of 1.9929
+seconds (501.8 per second); the five runs ranged from 1.9614 to 2.0945 seconds.
+It scored a 15,201-word document in a median of 0.3223 seconds. The slowest
+stress case took 2.2932 seconds, and learning from an 8,000-word edit took
+0.1592 seconds. The measurements and machine details are in
+[`bench/performance-results.json`](bench/performance-results.json).
 
-This small LLM-reviewed regression study measures neither field accuracy nor a
-universal ranking. Drafts, hashes, and limits are in [`bench/README.md`](bench/README.md).
-The separate two-way replay used Zero Slop v2.6.0 and is preserved in
-[`bench/incumbent-blind-replay/`](bench/incumbent-blind-replay/).
+Across 12 interleaved runs against 2.7.7, we measured 0.54% lower median throughput,
+which is effectively unchanged. The separate two-way replay used
+Zero Slop v2.6.0.
 
-For the 38-item editorial panel, the current scorer matched the prior 84.2% result.
-All frozen scores stayed unchanged, all 18 human controls remained below the gate,
-and all 18 obvious search cases remained above it. These fixed-sample checks are not
-proof of general accuracy.
+The [RAID+ audit](bench/raid-plus-corpus/README.md) checks how the scorer responds
+to output from different models. Its pinned sample contains 7,627 usable
+generations:
 
-### Speed
+| Model | Texts scored | Mean writing score ↓ | At or above 25 |
+|---|---:|---:|---:|
+| DeepSeek V3 | 1,995 | 14.5 | 10.1% |
+| Gemini 3.1 Pro | 1,998 | 17.0 | 18.2% |
+| Gemma 3 27B | 1,634 | 21.6 | 30.4% |
+| Llama 3.3 70B | 2,000 | 25.5 | 41.7% |
 
-One Apple silicon Mac: the meter scored 1,000 documents in 1.9929 seconds
-(501.8 per second), 15,201 words in 0.3223 seconds, and the worst stress case in 2.2932
-seconds. The reading pass handled the same 1,000 in 0.7823 seconds (1278.3/second);
-learning on 8,000 words took 0.1592 seconds. Across 24 interleaved runs against 2.7.7,
-median throughput was 0.26% lower, effectively no difference. Editing is excluded.
+RAID+ labels record which model produced each text; they do not grade writing
+quality. The [Beemo paired-edit audit](bench/beemo-corpus/README.md) checks how
+scores change after human editing: raw responses averaged 30.2, expert edits
+25.3, and human answers 20.0. Beemo also lacks writing-quality labels.
 
-### Reading-pass accuracy
+</details>
 
-The reading pass budgets antithesis pairs by frequency, so the count has to be right
-before the budget means anything. On 75 labelled pairs in
-[`bench/antithesis/`](bench/antithesis/):
+### Documented capability audit
 
-| Reading pass | 2.8.0 | now |
-|---|---:|---:|
-| Recall, all shapes | 40.0% | 91.2% |
-| Recall, shapes in reach | 44.4% | 100% |
-| Precision | 80.0% | 100% |
-| False positives | 3 | 0 |
+![Documented capabilities at pinned repository versions](assets/competitor-capabilities.png)
 
-2.8.3 added the families the 58-pair corpus never tested, where 2.8.2 scores 67.5%
-precision.
+This chart says nothing about writing quality or which tool writes better. It
+records documented features at pinned commits; the data and reproduction notes
+are in [`bench/README.md`](bench/README.md).
 
-![Antithesis detection before and after, on 75 labelled pairs](assets/bench-antithesis.png)
+The design follows research on [predictable wording in machine text](https://arxiv.org/abs/2301.11305) and [overused vocabulary](https://arxiv.org/abs/2406.07016). It deliberately avoids authorship claims because detectors can [misclassify non-native English](https://arxiv.org/abs/2304.02819).
 
-Bare subject swap and the weak isocolon stay out of reach and count against recall: both
-are identical to ordinary prose on every lexical statistic. Maintainer labels on
-constructed pairs, so this is a regression floor, not field accuracy.
+## Private learning
 
-### Current models
+Learning begins only when you provide an original output and your reason-labelled edit. Zero Slop does not monitor files, browsers, or publishing tools. Private data stays under `$ZERO_SLOP_HOME`; it is not committed to this repository and does not retrain the model.
 
-The pinned [RAID+](https://huggingface.co/datasets/markstanl/RAID-Plus) sample yielded
-7,627 usable generations:
+A profile selected by name can exempt existing watchlist words. It does not
+learn cadence, tone, or a complete writing style.
 
-| Model | Texts scored | Mean writing score ↓ | At or above 25 |
-|---|---:|---:|---:|
-| DeepSeek V3 | 1,995 | 14.5 | 10.1% |
-| Gemini 3.1 Pro | 1,998 | 17.0 | 18.2% |
-| Gemma 3 27B | 1,634 | 21.6 | 30.4% |
-| Llama 3.3 70B | 2,000 | 25.5 | 41.7% |
+## Repository map
 
-RAID+ labels capture which model produced a text, not how well it reads. In
-Beemo, raw responses averaged
-30.2, expert edits 25.3, human answers 20.0. Neither dataset has quality labels.
+| Path | Purpose |
+|---|---|
+| [`SKILL.md`](SKILL.md) | The complete detect, rewrite, verify, and learn workflow |
+| [`scripts/slopscore.py`](scripts/slopscore.py) | Offline meter and source-detail gate |
+| [`scripts/register.py`](scripts/register.py) | Performed-register and reading pass |
+| [`references/`](references/) | Genre guidance, tells, safeguards, and evaluation rules |
+| [`examples/`](examples/) | Reproducible before-and-after edits |
+| [`bench/`](bench/) | Frozen benchmarks, provenance, and limitations |
+| [`mcp/`](mcp/) | Optional hosted MCP server documentation |
 
-## Where Zero Slop came from
+## Contributing and support
 
-Zero Slop builds on work by no-ai-slop, humanizer, de-slop, stop-slop, unslop-text,
-and avoid-ai-writing. It adds a writing score, source protection, separate editorial
-passes, private learning, portfolio analysis, and release tests.
+Bug reports, false positives, examples, and carefully tested pattern improvements are welcome. Read [`CONTRIBUTING.md`](CONTRIBUTING.md) before opening a pull request, use the structured [issue forms](https://github.com/manavmishra/ZeroSlop/issues/new/choose), or start a [Discussion](https://github.com/manavmishra/ZeroSlop/discussions).
 
-![Documented capabilities at pinned repository versions](assets/competitor-capabilities.png)
+For setup help and responsible disclosure, see [`SUPPORT.md`](SUPPORT.md) and [`SECURITY.md`](SECURITY.md).
 
-The chart says nothing about writing quality. Reproduce it with:
+## Credits
 
-```sh
-python3 tests/test_all.py
-python3 scripts/calibrate.py --selftest
-python3 scripts/register.py --selftest
-python3 bench/make_charts.py --check
-```
+Zero Slop builds on ideas from [no-ai-slop](https://github.com/petergyang/no-ai-slop), [humanizer](https://github.com/blader/humanizer), [de-slop](https://github.com/isatimur/de-slop), [stop-slop](https://github.com/hardikpandya/stop-slop), [unslop-text](https://github.com/JCarterJohnson/vibecoded-design-tells/tree/main/unslop-ai-text), and [avoid-ai-writing](https://github.com/conorbronsdon/avoid-ai-writing).
 
 ## License
 
-MIT
+[MIT](LICENSE)

package/SKILL.md

@@ -2,7 +2,7 @@
 name: zero-slop
 license: MIT
 metadata:
-  version: "2.8.9"
+  version: "2.8.11"
   author: manavmishra
 description: Turn drafts into sharp, natural prose or inspect them without rewriting. Zero Slop runs inside the user's existing AI assistant; Claude, GPT, or another compatible model reads and edits in context while local tools point to exact phrases and protect the source. Use when the user asks to humanize or de-slop writing, inspect AI-sounding patterns, fix text that reads like ChatGPT, polish outward-facing prose, draft social or LinkedIn content, or apply a final quality check to prose the agent generated. The workflow preserves facts, voice, and format and learns privately from repeated, reason-labelled human edits.
 ---
@@ -80,7 +80,22 @@ not eight models or services. In an installed assistant, use role-isolated passe
 the harness can do that without extra network calls. When a service has a one-request
 budget, combine the AI responsibilities into one structured editorial response and
 run the local checks before and after it. Name that consolidation honestly; one model
-response is not independent review. Keep local and AI responsibilities distinct:
+response is not independent review.
+
+Preserve source material rather than sentence count. Delete before rewriting: keep
+a sentence when it adds a fact, position, reason, example, instruction, or necessary
+connection. Delete empty sentences instead of replacing their flagged words with
+milder synonyms. Do not add a takeaway or benefit summary that repeats a nearby
+point. For example, delete “Efficiency is paramount” instead of changing it to
+“Efficiency is crucial.” After a measured improvement in setup time, do not append
+that the change “makes it easier to get started.” Preserve substantive opinions,
+emotion, and useful transitions even when they contain flagged wording. Leave clear
+factual statements and qualifications unchanged where possible. Missing knowledge
+stays missing: “not measured beyond the first month” does not establish that the
+first month was measured, and a missing feature in a new product does not establish
+that the old product had it.
+
+Keep local and AI responsibilities distinct:
 
 1. **Scorer — local tools.** Point to exact phrases and problems with rhythm,
    readability, formatting, and register; explain the writing score.
@@ -643,9 +658,13 @@ restart the complete editorial sequence. If the second check still finds a probl
 return the safest source-preserving edit and name the remaining issue plainly.
 
 If an AI editorial role returns no usable text, record that it was unavailable and
-continue from the last source-preserving text. Unavailability is an abstention, not a
-reason to retry, switch models, or replay earlier roles. A caller with a one-request
-budget must never make a second remote request. Report any role that did not complete.
+continue from the last source-preserving text. For an explicit rewrite request, if that
+text is still the unchanged source, run `python3 scripts/rescue.py -` on the source and
+pass its output through the same scorer and fact gate. This deterministic availability
+editor removes only reviewed stock wrappers and never certifies itself; label its use
+plainly. Unavailability is an abstention, not a reason to retry, switch models, or replay
+earlier roles. A caller with a one-request budget must never make a second remote
+request. Report any role that did not complete.
 
 A required repair may raise the writing score from the previous draft as long as it
 stays below the release limit. Source meaning, stated emotion, and factual accuracy
@@ -967,6 +986,9 @@ the AI model already running in the assistant or rewrite this `SKILL.md`.
   requires the section A counts to be written down rather than judged silently.
 - `references/evidence.md` — the research basis: papers, detector mechanics,
   and why each ladder rung is ordered where it is.
+- `scripts/rescue.py` — the conservative, no-network availability editor shared by
+  installed skills and the web demo. It returns a changed draft when a known safe edit
+  is available, then leaves approval to the scorer and fact gate.
 
 ## Worked example (LinkedIn)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zero-slop",
-  "version": "2.8.9",
+  "version": "2.8.11",
   "description": "An Agent Skill that scores AI-sounding prose locally, guides the host AI through an editorial rewrite, and checks changed source details. The local tools run offline with zero dependencies.",
   "bin": {
     "zero-slop": "bin/zero-slop.mjs"

package/references/eval.md

@@ -155,7 +155,10 @@ the report even when they are zero.
 
 ## B. Substance
 
-31. **Removal test.** Does every paragraph lose something real when deleted?
+31. **Removal test.** Does every paragraph lose something real when deleted? Check
+    individual sentences too. Replacing “Efficiency is paramount” with “Efficiency
+    is crucial” fails when the whole sentence is empty. Cut sentences that merely
+    restate a nearby benefit; preserve substantive opinions and useful transitions.
 32. **Relevance test.** Does every paragraph serve the brief, audience, and argument?
 33. **Front-loading, applied selectively.** Conclusions arrive early where that helps
     the reader, without forcing every section into the same point-then-detail shape.

package/scripts/rescue.py

@@ -0,0 +1,156 @@
+#!/usr/bin/env python3
+"""Conservative, deterministic editing when an AI response is unavailable.
+
+This is an availability path, not a substitute for the contextual editor. Every
+rule removes a stock wrapper, contracts a phrase, or repairs paragraph staging.
+Quoted text, code, Markdown links, URLs, names, figures, and claims are left alone.
+
+    python3 scripts/rescue.py draft.txt
+    cat draft.txt | python3 scripts/rescue.py -
+"""
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+import re
+import sys
+
+
+MAX_INPUT_BYTES = 4 * 1024 * 1024
+PROTECTED = re.compile(
+    r"```[\s\S]*?```|`[^`\n]+`|\[[^\]\n]+\]\([^)]+\)|https?://[^\s<]+|"
+    r"“[^”\n]*”|‘[^’\n]*’|\"[^\"\n]*\""
+)
+TOKEN = re.compile(r"\ue000(\d+)\ue001")
+
+
+def _sentence_pair(match: re.Match[str], *, past: bool) -> str:
+    first, second = match.group(1), match.group(2)
+    lead = first[:1].upper() + first[1:]
+    return f"{lead} {'mattered' if past else 'matters'}. " + (
+        f"More important was {second}." if past else f"The larger gain is {second}."
+    )
+
+
+def rescue_text(text: str) -> str:
+    """Return a bounded, source-preserving edit; return clean text unchanged."""
+    original = str(text or "").strip()
+    protected: list[str] = []
+
+    def mask(match: re.Match[str]) -> str:
+        protected.append(match.group(0))
+        return f"\ue000{len(protected) - 1}\ue001"
+
+    masked = PROTECTED.sub(mask, original)
+    out = re.sub(r"[\u00a0\u202f]", " ", masked)
+    rules: list[tuple[str, str | object]] = [
+        (
+            r"\bwe are thrilled to unveil ([^,\n]+),\s+a transformative release that "
+            r"redefines what is possible in ([^.]+)\.",
+            lambda m: f"{m.group(1)} updates {m.group(2)}.",
+        ),
+        (r"\bthis release represents a significant milestone in our journey to empower "
+         r"teams everywhere\.\s*", ""),
+        (r"\bwe have listened carefully to your feedback and are excited to deliver a "
+         r"suite of powerful new capabilities\.",
+         "We listened to your feedback and added new capabilities."),
+        (r"\bour cutting[-\u2010\u2011 ]edge\b", "Our"),
+        (r"\bhours of tedious manual configuration\b", "hours of manual configuration"),
+        (r"\bwe have completely reimagined\b", "We rebuilt"),
+        (r"\bwith robust error handling built in from the ground up\b",
+         "with built-in error handling"),
+        (r"\bwe believe these improvements will fundamentally transform how your team "
+         r"works,\s+and the release is available today\.", "The release is available today."),
+        (r"\bwe are incredibly excited to share(?: some news)? about\b", "We're excited about"),
+        (r"\bwe(?:['’]re| are) excited to share(?: some news)? about\b", "We're excited about"),
+        (r"\bwe are incredibly excited to share\b", "We're sharing"),
+        (r"\bwe(?:['’]re| are) excited to share\b", "We're excited about"),
+        (r"\bi(?:['’]m| am) incredibly excited to (?:share|announce)\b", "I'm sharing"),
+        (r"\bour journey\b", "our work"),
+        (r"\bour transformative journey\b", "our work"),
+        (r"\bin today'?s rapidly evolving (?:landscape|world)\b", "Today"),
+        (r"\bit is important to note that\b", ""),
+        (r"\bit is worth noting that\b", ""),
+        (r"\bwhat we did not realize was just how deeply it impacted everything downstream\.",
+         "We underestimated its effect on the work that followed."),
+        (r"\bonboarding is not a checklist\.\s*it is a promise\.",
+         "We see onboarding as a promise."),
+        (r"\bonboarding isn['’]t a checklist\s*[-—]\s*it['’]s a promise\.",
+         "We see onboarding as a promise."),
+        (r"\bthe insights were game[-\u2011]changing\.",
+         lambda m: ("Those" if m.group(0)[0].isupper() else "those")
+         + " conversations changed our approach."),
+        (r"\bthe insights were (?:transformative|clear|significant):\s*",
+         "Those conversations showed that "),
+        (r"\ba platform that leverages intelligent automation to streamline the entire "
+         r"process end to end\b", "a platform that automates onboarding from start to finish"),
+        (r"\bthe results speak for themselves:\s*([a-z])",
+         lambda m: m.group(1).upper()),
+        (r"\bthe results speak for themselves\.\s*", ""),
+        (r"\bbut here is the thing nobody talks about\.\s*", ""),
+        (r"\bthe real win was not ([^.]+)\.\s*it was ([^.]+)\.",
+         lambda m: _sentence_pair(m, past=True)),
+        (r"\bthe real win isn['’]t just ([^.]+)\.\s*it['’]s ([^.]+)\.",
+         lambda m: _sentence_pair(m, past=False)),
+        (r"\bthat is the kind of impact that keeps us going\b", "That result keeps us going"),
+        (r"\bunlock(?:ing)? the full potential of\b", "use"),
+        (r"\bseamlessly integrates?\b", "integrates"),
+        (r"\bjust how deeply\b", "how much"),
+        (r"\bgame[-\u2011]changing\b", "useful"),
+        (r"\bcutting[-\u2010\u2011 ]edge\b", "current"),
+        (r"\bredefines what(?:['’]s| is) possible in\b", "updates"),
+        (r"\bin order to\b", "to"),
+        (r"\bat the end of the day\b", "ultimately"),
+        (r"\bwe are\b", "we're"),
+        (r"\bwe did not\b", "we didn't"),
+        (r"\bwe do not\b", "we don't"),
+        (r"\bi am\b", "I'm"),
+        (r"\bit is\b", "it's"),
+        (r"\bthey are\b", "they're"),
+        (r"\byou are\b", "you're"),
+        (r"\bthere is\b", "there's"),
+        (r"\bdoes not\b", "doesn't"),
+        (r"\bis not\b", "isn't"),
+        (r"\bare not\b", "aren't"),
+        (r"\bcannot\b", "can't"),
+    ]
+    for pattern, replacement in rules:
+        out = re.sub(pattern, replacement, out, flags=re.IGNORECASE)
+    out = re.sub(r"[ \t]+\n", "\n", out)
+    out = re.sub(r" {2,}", " ", out).strip()
+
+    if out == masked:
+        paragraphs = [part.strip() for part in re.split(r"\n{2,}", out) if part.strip()]
+        if len(paragraphs) >= 4 and all(len(part.split()) < 24 for part in paragraphs):
+            out = " ".join(paragraphs)
+
+    def restore(match: re.Match[str]) -> str:
+        index = int(match.group(1))
+        return protected[index] if index < len(protected) else match.group(0)
+
+    return TOKEN.sub(restore, out).strip()
+
+
+def _read(path: str) -> str:
+    if path == "-":
+        raw = sys.stdin.buffer.read(MAX_INPUT_BYTES + 1)
+    else:
+        raw = Path(path).read_bytes()
+    if len(raw) > MAX_INPUT_BYTES:
+        raise SystemExit(f"input exceeds {MAX_INPUT_BYTES} bytes")
+    try:
+        return raw.decode("utf-8")
+    except UnicodeDecodeError as exc:
+        raise SystemExit(f"input is not valid UTF-8: {exc}") from exc
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    parser.add_argument("input", nargs="?", default="-", help="UTF-8 file, or - for stdin")
+    args = parser.parse_args(argv)
+    sys.stdout.write(rescue_text(_read(args.input)) + "\n")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/slopscore.py

@@ -1156,6 +1156,18 @@ are artificial bookmark despite hey modern please researchers save unpopular wel
 """.split())
 NOT_NAME_WORDS = {word.lower() for word in NOT_NAMES} | COMMON_WORDS
 
+# These ordinary subjects are capitalised by sentence position. Exempt only
+# the generic construction, not the word everywhere: "Efficiency raised $4M"
+# and "Efficiency Labs" still contain protected names. A quoted construction
+# remains protected by the independent quotation check.
+_ABSTRACT_SUBJECT = re.compile(
+    r"(?:^|(?<=[.!?])\s+|\n[ \t]*)"
+    r"(?P<subject>Efficiency|Productivity|Innovation|Quality|Reliability|Success|Customer)"
+    r"(?: (?:(?:experience|service|support|satisfaction)))?"
+    r" is (?:paramount|crucial|essential|important|key|everything)\b",
+    re.M,
+)
+
 
 def _peel_entity(run, prose, other):
     """The entity inside a title-case run, or None if the run holds no name.
@@ -1217,6 +1229,7 @@ def facts(text, _other=""):
     prose = re.sub(r"(?m)^\s*\d+[.)]\s+", "", prose)
     other = _spell_to_digits(_other)
     other = re.sub(r"(?m)^\s*\d+[.)]\s+", "", other)
+    ordinary_subject_positions = {m.start("subject") for m in _ABSTRACT_SUBJECT.finditer(prose)}
     out = {}
     for kind, rx in FACT_RX:
         found = set()
@@ -1224,6 +1237,8 @@ def facts(text, _other=""):
         for m in re.finditer(rx, urls if kind == "url" else prose, flags):
             v = (m.group(1) if m.lastindex else m.group(0)).strip()
             if kind == "name":
+                if m.start() in ordinary_subject_positions:
+                    continue
                 v = _peel_entity(v, prose, other)
                 if not v:
                     continue