zero-slop 2.8.1 → 2.8.3

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.1-72528F">
+  <img alt="version" src="https://img.shields.io/badge/version-2.8.3-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>
@@ -228,33 +228,35 @@ proof of general accuracy.
 
 ### Speed
 
-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
+One busy Apple silicon Mac. Meter: 1,000 documents in 1.9949 seconds (501.3 per
+second), 15,201 words in 0.3200 seconds, worst stress case 2.3077 seconds.
+Reading pass: 0.7712 seconds for the same 1,000 (1296.7 per
+second), 0.1054 for the same large document, linear to 96,000 words. Learning
+pass, 8,000 words: 0.2832 seconds. Across 24 interleaved runs against 2.7.7 we measured
+0.22% 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
+before the budget means anything. On 75 labelled pairs in
 [`bench/antithesis/`](bench/antithesis/):
 
 | Reading pass | 2.8.0 | now |
 |---|---:|---:|
-| Recall, all shapes | 40.0% | 90.0% |
+| Recall, all shapes | 40.0% | 91.2% |
 | 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)
+2.8.3 added the families the 58-pair corpus never tested, where 2.8.2 scores 67.5%
+precision.
 
-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.
+![Antithesis detection before and after, on 75 labelled pairs](assets/bench-antithesis.png)
+
+Bare subject swap and the weak isocolon stay out of reach and count against recall: both
+are identical to ordinary 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.1"
+  version: "2.8.3"
   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/data/corpus/must-flag/manifest.json

