zero-slop 2.8.9 → 2.8.10

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.9-72528F">
+  <img alt="version" src="https://img.shields.io/badge/version-2.8.10-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 11.6 out of 100 on the slop score, inside the human range" src="https://img.shields.io/badge/slop%20score-11.6%2F100-0f7d55"></a>
@@ -163,7 +163,9 @@ is an engineering choice.
 Missed editorial targets do not erase a useful edit or start an open-ended loop. Zero
 Slop permits one targeted repair and one local recheck, then returns the safest
 source-preserving edit with a plain warning. On the website, a failed model call falls
-back to a conservative local edit instead of retrying through more providers.
+back to the same conservative local editor shipped with the installed skill instead of
+retrying through more providers. Shared fixtures require the browser and local command
+to return the same fallback edit, character for character.
 
 Studies find
 [predictable wording](https://arxiv.org/abs/2301.11305) and

package/SKILL.md

@@ -2,7 +2,7 @@
 name: zero-slop
 license: MIT
 metadata:
-  version: "2.8.9"
+  version: "2.8.10"
   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.
 ---
@@ -643,9 +643,13 @@ restart the complete editorial sequence. If the second check still finds a probl
 return the safest source-preserving edit and name the remaining issue plainly.
 
 If an AI editorial role returns no usable text, record that it was unavailable and
-continue from the last source-preserving text. Unavailability is an abstention, not a
-reason to retry, switch models, or replay earlier roles. A caller with a one-request
-budget must never make a second remote request. Report any role that did not complete.
+continue from the last source-preserving text. For an explicit rewrite request, if that
+text is still the unchanged source, run `python3 scripts/rescue.py -` on the source and
+pass its output through the same scorer and fact gate. This deterministic availability
+editor removes only reviewed stock wrappers and never certifies itself; label its use
+plainly. Unavailability is an abstention, not a reason to retry, switch models, or replay
+earlier roles. A caller with a one-request budget must never make a second remote
+request. Report any role that did not complete.
 
 A required repair may raise the writing score from the previous draft as long as it
 stays below the release limit. Source meaning, stated emotion, and factual accuracy
@@ -967,6 +971,9 @@ the AI model already running in the assistant or rewrite this `SKILL.md`.
   requires the section A counts to be written down rather than judged silently.
 - `references/evidence.md` — the research basis: papers, detector mechanics,
   and why each ladder rung is ordered where it is.
+- `scripts/rescue.py` — the conservative, no-network availability editor shared by
+  installed skills and the web demo. It returns a changed draft when a known safe edit
+  is available, then leaves approval to the scorer and fact gate.
 
 ## Worked example (LinkedIn)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zero-slop",
-  "version": "2.8.9",
+  "version": "2.8.10",
   "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/rescue.py

@@ -0,0 +1,155 @@
+#!/usr/bin/env python3
+"""Conservative, deterministic editing when an AI response is unavailable.
+
+This is an availability path, not a substitute for the contextual editor. Every
+rule removes a stock wrapper, contracts a phrase, or repairs paragraph staging.
+Quoted text, code, Markdown links, URLs, names, figures, and claims are left alone.
+
+    python3 scripts/rescue.py draft.txt
+    cat draft.txt | python3 scripts/rescue.py -
+"""
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+import re
+import sys
+
+
+MAX_INPUT_BYTES = 4 * 1024 * 1024
+PROTECTED = re.compile(
+    r"```[\s\S]*?```|`[^`\n]+`|\[[^\]\n]+\]\([^)]+\)|https?://[^\s<]+|"
+    r"“[^”\n]*”|‘[^’\n]*’|\"[^\"\n]*\""
+)
+TOKEN = re.compile(r"\ue000(\d+)\ue001")
+
+
+def _sentence_pair(match: re.Match[str], *, past: bool) -> str:
+    first, second = match.group(1), match.group(2)
+    lead = first[:1].upper() + first[1:]
+    return f"{lead} {'mattered' if past else 'matters'}. " + (
+        f"More important was {second}." if past else f"The larger gain is {second}."
+    )
+
+
+def rescue_text(text: str) -> str:
+    """Return a bounded, source-preserving edit; return clean text unchanged."""
+    original = str(text or "").strip()
+    protected: list[str] = []
+
+    def mask(match: re.Match[str]) -> str:
+        protected.append(match.group(0))
+        return f"\ue000{len(protected) - 1}\ue001"
+
+    masked = PROTECTED.sub(mask, original)
+    out = re.sub(r"[\u00a0\u202f]", " ", masked)
+    rules: list[tuple[str, str | object]] = [
+        (
+            r"\bwe are thrilled to unveil ([^,\n]+),\s+a transformative release that "
+            r"redefines what is possible in ([^.]+)\.",
+            lambda m: f"{m.group(1)} updates {m.group(2)}.",
+        ),
+        (r"\bthis release represents a significant milestone in our journey to empower "
+         r"teams everywhere\.\s*", ""),
+        (r"\bwe have listened carefully to your feedback and are excited to deliver a "
+         r"suite of powerful new capabilities\.",
+         "We listened to your feedback and added new capabilities."),
+        (r"\bour cutting[-\u2010\u2011 ]edge\b", "Our"),
+        (r"\bhours of tedious manual configuration\b", "hours of manual configuration"),
+        (r"\bwe have completely reimagined\b", "We rebuilt"),
+        (r"\bwith robust error handling built in from the ground up\b",
+         "with built-in error handling"),
+        (r"\bwe believe these improvements will fundamentally transform how your team "
+         r"works,\s+and the release is available today\.", "The release is available today."),
+        (r"\bwe are incredibly excited to share(?: some news)? about\b", "We're excited about"),
+        (r"\bwe(?:['’]re| are) excited to share(?: some news)? about\b", "We're excited about"),
+        (r"\bwe are incredibly excited to share\b", "We're sharing"),
+        (r"\bwe(?:['’]re| are) excited to share\b", "We're excited about"),
+        (r"\bi(?:['’]m| am) incredibly excited to (?:share|announce)\b", "I'm sharing"),
+        (r"\bour journey\b", "our work"),
+        (r"\bour transformative journey\b", "our work"),
+        (r"\bin today'?s rapidly evolving (?:landscape|world)\b", "Today"),
+        (r"\bit is important to note that\b", ""),
+        (r"\bit is worth noting that\b", ""),
+        (r"\bwhat we did not realize was just how deeply it impacted everything downstream\.",
+         "We underestimated its effect on the work that followed."),
+        (r"\bonboarding is not a checklist\.\s*it is a promise\.",
+         "We see onboarding as a promise."),
+        (r"\bonboarding isn['’]t a checklist\s*[-—]\s*it['’]s a promise\.",
+         "We see onboarding as a promise."),
+        (r"\bthe insights were game[-\u2011]changing\.",
+         "Those conversations changed our approach."),
+        (r"\bthe insights were (?:transformative|clear|significant):\s*",
+         "Those conversations showed that "),
+        (r"\ba platform that leverages intelligent automation to streamline the entire "
+         r"process end to end\b", "a platform that automates onboarding from start to finish"),
+        (r"\bthe results speak for themselves:\s*([a-z])",
+         lambda m: m.group(1).upper()),
+        (r"\bthe results speak for themselves\.\s*", ""),
+        (r"\bbut here is the thing nobody talks about\.\s*", ""),
+        (r"\bthe real win was not ([^.]+)\.\s*it was ([^.]+)\.",
+         lambda m: _sentence_pair(m, past=True)),
+        (r"\bthe real win isn['’]t just ([^.]+)\.\s*it['’]s ([^.]+)\.",
+         lambda m: _sentence_pair(m, past=False)),
+        (r"\bthat is the kind of impact that keeps us going\b", "That result keeps us going"),
+        (r"\bunlock(?:ing)? the full potential of\b", "use"),
+        (r"\bseamlessly integrates?\b", "integrates"),
+        (r"\bjust how deeply\b", "how much"),
+        (r"\bgame[-\u2011]changing\b", "useful"),
+        (r"\bcutting[-\u2010\u2011 ]edge\b", "current"),
+        (r"\bredefines what(?:['’]s| is) possible in\b", "updates"),
+        (r"\bin order to\b", "to"),
+        (r"\bat the end of the day\b", "ultimately"),
+        (r"\bwe are\b", "we're"),
+        (r"\bwe did not\b", "we didn't"),
+        (r"\bwe do not\b", "we don't"),
+        (r"\bi am\b", "I'm"),
+        (r"\bit is\b", "it's"),
+        (r"\bthey are\b", "they're"),
+        (r"\byou are\b", "you're"),
+        (r"\bthere is\b", "there's"),
+        (r"\bdoes not\b", "doesn't"),
+        (r"\bis not\b", "isn't"),
+        (r"\bare not\b", "aren't"),
+        (r"\bcannot\b", "can't"),
+    ]
+    for pattern, replacement in rules:
+        out = re.sub(pattern, replacement, out, flags=re.IGNORECASE)
+    out = re.sub(r"[ \t]+\n", "\n", out)
+    out = re.sub(r" {2,}", " ", out).strip()
+
+    if out == masked:
+        paragraphs = [part.strip() for part in re.split(r"\n{2,}", out) if part.strip()]
+        if len(paragraphs) >= 4 and all(len(part.split()) < 24 for part in paragraphs):
+            out = " ".join(paragraphs)
+
+    def restore(match: re.Match[str]) -> str:
+        index = int(match.group(1))
+        return protected[index] if index < len(protected) else match.group(0)
+
+    return TOKEN.sub(restore, out).strip()
+
+
+def _read(path: str) -> str:
+    if path == "-":
+        raw = sys.stdin.buffer.read(MAX_INPUT_BYTES + 1)
+    else:
+        raw = Path(path).read_bytes()
+    if len(raw) > MAX_INPUT_BYTES:
+        raise SystemExit(f"input exceeds {MAX_INPUT_BYTES} bytes")
+    try:
+        return raw.decode("utf-8")
+    except UnicodeDecodeError as exc:
+        raise SystemExit(f"input is not valid UTF-8: {exc}") from exc
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    parser.add_argument("input", nargs="?", default="-", help="UTF-8 file, or - for stdin")
+    args = parser.parse_args(argv)
+    sys.stdout.write(rescue_text(_read(args.input)) + "\n")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())