zero-slop 2.12.22 → 2.12.24

package/README.md

@@ -14,7 +14,7 @@ Zero Slop is a free, open-source agent skill that finds and removes AI slop whil
 
 <p align="center">
   <a href="https://github.com/manavmishra/ZeroSlop/actions/workflows/validate.yml"><img alt="Validate" src="https://github.com/manavmishra/ZeroSlop/actions/workflows/validate.yml/badge.svg"></a>
-  <img alt="Version 2.12.22" src="https://img.shields.io/badge/version-2.12.22-72528F?color=C15732">
+  <img alt="Version 2.12.24" src="https://img.shields.io/badge/version-2.12.24-72528F?color=C15732">
   <a href="https://www.npmjs.com/package/zero-slop"><img alt="npm version" src="https://img.shields.io/npm/v/zero-slop?color=C15732"></a>
   <a href="https://www.npmjs.com/package/zero-slop"><img alt="npm downloads" src="https://img.shields.io/npm/dm/zero-slop?color=17634F"></a>
   <a href="https://github.com/manavmishra/ZeroSlop/stargazers"><img alt="GitHub stars" src="https://img.shields.io/github/stars/manavmishra/ZeroSlop?style=flat&color=C15732"></a>
@@ -176,7 +176,7 @@ python3 scripts/slopscore.py --batch drafts/ --gate 25
 The CLI sends a file to the hosted editor without changing the file on disk:
 
 ```sh
-npx --yes zero-slop@2.12.22 deslop draft.md --genre professional
+npx --yes zero-slop@2.12.24 deslop draft.md --genre professional
 ```
 
 Use `-` for stdin and `--json` for structured output. `--require-approved` prints the result but exits nonzero when review is needed. Requires Node.js 22+; offline `score` also needs Python 3. [CLI options and privacy](docs/cli.md).

package/SKILL.md

@@ -2,7 +2,7 @@
 name: zero-slop
 license: MIT
 metadata:
-  version: "2.12.22"
+  version: "2.12.24"
   author: manavmishra
 description: Edit drafts into natural prose, inspect AI-sounding patterns, or review how a specified audience might respond passage by passage. Zero Slop runs inside the user's existing AI assistant with local tools that protect source details. Use for humanizing or de-slopping writing, polishing outward-facing prose, social drafts, final editorial checks, or an explicit simulated reader review. Preserve facts, voice and format; reader simulations are hypotheses, not human feedback.
 ---

package/bin/lib/deslop.mjs

@@ -74,7 +74,7 @@ export function validateResult(result) {
     || !validReport(result.before) || !validReport(result.after) || !number(result.scoreChange, -100, 100)
     || typeof result.factsPreserved !== "boolean" || typeof result.passedFinalChecks !== "boolean"
     || ![result.independentModelChecks, result.modelRequests, result.rolesCompleted, result.finishingRounds, result.durationMs].every(integer)
-    || result.modelRequests > 1 || !string(result.scorerVersion) || !string(result.note)) {
+    || result.modelRequests > 2 || !string(result.scorerVersion) || !string(result.note)) {
     throw new DeslopError("invalid_response", "The MCP service returned an invalid structured result.");
   }
   // Return the original object, including additive fields; never rewrite its status.

package/docs/cli.md

