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

watermarks-remover

Skill de agente + serviço Python stdlib para remover marcas de proveniência de IA de múltiplos fornecedores de texto e arquivos — para privacidade e higiene em conteúdo que você possui. O skill é um cliente leve: ele aciona a maquinaria via HTTP, então o host do agente não precisa de Python.

Camada	Alvo	Como
A	Unicode invisível, espaços exóticos, bidi, caracteres de tag	Scripts Python determinísticos
B	Marcas d'água estatísticas (amostragem de tokens) em texto	Reescrita pelo agente + hook opcional rewrite_text.py
Arquivos	C2PA / EXIF / XMP / propriedades de documentos	PNG, JPEG, WebP, AVIF, HEIC, BMP, GIF, TIFF, SVG, PDF, DOCX, XLSX, PPTX, EPUB, ODT, HTML, Markdown, MP4/MOV/M4A/M4V, WAV, MP3, FLAC

Fornecedores / ecossistemas (nível de classe): Claude, Gemini / SynthID-Text, superfícies de proveniência da OpenAI, marcas open-LLM estilo Kirchenbauer (green-list) e keyed-Gumbel / EXP (Aaronson).

Última versão: v0.7.0

Caminho do skill: skills/remove-ai-marks/
Caminho do serviço: service/
(migração: anteriormente remove-claude-marks; alias de barra /remove-claude-marks ainda documentado)

Instalação (skill de agente)

O skill não inclui código — ele chama o serviço via HTTP. Instale o skill (apenas markdown) e inicie o serviço, depois defina WATERMARKS_SERVICE_URL se não for http://127.0.0.1:8765.

No Claude Code, a rota mais rápida é o marketplace de plugins incluído — sem clonar, e ele se atualiza no local. Em todos os outros lugares, um instalador cobre todos os hosts suportados (Python 3.10+ stdlib, sem dependências):```bash python3 install_skill.py --skill remove-ai-marks --target claude-code

| Host | Target | Lands in |
| --- | --- | --- |
| Claude Code (pessoal) | `--target claude-code` | `~/.claude/skills/<skill>` (honors `CLAUDE_CONFIG_DIR`) |
| Claude Code (projeto) | `--target claude-project --project-dir PATH` | `PATH/.claude/skills/<skill>` |
| Cowork, claude.ai, sessões na nuvem, rotinas | `--target cowork` | `dist/<skill>.zip` para enviar em **Customize → Skills** |
| Cursor | `--target cursor` (padrão) | `~/.cursor/skills/<skill>` |

Skills incluídas: `remove-ai-marks` (completa, com suporte de serviço) e
`clean-user-facing-text` (apenas texto, autossuficiente). `--list` as exibe.
Instalações existentes são preservadas a menos que você passe `--force`; a
substituição é preparada primeiro e a instalação anterior é mantida como um
backup com nome exclusivo. `--link` cria symlinks para este checkout em vez de
copiar, de modo que as edições são captadas em tempo real. No Windows, use
`py install_skill.py ...`; o wrapper `install-skill.sh` é fornecido para shells
macOS/Linux.

Antes de escrever qualquer coisa, o instalador valida a skill de acordo com as
regras de empacotamento do [Agent Skills](https://agentskills.io) que os uploads
do claude.ai e a Skills API impõem: frontmatter apenas de especificação (`name`,
`description`, `license`, `compatibility`, `metadata`, `allowed-tools`), um
`name` em minúsculas com hífens de no máximo 64 caracteres correspondendo ao
diretório, uma `description` não vazia de no máximo 1024 caracteres. O pacote
Cowork adicionalmente precisa caber no limite de upload de 30 MB, o que o
empacotador impõe.

### Limpeza automática via hook (determinística)

Uma skill é uma instrução: o modelo decide se deve invocá-la, e o modelo é a
coisa que produz as marcas. Um **hook** é executado pelo harness em cada chamada
de ferramenta correspondente, sem necessidade de cooperação. Isso torna o hook a
metade determinística deste fluxo de trabalho.

O plugin registra um hook `PostToolUse` em `Write|Edit|MultiEdit|NotebookEdit`
que executa [`service/scripts/hook_written_file.py`](https://github.com/guillaumemeyer/watermarks-remover/blob/main/service/scripts/hook_written_file.py)
contra o arquivo que o agente acabou de escrever. Dois modos, seguindo a
convenção de pré-commit de verificação por padrão:

| Modo | Comportamento |
| --- | --- |
| `check` (padrão) | Relata marcas de proveniência, deixa o arquivo intacto. Os achados vão para o modelo (exit 2), para que ele possa oferecer limpá-los. |
| `clean` | Remove as marcas no local, depois informa ao modelo que o arquivo em disco mudou. |

Defina o modo nas configurações do plugin (**Hook mode** em `/plugin manage`,
lido pelo hook como `CLAUDE_PLUGIN_OPTION_HOOK_MODE`), ou com
`WATERMARKS_HOOK_MODE=clean` no ambiente. O comando do hook deliberadamente
**não** interpola `${user_config.hook_mode}`: o Claude Code se recusa a executar
um hook que referencia uma opção que o usuário nunca abriu `/plugin manage` para
definir — um `default` declarado não o satisfaz — então interpolá-lo significaria
que o hook silenciosamente nunca seria executado em uma instalação nova. A
detecção reutiliza `scan_file` / `is_actionable` do `audit_lib`, de modo que o
hook, o gate de pré-commit e a exportação SARIF do CI concordam sobre o que conta
como acionável; a limpeza chama `clean_file.py`, então nenhuma lógica de limpeza
é duplicada. O modo `clean` escreve em um arquivo temporário irmão e troca apenas
em caso de diferença real, então arquivos que já estavam limpos mantêm seu mtime
e não reacionam os observadores de arquivos.

Sem o plugin, conecte-o você mesmo em `~/.claude/settings.json` (ou em um
`.claude/settings.json` do projeto):```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
          }
        ]
      }
    ]
  }
}

No Windows, substitua python3 por py.

O que um hook não pode fazer. Nenhum hook pode reescrever a mensagem de chat do assistente antes que você a leia. O hook Stop do Claude Code recebe last_assistant_message como somente leitura, e não há filtro de pré-envio para respostas finais — o mesmo limite que este projeto já documenta para regras do Cursor. Portanto, a garantia determinística cobre arquivos que o agente escreve, além do gate de pré-commit para qualquer coisa a caminho do git. Texto que só existe no transcript do chat ainda depende do fluxo de trabalho da skill, que é baseado em instruções do modelo e, portanto, best-effort.

Plugin do Claude Code (marketplace)