zero-slop 2.7.1 → 2.7.7

package/README.md

@@ -5,23 +5,20 @@
   <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.7.1-72528F">
+  <img alt="version" src="https://img.shields.io/badge/version-2.7.7-72528F">
 </p>
 
-Score your writing 0 to 100 for AI slop, then edit it out without changing a single fact.
+Take all the slop out of your AI writing. The #1 agentic anti-slop skill.
+
+Score your writing 0 to 100 for AI slop, see the exact phrases behind the number, and edit them out without changing a single fact. Free, MIT, scored offline with no account. Worked examples and the full benchmark are at [zero-slop.ai](https://zero-slop.ai).
 
 ![A scored sentence before and after editing](assets/demo.png)
 
 ## Problem
 
-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.
-
+AI writing has a distinct tell: "It's not X. It's Y." "Here's the thing nobody tells you." 
 
-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.
+Zero Slop is an Agent Skill and ships no model. Claude, GPT, or another compatible model does the editing; Zero Slop supplies the workflow and the checks that refuse any change to a name, number, quotation or link. It runs in Claude Code, Cowork, Codex, Cursor, Warp, Zed, and any other harness that reads SKILL.md.
 
 ## How to install Zero Slop
 
@@ -37,8 +34,15 @@ Or install it with `npx`:
 npx skills add manavmishra/ZeroSlop --global
 ```
 
+Or from the registry, which also installs the scorer as a command:
+
+```sh
+npx zero-slop install          # add --harness codex|cursor|opencode|zed
+npx zero-slop score draft.md   # score without installing anything
+```
+
 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.
+Claude.ai users can upload [`dist/zero-slop.zip`](dist/zero-slop.zip). `npx skills update zero-slop --global` updates it later.
 
 ## How to use Zero Slop
 
@@ -46,40 +50,37 @@ Claude.ai users can upload [`dist/zero-slop.zip`](dist/zero-slop.zip). `npx skil
 /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.
+You get the edited draft, a before-and-after score, and the flagged phrases quoted with why. `/zero-slop inspect (your writing)` reviews without rewriting.
+For a folder, `slopscore.py --batch drafts/ --gate 25` fails the build above the threshold.
+
 ## 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,
+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 defects of the whole document, which no span pattern reaches: 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.
+80 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. 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.
+Eight roles form one workflow. Each is a job rather than a service, run as its own pass so nothing grades its own output. The research supports the checks, not the number eight, which is an engineering choice.
 
 | Role | Who does it | What happens |
 |---|---|---|
@@ -92,7 +93,7 @@ several of them, each as its own pass, so nothing grades its own output.
 | 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. |
 
-Eight is an engineering choice; research supports the individual checks. Studies find
+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
@@ -100,12 +101,10 @@ tools use only Python's standard library.
 
 ## Private learning from your edits
 
-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
+Learning starts only when you hand over both versions: the original output and your edited version. 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
+Private
 data stays under `$ZERO_SLOP_HOME`.
 
 This is human-in-the-loop online learning. It never retrains Claude, GPT, or another
@@ -113,13 +112,13 @@ model, and involves no neural training or RLHF. A profile can exempt existing wa
 words when selected by name; it does not learn cadence, tone, or a complete writing
 style.
 
-
 ## What's inside
 
 [`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,
+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/).
 
 ## Evidence
 
@@ -127,7 +126,7 @@ with [`scripts/register.py`](scripts/register.py) running the reading pass.
 
 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) on the same 18 obvious drafts, each with
+[humanizer](https://github.com/blader/humanizer) on the same   samples, 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 |
@@ -140,28 +139,31 @@ GPT-5.4, high reasoning, batches of three, and its pinned instructions.
 
 ![Fresh same-model editing replay on 18 drafts](assets/bench-search-rewrites.png)
 
-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)
 
+Cross-checks the tools didn't build: the AIStoryHub checker's clean
+rates, and a method-hidden quality ranking.
+
+![External checker clean rates per method](assets/bench-external-checker.png)
+
+![Method-hidden quality ranking, lower is better](assets/bench-blind-quality.png)
+
 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.
+editorial panel ([`bench/README.md`](bench/README.md)), v2.7.7 matched the prior 84.2% result
+with every frozen document score unchanged, all 18 human controls clear and all 18 search
+cases still caught: the release moves what the gate asks and leaves the meter
+untouched. Median throughput was 3.51% 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.
+On one Apple silicon Mac: 1,000 documents in 2.1956 seconds (455.5 per second), a
+15,201-word document in 0.3225 seconds, the slowest stress case in 2.2577 seconds, an
+8,000-word learning pass in 0.1811 seconds. Editing time is excluded; expect different numbers on different machines.
 
 ### Current models
 
@@ -175,21 +177,19 @@ 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+ labels capture which model produced a text and say nothing about quality. In
+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 carries quality labels.
-
+30.2, expert edits 25.3, human answers 20.0. Neither dataset has quality labels.
 
 ## Where Zero Slop came from
 
-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,
+Zero Slop enhances work done by  no-ai-slop, humanizer, de-slop, stop-slop, unslop-text and
+avoid-ai-writing, by adding a slop score, source protection, separate editorial passes,
 private learning, portfolio analysis and release tests.
 
 ![Documented capabilities at pinned repository versions](assets/competitor-capabilities.png)
 
-The chart records which features each project documents, and says nothing about writing
-quality. Reproduce the shipped checks:
+The chart records which features each project documents. It says nothing about writing quality and is not a claim about which tool writes better. Reproduce by using these tests:
 
 ```sh
 python3 tests/test_all.py
@@ -198,7 +198,6 @@ python3 scripts/register.py --selftest
 python3 bench/make_charts.py --check
 ```
 
-
 ## License
 
 MIT

package/SKILL.md

@@ -2,7 +2,7 @@
 name: zero-slop
 license: MIT
 metadata:
-  version: "2.7.1"
+  version: "2.7.7"
   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.
 ---
@@ -165,7 +165,9 @@ conversation, a linked or supplied sample, or none). A sample-built, named
 scoring profile under `$ZERO_SLOP_HOME/voices/` contains only existing
 watchlist-word exceptions. It does not contain the sample or capture the
 writer's cadence, syntax, humor, or tone. Skip code blocks, quotes, and legal
-boilerplate.
+boilerplate — but only the quoted or boilerplate words themselves: the authored frame
+around them (labels, emphasis, list geometry) is the writer's prose and stays in
+scope.
 **Record the input format** — pasted text, .md, .docx, .pdf,
 .html, .txt, a JSON field — because the output must come back in that same
 format (step 9). Take a form inventory: decide which parts of the document are

package/bin/zero-slop.mjs

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+// The npm package shipped four versions with no bin, no main and no scripts, so
+// `npx zero-slop` did nothing and every real install went through the `skills`
+// CLI against GitHub instead. That left the registry download count measuring
+// mirrors rather than people. This is the executable half: it installs the same
+// runtime the tarball already carries, and runs the scorer without a checkout.
+
+import { cp, mkdir, readFile, rm, stat } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const PAYLOAD = ["SKILL.md", "references", "scripts", "data"];
+
+// Where each harness reads global skills from. `skills add` knows this mapping
+// too; it is repeated here so the package works without that CLI installed.
+const HARNESS_DIRS = {
+  claude: ".claude/skills",
+  codex: ".codex/skills",
+  cursor: ".cursor/skills",
+  opencode: ".config/opencode/skills",
+  zed: ".config/zed/skills",
+};
+
+async function version() {
+  const pkg = JSON.parse(await readFile(join(ROOT, "package.json"), "utf8"));
+  return pkg.version;
+}
+
+function usage(v) {
+  return `zero-slop ${v} — score AI-sounding prose 0-100 and edit it out.
+
+Usage
+  npx zero-slop install [--harness <name>] [--dir <path>] [--force]
+  npx zero-slop score <file>... [-- <slopscore flags>]
+  npx zero-slop where
+  npx zero-slop --version
+
+Install targets
+  --harness   ${Object.keys(HARNESS_DIRS).join(", ")}   (default: claude)
+  --dir       install into an explicit directory instead
+  --force     overwrite an existing installation
+
+Examples
+  npx zero-slop install                    # ~/.claude/skills/zero-slop
+  npx zero-slop install --harness codex
+  npx zero-slop score draft.md
+  npx zero-slop score drafts/ -- --batch --gate 25
+
+Docs: https://zero-slop.ai   Source: https://github.com/manavmishra/ZeroSlop`;
+}
+
+function parseArgs(argv) {
+  const flags = {};
+  const rest = [];
+  let passthrough = [];
+  for (let i = 0; i < argv.length; i += 1) {
+    const a = argv[i];
+    if (a === "--") {
+      passthrough = argv.slice(i + 1);
+      break;
+    }
+    if (a === "--force") flags.force = true;
+    else if (a === "--harness" || a === "--dir") flags[a.slice(2)] = argv[++i];
+    else if (a.startsWith("--harness=")) flags.harness = a.split("=")[1];
+    else if (a.startsWith("--dir=")) flags.dir = a.split("=")[1];
+    else rest.push(a);
+  }
+  return { flags, rest, passthrough };
+}
+
+function targetDir(flags) {
+  if (flags.dir) return resolve(flags.dir);
+  const harness = flags.harness ?? "claude";
+  const base = HARNESS_DIRS[harness];
+  if (!base) {
+    throw new Error(
+      `unknown harness "${harness}". Known: ${Object.keys(HARNESS_DIRS).join(", ")}`,
+    );
+  }
+  return join(homedir(), base, "zero-slop");
+}
+
+async function exists(p) {
+  try {
+    await stat(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function install(flags) {
+  const dest = targetDir(flags);
+  if ((await exists(dest)) && !flags.force) {
+    console.error(
+      `zero-slop is already installed at ${dest}\n` +
+        `Re-run with --force to overwrite it, or --dir to install elsewhere.`,
+    );
+    return 1;
+  }
+  // Replace rather than merge: a stale reference file left behind by an older
+  // version is a silent behaviour change, which is the failure this avoids.
+  await rm(dest, { recursive: true, force: true });
+  await mkdir(dest, { recursive: true });
+  for (const entry of PAYLOAD) {
+    await cp(join(ROOT, entry), join(dest, entry), { recursive: true });
+  }
+  console.log(`Installed zero-slop ${await version()} into ${dest}`);
+  console.log("Restart your agent, then run: /zero-slop (your writing)");
+  return 0;
+}
+
+function runScorer(args) {
+  return new Promise((resolvePromise) => {
+    const script = join(ROOT, "scripts", "slopscore.py");
+    const child = spawn("python3", [script, ...args], { stdio: "inherit" });
+    child.on("error", (err) => {
+      if (err.code === "ENOENT") {
+        console.error(
+          "python3 was not found on PATH. The scorer is a standard-library " +
+            "Python program and needs Python 3 to run.",
+        );
+        resolvePromise(127);
+        return;
+      }
+      console.error(err.message);
+      resolvePromise(1);
+    });
+    child.on("close", (code) => resolvePromise(code ?? 0));
+  });
+}
+
+async function main() {
+  const argv = process.argv.slice(2);
+  const { flags, rest, passthrough } = parseArgs(argv);
+  const command = rest[0];
+  const v = await version();
+
+  if (argv.includes("--version") || argv.includes("-v")) {
+    console.log(v);
+    return 0;
+  }
+  if (!command || argv.includes("--help") || argv.includes("-h") || command === "help") {
+    console.log(usage(v));
+    return command || argv.length ? 0 : 0;
+  }
+  if (command === "install") return install(flags);
+  if (command === "where") {
+    console.log(targetDir(flags));
+    return 0;
+  }
+  if (command === "score") {
+    const files = rest.slice(1);
+    if (!files.length && !passthrough.length) {
+      console.error("score needs at least one file. See: npx zero-slop --help");
+      return 2;
+    }
+    return runScorer([...files, ...passthrough]);
+  }
+
+  console.error(`unknown command "${command}". See: npx zero-slop --help`);
+  return 2;
+}
+
+main()
+  .then((code) => process.exit(code))
+  .catch((err) => {
+    console.error(err.message);
+    process.exit(1);
+  });

package/data/corpus/must-flag/caveat-template.md

@@ -0,0 +1,21 @@
+# Quarterly metrics review
+
+## Traffic
+
+Sessions rose from 41,200 to 48,900 after the March relaunch, with mobile
+carrying most of the gain. Neither figure includes bot traffic.
+
+## Revenue
+
+Subscription revenue reached $212,000 against a $195,000 target, driven by the
+annual-plan discount that ran through April. None of these numbers are audited.
+
+## Support
+
+Median first-response time fell from 9 hours to 4 after the queue rework. No
+figure here covers weekend tickets.
+
+## Hiring
+
+Two of the three open platform roles closed in under six weeks. Neither offer
+has been announced.

package/data/corpus/must-flag/classifier-scaffolding.md

@@ -0,0 +1,19 @@
+# What the logging migration cost
+
+The economics are simple. Storage is cheap and cardinality is not, so a
+pipeline that indexes every label pays for the labels rather than the bytes.
+
+We ingested 4TB a day across 240 services. The dangerous part is that the bill
+arrived monthly while the cardinality grew hourly, so the first three alerts
+looked like billing errors.
+
+Sampling debug lines at 1% took ingest to 900GB a day. The gap between the two
+figures has a simple cause: 78% of the volume came from one library's retry
+logging, which nobody had read since the library shipped.
+
+The score has limits worth stating. It counts what it can see, and the rest is
+the reader's judgment.
+
+One honest caveat before the numbers: this is a single fleet over one quarter,
+and the shape of the saving depends on how your services log. Those are the
+ones that matter when you plan your own migration.

package/data/corpus/must-flag/label-period-list.md

@@ -0,0 +1,10 @@
+# Release review checklist
+
+Before every release the platform team walks the same four gates:
+
+1. **Latency.** "p99 under 200ms on the checkout path."
+2. **Rollback.** "One command, under five minutes, no data loss."
+3. **Access.** "No new scopes without a security sign-off."
+4. **Comms.** "Status page drafted before the deploy starts."
+
+The quoted bars come from the SRE handbook and have not changed since March.

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

@@ -73,6 +73,70 @@
      "span": "Different teams, different fixes, same bottleneck."
     }
    ]
+  },
+  {
+   "file": "caveat-template.md",
+   "expect": [
+    {
+     "check": "Robotic symmetry",
+     "span": "Neither figure includes bot traffic"
+    }
+   ]
+  },
+  {
+   "file": "label-period-list.md",
+   "expect": [
+    {
+     "check": "List-label periods and bare-noun bullets",
+     "span": "**Latency.**"
+    }
+   ]
+  },
+  {
+   "file": "unnamed-validator.md",
+   "expect": [
+    {
+     "check": "Weasel attribution",
+     "span": "An external audit"
+    },
+    {
+     "check": "Weasel attribution",
+     "span": "A\nthird-party checker"
+    }
+   ]
+  },
+  {
+   "file": "classifier-scaffolding.md",
+   "expect": [
+    {
+     "metric": "classifier_scaffolding",
+     "span": "The economics are simple"
+    },
+    {
+     "metric": "classifier_scaffolding",
+     "span": "The dangerous part is"
+    },
+    {
+     "metric": "classifier_scaffolding",
+     "span": "has a simple cause"
+    },
+    {
+     "metric": "classifier_scaffolding",
+     "span": "limits worth stating"
+    },
+    {
+     "metric": "classifier_scaffolding",
+     "span": "One honest caveat"
+    },
+    {
+     "metric": "classifier_scaffolding",
+     "span": "the ones that matter"
+    },
+    {
+     "check": "Interpretive metadiscourse",
+     "span": "It counts what it can see, and the rest is the reader's judgment."
+    }
+   ]
   }
  ]
 }