@@ -3,7 +3,7 @@
 Use `deslop` for hosted editing with MCP parity. Use `score` for offline checks.
 
 ```sh
-npm install --global zero-slop@2.12.22
+npm install --global zero-slop@2.12.24
 zero-slop deslop draft.md --genre professional
 zero-slop deslop - --genre email < draft.txt
 zero-slop deslop draft.md --json --require-approved

package/docs/rest-api.md

@@ -102,7 +102,7 @@ The successful response contains these 14 fields:
 | `factsPreserved` | Whether tracked source details survived the checks |
 | `passedFinalChecks` | Whether the rewritten text passed the final checks |
 | `independentModelChecks` | Count of independent model checks; currently zero |
-| `modelRequests` | Editing-model requests made, zero or one |
+| `modelRequests` | Provider attempts started, from zero to two; failed attempts count |
 | `rolesCompleted` | Completed pipeline responsibilities |
 | `finishingRounds` | Additional local finishing rounds |
 | `scorerVersion` | Deployed Zero Slop release |

package/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "zero-slop",
-  "version": "2.12.22",
+  "version": "2.12.24",
   "description": "Find and fix canned AI writing while preserving the facts, voice, and format.",
   "mcpServers": {
     "zero-slop": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zero-slop",
-  "version": "2.12.22",
+  "version": "2.12.24",
   "description": "An editing skill, offline writing checks, and a CLI for the hosted Zero Slop MCP pipeline. Find stock AI phrasing, rewrite, and check source details.",
   "bin": {
     "zero-slop": "bin/zero-slop.mjs"

package/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "zero-slop",
-  "version": "2.12.22",
+  "version": "2.12.24",
   "description": "Find and fix canned AI writing while preserving the facts, voice, and format.",
   "author": {
     "name": "Manav Mishra",

package/scripts/rescue.py

@@ -18,12 +18,89 @@ import sys
 
 MAX_INPUT_BYTES = 4 * 1024 * 1024
 PROTECTED = re.compile(
-    r"```[\s\S]*?```|`[^`\n]+`|\[[^\]\n]+\]\([^)]+\)|https?://[^\s<]+|"
-    r"“[^”\n]*”|‘[^’\n]*’|\"[^\"\n]*\""
+    r"```[\s\S]*?```|^[ \t]*>[^\n]*(?:\n[ \t]*>[^\n]*)*|"
+    r"`[^`\n]+`|\[[^\]\n]+\]\([^)]+\)|https?://[^\s<]+",
+    re.MULTILINE,
 )
 TOKEN = re.compile(r"\ue000(\d+)\ue001")
 
 
+def _protected_ranges(text: str) -> list[tuple[int, int]]:
+    """Scan quote delimiters once; an unmatched opener never rescans a suffix."""
+    base = []
+    for match in PROTECTED.finditer(text):
+        end = match.end()
+        if match.group(0).startswith(("http://", "https://")):
+            # A closing prose quote may be adjacent to a URL. Leave its
+            # delimiter to the quote scanner, preserving all original bytes.
+            boundary = re.search(r"[\"'“”‘’][.!?,;:)]*$", match.group(0))
+            if boundary:
+                end = match.start() + boundary.start()
+        base.append((match.start(), end))
+    quotes: list[list[tuple[int, int]]] = [[], [], [], []]
+    opened: list[int | None] = [None, None, None, None]
+    base_index = 0
+
+    def word(char: str) -> bool:
+        return bool(char) and char in "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+
+    for index, char in enumerate(text):
+        while base_index < len(base) and index >= base[base_index][1]:
+            base_index += 1
+        in_base = base_index < len(base) and base[base_index][0] <= index
+        if in_base:
+            continue
+        previous = text[index - 1] if index else ""
+        following = text[index + 1] if index + 1 < len(text) else ""
+        kind: int | None = None
+        starts = False
+        closes = False
+        if char == "“":
+            kind, starts = 0, True
+        elif char == "”":
+            kind, closes = 0, True
+        elif char == "‘":
+            kind, starts = 1, True
+        elif char == "’":
+            kind, closes = 1, not (word(previous) and word(following))
+        elif char == '"':
+            kind, starts, closes = 2, True, True
+        elif char == "'":
+            kind, starts, closes = 3, not word(previous), not word(following)
+        if kind is None:
+            continue
+        start = opened[kind]
+        if start is not None and closes:
+            quotes[kind].append((start, index + 1))
+            opened[kind] = None
+        elif start is None and starts:
+            opened[kind] = index
+
+    # An incomplete quoted passage is still source material. Abstain from
+    # editing its remaining suffix rather than guessing where the quote ended.
+    for kind, start in enumerate(opened):
+        if start is not None:
+            quotes[kind].append((start, len(text)))
+
+    # Each list is already ordered. Merge the fixed five lists in linear time,
+    # including nested quotes and protected code/links inside an outer quote.
+    lists = [base, *quotes]
+    positions = [0] * len(lists)
+    merged: list[tuple[int, int]] = []
+    while True:
+        available = [kind for kind, spans in enumerate(lists) if positions[kind] < len(spans)]
+        if not available:
+            break
+        kind = min(available, key=lambda key: lists[key][positions[key]][0])
+        start, end = lists[kind][positions[kind]]
+        positions[kind] += 1
+        if merged and start <= merged[-1][1]:
+            merged[-1] = (merged[-1][0], max(merged[-1][1], end))
+        else:
+            merged.append((start, end))
+    return merged
+
+
 def _without_wrapper(match: re.Match[str]) -> str:
     prefix, word = match.group(1), match.group(2)
     # Capitalize the exposed sentence, but leave names such as iOS and eBay
