zero-slop 2.9.2 → 2.10.1

package/README.md

@@ -7,14 +7,12 @@
   </a>
 </p>
 
-Zero Slop crossed 100 GitHub stars and 2,000 npm downloads in its first 12 days.
+      Zero Slop crossed 100 GitHub stars and 2,000 npm downloads in its first 12 days.
 
-<h1 align="center">Zero Slop</h1>
-
-<p align="center"><strong>Find AI-sounding writing. Keep the source intact.</strong></p>
+<p align="center"><strong>Find AI-sounding tells and slop in your writing.</strong></p>
 
 <p align="center">
-  Zero Slop finds stock phrasing, mechanical rhythm, vague claims, and canned formatting.<br>
+  Zero Slop finds slop- stock phrasing, mechanical rhythm, vague claims, and canned formatting in writing.<br>
   Your existing AI assistant edits the draft; local checks guard its names, numbers, links, quotations, code, tables, and paths.
 </p>
 
@@ -32,12 +30,12 @@ Zero Slop crossed 100 GitHub stars and 2,000 npm downloads in its first 12 days.
 
 <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.9.2" src="https://img.shields.io/badge/version-2.9.2-72528F?color=C15732">
+  <img alt="Version 2.10.1" src="https://img.shields.io/badge/version-2.10.1-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>
   <a href="LICENSE"><img alt="MIT license" src="https://img.shields.io/badge/license-MIT-141412"></a>
-  <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://hol.org/registry/plugins/manav-mishra%2Fzero-slop"><img alt="Listed in the HOL plugin registry" src="https://img.shields.io/badge/HOL%20registry-listed-2C6E8F"></a>
 </p>
 
 ```sh
@@ -52,7 +50,7 @@ npx skills add manavmishra/ZeroSlop --global
   </picture>
 </a>
 
-<p align="center"><a href="assets/zero-slop-demo.mp4?v=dark-shell-restored-20260906">Watch the 15-second shell demo</a> · <sub>The original demo uses a longer sample than the example below.</sub></p>
+
 
 ## Before and after
 
@@ -82,11 +80,11 @@ The rewrite retains the draft's stated result. See four complete, reproducible p
 - Edit a research summary without flattening its qualifications.
 - Gate a folder of generated copy before it ships.
 
-Zero Slop is a writing tool. It does not detect authorship; its score describes the text.
+The score describes writing patterns, not authorship.
 
 ## Install
 
-Paste a draft into [zero-slop.ai/try](https://zero-slop.ai/try/). The free editor returns the edit, the before-and-after scores, and the exact phrases that triggered the scorer.
+[Try the free browser editor](https://zero-slop.ai/try/), or install:
 
 | Environment | Fastest route |
 |---|---|
@@ -97,19 +95,19 @@ Paste a draft into [zero-slop.ai/try](https://zero-slop.ai/try/). The free edito
 | Claude.ai | Upload the [latest skill ZIP](https://github.com/manavmishra/ZeroSlop/releases/latest/download/zero-slop.zip) |
 | ChatGPT, Claude, Grok, Gemini, Cursor, or another MCP client | Connect the optional [hosted MCP server](mcp/README.md) |
 
-Once installed, ask your AI assistant to edit a draft:
+Ask your assistant to edit:
 
 ```text
 /zero-slop (your writing)
 ```
 
-Inspect a draft without changing it:
+Inspect without editing:
 
 ```text
 /zero-slop inspect (your writing)
 ```
 
-Score a file locally:
+Score locally:
 
 ```sh
 npx zero-slop score draft.md