@@ -1,142 +1,155 @@
 {
- "_comment": "The ratchet: every miss an audit or a competitor catches becomes a fixture here, in the same change. metric entries are verified by register.py --recall; check entries name the eval.md family a reading pass must catch, and --recall verifies the span exists and the family is a real check.",
- "fixtures": [
-  {
-   "file": "adjective-inflation.md",
-   "expect": [
-    {
-     "metric": "adjective_inflation",
-     "span": "a real improvement"
-    },
-    {
-     "metric": "adjective_inflation",
-     "span": "a genuine breakthrough"
-    }
-   ]
-  },
-  {
-   "file": "monument-negation.md",
-   "expect": [
-    {
-     "metric": "monument_verb",
-     "span": "stands as a testament"
-    },
-    {
-     "metric": "negation_triad",
-     "span": "no runbook, no owner, no rollback"
+  "_comment": "The ratchet: every miss an audit or a competitor catches becomes a fixture here, in the same change. metric entries are verified by register.py --recall; check entries name the eval.md family a reading pass must catch, and --recall verifies the span exists and the family is a real check.",
+  "fixtures": [
+    {
+      "file": "adjective-inflation.md",
+      "expect": [
+        {
+          "metric": "adjective_inflation",
+          "span": "a real improvement"
+        },
+        {
+          "metric": "adjective_inflation",
+          "span": "a genuine breakthrough"
+        }
+      ]
     },
     {
-     "metric": "negation_triad",
-     "span": "Not reviewed, not staged, not announced"
-    }
-   ]
-  },
-  {
-   "file": "dangling-thin.md",
-   "expect": [
-    {
-     "metric": "thin_section",
-     "span": "Install"
+      "file": "monument-negation.md",
+      "expect": [
+        {
+          "metric": "monument_verb",
+          "span": "stands as a testament"
+        },
+        {
+          "metric": "negation_triad",
+          "span": "no runbook, no owner, no rollback"
+        },
+        {
+          "metric": "negation_triad",
+          "span": "Not reviewed, not staged, not announced"
+        }
+      ]
     },
     {
-     "metric": "thin_section",
-     "span": "Configure"
+      "file": "dangling-thin.md",
+      "expect": [
+        {
+          "metric": "thin_section",
+          "span": "Install"
+        },
+        {
+          "metric": "thin_section",
+          "span": "Configure"
+        },
+        {
+          "metric": "dangling_pointer",
+          "span": "download the installer"
+        }
+      ]
     },
     {
-     "metric": "dangling_pointer",
-     "span": "download the installer"
-    }
-   ]
-  },
-  {
-   "file": "referent-cycling.md",
-   "expect": [
-    {
-     "metric": "referent_cluster",
-     "span": "local tools"
-    },
-    {
-     "check": "Synonym cycling",
-     "span": "the local checker"
-    }
-   ]
-  },
-  {
-   "file": "mic-drop.md",
-   "expect": [
-    {
-     "metric": "verbless_fragment",
-     "span": "The review queue."
-    },
-    {
-     "check": "Antithesis pairs",
-     "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"
+      "file": "referent-cycling.md",
+      "expect": [
+        {
+          "metric": "referent_cluster",
+          "span": "local tools"
+        },
+        {
+          "check": "Synonym cycling",
+          "span": "the local checker"
+        }
+      ]
     },
     {
-     "metric": "classifier_scaffolding",
-     "span": "The dangerous part is"
+      "file": "mic-drop.md",
+      "expect": [
+        {
+          "metric": "verbless_fragment",
+          "span": "The review queue."
+        },
+        {
+          "check": "Antithesis pairs",
+          "span": "Different teams, different fixes, same bottleneck."
+        }
+      ]
     },
     {
-     "metric": "classifier_scaffolding",
-     "span": "has a simple cause"
+      "file": "caveat-template.md",
+      "expect": [
+        {
+          "check": "Robotic symmetry",
+          "span": "Neither figure includes bot traffic"
+        }
+      ]
     },
     {
-     "metric": "classifier_scaffolding",
-     "span": "limits worth stating"
+      "file": "label-period-list.md",
+      "expect": [
+        {
+          "check": "List-label periods and bare-noun bullets",
+          "span": "**Latency.**"
+        }
+      ]
     },
     {
-     "metric": "classifier_scaffolding",
-     "span": "One honest caveat"
+      "file": "unnamed-validator.md",
+      "expect": [
+        {
+          "check": "Weasel attribution",
+          "span": "An external audit"
+        },
+        {
+          "check": "Weasel attribution",
+          "span": "A\nthird-party checker"
+        }
+      ]
     },
     {
-     "metric": "classifier_scaffolding",
-     "span": "the ones that matter"
+      "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."
+        }
+      ]
     },
     {
-     "check": "Interpretive metadiscourse",
-     "span": "It counts what it can see, and the rest is the reader's judgment."
+      "file": "plural-noun-fragment.md",
+      "expect": [
+        {
+          "metric": "verbless_fragment",
+          "span": "Same compound, three identifiers."
+        },
+        {
+          "metric": "verbless_fragment",
+          "span": "Same assay, two units."
+        }
+      ]
     }
-   ]
-  }
- ]
+  ]
 }

package/data/corpus/must-flag/plural-noun-fragment.md

@@ -0,0 +1,4 @@
+Every dataset you add widens the space of things that look relevant. Same
+compound, three identifiers. Same assay, two units. Two sources that disagree
+and no rule for which one wins. The model stays exactly as smart. The retrieval
+gets ambiguous, and fluent ambiguity reads as confidence.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zero-slop",
-  "version": "2.8.1",
+  "version": "2.8.3",
   "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

@@ -95,9 +95,13 @@ NEGATION = re.compile(r"\b(?:not|never|cannot)\b|\w+n['’]t\b", re.I)
 # 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_OPEN = re.compile(
+    r"^\W*not\s+(?!all\b|every\b|only\b|just\b|much\b|many\b|most\b|enough\b"
+    r"|yet\b|quite\b|nearly\b|entirely\b|\w+ly\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)
+    r"\b(?:was|were|is|are|did|does|do|has|have|had|will|can|could|would)\s+not\W*$"
+    r"|\b(?:wasn|weren|isn|aren|didn|doesn|don|hasn|haven|hadn|won|can|couldn|wouldn)"
+    r"['\u2019]t\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
@@ -138,7 +142,20 @@ def _common_prefix(a: list[str], b: list[str]) -> int:
 # 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)")