package/data/corpus/must-flag/unnamed-validator.md

@@ -0,0 +1,8 @@
+# Migration results
+
+We moved the billing service to the new queue in April. Median settlement time
+fell from 41 seconds to 9, and the duplicate-charge rate dropped to zero across
+1.2 million transactions.
+
+An external audit reviewed the cutover and found no unresolved issues. A
+third-party checker also rated the new pipeline clean on every run it sampled.

package/package.json

@@ -1,7 +1,10 @@
 {
   "name": "zero-slop",
-  "version": "2.7.1",
+  "version": "2.7.7",
   "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.",
+  "bin": {
+    "zero-slop": "bin/zero-slop.mjs"
+  },
   "keywords": [
     "agent-skill",
     "agent-skills",
@@ -32,6 +35,7 @@
     "url": "https://zero-slop.ai/about/"
   },
   "files": [
+    "bin/",
     "SKILL.md",
     "references/",
     "scripts/",

package/references/eval.md

@@ -30,6 +30,11 @@ Scoring this file is meaningless: it quotes tells as examples, so the meter flag
 own catalogue. That is the documented exception for material quoted as an example, and
 it is a good candidate for `data/corpus/must-not-flag/`.
 
+The exception covers only the quoted words. The authored frame around a quotation —
+the label that introduces it, emphasis on that label, the list geometry it sits in —
+is the writer's own prose and every check here applies to it. A line is never exempt
+merely because part of it is quoted.
+
 ## A. Register, which the meter cannot reach
 
 Run every item on every draft, including one that scored clear. Record the counts in
@@ -77,10 +82,23 @@ the report even when they are zero.
     significance: highlighting, underscoring, reflecting, showcasing.
 15. **Importance puffery.** "Marks a pivotal moment." "Stands as a testament." State
     the fact and let the reader weigh it.
-16. **Interpretive metadiscourse.** Lines that step outside the subject to tell the
-    reader what to notice or how much weight to give it.
+16. **Interpretive metadiscourse. Count per 1,000 words: ___** Lines that step outside
+    the subject to tell the reader what to notice or how much weight to give it. Two
+    forms, and the flat one is the one that survives every other channel. Theatrical:
+    "Here's the detail that matters:" Flat: "The economics are simple." "The dangerous
+    part is that slop feels fast." "The score has limits worth stating." "One honest
+    caveat before the ranking." Each grades, previews or ranks the point instead of
+    delivering it, and each reads as ordinary prose, so a clear writing score is no
+    evidence at all. Test every candidate by deletion: if the sentence after it still
+    lands, the classifier was scaffolding. Anchored stems are counted for you; the
+    shapes no stem reaches are yours to find, because whether a sentence earns its
+    claim is a judgment and not a match. A zero on the anchored count is not an
+    answer to this check and never closes it: the stems match the shapes they were
+    built from, and this family's whole character is that it arrives in new ones.
 17. **Weasel attribution.** "Studies show." "Experts agree." Name the source, or flag
-    it for the writer. Never invent one.
+    it for the writer. Never invent one. An unnamed validator is the same defect —
+    "an external checker", "a third-party audit", "an independent review" — name the
+    tool or the auditor, or flag it.
 18. **Adjective inflation and hollow intensifiers.** "a real improvement", "actual
    results", "a genuine breakthrough", "true value". Delete the adjective; the noun
    carries the claim or it does not. Distinct from empty adverbs (next): adverbs pad
@@ -176,6 +194,17 @@ the report even when they are zero.
 47. **Wall-of-text reply.** Paragraphing that hides a sequence the reader needs. A
     long narrative paragraph is not a wall of text merely because it is long; the tell
     is a buried list of steps or options.
+47a. **Compression standing in for editing. `reorder_ratio`: ___** Cutting and
+    reordering are different edits and they do not produce the same draft. Subtraction
+    leaves every surviving sentence exactly where the model put it, so a shorter draft
+    can read more machine-shaped than the one it replaced; a measured case scored the
+    original 83 for predictability, the compressed rewrite 92, and the reordered
+    rewrite 58. A ratio near zero on a rewrite that cut a lot of words means the ladder
+    delivered its lexicon and formatting rungs and skipped its order rung. That is not
+    automatically wrong: a draft whose argument already arrives in the right sequence
+    should keep it, and shuffling a sound structure to move a number is exactly the
+    over-correction hard rule 3 forbids. What the check forbids is not noticing. Say
+    which one happened and why the order you shipped is the right one.
 
 ## C. Fidelity
 
@@ -196,6 +225,18 @@ the report even when they are zero.
     source, never a word list.
 53. **Non-prose untouched.** Code, front matter, tables, blockquotes, identifiers,
     paths, and heading hierarchy intact.
+53a. **Every dropped figure ruled, not defaulted.** The gate protects every number
+    it sees and cannot tell a measured fact from a flourish, because the difference
+    is whether a source stands behind it and that lives in the document, not in the
+    digits. So it hands you each dropped figure with the sentence it came from
+    (`figure_evidence`) and waits. Rule on each one: a figure with a source, a unit,
+    a baseline or a citation must be restored; an unsourced multiplier or statistic
+    doing an intensifier's job -- "the 10x move", "tenfold", "~70% of pilots fail" --
+    was right to cut, and you record that ruling rather than letting the gate assume
+    it. Never invent a citation to keep a number alive. Unruled means unresolved:
+    the default is that the figure stays, so silence here is a failed check and not
+    a pass. Both errors are real. Restoring a flourish is how a rewrite ships fake
+    precision, and dropping a measurement is how it ships a lie.
 
 ## D. Voice and readability
 

package/scripts/register.py

@@ -38,6 +38,7 @@ BUDGETS = {
     "subtractive_contrast": (6.0, 3),
     "comma_series": (26.0, 8),
     "significance_scaffolding": (0.0, 1),
+    "classifier_scaffolding": (1.5, 1),
     "inanimate_agent": (4.0, 2),
     "repeated_openings": (3.0, 2),
     # Added after a three-way audit found eight families the reading pass missed
@@ -71,6 +72,29 @@ RX_SIGNIFICANCE = re.compile(
     re.I,
 )
 
+# The mild half of announced significance: a clause that grades, previews or
+# ranks the point instead of delivering it. RX_SIGNIFICANCE above catches the
+# theatrical form ("Here's the detail that matters:"); these are the flat
+# classifiers that read as ordinary prose and scored clear on every channel --
+# "The economics are simple", "the ones that matter", "limits worth stating".
+# Found by running a competing skill over ten already-clean pages, so the
+# ratchet applies: the anchors ship here and data/corpus/must-flag keeps them
+# honest. The shapes no anchor reaches are asked of the reader in eval.md A11,
+# because whether a sentence earns its claim is a judgment, not a match.
+# Wrapped prose is still prose: the separators are \s+ so a tell that happens to
+# straddle a line break is still counted.
+RX_CLASSIFIER = re.compile(
+    r"\b(?:the\s+\w+\s+(?:is|are|was|were)\s+simple"
+    r"|(?:has|have|had)\s+a\s+simple\s+\w+"
+    r"|the\s+(?:dangerous|important|interesting|tricky|hard|scary|surprising|real)"
+    r"\s+(?:part|thing|bit|point|question)\s+(?:here\s+)?is"
+    r"|worth\s+(?:stating|sitting\s+with|pausing\s+on|dwelling\s+on)"
+    r"|the\s+ones?\s+that\s+(?:actually\s+)?matters?"
+    r"|(?:one|an)\s+honest\s+(?:caveat|note|admission|answer)"
+    r"|that\s+is\s+the\s+(?:finding|part|point)\s+worth)\b",
+    re.I,
+)
+
 # Inanimate subjects performing human verbs. no-ai-slop catches this family by
 # asking; here it is the lexically anchored subset of it.
 RX_INANIMATE = re.compile(
@@ -252,6 +276,7 @@ def measure(text: str) -> dict:
     subtractive = [" ".join(m.split()) for m in RX_SUBTRACTIVE.findall(prose)]
     series = RX_SERIES.findall(prose)
     significance = [" ".join(m.split()) for m in RX_SIGNIFICANCE.findall(prose)]
+    classifier = [" ".join(m.group(0).split()) for m in RX_CLASSIFIER.finditer(prose)]
     inanimate = [" ".join(m.split()) for m in RX_INANIMATE.findall(prose)]
 
     openings = sentence_openings(prose)
@@ -290,6 +315,7 @@ def measure(text: str) -> dict:
         "subtractive_contrast": {"count": len(subtractive), "per_1k": per_k(len(subtractive)), "hits": subtractive[:12]},
         "comma_series": {"count": len(series), "per_1k": per_k(len(series))},
         "significance_scaffolding": {"count": len(significance), "per_1k": per_k(len(significance)), "hits": significance[:6]},
+        "classifier_scaffolding": {"count": len(classifier), "per_1k": per_k(len(classifier)), "hits": classifier[:6]},
         "inanimate_agent": {"count": len(inanimate), "per_1k": per_k(len(inanimate)), "hits": inanimate[:8]},
         "repeated_openings": {"count": len(repeated), "per_1k": per_k(len(repeated)), "hits": repeated[:6]},
         "paragraph_uniformity": uniformity,
@@ -319,6 +345,7 @@ LABEL = {
     "subtractive_contrast": "Binary contrasts",
     "comma_series": "Comma-series density",
     "significance_scaffolding": "Announced significance",
+    "classifier_scaffolding": "Graded not delivered (stems)",
     "inanimate_agent": "Inanimate subjects, human verbs",
     "repeated_openings": "Repeated sentence openings",
 }
@@ -398,6 +425,13 @@ AUTO_ANSWERED = {
     "comma-series density": "comma_series",
     "announced significance": "significance_scaffolding",
     "significance scaffolding": "significance_scaffolding",
+    # Interpretive metadiscourse is deliberately NOT here. A density metric can
+    # answer "how often does this shape appear"; it cannot answer "does this
+    # sentence earn its claim", and the anchored stems below match only the
+    # shapes they were built from. Auto-answering the check with them scored 0
+    # on a draft carrying "What's easy to miss:" and "This is the insight that
+    # changed how I think about..." -- the count silenced the question instead
+    # of answering it. The reader answers A16; the stems only give a head start.
 }
 SKIP_SECTIONS = {"C"}  # owned by slopscore --fidelity
 
@@ -427,10 +461,18 @@ def load_checks(path: pathlib.Path | None = None) -> list[dict]:
                 "id": f"{section}{item.group(1)}",
                 "section": section,
                 "title": title,
-                "ask": item.group(3).strip(),
+                # Collected as a list and joined below. Rebuilding the string on
+                # every continuation line reread the whole ask to append six words.
+                "ask": [item.group(3).strip()],
             }
-        elif current and line.startswith("    "):
-            current["ask"] = (current["ask"] + " " + line.strip()).strip()
+        # Continuation lines clear the item number by three spaces on some items
+        # and four on others. Testing for four dropped every three-space item and
+        # truncated its ask to whatever fit beside the title: A2's ask parsed as
+        # the single word "The". Any indent counts now, and a whitespace-only
+        # line still falls through to the terminator below instead of appending
+        # nothing and holding the item open.
+        elif current and line.startswith((" ", "\t")) and line.strip():
+            current["ask"].append(line.strip())
         elif current and not line.strip():
             checks.append(current)
             current = None
@@ -438,6 +480,7 @@ def load_checks(path: pathlib.Path | None = None) -> list[dict]:
         checks.append(current)
 
     for c in checks:
+        c["ask"] = " ".join(c["ask"]).strip()
         low = c["title"].lower()
         c["auto"] = next((v for k, v in AUTO_ANSWERED.items() if k in low), None)
         c["skip"] = c["section"] in SKIP_SECTIONS
@@ -447,6 +490,7 @@ def load_checks(path: pathlib.Path | None = None) -> list[dict]:
 def read_packet(text: str, name: str) -> dict:
     """Emit the reading brief. The host model answers it; nothing here guesses."""
     prose = prose_of(text)
+    checks = load_checks()  # one parse feeds all three views below
     paras = []
     for i, para in enumerate(re.split(r"\n\s*\n", prose), 1):
         para = para.strip()
@@ -473,15 +517,15 @@ def read_packet(text: str, name: str) -> dict:
         },
         "questions": [
             {"id": c["id"], "title": c["title"], "ask": c["ask"]}
-            for c in load_checks()
+            for c in checks
             if not c["skip"] and not c["auto"]
         ],
         "answered_from_measurement": [
             {"id": c["id"], "title": c["title"], "metric": c["auto"]}
-            for c in load_checks() if c["auto"]
+            for c in checks if c["auto"]
         ],
         "handled_by_fidelity_gate": [
-            {"id": c["id"], "title": c["title"]} for c in load_checks() if c["skip"]
+            {"id": c["id"], "title": c["title"]} for c in checks if c["skip"]
         ],
         "paragraphs": paras,
     }
@@ -545,7 +589,7 @@ def verdict(text: str, answers: dict) -> tuple[int, str]:
     out.append("")
 
     out.append("  Read by the model:")
-    for check in [c for c in load_checks() if not c["skip"] and not c["auto"]]:
+    for check in checks:  # same filtered list built above
         qid = check["id"]
         got = answers.get(qid)
         if not isinstance(got, dict) or got.get("answer") not in ("pass", "fail"):

package/scripts/slopscore.py

@@ -45,6 +45,89 @@ class PatternData(dict):
     """JSON-compatible pattern mapping with an out-of-band compiled plan."""
 
 
+# One-time note asking for a GitHub star.
+#
+# 448 machines cloned this in a fortnight and seventeen people had starred it,
+# because nothing ever asked. The risk in fixing that is obvious: a tool whose
+# whole job is deleting manipulative filler cannot itself nag, so every rule
+# below is a restriction rather than a reach.
+#
+#   - Once per machine, ever. A marker in the state directory, not a counter
+#     that resets.
+#   - Not until the third run, so it asks people who kept using it rather than
+#     people evaluating it once.
+#   - Never when the output is being read by a machine: --json, --batch,
+#     --gate, or any run whose stdout is not a terminal. CI logs stay clean.
+#   - No prompt, no keypress, no opening a browser, no network call. One line
+#     to stderr, so it cannot corrupt piped output even if the checks above
+#     were somehow wrong.
+#   - ZERO_SLOP_NO_NOTES=1 turns it off for good.
+NOTES_FILE = HOME / "notes.json"
+STAR_NOTE_AFTER_RUNS = 3
+
+
+def _load_notes():
+    try:
+        with open(NOTES_FILE, encoding="utf-8") as fh:
+            data = json.load(fh)
+        return data if isinstance(data, dict) else {}
+    except (OSError, ValueError):
+        return {}
+
+
+def _save_notes(state):
+    try:
+        HOME.mkdir(parents=True, exist_ok=True)
+        tmp = NOTES_FILE.with_suffix(".json.tmp")
+        with open(tmp, "w", encoding="utf-8") as fh:
+            json.dump(state, fh)
+        os.replace(tmp, NOTES_FILE)
+    except OSError:
+        pass  # a read-only home must never break a score
+
+
+def star_note_is_due(argv=None, isatty=None, env=None):
+    """Decide without writing anything, so the rule is testable in isolation."""
+    argv = sys.argv[1:] if argv is None else argv
+    env = os.environ if env is None else env
+    if env.get("ZERO_SLOP_NO_NOTES"):
+        return False
+    if any(flag in argv for flag in ("--json", "--batch", "--gate")):
+        return False
+    if not (sys.stdout.isatty() if isatty is None else isatty):
+        return False
+    state = _load_notes()
+    if state.get("star_note_shown"):
+        return False
+    return int(state.get("human_runs", 0)) + 1 >= STAR_NOTE_AFTER_RUNS
+
+
+def record_human_run(argv=None, isatty=None, env=None):
+    """Count this run and, if it is the one, return the note to print."""
+    argv = sys.argv[1:] if argv is None else argv
+    env = os.environ if env is None else env
+    if env.get("ZERO_SLOP_NO_NOTES"):
+        return None
+    if any(flag in argv for flag in ("--json", "--batch", "--gate")):
+        return None
+    if not (sys.stdout.isatty() if isatty is None else isatty):
+        return None
+    state = _load_notes()
+    if state.get("star_note_shown"):
+        return None
+    state["human_runs"] = int(state.get("human_runs", 0)) + 1
+    due = state["human_runs"] >= STAR_NOTE_AFTER_RUNS
+    if due:
+        state["star_note_shown"] = True
+    _save_notes(state)
+    if not due:
+        return None
+    return ("\n  If Zero Slop has been useful, a star helps people find it: "
+            "https://github.com/manavmishra/ZeroSlop\n"
+            "  This is the only time you will see this. "
+            "ZERO_SLOP_NO_NOTES=1 silences all notes.")
+
+
 def _voice_path(name):
     """Resolve a profile name without letting it become a filesystem path."""
     if not VOICE_NAME.fullmatch(name or "") or name in (".", ".."):
@@ -159,6 +242,39 @@ def _apply_voice(base, name):
 SENT_SPLIT = re.compile(r"(?<=[.!?])[\")”’]?\s+(?=[A-Z“\"(0-9])")
 WORD = re.compile(r"[A-Za-z’']+")
 
+
+# A quoted span longer than this is a passage, not a named tell, and stays in
+# scope. Short enough to exempt "delve" or "it's not just X, it's Y"; short
+# enough that quoting cannot be used to smuggle paragraphs past the meter.
+QUOTE_SKIP_LIMIT = 200
+
+_BLOCKQUOTE_SCAN_RX = re.compile(r"(?m)^[ \t]*>[ \t]?.*$")
+_INLINE_QUOTE_RXS = (
+    re.compile(rf'"[^"\n]{{0,{QUOTE_SKIP_LIMIT}}}"'),
+    re.compile(rf"“[^”\n]{{0,{QUOTE_SKIP_LIMIT}}}”"),
+)
+
+
+def mask_quoted(text):
+    """Blank quoted material for the pattern meter, keeping every offset.
+
+    Naming a cliche in order to discuss it is the opposite of committing it,
+    and step 0 of SKILL.md has always said to skip quotes. Only the phrase
+    meter and the lexicon honour that: rhythm, readability, word variety and
+    formatting still read the quotation, because a quote a writer chose to
+    include is part of how the finished page reads.
+
+    Spans are replaced character for character, so sentence offsets, word
+    counts and hit positions are identical to the unmasked text.
+    """
+    def blank(match):
+        return re.sub(r"[^\n]", " ", match.group(0))
+
+    text = _BLOCKQUOTE_SCAN_RX.sub(blank, text)
+    for rx in _INLINE_QUOTE_RXS:
+        text = rx.sub(blank, text)
+    return text
+
 # Normalise only detector-evasion characters, never ordinary non-Latin prose.
 # A Cyrillic or Greek lookalike is mapped only when it appears in the same word
 # as an ASCII letter (for example, dеlvе). This keeps Russian and Greek text
@@ -418,6 +534,10 @@ def score_text(text, data, formal=False):
                         if n_words >= 200 else None)
     sent_spans = _sentence_spans(text)
     sents = [text[a:b].replace("\n", " ") for a, b in sent_spans]