@@ -121,17 +119,43 @@ From a cloned checkout, gate a folder:
 python3 scripts/slopscore.py --batch drafts/ --gate 25
 ```
 
-Installed checks run locally; editing follows your AI assistant's privacy settings. The optional hosted MCP processes drafts remotely. See its [privacy details](mcp/README.md).
+Installed checks run locally. Skill editing follows your assistant's privacy settings; [MCP editing is remote](mcp/README.md).
 
 ### Prefer one hosted connection? Use the MCP
 
-Connect the [Zero Slop MCP](https://zero-slop.ai/#mcp) once to edit drafts inside your MCP client. Its `deslop` tool returns the edit, before-and-after scores, and review status. Zero Slop requires no account or API key; server updates are managed for you.
+Connect the [Zero Slop MCP](https://zero-slop.ai/#mcp) to edit drafts inside your MCP client. No account or API key required.
 
 ```text
 https://mcp.zero-slop.ai/mcp
 ```
 
-See [`DISTRIBUTION.md`](DISTRIBUTION.md) for direct connector commands and directory status.
+[Connection options and listing status](DISTRIBUTION.md).
+
+## CLI
+
+Edit a file through MCP:
+
+```sh
+npx --yes zero-slop@2.10.1 deslop draft.md --genre professional
+```
+
+Use `-` for stdin and `--json` for structured output. `--require-approved` exits nonzero
+when review is needed; the result is still printed. Files stay unchanged. Node.js 22+;
+offline `score` also needs Python 3. [CLI reference and privacy](docs/cli.md).
+
+## REST API
+
+```sh
+curl --fail-with-body --max-time 75 https://mcp.zero-slop.ai/v1/deslop \
+  -H 'Content-Type: application/json' \
+  --data '{"text":"Maya owns the pricing review.","genre":"professional"}'
+```
+
+Same pipeline and result as MCP. Check `status` before using the edit. Free, shared
+capacity; up to 20,000 Unicode code points per draft after trimming. Hosted CLI
+editing and REST process drafts remotely without storing them.
+
+[API reference](docs/rest-api.md) · [OpenAPI contract](https://mcp.zero-slop.ai/openapi.json)
 
 ## What the workflow adds
 
@@ -230,8 +254,8 @@ stress case took 2.2932 seconds, and learning from an 8,000-word edit took
 0.1592 seconds. The measurements and machine details are in
 [`bench/performance-results.json`](bench/performance-results.json).
 
-Across 12 interleaved runs against 2.7.7, we measured 2.57% higher median throughput,
-which is effectively unchanged. The separate two-way replay used
+Across 12 interleaved runs against 2.7.7, we measured 0.71% lower median throughput,
+within the 5% regression limit. The separate two-way replay used
 Zero Slop v2.6.0.
 
 The [RAID+ audit](bench/raid-plus-corpus/README.md) checks how the scorer responds

package/SECURITY.md

@@ -0,0 +1,163 @@
+# Security posture
+
+## Runtime boundary
+
+The installed skill ships eight standard-library Python modules:
+
+| File | Purpose | Writes | Network |
+|---|---|---|---|
+| `scripts/slopscore.py` | score, heatmap, and fidelity checks | one-time interactive-note state under `$ZERO_SLOP_HOME`; never the draft | none |
+| `scripts/register.py` | document-level measurements and validated final-review packets | none | none |
+| `scripts/predictability.py` | create and score deterministic cloze probes | none | none |
+| `scripts/rerank.py` | rank candidate rewrites | optional user-selected output | none |
+| `scripts/learn.py` | private online learning, named scoring profiles, reviewed imports/exports | `$ZERO_SLOP_HOME`; shared taxonomy only through explicit maintainer `--merge --apply` | none |
+| `scripts/calibrate.py` | corpus calibration and shared-pattern maintenance | explicit calibration output or shared learned data | none |
+| `scripts/safeio.py` | locks and atomic file replacement | only on behalf of the two writers above | none |
+| `scripts/version_check.py` | optional release check | none | one metadata-only GitHub API request |
+
+These local Python checks do not transmit the draft. Editing inside an assistant
+follows that assistant's privacy settings. The version checker sends only a GET
+for the latest public release tag, times out after 2.5 seconds, fails open, and can be
+disabled with `ZS_NO_UPDATE_CHECK=1`.
+
+An ordinary interactive score may update a local counter and show one optional
+GitHub-star note after the third run. That state remains under `$ZERO_SLOP_HOME`, is
+never transmitted, and is skipped for pipes, JSON, batch, and gate runs. Set
+`ZERO_SLOP_NO_NOTES=1` to disable it.
+
+Build, packaging, benchmark, chart, PDF, website, and test utilities remain in the
+repository but are excluded from the installed plugin runtime.
+`scripts/contextual.py` is one of those maintainer-only research utilities; it is
+not a production feature and cannot change a live draft or score.
+
+## Remote service boundary
+
+The npm CLI's explicit `deslop` command is a remote operation. It reads one selected
+file or standard input and sends the text, genre, and optional audience to the public
+MCP endpoint below. It does not transmit file paths or private learning profiles,
+overwrite the source, retry automatically, or follow redirects with draft content.
+The `score` command remains offline. The Node.js transport is separate from the
+stdlib-only Python runtime.
+
+The optional public MCP at `https://mcp.zero-slop.ai/mcp` is a separate remote
+service. A draft sent to that endpoint must leave the client to be edited. It is
+processed in memory, excluded from the demo cache, and routed through model endpoints
+configured for zero retention and no training. The gateway rejects any editor
+response that does not confirm `stored: false`. Zero Slop does not log or retain the
+draft or rewrite.
+
+The REST endpoint `https://mcp.zero-slop.ai/v1/deslop` calls this same pipeline.
+It accepts at most 128 KiB of UTF-8 JSON and one trimmed draft of 20,000 Unicode code
+points. REST and MCP share an edge capacity limiter. That limiter operates per
+Cloudflare location; a separate atomic budget reservation gates every hosted
+editing-model call across REST, MCP, CLI and the browser demo. Adding a transport
+does not create an independent editing allowance. REST errors omit request content. Responses use `no-store`,
+and there is no stored response replay or idempotency cache.
+
+The editor fails closed when its shared daily budget or per-client limit is reached,
+or when budget enforcement is unavailable. Capacity is reserved before inference;
+failed or timed-out model calls are not refunded because their usage may be unknown.
+No automatic model retry or paid-model fallback is used. Local scoring is not metered.
+The service derives a keyed daily hash of the trusted connection IP to coordinate
+abuse limits. This separate counter stores the daily hash and counts, never the raw
+IP or draft, and does not join them to analytics. Shared networks can share a limit.
+Active daily identifiers expire after the UTC day. Cloudflare's SQLite recovery
+history may retain earlier database states for up to 30 days; this history contains
+no drafts or raw IP addresses.
+The project budget bounds Zero Slop's reserved model usage, not other applications'
+usage or the account's existing hosting charges.
+
+REST adds completed results, failures, and capacity rejections to the existing
+aggregate counters. It does not increment MCP initialization or tool-call counts.
+REST logs contain only event name, outcome, character count, and elapsed time.
+
+The gateway writes aggregate product and reliability events to Cloudflare Analytics
+Engine. Recorded fields are limited to JSON-RPC method, tool, normalized client family
+and major version, MCP protocol version, coarse country and data-center code, genre,
+character and word counts, before and after scores and flag counts, result status,
+completed-check counts, duration, and capacity outcome. Drafts, rewrites, prompts,
+detected phrases, IP addresses, raw user agents, cookies, email addresses, and stable
+user or session identifiers are excluded. Initializations are reported as connections,
+not unique people. Analytics Engine retains the dataset for three months.
+
+Hosted events also record the entry channel (MCP, CLI, REST, or the web editor),
+approval category and model-attempt count. The CLI sends a fixed app-family and
+major-version header on its existing hosted requests; this is self-reported
+attribution, not identity. Offline commands send no analytics. The web endpoint
+does not claim to measure the browser's final source checks. Internal signed
+gateway model calls are excluded from the web channel to prevent double counting.
+
+Telemetry writes are non-blocking and wrapped so an analytics failure cannot fail an
+MCP call. The daily report uses sampling-aware aggregate queries and degrades to a
+clearly labeled missing section if the dataset cannot be read.
+
+Thirty-two SQLite-backed Durable Object shards keep lifetime counters for aggregate
+MCP events: initializations, tool calls, completed results, changed messages,
+warnings, failures, and capacity rejects. Each write is an atomic transaction with
+a one-hour idempotency record, so bounded retries cannot double-count an event. The
+protected report aggregates every shard and the legacy `global` object, preserving
+totals recorded before sharding. It stores no request content or stable identity.
+A report-only bearer secret protects
+the read endpoint; the editor signing secret is never reused. Because MCP provides
+no stable installation identifier, the service does not claim that an initialization
+count is a unique-install count.
+
+## Online-learning isolation
+
+Reflection evidence, local detector rules, recurring rewrite preferences, logs, and
+named scoring profiles live under
+`$ZERO_SLOP_HOME` (default `~/.zero-slop`) with owner-only file permissions. They are
+not committed and are not overwritten by skill updates. The scorer loads the reviewed
+shared taxonomy first, then this private overlay on every run.
+
+One edit cannot activate a pattern. Phrase evidence needs the same cut across three
+content-distinct before/after pairs; single words need five. Candidate rules must also
+be new and must not match or borrow four consecutive words from the certified human
+corpus. Repeated kept-text evidence can lower a local weight. Reconfirmation keeps a
+local rule current; stale local detector rules decay after 18 months. A rewrite
+preference also needs the same replacement across three content-distinct pairs and is
+retired after 18 months without confirmation.
+
+These controls limit blast radius; they do not make feedback trustworthy in the
+cryptographic sense. A determined local user controls their own overlay. Shared changes
+still require an explicit export, review, re-gating, tests, version bump, and release.
+
+## File integrity and path safety
+
+Learning uses process-safe lock directories plus same-directory atomic replacement, so
+concurrent reflections cannot silently overwrite one another and a crash cannot leave
+half-written JSON. Corrupt reflection state fails closed instead of being reset.
+Malformed learned rules degrade to the last valid shared layer rather than crashing the
+scorer.
+
+Voice-profile names are restricted to a short filename-safe alphabet. Contribution
+exports must remain inside the working directory, cannot target `data/`, and cannot
+overwrite an existing file. Imported contributions are untrusted: Zero Slop discards
+their regexes, rebuilds patterns locally from the reviewed spans, and reruns the safety
+gate.
+
+The npm installer stages a complete copy before replacement. `--force` refuses roots,
+the home directory, the current project, symlinks, files, and nonempty directories that
+do not contain a verifiable Zero Slop runtime. A failed copy leaves the installed skill
+in place.
+
+## Known limits
+
+- A sample-based `--voice` profile records an existing lexicon or context-gated
+  watchlist term after one exact word match. It must be selected explicitly and
+  does not learn cadence, syntax, humor, tone, arbitrary phrases, or the writer's
+  full style.
+- The human safety corpus contains twelve prose samples. It is a regression floor, not
+  proof that a pattern is safe for every dialect, genre, or language.
+- The 0–100 result is a transparent heuristic surface score, not a calibrated
+  probability that AI wrote the text.
+- Scripted fidelity checks cover figures, names, quotations, links, asserted
+  feelings, and protected document structure. Claim meaning, qualifiers, and voice
+  still require the final semantic review described in `SKILL.md`.
+- Feedback recurrence proves content diversity, not independent authorship. Local
+  isolation prevents that limitation from changing the shared detector automatically.
+
+## Reporting
+
+Open a GitHub issue, or use the email address on the maintainer's GitHub profile for a
+report you would rather not file publicly.

