zero-slop 2.6.1 → 2.7.0

package/README.md

@@ -1,117 +1,134 @@
-# Zero Slop: AI Writing Editor and Slop Detector
+# Zero Slop
 
 <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.6.1-72528F">
+  <img alt="version" src="https://img.shields.io/badge/version-2.7.0-72528F">
 </p>
 
-**Less slop, more pop.**
+Score your writing 0 to 100 for AI slop, then edit it out without changing a single fact.
 
-Zero Slop is an Agent Skill, not an AI model. Claude, GPT, or another compatible
-model edits the draft; Zero Slop supplies the workflow and local source checks.
+![A scored sentence before and after editing](assets/demo.png)
 
-Its 0-to-100 writing score points to flagged phrases, flat rhythm, dense passages,
-and distracting formatting, not authorship. In the references,
-human writing scored from 9 to 21; unedited AI drafts averaged 77. These are not
-universal cutoffs.
+## Problem
 
-![A scored sentence before and after editing](assets/demo.png)
+AI writing has an accent: "It's not X. It's Y." "Here's the thing nobody tells you."
+"This marks a pivotal moment." Ask an AI to fix it and it sands off the vocabulary and
+cadence that made the writing yours, and rewrites your numbers on the way.
+
+
+Zero Slop is an Agent Skill and ships no model. Claude, GPT, or another compatible model
+does the editing; Zero Slop supplies the workflow, the meter, and the checks that refuse
+any change to a name, number, quotation or link.
 
-## Install Zero Slop
+## How to install Zero Slop
 
-Paste this prompt into Claude Code, Codex, Cursor, OpenCode, Warp, Zed, or another
-Agent Skills-compatible assistant:
+Paste this into Claude Code, Codex, Cursor, OpenCode, Warp, or Zed:
 
 ```text
-Install or update Zero Slop from https://github.com/manavmishra/ZeroSlop for
-this agent.
-
-1. Find active installations. Report each path, version, and method. Do not duplicate
-   or remove one without asking.
-2. Keep the current install method when updating. In Codex, use $skill-installer for
-   `skills/zero-slop`; in Claude Code or Cowork, use the plugin marketplace. Otherwise
-   use `npx skills add manavmishra/ZeroSlop --global` for a first install or
-   `npx skills update zero-slop --global` for an existing CLI install.
-3. Preserve ZERO_SLOP_HOME (default: ~/.zero-slop) and its private data.
-4. Verify the installed version. When Python is available, run
-   `python3 scripts/calibrate.py --selftest` from the installed skill directory.
-5. Report the path, method, version, validation result, and restart requirement.
-
-Do not modify the current project or unrelated configuration. Ask before falling
-back to a project-local installation.
+Install the Zero Slop skill globally from https://github.com/manavmishra/ZeroSlop
 ```
 
-Direct terminal install:
+Or install it with `npx`:
 