+    # Same string with quotations blanked out, used only by the phrase meter
+    # and the lexicon. Offsets match `text` exactly.
+    scan_text = mask_quoted(text)
+    scan_sents = [scan_text[a:b].replace("\n", " ") for a, b in sent_spans]
     hits = []
     pattern_spans = []  # (start, end, lower-rx, compiled-rx) for dedup below
 
@@ -449,10 +569,10 @@ def score_text(text, data, formal=False):
             continue
         if hints:
             if lowercase_text is None:
-                lowercase_text = text.lower()
+                lowercase_text = scan_text.lower()
             if not any(hint in lowercase_text for hint in hints):
                 continue
-        for m in compiled.finditer(text):
+        for m in compiled.finditer(scan_text):
             hits.append({
                 "cat": category, "name": name, "w": weight,
                 "quote": m.group(0)[:90].strip(),
@@ -484,7 +604,7 @@ def score_text(text, data, formal=False):
                    and (term in rx_lower or compiled.search(matched))
                    for ps, pe, rx_lower, compiled in pattern_spans)
 
-    candidates = [candidate for candidate in _term_candidates(text, data["lexicon"])
+    candidates = [candidate for candidate in _term_candidates(scan_text, data["lexicon"])
                   if not _pattern_owns(candidate[:2], candidate[2], candidate[4])]
     last_end = 0
     for s, e, term, w, quote in candidates:
@@ -494,7 +614,7 @@ def score_text(text, data, formal=False):
         hits.append({"cat": "lexicon", "name": term, "w": w, "quote": quote})
     riders, triggers = data.get("riders", {}), data.get("rider_triggers", [])
     if riders:
-        for (a, _), sent in zip(sent_spans, sents):
+        for (a, _), sent in zip(sent_spans, scan_sents):
             sl = sent.lower()
             if not any(t in sl for t in triggers):
                 continue
@@ -941,7 +1061,11 @@ CHANNELS = [
 # could check, and things whose invention is the failure the skill forbids.
 FACT_RX = [
     ("figure",  r"(?<![\w.])\$?\d[\d,]*(?:\.\d+)?\s*(?:%|percent|x|bn|m|k|million|billion)?(?![\w])"),
-    ("name",    r"\b(?:[A-Z][a-z]{2,}(?:\s+[A-Z][a-z]+)*)\b"),
+    # A name never spans a line break. Allowing \s+ here let a run swallow the
+    # paragraph boundary after a heading -- "Leverage\n\nThe", "Mishra\n\nPaste"
+    # -- and the invented run then read as a dropped entity in any rewrite that
+    # repunctuated the section.
+    ("name",    r"\b(?:[A-Z][a-z]{2,}(?:[ \t]+[A-Z][a-z]+)*)\b"),
     ("quote",   r"[\u201c\"]([^\u201d\"]{6,120})[\u201d\"]"),
     ("url",     r"https?://\S+"),
 ]
@@ -1014,6 +1138,46 @@ are artificial bookmark despite hey modern please researchers save unpopular wel
 NOT_NAME_WORDS = {word.lower() for word in NOT_NAMES} | COMMON_WORDS
 
 
+def _peel_entity(run, prose, other):
+    """The entity inside a title-case run, or None if the run holds no name.
+
+    A capitalised ordinary word glues itself to the name that follows it --
+    "With Claude", "In March", "At Acme". Discarding the whole run loses the
+    entity, so the rewrite that punctuates the sentence differently gets
+    reported as having dropped a name that is still sitting in it. Peel the
+    leading word and re-test what remains.
+    """
+    while run:
+        if run in NOT_NAMES or len(run) < 3:
+            return None
+        low = run.lower()
+        tokens = re.findall(r"[a-z]+", low)
+        # A title-cased run made entirely of ordinary sentence words is not an
+        # entity (for example, "Shipped Tuesday").
+        if tokens and all(token in NOT_NAME_WORDS for token in tokens):
+            return None
+        single = " " not in run
+        # A capitalised common word ("Draw", "Usually", "Start"), an adverb
+        # ("Finally"), or a sentence-opening gerund ("Watching") is not an
+        # entity; a real name never is.
+        if single and (low in COMMON_WORDS
+                       or low.endswith("ly") or low.endswith("ing")):
+            return None
+        # A word is only a name if it is never used as an ordinary lowercase
+        # word -- not here, and not in the text we compare against.
+        # "Under"/"Shipped" appear lowercased somewhere in normal prose;
+        # "Priya"/"Acme" do not. Strip the capitalised forms first so the
+        # entity cannot vouch for itself.
+        head = run.split()[0]
+        blob = re.sub(r"\b" + re.escape(head) + r"\b", " ", prose + " " + other)
+        if not re.search(r"\b" + re.escape(head.lower()) + r"\b", blob):
+            return run
+        if single:
+            return None
+        run = run.split(" ", 1)[1]
+    return None
+
+
 def facts(text, _other=""):
     """Checkable claims in a draft: figures, named entities, quotes, links."""
     # URLs contain lowercase forms of the names they point at ("acme.io" made
@@ -1040,32 +1204,8 @@ def facts(text, _other=""):
         for m in re.finditer(rx, urls if kind == "url" else prose):
             v = (m.group(1) if m.lastindex else m.group(0)).strip()
             if kind == "name":
-                if v in NOT_NAMES or len(v) < 3:
-                    continue
-                low = v.lower()
-                tokens = re.findall(r"[a-z]+", low)
-                # A title-cased run made entirely of ordinary sentence words is
-                # not an entity (for example, "Shipped Tuesday").
-                if tokens and all(token in NOT_NAME_WORDS for token in tokens):
-                    continue
-                # A capitalised common word ("Draw", "Usually", "Start"), an
-                # adverb ("Finally"), or a sentence-opening gerund ("Watching",
-                # "Calling") is not an entity; a real name never is.
-                if " " not in v and (low in COMMON_WORDS
-                                     or low.endswith("ly") or low.endswith("ing")):
-                    continue
-                # A word is only a name if it is never used as an ordinary
-                # lowercase word — not here, and not in the text we compare
-                # against. "Under"/"Shipped" appear lowercased somewhere in
-                # normal prose; "Priya"/"Acme" do not. Multi-word entities keep
-                # their head token for this test.
-                head = v.split()[0]
-                # Is this token ever used as an ordinary lowercase word, here or
-                # in the compared text? Sentence openers are ("under load",
-                # "shipped tuesday"); real names never are. Strip the capitalized
-                # forms first so the entity cannot vouch for itself.
-                blob = re.sub(r"\b" + re.escape(head) + r"\b", " ", prose + " " + other)
-                if re.search(r"\b" + re.escape(head.lower()) + r"\b", blob):
+                v = _peel_entity(v, prose, other)
+                if not v:
                     continue
             if kind == "figure":
                 v = v.replace(",", "").lstrip("$").rstrip()
@@ -1263,9 +1403,50 @@ def structure_changes(before, after):
     return findings
 
 
-def fidelity(before, after):
+# An unsourced figure -- "the 10x move", "tenfold", "~70% of pilots fail" -- is
+# an intensifier wearing a number's clothes. The gate exists to protect facts,
+# and a figure with no source behind it is not one. Protecting it anyway made
+# the gate report the honest cut as a dropped fact, and rerank sorts on
+# fidelity first, so the rewrite that KEPT the fake precision won. That is the
+# gate preserving slop, which is the opposite of its job.
+#
+# Which figures are load-bearing is a contextual judgment, so this script does
+# not make it. No pattern can separate "fell 40%" from "10x better" reliably --
+# the difference is whether a source stands behind the number, which lives in
+# the surrounding document, not in the digits. The tool's job is to hand the
+# reviewer the evidence; the ruling belongs to the assistant running the
+# verifier role (SKILL step 7, "Unsourced statistics") or to the writer. A
+# figure is protected until someone with context says otherwise, so the default
+# behaviour here is exactly as strict as it was before.
+
+
+def figure_contexts(text, figures):
+    """Each figure with the sentence it sits in, so a reviewer can rule on it.
+
+    Evidence, not a verdict: the caller decides whether a dropped figure was a
+    measured fact that must be restored or an unsourced flourish that was right
+    to cut.
+    """
+    out = {}
+    for figure in figures:
+        for sentence in sentences(text):
+            if re.search(r"\b" + re.escape(figure) + r"\b", sentence, re.I):
+                out[figure] = " ".join(sentence.split())
+                break
+        else:
+            out[figure] = ""
+    return out
+
+
+def fidelity(before, after, adjudicated=None):
     """Did the rewrite keep every fact, and did it add any?
 
+    ``adjudicated`` is the set of dropped figures a reviewer with context has
+    ruled unsourced, so cutting them is an improvement rather than a loss. It
+    is empty unless someone explicitly rules, which keeps the deterministic
+    default strict: this function never decides on its own that a number was
+    only rhetoric.
+
     The benchmark's worst result was a rewrite that invented a feeling the
     author never described — the exact thing hard rule 1 forbids — and nothing
     in the gate measured it. Preservation is checkable; invention is the half
@@ -1275,6 +1456,8 @@ def fidelity(before, after):
     a, b = facts(before, after), facts(after, before)
     structure = structure_changes(before, after)
     rows, kept_all, invented_any = [], True, False
+    adjudicated = set(adjudicated or ())
+    unsourced, dropped_items = set(), set()
     def entity_tokens(entity):
         return {w for w in re.findall(r"[a-z]+", entity.lower())
                 if w not in NOT_NAME_WORDS}
@@ -1298,10 +1481,26 @@ def fidelity(before, after):
             dropped = {e for e in a[kind] if not entity_match(e, b[kind])}
             added = {e for e in b[kind] if not entity_match(e, a[kind])}
             kept = a[kind] - dropped
+            # A word capitalised once at a heading or sentence start reads
+            # exactly like a product name to any lexical rule -- "Embedded
+            # governance", "Models + Context = Leverage". Which one it is
+            # depends on the document, so the reviewer rules and the tool
+            # supplies the sentence rather than guessing.
+            unsourced |= dropped & adjudicated
+            dropped = dropped - adjudicated
+            dropped_items |= dropped
         else:
             kept = a[kind] & b[kind]
             dropped = a[kind] - b[kind]
             added = b[kind] - a[kind]
+            if kind == "figure" and dropped:
+                # Figures the reviewer has ruled unsourced were right to cut,
+                # so they stop failing preservation. Nothing is ruled without
+                # that explicit judgment, and adding a figure is still an
+                # invention however it was ruled.
+                unsourced |= dropped & adjudicated
+                dropped = dropped - adjudicated
+                dropped_items |= dropped
         if not (a[kind] or b[kind]):
             continue
         rows.append((kind, kept, dropped, added))
@@ -1316,7 +1515,55 @@ def fidelity(before, after):
         kept_all = False
         invented_any = invented_any or any(row["added"] for row in structure)
     return {"rows": rows, "preserved": kept_all, "invented": invented_any,
-            "interior": new_interior, "structure": structure}
+            "interior": new_interior, "structure": structure,
+            "unsourced": unsourced,
+            # The sentence each dropped figure came from, so whoever rules on
+            # it can see whether a source stood behind the number.
+            "figure_evidence": figure_contexts(before, dropped_items)}
+
+
+def reorder_ratio(before, after):
+    """How much of the surviving material the rewrite actually moved.
+
+    0.0 means every kept sentence is still in its original order; 1.0 means the
+    order was inverted. Cutting and reordering are different edits with
+    different results: subtraction leaves the surviving prose sitting exactly
+    where the model would have put it, while moving the payoff changes what the
+    reader meets first. Nothing in the gate could tell the two apart, so a
+    compression-only rewrite passed every check the ladder's order rung was
+    supposed to enforce.
+    """
+    def shingles(text):
+        out = []
+        for sentence in sentences(text):
+            words = {w for w in re.findall(r"[a-z]{4,}", sentence.lower())
+                     if w not in NOT_NAME_WORDS}
+            if words:
+                out.append(words)
+        return out
+
+    src, dst = shingles(before), shingles(after)
+    if len(src) < 2 or len(dst) < 2:
+        return 0.0
+    order = []
+    for target in dst:
+        best, best_at = 0.0, None
+        for i, source in enumerate(src):
+            union = len(target | source)
+            overlap = len(target & source) / union if union else 0.0
+            if overlap > best:
+                best, best_at = overlap, i
+        if best >= 0.3 and best_at is not None:
+            order.append(best_at)
+    if len(order) < 2:
+        return 0.0
+    pairs = inversions = 0
+    for i in range(len(order)):
+        for j in range(i + 1, len(order)):
+            pairs += 1
+            if order[i] > order[j]:
+                inversions += 1
+    return round(inversions / pairs, 3) if pairs else 0.0
 
 
 # The shared rewrite-quality objective. One definition of "a better rewrite",
@@ -1326,10 +1573,18 @@ def fidelity(before, after):
 RW_GATE = {"email": 35, "research": 40, "professional": 40}
 RW_GATE_DEFAULT = 25
 RW_FORMAL = {"research", "professional"}
-RW_WEIGHTS = {"deslop": 0.45, "gate": 0.25, "rhythm": 0.15, "length": 0.15}
-
-
-def rewrite_score(before_text, after_text, genre=None, data=None):
+# "structure" exists because the other four terms all saturate on a draft that
+# arrives clean: deslop is ~0 when there is no slop to remove, and gate, rhythm
+# and length each cap at 1.0, so every candidate scored an identical 0.55 and
+# the ranking fell through to the fidelity tier. A meter with no opinion about
+# which rewrite is better is the reason a worse rewrite could win.
+RW_WEIGHTS = {"deslop": 0.40, "gate": 0.20, "rhythm": 0.12, "length": 0.13,
+              "structure": 0.15}
+RW_REORDER_FULL = 0.20
+
+
+def rewrite_score(before_text, after_text, genre=None, data=None,
+                  adjudicated=None):
     """Score one rewrite: a soft quality in [0,1] plus its fidelity flags."""
     if data is None:
         data = load_patterns()
@@ -1340,14 +1595,25 @@ def rewrite_score(before_text, after_text, genre=None, data=None):
     clamp = lambda x: max(0.0, min(1.0, x))
     deslop = clamp((b_ai - a["ai_likelihood"]) / b_ai)
     gate = 1.0 if a["ai_likelihood"] <= RW_GATE.get(genre, RW_GATE_DEFAULT) else 0.0
-    rhythm = clamp(a.get("burstiness", 0.0) / 0.45)
+    # Formal genres score with the rhythm-uniformity penalty switched off,
+    # because an even pulse is native to an abstract rather than a tell. The
+    # objective was still paying for burstiness there, so a casualised abstract
+    # outranked one that kept its register -- the composite penalising formal
+    # writing for being formal, which is the thing --formal exists to stop.
+    rhythm = 1.0 if formal else clamp(a.get("burstiness", 0.0) / 0.45)
     bw, aw = len(before_text.split()), len(after_text.split())
     length = 1.0 if not bw or aw / bw >= 0.6 else clamp((aw / bw) / 0.6)
+    reorder = reorder_ratio(before_text, after_text)
+    structure = clamp(reorder / RW_REORDER_FULL)
     soft = sum(RW_WEIGHTS[k] * v for k, v in
-               {"deslop": deslop, "gate": gate, "rhythm": rhythm, "length": length}.items())
-    fid = fidelity(before_text, after_text)
+               {"deslop": deslop, "gate": gate, "rhythm": rhythm,
+                "length": length, "structure": structure}.items())
+    fid = fidelity(before_text, after_text, adjudicated)
     return {"soft": round(soft, 4), "deslop": round(deslop, 3), "gate": gate,
             "rhythm": round(rhythm, 3), "length": round(length, 3),
+            "structure": round(structure, 3), "reorder": reorder,
+            "unsourced": sorted(fid["unsourced"]),
+            "figure_evidence": fid["figure_evidence"],
             "after_ai": a["ai_likelihood"], "before_ai": b["ai_likelihood"],
             "burstiness": round(a.get("burstiness", 0.0), 3),
             "high_tells": sum(1 for h in a.get("hits", []) if h.get("w", 0) >= 4),
@@ -1641,6 +1907,11 @@ def main():
               f"layout; your AI assistant still reviews the ideas, voice, and facts.")
         sys.exit(0 if ok else 1)
 
+    # Last line of a human run, and only ever once. See record_human_run.
+    note = record_human_run()
+    if note:
+        print(note, file=sys.stderr)
+
 
 if __name__ == "__main__":
     main()