package/SKILL.md

@@ -2,7 +2,7 @@
 name: zero-slop
 license: MIT
 metadata:
-  version: "2.9.2"
+  version: "2.10.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.
 ---
@@ -18,6 +18,11 @@ context, and performs the editorial work. The bundled local tools handle
 repeatable checks. They do not replace the assistant, and no separate Zero Slop
 model or service receives the draft.
 
+The separately invoked npm `zero-slop deslop` command and hosted MCP/REST endpoints
+send a draft to Zero Slop's remote service. They are opt-in alternatives, not local
+checks in this workflow. Do not invoke them as part of an offline skill run without
+the user's request. The npm `score` command continues to run locally.
+
 The science in one paragraph: detectors (and readers) key on the *post-training
 register* — text that sits at the most-probable phrasing, with uniform sentence
 rhythm, a few hundred over-represented style words, tidy template structure, and

package/bin/lib/deslop.d.mts

@@ -0,0 +1,34 @@
+export type Genre = "general" | "social" | "email" | "research" | "professional";
+export type ResultStatus = "rewritten" | "rewritten_with_warnings" | "already_clear" | "unchanged_no_better_version" | "unchanged_verification_failed" | "unchanged_service_unavailable";
+export interface WritingReport {
+  score: number; band: string; words: number; sentences: number; flaggedPhrases: number;
+  sentenceVariety: "natural" | "too even"; readability: "clear" | "needs work";
+  punctuation: { dashes: number; emoji: number; hashtags: number };
+  highWeightFlags: number;
+  shape: { measured: boolean; broetry: boolean; oneSentenceParagraphShare: number | null; longestFragmentRun: number | null };
+  register: {
+    measured: boolean; words: number; checked: number;
+    findings: Array<{ name: string; rate: number; budget: number; found: number; quote: string }>;
+    twoPartContrasts: number; announcements: number;
+  };
+  flags: Array<{ phrase: string; strength: number; issue: string; direction: string }>;
+}
+export interface PipelineResult {
+  text: string; status: ResultStatus; before: WritingReport; after: WritingReport;
+  scoreChange: number; factsPreserved: boolean; passedFinalChecks: boolean;
+  independentModelChecks: number; modelRequests: number; rolesCompleted: number;
+  finishingRounds: number; scorerVersion: string; durationMs: number; note: string;
+}
+export interface DeslopInput { text: string; genre?: Genre; audience?: string }
+export interface DeslopOptions { signal?: AbortSignal; timeoutMs?: number; clientName?: string; clientVersion?: string }
+export class DeslopError extends Error {
+  code: string; httpStatus?: number; rpcCode?: number; retryAfterSeconds?: number;
+  constructor(code: string, message: string, details?: Record<string, unknown>);
+}
+export const MCP_ENDPOINT: string;
+export const GENRES: readonly Genre[];
+export const RESULT_STATUSES: readonly ResultStatus[];
+export function validateInput(input: DeslopInput): Required<Pick<DeslopInput, "text" | "genre">> & Pick<DeslopInput, "audience">;
+export function validateResult(result: unknown): PipelineResult;
+export function isApprovedResult(result: PipelineResult): boolean;
+export function deslop(input: DeslopInput, options?: DeslopOptions): Promise<PipelineResult>;

package/bin/lib/deslop.mjs

