zero-slop 2.7.8 → 2.8.1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Manav Mishra
+Copyright (c) 2026 Garage Capital Ventures
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -5,23 +5,65 @@
   <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.8-72528F">
+  <img alt="version" src="https://img.shields.io/badge/version-2.8.1-72528F">
+  <a href="https://hol.org/guard/plugins"><img alt="Listed in the HOL plugin registry" src="https://img.shields.io/badge/HOL%20registry-listed-2C6E8F"></a>
+  <a href="https://github.com/hashgraph-online/awesome-ai-plugins#tools--integrations"><img alt="Listed in awesome-ai-plugins" src="https://img.shields.io/badge/awesome--ai--plugins-listed-2C6E8F"></a>
+  <a href="https://zero-slop.ai/try/"><img alt="This README scores 12.0 out of 100 on the slop score, inside the human range" src="https://img.shields.io/badge/slop%20score-12.0%2F100-0f7d55"></a>
 </p>
 
-Less slop, more pop.
+Less slop, more pop in your writing.
 
 Zero Slop finds stock phrasing, mechanical rhythm, vague claims, and canned
-formatting, then gives your AI assistant a guarded editing workflow. Its
-MIT-licensed local checks run offline; your existing AI assistant does the editing.
-See the benchmark at [zero-slop.ai](https://zero-slop.ai).
+formatting, then gives your AI assistant or agent harness an editing workflow on guardrails. Its
+MIT-licensed local checks run offline; your existing AI assistant or harness does the editing.
+Score a draft at [zero-slop.ai/try](https://zero-slop.ai/try/); benchmark at
+[zero-slop.ai](https://zero-slop.ai).
 
-![A scored sentence before and after editing](assets/demo.png)
+```sh
+npx zero-slop install
+```
+
+![Scoring a launch post at 100.0, rewriting it to 9.5, with the 40% figure held by the fact gate](assets/zero-slop-demo.gif)
+
+### What it does, on a real draft
+
+A launch post, as AI wrote it:
+
+> We're thrilled to announce that our team has leveraged cutting-edge AI to deliver a seamless onboarding experience. It's not just a redesign, it's a fundamental reimagining of how users engage with our platform. In today's fast-paced landscape, the ability to iterate quickly is crucial. By harnessing the power of machine learning, we've been able to reduce setup time by 40%. Here's the thing nobody tells you: onboarding is where most products lose their users. We're excited to continue this journey with you.
+
+`slopscore.py --explain` on that paragraph, unedited:
+
+```text
+Writing score: 100.0/100  [major rewrite]
+  Flagged phrases : 11 across 83 words
+  Sentence variety: too even
+  Main issues     : canned LinkedIn phrase, promotional language, manufactured
+                    stakes, two-part contrast used as a formula, performed
+                    writer's voice, buzzword used as promotion
+
+  Flagged phrases (11), strongest first:
+    "In today's fast-paced"  manufactured stakes; start where the reader needs to start
+    "We're thrilled to"      canned LinkedIn phrase; say what happened without the stock opening
+    "It's not just a redesign, it's"
+                             two-part contrast used as a formula; state the claim once, plainly
+    "Here's the thing"       performed writer's voice; say the thing plainly
+    'cutting-edge'           promotional language; name what it does; cut the adjectives
+    'leveraged'              buzzword used as promotion; use the plain word
+```
+
+The rewrite, limited to the draft's stated claims:
+
+> We used machine learning to reduce onboarding setup time by 40%.
+
+```text
+Writing score: 9.5/100  [clear]
+  Flagged phrases : 0 across 10 words
+```
 
 ## Problem
 
 AI-assisted writing often converges on the same constructions: "It's not X. It's Y."
-"Here's the thing nobody tells you." One phrase proves little. Repetition across
-wording, rhythm, structure, and formatting is the problem.
+"Here's the thing nobody tells you." One emdash is fine. Multiple emdashes, definitely slop. The same effect can come from repetition in the wording or the structure. Mechanical rhythm and overworked formatting can do it too.
 
 Zero Slop is an Agent Skill and ships no model. Claude, GPT, or another compatible
 model edits; local tools check names, numbers, quotations, links, code, tables, and
@@ -42,7 +84,10 @@ Or install it with `npx`:
 npx skills add manavmishra/ZeroSlop --global
 ```
 
-Or from the registry, which also installs the scorer as a command:
+Or from the registry, which also installs the scorer as a command. Zero Slop is
+listed in [awesome-ai-plugins](https://github.com/hashgraph-online/awesome-ai-plugins#tools--integrations)
+and carries a public profile in the [HOL plugin registry](https://hol.org/guard/plugins),
+where its trust score and scanner results are published:
 
 ```sh
 npx zero-slop install          # add --harness codex|cursor|opencode|zed
@@ -63,6 +108,18 @@ You get the edited draft, before-and-after scores, and quoted flagged phrases.
 `/zero-slop inspect (your writing)` reviews without rewriting. For a folder,
 `slopscore.py --batch drafts/ --gate 25` fails above the threshold.
 
+## Show your score
+
+The badge above is this README's own, from `npx zero-slop score README.md`.
+Put yours up the same way:
+
+```md
+[![Slop score](https://img.shields.io/badge/slop%20score-12.0%2F100-0f7d55)](https://zero-slop.ai/try/)
+```
+
+Colours are the scorer's bands: `0f7d55` under 25, `b8860b` under 60, `b0502c`
+above.
+
 ## The slop that Zero Slop catches
 
 290 weighted patterns and a 96-term lexicon, including:
@@ -94,7 +151,7 @@ Eight roles form one workflow. Each is a job rather than a service, run as its o
 
 | Role | Who does it | What happens |
 |---|---|---|
-| 1. Scorer | Local tools | Finds the exact wording, rhythm, readability, and formatting problems that raised the writing score. |
+| 1. Scorer | Local tools | Finds the exact phrases behind the writing score, then checks pacing and readability. It also catches overworked formatting. |
 | 2. Interpreter | Your AI assistant | Reads the claims, purpose, audience, structure, and voice before changing anything. |
 | 3. Rewriter | Your AI assistant | Removes stock language and rebuilds order, rhythm, and tone without inventing detail. |
 | 4. Fact gate | Local tools | Rejects any version that changes names, numbers, quotations, links, code, tables, paths, or structure. |
@@ -134,10 +191,9 @@ with [`scripts/register.py`](scripts/register.py) running the reading pass.
 
 The saved replay ran Zero Slop, [avoid-ai-writing](https://github.com/conorbronsdon/avoid-ai-writing),
 [no-ai-slop](https://github.com/petergyang/no-ai-slop) and
-[humanizer](https://github.com/blader/humanizer) on the same 18 drafts, each with
-GPT-5.4, high reasoning, batches of three, and pinned instructions. The Zero Slop
-outputs came from v2.5.9; later releases rescore those frozen outputs but do not
-pretend to have regenerated them.
+[humanizer](https://github.com/blader/humanizer) over 18 drafts with GPT-5.4, high
+reasoning, and pinned instructions. Zero Slop's outputs came from v2.5.9; later
+releases rescore those frozen outputs rather than pretend to regenerate them.
 
 | Method | Mean writing score ↓ | Passed Zero Slop's local gates | Source check passed | Average length change |
 |---|---:|---:|---:|---:|
@@ -161,23 +217,44 @@ rates, and a method-hidden quality ranking.
 ![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, version records, and limits are
-in [`bench/README.md`](bench/README.md). The separate method-hidden two-way replay used
+universal ranking. Drafts, hashes, and limits are in [`bench/README.md`](bench/README.md). The separate method-hidden two-way replay used
 Zero Slop v2.6.0 and is preserved in
 [`bench/incumbent-blind-replay/`](bench/incumbent-blind-replay/).
 
 For the 38-item editorial panel, the current scorer matched the prior 84.2% result.
 All frozen scores stayed unchanged, all 18 human controls remained below the gate,
 and all 18 obvious search cases remained above it. These fixed-sample checks are not
-proof of general accuracy. We recorded 6.51% higher median throughput across 12 interleaved
-local runs; treat that as machine noise, not a speed claim.
+proof of general accuracy.
 
 ### Speed
 
-On one busy Apple silicon Mac: 1,000 documents in 3.2233 seconds (310.2 per second),
-a 15,201-word document in 0.4757 seconds, the slowest stress case in 3.3487 seconds,
-and an 8,000-word learning pass in 0.2284 seconds. Editing time is excluded; expect
-different results on other machines and loads.
+One busy Apple silicon Mac. Meter: 1,000 documents in 2.5035 seconds (399.4 per
+second), 15,201 words in 0.4301 seconds, worst stress case 3.2518 seconds. Reading
+pass, untimed on record until now: 0.8304 seconds for the same 1,000 (1,204.2 per
+second), 0.1359 for the same large document, linear to 96,000 words. Learning pass,
+8,000 words: 0.2027 seconds. Across 31 interleaved runs against 2.7.7 we measured
+0.07% higher median throughput; that is machine noise, not a speed claim. Editing
+time is excluded.
+
+### Reading-pass accuracy
+
+The reading pass budgets antithesis pairs by frequency, so the count has to be right
+before the budget means anything. It had never been measured. On 58 labelled pairs in
+[`bench/antithesis/`](bench/antithesis/):
+
+| Reading pass | 2.8.0 | now |
+|---|---:|---:|
+| Recall, all shapes | 40.0% | 90.0% |
+| Recall, shapes in reach | 44.4% | 100% |
+| Precision | 80.0% | 100% |
+| False positives | 3 | 0 |
+
+![Antithesis detection before and after, on 58 labelled pairs](assets/bench-antithesis.png)
+
+Bare subject swap and the weak isocolon stay out of reach and count against recall: the
+first is a judgment call in `references/tells.md`, the second is identical to ordinary
+parallel prose on every lexical statistic. Maintainer labels on constructed pairs, so
+this is a regression floor, not field accuracy.
 
 ### Current models
 

package/SKILL.md

@@ -2,7 +2,7 @@
 name: zero-slop
 license: MIT
 metadata:
-  version: "2.7.8"
+  version: "2.8.1"
   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.
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zero-slop",
-  "version": "2.7.8",
+  "version": "2.8.1",
   "description": "An Agent Skill that scores AI-sounding prose locally, guides the host AI through an editorial rewrite, and checks changed source details. The local tools run offline with zero dependencies.",
   "bin": {
     "zero-slop": "bin/zero-slop.mjs"
@@ -50,6 +50,7 @@
     "!scripts/contextual.py",
     "!scripts/contextual-signals.md",
     "!references/contextual-signals.md",
+    "!scripts/make-readme-gif.mjs",
     "!scripts/growth-snapshot.mjs",
     "!data/voices/",
     "!**/__pycache__/"

package/scripts/register.py

@@ -35,6 +35,7 @@ import sys
 # certified-human samples would let these budgets be derived rather than argued.
 MIN_WORDS = 300
 BUDGETS = {
+    "antithesis_pair": (0.0, 2),
     "subtractive_contrast": (6.0, 3),
     "comma_series": (26.0, 8),
     "significance_scaffolding": (0.0, 1),
@@ -61,6 +62,167 @@ SHORT_FLOORS = {
     "referent_cluster": 2,
 }
 
+# eval.md A1 / SKILL.md step 2.1: antithesis pairs -- two balanced statements,
+# the second landing the twist. Budget is ONE per piece, and "three or more under
+# 500 words means the register failed whatever the score said."
+#
+# This report had no row for that family. RX_SUBTRACTIVE below is a different
+# check -- eval.md A2, the corrective appositive, judged on density -- and it was
+# carrying the whole contrast family's name in the report while A1 went
+# unmeasured. A 479-word manifesto with five antithesis pairs in it therefore
+# printed "Binary contrasts: 1 found, ok" and nothing else about contrast.
+#
+# Two of the four shapes are reachable without a parser, and only those two ship:
+#   marked staccato   -- "Not perfect. Honest."
+#   adjacent isocolon -- one verb frame, both arguments swapped: "Speed is moving
+#                        fast. Velocity is moving fast in the same direction."
+# Bare subject swap and unmarked reversal stay the reader's judgment, exactly as
+# references/tells.md already says they must.
+ANTITHESIS_STOP = frozenset("""
+a an the this that these those it its is are was were be been being am do does did
+to of in on at by for with from as and or but so if then than not no nor yet
+we you they he she i us our your their his her them me my there here
+one two three first second next last own same very just only also more most less
+every all each any some many few way thing
+""".split())
+
+# Negation, including the contracted forms. "isn't", "don't" and "won't" carry
+# the figure exactly as "is not" does, and the shipped detector matched none of
+# them: "Slop isn't a vibe. It's measurable." is a documented anchor in
+# references/tells.md and it walked straight past.
+NEGATION = re.compile(r"\b(?:not|never|cannot)\b|\w+n['’]t\b", re.I)
+# A copula in both halves is the "X is A. Y is B." frame, which is the marked
+# figure's usual carrier and is absent from ordinary negated prose ("The server
+# did not respond. We restarted it.").
+COPULA = re.compile(r"\b(?:is|are|was|were|be|been|am)\b|\w+['’]s\b|\w+n['’]t\b", re.I)
+RX_MARKED_OPEN = re.compile(r"^\W*not\b", re.I)
+RX_MARKED_CLOSE = re.compile(
+    r"\b(?:was|were|is|are|did|does|do|has|have|had|will|can|could|would)\s+not\W*$", re.I)
+# The two template shapes the meter already anchors (this-is-what-looks-like,
+# no-x-had-to). The meter scores them as spans; the register pass has to COUNT
+# them, because tells.md budgets the family by frequency and a span hit is not
+# a count.
+RX_CONTRASTIVE = re.compile(r"^\W*(?:but|yet|however)\b", re.I)
+RX_STOCK_CLOSER = re.compile(r"\bthis is what\b.{0,60}?\blooks? like\b", re.I)
+RX_UNMARKED_REVERSAL = re.compile(r"^\W*no\s+[\w-]+(?:\s+[\w-]+){0,3}\s+had to\b", re.I)
+
+
+def _tokens(sent: str) -> list[str]:
+    return [w.lower() for w in re.findall(r"[A-Za-z][\w'’-]*", sent)]
+
+
+def _antithesis_content(tokens: list[str]) -> list[str]:
+    """Content words, with a trailing -s folded away so a verb frame still
+    matches when only its agreement changed: 'let' and 'lets' are one frame."""
+    out = []
+    for word in tokens:
+        if word in ANTITHESIS_STOP:
+            continue
+        if len(word) > 3 and word.endswith("s") and not word.endswith("ss"):
+            word = word[:-1]
+        out.append(word)
+    return out
+
+
+def _common_prefix(a: list[str], b: list[str]) -> int:
+    n = 0
+    for x, y in zip(a, b):
+        if x != y:
+            break
+        n += 1
+    return n
+
+
+# A heading or a list lead-in carries no terminal punctuation, so it arrives
+# from _sentences glued to the paragraph beneath it. Rather than change the
+# splitter or prose_of -- both are shared by every family, and moving either one
+# pushed four to eleven documents over budget on rate alone -- this family
+# rejects the glued span itself. Nothing else sees the change.
+RX_SCAFFOLD = re.compile(r"^\s*(?:[#>|]|[-*+]\s|\d+\.\s)|\*\*|\n\s*(?:[#>|]|[-*+]\s|\d+\.\s)")
+
+
+def antithesis_pairs(prose: str) -> list[str]:
+    """Adjacent balanced sentences where the second lands the twist.
+
+    Recall is bounded and the bound is a property of the figure, not of the
+    implementation. "A meter reports a number. A reader reports a feeling." and
+    "The report lists every vendor. The appendix lists every contract." are the
+    same construction to every lexical statistic -- same lengths, same one
+    shared word, same 0.33 overlap -- and only the first is antithesis. What
+    separates them is semantic opposition, which no word count can see. So the
+    marked shapes, where a negation anchors the figure, are matched broadly;
+    the unmarked ones are matched only where the parallel is strong enough to
+    be structural. Bare subject swap stays the reader's call, as tells.md says.
+    """
+    out = []
+    sents = _sentences(prose)
+    toks = [_tokens(s) for s in sents]
+    cont = [_antithesis_content(t) for t in toks]
+    # Matches do not overlap. The figure is a pair, so a sentence that has
+    # already landed one twist cannot also be the setup for the next: three
+    # short consecutive sentences were producing two pairs out of one figure
+    # and inflating a rate the budget reads directly.
+    consumed = -1
+    for i in range(len(sents) - 1):
+        if i <= consumed:
+            continue
+        first, second = sents[i], sents[i + 1]
+        ta, tb = toks[i], toks[i + 1]
+        na, nb = len(ta), len(tb)
+        if not (2 <= na <= 14 and 1 <= nb <= 14):
+            continue
+        if RX_SCAFFOLD.search(first) or RX_SCAFFOLD.search(second):
+            continue
+        head, tail = cont[i], cont[i + 1]
+        shared = set(head) & set(tail)
+        prefix = _common_prefix(ta, tb)
+        negated = bool(NEGATION.search(first) or NEGATION.search(second))
+
+        # Marked, announced at the open or the close of the pair.
+        if RX_MARKED_OPEN.match(first) and nb <= 10:
+            out.append(f"{first} {second}"); consumed = i + 1; continue
+        if RX_MARKED_CLOSE.search(second) and na <= 10:
+            out.append(f"{first} {second}"); consumed = i + 1; continue
+        # Marked, carried inside the pair. A negation alone is ordinary prose,
+        # so the halves also have to be short AND share a frame. One shared
+        # topic word is not a frame: "The AI roles supply judgment. A generating
+        # role never certifies its own output." shares "role" and is ordinary
+        # prose. The frame is a repeated opening, a copula on both sides, or two
+        # words in common.
+        if negated and na <= 10 and nb <= 8 and (prefix >= 1 or len(shared) >= 2):
+            out.append(f"{first} {second}"); consumed = i + 1; continue
+        # A copula on both sides is the weakest of the three frames, so it only
+        # counts when the halves are staccato-short. "Passwords are never stored
+        # in plain text. They are hashed with a per-user salt." is two copulas
+        # and a negation and no figure at all.
+        if (negated and na <= 7 and nb <= 6
+                and COPULA.search(first) and COPULA.search(second)):
+            out.append(f"{first} {second}"); consumed = i + 1; continue
+        # A contrastive opener on the second half is the twist announced by a
+        # conjunction rather than by the negation's position: "That creates
+        # speed. But speed is not velocity."
+        if (negated and RX_CONTRASTIVE.match(second) and na <= 8 and nb <= 7
+                and (shared or COPULA.search(second))):
+            out.append(f"{first} {second}"); consumed = i + 1; continue
+        # The two template shapes the meter anchors, counted here.
+        if RX_STOCK_CLOSER.search(second) or RX_UNMARKED_REVERSAL.match(first):
+            out.append(f"{first} {second}"); consumed = i + 1; continue
+        # Isocolon: one frame, both arguments swapped. A repeated opening is
+        # restatement rather than a swap, but only when the repeated part
+        # carries meaning: "Version one shipped in March. Version two shipped in
+        # June." repeats the subject and is enumeration, while "A junior
+        # engineer reads the error. A senior engineer reads the stack trace."
+        # repeats only the article and is the figure. So the test is whether any
+        # CONTENT word opens both halves, not whether any token does.
+        shared_open = any(w not in ANTITHESIS_STOP for w in ta[:prefix])
+        if shared_open or head == tail or len(head) < 2 or len(tail) < 2:
+            continue
+        if len(shared) >= 2 and len(shared) / min(len(head), len(tail)) >= 0.5:
+            out.append(f"{first} {second}")
+            consumed = i + 1
+    return out
+
+
 # "X, not Y." and "A rather than B." The corrective appositive. Each instance is
 # usually careful writing, which is why no pattern list contains it.
 RX_SUBTRACTIVE = re.compile(
@@ -142,6 +304,28 @@ RX_INFLATION = re.compile(
     r"(?:improvement|progress|difference|impact|result|results|value|win|shift"
     r"|change|benefit|breakthrough|game.?changer)\b", re.I)
 
+# An imperative is the bare base form, so it carries none of the inflection
+# (-s, -ed, -es) or the auxiliaries FINITE_VERB looks for: "Play to win." and
+# "Build durable growth." were both being reported as verbless fragments. On the
+# seven-line manifesto that surfaced this, two of the five hits were imperatives,
+# so 40% of the document's one finding was wrong. A closed list is the same
+# device FINITE_VERB already is, and it only ever fires at a sentence opening.
+IMPERATIVE_OPENER = re.compile(
+    r"^\W*(?:and|but|so|then|now|first|next|finally)?\W*"
+    r"(?:add|aim|allow|apply|ask|assume|avoid|begin|book|break|bring|build|buy"
+    r"|call|change|check|choose|clean|clear|click|close|collect|come|compare"
+    r"|consider|copy|count|cover|create|cut|decide|define|delete|deliver|design"
+    r"|do|draw|drive|drop|edit|enter|expect|explain|fill|find|finish|fix|focus"
+    r"|follow|forget|get|give|go|grab|grow|handle|help|hire|hold|imagine|include"
+    r"|install|invest|join|keep|know|launch|lead|learn|leave|let|listen|look"
+    r"|love|make|meet|move|name|note|notice|open|pay|pick|plan|play|point|prefer"
+    r"|press|pull|push|put|read|remember|remove|repeat|replace|report|reset"
+    r"|return|review|run|save|say|scale|see|select|sell|send|set|share|ship|show"
+    r"|sign|skip|solve|sort|speak|spend|stand|start|stay|stop|study|take|talk"
+    r"|teach|tell|test|think|throw|touch|track|treat|trust|try|turn|update|use"
+    r"|wait|walk|want|watch|win|write)\b",
+    re.I)
+
 FINITE_VERB = re.compile(
     r"\b(?:is|are|was|were|be|been|being|has|have|had|do|does|did|can|could|will"
     r"|would|shall|should|may|might|must|gets?|goes|comes?|makes?|takes?|gives?"
@@ -161,6 +345,8 @@ def verbless_fragments(prose: str) -> list[str]:
             continue
         if sent.rstrip().endswith(":") or sent.lstrip().startswith(("-", "*", "#", "|")):
             continue
+        if IMPERATIVE_OPENER.match(sent):
+            continue
         if not FINITE_VERB.search(sent):
             out.append(sent)
     return out
@@ -307,6 +493,7 @@ def measure(text: str) -> dict:
     triads = [" ".join(m.group(0).split()) for m in NEGATION_TRIAD.finditer(prose)]
     dangling = dangling_pointers(text)
     fragments = verbless_fragments(prose)
+    antithesis = antithesis_pairs(prose)
     thin = thin_sections(text)
     clusters = referent_clusters(text)
     table_uniformity, column = table_row_uniformity(text)
@@ -321,6 +508,7 @@ def measure(text: str) -> dict:
         "thin_section": {"count": len(thin), "per_1k": per_k(len(thin)), "hits": thin[:6]},
         "referent_cluster": {"count": len(clusters), "per_1k": per_k(len(clusters)), "hits": clusters[:3]},
         "table_uniformity": {"share": table_uniformity, "column": column},
+        "antithesis_pair": {"count": len(antithesis), "per_1k": per_k(len(antithesis)), "hits": antithesis[:6]},
         "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]},
@@ -354,7 +542,8 @@ LABEL = {
     "verbless_fragment": "Verbless fragments",
     "thin_section": "Headings over a sentence or two",
     "referent_cluster": "One thing under several names",
-    "subtractive_contrast": "Binary contrasts",
+    "antithesis_pair": "Antithesis pairs",
+    "subtractive_contrast": "Binary contrasts (X, not Y)",
     "comma_series": "Comma-series density",
     "significance_scaffolding": "Announced significance",
     "classifier_scaffolding": "Graded not delivered (stems)",