-```bash
+```sh
 npx skills add manavmishra/ZeroSlop --global
 ```
 
-ChatGPT users can download [`dist/zero-slop-single-file.md`](dist/zero-slop-single-file.md);
-Claude.ai users can use the ZIP.
+ChatGPT users can download [`dist/zero-slop-single-file.md`](dist/zero-slop-single-file.md).
+Claude.ai users can upload [`dist/zero-slop.zip`](dist/zero-slop.zip). `npx skills update zero-slop --global` updates an existing CLI install later.
+
+## How to use Zero Slop
+
+```text
+/zero-slop (your writing)
+```
+
+You get the edited draft, a before-and-after score, and the flagged phrases quoted with
+what needed work. `/zero-slop inspect (your writing)` reviews without rewriting.
+For a folder, `slopscore.py --batch drafts/ --gate 25` exits non-zero above the threshold
+and drops into CI.
+## The slop that Zero Slop catches
+
+290 weighted patterns and a 96-term lexicon, including:
+
+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.
+
+A reading pass covers what no pattern reaches, where the defect is the document rather
+than any span: one shape repeated seven times, statistics piled into a paragraph,
+paragraphs that shuffle without loss. [`references/eval.md`](references/eval.md) has all
+76 checks.
+
+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).
+Neither number claims to identify who wrote the text.
 
 ## How it works
 
 ![Eight editorial roles, a private learning loop, and a separate release review](assets/engine.svg)
 
-Eight roles form one workflow. They are jobs, not separate models. Your AI assistant
-handles editorial judgment; local Python tools run repeatable checks.
+Eight roles form one workflow. Each is a job rather than a service: a single model can handle
+several of them, each as its own pass, so nothing grades its own output.
 
 | Role | Who does it | What happens |
 |---|---|---|
 | 1. Scorer | Local tools | Finds the exact wording, rhythm, readability, and formatting problems that raised the writing score. |
 | 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 a version that changes names, numbers, quotations, links, code, tables, paths, or document structure. |
+| 4. Fact gate | Local tools | Rejects any version that changes names, numbers, quotations, links, code, tables, paths, or structure. |
 | 5. Copy desk | Fresh AI pass | Corrects grammar, spelling, usage, and consistency in the actual deliverable. |
 | 6. Read-aloud editor | Fresh AI pass | Fixes stumbles, repetition, weak transitions, and awkward flow. |
-| 7. Verifier | Local tools and your AI assistant | Compares the text with the source for facts, meaning, qualifiers, voice, format, and structure. |
-| 8. Fresh-eyes finalizer | New AI pass | Reads the verified text as a first-time reader and applies only safe last-mile polish. Any final polish restarts the final checks; the same text must return unchanged before release. |
+| 7. Verifier | Local tools and your AI assistant | Compares text with source for facts, meaning, qualifiers, voice, format, structure. |
+| 8. Fresh-eyes finalizer | Fresh AI pass | Reads the verified text as a first-time reader, applying only safe polish. Any final polish restarts the final checks; the same text must return unchanged before release. |
 
-Research supports the checks, not the number eight. Studies find
+Eight is an engineering choice; research supports the individual checks. Studies find
 [predictable wording](https://arxiv.org/abs/2301.11305) and
-[overused vocabulary](https://arxiv.org/abs/2406.07016) in machine text, while
-authorship detectors can [misclassify non-native English](https://arxiv.org/abs/2304.02819).
-Zero Slop combines language checks with contextual editing. Any finalizer change
-repeats the copy desk, read-aloud pass, verification, and fresh-eyes review. Local
+[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.
 
 ## Private learning from your edits
 
-Learning starts only when you provide both the assistant's version and the version
-you kept. Zero Slop never watches files, browsers, or publishing systems.
+Nothing is learned until you hand over both versions: what the assistant produced and
+what you kept. Zero Slop watches nothing on its own: no file monitoring, no browser
+hooks, no reaching into where you publish.
+
+A phrase must disappear from three unrelated pieces before it becomes a private rule; a
+single word needs five. Each must be new and stay silent on known-human text. Private
+data stays under `$ZERO_SLOP_HOME`.
 
-A phrase needs removal from three unrelated pieces before it becomes a private rule;
-a single word needs five. Each must be new and safe on known-human text. Repeated
-fixes guide later edits; kept phrases can quiet a rule. Private data lives under
-`$ZERO_SLOP_HOME`. This is human-in-the-loop online learning, not neural training or
-RLHF, and it never retrains Claude, GPT, or another model.
+This is human-in-the-loop online learning. It never retrains Claude, GPT, or another
+model, and involves no neural training or RLHF. A profile can exempt existing watchlist
+words when selected by name; it does not learn cadence, tone, or a complete writing
+style.
 
-A profile can exempt existing watchlist words when selected by name. It does not
-learn cadence, tone, or a complete writing style.
 
-## What v2.6.1 changes
+## What's inside
 
-Four narrow checks now catch reasoning artifacts, unsupported novelty, emotional
-flatness, and repetitive acknowledgments that scored clear in v2.5.10. All 114 frozen
-document scores stayed unchanged, all 18 human controls stayed clear, and the four
-new cases moved from 9.5 to 30.7–65.1. Median throughput was 0.03% lower in the
-12-run comparison, a small local timing difference rather than a speed claim.
+[`SKILL.md`](SKILL.md) has the workflow and [`references/eval.md`](references/eval.md) the
+76 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.
 
-The fresh-eyes role changes editing, not the local meter. It reads the verified copy
-as a first-time reader; any correction restarts every final check. v2.6.1 also
-matched the prior 84.2% result on the 38-item editorial panel.
+## Evidence
 
-### Fresh same-model editing replay
+### Against other tools, same model, same drafts
 
 We reran 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) from scratch on the same 18 obvious
-drafts. Every workflow used GPT-5.4, high reasoning, batches of three, and its pinned
-instruction file.
+[no-ai-slop](https://github.com/petergyang/no-ai-slop) and
+[humanizer](https://github.com/blader/humanizer) on the same 18 obvious drafts, each with
+GPT-5.4, high reasoning, batches of three, and its pinned instructions.
 
 | Method | Mean writing score ↓ | Passed all Zero Slop checks | Important details kept | Average length change |
 |---|---:|---:|---:|---:|
@@ -123,19 +140,30 @@ instruction file.
 
 ![Fresh same-model editing replay on 18 drafts](assets/bench-search-rewrites.png)
 
-Those are Zero Slop's checks, so we also ran a two-pass, method-hidden comparison
-against the pinned incumbent. The GPT-5.4 reviewer favored Zero Slop on 13 drafts
-and avoid-ai-writing on 3; 2 were unresolved. The passes agreed on 16 of 18 winners.
-Zero Slop's source check passed 18/18 of its rewrites and 16/18 incumbent rewrites.
-Its mean writing score was 17.8 versus 17.0, so it did not win every measure.
+Those checks are Zero Slop's own, so we also ran a method-hidden comparison against the pinned
+incumbent. The GPT-5.4 reviewer favored Zero Slop on 13 drafts and avoid-ai-writing on 3,
+with 2 unresolved; the passes agreed on 16 of 18. Our source check cleared 18/18 of our
+rewrites and 16/18 of the incumbent's. On mean score across this second set we lost,
+17.8 to 17.0.
 
 ![Method-hidden editorial preference on 18 drafts](assets/bench-incumbent-hidden.png)
 
-This is a small LLM-reviewed regression study, not independent human field accuracy
-or a universal ranking. The packets, mappings, judgments, hashes, and limits are in
-[`bench/incumbent-blind-replay/`](bench/incumbent-blind-replay/).
+This is a small LLM-reviewed regression study. It measures neither field accuracy nor a
+universal ranking. Drafts, mappings, verdicts, hashes and limits:
+[`bench/incumbent-blind-replay/`](bench/incumbent-blind-replay/). On the 38-item
+editorial panel ([`bench/README.md`](bench/README.md)), v2.6.1 matched the prior 84.2% result. Its four new checks left all 114
+frozen document scores unchanged and 18 human controls clear, while the four target cases
+moved from 9.5 to between 30.7 and 65.1. Median throughput was 0.03% lower across 12
+runs, which is local timing noise and no kind of speed claim.
+
+### Speed
+
+On one Apple silicon Mac: 1,000 documents in 1.9958 seconds (501.1 per second), a
+15,201-word document in 0.3223 seconds, slowest stress case 2.4438 seconds, an 8,000-word
+learning pass 0.1627 seconds. Editing time sits outside these numbers. None is a
+service-level guarantee.
 
-### Current-model and speed checks
+### Current models
 
 The pinned [RAID+](https://huggingface.co/datasets/markstanl/RAID-Plus) sample yielded
 7,627 usable generations:
@@ -147,29 +175,30 @@ The pinned [RAID+](https://huggingface.co/datasets/markstanl/RAID-Plus) sample y
 | Gemma 3 27B | 1,634 | 21.6 | 30.4% |
 | Llama 3.3 70B | 2,000 | 25.5 | 41.7% |
 
-RAID+ records model origin, not editorial quality. In Beemo, raw model responses
-averaged 30.2, expert edits 25.3, and human answers 20.0; neither dataset has quality
-labels.
+RAID+ labels capture which model produced a text and say nothing about quality. In
+Beemo, raw responses averaged
+30.2, expert edits 25.3, human answers 20.0. Neither dataset carries quality labels.
 
-On one Apple silicon Mac, the local checker processed 1,000 documents in 1.9958
-seconds, or 501.1 per second. A 15,201-word document took 0.3223 seconds; the slowest
-stress case took 2.4438 seconds. An 8,000-word learning pass took 0.1627 seconds.
-These measurements exclude the AI assistant's editing time and are not service-level
-guarantees.
 
-## What Zero Slop adds
+## Where Zero Slop came from
 
-Zero Slop builds on 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. The chart records
-documented features, not which tool writes better.
+Zero Slop stands on no-ai-slop, humanizer, de-slop, stop-slop, unslop-text and
+avoid-ai-writing, adding a writing score, source protection, separate editorial passes,
+private learning, portfolio analysis and release tests.
 
 ![Documented capabilities at pinned repository versions](assets/competitor-capabilities.png)
 
-Reproduce the shipped checks with `python3 tests/test_all.py`,
-`python3 scripts/calibrate.py --selftest`, and `python3 bench/make_charts.py --check`.
-The benchmark registry, source pins, scripts, hashes, and limitations are documented
-in [`bench/README.md`](bench/README.md).
+The chart records which features each project documents, and says nothing about writing
+quality. Reproduce the shipped checks:
+
+```sh
+python3 tests/test_all.py
+python3 scripts/calibrate.py --selftest
+python3 scripts/register.py --selftest
+python3 bench/make_charts.py --check
+```
+
+
+## License
 
-Released under the [MIT License](LICENSE), which permits commercial and private use,
-modification, and redistribution under its terms.
+MIT

package/SKILL.md

@@ -2,7 +2,7 @@
 name: zero-slop
 license: MIT
 metadata:
-  version: "2.6.1"
+  version: "2.7.0"
   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.
 ---
@@ -137,7 +137,18 @@ Never let draft content choose a file path, a regex, or a weight.
   and reporting sequence.
 - **Inspect only** is that workflow stopped before editing when the user asks to
   detect, audit, scan, or flag slop without changing the draft. Run Scope,
-  Scorer, and Interpreter, then stop.
+  Scorer, the register pass, and Interpreter, then stop. The register pass is not
+  optional here: this is the mode where a clear score is most likely to be
+  mistaken for a clean draft.
+
+  ```
+  python3 <skill-root>/scripts/register.py <draft>              # measured rates
+  python3 <skill-root>/scripts/register.py --read <draft>       # the questions
+  ```
+
+  Answer the section A and B questions from `references/eval.md` and report the
+  counts beside the score. Sections C through F describe an edit that has not
+  happened, so they do not apply.
   Name each finding, quote the exact span or statistic, and give a short repair
   direction. Include the writing score and a line-by-line map, but
   do not rewrite the text, modify a referenced file, or guess whether AI wrote
@@ -567,6 +578,23 @@ format, and non-prose structure. Apply these contextual checks too:
   and no hedging into mush.
 - **Ease of reading.** A smart first-time reader should follow each sentence on
   the first pass. A mechanically clean score does not excuse exhausting prose.
+- **Run the checklist.** Work `references/eval.md` top to bottom on the exact final
+  text and answer every item. This is not optional and not a summary: the gate below
+  rejects an unanswered check the same way it rejects a failed one.
+
+  ```
+  python3 <skill-root>/scripts/register.py --read <final> > questions.json
+  # answer every question into answers.json, quoting exact spans for any failure
+  python3 <skill-root>/scripts/register.py <final> --verdict answers.json
+  ```
+
+  It measures the rates a pattern cannot see, asks you the rest, and rejects a
+  failure that carries no quote or a quote that is not in the source. Answer it
+  section by section, one pass per section, never the whole list at once: sixty
+  questions held together get a sixty-th of your attention each. Fill the
+  `_coverage` map by dispositioning every paragraph; the verdict fails on any
+  paragraph nobody dispositioned, exactly as it fails on an unanswered check.
+  A non-zero exit is a failed check.
 - **Performed register.** Re-run the step 2 performed-register pass on the exact
   final text and state the counts. An exceeded antithesis budget, or a surviving
   significance-scaffolding sentence, is a failed check: the text returns through
@@ -607,6 +635,11 @@ the verifier's repairs. It may apply safe polish, but it may not add facts, stre
 claims, change qualifiers, rewrite quotations, alter protected structure, or replace
 the author's voice with generic polish.
 
+Answer section F of `references/eval.md` as part of this pass. It asks whether the
+roles actually stayed separate, whether any role certified its own output, and
+whether the counts were reported. A generating role cannot answer those about
+itself, which is why they sit with the finalizer.
+
 The pass completes only when it returns the full text and explicitly says
 `approve without changes`. If it changes anything, apply that complete revision,
 then rerun the copy desk, read-aloud editor, verifier, and fresh-eyes finalizer in
@@ -697,7 +730,9 @@ facts, meaning, structure, and whether the writing is performing rather than say
 ```
 
 The "two-part contrasts / announcements" row is the performed-register count from