@@ -0,0 +1,275 @@
+// Shared hosted-MCP client. No filesystem, process, model or local-scoring work.
+export const MCP_ENDPOINT = "https://mcp.zero-slop.ai/mcp";
+export const GENRES = Object.freeze(["general", "social", "email", "research", "professional"]);
+export const RESULT_STATUSES = Object.freeze([
+  "rewritten", "rewritten_with_warnings", "already_clear",
+  "unchanged_no_better_version", "unchanged_verification_failed",
+  "unchanged_service_unavailable",
+]);
+const PROTOCOLS = ["2025-11-25", "2025-06-18"];
+const MAX_REQUEST_BYTES = 128 * 1024;
+const MAX_RESPONSE_BYTES = 8 * 1024 * 1024;
+const encoder = new TextEncoder();
+// Zod's MCP string limits count Unicode code points, not UTF-16 units.
+// Avoid allocating a character array, and stop as soon as the bound is crossed.
+const withinLength = (value, maximum) => {
+  if (value.length <= maximum) return true;
+  let count = 0;
+  for (const _character of value) if (++count > maximum) return false;
+  return true;
+};
+
+export class DeslopError extends Error {
+  constructor(code, message, details = {}) {
+    super(message);
+    this.name = "DeslopError";
+    this.code = code;
+    Object.assign(this, details);
+  }
+}
+
+export function validateInput(input) {
+  if (!input || typeof input.text !== "string") {
+    throw new DeslopError("invalid_input", "Provide one UTF-8 draft as text.");
+  }
+  const text = input.text.trim();
+  const genre = input.genre === undefined ? "general" : input.genre;
+  if (!text || !withinLength(text, 20_000)) {
+    throw new DeslopError("invalid_input", "The draft must contain 1–20,000 Unicode code points after trimming.");
+  }
+  if (!GENRES.includes(genre)) {
+    throw new DeslopError("invalid_input", `Genre must be one of: ${GENRES.join(", ")}.`);
+  }
+  if (input.audience !== undefined && (typeof input.audience !== "string" || !withinLength(input.audience.trim(), 200))) {
+    throw new DeslopError("invalid_input", "Audience must be at most 200 Unicode code points.");
+  }
+  // Never forward filenames, private preferences or other caller properties.
+  return { text, genre, ...(input.audience?.trim() ? { audience: input.audience.trim() } : {}) };
+}
+
+const object = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+const number = (value, min, max = Infinity) => typeof value === "number" && Number.isFinite(value) && value >= min && value <= max;
+const integer = (value) => Number.isSafeInteger(value) && value >= 0;
+const string = (value, max = Infinity) => typeof value === "string" && withinLength(value, max);
+const array = (value, max, check) => Array.isArray(value) && value.length <= max && value.every(check);
+
+function validReport(value) {
+  return object(value) && number(value.score, 0, 100) && string(value.band, 80) && value.band.length > 0
+    && [value.words, value.sentences, value.flaggedPhrases, value.highWeightFlags].every(integer)
+    && ["natural", "too even"].includes(value.sentenceVariety) && ["clear", "needs work"].includes(value.readability)
+    && object(value.punctuation) && [value.punctuation.dashes, value.punctuation.emoji, value.punctuation.hashtags].every(integer)
+    && object(value.shape) && typeof value.shape.measured === "boolean" && typeof value.shape.broetry === "boolean"
+    && (value.shape.oneSentenceParagraphShare === null || number(value.shape.oneSentenceParagraphShare, 0, 1))
+    && (value.shape.longestFragmentRun === null || integer(value.shape.longestFragmentRun))
+    && object(value.register) && typeof value.register.measured === "boolean"
+    && [value.register.words, value.register.checked, value.register.twoPartContrasts, value.register.announcements].every(integer)
+    && array(value.register.findings, 1_000, (finding) => object(finding) && string(finding.name, 160)
+      && [finding.rate, finding.budget].every((item) => number(item, 0)) && integer(finding.found) && string(finding.quote, 1_000))
+    && array(value.flags, 5_000, (flag) => object(flag) && string(flag.phrase, 1_000)
+      && number(flag.strength, 0) && string(flag.issue, 2_000) && string(flag.direction, 2_000));
+}
+
+export function validateResult(result) {
+  if (!object(result) || !string(result.text) || !RESULT_STATUSES.includes(result.status)
+    || !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)) {
+    throw new DeslopError("invalid_response", "The MCP service returned an invalid structured result.");
+  }
+  // Return the original object, including additive fields; never rewrite its status.
+  return result;
+}
+
+export function isApprovedResult(result) {
+  try { validateResult(result); } catch { return false; }
+  return result?.factsPreserved === true && (
+    (result.status === "rewritten" && result.passedFinalChecks === true)
+    || (result.status === "already_clear" && result.modelRequests === 0
+      && result.scoreChange === 0 && result.before?.score === result.after?.score)
+  );
+}
+
+function messageFromJson(raw, id) {
+  let message;
+  try { message = JSON.parse(raw); } catch {
+    throw new DeslopError("invalid_response", "The MCP service returned malformed JSON.");
+  }
+  if (!object(message) || message.jsonrpc !== "2.0") {
+    throw new DeslopError("invalid_response", "The MCP service returned an invalid protocol message.");
+  }
+  if (message.id !== id) return null;
+  if (message.error !== undefined) {
+    const rpcCode = Number.isSafeInteger(message.error?.code) ? message.error.code : undefined;
+    throw new DeslopError("protocol_error", "The MCP service rejected the request.", { rpcCode });
+  }
+  if (!object(message.result)) {
+    throw new DeslopError("invalid_response", "The MCP service returned no result.");
+  }
+  return message.result;
+}
+
+async function readReply(response, id, signal) {
+  const type = response.headers.get("content-type")?.split(";", 1)[0].trim().toLowerCase();
+  if (!["application/json", "text/event-stream"].includes(type) || !response.body) {
+    void response.body?.cancel().catch(() => {});
+    throw new DeslopError("invalid_response", "The MCP service returned an unsupported response type.");
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  let size = 0;
+  let buffer = "";
+  const stop = () => { void reader.cancel().catch(() => {}); };
+  signal.addEventListener("abort", stop, { once: true });
+  try {
+    while (true) {
+      signal.throwIfAborted();
+      const { value, done } = await reader.read();
+      signal.throwIfAborted();
+      if (value) {
+        size += value.byteLength;
+        if (size > MAX_RESPONSE_BYTES) throw new DeslopError("invalid_response", "The MCP response exceeded the size limit.");
+      }
+      buffer += decoder.decode(value, { stream: !done });
+      if (type === "text/event-stream") {
+        let boundary;
+        while ((boundary = /\r\n\r\n|\n\n|\r\r/.exec(buffer))) {
+          const event = buffer.slice(0, boundary.index);
+          buffer = buffer.slice(boundary.index + boundary[0].length);
+          const data = event.split(/\r\n|\n|\r/).filter((line) => line.startsWith("data:"))
+            .map((line) => line.slice(5).replace(/^ /, "")).join("\n");
+          if (!data) continue;
+          const reply = messageFromJson(data, id);
+          if (reply) return reply;
+        }
+      } else if (done) {
+        const reply = messageFromJson(buffer, id);
+        if (reply) return reply;
+      }
+      if (done) throw new DeslopError("invalid_response", "The MCP response ended before the matching result arrived.");
+    }
+  } catch (error) {
+    if (signal.aborted) throw signal.reason;
+    if (error instanceof DeslopError) throw error;
+    throw new DeslopError("invalid_response", "The MCP response could not be read.");
+  } finally {
+    signal.removeEventListener("abort", stop);
+    stop();
+    reader.releaseLock();
+  }
+}
+
+/** Call the existing hosted pipeline once. Cancellation cannot guarantee server work stops. */
+export async function deslop(input, options = {}) {
+  const args = validateInput(input);
+  const timeoutMs = options.timeoutMs ?? 75_000;
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 300_000) {
+    throw new DeslopError("invalid_input", "Timeout must be between 1 and 300,000 milliseconds.");
+  }
+  const clientName = options.clientName ?? "zero-slop";
+  const clientVersion = options.clientVersion ?? "unknown";
+  if (!/^[a-zA-Z0-9._-]{1,64}$/.test(clientName) || !/^[a-zA-Z0-9.+_-]{1,64}$/.test(clientVersion)) {
+    throw new DeslopError("invalid_input", "Client name and version must be bounded application metadata.");
+  }
+  const toolBody = { jsonrpc: "2.0", id: 2, method: "tools/call", params: { name: "deslop", arguments: args } };
+  if (encoder.encode(JSON.stringify(toolBody)).byteLength > MAX_REQUEST_BYTES) {
+    throw new DeslopError("invalid_input", "The encoded MCP request exceeds 128 KiB.");
+  }
+  const controller = new AbortController();
+  const cancel = () => controller.abort(new DeslopError("cancelled", "Cancelled locally; hosted processing may still finish."));
+  if (options.signal?.aborted) cancel();
+  else options.signal?.addEventListener("abort", cancel, { once: true });
+  const timer = setTimeout(() => controller.abort(new DeslopError("timeout", "The hosted request timed out; its outcome is unknown. No retry was sent.")), timeoutMs);
+  let protocolVersion = PROTOCOLS[0];
+  let session;
+  let toolPending = false;
+  // Hosted CLI attribution only: no identifier, machine data, or extra request.
+  // Other integrations retain their existing clientInfo without posing as CLI.
+  const cliMajorVersion = clientVersion.match(/^(\d{1,4})(?:\.|$)/)?.[1] ?? "unknown";
+  const headers = () => ({
+    "content-type": "application/json", accept: "application/json, text/event-stream",
+    "cache-control": "no-store", "mcp-protocol-version": protocolVersion,
+    ...(clientName === "zero-slop-cli" ? { "user-agent": `zero-slop-cli/${cliMajorVersion}` } : {}),
+    ...(session ? { "mcp-session-id": session } : {}),
+  });
+  // A dropped HTTP connection is not an MCP cancellation notification. Request it
+  // separately, without replaying the tool, but bound this best-effort cleanup.
+  const notifyCancellation = () => {
+    if (!toolPending) return;
+    const cleanup = new AbortController();
+    const cleanupTimer = setTimeout(() => cleanup.abort(), 250);
+    void fetch(MCP_ENDPOINT, {
+      method: "POST", redirect: "manual", signal: cleanup.signal, headers: headers(),
+      body: JSON.stringify({ jsonrpc: "2.0", method: "notifications/cancelled", params: { requestId: 2, reason: "Client cancelled" } }),
+    }).then((response) => response.body?.cancel()).catch(() => {}).finally(() => clearTimeout(cleanupTimer));
+  };
+  controller.signal.addEventListener("abort", notifyCancellation, { once: true });
+  async function rpc(body, notification = false) {
+    controller.signal.throwIfAborted();
+    const response = await fetch(MCP_ENDPOINT, {
+      method: "POST", redirect: "manual", signal: controller.signal, headers: headers(), body: JSON.stringify(body),
+    });
+    controller.signal.throwIfAborted();
+    if (!response.ok) {
+      void response.body?.cancel().catch(() => {});
+      const retry = response.headers.get("retry-after");
+      const retryAfterSeconds = retry && /^\d{1,5}$/.test(retry) ? Number(retry) : undefined;
+      throw new DeslopError("http_error", response.status === 429
+        ? "Zero Slop is busy or at a usage limit. Please wait before trying again. No retry was sent."
+        : `The MCP service returned HTTP ${response.status}. No retry was sent.`, {
+        httpStatus: response.status, ...(retryAfterSeconds !== undefined ? { retryAfterSeconds } : {}),
+      });
+    }
+    if (notification) {
+      void response.body?.cancel().catch(() => {});
+      return;
+    }
+    if (body.method === "initialize") {
+      session = response.headers.get("mcp-session-id");
+      if (session && !/^[\x21-\x7e]{1,512}$/.test(session)) {
+        void response.body?.cancel().catch(() => {});
+        throw new DeslopError("invalid_response", "The MCP service returned an invalid session identifier.");
+      }
+    }
+    return readReply(response, body.id, controller.signal);
+  }
+  try {
+    const initialized = await rpc({ jsonrpc: "2.0", id: 1, method: "initialize", params: {
+      protocolVersion, capabilities: {}, clientInfo: { name: clientName, version: clientVersion },
+    } });
+    if (!PROTOCOLS.includes(initialized.protocolVersion)) {
+      throw new DeslopError("unsupported_protocol", "The MCP service negotiated an unsupported protocol version.");
+    }
+    protocolVersion = initialized.protocolVersion;
+    await rpc({ jsonrpc: "2.0", method: "notifications/initialized" }, true);
+    toolPending = true;
+    const reply = await rpc(toolBody);
+    toolPending = false;
+    if (reply.isError !== undefined && typeof reply.isError !== "boolean") {
+      throw new DeslopError("invalid_response", "The MCP service returned an invalid tool result.");
+    }
+    if (reply.isError === true) {
+      const gate = reply._meta?.["zero-slop/error"];
+      if (gate && (gate.code === "usage_limit" || gate.code === "budget_unavailable") &&
+          gate.status === (gate.code === "usage_limit" ? 429 : 503)) {
+        const retry = gate.retryAfterSeconds;
+        throw new DeslopError(gate.code, gate.code === "usage_limit"
+          ? "Hosted editing is temporarily busy or at its free usage limit. Please wait before trying again. Keep your source; no retry was sent."
+          : "Hosted capacity could not be checked. Please try again later. Keep your source; no retry was sent.", {
+          httpStatus: gate.status,
+          ...(Number.isInteger(retry) && retry > 0 && retry <= 86_400 ? { retryAfterSeconds: retry } : {}),
+        });
+      }
+      throw new DeslopError("tool_error", "Zero Slop could not return a safely checked result. The source was not changed locally.");
+    }
+    return validateResult(reply.structuredContent);
+  } catch (error) {
+    if (controller.signal.aborted) throw controller.signal.reason;
+    if (error instanceof DeslopError) throw error;
+    throw new DeslopError("network_error", "The hosted MCP request failed. Its outcome may be unknown; no retry was sent.");
+  } finally {
+    clearTimeout(timer);
+    options.signal?.removeEventListener("abort", cancel);
+    controller.signal.removeEventListener("abort", notifyCancellation);
+  }
+}