+RX_SCAFFOLD = re.compile(r"^\s*(?:[#>|]|[-*+]\s|\d+\.\s|\*\*)|\n\s*(?:[#>|]|[-*+]\s|\d+\.\s|\*\*)")
+
+
+# Cardinals and calendar words. Their presence in the part of a pair that
+# differs marks a specification rather than a rhetorical figure.
+ENUMERATED_VALUE = frozenset("""
+one two three four five six seven eight nine ten eleven twelve twenty thirty
+forty fifty sixty seventy eighty ninety hundred thousand million billion
+first second third fourth fifth
+monday tuesday wednesday thursday friday saturday sunday
+january february march april may june july august september october november
+december hour hours minute minutes day days week weeks month months year years
+am pm noon midnight
+""".split())
 
 
 def antithesis_pairs(prose: str) -> list[str]:
@@ -189,7 +206,24 @@ def antithesis_pairs(prose: str) -> list[str]:
         # 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):
+        # `prefix >= 1` counted a shared stopword as a frame, so "It does not
+        # run on Windows. It runs on Linux and macOS." qualified on "it" alone.
+        # Requiring a CONTENT frame instead was too strict: "We do not guess. We
+        # measure." shares only "we" and is the figure.
+        #
+        # What separates them is the payoff, not the frame. The figure lands its
+        # twist in a breath -- "We measure." "She proved it." -- while ordinary
+        # negated prose just carries on at normal length. So a stopword frame is
+        # allowed, but only when the second half is that short.
+        content_prefix = any(w not in ANTITHESIS_STOP for w in ta[:prefix])
+        shared_content = {w for w in shared if w not in ANTITHESIS_STOP}
+        # A repeated CONTENT opening is anaphora -- "The report ... The report
+        # ..." -- which the isocolon branch below already refuses for exactly
+        # this reason. Here it was being read as a frame, i.e. as evidence for
+        # the figure rather than against it.
+        strong_frame = len(shared_content) >= 2 and not content_prefix
+        weak_frame = prefix >= 1 or len(shared) >= 2
+        if negated and na <= 10 and ((strong_frame and nb <= 8) or (weak_frame and nb <= 5)):
             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
@@ -217,6 +251,20 @@ def antithesis_pairs(prose: str) -> list[str]:
         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
+        # Enumeration wears the same clothes as isocolon: one frame, both
+        # arguments swapped, the same word overlap. "The free tier includes ten
+        # seats. The pro tier includes fifty seats." is structurally identical
+        # to "A junior engineer reads the error. A senior engineer reads the
+        # stack trace." -- four shared words and 0.67 overlap in both.
+        #
+        # What separates them is what varies. A specification varies a VALUE:
+        # a quantity, a weekday, a time. The figure varies a CONCEPT. So a
+        # cardinal or a calendar word in the part that differs means this is a
+        # table written as prose, and the pass stays quiet.
+        differing = set(head) | set(tail)
+        if differing & ENUMERATED_VALUE or any(
+                any(ch.isdigit() for ch in w) for w in differing):
+            continue
         if len(shared) >= 2 and len(shared) / min(len(head), len(tail)) >= 0.5:
             out.append(f"{first} {second}")
             consumed = i + 1
@@ -226,7 +274,7 @@ def antithesis_pairs(prose: str) -> list[str]:
 # "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(
-    r"[^.\n]{3,90}?,\s+not\s+[^.\n]{3,60}[.\n]"
+    r"[^.\n]{3,90}?[,\u2014\u2013]\s*(?:not|never)\s+[^.\n]{3,60}[.\n]"
     r"|[^.\n]{3,70}\brather than\b[^.\n]{3,50}[.\n]",
     re.I,
 )
@@ -332,6 +380,74 @@ FINITE_VERB = re.compile(
     r"|gate[sd]?|gives?|runs?|gets?|gave|gone)\b"
     r"|\b\w+(?:s|ed|es)\b", re.I)
 