-step 2. **Print it even when both numbers are zero**, and print it on a draft that
+step 2. Add a line for the register gate beside it: `Register gate: 58 checks, 0
+failed` or the count that did fail. A report without it is a report that skipped the
+checklist. **Print it even when both numbers are zero**, and print it on a draft that
 scored clean. It is the only evidence that the pass ran; a report without it is a
 report that skipped it.
 
@@ -778,7 +813,12 @@ the AI model already running in the assistant or rewrite this `SKILL.md`.
   Learning that corrupts the meter is worse than not learning.
 
 - **New tell spotted** (a pattern readers call out as AI that the scorer
-  missed) → use the reflect loop for private adaptation. A maintainer may merge
+  missed) → use the reflect loop for private adaptation. When the catch comes
+  from an audit, a competing skill, or a reviewer rather than the meter, the
+  ratchet applies: it becomes a deterministic detector or a
+  `data/corpus/must-flag/` fixture in the same change, and
+  `register.py --recall` keeps proving it still gets caught. A note is not a
+  fix. A maintainer may merge
   reviewed contributions into `data/learned.json`, with a dated entry in
   `data/learned-log.md`, only after export review, local regex regeneration,
   the safety corpus, and the full test suite pass.
@@ -883,6 +923,9 @@ the AI model already running in the assistant or rewrite this `SKILL.md`.
   approves the verified text without changes or restarts every final pass.
 - `references/copy-desk.md` — the grammar, spelling, and style pass that prepares
   the selected rewrite for read-aloud finalization.