package/bin/zero-slop.mjs

@@ -5,11 +5,13 @@
 // mirrors rather than people. This is the executable half: it installs the same
 // runtime the tarball already carries, and runs the scorer without a checkout.
 
-import { cp, lstat, mkdir, readFile, readdir, rename, rm, stat } from "node:fs/promises";
+import { cp, lstat, mkdir, open, readFile, readdir, rename, rm, stat } from "node:fs/promises";
+import { constants } from "node:fs";
 import { spawn } from "node:child_process";
 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";
 
 const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 const PAYLOAD = ["SKILL.md", "references", "scripts", "data"];
@@ -30,11 +32,13 @@ async function version() {
 }
 
 function usage(v) {
-  return `zero-slop ${v} — score AI-sounding prose 0-100 and edit it out.
+  return `zero-slop ${v} — score locally or edit through the hosted Zero Slop MCP.
 
 Usage
   npx zero-slop install [--harness <name>] [--dir <path>] [--force]
-  npx zero-slop score <file>... [-- <slopscore flags>]
+  npx zero-slop score <file|-> [-- <slopscore flags>]
+  npx zero-slop deslop <file|-> [--genre <name>] [--audience <reader>] [--json]
+                       [--require-approved] [--timeout <seconds>]
   npx zero-slop where
   npx zero-slop --version
 
@@ -43,11 +47,27 @@ Install targets
   --dir       install into an explicit directory instead
   --force     replace a verified Zero Slop installation
 
+Hosted editing (deslop)
+  Sends only the explicit draft, genre and audience to https://mcp.zero-slop.ai/mcp.
+  Zero Slop does not store drafts or rewrites; aggregate usage metrics are recorded.
+  Requires Node.js 22+, network access, and no Python or API key. No automatic retry.
+  One UTF-8 file or stdin (-); 1–20,000 Unicode code points, audience at most 200.
+  --genre     general (default), social, email, research, professional
+  --json      full structured MCP result on stdout; notices stay on stderr
+  --require-approved  exit 3 unless already clear or a checked rewrite; keep the result
+  --timeout   whole remote request timeout in seconds (default: 75; maximum: 300)
+  Text mode prints the returned draft on stdout and the review summary on stderr.
+  No files are changed. A timeout or cancellation may not stop hosted processing.
+  Exits: 0 valid result, 1 request failure, 2 invalid input, 3 approval gate,
+         124 timeout, 130 interrupted, 143 terminated.
+
 Examples
   npx zero-slop install                    # ~/.claude/skills/zero-slop
   npx zero-slop install --harness codex
   npx zero-slop score draft.md
   npx zero-slop score drafts/ -- --batch --gate 25
+  npx zero-slop deslop draft.md --genre email
+  npx zero-slop deslop - --json < draft.md
 
 Docs: https://zero-slop.ai   Source: https://github.com/manavmishra/ZeroSlop`;
 }
@@ -193,12 +213,148 @@ function runScorer(args) {
       console.error(err.message);
       resolvePromise(1);
     });
