zero-slop 2.12.29 → 2.12.31

package/README.md

@@ -14,7 +14,7 @@ It finds AI slop and workslop, guides the edit, and checks that the key details
 
 <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.29" src="https://img.shields.io/badge/version-2.12.29-72528F?color=C15732">
+  <img alt="Version 2.12.31" src="https://img.shields.io/badge/version-2.12.31-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>
@@ -120,7 +120,7 @@ We ran Zero Slop and three other open-source agent skills on our AI Slop test co
 
 ![Writing scores and local checks for a saved, same-model replay of the AI Slop test corpus; lower scores are better](assets/bench-search-rewrites.png)
 
-The [RAID+ audit](bench/raid-plus-corpus/README.md) asks a different question: how much default writing from different models is flagged as AI slop by Zero Slop? The test corpus contains 7,627 anonymous, user-generated transcripts:
+Our [RAID+ audit](bench/raid-plus-corpus/README.md) scored 7,627 non-empty machine-generated abstracts from four models. The [INSCONE project](https://github.com/markstanl/INSCONE) extended RAID by generating new outputs from the original RAID prompts.
 
 | Model | Texts scored | Mean writing score ↓ | At or above 25 |
 |---|---:|---:|---:|
@@ -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.29 deslop draft.md --genre professional
+npx --yes zero-slop@2.12.31 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.29"
+  version: "2.12.31"
   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.
 ---
@@ -33,6 +33,22 @@ citations, and the ladder below orders the signals by measured strength.
 
 ## Hard rules (non-negotiable)
 
+For an explicit character-cleanup request, use the bundled offline text-hygiene
+helper at `scripts/text_hygiene.py` when available. It inspects formatting
+characters and removes only a
+small reviewed set of embedded artifacts in 16 common ASCII prose words.
+Only sentence-shaped lines with conservative prose openers are eligible.
+Recognized code, command syntax, URLs, formulas, quotations and multilingual
+formatting are excluded; these guards are not a complete code parser. Preserve
+uncertain text and use inspection when its purpose is unclear.
+This is a separate local operation, not a replacement for contextual editing.
+Its change record can reverse the exact cleanup. A scriptless assistant must
+not claim byte-level cleanup it did not perform. Character cleanup does not
+verify removal of statistical watermarks from ChatGPT, Claude, Gemini or any
+other model. Preserve required disclosures and attribution.
+In a host that routes local checks through the bundled MCP connector, use its
+`clean_text` tool with the supplied text and optional `inspect: true` instead.
+
 1. **Fidelity.** Meaning, claims, and facts survive exactly. Never invent a
    number, name, anecdote, or experience — and experiential/interior claims
    count ("by test day it felt familiar", "I was terrified"): if the author

package/bin/lib/text-hygiene.d.mts

@@ -0,0 +1,6 @@
+export type HygieneEdit = { start: number; end: number; original: string; replacement: ''; reason: string; outputStart: number; outputBinding: string };
+export type HygieneResult = { text: string; edits: HygieneEdit[]; status: 'cleaned' | 'unchanged'; policyVersion: string; offsetUnit: 'utf16'; statisticalWatermark: { status: 'not_verified'; reason: string } };
+export function cleanTextHygiene(text: string): HygieneResult;
+export function inspectTextHygiene(text: string): Omit<HygieneResult, 'status'> & { status: 'inspected'; findings: Array<{ start: number; codePoint: string; disposition: 'removable' | 'preserved' }> };
+export function reverseTextHygiene(text: string, edits: HygieneEdit[]): string;
+export function createTextHygiene(): { cleanTextHygiene: typeof cleanTextHygiene; inspectTextHygiene: typeof inspectTextHygiene; reverseTextHygiene: typeof reverseTextHygiene };

package/bin/lib/text-hygiene.mjs

@@ -0,0 +1,111 @@
+/** Conservative copy-artifact cleanup. This never detects a provider watermark. */
+export function createTextHygiene() {
+  const policyVersion = '2026-10-26.1';
+  const removable = /[\u200B\u2060\uFEFF]/g;
+  const words = new Set('a an and are clear draft hello in is of text the this to world writing'.split(' '));
+  const statisticalWatermark = { status: 'not_verified', reason: 'matching_detector_unavailable' };
+  function validate(text) {
+    if (typeof text !== 'string') throw new TypeError('Text must be a string.');
+    if (text.length > 200000) throw new RangeError('Text hygiene input exceeds 200000 UTF-16 units.');
+  }
+  // A change-detection fingerprint, not authentication or provenance evidence.
+  function binding(text) {
+    let first = 2166136261; let second = 2246822519;
+    for (let i = 0; i < text.length; i += 1) {
+      first = Math.imul(first ^ text.charCodeAt(i), 16777619) >>> 0;
+      second = Math.imul(second ^ text.charCodeAt(i), 3266489917) >>> 0;
+    }
+    return `${text.length}:${first}:${second}`;
+  }
+  function plannedEdits(text) {
+    if (/[<>]/.test(text)) return []; // Preserve unknown markup and multiline HTML as a whole.
+    const edits = []; let offset = 0; let fence = null; let frontmatter = false;
+    for (const line of text.split(/(?<=\n)/)) {
+      if (offset === 0 && /^\uFEFF?---\s*$/.test(line)) { frontmatter = true; offset += line.length; continue; }
+      if (frontmatter) { if (/^(?:---|\.\.\.)\s*$/.test(line)) frontmatter = false; offset += line.length; continue; }
+      const marker = line.match(/^\s*(`{3,}|~{3,})/);
+      if (marker) {
+        if (!fence) fence = { char: marker[1][0], length: marker[1].length };
+        else if (fence.char === marker[1][0] && marker[1].length >= fence.length && /^\s*(?:`+|~+)\s*$/.test(line)) fence = null;
+        offset += line.length; continue;
+      }
+      const plain = line.replace(removable, '');
+      // Sentence shape and a small set of prose openers keep unfenced commands
+      // and unknown fragments out of this deliberately conservative cleanup.
+      const protectedLine = fence || !/^\s*(?:the|this|hello|an?)\b/i.test(plain) || !/[.!?]\s*$/.test(plain)
+        || /[()[\]{};&]|(?:^|\s)--?[A-Za-z]/.test(plain)
+        || [...plain].some(char => (char.charCodeAt(0) < 32 && !'\t\n\r'.includes(char)) || char.charCodeAt(0) > 126)
+        || /^ {4}|^\t|[`"'<>$=\\:|]|https?:|www\.|@|\]\(|\b(?:identifier|variable|function|path|command|token|password|code|regex|formula|equation)\b/i.test(plain)
+        || /\b\w+[./_]\w+\b/.test(plain);
+      const ordinaryWords = plain.match(/[A-Za-z]+/g) || [];
+      if (!protectedLine && ordinaryWords.length >= 2) {
+        for (const word of line.matchAll(/[A-Za-z\u200B\u2060\uFEFF]+/g)) {
+          const cleaned = word[0].replace(removable, '');
+          if (!words.has(cleaned.toLowerCase())) continue;
+          for (let i = 1; i < word[0].length - 1; i += 1) {
+            const char = word[0][i];
+            if ('\u200B\u2060\uFEFF'.includes(char) && /[A-Za-z]/.test(word[0][i - 1]) && /[A-Za-z]/.test(word[0][i + 1])) {
+              const start = offset + word.index + i;
+              edits.push({ start, end: start + 1, original: char, replacement: '', reason: 'embedded_ascii_copy_artifact' });
+            }
+          }
+        }
+      }
+      offset += line.length;
+    }
+    return edits;
+  }
+  function cleanTextHygiene(text) {
+    validate(text);
+    const edits = plannedEdits(text);
+    const chunks = []; let cursor = 0;
+    for (const edit of edits) { chunks.push(text.slice(cursor, edit.start)); cursor = edit.end; }
+    chunks.push(text.slice(cursor));
+    const cleaned = chunks.join(''); const outputBinding = binding(cleaned);
+    for (let i = 0; i < edits.length; i += 1) {
+      edits[i].outputStart = edits[i].start - i;
+      edits[i].outputBinding = outputBinding;
+    }
+    return { text: cleaned, edits, status: edits.length ? 'cleaned' : 'unchanged', policyVersion,
+      offsetUnit: 'utf16', statisticalWatermark: { ...statisticalWatermark } };
+  }
+  function inspectTextHygiene(text) {
+    const result = cleanTextHygiene(text); const findings = [];
+    const actionable = new Set(result.edits.map(edit => edit.start));
+    for (let i = 0; i < text.length;) {
+      const cp = text.codePointAt(i);
+      if (cp === 0xAD || cp === 0xFEFF || (cp >= 0x200B && cp <= 0x200F)
+        || (cp >= 0x202A && cp <= 0x202E) || (cp >= 0x2060 && cp <= 0x2069)
+        || (cp >= 0xFE00 && cp <= 0xFE0F) || (cp >= 0xE0000 && cp <= 0xE01EF)) {
+        findings.push({ start: i, codePoint: `U+${cp.toString(16).toUpperCase().padStart(4, '0')}`,
+          disposition: actionable.has(i) ? 'removable' : 'preserved' });
+      }
+      i += cp > 0xFFFF ? 2 : 1;
+    }
+    return { ...result, text, findings, status: 'inspected' };
+  }
+  function reverseTextHygiene(text, edits) {
+    validate(text);
+    if (!Array.isArray(edits) || edits.length > 200000) throw new TypeError('Edits must be a bounded array.');
+    const chunks = []; let cursor = 0; let previous = -1; const outputBinding = binding(text);
+    for (let i = 0; i < edits.length; i += 1) {
+      const edit = edits[i];
+      if (!edit || typeof edit !== 'object' || !Number.isInteger(edit.start) || edit.start < 1 || edit.start > text.length + edits.length
+        || !Number.isInteger(edit.outputStart) || edit.outputStart < 0 || edit.outputStart > text.length
+        || edit.start <= previous || edit.end !== edit.start + 1
+        || !'\u200B\u2060\uFEFF'.includes(edit.original) || edit.original.length !== 1
+        || edit.replacement !== '' || edit.outputBinding !== outputBinding
+        || edit.outputStart !== edit.start - i) throw new Error('Cleanup plan does not match this text.');
+      previous = edit.start;
+      chunks.push(text.slice(cursor, edit.outputStart), edit.original); cursor = edit.outputStart;
+    }
+    chunks.push(text.slice(cursor));
+    return chunks.join('');
+  }
+  return Object.freeze({ cleanTextHygiene, inspectTextHygiene, reverseTextHygiene });
+}
+
+const helpers = createTextHygiene();
+export const cleanTextHygiene = helpers.cleanTextHygiene;
+export const inspectTextHygiene = helpers.inspectTextHygiene;
+export const reverseTextHygiene = helpers.reverseTextHygiene;

package/bin/zero-slop.mjs

@@ -12,6 +12,7 @@ import { homedir } from "node:os";
 import { dirname, join, parse, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { deslop, DeslopError, isApprovedResult, validateInput } from "./lib/deslop.mjs";
+import { cleanTextHygiene, inspectTextHygiene } from "./lib/text-hygiene.mjs";
 
 const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 const PAYLOAD = ["SKILL.md", "references", "scripts", "data"];
@@ -37,6 +38,7 @@ function usage(v) {
 Usage
   npx zero-slop install [--harness <name>] [--dir <path>] [--force]
   npx zero-slop score <file|-> [-- <slopscore flags>]
+  npx zero-slop clean-text <file|-> [--inspect] [--json]
   npx zero-slop deslop <file|-> [--genre <name>] [--audience <reader>] [--json]
                        [--require-approved] [--timeout <seconds>]
   npx zero-slop where
@@ -249,7 +251,7 @@ function parseDeslopArgs(argv) {
     json: Boolean(values["--json"]), requireApproved: Boolean(values["--require-approved"]), timeoutMs };
 }
 
-async function readDraft(file, signal) {
+async function readDraft(file, signal, preserveBOM = false) {
   const maximum = 128 * 1024;
   let bytes;
   if (file === "-") {
@@ -288,7 +290,7 @@ async function readDraft(file, signal) {
     } finally { await handle?.close(); }
   }
   signal.throwIfAborted();
-  try { return new TextDecoder("utf-8", { fatal: true }).decode(bytes); } catch {
+  try { return new TextDecoder("utf-8", { fatal: true, ignoreBOM: preserveBOM }).decode(bytes); } catch {
     throw new DeslopError("invalid_input", "The draft must be valid UTF-8; nothing was uploaded.");
   }
 }
@@ -348,6 +350,15 @@ async function runDeslop(argv, v) {
 
 async function main() {
   const argv = process.argv.slice(2);
+  if (argv[0] === "clean-text") {
+    const args = argv.slice(1);
+    const files = args.filter(arg => !["--inspect", "--json"].includes(arg));
+    if (files.length !== 1 || (files[0].startsWith("--"))) throw new Error("clean-text needs one file or -, plus optional --inspect and --json");
+    const text = await readDraft(files[0], new AbortController().signal, true);
+    const result = args.includes("--inspect") ? inspectTextHygiene(text) : cleanTextHygiene(text);
+    process.stdout.write(args.includes("--json") ? `${JSON.stringify(result)}\n` : result.text);
+    return 0;
+  }
   // Parse this command separately: no install flags or scorer passthrough can
   // accidentally become a remote-upload option.
   if (argv[0] === "deslop") {

package/docs/cli.md

@@ -1,9 +1,25 @@
 # Zero Slop CLI
 
+For an explicit local copy-artifact cleanup, use `npx zero-slop clean-text draft.md`.
+Use `--inspect --json` to inspect without changing the returned text, or `--json`
+with cleanup to receive reversible edits. The command never changes the source
+file and accepts one regular UTF-8 file or stdin, up to 128 KiB.
+
+This first policy removes only embedded U+200B, U+2060 and U+FEFF in a small
+reviewed vocabulary of 16 common ASCII prose words. A line is eligible only
+when it starts with The, This, Hello, A or An and ends with sentence punctuation.
+Recognized code, command flags, operators, quotes, URLs, markup and non-ASCII
+text are excluded. Other words and fragments stay unchanged. These guards are
+conservative rules, not a complete parser for every programming language.
+This deliberately limited cleanup does not verify statistical watermark removal.
+The installed skill also includes the offline Python helper. Its offsets use
+code points; the JavaScript result uses UTF-16 offsets. Change-detection bindings
+are not authentication or provenance evidence.
+
 Use `deslop` for hosted editing with MCP parity. Use `score` for offline checks.
 
 ```sh
-npm install --global zero-slop@2.12.29
+npm install --global zero-slop@2.12.31
 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

@@ -22,9 +22,10 @@ curl --fail-with-body --max-time 75 --include https://mcp.zero-slop.ai/v1/deslop
 
 | Field | Accepted value |
 |---|---|
-| `text` | Required, nonempty string; up to 20,000 Unicode code points after trimming |
+| `text` | Required, nonempty string; up to 20,000 Unicode code points. Editing trims the text first; `clean_text` preserves it and counts its full length. |
 | `genre` | `general` (default), `social`, `email`, `research`, or `professional` |
 | `audience` | Optional string, up to 200 Unicode code points after trimming |
+| `operation` | Optional `"clean_text"` for conservative character cleanup without an editing-model call |
 
 Lengths count Unicode code points; a combined emoji or accented character can contain more than one.
 Send UTF-8 JSON in the body, never a URL query. The body limit is 128 KiB, including

package/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "zero-slop",
-  "version": "2.12.29",
+  "version": "2.12.31",
   "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.29",
+  "version": "2.12.31",
   "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.29",
+  "version": "2.12.31",
   "description": "Find and fix canned AI writing while preserving the facts, voice, and format.",
   "author": {
     "name": "Manav Mishra",

package/scripts/text_hygiene.py

@@ -0,0 +1,143 @@
+#!/usr/bin/env python3
+"""Offline, conservative copy-artifact cleanup; not a watermark detector."""
+import argparse
+import hashlib
+import json
+import os
+import re
+import stat
+import sys
+
+POLICY_VERSION = "2026-10-26.1"
+REMOVABLE = re.compile("[\u200b\u2060\ufeff]")
+WORDS = frozenset("a an and are clear draft hello in is of text the this to world writing".split())
+PROTECTED = re.compile(r'''^ {4}|^\t|[`"'<>$=\\:|]|https?:|www\.|@|\]\(|\b(?:identifier|variable|function|path|command|token|password|code|regex|formula|equation)\b|\b\w+[./_]\w+\b''', re.I)
+
+
+def _validate(text):
+    if not isinstance(text, str):
+        raise TypeError("Text must be a string.")
+    if len(text.encode("utf-16-le", errors="surrogatepass")) // 2 > 200000:
+        raise ValueError("Text hygiene input exceeds 200000 UTF-16 units.")
+
+
+def clean_text_hygiene(text):
+    _validate(text)
+    edits, offset, fence, frontmatter = [], 0, None, False
+    markup = "<" in text or ">" in text
+    parts = text.split("\n")
+    for line_index, part in enumerate(parts):
+        line = part + ("\n" if line_index < len(parts) - 1 else "")
+        if offset == 0 and re.fullmatch("\ufeff?---\\s*", line):
+            frontmatter = True
+            offset += len(line)
+            continue
+        if frontmatter:
+            if re.fullmatch(r"(?:---|\.\.\.)\s*", line):
+                frontmatter = False
+            offset += len(line)
+            continue
+        marker = re.match(r"\s*(`{3,}|~{3,})", line)
+        if marker:
+            char = marker[1][0]
+            if not fence:
+                fence = (char, len(marker[1]))
+            elif fence[0] == char and len(marker[1]) >= fence[1] and re.fullmatch(r"\s*(?:`+|~+)\s*", line):
+                fence = None
+            offset += len(line)
+            continue
+        plain = REMOVABLE.sub("", line)
+        # Preserve unfenced commands and fragments: only conservative prose
+        # openers with sentence-ending punctuation are eligible for cleanup.
+        protected = (markup or fence or not re.match(r"\s*(?:the|this|hello|an?)\b", plain, re.I)
+                     or not re.search(r"[.!?]\s*$", plain)
+                     or re.search(r"[()[\]{};&]|(?:^|\s)--?[A-Za-z]", plain)
+                     or re.search(r"[^\x09\x0a\x0d\x20-\x7e]", plain) or PROTECTED.search(plain))
+        if not protected and len(re.findall(r"[A-Za-z]+", plain)) >= 2:
+            for match in re.finditer("[A-Za-z\u200b\u2060\ufeff]+", line):
+                word = match[0]
+                if REMOVABLE.sub("", word).lower() not in WORDS:
+                    continue
+                for index in range(1, len(word) - 1):
+                    if word[index] in "\u200b\u2060\ufeff" and re.fullmatch("[A-Za-z]", word[index - 1]) and re.fullmatch("[A-Za-z]", word[index + 1]):
+                        start = offset + match.start() + index
+                        edits.append({"start": start, "end": start + 1, "original": word[index], "replacement": "", "reason": "embedded_ascii_copy_artifact"})
+        offset += len(line)
+    chunks, cursor = [], 0
+    for edit in edits:
+        chunks.append(text[cursor:edit["start"]])
+        cursor = edit["end"]
+    chunks.append(text[cursor:])
+    cleaned = "".join(chunks)
+    digest = hashlib.sha256(cleaned.encode("utf-8", errors="surrogatepass")).hexdigest()
+    for index, edit in enumerate(edits):
+        edit.update(outputStart=edit["start"] - index, outputBinding=digest)
+    return {"text": cleaned, "edits": edits, "status": "cleaned" if edits else "unchanged", "policyVersion": POLICY_VERSION,
+            "offsetUnit": "codepoint", "statisticalWatermark": {"status": "not_verified", "reason": "matching_detector_unavailable"}}
+
+
+def inspect_text_hygiene(text):
+    result = clean_text_hygiene(text)
+    actionable = {edit["start"] for edit in result["edits"]}
+    findings = []
+    for index, char in enumerate(text):
+        cp = ord(char)
+        if cp in (0xad, 0xfeff) or 0x200b <= cp <= 0x200f or 0x202a <= cp <= 0x202e or 0x2060 <= cp <= 0x2069 or 0xfe00 <= cp <= 0xfe0f or 0xe0000 <= cp <= 0xe01ef:
+            findings.append({"start": index, "codePoint": f"U+{cp:04X}", "disposition": "removable" if index in actionable else "preserved"})
+    return dict(result, text=text, findings=findings, status="inspected")
+
+
+def reverse_text_hygiene(text, edits):
+    _validate(text)
+    if not isinstance(edits, list) or len(edits) > 200000:
+        raise ValueError("Edits must be a bounded array.")
+    digest = hashlib.sha256(text.encode("utf-8", errors="surrogatepass")).hexdigest()
+    chunks, cursor, previous = [], 0, -1
+    for index, edit in enumerate(edits):
+        if not isinstance(edit, dict):
+            raise ValueError("Cleanup plan does not match this text.")
+        start = edit.get("start")
+        output_start = edit.get("outputStart")
+        if (type(start) is not int or not 1 <= start <= len(text) + len(edits)
+                or type(output_start) is not int or not 0 <= output_start <= len(text)
+                or start <= previous or type(edit.get("end")) is not int
+                or edit["end"] != start + 1
+                or edit.get("original") not in ("\u200b", "\u2060", "\ufeff")
+                or edit.get("replacement") != "" or edit.get("outputBinding") != digest
+                or output_start != start - index):
+            raise ValueError("Cleanup plan does not match this text.")
+        previous = start
+        chunks.extend((text[cursor:output_start], edit["original"]))
+        cursor = output_start
+    chunks.append(text[cursor:])
+    return "".join(chunks)
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("path", help="UTF-8 file or - for stdin")
+    parser.add_argument("--inspect", action="store_true")
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args()
+    maximum = 128 * 1024
+    if args.path == "-":
+        payload = sys.stdin.buffer.read(maximum + 1)
+    else:
+        descriptor = os.open(args.path, os.O_RDONLY | getattr(os, "O_NONBLOCK", 0))
+        with os.fdopen(descriptor, "rb") as source:
+            if not stat.S_ISREG(os.fstat(source.fileno()).st_mode):
+                raise ValueError("Provide a regular UTF-8 file.")
+            payload = source.read(maximum + 1)
+    if len(payload) > maximum:
+        raise ValueError("Input exceeds 128 KiB.")
+    text = payload.decode("utf-8", errors="strict")
+    result = inspect_text_hygiene(text) if args.inspect else clean_text_hygiene(text)
+    print(json.dumps(result, ensure_ascii=True) if args.json else result["text"], end="\n" if args.json else "")
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except (OSError, ValueError, TypeError):
+        print("Text cleanup failed: provide bounded, valid UTF-8 input.", file=sys.stderr)
+        raise SystemExit(2)