+# The -s half of that catch-all cannot tell a verb from a plural noun, and a
+# plural noun in a fragment made the whole fragment invisible: "Same compound,
+# three identifiers." and "Same assay, two units." both read as verbed on
+# `identifiers` and `units`. Since fragments are mostly noun phrases, and noun
+# phrases are mostly plural, the detector was blind to its own commonest shape.
+#
+# A determiner, number or quantifier immediately before an -s word makes it a
+# noun ("three identifiers", "no rules"), not a verb ("the model runs" keeps
+# its verb because "model" is not in this list). Same closed-list device as
+# IMPERATIVE_OPENER above, and measured the same way: on data/corpus/
+# must-not-flag it adds no findings at all.
+NOUN_MARKER = frozenset("""
+a an the this that these those my your his her its our their no some any
+many several few both all each every another other more most much little
+two three four five six seven eight nine ten dozen hundred thousand
+one first second third next last same own other
+of at in on for by with from to into onto over under about across through
+without within per via against between during after before
+""".split())
+# The prepositions are there for the same reason as the determiners: what
+# follows one is a noun, not a verb. "In innovation at scale." has two words
+# that are verbs elsewhere ("scale", and "innovation" is safe), and without
+# this the fragment reads as a sentence. An infinitive after "to" is not a
+# finite verb either, so listing it here is correct rather than convenient.
+
+
+# The base forms IMPERATIVE_OPENER already knows, reused away from the sentence
+# opening. A plural subject takes a bare verb -- "our engineers ship weekly" --
+# which carries no inflection for the catch-all to find, so without this the
+# fix above turns every such sentence into a fragment.
+BASE_VERBS = frozenset(
+    IMPERATIVE_OPENER.pattern
+    .split("(?:add|", 1)[1]
+    .split(")\\b", 1)[0]
+    .replace("|", " ")
+    .split()
+) | {"add"} | frozenset("""
+work need mean seem feel matter differ vary exist remain happen occur tend
+cost fail pass fit last agree apply depend belong arrive land stick
+""".split())
+# The extras are the stative and intransitive verbs a plural subject takes and
+# the imperative list has no reason to carry -- you do not tell someone to
+# "matter". "The tools work." was the fragment this produced without them. Each
+# one is also a noun in some context ("the work", "the cost"), which the
+# determiner test in _looks_like_noun already handles.
+
+
+def _looks_like_noun(sent: str, start: int) -> bool:
+    """Is the word at `start` sitting in a noun phrase rather than a verb slot?"""
+    prev = re.findall(r"[A-Za-z][\w'-]*", sent[:start])
+    return bool(prev) and prev[-1].lower() in NOUN_MARKER
+
+
+def _has_finite_verb(sent: str) -> bool:
+    for match in FINITE_VERB.finditer(sent):
+        word = match.group(0)
+        # An explicit auxiliary or an -ed form is a verb wherever it appears.
+        if not re.fullmatch(r"\w+(?:s|es)", word, re.I):
+            return True
+        if not _looks_like_noun(sent, match.start()):
+            return True                      # "the model runs"
+    # "three identifiers" is a noun, "one report" is a noun, but "engineers
+    # ship" is a verb: the same determiner test decides both.
+    for match in re.finditer(r"\b[A-Za-z][\w'-]*\b", sent):
+        if match.group(0).lower() in BASE_VERBS and not _looks_like_noun(sent, match.start()):
+            return True
+    return False
+
 
 def _sentences(prose: str) -> list[str]:
     return [x.strip() for x in re.split(r"(?<=[.!?])\s+", prose) if x.strip()]
@@ -347,7 +463,7 @@ def verbless_fragments(prose: str) -> list[str]:
             continue
         if IMPERATIVE_OPENER.match(sent):
             continue
-        if not FINITE_VERB.search(sent):
+        if not _has_finite_verb(sent):
             out.append(sent)
     return out