-    child.on("close", (code) => resolvePromise(code ?? 0));
+    child.on("close", (code, signal) => resolvePromise(code ?? (signal === "SIGINT" ? 130 : signal === "SIGTERM" ? 143 : 1)));
   });
 }
 
+function parseDeslopArgs(argv) {
+  const values = {};
+  const files = [];
+  const allowedValues = new Set(["--genre", "--audience", "--timeout"]);
+  let positionalOnly = false;
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index];
+    if (positionalOnly) { files.push(argument); continue; }
+    if (argument === "--") { positionalOnly = true; continue; }
+    const [flag, ...attached] = argument.split("=");
+    if (allowedValues.has(flag)) {
+      if (Object.hasOwn(values, flag)) throw new DeslopError("invalid_input", `Duplicate option: ${flag}`);
+      const value = attached.length ? attached.join("=") : argv[++index];
+      if (value === undefined || value.startsWith("--")) throw new DeslopError("invalid_input", `${flag} needs a value.`);
+      values[flag] = value;
+    } else if (argument === "--json" || argument === "--require-approved") {
+      if (values[argument]) throw new DeslopError("invalid_input", `Duplicate option: ${argument}`);
+      values[argument] = true;
+    } else if (argument.startsWith("-") && argument !== "-") {
+      throw new DeslopError("invalid_input", "Unknown deslop option. See: zero-slop deslop --help");
+    } else files.push(argument);
+  }
+  if (files.length !== 1) throw new DeslopError("invalid_input", "deslop needs exactly one file or '-' for stdin; directories and batches are not uploaded.");
+  const seconds = values["--timeout"] === undefined ? 75 : Number(values["--timeout"]);
+  const timeoutMs = seconds * 1_000;
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 300_000) {
+    throw new DeslopError("invalid_input", "--timeout needs 0.001–300 seconds.");
+  }
+  return { file: files[0], genre: values["--genre"], audience: values["--audience"],
+    json: Boolean(values["--json"]), requireApproved: Boolean(values["--require-approved"]), timeoutMs };
+}
+
+async function readDraft(file, signal) {
+  const maximum = 128 * 1024;
+  let bytes;
+  if (file === "-") {
+    const chunks = [];
+    let size = 0;
+    const stop = () => process.stdin.destroy(signal.reason);
+    signal.addEventListener("abort", stop, { once: true });
+    try {
+      signal.throwIfAborted();
+      for await (const chunk of process.stdin) {
+        signal.throwIfAborted();
+        size += chunk.length;
+        if (size > maximum) throw new DeslopError("invalid_input", "The input exceeds 128 KiB; nothing was uploaded.");
+        chunks.push(chunk);
+      }
+      bytes = Buffer.concat(chunks);
+    } finally { signal.removeEventListener("abort", stop); }
+  } else {
+    let handle;
+    try {
+      // Nonblocking open plus fstat rejects directories, devices and named pipes.
+      handle = await open(file, constants.O_RDONLY | constants.O_NONBLOCK);
+      const info = await handle.stat();
+      if (!info.isFile() || info.size > maximum) throw new DeslopError("invalid_input", "Provide one regular UTF-8 file no larger than 128 KiB; nothing was uploaded.");
+      // Keep the read bounded even if a regular file grows after fstat.
+      const buffer = Buffer.alloc(maximum + 1);
+      let size = 0;
+      while (size < buffer.length) {
+        signal.throwIfAborted();
+        const { bytesRead } = await handle.read(buffer, size, buffer.length - size, null);
+        if (!bytesRead) break;
+        size += bytesRead;
+      }
+      if (size > maximum) throw new DeslopError("invalid_input", "The input exceeds 128 KiB; nothing was uploaded.");
+      bytes = buffer.subarray(0, size);
+    } finally { await handle?.close(); }
+  }
+  signal.throwIfAborted();
+  try { return new TextDecoder("utf-8", { fatal: true }).decode(bytes); } catch {
+    throw new DeslopError("invalid_input", "The draft must be valid UTF-8; nothing was uploaded.");
+  }
+}
+
+async function runDeslop(argv, v) {
+  const controller = new AbortController();
+  let interrupted;
+  let parsed;
+  const json = argv.slice(0, argv.indexOf("--") < 0 ? undefined : argv.indexOf("--")).includes("--json");
+  const stop = (signal) => {
+    interrupted = signal;
+    controller.abort(new DeslopError("cancelled", "Cancelled locally; hosted processing may still finish."));
+  };
+  const onInterrupt = () => stop("SIGINT");
+  const onTerminate = () => stop("SIGTERM");
+  process.once("SIGINT", onInterrupt);
+  process.once("SIGTERM", onTerminate);
+  try {
+    parsed = parseDeslopArgs(argv);
+    let text;
+    try { text = await readDraft(parsed.file, controller.signal); } catch (error) {
+      if (error instanceof DeslopError || controller.signal.aborted) throw error;
+      throw new DeslopError("invalid_input", "The input file could not be read; nothing was uploaded.");
+    }
+    const input = validateInput({ text, genre: parsed.genre, audience: parsed.audience });
+    console.error("Hosted editing: sending this draft to mcp.zero-slop.ai. Drafts and rewrites are not stored; aggregate usage metrics are recorded.");
+    const result = await deslop(input, { signal: controller.signal, timeoutMs: parsed.timeoutMs,
+      clientName: "zero-slop-cli", clientVersion: v });
+    controller.signal.throwIfAborted();
+    process.stdout.write(parsed.json ? `${JSON.stringify(result)}\n` : result.text);
+    if (!parsed.json) {
+      console.error(`Status: ${result.status}. Writing score: ${result.before.score} before, ${result.after.score} after. Lower is better.`);
+      console.error(`Facts preserved: ${result.factsPreserved ? "yes" : "not confirmed"}. Final checks: ${result.passedFinalChecks ? "passed" : result.status === "already_clear" ? "not needed; already clear" : "did not all pass"}.`);
+      // Notes can contain prose supplied by the service. Render them as text,
+      // without allowing terminal-control sequences to execute.
+      console.error(result.note.replace(/[\u0000-\u001f\u007f-\u009f]/g, " "));
+    }
+    return parsed.requireApproved && !isApprovedResult(result) ? 3 : 0;
+  } catch (error) {
+    const failure = controller.signal.aborted ? controller.signal.reason
+      : error instanceof DeslopError ? error : new DeslopError("request_failed", "The request could not be completed.");
+    const code = interrupted ? (interrupted === "SIGINT" ? 130 : 143)
+      : failure.code === "timeout" ? 124 : failure.code === "invalid_input" ? 2 : 1;
+    const details = { code: failure.code, message: failure.message,
+      ...(failure.httpStatus !== undefined ? { httpStatus: failure.httpStatus } : {}),
+      ...(failure.rpcCode !== undefined ? { rpcCode: failure.rpcCode } : {}),
+      ...(failure.retryAfterSeconds !== undefined ? { retryAfterSeconds: failure.retryAfterSeconds } : {}) };
+    if (json) process.stdout.write(`${JSON.stringify({ error: details })}\n`);
+    console.error(failure.message);
+    if (failure.retryAfterSeconds !== undefined) console.error(`Retry-After: ${failure.retryAfterSeconds} seconds. No retry was sent.`);
+    return code;
+  } finally {
+    process.removeListener("SIGINT", onInterrupt);
+    process.removeListener("SIGTERM", onTerminate);
+  }
+}
+
 async function main() {
   const argv = process.argv.slice(2);
+  // Parse this command separately: no install flags or scorer passthrough can
+  // accidentally become a remote-upload option.
+  if (argv[0] === "deslop") {
+    const v = await version();
+    if (argv.length === 2 && ["--help", "-h"].includes(argv[1])) { console.log(usage(v)); return 0; }
+    return runDeslop(argv.slice(1), v);
+  }
   const { flags, rest, passthrough } = parseArgs(argv);
   const command = rest[0];
   const v = await version();
@@ -236,8 +392,8 @@ async function main() {
 }
 
 main()
-  .then((code) => process.exit(code))
+  .then((code) => { process.exitCode = code; })
   .catch((err) => {
     console.error(err.message);
-    process.exit(1);
+    process.exitCode = 1;
   });

package/docs/cli.md

@@ -0,0 +1,95 @@
+# Zero Slop CLI
+
+Use `deslop` for hosted editing with MCP parity. Use `score` for offline checks.
+
+```sh
+npm install --global zero-slop@2.10.1
+zero-slop deslop draft.md --genre professional
+zero-slop deslop - --genre email < draft.txt
+zero-slop deslop draft.md --json --require-approved
+zero-slop score draft.md -- --json
+```
+
+Use Node.js 22 or newer for hosted editing. Offline scoring also requires Python 3.
+The npm package includes the skill and its local checks; no separate model ships.
+
+On macOS, [Homebrew](https://github.com/manavmishra/homebrew-zero-slop) installs
+the same npm CLI plus Node and Python:
+
+```sh
+brew install manavmishra/zero-slop/zero-slop
+```
+
+The tap pins a tested npm release; a new npm version may arrive before its
+Homebrew update. Linux Homebrew has not been tested.
+
+`deslop` reads exactly one file or standard input, sends the draft to
+`https://mcp.zero-slop.ai/mcp`, and writes the returned text to standard output.
+It never edits a source file in place. Warnings go to standard error. Capture
+standard output only when you intend to save it.
+
+## Options and results
+
+| Option | Purpose |
+|---|---|
+| `--genre` | `general`, `social`, `email`, `research`, or `professional` |
+| `--audience` | Intended reader or destination, up to 200 Unicode code points |
+| `--json` | Full MCP result, including all check fields and status |
+| `--require-approved` | Exit nonzero if the result needs review |
+| `--timeout` | Remote request deadline in seconds: 75 by default, up to 300 |
+
+The draft limit is 20,000 Unicode code points after trimming. Directory uploads,
+automatic chunking, and automatic retries are not supported. Only the draft and
+supplied genre/audience are transmitted; filenames and private learning profiles
+stay local. See the [remote-service privacy boundary](../SECURITY.md#remote-service-boundary).
+
+Inspect the [six result statuses](rest-api.md#read-the-result). In particular,
+`rewritten_with_warnings` is an edit to review, not an approved result.
+`already_clear` returns the original without an editing-model request.
+
+| Exit code | Meaning |
+|---|---|
+| `0` | A valid result was returned; inspect its status before using it |
+| `1` | Transport or service failure |
+| `2` | Invalid input or options |
+| `3` | `--require-approved` rejected the result; the result is still printed |
+| `124` | Remote request timed out |
+| `130` / `143` | Interrupted / terminated |
+
+A timeout or cancellation may not stop hosted processing. The CLI does not replay
+the request. Review any returned status or error before choosing to send the draft again.
+
+Hosted editing shares its free allowance with MCP, REST, and `/try/`. A
+`usage_limit` error exits `1`; JSON errors include `httpStatus: 429` and, when
+provided, `retryAfterSeconds`. Wait at least that long before a manual retry.
+`budget_unavailable` (`503`) means capacity could not be checked, so no new model
+request was started. Offline scoring does not consume this allowance.
+
+Hosted calls are included in aggregate service metrics: channel, result status,
+model attempts, and latency. A fixed CLI-family/major-version header identifies
+the entry channel on the requests already being sent; no extra tracking request
+is made. It does not identify a person or installation. Offline commands send no
+analytics. See the [security policy](../SECURITY.md) for the complete field list.
+
+## Offline scoring
+
+```sh
+zero-slop score draft.md -- --json
+zero-slop score - -- --json < draft.txt
+zero-slop score docs/ -- --batch --json --gate 25
+```
+
+The scorer does not transmit drafts. A numerical gate fails when the score exceeds
+its threshold; equality passes. Its score measures writing patterns, not authorship
+or factual truth. Hosted editorial approval includes additional checks and should
+not be inferred from the number alone.
+
+## Install the portable skill
+
+```sh
+zero-slop install
+```
+
+The installed skill runs inside a compatible AI assistant. Its editing follows that
+assistant's privacy settings. Installing the skill does not send your writing to
+the hosted service.

package/docs/rest-api.md

@@ -0,0 +1,182 @@
+# Zero Slop REST API
+
+`POST https://mcp.zero-slop.ai/v1/deslop` edits one draft through the same pipeline
+as the hosted MCP `deslop` tool. It returns the same 14 fields, including the edit,
+writing scores, source-check result, and review status.
+
+The [OpenAPI 3.1.2 contract](https://mcp.zero-slop.ai/openapi.json) is generated
+from the schemas used to validate MCP and REST requests and results. Import it
+into an OpenAPI-compatible client or documentation tool.
+
+Use the [API sandbox](https://zero-slop.ai/sandbox/) to inspect a simulated result
+before sending a draft. Its live mode requires an explicit request and uses this
+same endpoint.
+
+## Send a draft
+
+```sh
+curl --fail-with-body --max-time 75 --include https://mcp.zero-slop.ai/v1/deslop \
+  -H 'Content-Type: application/json' \
+  --data '{"text":"It is important to note that Maya owns the pricing review. The team will decide on Friday.","genre":"professional","audience":"The product team"}'
+```
+
+| Field | Accepted value |
+|---|---|
+| `text` | Required, nonempty string; up to 20,000 Unicode code points after trimming |
+| `genre` | `general` (default), `social`, `email`, `research`, or `professional` |
+| `audience` | Optional string, up to 200 Unicode code points after trimming |
+
+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
+JSON escaping. Compressed bodies are not accepted. Unknown properties are ignored.
+
+Call from your application server. Browser access is enabled only for the Zero Slop
+site at `https://zero-slop.ai` and `https://www.zero-slop.ai`; other sites should
+call from their servers. CORS is a browser policy, not authentication.
+
+Access is free, without an API key. REST and MCP share capacity and usage limits,
+including a daily hosted allowance and a short client cooldown. The allowance can
+run out; it does not reserve capacity for an application. Availability is best
+effort, with no uptime SLA. Offline skill checks and CLI scoring stay free and do
+not consume this hosted allowance.
+
+Current safety limits allow at most five model calls per client network per UTC
+day and two per minute, shared across REST, MCP, CLI editing, and `/try/`.
+Shared networks can reach those limits together. A separate global limit reserves
+up to 8,000 estimated Workers AI neurons per UTC day before inference; it can
+stop calls before the client limit is reached. Reservations are conservative and
+are not refunded after timeouts. New model calls pause during the last minute
+before the UTC reset. These are capacity ceilings, not a guaranteed allocation.
+
+The service records aggregate REST call counts, result categories, model attempts,
+quota rejections, and latency. Drafts, rewrites, IP addresses, email addresses and
+stable user identifiers are excluded from this telemetry. Calls are not unique
+users, and model attempts are not billable token counts. See the
+[security policy](../SECURITY.md) for the field list and retention.
+
+## Working language examples
+
+The [example directory](../integrations/api-examples/README.md) contains runnable
+clients with 75-second timeouts, structured error handling, and an explicit check
+before the returned text can pass to an automated step.
+
+| Language | Source | HTTP client |
+|---|---|---|
+| curl | [Shell example](../integrations/api-examples/curl/deslop.sh) | curl; jq reads the result |
+| JavaScript | [Node.js example](../integrations/api-examples/javascript/deslop.mjs) | Built-in `fetch` |
+| TypeScript | [Typed Node.js example](../integrations/api-examples/typescript/deslop.ts) | Built-in `fetch` |
+| Python | [Python example](../integrations/api-examples/python/deslop.py) | Standard-library `urllib.request` |
+| Java | [Java example](../integrations/api-examples/java/src/main/java/Deslop.java) | JDK `HttpClient`; Jackson for JSON |
+| C# | [.NET example](../integrations/api-examples/csharp/Program.cs) | `HttpClient` and `System.Text.Json` |
+| Go | [Go example](../integrations/api-examples/go/main.go) | Standard-library `net/http` |
+| Rust | [Rust example](../integrations/api-examples/rust/src/main.rs) | reqwest and serde_json |
+
+Each example reads one request object from stdin, sends one POST, and preserves
+the complete JSON response. Exit `0` means the approval condition below passed;
+exit `3` means review is required. HTTP and transport failures exit `1`. Check
+the exit code before extracting `text`; an HTTP `200` alone is insufficient.
+These are examples to adapt within an application, not separate SDKs.
+
+## Read the result
+
+HTTP `200` means the pipeline returned a result. It does not mean the edit passed
+every check.
+
+| `status` | What to do |
+|---|---|
+| `rewritten` | Review the edit; the model edit passed the local writing and source checks |
+| `already_clear` | Keep the original; no editing-model call was needed |
+| `rewritten_with_warnings` | Read `note` and review the result before using it |
+| `unchanged_no_better_version` | Keep the original; no better version was selected |
+| `unchanged_verification_failed` | Keep the original; proposed edits failed source checks |
+| `unchanged_service_unavailable` | Keep the original; the model did not yield a usable edit |
+
+The successful response contains these 14 fields:
+
+| Field | Meaning |
+|---|---|
+| `text` | Returned draft, which may be unchanged |
+| `status` | One of the six outcomes above |
+| `before`, `after` | Writing reports: score, flagged phrases, readability, rhythm, punctuation, layout, and register checks |
+| `scoreChange` | After score minus before score |
+| `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 |
+| `rolesCompleted` | Completed pipeline responsibilities |
+| `finishingRounds` | Additional local finishing rounds |
+| `scorerVersion` | Deployed Zero Slop release |
+| `durationMs` | Server processing time in milliseconds |
+| `note` | Review guidance, including any limitations |
+
+`scoreChange` is after minus before, so a negative value means the measured score fell.
+The writing score is not a probability that AI wrote the draft.
+
+For an automation that must stop on a warning, use this condition:
+
+```js
+const approved = result.factsPreserved === true && (
+  (result.status === "already_clear" && result.modelRequests === 0 &&
+   result.scoreChange === 0 && result.before.score === result.after.score) ||
+  (result.status === "rewritten" && result.passedFinalChecks === true)
+);
+```
+
+`already_clear` has `passedFinalChecks: false` because editing-model checks were not
+needed. Do not reject it solely on that boolean. Source checks protect tracked
+details; they cannot certify factual truth or every change in meaning. Human review
+remains necessary before publication.
+
+## Errors and retries
+
+Errors use `application/problem+json` with `type`, `title`, `status`, `detail`,
+`code`, and `requestId`. Their details do not echo drafts, model responses, or secrets.
+
+| HTTP status | Meaning |
+|---|---|
+| `400` | Invalid JSON, UTF-8, declared length, or input fields |
+| `403` | `forbidden_origin` or `forbidden_preflight`; use an allowed first-party browser request or call from your server |
+| `405` | Wrong method; use `POST` |
+| `408` | The request body did not arrive within 10 seconds |
+| `413` | The JSON body exceeds 128 KiB |
+| `415` | Unsupported media type or compression |
+| `429` | `capacity_limit` or `usage_limit`; respect `Retry-After` |
+| `503` | `budget_unavailable` if the usage gate could not complete, or `service_unavailable` if no safely scored result was available |
+
+For example, a usage-limit response has this shape; values here are illustrative:
+
+```json
+{
+  "type": "about:blank",
+  "title": "Too Many Requests",
+  "status": 429,
+  "detail": "The free hosted allowance is currently exhausted. Try again after the indicated delay.",
+  "code": "usage_limit",
+  "requestId": "11111111-1111-4111-8111-111111111111"
+}
+```
+
+The `Retry-After` response header gives the minimum delay in seconds. Read it
+from the header rather than parsing `detail`. Keep the problem code and request
+ID for troubleshooting without logging the draft or result.
+
+Allow 75 seconds on the client. The service makes at most one editing-model request;
+scoring and source checks add their own bounded work. A client timeout or cancellation
+does not guarantee upstream work stopped. Do not retry automatically after an uncertain
+outcome. If a user chooses to retry a `429`, wait at least the `Retry-After` delay.
+
+The API does not store drafts or results for idempotency. Repeated POSTs are separate
+calls, may repeat work, and are not guaranteed to return identical text.
+
+## Privacy and versioning
+
+The draft is sent to Zero Slop's hosted service and processed in memory. The upstream
+editing service must confirm `stored: false`; drafts and rewrites are not cached or logged by this
+service. Aggregate operational counts and short-lived daily hashed client counters
+support usage limits and abuse controls. See [SECURITY.md](../SECURITY.md) and
+the [hosted-service terms](https://zero-slop.ai/terms/).
+
+`/v1` identifies the HTTP contract. `scorerVersion` identifies the deployed Zero Slop
+release. Clients should accept new optional response fields and treat any unrecognized
+result status as requiring review. The OpenAPI document is served by the same Worker
+as the API, so its version follows the deployment.

package/gemini-extension.json

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "zero-slop",
-  "version": "2.9.2",
-  "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.",
+  "version": "2.10.1",
+  "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"
   },
@@ -21,6 +21,9 @@
     "ai-writing",
     "writing-tools",
     "editing",
+    "cli",
+    "mcp",
+    "rest-api",
     "prose"
   ],
   "homepage": "https://zero-slop.ai",
@@ -41,6 +44,9 @@
     "scripts/",
     "data/",
     "README.md",
+    "docs/cli.md",
+    "docs/rest-api.md",
+    "SECURITY.md",
     "LICENSE",
     "plugin.json",
     "mcp.json",

package/plugin.json

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