zero-slop 2.8.0 → 2.8.1

package/README.md

@@ -5,7 +5,7 @@
   <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.8.0-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>
@@ -191,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 |
 |---|---:|---:|---:|---:|
@@ -218,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 1.86% lower median throughput across 31 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.8.0"
+  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.8.0",
+  "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"

package/scripts/register.py

@@ -81,22 +81,41 @@ SHORT_FLOORS = {
 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
+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())
 
-# 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.
+# 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)\s+not\W*$", 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 _antithesis_content(sent: str) -> list[str]:
+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 re.findall(r"[A-Za-z][\w'-]*", sent):
-        word = word.lower()
+    for word in tokens:
         if word in ANTITHESIS_STOP:
             continue
         if len(word) > 3 and word.endswith("s") and not word.endswith("ss"):
@@ -105,35 +124,102 @@ def _antithesis_content(sent: str) -> list[str]:
     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: the marked form, and the swapped-argument one."""
+    """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)
-    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}")
+    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
-        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:
+        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
-        # Identical content is repetition, not antithesis: the figure needs the
-        # arguments to have changed.
-        if head == tail:
+        if RX_SCAFFOLD.search(first) or RX_SCAFFOLD.search(second):
             continue
+        head, tail = cont[i], cont[i + 1]
         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.
+        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