_ _ _ ____ ___ ____ ____ _  _ ____ ____ _  _ ____    ____ ____ _  _ ____ _  _ ____ ____
| | | |__|  |  |___ |__/ |\/| |__| |__/ |_/  [__  __ |__/ |___ |\/| |  | |  | |___ |__/
|_|_| |  |  |  |___ |  \ |  | |  | |  \ | \_ ___]    |  \ |___ |  | |__|  \/  |___ |  \

| Host | Target | Lands in |
| --- | --- | --- |
| Claude Code (personal) | `--target claude-code` | `~/.claude/skills/<skill>` (honors `CLAUDE_CONFIG_DIR`) |
| Claude Code (project) | `--target claude-project --project-dir PATH` | `PATH/.claude/skills/<skill>` |
| Cowork, claude.ai, cloud sessions, routines | `--target cowork` | `dist/<skill>.zip` to upload under **Customize → Skills** |
| Cursor | `--target cursor` (default) | `~/.cursor/skills/<skill>` |

Shipped skills: `remove-ai-marks` (full, service-backed) and
`clean-user-facing-text` (text only, self-contained). `--list` prints them.
Existing installations are preserved unless you pass `--force`; replacement is
staged first and the previous install is kept as a uniquely named backup.
`--link` symlinks this checkout instead of copying, so edits are picked up
live. On Windows, use `py install_skill.py ...`; the `install-skill.sh` wrapper
is provided for macOS/Linux shells.

