zero-slop 2.7.0 → 2.7.6

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.0-72528F">
+  <img alt="version" src="https://img.shields.io/badge/version-2.7.6-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.6 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 2.32% 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.0"
+  version: "2.7.6"
   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
@@ -449,6 +451,8 @@ the most reader value. `references/rewrite-moves.md` expands each rung.
   "decided". Kill participial openers ("Leveraging X, …"). Translate internal
   workflow labels into plain language; never let evaluator or harness language
   leak into reader-facing prose.
+  Strong claims the author owns are content, not register: cut an intensifier
+  only for a defect you can name in context, never for strength alone.
   Prefer an explicit actor and an active verb when responsibility matters. Keep
   passive voice when the actor is unknown, irrelevant, deliberately withheld, or
   native to the genre; passive voice alone is not evidence of AI writing.
@@ -595,6 +599,13 @@ format, and non-prose structure. Apply these contextual checks too:
   `_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.
+- **The delta.** Run
+  `python3 <skill-root>/scripts/register.py --delta <original> <final>` and
+  answer for what it prints: every inserted run must restate source meaning,
+  every cut emphasis word needs a named defect, and every rewritten span passes
+  the three direction tests — purpose has not become outcome, agency has not
+  moved, a warned future has not become an asserted present. The fact gate
+  cannot see any of these; this is where a reframed claim gets caught.
 - **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

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.0",
+  "version": "2.7.6",
   "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
 
@@ -187,9 +216,27 @@ the report even when they are zero.
 51. **Qualifiers survive.** Hedges, scope limits, and caveats carry the same strength
     as the source.
 52. **Claims not reframed.** Same names and numbers can still carry a changed
-    emphasis or implication. Compare meaning, not tokens.
+    emphasis or implication. Compare meaning, not tokens, and run three direction
+    tests on every span `register.py --delta` reports as inserted or rewritten:
+    purpose has not become outcome ("changed tactics to achieve its objective" is
+    not "changed tactics until it reached its objective"); agency has not moved
+    ("helps teams generate fixes" is not "generates fixes"); a warned future has
+    not become an asserted present. These are contextual comparisons against this
+    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
 
@@ -207,44 +254,55 @@ the report even when they are zero.
 59. **Proportional cutting.** No compression that stripped character. Density is
     information per word, not fewer words.
 60. **Read aloud.** Would this sound natural read to a sharp colleague?
-61. **No over-correction.** AI slop was not traded for edgy slop: forced hot takes,
+61. **Emphasis survives.** `register.py --delta` lists every intensifier or
+    absolute the rewrite cut from this source. Each cut needs a defect named from
+    this file, judged in its own context: puffery, hyperbole universal, filler.
+    "Too strong" is not a defect, and a falsifiable claim the author owns keeps
+    its full strength whatever word carries it. Cutting "changed overnight" from
+    a claim the author would defend cost a blind head-to-head once.
+62. **Earned length.** `--delta` lists every run of three or more words the rewrite
+    added. Each must restate meaning already in this source for this audience; a
+    bridge or an unpacked definition can qualify, scaffolding the author never
+    wrote cannot. A rewrite longer than its original defends every insertion or
+    loses them.
+63. **No over-correction.** AI slop was not traded for edgy slop: forced hot takes,
     fake first person, performed candor, staccato drama.
 
 ## E. Form
 
-62. **Returned in the format it arrived in.** A .docx comes back a .docx.
-63. **Reader language.** No evaluator or harness vocabulary leaked into the copy:
+64. **Returned in the format it arrived in.** A .docx comes back a .docx.
+65. **Reader language.** No evaluator or harness vocabulary leaked into the copy:
     candidate, artifact, overlay, gate, scorecard, burstiness.
-64. **Formatting slop.** No emoji headings, decorative bold, or bullets that should be
+66. **Formatting slop.** No emoji headings, decorative bold, or bullets that should be
     prose. Count the headings over one or two sentences: four consecutive H3s each
     wrapping a code block and one line is a section that wants to be one section.
-65. **Em dashes.** None in short copy. One or two in a long draft only where they
+67. **Em dashes.** None in short copy. One or two in a long draft only where they
     clearly beat a comma, period, or parenthesis.
-66. **Hyphenated modifier stacking.** "AI-powered cloud-native data-driven platform".
+68. **Hyphenated modifier stacking.** "AI-powered cloud-native data-driven platform".
    Two stacked compound modifiers in one noun phrase is a tell; keep the hyphens
    grammar requires and cut the rest.
-67. **List-label periods and bare-noun bullets.** Bullets that are fragments ending in
+69. **List-label periods and bare-noun bullets.** Bullets that are fragments ending in
    full stops, or a list of bare noun phrases with no predicate. Either make them
    sentences or make them a real list.
-68. **Numbered-list inflation.** A numbered list where order carries no meaning, or a
+70. **Numbered-list inflation.** A numbered list where order carries no meaning, or a
    list padded to a round number. Use a bulleted list, or prose.
-69. **Chatbot artifacts.** Citation markup leaks, "Regenerate response", tool URL
+71. **Chatbot artifacts.** Citation markup leaks, "Regenerate response", tool URL
    parameters such as utm_source, and any assistant scaffolding left in the copy.
-70. **Attribution accurate.** The report names who did what without guessing which
+72. **Attribution accurate.** The report names who did what without guessing which
     model is running, and never implies a Zero Slop service read the draft.
 
 ## F. Process integrity
 
 Role 8 answers this section. It is the check no single-agent eval can make.
 
-71. **Roles stayed separate.** The copy desk, read-aloud pass, verification, and
+73. **Roles stayed separate.** The copy desk, read-aloud pass, verification, and
     fresh-eyes review each ran as a distinct pass.
-72. **No self-certification.** No role graded text it generated.
-73. **Counts reported.** Every count in section A appears in the summary, including
+74. **No self-certification.** No role graded text it generated.
+75. **Counts reported.** Every count in section A appears in the summary, including
     the zeros.
-74. **The exact final text cleared every check.** Not an earlier draft, not a version
+76. **The exact final text cleared every check.** Not an earlier draft, not a version
     that was repaired afterward.
-75. **Role 8 approved without changes.** If it changed anything, roles 5 through 8
+77. **Role 8 approved without changes.** If it changed anything, roles 5 through 8
     ran again on the revision.
-76. **Fallbacks named honestly.** If the three-round limit was reached, the report
+78. **Fallbacks named honestly.** If the three-round limit was reached, the report
     says which check failed and does not describe the result as fully verified.

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"):
@@ -611,6 +655,68 @@ def verdict(text: str, answers: dict) -> tuple[int, str]:
     return 0, "\n".join(out)
 
 
+# Emphasis words: cutting one is sometimes right (puffery) and sometimes voice
+# flattening ("changed overnight" is a falsifiable claim the author owns). The
+# tool cannot tell which, so it reports every cut and the eval demands a defect
+# name for each. "Too strong" is not a defect.
+EMPHASIS = {
+    "overnight", "never", "always", "every", "entire", "all", "nothing",
+    "worst", "best", "first", "only", "immediately", "instantly", "forever",
+    "massive", "enormous", "catastrophically", "obsessively", "extraordinary",
+    "unprecedented", "remarkable", "completely", "exactly",
+}
+
+
+def delta(original: str, rewrite: str) -> dict:
+    """Word-level diff: what the rewrite added that the author never wrote, and
+    what emphasis it took away. Insertions are never free; each run must carry
+    meaning already in the source. A rewrite 27 words longer than the original
+    once lost a blind head-to-head on exactly this."""
+    import difflib
+    a = original.split()
+    b = rewrite.split()
+    sm = difflib.SequenceMatcher(a=[w.lower().strip(".,;:!?\"'()") for w in a],
+                                 b=[w.lower().strip(".,;:!?\"'()") for w in b])
+    inserted, deleted, cut_emphasis = [], [], []
+    for op, i1, i2, j1, j2 in sm.get_opcodes():
+        if op in ("insert", "replace") and j2 - j1 >= 3:
+            inserted.append(" ".join(b[j1:j2])[:90])
+        if op in ("delete", "replace"):
+            for w in a[i1:i2]:
+                if w.lower().strip(".,;:!?\"'()") in EMPHASIS:
+                    ctx = " ".join(a[max(0, i1 - 4):min(len(a), i2 + 4)])
+                    cut_emphasis.append(f"{w}  ({ctx[:70]})")
+            if op == "delete" and i2 - i1 >= 3:
+                deleted.append(" ".join(a[i1:i2])[:90])
+    return {
+        "original_words": len(a), "rewrite_words": len(b),
+        "net": len(b) - len(a),
+        "inserted_runs": inserted[:12], "deleted_runs": deleted[:12],
+        "cut_emphasis": cut_emphasis[:12],
+    }
+
+
+def render_delta(d: dict) -> str:
+    out = [f"Length: {d['original_words']} -> {d['rewrite_words']} words "
+           f"({'+' if d['net'] >= 0 else ''}{d['net']})"]
+    if d["net"] > 0:
+        out.append("  The rewrite is LONGER than the original. Every inserted run below")
+        out.append("  must carry meaning already in the source, or it goes.")
+    out.append("")
+    out.append(f"  Inserted runs the author never wrote ({len(d['inserted_runs'])}):")
+    for r in d["inserted_runs"] or ["(none)"]:
+        out.append(f"    + {r}")
+    out.append(f"  Cut emphasis, each needs a defect name, not 'too strong' ({len(d['cut_emphasis'])}):")
+    for r in d["cut_emphasis"] or ["(none)"]:
+        out.append(f"    - {r}")
+    if d["deleted_runs"]:
+        out.append(f"  Deleted runs ({len(d['deleted_runs'])}):")
+        for r in d["deleted_runs"]:
+            out.append(f"    - {r}")
+    return "\n".join(out)
+
+
+
 MUST_FLAG = EVAL_PATH.resolve().parent.parent / "data" / "corpus" / "must-flag"
 
 
@@ -736,6 +842,8 @@ def main() -> int:
     ap.add_argument("--gate", action="store_true", help="exit 1 when any rate is over budget")
     ap.add_argument("--calibrate", metavar="DIR", help="recompute budgets from a human corpus")
     ap.add_argument("--selftest", action="store_true", help="check the gate against the checklist")
+    ap.add_argument("--delta", nargs=2, metavar=("ORIGINAL", "REWRITE"),
+                    help="what the rewrite inserted, and what emphasis it cut")
     ap.add_argument("--recall", action="store_true", help="verify every recorded miss in data/corpus/must-flag still gets caught")
     ap.add_argument("--read", action="store_true", help="emit the reading brief for the host model")
     ap.add_argument("--verdict", metavar="ANSWERS_JSON", help="gate on the measured rates plus the model's answers")
@@ -745,6 +853,11 @@ def main() -> int:
         return _selftest()
     if args.recall:
         return recall()
+    if args.delta:
+        a = pathlib.Path(args.delta[0]).read_text(encoding="utf-8", errors="ignore")
+        b = pathlib.Path(args.delta[1]).read_text(encoding="utf-8", errors="ignore")
+        print(render_delta(delta(a, b)))
+        return 0
     if args.calibrate:
         calibrate(args.calibrate)
         return 0

package/scripts/slopscore.py

@@ -941,7 +941,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 +1018,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 +1084,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 +1283,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 +1336,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 +1361,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 +1395,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 +1453,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 +1475,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),