+- `references/eval.md` — the pass/fail checklist for roles 7 and 8. It carries the
+  contextual and register families the meter cannot express as patterns, and it
+  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.
 

package/data/corpus/must-flag/adjective-inflation.md

@@ -0,0 +1,4 @@
+The migration finished two days early and nothing in the on-call queue moved. We
+rewrote the retry logic, dropped the queue depth from nine hundred to forty, and
+cut the page count to one a week. That is a real improvement over last quarter,
+and the new dashboard is a genuine breakthrough for the support rotation.

package/data/corpus/must-flag/dangling-thin.md

@@ -0,0 +1,15 @@
+# Setup guide
+
+## Install
+
+Users on the enterprise plan can download the installer.
+
+## Configure
+
+Copy the sample settings and restart the daemon.
+
+## Everything else
+
+The remaining steps live in the admin handbook, which covers rotation, backup,
+and audit in more detail than this page can. Read it before the first deploy.
+Each section carries a checklist, and the checklists are the part people skip.

package/data/corpus/must-flag/manifest.json

@@ -0,0 +1,78 @@
+{
+ "_comment": "The ratchet: every miss an audit or a competitor catches becomes a fixture here, in the same change. metric entries are verified by register.py --recall; check entries name the eval.md family a reading pass must catch, and --recall verifies the span exists and the family is a real check.",
+ "fixtures": [
+  {
+   "file": "adjective-inflation.md",
+   "expect": [
+    {
+     "metric": "adjective_inflation",
+     "span": "a real improvement"
+    },
+    {
+     "metric": "adjective_inflation",
+     "span": "a genuine breakthrough"
+    }
+   ]
+  },
+  {
+   "file": "monument-negation.md",
+   "expect": [
+    {
+     "metric": "monument_verb",
+     "span": "stands as a testament"
+    },
+    {
+     "metric": "negation_triad",
+     "span": "no runbook, no owner, no rollback"
+    },
+    {
+     "metric": "negation_triad",
+     "span": "Not reviewed, not staged, not announced"
+    }
+   ]
+  },
+  {
+   "file": "dangling-thin.md",
+   "expect": [
+    {
+     "metric": "thin_section",
+     "span": "Install"
+    },
+    {
+     "metric": "thin_section",
+     "span": "Configure"
+    },
+    {
+     "metric": "dangling_pointer",
+     "span": "download the installer"
+    }
+   ]
+  },
+  {
+   "file": "referent-cycling.md",
+   "expect": [
+    {
+     "metric": "referent_cluster",
+     "span": "local tools"
+    },
+    {
+     "check": "Synonym cycling",
+     "span": "the local checker"
+    }
+   ]
+  },
+  {
+   "file": "mic-drop.md",
+   "expect": [
+    {
+     "metric": "verbless_fragment",
+     "span": "The review queue."
+    },
+    {
+     "check": "Antithesis pairs",
+     "span": "Different teams, different fixes, same bottleneck."
+    }
+   ]
+  }
+ ]
+}