Before writing anything, the installer validates the skill against the
[Agent Skills](https://agentskills.io) packaging rules that claude.ai uploads
and the Skills API enforce: spec-only frontmatter (`name`, `description`,
`license`, `compatibility`, `metadata`, `allowed-tools`), a lowercase hyphenated
`name` of at most 64 characters matching the directory, a non-empty
`description` of at most 1024 characters. The Cowork bundle additionally has
to fit the 30 MB upload limit, which the packager enforces.

### Automatic cleaning via hook (deterministic)

A skill is an instruction: the model decides whether to invoke it, and the
model is the thing producing the marks. A **hook** is executed by the harness
on every matching tool call, cooperation not required. That makes the hook the
deterministic half of this workflow.

The plugin registers a `PostToolUse` hook on `Write|Edit|MultiEdit|NotebookEdit`
that runs [`service/scripts/hook_written_file.py`](https://github.com/guillaumemeyer/watermarks-remover/blob/main/service/scripts/hook_written_file.py)
against the file the agent just wrote. Two modes, matching the pre-commit
convention of check-by-default:

| Mode | Behaviour |
| --- | --- |
| `check` (default) | Reports provenance marks, leaves the file alone. Findings go to the model (exit 2), so it can offer to clean them. |
| `clean` | Strips the marks in place, then tells the model the file on disk changed. |

Set the mode from the plugin's settings (**Hook mode** in `/plugin manage`,
read by the hook as `CLAUDE_PLUGIN_OPTION_HOOK_MODE`), or with
`WATERMARKS_HOOK_MODE=clean` in the environment. The hook command deliberately
does **not** interpolate `${user_config.hook_mode}`: Claude Code refuses to run
a hook that references an option the user has never opened `/plugin manage` to
set — a declared `default` does not satisfy it — so interpolating it would mean
the hook silently never runs on a fresh install. Detection reuses `audit_lib`'s
`scan_file` / `is_actionable`, so the hook, the pre-commit gate, and the CI
SARIF export agree on what counts as actionable; cleaning shells out to
`clean_file.py`, so no cleaning logic is duplicated. `clean` mode writes to a
sibling temp file and swaps only on a real difference, so files that were
already clean keep their mtime and don't retrigger file watchers.

Without the plugin, wire it in `~/.claude/settings.json` (or a project
`.claude/settings.json`) yourself:```json
{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit|MultiEdit|NotebookEdit",
        "hooks": [
          {
            "type": "command",
            "command": "python3",
            "args": ["/path/to/watermarks-remover/service/scripts/hook_written_file.py",
                     "--mode", "check"],
            "timeout": 30
          }
        ]
      }
    ]
  }
}

कौशल फिर नेमस्पेस्ड लोड होते हैं: `/watermarks-remover:remove-ai-marks` और
`/watermarks-remover:clean-user-facing-text` (बिना नेमस्पेस वाला `/remove-ai-marks` भी
काम करता है जब कोई और उस नाम पर दावा नहीं करता)। `/plugin marketplace update
watermarks-remover` बाद के संस्करणों को खींच लाता है। यही CLI से भी काम करता है
`claude plugin marketplace add …` / `claude plugin install …` के साथ, और लोकल
चेकआउट से `owner/repo` के बजाय एक पाथ पास करके।

मेंटेनर्स: `make plugin-validate` दोनों मैनिफ़ेस्ट के विरुद्ध `claude plugin validate . --strict`
चलाता है; `tests/test_plugin_manifest.py` CLI की आवश्यकता के बिना उन्हीं फ़ाइलों को कवर करता है।

### Claude Code```bash
# Personal — available in all your projects
python3 install_skill.py --skill remove-ai-marks --target claude-code
# or: make install-claude-code-skill

# Project — commit .claude/skills/ to share it with the repo
python3 install_skill.py --skill remove-ai-marks --target claude-project \
  --project-dir /path/to/project
# or: make install-claude-project-skill PROJECT=/path/to/project

फिर, Claude Desktop ऐप में, **Customize → Skills → Add** खोलें और
zip अपलोड करें (claude.ai पर वही skill settings भी काम करती हैं)। यह
bundle reproducible है और इसमें एक ही top-level `remove-ai-marks/` directory होती है जिसके
root में `SKILL.md` होता है, जो वही layout है जिसकी upload अपेक्षा करता है।

Service reachability यहाँ local install की तुलना में अधिक मायने रखती है: यह skill एक
thin HTTP client है, इसलिए session को `WATERMARKS_SERVICE_URL` तक पहुँचने में सक्षम होना चाहिए।
Cowork sessions जो आपकी मशीन पर locally चलते हैं, एक local `make serve` तक पहुँचते हैं;
cloud sessions और routines remotely चलते हैं और उन्हें वहाँ से reachable एक service URL चाहिए
(और उस पर `WATERMARKS_SERVER_API_KEY` set होना चाहिए)। यदि आप बिना किसी
service के skill चाहते हैं, तो इसके बजाय `clean-user-facing-text` अपलोड करें — यह text-only है और
अपनी scripts के साथ आता है:```bash
python3 install_skill.py --skill clean-user-facing-text --target cowork

### वैकल्पिक टेक्स्ट-केवल स्किल

[`skills/clean-user-facing-text/`](https://github.com/guillaumemeyer/watermarks-remover/blob/main/skills/clean-user-facing-text) अधिकृत पांडुलिपियों, दस्तावेज़ीकरण और वेब कॉपी के लिए एक स्व-निहित स्किल है। यह इमेज, C2PA, सेवा और बाहरी-मॉडल टूलिंग को बाहर रखता है, और सेवा को कॉल करने के बजाय अपनी स्वयं की वेंडर की गई Layer A स्क्रिप्ट चलाता है।```bash
python3 install_skill.py --skill clean-user-facing-text --target claude-code
python3 install_skill.py --skill clean-user-facing-text --target cursor

सभी प्रोजेक्ट्स के लिए, उसी निर्देश को Cursor **User Rules** में डालें।
नियम निरंतरता में सुधार करते हैं लेकिन मॉडल निर्देश बने रहते हैं; Cursor अंतिम चैट प्रतिक्रियाओं के लिए
एक नियतात्मक प्री-सेंड फ़िल्टर उजागर नहीं करता है।

### सेवा प्रारंभ करें

सबसे तेज़ तरीका एक स्थानीय HTTP सर्वर है (केवल Python 3.10+ stdlib — कोई deps नहीं, कोई Docker नहीं):```bash
make serve                 # http://127.0.0.1:8765
# or directly:
python3 service/scripts/server.py --host 127.0.0.1 --port 8765

### टेक्स्ट टूल्स बाइनरी इनपुट अस्वीकार करते हैं

`inspect_text.py`, `clean_text.py` और `rewrite_text.py` टेक्स्ट पर काम करते हैं। किसी `.docx`, `.pdf` या इमेज पर इंगित किए जाने पर ये पहले संपीड़ित बाइट्स को डिकोड करके जो भी कोडपॉइंट्स निकलते थे, उन्हें रिपोर्ट करते थे — शोर जो सामग्री नहीं, बल्कि संपीड़न को ट्रैक करता है — और फिर `clean_text.py` उन विकृत बाइट्स को वापस लिख देता था, जिससे फ़ाइल नष्ट हो जाती थी। अब ये बाइनरी इनपुट अस्वीकार करते हैं और उस टूल का नाम बताते हैं जो इसे संभालता है:```bash
python3 "$SCRIPTS/inspect_text.py" report.docx
# refusing to treat report.docx as text: it looks like a ZIP container (DOCX, ODT, …).
# Use inspect_file.py / clean_file.py, which route by format,
# or pass --force-text to scan the raw bytes anyway.

सेवा फ़ाइल नाम एक्सटेंशन और फिर मैजिक बाइट्स के आधार पर रूट करती है, इसलिए टेक्स्ट / इमेज / कंटेनर स्वतः पहचाने जाते हैं। हर अनुरोध पर `Authorization: Bearer <key>` की आवश्यकता के लिए `WATERMARKS_SERVER_API_KEY` सेट करें। डिफ़ॉल्ट रूप से केवल लूपबैक पर बाइंड (`--host` से ओवरराइड करें); विश्वसनीय नेटवर्क के लिए अभिप्रेत।

### वॉटरमार्क डिटेक्शन (`/detect` और `detect_before` / `detect_after`)

डिटेक्शन क्लीनिंग से एक अलग चरण है — सेवा कभी भी विक्रेता
API को कॉल नहीं करती जब तक आप इसे कहने के लिए न कहें:

- **`POST /detect`** किसी फ़ाइल पर कॉन्फ़िगर किए गए वॉटरमार्क डिटेक्टर चलाता है।
  टेक्स्ट → विक्रेता डिटेक्टर + स्टाइलोमेट्री; इमेज → SynthID पिक्सेल स्कोर।
- **`/inspect`** एक ऑप्ट-इन `"detect": true` फ़्लैग स्वीकार करता है जो
  टेक्स्ट रिपोर्ट में डिटेक्टर परिणाम जोड़ता है (और `suspicious` को फ़्लिप कर सकता है)।
- **`/clean`** `"detect_before"` / `"detect_after"` विकल्प स्वीकार करता है ताकि
  इनपुट और क्लीन किए गए आउटपुट को स्कोर किया जा सके, जिससे आप माप सकें कि क्लीन ने
  वास्तव में क्या बदला।
- **`/clean`** डिफ़ॉल्ट रूप से Layer A के बाद Layer B टेक्स्ट रीराइट चलाता है (यह
  टेक्स्ट के लिए एक आवश्यक चरण है)। एक **`"strategy"`** विकल्प (एक क्रमबद्ध
  `tactic@intensity` सूची, जैसे `"[email protected],[email protected]"`) स्ट्रैटेजी कॉन्फ़िग
  फ़ाइल से डिफ़ॉल्ट को ओवरराइड करता है (नीचे देखें)। जब किसी चरण के लिए रीराइट
  बैकएंड/मॉडल कॉन्फ़िगर नहीं होता, तो `/clean` 400 लौटाता है।

टेक्स्ट डिटेक्टर (देखें `/capabilities` → `text_detectors`):

टेक्स्ट डिटेक्टर (देखें `/capabilities` → `text_detectors`):

| डिटेक्टर | सक्रियकर्ता | नोट्स |
| --- | --- | --- |
| `markllm` | `MARKLLM_DIR` (होस्ट चेकआउट) | रिसर्च हार्नेस (KGW / SynthID स्कीम), केवल-समान-कॉन्फ़िग — विक्रेता ओरेकल नहीं। |
| `gumbel` | `WATERMARKS_GUMBEL_KEY` | कीड-गुम्बेल (Aaronson EXP) स्कीम का मॉडल-मुक्त समान-की रीप्ले (देखें `detect_gumbel.py`), केवल-stdlib — arbi-serve जैसे स्व-होस्टेड इंजन; केवल-समान-की, विक्रेता ओरेकल नहीं। |
| `claude-text` | — (प्लेसहोल्डर) | Anthropic ने वॉटरमार्क डिटेक्शन API की घोषणा की है; यह सीम तब सक्रिय होती है जब यह शिप होती है। |

इमेज स्कोरिंग: जब `WATERMARKS_SYNTHID_SCORER_URL` सेट होता है, तो सेवा
`wr-synthid-score` साइडकार (हेवी प्रोफ़ाइल) के माध्यम से इमेज स्कोर करती है; स्थानीय
`REVERSE_SYNTHID_DIR` के साथ यह सीधे चेकआउट का उपयोग करती है। डिटेक्शन
फेल-सॉफ्ट है: अनकॉन्फ़िगर, टाइम-आउट, या त्रुटिग्रस्त डिटेक्टर
`{"available": false, "error": ...}` रिपोर्ट करते हैं और क्लीनिंग को कभी ब्लॉक नहीं करते।

### वॉटरमार्क जनरेशन (`/watermark` और `/watermark/batch`)

बेंचमार्क मूल्यांकन और राउंड-ट्रिप परीक्षण के लिए वॉटरमार्क्ड टेक्स्ट जनरेट करता है।
जब `WATERMARKS_SYNTHID_TEXT_URL` सेट होता है, तो सेवा जनरेशन को
`wr-synthid-text` साइडकार (हार्नेस प्रोफ़ाइल) को सौंपती है; स्थानीय `MARKLLM_DIR` के साथ यह
सीधे चेकआउट का उपयोग करती है। डिटेक्शन की तरह, जनरेशन भी फेल-सॉफ्ट है: एक अनकॉन्फ़िगर जनरेटर
`{"ok": false, "error": ...}` रिपोर्ट करता है।

## Docker / compose

प्रकाशित इमेज (GHCR):

| इमेज टैग | सामग्री | प्रकाशित? |
| --- | --- | --- |
| `ghcr.io/guillaumemeyer/watermarks-remover:<tag>` / `:latest` | कोर HTTP सेवा + सभी क्लीनर + exiftool / qpdf / c2patool | हाँ |
| `…:markllm-<tag>` / `:markllm-latest` | MarkLLM टेक्स्ट-वॉटरमार्क हार्नेस (Apache-2.0 अपस्ट्रीम) | हाँ |
| `…:markdiffusion-<tag>` / `:markdiffusion-latest` | MarkDiffusion इमेज हार्नेस (Apache-2.0 अपस्ट्रीम) | हाँ |
| `watermarks-remover-ctrlregen:local` | CtrlRegen पिक्सेल रिमूवल — **कभी प्रकाशित नहीं** (`noai-watermark` कोई LICENSE शिप नहीं करता) | केवल स्थानीय बिल्ड |
| `watermarks-remover-synthid-scorer:local` | reverse-SynthID स्कोरर — **कभी प्रकाशित नहीं** (गैर-व्यावसायिक Research License) | केवल स्थानीय बिल्ड (CLI स्कोरर + वैकल्पिक `wr-synthid-score` HTTP साइडकार `heavy` प्रोफ़ाइल के अंतर्गत) |

कोर सेवा बिल्ड और रन करें:```bash
make docker-core-build
docker run --rm -p 127.0.0.1:8765:8765 --read-only --tmpfs /tmp watermarks-remover
# any CLI stays runnable by overriding the command:
docker run --rm -v "$(pwd):/data" watermarks-remover \
  /app/scripts/clean_file.py /data/notes.md -o /data/notes.cleaned.md

The compose stack core service को `127.0.0.1:8765` पर map करता है। Persistent services background daemons के रूप में चलते हैं (`wr-core` और harness profile के अंतर्गत `wr-synthid-text` sidecar)। शेष harness/heavy services one-shot CLIs हैं — जब आपको verification या pixel work की आवश्यकता हो तो `docker compose run --rm <service> …` के साथ invoke करें।

चल रहे stack को validate करें (केवल exit code, सफलता पर कोई output नहीं):```bash
make compose-check        # or: ./compose-check.sh

जिन भाषाओं की टाइपोग्राफी नॉन-ब्रेकिंग स्पेस पर निर्भर करती है (फ़्रेंच `« … »`, `; : ! ?` से पहले का स्पेस), उन्हें `"options": {"normalize_spaces": false}` पास करना चाहिए, जो `clean_text.py --no-normalize-spaces` का HTTP समकक्ष है। अदृश्य कैरियर अभी भी हटा दिए जाते हैं; केवल स्पेस रीराइट छोड़ दिया जाता है।

बाकी सब कुछ वैकल्पिक है और रेपो रूट में एक `.env` फ़ाइल में रहता है। `docker compose` **`.env` को स्वतः लोड करता है** और उससे `compose.yaml` में `${VAR}` संदर्भों को इंटरपोलेट करता है (यदि दोनों सेट हों तो शेल एक्सपोर्ट `.env` पर भारी पड़ते हैं)।```bash
cp .env.example .env       # then edit
docker compose up -d       # picks up .env automatically

| Var | Reaches | Purpose |
| --- | --- | --- |
| `WATERMARKS_SERVER_API_KEY` | `wr-core` (compose `environment` के माध्यम से) | HTTP API पर `Authorization: Bearer <key>` आवश्यक करें |
| `WATERMARKS_GEMINI_*` | — | अगस्त 2026 में हटाया गया: Google ने API पर SynthID टेक्स्ट वॉटरमार्किंग बंद कर दी (देखें `vendor-notes.md`) |
| `WATERMARKS_SYNTHID_SCORER_URL` | `wr-core` | SynthID इमेज स्कोरिंग के लिए core को `wr-synthid-score` साइडकार की ओर इंगित करें (जैसे heavy प्रोफ़ाइल के अंतर्गत `http://wr-synthid-score:8766`) |
| `WATERMARKS_SYNTHID_SCORER_API_KEY` | `wr-core` + `wr-synthid-score` | स्कोरर साइडकार के लिए साझा bearer key (खाली = कोई प्रमाणीकरण नहीं) |
| `WATERMARKS_SYNTHID_TEXT_URL` | `wr-core` | SynthID टेक्स्ट वॉटरमार्किंग के लिए core को `wr-synthid-text` साइडकार की ओर इंगित करें (जैसे harness प्रोफ़ाइल के अंतर्गत `http://wr-synthid-text:8767`) |
| `WATERMARKS_SYNTHID_TEXT_API_KEY` | `wr-core` + `wr-synthid-text` | टेक्स्ट वॉटरमार्क साइडकार के लिए साझा bearer key (खाली = कोई प्रमाणीकरण नहीं) |
| `WATERMARKS_SYNTHID_TEXT_TIMEOUT` | `wr-core` | `wr-synthid-text` साइडकार की प्रतीक्षा करने के लिए सेकंड (डिफ़ॉल्ट 120) |
| `WATERMARKS_MARKLLM_SCHEME` | `text_detectors.py` (होस्ट) | `/detect` के लिए MarkLLM स्कीम: `kgw` (डिफ़ॉल्ट) / `synthid` |
| `HF_TOKEN` | harness/heavy सेवाएँ | gated मॉडल के लिए Hugging Face टोकन |
| `WATERMARKS_SERVICE_URL` | केवल क्लाइंट (skill / curl) | सेवा तक कहाँ पहुँचना है; डिफ़ॉल्ट `http://127.0.0.1:8765` |
| `WATERMARKS_REWRITE_BACKEND` | `rewrite_text.py` हुक | `print-prompt` (डिफ़ॉल्ट) / `ollama` / `openai-compatible` |
| `WATERMARKS_REWRITE_MODEL` | `rewrite_text.py` हुक | मॉडल नाम (जैसे `deepseek-v4-flash`) |
| `WATERMARKS_REWRITE_BASE_URL` | `rewrite_text.py` हुक | API बेस (जैसे `https://api.deepseek.com`) |
| `WATERMARKS_REWRITE_API_KEY` | `rewrite_text.py` हुक | API key — केवल env में, कभी argv पर नहीं |
| `WATERMARKS_REWRITE_ALLOW_REMOTE` | `rewrite_text.py` हुक | गैर-loopback एंडपॉइंट की अनुमति देने के लिए `1` |
| `WATERMARKS_REWRITE_REASONING_EFFORT` | `rewrite_text.py` हुक | `none` (डिफ़ॉल्ट) / `low` / `medium` / `high` / `off` |
| `WATERMARKS_CLEAN_STRATEGY_FILE` | `server.py` `/clean` | Layer B रणनीति कॉन्फ़िग JSON का पथ (डिफ़ॉल्ट `config/clean_strategy.json`) |
| `WATERMARKS_GUMBEL_KEY` | `detect_gumbel.py` / `text_detectors.py` | keyed-Gumbel (EXP) same-key replay के लिए गुप्त key (जैसे `0x…`); argv पर वरीयता — कभी लॉग नहीं किया जाता |

**टेक्स्ट सफ़ाई के लिए Layer B आवश्यक है।** `/clean` हमेशा Layer A के बाद एक टेक्स्ट फ़ाइल पर डिफ़ॉल्ट रणनीति (from `config/clean_strategy.json`, `{"default_strategy": "[email protected],[email protected]"}`) लागू करता है, जब तक कि अनुरोध अपना स्वयं का `"strategy"` विकल्प (एक क्रमबद्ध `tactic@intensity` सूची) पास न करे। एक रणनीति चरण `tactic@intensity` होता है; `mlm` चरण को `transformers` + `roberta-large` चाहिए, और किसी भी LLM चरण (`paraphrase`, `humanize`, …) को `WATERMARKS_REWRITE_*` कॉन्फ़िग चाहिए। यदि आवश्यक बैकएंड/मॉडल कॉन्फ़िगर नहीं है — या कोई रणनीति उपलब्ध नहीं है — तो `/clean` **अनुरोध को 400 के साथ अस्वीकार कर देता है**। कॉन्फ़िग पथ के लिए प्राथमिकता: `--strategy-config` CLI फ़्लैग > `WATERMARKS_CLEAN_STRATEGY_FILE` env var > डिफ़ॉल्ट `config/clean_strategy.json`।

इमेज [`.github/workflows/release-images.yml`](https://github.com/guillaumemeyer/watermarks-remover/blob/main/.github/workflows/release-images.yml) के माध्यम से `v*` टैग पर स्वचालित रूप से प्रकाशित होती हैं।

## वैकल्पिक SynthID पिक्सेल स्कोरिंग

`inspect_image.py` और `clean_image.py` एक पिक्सेल-डोमेन SynthID
विश्वास स्कोर रिपोर्ट कर सकते हैं जब
[`aloshdenny/reverse-SynthID`](https://github.com/aloshdenny/reverse-SynthID)
का बाहरी चेकआउट उपलब्ध हो। स्कोरर **बंडल नहीं किया गया है**: यह रनटाइम पर आपके
चेकआउट से लोड होता है, और इसका कोड अपस्ट्रीम प्रोजेक्ट के गैर-व्यावसायिक
Research License के अंतर्गत रहता है।

### विकल्प 1: एक-कमांड बूटस्ट्रैप (कोई Docker नहीं)```bash
SCRIPTS=service/scripts

# Clones upstream, creates a venv, and installs scorer-only dependencies.
"$SCRIPTS/setup_synthid.sh"

# Score an image (default checkout: ~/reverse-SynthID).
REVERSE_SYNTHID_DIR=~/reverse-SynthID \
~/reverse-SynthID/.venv/bin/python "$SCRIPTS/score_synthid.py" shot.png

# Or surface the score from inspect / clean (same venv Python).
REVERSE_SYNTHID_DIR=~/reverse-SynthID \
~/reverse-SynthID/.venv/bin/python "$SCRIPTS/inspect_image.py" shot.png

इमेज बिल्ड समय पर अपस्ट्रीम स्रोत से स्थानीय रूप से बनाई जाती है। यह प्रकाशित नहीं की जाती, इसलिए यह अपस्ट्रीम कोड का पुनर्वितरण नहीं करती।

### विकल्प 3: HTTP स्कोरर साइडकार (docker compose)

`heavy` प्रोफ़ाइल के अंतर्गत compose स्टैक स्कोरर को एक HTTP साइडकार (`wr-synthid-score`) के रूप में भी चलाता है ताकि **प्रकाशित कोर सेवा** गैर-व्यावसायिक अपस्ट्रीम कोड को बंडल किए बिना क्लीनिंग से पहले/बाद में इमेज को स्कोर कर सके। `wr-core` को इसकी ओर इंगित करें और एक bearer key साझा करें (देखें `.env.example`):```bash
# .env
WATERMARKS_SYNTHID_SCORER_URL=http://wr-synthid-score:8766
WATERMARKS_SYNTHID_SCORER_API_KEY=change-me

docker compose --profile heavy up -d

Windows पर `setup_ctrlregen.ps1` का उपयोग करें (`-Dir`, `-Ref`, `-Python` के समान फ़्लैग्स);
venv `.venv\Scripts\` में बनता है, जिसे `clean_image.py` पहले से ही हल कर लेता है।
यह प्रकाशित PyTorch wheel indices की जाँच करता है और `nvidia-smi` द्वारा दिखाए गए CUDA संस्करण के बराबर या उससे नीचे का उच्चतम वह index चुनता है जो वास्तव में मौजूद है — वह संख्या वह अधिकतम है जिसे *driver* समर्थन करता है, और drivers पीछे की ओर संगत होते हैं, इसलिए 13.1 रिपोर्ट करने वाला driver (कोई प्रकाशित `cu131` नहीं) `cu130` इंस्टॉल करता है। compute capability 7.5 से नीचे यह `cu126` को बाध्य करता है, जो अंतिम index है जिसके wheels में अभी भी Maxwell/Pascal/Volta kernels होते हैं। यह उस index से `torch` **और** `torchvision` दोनों को एक साथ इंस्टॉल करता है ताकि dependency install उन्हें PyPI से CPU builds से न बदल सके, फिर इंस्टॉल के बाद सत्यापित करता है कि `torch.cuda.is_available()` true है — यदि GPU का पता चला था लेकिन torch CPU-only निकलता है, तो script ज़ोर से चेतावनी देता है और सेटअप सफल होने का दिखावा करने के बजाय non-zero के साथ बाहर निकल जाता है।

### `clean_image.py` से```bash
NOAI_WATERMARK_DIR=~/noai-watermark \
~/noai-watermark/.venv/bin/python "$SCRIPTS/clean_image.py" shot.png \
  -o shot.cleaned.png --remove-pixel ctrlregen

## वैकल्पिक MarkLLM टेक्स्ट-वॉटरमार्क सत्यापन

**नियंत्रित प्रयोगों** के लिए, एक वैकल्पिक बाहरी हार्नेस
[`THU-BPM/MarkLLM`](https://github.com/THU-BPM/MarkLLM) (Apache-2.0) को रैप करता है ताकि
परीक्षण टेक्स्ट पर वॉटरमार्क लगाया जा सके और Layer B रीराइट के बाद उसे फिर से डिटेक्ट किया जा सके — उदाहरण के लिए, यह साबित करना कि
एक KGW (Kirchenbauer, आपकी "open-LLM" पंक्ति) या SynthID-Text (Gemini पंक्ति) मार्क
आपके रीराइट के अंतर्गत गायब हो जाता है। यह एक **सत्यापन हार्नेस है, ऑरेकल नहीं**:
MarkLLM डिटेक्शन केवल उसी स्कीम कॉन्फ़िग + keys के विरुद्ध मान्य है जो जनरेशन के समय उपयोग किए गए थे, और यह प्रमाणित नहीं कर सकता कि किसी विक्रेता का डिटेक्टर विफल होगा।

बैकएंड **बंडल नहीं किया गया है**। `setup_markllm.sh` अपस्ट्रीम को एक पिन किए गए
कमिट पर क्लोन करता है, एक venv बनाता है, और पिन किए गए डिप्स (torch + transformers) इंस्टॉल करता है; स्कोरिंग मॉडल (डिफ़ॉल्ट `facebook/opt-1.3b`, Apache-2.0) पहले रन पर Hugging
Face से डाउनलोड होता है।```bash
SCRIPTS=service/scripts

# Bootstrap (clones upstream, creates ~/MarkLLM/.venv, installs deps).
"$SCRIPTS/setup_markllm.sh"

# Generate watermarked + unwatermarked sample text under the KGW scheme.
MARKLLM_DIR=~/MarkLLM \
  ~/MarkLLM/.venv/bin/python "$SCRIPTS/detect_text_watermark.py" watermark prompt.txt \
    --scheme kgw -o wm.txt -o2 plain.txt

# Detect the scheme mark in a text file.
MARKLLM_DIR=~/MarkLLM \
  ~/MarkLLM/.venv/bin/python "$SCRIPTS/detect_text_watermark.py" detect wm.txt --scheme kgw --json

**डिटेक्शन-निर्देशित पुनरावृत्तीय पुनर्लेखन:** लेयर B अब पुनरावृत्तीय रूप से पुनर्लेखन करता है और जैसे ही कोई प्रयास मूल्यांकन पास करता है, रुक जाता है। प्रत्येक मूल्यांकन दौर `--candidates` वेरिएंट उत्पन्न करता है (डिफ़ॉल्ट **1**, `WATERMARKS_REWRITE_CANDIDATES`) और `--max-loops` यह सीमित करता है कि सर्वोत्तम-प्रयास वेरिएंट लौटाए जाने से पहले कितने दौर चलें (डिफ़ॉल्ट **1**, `WATERMARKS_REWRITE_LOOPS`)। प्रत्येक वेरिएंट एक पुनर्लेखन कॉल और एक मूल्यांकन है, और एक दौर पहले प्रयास पर ही जल्दी समाप्त हो जाता है जिसे मूल्यांकनकर्ता गैर-वॉटरमार्क्ड बताता है — इसलिए `--max-loops` बढ़ाने से नए वेरिएंट तब तक पुनः प्रयास करते हैं जब तक कोई मूल्यांकन पास न हो जाए (एक सामान्य स्वच्छ पुनर्लेखन में एक प्रयास लगता है)। मूल्यांकनकर्ता प्राथमिकता के आधार पर चुना जाता है:

1. **MarkLLM** — समान-कॉन्फ़िग शोध डिटेक्शन, जब `--markllm-scheme` पास किया जाता है (साथ में `--markllm-dir`)। MarkLLM के ऊपर Google के SynthID-text डिटेक्टर के लिए एक विक्रेता-डिटेक्टर स्लॉट आरक्षित है, जिसे Google ने अगस्त 2026 में अपने API पर बंद कर दिया — भविष्य में कोई विक्रेता एंडपॉइंट वहाँ जुड़ सकता है।
2. **bigram-Jaccard शाब्दिक विचलन** — जब कोई डिटेक्टर कॉन्फ़िगर नहीं होता; कोई पास/फेल निर्णय नहीं, इसलिए प्रत्येक प्रयास उत्पन्न होता है और सबसे अधिक शाब्दिक रूप से विचलित चुना जाता है (मूल व्यवहार)।

`--json-stats` मूल्यांकनकर्ता, किए गए प्रयास, पास/फेल, और प्रति-प्रयास रिकॉर्ड रिपोर्ट करता है:```json
{
  "evaluator": "markllm",
  "candidates": 1,
  "max_loops": 2,
  "attempts_made": 2,
  "passed": true,
  "candidate_scores": [
    {
      "lexical_divergence": 0.91,
      "selection_score": 0.91,
      "selected": false,
      "passed": false,
      "evaluation": {"detector": "markllm", "available": true, "scheme": "kgw",
                     "is_watermarked": true, "score": 4.3, "threshold": 3.0}
    },
    {
      "lexical_divergence": 0.84,
      "selection_score": 0.84,
      "selected": true,
      "passed": true,
      "evaluation": {"detector": "markllm", "available": true, "scheme": "kgw",
                     "is_watermarked": false, "score": 1.7, "threshold": 3.0}
    }
  ],
  "markllm": {"scheme": "kgw", "before": {"...": "..."}, "after": {"...": "..."},
              "cleared": true, "note": "same-config only"}
}

### Keyed-Gumbel (Aaronson EXP) समान-कुंजी सत्यापन

[ARBI की तकनीकी रिपोर्ट](https://arbicity.com/news/ai-text-watermarking-for-self-hosted-ai/) keyed-Gumbel ("exponential") टेक्स्ट वॉटरमार्क का वर्णन करती है — जो अब ओपन-सोर्स arbi-serve इंजन (`ARBI_WATERMARK_KEY`) में शिप हो रहा है — जहाँ सैंपलर का शोर अंतिम 4-टोकन कॉन्टेक्स्ट विंडो के keyed hash से प्राप्त होता है। डिटेक्शन एक **मॉडल-मुक्त रीप्ले** है: केवल टेक्स्ट से `u = PRF(Hash(key, window), token)` की पुनर्गणना करें और Gamma tail का परीक्षण करें, इसलिए इसे किसी GPU, मॉडल, या logits की आवश्यकता नहीं होती। यह रेपो उस डिटेक्टर को `detect_gumbel.py` के रूप में शिप करता है (केवल-stdlib; p-value एक पूर्णांक Gamma shape के लिए सटीक Poisson-sum identity है):```bash
# Text mode (deterministic word/run tokenizer) — quick checks and rewrite-loop
# evaluation; exact replay against a real engine needs its tokenizer:
python3 service/scripts/detect_gumbel.py draft.txt --key 0x... --json

# Exact replay: pass the engine's token ids (JSON array or one per line).
python3 service/scripts/detect_gumbel.py ids.json --tokens --key 0x... --json

कुंजी कभी भी stats या logs में नहीं दिखाई देती। जो self-hosted operators अपने
engine की कुंजी रखते हैं, वे सत्यापित कर सकते हैं कि किसी rewrite ने Gumbel mark को साफ़ कर दिया; बाकी सभी Layer B को केवल best-effort मानते हैं।

## वैकल्पिक SynthID-text हटाने का बेंचमार्क

[`bench_synthid_text.py`](https://github.com/guillaumemeyer/watermarks-remover/blob/main/service/scripts/bench_synthid_text.py) मापता है कि
एक Layer B rewrite SynthID-text-श्रेणी के watermarks को कितने प्रभावी ढंग से साफ़ करता है और
किस लागत पर। यह MarkLLM
SynthID scheme (same-config detection, sanity-gated) के साथ watermarked + unwatermarked samples उत्पन्न करता है, आपके rewrite
variants (tactic × max rewrite attempts; pass पर loop जल्दी रुक जाता है) के साथ-साथ
controls (no-removal, Layer-A-only, वैकल्पिक re-stamp check) चलाता है, और एक साझा करने योग्य `report.md` /
`results.json` / `results.csv` लिखता है। पूरी मार्गदर्शिका:
[`docs/synthid-text-benchmark.md`](https://github.com/guillaumemeyer/watermarks-remover/blob/main/docs/synthid-text-benchmark.md)।

इसके लिए एक MarkLLM checkout (`setup_markllm.sh` / `MARKLLM_DIR`) और एक
rewrite backend आवश्यक है। **rewriting model एक LLM है जिसे आप configure करते हैं** — वही
`rewrite_text.py` backend जो skill उपयोग करता है। MarkLLM का डिफ़ॉल्ट
`facebook/opt-1.3b` (`--markllm-model`) केवल watermark
generator/detector है; यह कभी rewrite नहीं करता। rewrite model को env
vars या benchmark flags के माध्यम से configure करें (वे ऊपर दी गई
[config table](#configuration-env-vars-for-docker-compose) को दर्शाते हैं):

| Env var | Benchmark flag | Default | Meaning |
| --- | --- | --- | --- |
| `WATERMARKS_REWRITE_BACKEND` | `--rewrite-backend` | `ollama` | `ollama` या `openai-compatible` |
| `WATERMARKS_REWRITE_MODEL` | `--rewrite-model` | *(आवश्यक)* | वह LLM जो rewrite करता है (जैसे `llama3.2`, `deepseek-v4-flash`) |
| `WATERMARKS_REWRITE_BASE_URL` | `--rewrite-base-url` | `http://127.0.0.1:11434` | Endpoint; Ollama का डिफ़ॉल्ट loopback है |
| `WATERMARKS_REWRITE_API_KEY` | `--rewrite-api-key` | — | API key (child process में केवल env, कभी argv नहीं) |
| `WATERMARKS_REWRITE_ALLOW_REMOTE=1` | `--rewrite-allow-remote` | off | non-loopback endpoints पर content भेजने के लिए आवश्यक |```bash
# Ollama (loopback):
python3 service/scripts/bench_synthid_text.py --markllm-dir ~/MarkLLM \
  --rewrite-backend ollama --rewrite-model llama3.2

# OpenAI-compatible API (remote):
WATERMARKS_REWRITE_API_KEY=... python3 service/scripts/bench_synthid_text.py \
  --markllm-dir ~/MarkLLM --rewrite-backend openai-compatible \
  --rewrite-model deepseek-v4-flash --rewrite-base-url https://api.deepseek.com \
  --rewrite-allow-remote

या सामान्य इमेज पाइपलाइन के हिस्से के रूप में शुद्धिकरण चलाएँ:```bash
MARKDIFFUSION_DIR=~/markdiffusion \
  ~/markdiffusion/.venv/bin/python "$SCRIPTS/clean_image.py" shot.png \
    -o shot.cleaned.png --remove-pixel diffusion

यह इमेज एक CPU torch इंस्टॉल करती है; CUDA उपयोगकर्ताओं को होस्ट पर इसके बजाय `setup_markdiffusion.sh` चलाना चाहिए। मॉडल डाउनलोड पहली बार चलाने पर अभी भी HF hub पर हिट करते हैं।

## कवरेज मैट्रिक्स

| चैनल | Claude | Gemini/SynthID | OpenAI | Open-LLM |
| --- | --- | --- | --- | --- |
| Unicode / edit-आधारित टेक्स्ट | Layer A | Layer A | Layer A | Layer A |
| **सांख्यिकीय सैंपलिंग टेक्स्ट** | Layer B best-effort (Claude seam जब Anthropic का detection API शिप होता है) | Layer B best-effort (+ MarkLLM same-config harness; Google ने vendor detector को Aug 2026 में रिटायर कर दिया) | Layer B यदि मौजूद हो | Layer B best-effort + वैकल्पिक MarkLLM harness |
| C2PA / फ़ाइल मेटाडेटा | हाँ (सूचीबद्ध फ़ॉर्मेट) | हाँ जब मौजूद हो | हाँ जब मौजूद हो | हाँ जब मौजूद हो |
| पिक्सेल इमेज मार्क्स | दायरे से बाहर | वैकल्पिक SynthID स्कोर + CtrlRegen हटाना (बाहरी); वैकल्पिक MarkDiffusion same-scheme detect + DiffusionPurification हटाना (बाहरी) | दायरे से बाहर | वैकल्पिक CtrlRegen / MarkDiffusion हटाना (बाहरी) |
| ट्रेनिंग बैकडोर | दायरे से बाहर | दायरे से बाहर | दायरे से बाहर | दायरे से बाहर |

विवरण: [`skills/remove-ai-marks/references/vendor-notes.md`](https://github.com/guillaumemeyer/watermarks-remover/blob/main/skills/remove-ai-marks/references/vendor-notes.md), [`mark-classes.md`](https://github.com/guillaumemeyer/watermarks-remover/blob/main/skills/remove-ai-marks/references/mark-classes.md)।

---

## टेक्स्ट मार्किंग कैसे काम करती है (संक्षेप)

आधुनिक LLM वॉटरमार्क अक्सर एक सिग्नल को **कौन से टोकन चुने जाते हैं** (generative / sampling bias) में छिपाते हैं, न कि केवल अदृश्य वर्णों में। Edit-आधारित स्कीमें Unicode या synonym नियम इंजेक्ट करती हैं। फ़ाइल स्कीमें **C2PA** या generator मेटाडेटा संलग्न करती हैं।

- **Layer A** edit-आधारित Unicode वाहक हटाता है (परीक्षण योग्य)।
- **Layer B** भारी पुनर्लेखन के माध्यम से sampling वॉटरमार्क पर हमला करता है (best-effort; साहित्य-मानक हमले जैसे paraphrase / back-translation)।
- **फ़ाइल क्लीनर** समर्थित कंटेनरों से C2PA/XMP/props हटाते हैं।

जब तक विक्रेता सार्वजनिक डिटेक्टर और कुंजियाँ शिप नहीं करते, **कोई भी टूल ईमानदारी से प्रमाणित नहीं कर सकता** कि "यह आधिकारिक जाँच में विफल होता है।" रिपोर्टों को सत्यापन योग्य बनाम best-effort कार्य को अलग करना चाहिए।

Layer B के लिए **non-origin** मॉडल को प्राथमिकता दें (यदि आप पुनः-स्टैम्पिंग से बचना चाहते हैं तो Claude टेक्स्ट को Claude से पुनर्लेखित न करें)।

---

## अस्वीकरण: टेक्स्ट वॉटरमार्क हटाने की लागत

टेक्स्ट वॉटरमार्क **शब्दावली में ही** रहते हैं: सिग्नल टोकन विकल्पों में फैला होता है, इसलिए लगभग हर वाक्य उसका थोड़ा हिस्सा वहन करता है। इसके दो परिणाम होते हैं, और यही कारण है कि Layer B को ईमानदारी से *best-effort* बताया जाता है, न कि जादुई इरेज़र।

1. **हटाने का अर्थ पुनर्शब्दीकरण है, पुनर्संरचना नहीं।** पैराग्राफ़ों को फेरबदल करना, शीर्षक बदलना, या हल्के टच-अप सिग्नल को मुश्किल से हिलाते हैं। सांख्यिकीय मार्क को हटाने के लिए टेक्स्ट के एक बड़े हिस्से को फिर से लिखना आवश्यक है — वाक्य-दर-वाक्य, अनुभाग-दर-अनुभाग नहीं।

2. **पुनर्शब्दीकरण कॉपी को ख़राब करता है।** कोई भी पुनर्लेखन मूल शब्द विकल्पों को पुनर्लेखन मॉडल के साथ बदल देता है, जो टोन, आवाज़ और सटीकता को सपाट कर देता है। प्रोडक्शन कॉपी (SEO, मार्केटिंग, क्लाइंट कार्य) पर यह गिरावट वास्तविक होती है और अक्सर उन लोगों को दिखाई देती है जो लेखन की सबसे अधिक परवाह करते हैं। यह ऐसा है जैसे किसी शीर्ष-स्तरीय मॉडल से टेक्स्ट लेकर किसी कम सक्षम मॉडल से इसे शुरू से फिर से लिखवाना: परिणाम पुनर्लेखन मॉडल की सीमा से अधिक नहीं हो सकता।

जो ईमानदार पूर्ण-वृत्त प्रश्न की ओर ले जाता है:

> यदि योजना वैसे भी सस्ते मॉडल से टेक्स्ट को फिर से लिखने की है, तो पहले स्थान पर प्रीमियम मॉडल के लिए भुगतान क्यों करें? सीधे सस्ते मॉडल से जनरेट करना सरल, सस्ता है, और वही — या बेहतर — अंतिम परिणाम देता है।

Layer B तब समझ में आता है जब आप विशेष रूप से प्रीमियम मॉडल की **सोच और ड्राफ्टिंग** चाहते हैं और स्वच्छता या गोपनीयता आवश्यकता को पूरा करने के लिए एक पुनर्लेखन पास स्वीकार करते हैं — न कि मार्क-मुक्त टेक्स्ट के सस्ते मार्ग के रूप में।

**Layer B को कब छोड़ें:**

- **गुणवत्ता स्वच्छता से अधिक मायने रखती है:** lossless पथ का उपयोग करें — Layer A Unicode स्क्रब प्लस फ़ाइल मेटाडेटा क्लीनर — और मूल गद्य रखें।
- **वैसे भी पुनर्लेखन कर रहे हैं:** एक **non-origin** मॉडल का उपयोग करें (origin मॉडल से पुनर्लेखन टेक्स्ट को फिर से स्टैम्प कर सकता है), और याद रखें कि अवशिष्ट जोखिम बना रहता है — कोई भी टूल प्रमाणित नहीं कर सकता कि विक्रेता डिटेक्टर विफल होगा।

---

## फ़ाइल फ़ॉर्मेट

| फ़ॉर्मेट | निरीक्षण | सफ़ाई |
| --- | --- | --- |
| PNG / JPEG / WebP | C2PA chunks / APP11 / RIFF `C2PA`, AI XMP संकेत | मेटाडेटा सेगमेंट हटाएँ |
| AVIF / HEIC | ISOBMFF `jumb` / XMP `uuid` बॉक्स | बॉक्स हटाएँ |
| BMP | अनुगामी गैर-इमेज बाइट्स (कोई मानकीकृत चैनल नहीं) | अनुगामी मेटाडेटा ट्रंकेट करें, फ़ाइल-आकार फ़ील्ड ठीक करें |
| GIF | Comment / XMP एप्लिकेशन एक्सटेंशन | Comment और XMP हटाएँ, `NETSCAPE2.0` लूप रखें |
| TIFF (classic + BigTIFF) | IFD टैग: XMP, EXIF, GPS, IPTC, MakerNote | टैग हटाएँ, पेलोड शून्य करें, strips रखें |
| SVG | `<metadata>`, XMP | ब्लॉक हटाएँ |
| PDF | Byte/XMP + वैकल्पिक टूल | **exiftool** फिर **qpdf**, फिर एम्बेडेड इमेज के अंदर मेटाडेटा के लिए **ghostscript**; प्रत्येक अनुपस्थित टूल एक अलग परत को कमज़ोर करता है (दस्तावेज़ स्ट्रिप, संरचनात्मक पुनर्लेखन, एम्बेडेड इमेज) |
| DOCX | docProps / customXml | props स्क्रब करें, customXml हटाएँ |
| EPUB | OPF मेटाडेटा, XHTML meta/JSON-LD, एम्बेडेड मीडिया | OPF स्क्रब करें, XHTML meta हटाएँ, मीडिया साफ़ करें + Layer A (एन्क्रिप्टेड भागों को छोड़ता है) |
| ODT | meta.xml | generator / AI-जैसा meta हटाएँ |
| HTML | meta, JSON-LD, data-ai* | टैग/attrs हटाएँ |
| Markdown | YAML frontmatter AI कुंजियाँ | कुंजियाँ हटाएँ + Layer A बॉडी |
| MP4 / MOV / M4A / M4V | ISOBMFF `jumb`/`uuid` बॉक्स (AVIF/HEIC के समान तंत्र) + `moov/udta` generator टैग | बॉक्स हटाएँ |
| WAV | RIFF `C2PA` / `LIST INFO` chunks, एम्बेडेड `id3\x20` chunk | chunks हटाएँ |
| MP3 | ID3v2 फ़्रेम (v2.3/v2.4 per-frame; v2.2 whole-tag) | मिलान किए गए फ़्रेम या पूरा टैग हटाएँ |
| FLAC | ID3v2 `GEOB` फ़्रेम में C2PA मैनिफ़ेस्ट | मिलान किया गया फ़्रेम या पूरा ID3v2 टैग हटाएँ |

FLAC समर्थन C2PA के मानकीकृत ID3v2 वाहक को कवर करता है। मूल FLAC मेटाडेटा ब्लॉक, Vorbis Comments, और waveform-डोमेन वॉटरमार्क अछूते छोड़े जाते हैं।

#### PDF को qpdf की आवश्यकता क्यों है, केवल exiftool की नहीं

ExifTool PDF को **इंक्रीमेंटली** लिखता है। `exiftool -all=` एक `%BeginExifToolUpdate` ब्लॉक जोड़ता है जो Info ऑब्जेक्ट को मुक्त करता है और trailer से `/Info` हटा देता है — लेकिन मूल मेटाडेटा बाइट्स फ़ाइल में शब्दशः बने रहते हैं, और exiftool स्वयं `-PDF-update:all=` के साथ संपादन को पूर्ववत कर सकता है। कमांड `0` पर निकलता है, व्यूअर कोई मेटाडेटा नहीं दिखाते, और फ़ाइल *बड़ी* हो जाती है, जो कि संकेत है।

एक provenance-हटाने वाले टूल के लिए यह एक मूक लीक है, इसलिए `clean_pdf` exiftool पास के बाद `qpdf --linearize` चलाता है, जो दस्तावेज़ को उसके ऑब्जेक्ट ग्राफ़ से पुनः-सीरियलाइज़ करता है और अब-असंदर्भित ऑब्जेक्ट्स को हटा देता है। `qpdf` इंस्टॉल न होने पर सफ़ाई फिर भी चलती है, लेकिन यह बताती है:```
warning: exiftool PDF edits are incremental — the original metadata bytes
remain recoverable; install qpdf for a structural rewrite

Ghostscript इंस्टॉल किए बिना भी क्लीन अभी भी चलता है और बताता है कि वह किस तक नहीं पहुँच सका:```text
warning: metadata inside embedded images left in place; install ghostscript
for the deep image pass

`watermarks-remover-check` कमिट को विफल करता है और निष्कर्षों की सूची देता है; `watermarks-remover-clean` ऑप्ट-इन है और स्टेज किए गए फ़ाइलों को यथास्थान फिर से लिखता है (एक्ज़िट 1 ताकि आप डिफ़ की समीक्षा करें और फिर से स्टेज करें — यह उसी परंपरा का पालन करता है जैसे `ruff --fix` जैसे ऑटो-फिक्सिंग हुक)। जब क्लीनर किसी फ़ाइल को बिल्कुल भी प्रोसेस नहीं कर पाता — वह क्रैश हो गया, किल कर दिया गया, या कोई रिपोर्ट उत्पन्न नहीं हुई — तो `watermarks-remover-clean` उस फ़ाइल का नाम लेता है और इसके बजाय एक्ज़िट 3 करता है, ताकि विफल हुए क्लीनर को कभी भी पहले से साफ़ फ़ाइल न समझा जाए। इनमें से किसी को भी मैन्युअल रूप से `python3 service/scripts/check_staged.py <files...>` / `clean_staged.py <files...>` के साथ चलाएँ।

## परीक्षण```bash
python3 -m venv .venv && .venv/bin/pip install pytest
.venv/bin/python -m pytest          # or: make test
make smoke                          # quick CLI smoke on fixtures