zero-slop 2.7.8 → 2.8.0

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.0-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. |
@@ -169,7 +226,7 @@ Zero Slop v2.6.0 and is preserved in
 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
+proof of general accuracy. We recorded 1.86% lower median throughput across 31 interleaved
 local runs; treat that as machine noise, not a speed claim.
 
 ### Speed

package/SKILL.md

@@ -2,7 +2,7 @@
 name: zero-slop
 license: MIT
 metadata:
-  version: "2.7.8"
+  version: "2.8.0"
   author: manavmishra
 description: Turn drafts into sharp, natural prose or inspect them without rewriting. Zero Slop runs inside the user's existing AI assistant; Claude, GPT, or another compatible model reads and edits in context while local tools point to exact phrases and protect the source. Use when the user asks to humanize or de-slop writing, inspect AI-sounding patterns, fix text that reads like ChatGPT, polish outward-facing prose, draft social or LinkedIn content, or apply a final quality check to prose the agent generated. The workflow preserves facts, voice, and format and learns privately from repeated, reason-labelled human edits.
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zero-slop",
-  "version": "2.7.8",
+  "version": "2.8.0",
   "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,81 @@ 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 their there here
+one two three first second next last own same very just only also more most less
+""".split())
+
+# The negation can open the pair ("Not perfect. Honest.") or land at the end of
+# it ("The draft was cheap. The signal it sent was not."). Both are in tells.md.
+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)\s+not\W*$", re.I)
+
+
+def _antithesis_content(sent: 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 re.findall(r"[A-Za-z][\w'-]*", sent):
+        word = word.lower()
+        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 antithesis_pairs(prose: str) -> list[str]:
+    """Adjacent balanced sentences: the marked form, and the swapped-argument one."""
+    out = []
+    sents = _sentences(prose)
+    for first, second in zip(sents, sents[1:]):
+        n_first, n_second = len(first.split()), len(second.split())
+        # Both halves have to be short enough to read as one figure. A short
+        # line beside a paragraph-length sentence is not a balanced pair.
+        if not (2 <= n_first <= 14 and 1 <= n_second <= 14):
+            continue
+        # Marked: the twist is announced, at either end of the pair.
+        if RX_MARKED_OPEN.match(first) and n_second <= 10:
+            out.append(f"{first} {second}")
+            continue
+        if RX_MARKED_CLOSE.search(second) and n_first <= 10:
+            out.append(f"{first} {second}")
+            continue
+        head, tail = _antithesis_content(first), _antithesis_content(second)
+        if len(head) < 2 or len(tail) < 2:
+            continue
+        # Identical content is repetition, not antithesis: the figure needs the
+        # arguments to have changed.
+        if head == tail:
+            continue
+        shared = set(head) & set(tail)
+        # A shared frame carrying most of the shorter sentence, with the
+        # arguments changed: that is the figure, not an accidental echo.
+        if len(shared) >= 2 and len(shared) / min(len(head), len(tail)) >= 0.5:
+            out.append(f"{first} {second}")
+    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 +218,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 +259,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 +407,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 +422,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 +456,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)",