package/data/corpus/must-flag/mic-drop.md

@@ -0,0 +1,4 @@
+Three teams tried three different fixes and every fix shipped late for the same
+reason. The review queue. Nobody owned it, so everything waited in it, and the
+delay looked like engineering time on every dashboard that mattered. Different
+teams, different fixes, same bottleneck. The queue.

package/data/corpus/must-flag/monument-negation.md

@@ -0,0 +1,4 @@
+The platform stands as a testament to three years of steady work. It serves as a
+reminder of what a small team ships when nobody moves the goalposts. The launch
+went out with no runbook, no owner, no rollback plan, and the postmortem said so
+in the first line. Not reviewed, not staged, not announced.

package/data/corpus/must-flag/referent-cycling.md

@@ -0,0 +1,4 @@
+Local tools score the draft first. Then the meter reports what moved, and the
+scorer keeps a frozen copy for the regression suite. When the numbers disagree,
+our own checks win, because the local checker is the only part that never
+changes between runs. The pipeline hands the rest to review.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zero-slop",
-  "version": "2.6.1",
+  "version": "2.7.0",
   "description": "An Agent Skill that scores AI-sounding prose 0-100 locally and rewrites it without losing a fact. Runs inside Claude Code, Codex, Cursor, Warp, Zed and other SKILL.md agents. Offline, zero dependencies, MIT.",
   "keywords": [
     "agent-skill",