Add Tencent Yuanbao visible watermark removal

README.md

@@ -21,13 +21,13 @@ If this tool saves you time, consider [sponsoring its development](https://githu
 
 ## Scope
 
-This tool removes **AI-provenance watermarks** that a platform stamps onto content **you generated yourself** — SynthID, the Gemini / Nano Banana sparkle, the Doubao / Jimeng / Qwen / Kling / Baidu / LibLibAI / RunningHub / Samsung visible AI labels, the Chinese TC260 "由…AI生成" label, and C2PA / IPTC / EXIF "Made with AI" metadata. The point is your autonomy over your own output.
+This tool removes **AI-provenance watermarks** that a platform stamps onto content **you generated yourself** — SynthID, the Gemini / Nano Banana sparkle, the Doubao / Jimeng / Qwen / Kling / Tencent Yuanbao / Baidu / LibLibAI / RunningHub / Samsung visible AI labels, the Chinese TC260 "由…AI生成" label, and C2PA / IPTC / EXIF "Made with AI" metadata. The point is your autonomy over your own output.
 
 It does **not** target watermarks that protect someone else's paid or copyrighted content — stock-agency overlays (Shutterstock, Getty, iStock, Adobe Stock), classifieds-site marks, or any tiled "preview" watermark whose job is to gate a purchase. Removing those is out of scope by design. `erase` is a generic, user-driven region tool for your own objects, not an automatic stock-watermark remover.
 
 ## Features
 
-- **Visible watermark removal** — a registry of known marks in their usual places: the Gemini / Nano Banana sparkle, the Doubao "豆包AI生成" text strip, the Jimeng "★ 即梦AI" wordmark, the Qwen "千问AI生成" and Kling "可灵AI 3.0" text strips, the Baidu "百度 AI生成" text + tag, the LibLibAI wordmark (bottom-center), the RunningHub "RunningHub AI生成" text (top-left), and the Samsung Galaxy AI "✦ Contenuti generati dall'AI" strip (bottom-left, locale-specific). Each mark is **localized to a footprint mask, then filled**: the engine finds the mark, builds a binary mask over its footprint, and one shared, swappable fill inpaints that region. Choose the fill with `--backend`: `cv2` (classical inpaint, no deps, the floor), `migan` (MI-GAN, light, the memory-tight pick where LaMa will not fit), or `lama` (big-LaMa, best quality, heavier, auto-preferred when a learned backend is available); the default `auto` uses LaMa > MI-GAN > cv2, best available. The localizer is cheap CPU (cv2/numpy), so it runs anywhere; the heavier MI-GAN/LaMa fill is opt-in. Detection keys on each mark's own shape (NCC against a captured silhouette; the alpha captures rebuilt by `scripts/visible_alpha_solve.py` are used to detect and to shape the mask, not for pixel recovery). The visual detector needs no metadata, but a borderline (faint or moved) mark is only trusted with corroboration: `--sensitivity` (default `auto`) relaxes a mark's gate when local metadata confirms the vendor or a same-product sibling mark is found; `strict` never relaxes. There is deliberately no "assume this is AI" mode: asserting that an image is AI says nothing about *which* vendor made it or *where* the mark is, which is exactly what a gate bypass needs. If you can SEE a mark the detector missed, point at it with `erase --region x,y,w,h`, or force a known text mark by name with `--mark <name> --no-detect` -- both act on what you actually see instead of relaxing every detector at once. `visible --mark auto` finds and removes every detected mark in one pass. Fast, offline, no GPU. (For arbitrary logos/objects, see `erase`.)
+- **Visible watermark removal** — a registry of known marks in their usual places: the Gemini / Nano Banana sparkle, the Doubao "豆包AI生成" text strip, the Jimeng "★ 即梦AI" wordmark, the Qwen "千问AI生成" and Kling "可灵AI 3.0" text strips, the Tencent Yuanbao two-line "元宝 / AI生成" mark, the Baidu "百度 AI生成" text + tag, the LibLibAI wordmark (bottom-center), the RunningHub "RunningHub AI生成" text (top-left), and the Samsung Galaxy AI "✦ Contenuti generati dall'AI" strip (bottom-left, locale-specific). Each mark is **localized to a footprint mask, then filled**: the engine finds the mark, builds a binary mask over its footprint, and one shared, swappable fill inpaints that region. Choose the fill with `--backend`: `cv2` (classical inpaint, no deps, the floor), `migan` (MI-GAN, light, the memory-tight pick where LaMa will not fit), or `lama` (big-LaMa, best quality, heavier, auto-preferred when a learned backend is available); the default `auto` uses LaMa > MI-GAN > cv2, best available. The localizer is cheap CPU (cv2/numpy), so it runs anywhere; the heavier MI-GAN/LaMa fill is opt-in. Detection keys on each mark's own shape (NCC against a captured or synthetic silhouette; the alpha captures rebuilt by `scripts/visible_alpha_solve.py` and synthetic assets from `scripts/render_vendor_silhouettes.py` are used for detection, not pixel recovery). The visual detector needs no metadata, but a borderline (faint or moved) mark is only trusted with corroboration: `--sensitivity` (default `auto`) relaxes a mark's gate when local metadata confirms the vendor or a same-product sibling mark is found; `strict` never relaxes. There is deliberately no "assume this is AI" mode: asserting that an image is AI says nothing about *which* vendor made it or *where* the mark is, which is exactly what a gate bypass needs. If you can SEE a mark the detector missed, point at it with `erase --region x,y,w,h`, or force a known text mark by name with `--mark <name> --no-detect` -- both act on what you actually see instead of relaxing every detector at once. `visible --mark auto` finds and removes every detected mark in one pass. Fast, offline, no GPU. (For arbitrary logos/objects, see `erase`.)
 - **Universal region eraser (`erase`)** — remove any logo / watermark / object inside boxes you specify, regardless of position or color. Default cv2 inpainting (CPU, instant); optional big-LaMa via onnxruntime (`lama` extra) for higher quality
 - **Invisible watermark removal** — SynthID, StableSignature, TreeRing via diffusion-based regeneration (needs a local GPU, or run it with no setup on [raiw.cc](https://raiw.cc))
 - **AI metadata stripping** — EXIF, PNG text chunks, C2PA provenance manifests (PNG / JPEG / AVIF / HEIF / JPEG-XL, **MP4 / MOV / M4V / M4A** at the container level, and **WebM / MP3 / WAV / FLAC / OGG** losslessly via ffmpeg), XMP DigitalSourceType
@@ -36,7 +36,7 @@ It does **not** target watermarks that protect someone else's paid or copyrighte
 - **Two SynthID quality tiers** — SDXL with canny ControlNet remains the default because it is much faster, cheaper, and supports CUDA, XPU, MPS, and CPU. It is the compatibility baseline, not the highest-fidelity option: at the denoise strength needed to remove SynthID it can visibly drift face identity and soften or alter fine content. For the best available visual quality, especially on faces and face-heavy scenes, install `pip install "remove-ai-watermarks[qwen-zimage]"` and select `--pipeline qwen-zimage`. This CUDA-only profile ports the two-stage Synthid-Bypass architecture: Qwen-Image-2512 with the 4-step Lightning LoRA and DiffSynth Canny ControlNet regenerates the full image, then YuNet + SAM isolate faces and Z-Image Turbo regenerates the original face crops before a feathered paste. Direct comparison on two official upstream examples measured much higher ArcFace identity than the current ControlNet result, close to the published upstream output. On July 25, 2026, all six current outputs from the full `visible -> qwen-zimage -> metadata` candidate were checked in provider-separated groups with the corresponding OpenAI and Gemini oracles; none retained the provider watermark signal. This supports the high-quality recommendation for those exact outputs, but is not broad certification across seeds, resolutions, and content classes. The tradeoff is substantial: `qwen-zimage` uses a large model stack, costs much more, runs only on CUDA, does not support a custom `--model`, and can still degrade very small text. It supports `--tile` for the global Qwen pass; after the tiles are blended, face detection and Z-Image restoration run once on the full frame. Tiled outputs require separate oracle validation because the seed-0 certification covers only the exact non-tiled candidate bytes. YuNet replaces the reference workflow's YOLO detector to avoid an AGPL runtime dependency.
 - **Batch processing** — process entire directories
 - **Detection** — three-stage NCC watermark detection with confidence scoring
-- **Provenance detection (`identify`)** — aggregate C2PA issuer, the C2PA soft-binding forensic-watermark vendor (Adobe TrustMark, Digimarc, Imatag, ...), IPTC "Made with AI" plus the IPTC 2025.1 `AISystemUsed` field, embedded SD/ComfyUI params, EXIF/XMP generator tags, the xAI/Grok EXIF signature, the China TC260 AIGC label (XMP, PNG chunk, EXIF, or JPEG segment), the HuggingFace `hf-job-id` job marker, the SynthID metadata proxy, the C2PA cloud-manifest reference (Adobe Durable Content Credentials, when the embedded manifest is stripped), the visible marks (Gemini sparkle plus the Doubao "豆包AI生成" / Jimeng "即梦AI" / Qwen "千问AI生成" / Kling "可灵AI 3.0" / Baidu "百度 AI生成" / LibLibAI / RunningHub "RunningHub AI生成" / Samsung Galaxy AI "Contenuti generati dall'AI" text marks), the open SD/SDXL/FLUX invisible watermark, and (with the `trustmark` extra) the open Adobe TrustMark watermark into one origin-platform + watermark-inventory verdict (`--json` for machine output)
+- **Provenance detection (`identify`)** — aggregate C2PA issuer, the C2PA soft-binding forensic-watermark vendor (Adobe TrustMark, Digimarc, Imatag, ...), IPTC "Made with AI" plus the IPTC 2025.1 `AISystemUsed` field, embedded SD/ComfyUI params, EXIF/XMP generator tags, the xAI/Grok EXIF signature, the China TC260 AIGC label (XMP, PNG chunk, EXIF, or JPEG segment), the HuggingFace `hf-job-id` job marker, the SynthID metadata proxy, the C2PA cloud-manifest reference (Adobe Durable Content Credentials, when the embedded manifest is stripped), the visible marks (Gemini sparkle plus the Doubao "豆包AI生成" / Jimeng "即梦AI" / Qwen "千问AI生成" / Kling "可灵AI 3.0" / Tencent Yuanbao "元宝 / AI生成" / Baidu "百度 AI生成" / LibLibAI / RunningHub "RunningHub AI生成" / Samsung Galaxy AI "Contenuti generati dall'AI" text marks), the open SD/SDXL/FLUX invisible watermark, and (with the `trustmark` extra) the open Adobe TrustMark watermark into one origin-platform + watermark-inventory verdict (`--json` for machine output)
 
 ## Examples
 
@@ -78,6 +78,7 @@ signal. Click an image to inspect it at full resolution.
 | **Jimeng / Dreamina** (即梦AI, ByteDance) | ✅ "★ 即梦AI" wordmark (bottom-right) | — | ✅ TC260 AIGC label + C2PA (Volcano Engine) | Localize glyph footprint + fill + metadata strip |
 | **Qwen / Tongyi Qianwen** (千问, Alibaba) | ✅ "千问AI生成" text strip (bottom-right) | — | ✅ TC260 AIGC label | Localize glyph footprint + fill + metadata strip |
 | **Kling** (可灵, Kuaishou) | ✅ "可灵AI 3.0" text strip (bottom-right) | — | ✅ TC260 AIGC label | Localize glyph footprint + fill + metadata strip |
+| **Yuanbao** (元宝, Tencent) | ✅ two-line "元宝 / AI生成" mark (bottom-right) | — | ✅ TC260 AIGC label, including Tencent Cloud's service-provider schema | Polarity-independent local contrast + fill + metadata strip |
 | **Baidu** | ✅ "百度 AI生成" text + tag (bottom-right) | — | ✅ TC260 AIGC label | Localize glyph footprint + fill + metadata strip |
 | **LibLibAI** (哩布哩布AI) | ✅ "LibLibAI" wordmark (bottom-center) | — | ✅ TC260 AIGC label | Localize glyph footprint + fill + metadata strip |
 | **RunningHub** | ✅ "RunningHub AI生成" text (top-left) | — | ✅ TC260 AIGC label | Localize glyph footprint + fill + metadata strip |
@@ -86,9 +87,9 @@ signal. Click an image to inspect it at full resolution.
 | **StableSignature** (Meta) | — | ✅ In-model watermark | — | Diffusion regeneration |
 | **TreeRing** | — | ✅ Latent space watermark | — | Diffusion regeneration |
 
-> Visible overlays are used by Google Gemini / Nano Banana (sparkle logo), by ByteDance's Doubao ("豆包AI生成" corner text) and Jimeng / Dreamina ("★ 即梦AI" wordmark), by Alibaba's Qwen / Tongyi Qianwen ("千问AI生成" corner text), by Kuaishou's Kling ("可灵AI 3.0" corner text), by Baidu ("百度 AI生成" text + tag), by LibLibAI ("LibLibAI" wordmark, bottom-center), by RunningHub ("RunningHub AI生成", top-left), and by Samsung Galaxy AI ("✦ Contenuti generati dall'AI" strip, bottom-left, locale-specific). All are removed by localizing the mark to a footprint mask and inpainting it with one shared fill (cv2 by default, MI-GAN or big-LaMa via `--backend`); the localizer is CPU-cheap and the heavier fills are opt-in. Other services rely on invisible watermarks and/or metadata; our diffusion-based regeneration works against any invisible watermark in pixel or frequency domain. For a visible mark from any other source (any position, any color), use the universal `erase --region` command.
+> Visible overlays are used by Google Gemini / Nano Banana (sparkle logo), by ByteDance's Doubao ("豆包AI生成" corner text) and Jimeng / Dreamina ("★ 即梦AI" wordmark), by Alibaba's Qwen / Tongyi Qianwen ("千问AI生成" corner text), by Kuaishou's Kling ("可灵AI 3.0" corner text), by Tencent Yuanbao (two-line "元宝 / AI生成" mark), by Baidu ("百度 AI生成" text + tag), by LibLibAI ("LibLibAI" wordmark, bottom-center), by RunningHub ("RunningHub AI生成", top-left), and by Samsung Galaxy AI ("✦ Contenuti generati dall'AI" strip, bottom-left, locale-specific). All are removed by localizing the mark to a footprint mask and inpainting it with one shared fill (cv2 by default, MI-GAN or big-LaMa via `--backend`); the localizer is CPU-cheap and the heavier fills are opt-in. Other services rely on invisible watermarks and/or metadata; our diffusion-based regeneration works against any invisible watermark in pixel or frequency domain. For a visible mark from any other source (any position, any color), use the universal `erase --region` command.
 
-> **Detection:** `remove-ai-watermarks identify <image>` reports the origin platform and watermark inventory for all the signals above — C2PA issuer, the C2PA soft-binding forensic-watermark vendor (TrustMark / Digimarc / Imatag / ...), IPTC "Made with AI" plus the IPTC 2025.1 `AISystemUsed` field, the China TC260 AIGC label (XMP, PNG chunk, EXIF, or JPEG segment), the HuggingFace `hf-job-id` job marker, embedded generation params, EXIF/XMP generator tags, the xAI/Grok EXIF signature, the SynthID metadata proxy, the C2PA cloud-manifest reference (Adobe Durable Content Credentials, when the embedded manifest is stripped), the visible marks (Gemini sparkle plus the Doubao "豆包AI生成" / Jimeng "即梦AI" / Qwen "千问AI生成" / Kling "可灵AI 3.0" / Baidu "百度 AI生成" / LibLibAI / RunningHub "RunningHub AI生成" / Samsung Galaxy AI "Contenuti generati dall'AI" text marks), and (with the `[detect]` / `[trustmark]` extras) the open SD/SDXL/FLUX and Adobe TrustMark invisible watermarks. SynthID and the proprietary soft-binding watermarks (Digimarc etc.) have no local decoder, so they are reported by metadata proxy / vendor name only.
+> **Detection:** `remove-ai-watermarks identify <image>` reports the origin platform and watermark inventory for all the signals above — C2PA issuer, the C2PA soft-binding forensic-watermark vendor (TrustMark / Digimarc / Imatag / ...), IPTC "Made with AI" plus the IPTC 2025.1 `AISystemUsed` field, the China TC260 AIGC label (XMP, PNG chunk, EXIF, or JPEG segment), the HuggingFace `hf-job-id` job marker, embedded generation params, EXIF/XMP generator tags, the xAI/Grok EXIF signature, the SynthID metadata proxy, the C2PA cloud-manifest reference (Adobe Durable Content Credentials, when the embedded manifest is stripped), the visible marks (Gemini sparkle plus the Doubao "豆包AI生成" / Jimeng "即梦AI" / Qwen "千问AI生成" / Kling "可灵AI 3.0" / Tencent Yuanbao "元宝 / AI生成" / Baidu "百度 AI生成" / LibLibAI / RunningHub "RunningHub AI生成" / Samsung Galaxy AI "Contenuti generati dall'AI" text marks), and (with the `[detect]` / `[trustmark]` extras) the open SD/SDXL/FLUX and Adobe TrustMark invisible watermarks. SynthID and the proprietary soft-binding watermarks (Digimarc etc.) have no local decoder, so they are reported by metadata proxy / vendor name only.
 
 ## How it works
 
@@ -366,10 +367,11 @@ remove-ai-watermarks identify image.png
 
 # Visible watermark only — fast, offline, CPU. --mark auto (default) removes every
 # detected known mark (Gemini sparkle / Doubao "豆包AI生成" / Jimeng "即梦AI" /
-# Qwen "千问AI生成" / Kling "可灵AI 3.0" / Baidu "百度 AI生成" / LibLibAI /
+# Qwen "千问AI生成" / Kling "可灵AI 3.0" / Tencent Yuanbao "元宝 / AI生成" /
+# Baidu "百度 AI生成" / LibLibAI /
 # RunningHub "RunningHub AI生成" / Samsung Galaxy AI "Contenuti generati dall'AI");
-# force one with --mark gemini / doubao / jimeng / qwen / kling / baidu / liblib /
-# runninghub / samsung. Removal localizes each mark to a
+# force one with --mark gemini / doubao / jimeng / qwen / kling / yuanbao / baidu /
+# liblib / runninghub / samsung. Removal localizes each mark to a
 # footprint mask and inpaints it with a shared fill; --backend auto|cv2|migan|lama
 # (default auto) picks the fill (auto = LaMa > MI-GAN > cv2, best available).
 # --sensitivity auto|strict (default auto) sets how hard a borderline mark is
@@ -438,7 +440,7 @@ remove-ai-watermarks batch ./images/ --mode all
 
 ### Python API
 
-One high-level call removes every detected visible mark (Gemini sparkle, Doubao / Jimeng / Qwen / Samsung text, the Jimeng pill) by localize then fill. For a file it reads metadata provenance automatically and preserves the alpha channel; `import remove_ai_watermarks` stays cheap (the heavy deps load lazily on first use).
+One high-level call removes every detected visible mark (Gemini sparkle, the registered vendor text marks including Tencent Yuanbao, and the Jimeng pill) by localize then fill. For a file it reads metadata provenance automatically and preserves the alpha channel; `import remove_ai_watermarks` stays cheap (the heavy deps load lazily on first use).
 
 ```python
 import remove_ai_watermarks as raiw

docs/module-internals.md

@@ -25,11 +25,11 @@ module.
 
 ## `identify.py`
 
-`identify.py` — the OpenAI rollout caveat is keyed on `_vendor_of(synthid) == "OpenAI"` (not a raw substring over the issuer + verdict blob). `identify(path)` aggregates every locally-readable signal (C2PA issuer→platform, C2PA soft-binding forensic-watermark vendor, **C2PA cloud-manifest reference** via `metadata.c2pa_cloud_manifest` — signal `c2pa_cloud`, **medium**, provenance-only (does NOT set `is_ai`, excluded from `ai_from_metadata` + clash vendors): a C2PA 2.4 Durable-Content-Credentials case where the embedded manifest is stripped but an XMP `dcterms:provenance` pointer to the vendor's cloud manifest store (`_C2PA_MANIFEST_REPOSITORIES`, today `cai-manifests.adobe.com` → "Adobe Content Authenticity") survives, so the credentials stay recoverable server-side; only emitted when no embedded manifest already attributed the file — surfaced on 2 corpus PNGs 2026-06-10 that read fully `unknown` before, IPTC "Made with AI" + IPTC 2025.1 `AISystemUsed`, embedded SD/ComfyUI params, SynthID proxy, xAI/Grok EXIF signature via `metadata.xai_signature`, the China TC260 AIGC label via `metadata.aigc_label`, the HuggingFace `hf-job-id` job marker via `metadata.huggingface_job`, the Samsung Galaxy AI editing marker via `metadata.samsung_genai`, the visible marks — Gemini sparkle plus the ByteDance Doubao 豆包AI生成 / Jimeng 即梦AI / Samsung Galaxy AI "Contenuti generati dall'AI" text marks via the `watermark_registry` — open invisible watermark, Adobe TrustMark via `trustmark_detector`) into one `ProvenanceReport`. `is_ai_generated` is True or None (never asserted False — stripped metadata is not proof of clean origin). The `hf_job`, visible-mark, and Samsung `samsung_genai` signals are **medium** confidence: each lifts an otherwise-Unknown verdict to a tentative AI (`hf_only` / `visible_only` / `samsung_only`, parallel branches; `visible_only` fires on any `visible_*` signal) but is excluded from the high-confidence `ai_from_metadata` set, so none overrides a hard metadata signal.
+`identify.py` — the OpenAI rollout caveat is keyed on `_vendor_of(synthid) == "OpenAI"` (not a raw substring over the issuer + verdict blob). `identify(path)` aggregates every locally-readable signal (C2PA issuer→platform, C2PA soft-binding forensic-watermark vendor, **C2PA cloud-manifest reference** via `metadata.c2pa_cloud_manifest` — signal `c2pa_cloud`, **medium**, provenance-only (does NOT set `is_ai`, excluded from `ai_from_metadata` + clash vendors): a C2PA 2.4 Durable-Content-Credentials case where the embedded manifest is stripped but an XMP `dcterms:provenance` pointer to the vendor's cloud manifest store (`_C2PA_MANIFEST_REPOSITORIES`, today `cai-manifests.adobe.com` → "Adobe Content Authenticity") survives, so the credentials stay recoverable server-side; only emitted when no embedded manifest already attributed the file — surfaced on 2 corpus PNGs 2026-06-10 that read fully `unknown` before, IPTC "Made with AI" + IPTC 2025.1 `AISystemUsed`, embedded SD/ComfyUI params, SynthID proxy, xAI/Grok EXIF signature via `metadata.xai_signature`, the China TC260 AIGC label via `metadata.aigc_label`, the HuggingFace `hf-job-id` job marker via `metadata.huggingface_job`, the Samsung Galaxy AI editing marker via `metadata.samsung_genai`, the visible marks — Gemini sparkle plus the registered vendor marks, including Tencent Yuanbao 元宝 / AI生成 and Samsung Galaxy AI "Contenuti generati dall'AI" text marks via the `watermark_registry` — open invisible watermark, Adobe TrustMark via `trustmark_detector`) into one `ProvenanceReport`. `is_ai_generated` is True or None (never asserted False — stripped metadata is not proof of clean origin). The `hf_job`, visible-mark, and Samsung `samsung_genai` signals are **medium** confidence: each lifts an otherwise-Unknown verdict to a tentative AI (`hf_only` / `visible_only` / `samsung_only`, parallel branches; `visible_only` fires on any `visible_*` signal) but is excluded from the high-confidence `ai_from_metadata` set, so none overrides a hard metadata signal.
 
 **AI-generated vs AI-enhanced** (`ProvenanceReport.ai_source_kind`, roadmap item): the C2PA digital-source-type is split into `"generated"` (trainedAlgorithmicMedia, fully synthetic) vs `"enhanced"` (compositeWithTrainedAlgorithmicMedia, a real photo with an AI-composited region) — the two byte strings are unambiguous (`compositeWithTrainedAlgorithmicMedia` capitalizes the inner "Trained", so a lowercase `trainedAlgorithmicMedia` match is standalone full generation; full generation wins when both appear). `ai_source_kind` is set only when the AI verdict actually came from the C2PA source type (a non-C2PA AI signal — IPTC/AIGC/local gen/xAI — leaves it None). It lets a caller branch a full-frame scrub (`generated`) from a region-targeted clean that preserves the real photo (`enhanced`; see `noai/tiling.feather_region_composite`). The CLI verdict line reads "AI-generated (fully synthetic)" vs "AI-enhanced (real content with an AI-composited region)".
 
-**Visible-mark detection** (`check_visible`, signals `visible_sparkle` / `visible_doubao` / `visible_jimeng` / `visible_qwen` / `visible_samsung`): the Gemini sparkle keeps its own file-level path (`_visible_sparkle` → `gemini_engine.detect_sparkle_confidence`, promoted only at confidence ≥ `_SPARKLE_THRESHOLD`, which is the SHARED `watermark_registry.GEMINI_SPARKLE_TRUST_CONF` (0.5) — imported, not a private copy, so the provenance detect threshold and the removal `detect_marks` / `_gemini_detect` arbitration gate can never drift (the detect-vs-remove desync from roadmap P0#7; regression-guarded by `tests/test_identify.py::TestSparkleDetectRemoveAlignment`, which composites the real demo sparkle at borderline opacities and asserts identify and `detect_marks` AGREE on either side of the line). Lowering the gate to recover faint sub-0.5 sparkles was evaluated 2026-06-20 and REJECTED: a real Doubao text mark scores ~0.40-0.42 as a gemini match with a HIGHER core-ring brightness margin than a genuine faint sparkle, so neither confidence nor the brightness gate separates them in the [0.35, 0.5) band — lowering trades a rare miss for false-positive removals on clean images. Corpus-tuned to separate Gemini sparkles ≥0.56 from non-sparkle ≤0.49), while Doubao/Jimeng/Qwen/Samsung reuse the registry detectors (`_visible_text_marks` → `watermark_registry`, iterating `_VISIBLE_MARK_PLATFORM`), each gated by its own engine NCC threshold via `MarkDetection.detected` (Doubao 0.50, Jimeng 0.45, Qwen 0.45, Samsung 0.40). Doubao/Jimeng are normally also caught by the TC260 AIGC metadata label and Samsung by its C2PA + `genAIType` marker, so the visible path is their stripped-metadata fallback. Visible marks set `platform` only when no harder signal already did, and (like the sparkle) are excluded from integrity-clash vendor claims. The cv2 dependency lives in the engines, not here.
+**Visible-mark detection** (`check_visible`, signals `visible_sparkle` plus `visible_<registry-key>` for every registered vendor mark): the Gemini sparkle keeps its own file-level path (`_visible_sparkle` → `gemini_engine.detect_sparkle_confidence`, promoted only at confidence ≥ `_SPARKLE_THRESHOLD`, which is the SHARED `watermark_registry.GEMINI_SPARKLE_TRUST_CONF` (0.5) — imported, not a private copy, so the provenance detect threshold and the removal `detect_marks` / `_gemini_detect` arbitration gate can never drift (the detect-vs-remove desync from roadmap P0#7; regression-guarded by `tests/test_identify.py::TestSparkleDetectRemoveAlignment`, which composites the real demo sparkle at borderline opacities and asserts identify and `detect_marks` AGREE on either side of the line). Lowering the gate to recover faint sub-0.5 sparkles was evaluated 2026-06-20 and REJECTED: a real Doubao text mark scores ~0.40-0.42 as a gemini match with a HIGHER core-ring brightness margin than a genuine faint sparkle, so neither confidence nor the brightness gate separates them in the [0.35, 0.5) band — lowering trades a rare miss for false-positive removals on clean images. Corpus-tuned to separate Gemini sparkles ≥0.56 from non-sparkle ≤0.49), while all registered vendor marks reuse the registry detectors (`_visible_text_marks` → `watermark_registry`, iterating `_VISIBLE_MARK_PLATFORM`), each gated by its own calibrated engine threshold via `MarkDetection.detected`. Doubao/Jimeng are normally also caught by the TC260 AIGC metadata label and Samsung by its C2PA + `genAIType` marker, so the visible path is their stripped-metadata fallback. Visible marks set `platform` only when no harder signal already did, and (like the sparkle) are excluded from integrity-clash vendor claims. The cv2 dependency lives in the engines, not here.
 
 **`import identify` is deliberately light** (~26 MB; ~36 MB with cv2 loaded by a visible-mark run, ~106 MB for a full `check_visible` run): it imports the `noai.c2pa`/`noai.constants` submodules, and `noai/__init__` is lazy (see "Test and lint"), so torch/diffusers are NOT pulled at import even in a full `gpu`/`detect` install — fits a 512 MB host. `noai.c2pa` does eagerly import the **c2pa-python** binary (Rust + cryptography, ~+5 MB RSS, no torch) for the primary `Reader` path — light enough to stay on the dependency-light host; a broken/absent wheel degrades to the byte-scan parser (`reader_available()` False). The heavy paths are opt-in: `check_invisible=True` needs the `detect`/`trustmark` extras (each pulls **torch**; TrustMark also **downloads weights**), so on a core-only deploy leave `check_invisible` off (it is a no-op there anyway). Before the lazy `__init__`, the mere presence of torch in the env inflated `import identify` to ~420 MB.
 
@@ -61,7 +61,7 @@ module.
 
 `watermark_registry.py` — **single catalog of known visible watermarks**, the unified "find known marks in their usual places, recognize, remove" entry.
 
-**Localize -> fill by policy (replaced reverse-alpha):** each mark is localized to a binary full-frame footprint mask (a `Localization`), and one shared, swappable fill inpaints that mask via `fill(image, mask, backend=...)` (delegates to `region_eraser.erase`). This replaced the old reverse-alpha removal (invert a captured alpha map, `original = (wm - a*logo)/(1-a)`, plus a thin residual inpaint) for ALL marks — gemini, doubao, jimeng, samsung, and jimeng_pill. **Why it changed:** reverse-alpha depended on a fixed captured alpha map at a fixed position, so it broke whenever a vendor moved or re-rendered its mark; and it was not color-lossless even with the right map (it amplifies 8-bit quantization and JPEG-chroma error by `1/(1-a)`), which showed up as "the color just changed, not removed" reports. Localize -> fill has a benign failure mode: a slightly-off localization just inpaints a small region near-losslessly instead of leaving a color-shifted smear. The captured alpha maps are still used to DETECT the marks and to shape the mask (gemini's footprint), but NOT for pixel recovery. Fill backends: `cv2` (classical inpaint, no deps, the floor), `migan` (MI-GAN ONNX, light, the memory-tight pick where LaMa will not fit), `lama` (big-LaMa ONNX, best quality, heavier, auto-preferred when a learned backend is available); `auto` = LaMa > MI-GAN > cv2, best available. Each `KnownMark` ties a key to {usual `location`, `in_auto` flag, a `_detect` callable → uniform `MarkDetection`, a `_mask` callable → full-frame footprint mask}; `KnownMark.remove(image, *, backend="auto", provenance=False, force=False)`. Entries today: `gemini` (bottom-right sparkle), `doubao` (bottom-right "豆包AI生成"), `jimeng` (bottom-right "★ 即梦AI"), `qwen` (bottom-right "千问AI生成", Alibaba Tongyi Qianwen), `samsung` (bottom-**LEFT** "✦ Contenuti generati dall'AI", Samsung Galaxy AI, Italian locale), and the capture-less `jimeng_pill` (top-left "AI生成"). `detect_marks(image, *, provenance=frozenset())` scans all (strict, for the identify verdict); `remove_auto_marks(image, *, sensitivity="auto", provenance=frozenset(), backend="auto")` removes every detected mark in one pass. **Sensitivity (`auto`/`strict`/`assume_ai`)** decides how hard a borderline mark is trusted: the visual detectors are pixel-based (no metadata needed) and the recall gain comes from relaxing the false-positive gate, not from metadata. `resolve_trust` turns the policy + evidence into the per-mark trust level the engines consume as `provenance = level != "strict"` — `strict` never relaxes; `auto` relaxes only on same-product evidence (metadata provenance for that vendor, or a confidently strict-detected sibling of the same `_PRODUCT_OF` — Doubao and Jimeng are both bottom-right ByteDance but distinct products, so they do NOT cross-relax); `assume_ai` relaxes every mark (the caller asserts AI, e.g. a metadata-stripped screenshot). **Three levels, not two: `strict` / `assumed` / `confirmed`.** Relaxing bypasses the engine's false-positive gate outright, and that bypass is contracted to mean the vendor is CONFIRMED (`GeminiEngine.detect_watermark`'s `trust_provenance`: "external metadata already proves this is a Google generation"). An `assume_ai` caller asserts the image is AI, which says nothing about WHICH vendor, so a mark relaxed on assumption alone must also clear `_ASSUMED_CONF_FLOOR` (`assumed_floor_ok`; gemini 0.50) — see "Assumed-trust confidence floor" below. **Perception / decision / action are separated three ways** (the removal path only; `identify` keeps calling `KnownMark.detect` directly, so its verdict is untouched): `_build_candidates(image)` is PERCEPTION — it runs each detector at both trust levels and packages raw verdicts + the pill's flatness feature into `Candidate`s, no policy; `decide(candidates, Context(sensitivity, provenance)) -> [Decision]` is the pure DECISION arbiter — all keep/drop policy (`resolve_trust` cross-mark corroboration + the assumed-trust floor + the pill gate) in one image-free, unit-testable function (`tests/test_watermark_registry.py::TestArbiter`); then `remove_auto_marks` does the ACTION, localizing -> filling each winner. The Gemini FP gate deliberately stays inside `gemini_engine` (not the arbiter) because `identify` reads that same gated confidence — pulling it out would drift the provenance verdict. Behavior was byte-identical to the pre-arbiter two-pass when the arbiter landed; `assume_ai` has since gained the assumed-trust confidence floor (see below), which deliberately changes its verdict on weak gate-bypassed matches.
+**Localize -> fill by policy (replaced reverse-alpha):** each mark is localized to a binary full-frame footprint mask (a `Localization`), and one shared, swappable fill inpaints that mask via `fill(image, mask, backend=...)` (delegates to `region_eraser.erase`). This replaced the old reverse-alpha removal (invert a captured alpha map, `original = (wm - a*logo)/(1-a)`, plus a thin residual inpaint) for ALL marks — all registered marks, including Yuanbao. **Why it changed:** reverse-alpha depended on a fixed captured alpha map at a fixed position, so it broke whenever a vendor moved or re-rendered its mark; and it was not color-lossless even with the right map (it amplifies 8-bit quantization and JPEG-chroma error by `1/(1-a)`), which showed up as "the color just changed, not removed" reports. Localize -> fill has a benign failure mode: a slightly-off localization just inpaints a small region near-losslessly instead of leaving a color-shifted smear. The captured alpha maps are still used to DETECT the marks and to shape the mask (gemini's footprint), but NOT for pixel recovery. Fill backends: `cv2` (classical inpaint, no deps, the floor), `migan` (MI-GAN ONNX, light, the memory-tight pick where LaMa will not fit), `lama` (big-LaMa ONNX, best quality, heavier, auto-preferred when a learned backend is available); `auto` = LaMa > MI-GAN > cv2, best available. Each `KnownMark` ties a key to {usual `location`, `in_auto` flag, a `_detect` callable → uniform `MarkDetection`, a `_mask` callable → full-frame footprint mask}; `KnownMark.remove(image, *, backend="auto", provenance=False, force=False)`. Entries today include `gemini` (bottom-right sparkle), `doubao` (bottom-right "豆包AI生成"), `jimeng` (bottom-right "★ 即梦AI"), `qwen` (bottom-right "千问AI生成", Alibaba Tongyi Qianwen), `yuanbao` (bottom-right two-line "元宝 / AI生成", Tencent), `samsung` (bottom-**LEFT** "✦ Contenuti generati dall'AI", Samsung Galaxy AI, Italian locale), and the capture-less `jimeng_pill` (top-left "AI生成"). `detect_marks(image, *, provenance=frozenset())` scans all (strict, for the identify verdict); `remove_auto_marks(image, *, sensitivity="auto", provenance=frozenset(), backend="auto")` removes every detected mark in one pass. **Sensitivity (`auto`/`strict`/`assume_ai`)** decides how hard a borderline mark is trusted: the visual detectors are pixel-based (no metadata needed) and the recall gain comes from relaxing the false-positive gate, not from metadata. `resolve_trust` turns the policy + evidence into the per-mark trust level the engines consume as `provenance = level != "strict"` — `strict` never relaxes; `auto` relaxes only on same-product evidence (metadata provenance for that vendor, or a confidently strict-detected sibling of the same `_PRODUCT_OF` — Doubao and Jimeng are both bottom-right ByteDance but distinct products, so they do NOT cross-relax); `assume_ai` relaxes every mark (the caller asserts AI, e.g. a metadata-stripped screenshot). **Three levels, not two: `strict` / `assumed` / `confirmed`.** Relaxing bypasses the engine's false-positive gate outright, and that bypass is contracted to mean the vendor is CONFIRMED (`GeminiEngine.detect_watermark`'s `trust_provenance`: "external metadata already proves this is a Google generation"). An `assume_ai` caller asserts the image is AI, which says nothing about WHICH vendor, so a mark relaxed on assumption alone must also clear `_ASSUMED_CONF_FLOOR` (`assumed_floor_ok`; gemini 0.50) — see "Assumed-trust confidence floor" below. **Perception / decision / action are separated three ways** (the removal path only; `identify` keeps calling `KnownMark.detect` directly, so its verdict is untouched): `_build_candidates(image)` is PERCEPTION — it runs each detector at both trust levels and packages raw verdicts + the pill's flatness feature into `Candidate`s, no policy; `decide(candidates, Context(sensitivity, provenance)) -> [Decision]` is the pure DECISION arbiter — all keep/drop policy (`resolve_trust` cross-mark corroboration + the assumed-trust floor + the pill gate) in one image-free, unit-testable function (`tests/test_watermark_registry.py::TestArbiter`); then `remove_auto_marks` does the ACTION, localizing -> filling each winner. The Gemini FP gate deliberately stays inside `gemini_engine` (not the arbiter) because `identify` reads that same gated confidence — pulling it out would drift the provenance verdict. Behavior was byte-identical to the pre-arbiter two-pass when the arbiter landed; `assume_ai` has since gained the assumed-trust confidence floor (see below), which deliberately changes its verdict on weak gate-bypassed matches.
 
 **Head-to-head validation (v0.12.1 reverse-alpha vs the current localize -> fill):** run over the full labelled visible-mark set, with the cv2 / MI-GAN / LaMa fills each compared against the old reverse-alpha. **doubao and jimeng are identical** across every backend -- 100% coverage and 100% clearance either way. **gemini** strict coverage is a few points below reverse-alpha's (the deliberate false-positive tightening), but the metadata-stripped faint ones are now mostly recovered by the DEFAULT white-core rescue in the FP gate (`gemini_engine`: a bright near-WHITE core distinguishes a real faint sparkle from a colored bright corner -- ~14/20 recovered at ~1.25% clean false-fire; a learned classifier on the same features measured worse, 2026-07 tier-1), the residual under `assume_ai`; clearance is equal (~98% both), and neither version touches pixels outside the mark box (outside-box PSNR ~99). **Clearance is fill-independent** -- cv2, MI-GAN and LaMa all strip the mark's shape equally, so the re-detect metric does not separate them; the difference is purely the *visual fill quality* on the recovered region, and it is background-dependent. reverse-alpha recovered textured and especially regular/structured backgrounds (a lattice, a grid) more cleanly than any inpaint; **LaMa closes most of that gap** (the best learned backend), **MI-GAN can ghost or hallucinate structure**, and **cv2 smears** (the last-resort floor). This is why `auto` resolves `LaMa > MI-GAN > cv2` (`preferred_inpaint_backend`) and warns once on the cv2 fallback; on flat backgrounds every backend is clean.
 
@@ -215,12 +215,14 @@ The cost (mislabel ~8-33% of non-Gemini content as Gemini) outweighs the benefit
 
 ## `_text_mark_engine.py`
 
-`_text_mark_engine.py` — **shared base for the three text-mark engines (Doubao/Jimeng/Samsung), extracted 2026-06-09** (they were ~90% byte-identical clones). `TextMarkEngine(config: TextMarkConfig)` owns the `locate → extract_mask → detect` detection pipeline plus the removal that localizes the glyph blob to a footprint mask and hands it to the shared `watermark_registry.fill` (+ the asset-keyed `load_alpha_template`/`glyph_silhouette`/`template_match_score` caches). Detection still matches the glyph silhouette (NCC against the captured template); the removal MASK is TEMPLATE-FREE — it is the bounding box of the top-hat glyph blob from `extract_mask`, filled solid + dilated, so a re-rendered or differently-placed mark is still masked. This dropped the fixed alpha-template placement; the captured alpha maps are now used only for the detection silhouette, not for removal. Each engine module is a thin subclass supplying only its `TextMarkConfig` (the tuned constants, the bundled asset, and the bounded structural deltas — `corner` br/bl, `margin_floor` 4/2, `morph_open_size` 5/3, `min_gw` 8/16, and since 2026-07-21 `ladder` — the scale rungs `_tophat_best` sweeps, per-mark because 千问's two size modes do not fit the shared 3-rung comb (default `(0.8, 1.0, 1.25)`, unchanged for every other mark; densifying the SHARED ladder was measured and rejected -- see the verification plan's B2). plus the test-facing module shims (`_alpha_template`/`_glyph_silhouette`/`_template_match_score` + the constants). Gemini stays a SEPARATE engine (its multi-size fixed-slot sparkle model is genuinely different). Add a new text mark = a new `TextMarkConfig` + a thin subclass + one registry `_text_mark(...)` row. The engine bullets below describe each mark's calibration history; the LOGIC lives here. **Small-image detection guard (`_MIN_DETECT_SHORT_SIDE` 200, added 2026-06-26):** `detect` returns not-detected when the image short side is below 200px. Below that the glyph template degrades to the `min_gw` floor (~8px) and `TM_CCOEFF_NORMED` on a few pixels is noise, so an unrelated small geometric shape can spuriously correlate with the CJK silhouette — a 48×48 app-icon chevron scored Doubao 0.41 / Jimeng 0.47 (both above their thresholds), a pure small-size artifact (the same icon upscaled collapses to ~0.06–0.10 NCC at ≥256px). A real AI-generation label is stamped on a full-resolution render (the captured samples are 1086–2048px wide, the smallest positive test image is 1086px), so the floor sits far below any genuine mark while killing the icon/thumbnail band (≤96px); `identify` falls back to "unknown" (the safe default) and removal, gated on detection, is suppressed too. Regression-guarded by `test_{doubao,jimeng,samsung}_engine.py::TestDetect::test_small_image_guarded_from_false_positive`.
+`_text_mark_engine.py` — **shared base for the registered text-mark engines, extracted 2026-06-09** (they were ~90% byte-identical clones). `TextMarkEngine(config: TextMarkConfig)` owns the `locate → extract_mask → detect` detection pipeline plus the removal that localizes the glyph blob to a footprint mask and hands it to the shared `watermark_registry.fill` (+ the asset-keyed `load_alpha_template`/`glyph_silhouette`/`template_match_score` caches). Detection still matches the glyph silhouette (NCC against the captured template); the removal MASK is TEMPLATE-FREE — it is the bounding box of the top-hat glyph blob from `extract_mask`, filled solid + dilated, so a re-rendered or differently-placed mark is still masked. This dropped the fixed alpha-template placement; the captured alpha maps are now used only for the detection silhouette, not for removal. Each engine module is a thin subclass supplying only its `TextMarkConfig` (the tuned constants, the bundled asset, and the bounded structural deltas — `corner` br/bl, `margin_floor` 4/2, `morph_open_size` 5/3, `min_gw` 8/16, and since 2026-07-21 `ladder` — the scale rungs `_tophat_best` sweeps, per-mark because 千问's two size modes do not fit the shared 3-rung comb (default `(0.8, 1.0, 1.25)`, unchanged for every other mark; densifying the SHARED ladder was measured and rejected -- see the verification plan's B2). plus the test-facing module shims (`_alpha_template`/`_glyph_silhouette`/`_template_match_score` + the constants). Gemini stays a SEPARATE engine (its multi-size fixed-slot sparkle model is genuinely different). Add a new text mark = a new `TextMarkConfig` + a thin subclass + one registry `_text_mark(...)` row. The engine bullets below describe each mark's calibration history; the LOGIC lives here. **Small-image detection guard (`_MIN_DETECT_SHORT_SIDE` 200, added 2026-06-26):** `detect` returns not-detected when the image short side is below 200px. Below that the glyph template degrades to the `min_gw` floor (~8px) and `TM_CCOEFF_NORMED` on a few pixels is noise, so an unrelated small geometric shape can spuriously correlate with the CJK silhouette — a 48×48 app-icon chevron scored Doubao 0.41 / Jimeng 0.47 (both above their thresholds), a pure small-size artifact (the same icon upscaled collapses to ~0.06–0.10 NCC at ≥256px). A real AI-generation label is stamped on a full-resolution render (the captured samples are 1086–2048px wide, the smallest positive test image is 1086px), so the floor sits far below any genuine mark while killing the icon/thumbnail band (≤96px); `identify` falls back to "unknown" (the safe default) and removal, gated on detection, is suppressed too. Regression-guarded by `test_{doubao,jimeng,samsung}_engine.py::TestDetect::test_small_image_guarded_from_false_positive`.
 
 **Removal is localize -> fill.** The engine localizes the glyph blob (`extract_mask` over the located box) into a solid, dilated footprint mask and hands it to the shared `watermark_registry.fill` (cv2 / MI-GAN / big-LaMa). The template-free mask (bounding box of the glyph blob, not the fixed alpha template) means a re-rendered or moved mark is still covered, and the fill reconstructs the box from its surroundings. On corpus images doubao and jimeng localize + remove at ~100% with clean footprints (the filled region blends into its surroundings within a few LAB levels, no color shift, no dark pit); clean images with no vendor signature had 0% false removal.
 
 **The reverse-alpha removal machinery is retired.** The old per-glyph reverse-alpha blend (`_apply_reverse_alpha`), the fixed/aligned alpha-map helpers, the over-subtraction guard (`_reverse_alpha_oversubtracts` → `_inpaint_footprint`, the dark-pit fix on dark/mid-tone backgrounds), and the always-align placement search are all gone — the fill reconstructs the footprint from its surroundings rather than inverting the captured alpha, so the dark-pit and color-shift failure modes those guards patched around no longer arise. `extract_mask` still returns a box-sized (`(loc.h, loc.w)`) mask rather than a full frame, which keeps the memory-tight `identify` detect path cheap.
 
+**Polarity-independent contrast front-end (`detect_frontend="contrast"`, 2026-07-25).** Some vendors choose light or dark text from the scene under the mark, so a white top-hat cannot represent both. The contrast response subtracts a local Gaussian luma estimate, takes the absolute residual, suppresses saturated pixels, and max-normalizes before silhouette NCC. One `_contrast_best` method supplies both the score and the winning match box; `footprint_mask` uses that same box after a successful detection, preserving the detector-to-mask parity contract. This mode was added for Tencent Yuanbao and its 0.38 gate is specific to that response. It must not be copied to another front-end or mark without recalibration.
+
 ## `doubao_engine.py`
 
 `doubao_engine.py` — **a thin `_text_mark_engine.TextMarkEngine` subclass (config only) since 2026-06-09.** visible Doubao "豆包AI生成" detector + localizer (cv2/numpy, no GPU). `DoubaoEngine.locate` anchors a bottom-right box by **geometry** (mark scales with image WIDTH), `extract_mask` pulls the light, low-chroma glyphs (the detection candidate) using a per-pixel channel-spread proxy `sat = roi.max(axis=2) - roi.min(axis=2)` (no HSV conversion). `detect` is **shape-consistent**: it matches the bundled glyph silhouette (`assets/doubao_alpha.png`) against the candidate via zero-mean normalized correlation (`_template_match_score`, cv2 `TM_CCOEFF_NORMED`), gated at `DETECT_NCC_THRESHOLD` 0.4 over a small `DETECT_MIN_COVERAGE` floor. Keying on glyph SHAPE (not coverage heuristics) fixed #23 (corpus FP 7/1243).
@@ -271,6 +273,18 @@ The cost (mislabel ~8-33% of non-Gemini content as Gemini) outweighs the benefit
 
 **The clean-arm contamination trap (load-bearing for any future calibration):** the 2026-07-18 `present: []` labels are in the vocabulary of the REGISTERED marks only, so 146 of the 432 "clean" frames sit in a TC260 cohort -- including Qwen-cohort frames visibly carrying 千问AI生成. They made up the clean arm's entire top tail (clean p99 0.37 -> 0.69). `vendor_mark_calibrate.load_sets` now excludes every frame in ANY TC260 cohort from the clean arm; a gate read off the unguarded arm is meaningless.
 
+## `yuanbao_engine.py`
+
+`yuanbao_engine.py` — **thin `TextMarkEngine` subclass, registered 2026-07-25.** Tencent Yuanbao's standard visible mark is a compact italic two-line block, `元宝` over `AI生成`, at the bottom-right. It feeds `identify` as `visible_yuanbao`.
+
+* **The earlier measured negative was invalidated at the renderer.** A negative shear was applied without an x translation, clipping much of the lower `AI生成` line off the left edge while retaining a wide blank tail. The matcher then squeezed that malformed asset into the fitted geometry, so the old "no separation" result measured a renderer bug rather than the mark. `render_vendor_silhouettes.py` now translates before negative shear and tightly crops the result.
+* **Polarity-independent `contrast` front-end:** real Yuanbao frames switch between light-on-dark and dark-on-light stamps. Absolute local-luma residual preserves both forms, while the white top-hat misses the dark one. The synthetic silhouette uses Hiragino Sans GB W6, tight line spacing, a two-pixel dilation, and -0.60 shear.
+* **Measured gate and anchor:** gate **0.38**, STRICT ONLY, plus a bottom-right anchor requiring both margins at most 0.04 of the short side. Across 33 byte-unique cohort frames, 28 carry the standard two-line mark and 26 fire (92.9% recall of that variant). The guarded clean arm is 0/286 fires, maximum score 0.348.
+* **Removal parity:** detect -> cv2 fill -> re-detect is clean on 26/26 detected real marks. The detector's own match box is the footprint, with median full-frame area 0.70% and maximum 0.95%.
+* **Known variant limit:** one frame carries a separate single-line photographer overlay rather than the standard two-line stamp. It stays unregistered because one example cannot support a recall or false-positive calibration.
+
+Regression: `tests/test_yuanbao_engine.py` covers both polarities, the anchor, the footprint, registry wiring, and detector-clean removal. A confident Yuanbao detection suppresses the Jimeng pill because both can occur on TC260-labelled content but Yuanbao is not Jimeng-basic.
+
 ## `runninghub_engine.py`
 
 `runninghub_engine.py` — **thin `TextMarkEngine` subclass, registered 2026-07-22.** RunningHub (hosted ComfyUI platform, USCC 91340100MAEB4N8H76, 73-frame cohort) "RunningHub AI生成" detector + localizer, **top-left** (the first `corner="tl"` mark), faint mid-gray latin+CJK text. Feeds `identify` as `visible_runninghub`.

docs/verification-plan.md

@@ -737,17 +737,20 @@ priority order:
    measurement.
 2. **The two small correctness items** (open defects 3 and 4) -- both are contained, both
    have the fix written out below.
-3. **The bonus vendors from the harvest** (元宝 n=50, 可灵 n=30, cat-logo n=19) repeat
-   the 千问 playbook each: font-rendered silhouette, `--fit-geometry`, gate calibration
-   against the contamination-guarded clean arm, crossfire against doubao/jimeng. 可灵
-   additionally stamps a second mark bottom-LEFT, which no current text-mark config
-   expresses (the pill is top-left; a bottom-left CJK mark needs a `corner="bl"` CJK
-   config -- samsung is `bl` but Latin-script and width-based). 星绘 is NOT in the
-   corpus in labelable quantity -- verified, do not hunt it again. (百度 WAS found
-   later via the USCC cohort harvest and is registered since 2026-07-22 -- see
-   "The 2026-07-22 vendor round" below.)
+3. **The bonus vendors from the harvest** (元宝 n=50, 可灵 n=30, cat-logo n=19)
+   started with the 千问 playbook: font-rendered silhouette, `--fit-geometry`, gate
+   calibration against the contamination-guarded clean arm, and crossfire against
+   doubao/jimeng. 可灵 registered on 2026-07-21; 元宝 registered on 2026-07-25 after
+   correcting a clipped synthetic render and adding polarity-independent local
+   contrast. The cat-logo remains evidence-limited to two byte-unique carriers.
+   可灵 additionally stamps a second mark bottom-LEFT, which no current text-mark
+   config expresses (the pill is top-left; a bottom-left CJK mark needs a
+   `corner="bl"` CJK config -- samsung is `bl` but Latin-script and width-based).
+   星绘 is NOT in the corpus in labelable quantity -- verified, do not hunt it
+   again. (百度 WAS found later via the USCC cohort harvest and is registered since
+   2026-07-22 -- see "The 2026-07-22 vendor round" below.)
 
-   **STATUS 2026-07-21 (same day): 可灵 REGISTERED, 元宝 measured and PARKED.**
+   **STATUS 2026-07-25: 可灵 and 元宝 REGISTERED.**
    * **可灵 (`kling_engine.py`)** -- "可灵AI 3.0" bottom-right, strict-only, gate
      0.35, no rival margin, shared 3-rung ladder (the mark is UNIMODAL at 0.12 of the
      short side). Cohort-vs-clean (286 guarded clean frames): clean p99 0.304 / max
@@ -760,24 +763,18 @@ priority order:
      the jimeng pill exactly like doubao's/qwen's does. The bottom-LEFT `AI生成`
      pill variant was NOT seen in this cohort's contact sheet at registration time
      and stays unhandled.
-   * **元宝 -- MEASURED NEGATIVE, parked.** The mark is a TWO-LINE, italic-slanted
-     block (元宝 over AI生成), ~5% of the short side. After fitting the render
-     against real tophat responses (left-align, tight gap, stroke dilation, shear
-     -0.75 -- which lifted marked frames to 0.65-0.70, at the real-vs-real ceiling
-     ~0.6), the CLEAN arm rose in lockstep (clean p99 0.643 vs cohort p50 0.472):
-     the slanted two-line template correlates with generic corner texture at the
-     same rate it gains on the mark, on BOTH the tophat and binary front-ends, in
-     wide and tight boxes, in three CJK fonts. Every separation metric measured was
-     negative. This is the 2026-07-18 千问-style wall, except it survived the
-     geometry fix: the mark is small + slanted + half-shared-tail, and no synthetic
-     template separates it on this front-end. The residual levers are a structural
-     two-line verification stage or a learned patch classifier -- both outside the
-     cheap playbook. `yuanbao_alpha.png` + its `MARK_OPTS` recipe stay in
-     `render_vendor_silhouettes.py` as the documented starting point if that lever
-     is ever built. Fit-trap found en route (now guarded): `_fit_one`'s tiny-gw NCC
-     inflation -- a sub-30px template scores spuriously high on smooth tophat
-     responses, so the auto-fit picked a degenerate 0.026 width fraction; the
-     numbers above come from a gw-floored re-fit.
+   * **元宝 (`yuanbao_engine.py`) -- REGISTERED 2026-07-25.** The earlier measured
+     negative was invalid because the synthetic renderer applied negative shear
+     without an x translation. That clipped most of the lower `AI生成` line off the
+     left edge and left a wide blank tail, which the matcher then squeezed into the
+     fitted box. The corrected renderer translates before shearing and tightly
+     crops the result. A polarity-independent local-contrast front-end then covers
+     both light-on-dark and dark-on-light stamps. Gate 0.38 plus the measured
+     bottom-right anchor detects 26 of 28 standard two-line marks across 33
+     byte-unique cohort frames (92.9%) and fires on 0 of 286 byte-unique clean
+     controls (clean max 0.348). Detect -> cv2 fill -> re-detect is clean on 26/26.
+     The separate one-line photographer overlay remains unregistered because only
+     one example exists.
    * **cat-logo -- probe READY, parked on evidence.** The cohort (USCC
      91110108562144110X) is 19 frames but only **2 unique carriers** (byte-unique) --
      the xinghui rule (nothing registered off ~one frame) applies. The mark is an
@@ -848,7 +845,8 @@ Parked, both as measured negatives with the silhouette kept in
 * **Zhipu Qingyan (清言·AI生成)** -- 7-frame cohort, white semi-transparent text +
   swirl logo. On both front-ends the cohort scores 0.34-0.39 vs clean max
   0.34-0.37 -- no separation at any render/box setting (text-only and
-  logo-composite templates, two CJK fonts). Same wall class as 元宝.
+  logo-composite templates, two CJK fonts). Unlike the old Yuanbao result, no
+  malformed-render explanation has been found for this overlap.
 * **MiniMax / Hailuo AI** -- only 1 of 6 cohort frames carries a visible mark
   (Hailuo is a video product; the mark is a video-frame stamp). The xinghui rule:
   nothing registered off a single frame.
@@ -963,9 +961,9 @@ meant "no registered mark", not "no mark" -- and a calibration clean arm has to
 re-filtered per candidate, or the gate is read off frames that carry the very mark being
 calibrated.
 
-The bonus vendors (元宝, 可灵, cat-logo) need their own font-rendered silhouettes before
-any of this repeats for them; 可灵 additionally puts a second mark bottom-LEFT, which no
-current text-mark config expresses.
+元宝 and 可灵 now have registered font-rendered silhouettes. The cat-logo still needs
+more than its two byte-unique carriers before registration; 可灵's separate second
+bottom-left mark remains uncovered.
 
 ### Open defects
 
@@ -1058,10 +1056,11 @@ evidence supports:
 2. **Coverage of uncovered vendors is the largest lever.** 千问 was the head of this item
    and is now CLOSED (registered 2026-07-21, see the harvest section above): the blocker
    turned out to be evidence, and the TC260 producer-USCC cohort trick removed it. The
-   remaining named vendors are 元宝 (n=50), 可灵 (n=30) and cat-logo (n=19) -- each needs
-   a font-rendered silhouette, then the same calibrate-and-crossfire chain. `百度` and the
-   星绘/抖音 class are NOT in the corpus in labelable quantity (verified twice; do not
-   hunt them again). Nothing may be registered off a single frame.
+   元宝 and 可灵 are now CLOSED (registered 2026-07-25 and 2026-07-21 respectively).
+   The cat-logo remains blocked by only two byte-unique carriers. `百度` was also
+   registered after a later cohort harvest; the 星绘/抖音 class is NOT in the corpus
+   in labelable quantity (verified twice; do not hunt it again). Nothing may be
+   registered off a single frame.
 3. **A generic shared-tail template is not a shortcut.** `AI生成` is guaranteed across
    compliant vendors by GB 45438-2025, so one template covering all of them is the obvious
    idea -- and measured on the tophat front-end it separates a bold 千问 positive from clean

docs/watermarking-landscape.md

@@ -72,6 +72,8 @@ Two consequences we can exploit: (1) the 5% floor is a **scale prior** -- a comp
 
 **Baidu: RESOLVED 2026-07-22, registered (`baidu_engine.py`).** The mark is a white bold "百度" text run + a separate white rounded tag with dark "AI生成", bottom-right -- settled by the TC260 USCC cohort harvest (16 frames, USCC 91110000802100433B), not by web research. Detection keys on the text run only; details in `docs/module-internals.md`.
 
+**Tencent Yuanbao: RESOLVED 2026-07-25, registered (`yuanbao_engine.py`).** The standard mark is a compact two-line italic `元宝` over `AI生成` block at bottom-right. It switches between light and dark strokes with the scene, so detection uses polarity-independent local contrast rather than a white top-hat. The corrected synthetic silhouette and corpus calibration are recorded in `docs/module-internals.md`; a separate one-line photographer-overlay variant remains evidence-limited to one example.
+
 **Meta `Imagined with AI` (string VERIFIED (a) from Meta's own newsroom; POSITION NOT VERIFIED).** Sources conflict (bottom-left vs bottom-right) and one claims newer Meta models dropped the visible mark for invisible watermarking; none survived a fetch. Do NOT encode a corner without a corpus sample. Meta also embeds IPTC + invisible watermarks, which `identify` already reads. Source: `https://about.fb.com/news/2024/02/labeling-ai-generated-images-on-facebook-instagram-and-threads/`.
 
 **Samsung English/other locales: still not established.** Samsung's own support page says only that "A Galaxy AI watermark will appear on AI-generated images" -- no string, no corner. Every community thread carrying the exact English string returned HTTP 403 to WebFetch, so the search paraphrase (bottom-left) is deliberately NOT recorded as fact. Feature-tier detail (b): the mark is applied by Generative Edit / sketch-to-image but reportedly NOT by Object Eraser, so Samsung absence is feature-dependent. The four-star icon variant: nothing found.

scripts/render_vendor_silhouettes.py

@@ -9,10 +9,8 @@ Covered here:
   qwen     "千问AI生成"  -- Alibaba Tongyi Qianwen, bottom-right, 3-lobed logo + text
   xinghui  "星绘AI生成"  -- ByteDance 星绘, bottom-right, 4-point sparkle + text
   yuanbao  "元宝\nAI生成" -- Tencent Yuanbao, bottom-right, two-line italic block
-           (MEASURED NEGATIVE 2026-07-21, parked: the slanted two-line template does
-           not separate the cohort from clean corners on either front-end; the recipe
-           + MARK_OPTS stay as the starting point if a structural/learned lever is
-           built -- full record in docs/verification-plan.md)
+           (REGISTERED 2026-07-25 after fixing the negative-shear clipping in this
+           renderer and matching both light and dark mark polarities)
   kling    "可灵AI 3.0"  -- Kuaishou Kling, bottom-right, spiral logo + text
            (REGISTERED 2026-07-21, kling_engine.py)
 
@@ -158,11 +156,16 @@ MARKS = {
 
 # Per-mark post-processing for the multi-line / slanted stamps (see render()).
 MARK_OPTS: dict[str, dict[str, Any]] = {
-    # Fitted against real tophat responses on the Yuanbao cohort (2026-07-21): a
-    # right-aligned, gapped, unslanted render plateaued at ~0.34 NCC; left-align +
-    # tight gap + stroke dilation + shear -0.75 reaches 0.65-0.70 on the same frames,
-    # at/above the real-vs-real ceiling (~0.6).
-    "yuanbao_alpha.png": {"gap_frac": 0.05, "dilate": 2, "shear": -0.75},
+    # Re-fitted 2026-07-25 after the old affine transform was found to clip the
+    # lower line and retain a large blank right half. Hiragino Sans GB W6, tight
+    # leading, a 2px dilation, and -0.60 shear match the standard Yuanbao stamp.
+    "yuanbao_alpha.png": {
+        "gap_frac": 0.05,
+        "dilate": 2,
+        "shear": -0.60,
+        "font": "/System/Library/Fonts/Hiragino Sans GB.ttc",
+        "font_index": 2,
+    },
     # Qingyan's real stamp is a heavier weight than STHeiti Medium -- Hiragino
     # Sans GB W6 matches the measured stroke (2026-07-22; with Medium the
     # silhouette aspect came out 0.19 vs the real 0.28 and NCC plateaued ~0.3).
@@ -219,7 +222,16 @@ def render(text: str, width: int = 335, opts: dict[str, Any] | None = None) -> n
             sil = cv2.dilate(sil, np.ones((dilate, dilate), np.uint8))
         if shear_k:
             hh, ww = sil.shape
-            sil = cv2.warpAffine(sil, np.float32([[1, shear_k, 0], [0, 1, 0]]), (ww + int(abs(shear_k) * hh), hh))
+            extra = int(abs(shear_k) * hh)
+            offset = extra if shear_k < 0 else 0
+            sil = cv2.warpAffine(
+                sil,
+                np.float32([[1, shear_k, offset], [0, 1, 0]]),
+                (ww + extra, hh),
+            )
+            ys, xs = np.where(sil > 0)
+            if xs.size:
+                sil = sil[ys.min() : ys.max() + 1, xs.min() : xs.max() + 1]
     return sil
 
 

src/remove_ai_watermarks/_text_mark_engine.py

@@ -132,7 +132,10 @@ class TextMarkConfig:
     # max-normalization suppress the response to clean-arm levels (positives 0.16-0.23
     # vs clean p99 0.31), while raw gray NCC separates (positives 0.38-0.54 vs clean
     # p99 0.264 / max 0.304, measured 2026-07-22). Contrast-DEPENDENT, unlike tophat.
-    detect_frontend: Literal["binary", "tophat", "gray"] = "binary"
+    # "contrast" correlates against the ABSOLUTE local-luma residual. It is for a mark
+    # whose renderer switches between light-on-dark and dark-on-light while preserving
+    # one silhouette (Tencent Yuanbao); a one-polarity white top-hat misses the latter.
+    detect_frontend: Literal["binary", "tophat", "gray", "contrast"] = "binary"
     # Gaussian sigma applied to the template in the "tophat" front-end (0 = none).
     template_blur: float = 0.0
     # Which image dimension the mark's size and margins scale with. VENDOR-SPECIFIC,
@@ -398,6 +401,46 @@ class TextMarkEngine:
         """The detection score alone -- the box the removal mask needs is discarded here."""
         return self._tophat_best(image, loc)[0]
 
+    def _contrast_best(
+        self, image: NDArray[Any], loc: TextMarkLocation
+    ) -> tuple[float, tuple[int, int, int, int] | None]:
+        """Best silhouette match against the absolute local-luma residual.
+
+        Unlike the white top-hat, this response is polarity-independent: the same
+        watermark can be lighter or darker than its local background. Detection and
+        removal share the returned box, preserving the front-end parity contract.
+        """
+        c = self.config
+        x, y, bw, bh = loc.bbox
+        if bh < 16 or bw < 16:
+            return (0.0, None)
+        roi = image_io.to_bgr(image[y : y + bh, x : x + bw]).astype(np.float32)
+        luma = roi.mean(axis=2)
+        sat = roi.max(axis=2) - roi.min(axis=2)
+        sigma = max(4.0, bh * 0.4)
+        response = np.abs(luma - cv2.GaussianBlur(luma, (0, 0), sigmaX=sigma, sigmaY=sigma))
+        response *= sat < c.max_saturation
+        peak = float(response.max())
+        sil = self._glyph_silhouette()
+        if peak <= 1e-6 or sil is None:
+            return (0.0, None)
+        response = (response / peak * 255).astype(np.uint8)
+        base = self.scale_base(image)
+        best_score = 0.0
+        best_box: tuple[int, int, int, int] | None = None
+        for scale in c.ladder:
+            gw = max(c.min_gw, int(c.alpha_width_frac * base * scale))
+            gh = max(4, int(c.alpha_height_frac * base * scale))
+            if gw >= response.shape[1] or gh >= response.shape[0]:
+                continue
+            template = cv2.resize(sil, (gw, gh), interpolation=cv2.INTER_AREA)
+            result = cv2.matchTemplate(response, template, cv2.TM_CCOEFF_NORMED)
+            _, score, _, top_left = cv2.minMaxLoc(result)
+            if score > best_score:
+                tx, ty = int(top_left[0]), int(top_left[1])
+                best_score, best_box = float(score), (tx, ty, tx + gw - 1, ty + gh - 1)
+        return (best_score, best_box)
+
     def _gray_best(self, image: NDArray[Any], loc: TextMarkLocation) -> tuple[float, tuple[int, int, int, int] | None]:
         """Best TM_CCOEFF_NORMED of the silhouette against the raw GRAYSCALE ROI, and
         the ROI-local box (x0, y0, x1, y1) of that best match.
@@ -584,6 +627,19 @@ class TextMarkEngine:
             det.detected = score >= threshold and self._rival_margin_ok(score, box, self.scale_base(image))
             logger.debug("%s detect (gray): ncc=%.2f thr=%.2f detected=%s", c.name, score, threshold, det.detected)
             return det
+        if c.detect_frontend == "contrast":
+            score = self._contrast_best(image, loc)[0]
+            threshold = c.detect_ncc_threshold * (c.provenance_ncc_factor if provenance else 1.0)
+            det.confidence = score
+            det.detected = score >= threshold and self._rival_margin_ok(score, box, self.scale_base(image))
+            logger.debug(
+                "%s detect (contrast): ncc=%.2f thr=%.2f detected=%s",
+                c.name,
+                score,
+                threshold,
+                det.detected,
+            )
+            return det
         if coverage >= c.detect_min_coverage:
             score = self._template_match_score(box, self.scale_base(image))
             threshold = c.detect_ncc_threshold * (c.provenance_ncc_factor if provenance else 1.0)
@@ -643,6 +699,10 @@ class TextMarkEngine:
             # leftmost "Runni" of "RunningHub AI生成" unremoved (2026-07-22). Use the
             # detector's own best-match box, same as the tophat faint path below.
             _, box = self._gray_best(image, loc)
+        elif self.config.detect_frontend == "contrast" and self.detect(image).detected:
+            # A dark-on-light Yuanbao mark has no WHITE top-hat blob at all. Bound
+            # the fill by the polarity-independent detector's own match box.
+            _, box = self._contrast_best(image, loc)
         elif xs.size >= self._MIN_GLYPH_PIXELS:
             box = (int(xs.min()), int(ys.min()), int(xs.max()), int(ys.max()))
         elif self.config.detect_frontend == "tophat" and self.detect(image).detected:

src/remove_ai_watermarks/api.py

@@ -128,9 +128,9 @@ def remove_visible(
     strip_metadata: bool = True,
     write_noop: bool = True,
 ) -> tuple[NDArray[Any], list[str]]:
-    """Remove every detected known visible AI mark (Gemini sparkle, Doubao/Jimeng/
-    Samsung text, the Jimeng pill) via localize -> fill, returning ``(result_bgr,
-    [labels removed])``.
+    """Remove every detected known visible AI mark (Gemini sparkle, the registered
+    vendor text marks including Tencent Yuanbao, and the Jimeng pill) via
+    localize -> fill, returning ``(result_bgr, [labels removed])``.
 
     ``source`` is a file path OR a BGR ndarray. For a PATH, metadata provenance is read
     automatically (so ``sensitivity="auto"`` recovers a moved/faint mark whenever the

src/remove_ai_watermarks/cli.py

@@ -418,7 +418,7 @@ def _remove_visible_auto(
 
     Routes the ``all``/``batch`` visible step through the same registry path the
     standalone ``visible`` command uses, so EVERY registered mark is handled (the
-    Gemini sparkle AND the Doubao/Jimeng/Samsung text marks), not just the sparkle.
+    Gemini sparkle and all registered vendor text marks), not just the sparkle.
     Returns ``(result, label-or-None)``; when no ``in_auto`` mark fires the image is
     returned unchanged with ``None``. ``backend`` selects the shared fill; ``sensitivity``
     controls how hard a borderline mark is trusted (auto reads metadata provenance)."""
@@ -475,7 +475,7 @@ def _no_visible_mark_exit(source: Path) -> NoReturn:
     """Explain why no visible watermark was removed, then exit non-zero.
 
     The visible registry handles only known visual marks (the Gemini sparkle and
-    the Doubao/Jimeng/Qwen/Samsung text strips). Most real uploads carry no such mark
+    the registered vendor text marks). Most real uploads carry no such mark
     -- frequently an invisible/metadata watermark instead (e.g. an OpenAI or
     Gemini image whose only signal is C2PA + SynthID). Returning the input
     unchanged with exit 0 reads as success to a caller and re-serves the
@@ -639,7 +639,7 @@ def _run_visible_auto(
     console.print(f"  Input:  {source.name}  ({w}x{h})")
     if not removed:
         # write_noop=False means nothing was written, so a pre-existing output is intact.
-        console.print("  No known visible mark detected (gemini / doubao / jimeng / jimeng-pill / samsung).")
+        console.print("  No registered visible mark detected.")
         _no_visible_mark_exit(source)
     console.print(f"  Removed: {', '.join(removed)}")
     size_kb = output.stat().st_size / 1024

src/remove_ai_watermarks/doubao_engine.py

@@ -6,7 +6,7 @@ label mandated by China's TC260 standard, a near-white semi-transparent overlay.
 
 Detection matches the bundled glyph silhouette against the corner candidate; removal
 is the shared **localize -> fill** (the glyph-bbox :meth:`footprint_mask` feeds
-``region_eraser``), NOT reverse-alpha. This is one of the three text-mark engines that
+``region_eraser``), NOT reverse-alpha. This is one of the registered text-mark engines that
 share :class:`remove_ai_watermarks._text_mark_engine.TextMarkEngine`; this module
 supplies only Doubao's tuned :class:`TextMarkConfig` (bottom-right corner,
 ``assets/doubao_alpha.png`` -- the detection silhouette, rebuilt by

src/remove_ai_watermarks/identify.py

@@ -451,6 +451,7 @@ _VISIBLE_MARK_PLATFORM = {
     "jimeng": "ByteDance Jimeng / Dreamina (visible 即梦AI mark detected)",
     "qwen": "Alibaba Tongyi Qianwen (visible 千问AI生成 mark detected)",
     "kling": "Kuaishou Kling (visible 可灵AI 3.0 mark detected)",
+    "yuanbao": "Tencent Yuanbao (visible 元宝 / AI生成 mark detected)",
     "samsung": "Samsung Galaxy AI (visible 'Contenuti generati dall'AI' mark detected)",
     "runninghub": "RunningHub (visible RunningHub AI生成 mark detected)",
     "baidu": "Baidu (visible 百度 AI生成 mark detected)",
@@ -555,7 +556,7 @@ def identify(image_path: Path, *, check_visible: bool = True, check_invisible: b
     Args:
         image_path: Path to the image (PNG, JPEG, WebP, or ISOBMFF container).
         check_visible: Also run the visible-mark detectors (cv2) -- the Gemini
-            sparkle and the Doubao/Jimeng text marks from the registry. Set
+            sparkle and vendor text marks from the registry. Set
             False for a pure-metadata, dependency-light scan.
         check_invisible: Also decode open invisible watermarks (SD/SDXL/FLUX) via
             the optional imwatermark library. No-op when it is not installed.

src/remove_ai_watermarks/jimeng_engine.py

@@ -6,7 +6,7 @@ class as the Doubao text strip.
 
 Detection matches the bundled glyph silhouette against the corner; removal is the
 shared **localize -> fill** (the glyph-bbox :meth:`footprint_mask` feeds
-``region_eraser``), NOT reverse-alpha. This is one of the three text-mark engines that
+``region_eraser``), NOT reverse-alpha. This is one of the registered text-mark engines that
 share :class:`remove_ai_watermarks._text_mark_engine.TextMarkEngine`; this module
 supplies only Jimeng's tuned :class:`TextMarkConfig` (bottom-right corner,
 ``assets/jimeng_alpha.png`` -- the detection silhouette, rebuilt by

src/remove_ai_watermarks/samsung_engine.py

@@ -9,7 +9,7 @@ Doubao/Jimeng marks but bottom-left.
 
 Detection matches the bundled glyph silhouette against the corner; removal is the
 shared **localize -> fill** (the glyph-bbox :meth:`footprint_mask` feeds
-``region_eraser``), NOT reverse-alpha. This is one of the three text-mark engines that
+``region_eraser``), NOT reverse-alpha. This is one of the registered text-mark engines that
 share :class:`remove_ai_watermarks._text_mark_engine.TextMarkEngine`; this module
 supplies only Samsung's tuned :class:`TextMarkConfig` (bottom-LEFT corner, a lower glyph
 luma since the mark is faint, ``assets/samsung_alpha.png`` -- the detection silhouette,

src/remove_ai_watermarks/watermark_registry.py

@@ -22,6 +22,7 @@ Entries:
   - ``jimeng`` -- ByteDance Jimeng / Dreamina "★ 即梦AI" wordmark, bottom-right.
   - ``qwen`` -- Alibaba Tongyi Qianwen "千问AI生成" text strip, bottom-right.
   - ``kling`` -- Kuaishou Kling "可灵AI 3.0" text strip, bottom-right.
+  - ``yuanbao`` -- Tencent Yuanbao "元宝 / AI生成" two-line mark, bottom-right.
   - ``samsung`` -- Samsung Galaxy AI "Contenuti generati dall'AI" strip, bottom-left.
   - ``jimeng_pill`` -- Jimeng-basic "AI生成" pill, top-left (capture-less).
   - ``runninghub`` -- RunningHub "RunningHub AI生成" text, top-left (gray front-end).
@@ -90,6 +91,7 @@ _PRODUCT_OF: dict[str, str] = {
     "jimeng_pill": "jimeng",  # same product as the Jimeng wordmark
     "qwen": "qwen",
     "kling": "kling",
+    "yuanbao": "yuanbao",
     "samsung": "samsung",
     "runninghub": "runninghub",
     "baidu": "baidu",
@@ -371,6 +373,10 @@ def _engine(key: str) -> Any:
             from remove_ai_watermarks.kling_engine import KlingEngine
 
             _engines[key] = KlingEngine()
+        elif key == "yuanbao":
+            from remove_ai_watermarks.yuanbao_engine import YuanbaoEngine
+
+            _engines[key] = YuanbaoEngine()
         elif key == "samsung":
             from remove_ai_watermarks.samsung_engine import SamsungEngine
 
@@ -473,8 +479,8 @@ def _gemini_mask(
     return _engine("gemini").footprint_mask(image, force=force, region=region)
 
 
-# The three text-mark engines (Doubao/Jimeng/Samsung) share the TextMarkEngine
-# interface, so one parameterized adapter pair drives all of them -- a new
+# The registered text-mark engines share the TextMarkEngine interface, so one
+# parameterized adapter pair drives all of them -- a new
 # text mark is one `_text_mark(...)` row below, not another copy-paste of these
 # bodies. Detection matches the glyph silhouette; the mask is the template-free
 # glyph-bbox footprint (see TextMarkEngine.footprint_mask).
@@ -534,6 +540,7 @@ _REGISTRY: tuple[KnownMark, ...] = (
     _text_mark("jimeng", "Jimeng 即梦AI wordmark", "bottom-right"),
     _text_mark("qwen", "Qwen 千问AI生成 text", "bottom-right"),
     _text_mark("kling", "Kling 可灵AI 3.0 text", "bottom-right"),
+    _text_mark("yuanbao", "Tencent Yuanbao 元宝 / AI生成 mark", "bottom-right"),
     _text_mark("samsung", "Samsung Galaxy AI text", "bottom-left"),
     _text_mark("runninghub", "RunningHub AI生成 text", "top-left"),
     _text_mark("baidu", "Baidu 百度 AI生成 text", "bottom-right"),
@@ -615,10 +622,17 @@ def _keep_pill(keys: set[str], *, provenance: frozenset[str], footprint_flat: bo
         so real flat-scene pills (and harmless flat false fires) are cleaned while the
         damaging textured false fires are left untouched.
     A Doubao image is TC260 too but is not Jimeng-basic, so the pill never rides on a
-    Doubao detection; a Qwen image likewise (another vendor's bottom-right mark naming
-    its own product), so a confident Qwen detection suppresses the pill the same way.
+    Doubao detection; Qwen, Kling, Yuanbao, RunningHub, and Baidu detections likewise
+    name other products and suppress the pill.
     No confirmation at all -> never remove (blocks false fires on non-Jimeng content)."""
-    if "doubao" in keys or "qwen" in keys or "kling" in keys or "runninghub" in keys or "baidu" in keys:
+    if (
+        "doubao" in keys
+        or "qwen" in keys
+        or "kling" in keys
+        or "yuanbao" in keys
+        or "runninghub" in keys
+        or "baidu" in keys
+    ):
         return False
     if "jimeng" in keys:
         return True

src/remove_ai_watermarks/yuanbao_engine.py

@@ -0,0 +1,138 @@
+"""Tencent Yuanbao visible watermark detector and localizer.
+
+Yuanbao stamps a compact italic two-line mark, ``元宝`` over ``AI生成``, in the
+bottom-right corner. The same silhouette is rendered light on dark scenes and
+dark on pale scenes, so a one-polarity white top-hat cannot detect it reliably.
+This engine uses the shared text-mark pipeline with the ``contrast`` front-end:
+normalized absolute local-luma residual followed by silhouette NCC.
+
+The bundled silhouette is synthetic and font-rendered by
+``scripts/render_vendor_silhouettes.py``. Removal follows the shared
+localize-then-fill path and uses the detector's own match box.
+
+Calibration (2026-07-25) used the metadata-harvested Tencent cohort after byte
+deduplication and visual adjudication. The standard two-line variant was detected
+on 26 of 28 unique marked carriers (92.9%) at gate 0.38, with 0 fires on 286
+hand-labeled clean frames. The separate photographer-overlay variant is not
+covered by this silhouette.
+"""
+
+# The module-level helpers are imported by tests.
+# pyright: reportUnusedFunction=false
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+from remove_ai_watermarks import _text_mark_engine
+from remove_ai_watermarks._text_mark_engine import TextMarkConfig, TextMarkDetection, TextMarkEngine
+
+logger = logging.getLogger(__name__)
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from numpy.typing import NDArray
+
+WM_WIDTH_FRAC = 0.20
+WM_HEIGHT_FRAC = 0.15
+MARGIN_RIGHT_FRAC = 0.002
+MARGIN_BOTTOM_FRAC = 0.002
+
+MAX_SATURATION = 55
+LOGO_MIN_LUMA = 150
+TOPHAT_DELTA = 12
+
+DETECT_MIN_COVERAGE = 0.04
+DETECT_NCC_THRESHOLD = 0.38
+
+_ALPHA_WIDTH_FRAC = 0.08
+_ALPHA_HEIGHT_FRAC = 0.0446
+_LADDER = (0.95, 1.0, 1.05)
+
+_CONFIG = TextMarkConfig(
+    name="Tencent Yuanbao",
+    asset_name="yuanbao_alpha.png",
+    corner="br",
+    margin_floor=4,
+    width_frac=WM_WIDTH_FRAC,
+    height_frac=WM_HEIGHT_FRAC,
+    margin_x_frac=MARGIN_RIGHT_FRAC,
+    margin_bottom_frac=MARGIN_BOTTOM_FRAC,
+    max_saturation=MAX_SATURATION,
+    logo_min_luma=LOGO_MIN_LUMA,
+    tophat_delta=TOPHAT_DELTA,
+    morph_open_size=5,
+    detect_min_coverage=DETECT_MIN_COVERAGE,
+    detect_ncc_threshold=DETECT_NCC_THRESHOLD,
+    detect_frontend="contrast",
+    scale_basis="short",
+    ladder=_LADDER,
+    alpha_width_frac=_ALPHA_WIDTH_FRAC,
+    alpha_height_frac=_ALPHA_HEIGHT_FRAC,
+    min_gw=32,
+    provenance_ncc_factor=1.0,
+)
+
+YuanbaoDetection = TextMarkDetection
+
+
+def _alpha_template() -> NDArray[Any] | None:
+    """The bundled Yuanbao alpha template (float [0,1]), or None."""
+    return _text_mark_engine.load_alpha_template(_CONFIG.asset_name)
+
+
+def _glyph_silhouette() -> NDArray[Any] | None:
+    """Binary two-line Yuanbao silhouette (255 = glyph), or None."""
+    return _text_mark_engine.glyph_silhouette(_CONFIG.asset_name)
+
+
+def _template_match_score(box_mask: NDArray[Any], scale_base: int) -> float:
+    """TM_CCOEFF_NORMED of the Yuanbao silhouette against ``box_mask``."""
+    return _text_mark_engine.template_match_score(box_mask, scale_base, _CONFIG)
+
+
+class YuanbaoEngine(TextMarkEngine):
+    """Detect and localize the bottom-right Yuanbao mark."""
+
+    _ANCHOR_MAX_RIGHT = 0.04
+    _ANCHOR_MAX_BOTTOM = 0.04
+
+    def __init__(self) -> None:
+        super().__init__(_CONFIG)
+
+    def detect(self, image: NDArray[Any] | None, *, provenance: bool = False) -> TextMarkDetection:
+        if image is None or not image.size:
+            return TextMarkDetection()
+        detection = super().detect(image, provenance=provenance)
+        if not detection.detected:
+            return detection
+        location = self.locate(image)
+        _, box = self._contrast_best(image, location)
+        if box is None:
+            detection.detected = False
+            return detection
+        h, w = image.shape[:2]
+        base = min(h, w)
+        right = (w - (location.x + box[2] + 1)) / base
+        bottom = (h - (location.y + box[3] + 1)) / base
+        if not (0 <= right <= self._ANCHOR_MAX_RIGHT and 0 <= bottom <= self._ANCHOR_MAX_BOTTOM):
+            logger.debug(
+                "Yuanbao detect: score %.3f but match off-anchor (right=%.3f bottom=%.3f); demoting.",
+                detection.confidence,
+                right,
+                bottom,
+            )
+            detection.detected = False
+        return detection
+
+
+def load_image_bgr(path: str | Path) -> NDArray[Any]:
+    """Read an image as a BGR ndarray."""
+    from remove_ai_watermarks import image_io
+
+    image = image_io.imread(path)
+    if image is None:
+        raise FileNotFoundError(f"Failed to read image: {path}")
+    return image

tests/test_watermark_registry.py

@@ -20,6 +20,7 @@ class TestCatalog:
             "jimeng",
             "qwen",
             "kling",
+            "yuanbao",
             "samsung",
             "runninghub",
             "baidu",
@@ -42,6 +43,7 @@ class TestCatalog:
         assert by_key["gemini"].location == "bottom-right"
         assert by_key["doubao"].location == "bottom-right"
         assert by_key["jimeng"].location == "bottom-right"
+        assert by_key["yuanbao"].location == "bottom-right"
         assert by_key["samsung"].location == "bottom-left"
         assert by_key["jimeng_pill"].location == "top-left"
 
@@ -60,6 +62,7 @@ class TestScan:
             "jimeng",
             "qwen",
             "kling",
+            "yuanbao",
             "samsung",
             "runninghub",
             "baidu",
@@ -89,7 +92,7 @@ class TestScan:
         forced remove on a zero-size ndarray crashed (cv2.error on an empty Mat). detect
         already guarded this; footprint_mask must too. Covers the text + gemini engines."""
         empty = np.zeros(shape, np.uint8)
-        for key in ("doubao", "jimeng", "qwen", "samsung", "gemini"):
+        for key in ("doubao", "jimeng", "qwen", "yuanbao", "samsung", "gemini"):
             _result, mask = reg.get_mark(key).remove(empty, force=True)
             assert mask is None
 
@@ -354,6 +357,16 @@ class TestArbiter:
         assert "qwen" in keys
         assert "jimeng_pill" not in keys
 
+    def test_pill_dropped_on_yuanbao(self):
+        # The standard Yuanbao mark identifies a different TC260 product, so a
+        # coincident top-left pill match must not be treated as Jimeng-basic.
+        cands = [
+            self._c("yuanbao", strict=True, relaxed=True),
+            self._c("jimeng_pill", strict=True, relaxed=True, flat=True),
+        ]
+        keys = self._keys(cands, reg.Context(provenance=frozenset({"jimeng"})))
+        assert keys == {"yuanbao"}
+
     def test_pill_metadata_arm_gated_on_flatness(self):
         ctx = reg.Context(provenance=frozenset({"jimeng"}))
         assert self._keys([self._c("jimeng_pill", strict=True, relaxed=True, flat=True)], ctx) == {"jimeng_pill"}

tests/test_yuanbao_engine.py

@@ -0,0 +1,94 @@
+"""Tests for the Tencent Yuanbao (元宝 / AI生成) visible-watermark engine."""
+
+from __future__ import annotations
+
+import cv2
+import numpy as np
+
+from remove_ai_watermarks import watermark_registry as registry
+from remove_ai_watermarks.yuanbao_engine import (
+    _ALPHA_HEIGHT_FRAC,
+    _ALPHA_WIDTH_FRAC,
+    YuanbaoEngine,
+    _alpha_template,
+)
+
+_MARK_WIDTH_FRAC = 0.08
+_RIGHT_MARGIN_FRAC = 0.028
+_BOTTOM_MARGIN_FRAC = 0.031
+
+
+def _compose(w: int, h: int, *, bg: float, foreground: float):
+    """Composite the synthetic Yuanbao silhouette at its measured geometry."""
+    image = np.full((h, w, 3), bg, np.float32)
+    alpha = _alpha_template()
+    assert alpha is not None
+    short = min(w, h)
+    gw = int(_MARK_WIDTH_FRAC * short)
+    gh = max(6, int((_ALPHA_HEIGHT_FRAC / _ALPHA_WIDTH_FRAC) * gw))
+    ax = w - int(_RIGHT_MARGIN_FRAC * short) - gw
+    ay = h - int(_BOTTOM_MARGIN_FRAC * short) - gh
+    mark_alpha = np.zeros((h, w), np.float32)
+    mark_alpha[ay : ay + gh, ax : ax + gw] = cv2.resize(alpha, (gw, gh))
+    a3 = mark_alpha[:, :, None]
+    composed = (a3 * foreground + (1 - a3) * image).clip(0, 255).astype(np.uint8)
+    return composed, (ax, ay, gw, gh)
+
+
+class TestConfig:
+    def test_uses_two_polarity_contrast_frontend(self):
+        assert YuanbaoEngine().config.detect_frontend == "contrast"
+
+    def test_strict_only(self):
+        assert YuanbaoEngine().config.provenance_ncc_factor == 1.0
+
+    def test_registry_row(self):
+        mark = registry.get_mark("yuanbao")
+        assert mark.location == "bottom-right"
+        assert "元宝" in mark.label
+        assert mark.in_auto
+
+
+class TestDetectAndMask:
+    def test_detects_light_mark_on_dark_background(self):
+        watermark, _ = _compose(1024, 1024, bg=60, foreground=230)
+        detection = YuanbaoEngine().detect(watermark)
+        assert detection.detected
+        assert detection.confidence >= 0.80
+
+    def test_detects_dark_mark_on_light_background(self):
+        """Yuanbao switches mark polarity with the background.
+
+        A white top-hat alone misses the dark-gray stamp used on pale scenes.
+        """
+        watermark, _ = _compose(1024, 1024, bg=230, foreground=110)
+        detection = YuanbaoEngine().detect(watermark)
+        assert detection.detected
+        assert detection.confidence >= 0.80
+
+    def test_clean_gradient_stays_quiet(self):
+        ramp = np.tile(np.linspace(40, 220, 1024, dtype=np.uint8), (1024, 1))
+        image = cv2.cvtColor(ramp, cv2.COLOR_GRAY2BGR)
+        assert not YuanbaoEngine().detect(image).detected
+
+    def test_match_must_hug_bottom_right_anchor(self):
+        watermark, (ax, ay, gw, gh) = _compose(1024, 1024, bg=60, foreground=230)
+        assert YuanbaoEngine().detect(watermark).detected
+        shifted = np.full_like(watermark, 60)
+        shifted[600 : 600 + gh, 600 : 600 + gw] = watermark[ay : ay + gh, ax : ax + gw]
+        assert not YuanbaoEngine().detect(shifted).detected
+
+    def test_mask_uses_detector_box_for_dark_mark(self):
+        watermark, (ax, ay, gw, gh) = _compose(1024, 1024, bg=230, foreground=110)
+        mask = YuanbaoEngine().footprint_mask(watermark)
+        assert mask is not None
+        ys, xs = np.where(mask > 0)
+        assert xs.min() <= ax + int(0.05 * gw)
+        assert xs.max() >= ax + gw - int(0.05 * gw)
+        assert ys.min() <= ay + gh // 2 <= ys.max()
+
+    def test_remove_clears_detector(self):
+        watermark, _ = _compose(1024, 1024, bg=60, foreground=230)
+        output, region = registry.get_mark("yuanbao").remove(watermark, backend="cv2")
+        assert region is not None
+        assert not YuanbaoEngine().detect(output).detected