@@ -37,12 +114,15 @@ 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)
+    parts: list[str] = []
+    cursor = 0
+    for start, end in _protected_ranges(original):
+        parts.append(original[cursor:start])
+        protected.append(original[start:end])
+        parts.append(f"\ue000{len(protected) - 1}\ue001")
+        cursor = end
+    parts.append(original[cursor:])
+    masked = "".join(parts)
     out = re.sub(r"[\u00a0\u202f]", " ", masked)
     # Drop only a complete introductory clause; "Today" would add event timing.
     # A single unpunctuated line break may only wrap the current sentence.
@@ -60,6 +140,13 @@ def rescue_text(text: str) -> str:
         r"(^|[.!?][ \t\r\n]+|\r?\n[ \t]*\r?\n[ \t]*)as we move forward,[ \t]+the team will\b",
         lambda m: m.group(1) + "The team will", out, flags=re.IGNORECASE,
     )
+    # Remove one hype modifier without substituting emotion or paraphrasing
+    # an unspecified benefit. Preserve the announcement and its exact subject.
+    out = re.sub(
+        r"(^|[.!?][ \t\r\n]+|\r?\n[ \t]*\r?\n[ \t]*)([Ww]e)(['’]re| are) "
+        r"thrilled to announce a game[-\u2011]changing update\b",
+        lambda m: m.group(1) + m.group(2) + m.group(3) + " thrilled to announce an update", out,
+    )
     rules: list[tuple[str, str | object]] = [
         (
             r"\bwe are thrilled to unveil ([^,\n]+),\s+a transformative release that "

package/scripts/slopscore.py

@@ -1265,8 +1265,30 @@ def facts(text, _other=""):
 # a feeling verb, because the goal is catching an INVENTED inner state, and the
 # comparison below cancels any that were already in the source.
 INTERIOR_STATE_RX = re.compile(
-    r"\b(?:I|we)\s+(?:genuinely\s+)?(?:was|were|am|felt|feel|got)\s+"
-    r"(?:(?:very|really|extremely|quite|so|genuinely)\s+)?(?P<state>[A-Za-z]+)", re.I)
+    r"\b(?P<subject>I|we)(?:(?P<contraction>['’](?:m|re))|\s+"
+    r"(?:genuinely\s+)?(?P<verb>was|were|am|are|felt|feel|got)(?P<negative>n['’]t)?)\s+"
+    r"(?P<modifiers>(?:(?:very|really|extremely|quite|so|genuinely|not|never|hardly|"
+    r"barely|somewhat|slightly|partly|mostly|almost|nearly|probably|possibly|"
+    r"perhaps|usually|sometimes|occasionally)\s+)*)"
+    r"(?P<state>[A-Za-z]+)\b", re.I)
+# New copula forms are limited to feelings, rather than treating "we're
+# exporting" or "we are product managers" as invented interior experience.
+# The older felt/was/am branches retain their existing experiential coverage.
+INTERIOR_EMOTIONS = frozenset("""afraid alarmed angry anxious ashamed astonished
+bewildered bitter bored calm comfortable confident confused content delighted
+depressed disappointed discouraged distressed eager elated embarrassed excited
+exhausted fearful familiar frustrated furious glad grateful happy hopeful humbled
+hurt isolated lonely miserable nervous overwhelmed panicked pleased proud relieved
+sad safe scared shocked surprised terrified thrilled tired uncomfortable uncertain
+uneasy unhappy unsafe upset worried""".split())
+INTERIOR_COSMETIC_INTENSITY = frozenset("very really extremely quite so genuinely".split())
+INTERIOR_CONTEXT_RX = re.compile(
+    r"\b(?:if|unless|provided|assuming|when|once|until|whether|wish|wished|"
+    r"may|might|could|would|should|possibly|probably|perhaps|reportedly|"
+    r"allegedly|apparently)\b", re.I)
+INTERIOR_ATTRIBUTION_RX = re.compile(
+    r"\b(?:said|says|wrote|writes|claimed|claims|reported|reports|told|tells|"
+    r"according\s+to)\b", re.I)
 INTERIOR_COGNITION_RX = re.compile(
     r"\b(?:I|we)\s+(?P<cognition>remember(?:ed)?|recall(?:ed)?|realise(?:d)?|"
     r"realize(?:d)?|knew|fear(?:ed)?|hope(?:d)?|worr(?:y|ied)|panic(?:ked)?|"
@@ -1285,10 +1307,92 @@ COGNITION_CANON = {
 }
 
 
+def _quoted_interior_starts(text, starts):
+    """Mark quotation/blockquote context in one forward delimiter scan."""
+    quoted, opened = set(), [False, False, False, False]
+    line_start = 0
+    blockquote = False
+    def word(value):
+        return bool(value) and value in "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+    for index, char in enumerate(text):
+        if index == line_start:
+            cursor = index
+            while cursor < len(text) and text[cursor] in " \t":
+                cursor += 1
+            blockquote = cursor < len(text) and text[cursor] == ">"
+        if index in starts and (blockquote or any(opened)):
+            quoted.add(index)
+        previous = text[index - 1] if index else ""
+        following = text[index + 1] if index + 1 < len(text) else ""
+        if char == "“":
+            opened[0] = True
+        elif char == "”":
+            opened[0] = False
+        elif char == "‘":
+            opened[1] = True
+        elif char == "’" and not (word(previous) and word(following)):
+            opened[1] = False
+        elif char == '"':
+            opened[2] = not opened[2]
+        elif char == "'":
+            if opened[3] and not word(following):
+                opened[3] = False
+            elif not opened[3] and not word(previous):
+                opened[3] = True
+        if char == "\n":
+            line_start = index + 1
+    return quoted
+
+
+def _interior_states(text):
+    # Literal code is protected by the structure gate, not an author's feeling.
+    prose = INLINE_CODE_RX.sub(lambda m: " " * len(m.group(0)), _mask_fenced(text))
+    matches = list(INTERIOR_STATE_RX.finditer(prose))
+    quoted = _quoted_interior_starts(prose, {match.start() for match in matches})
+    out, match_index, start = set(), 0, 0
+    # Context is scanned once per sentence, avoiding a suffix scan per state.
+    ends = [m.start() for m in re.finditer(r"[.!?](?=\s|$)|\n[ \t]*\n", prose)] + [len(prose)]
+    for end in ends:
+        sentence = prose[start:end]
+        context = INTERIOR_CONTEXT_RX.search(sentence)
+        attribution = INTERIOR_ATTRIBUTION_RX.search(sentence)
+        context_signature = None
+        if context:
+            # Pin the exact qualification without copying a long sentence into
+            # every state key or exposing it as a new diagnostics field.
+            qualification = " ".join(sentence[context.start():].lower().split())
+            context_signature = hashlib.sha256(qualification.encode("utf-8")).hexdigest()
+        while match_index < len(matches) and matches[match_index].start() < end:
+            match = matches[match_index]
+            match_index += 1
+            subject, state = match.group("subject").lower(), match.group("state").lower()
+            contraction = (match.group("contraction") or "").replace("’", "'").lower()
+            if contraction and contraction != ("'m" if subject == "i" else "'re"):
+                continue
+            if (contraction or match.group("verb").lower() == "are") and state not in INTERIOR_EMOTIONS:
+                continue
+            modifiers = [word.lower() for word in match.group("modifiers").split()
+                         if word.lower() not in INTERIOR_COSMETIC_INTENSITY]
+            if match.group("negative"):
+                modifiers.insert(0, "not")
+            parts = [subject, *modifiers, state]
+            if match.start() in quoted:
+                parts.insert(0, "quoted")
+            if attribution and start + attribution.start() < match.start():
+                parts.insert(0, "attributed")
+            if context_signature:
+                # A hypothetical/qualified feeling must not license a new
+                # unqualified assertion. Keep its actual context conservatively.
+                parts.append("context=" + context_signature)
+            out.add(":".join(parts))
+        start = end + 1
+    return out
+
+
 def interior_claims(text):
     """Inner-state assertions, reduced to a comparable core so paraphrase of an
     existing one does not read as a new invention."""
-    out = {m.group("state").lower() for m in INTERIOR_STATE_RX.finditer(text)}
+    out = _interior_states(text)
     for m in INTERIOR_COGNITION_RX.finditer(text):
         word = m.group("cognition").lower()
         out.add(COGNITION_CANON.get(word, word))