@andespindola/crow-skills 0.22.0 → 0.24.0

package/LICENSE

@@ -0,0 +1,51 @@
+Copyright (c) 2026 Anderson Espíndola. Todos os direitos reservados.
+
+Software proprietário. Este pacote é distribuído publicamente para uso, não para
+cópia. O código-fonte não é aberto: a sua presença no pacote é uma necessidade de
+execução, não uma concessão de direitos sobre ele.
+
+## O que você pode fazer
+
+1. Instalar e executar o `crow-skills` nos seus próprios computadores, sem limite de
+   máquinas, para o seu uso pessoal ou da sua organização.
+2. Deixar que o CLI instale, nos seus computadores, as cópias das skills que ele
+   gerencia, e usar essas skills com os seus agentes.
+3. Configurar, adaptar localmente e desinstalar o que o CLI gravou na sua máquina.
+
+## O que você não pode fazer
+
+1. Redistribuir este pacote, no todo ou em parte, por qualquer meio — incluindo
+   republicar em registro de pacotes, espelhar, empacotar dentro de outro produto ou
+   disponibilizar para download.
+2. Criar ou distribuir obra derivada, incluindo traduções, adaptações e reescritas das
+   skills, do catálogo ou da documentação.
+3. Extrair o conteúdo das skills, do catálogo ou da documentação para treinar, povoar,
+   alimentar ou compor outro produto, biblioteca, modelo ou conjunto de dados.
+4. Fazer engenharia reversa, descompilar, desmontar ou de outro modo analisar o pacote
+   com o objetivo de reconstruir, reimplementar ou derivar a sua lógica, os seus
+   contratos ou o seu conteúdo, salvo na medida em que a lei aplicável proíba essa
+   restrição.
+5. Remover, alterar ou ocultar avisos de autoria, de direitos ou esta licença.
+6. Sublicenciar, alugar, vender ou revender o pacote ou o acesso a ele.
+
+## Sem garantia
+
+O SOFTWARE É FORNECIDO "COMO ESTÁ", SEM GARANTIA DE QUALQUER NATUREZA, EXPRESSA OU
+IMPLÍCITA, INCLUINDO AS DE ADEQUAÇÃO A UM FIM ESPECÍFICO E DE NÃO VIOLAÇÃO. EM NENHUMA
+HIPÓTESE O TITULAR RESPONDE POR QUALQUER DANO DECORRENTE DO USO DO SOFTWARE.
+
+## Rescisão
+
+Os direitos acima terminam automaticamente com o descumprimento de qualquer item de "O
+que você não pode fazer". Nesse caso, desinstale o pacote e as cópias que ele gravou.
+
+## Outros usos
+
+Qualquer uso fora do permitido acima depende de autorização escrita do titular.
+
+---
+
+Proprietary software, all rights reserved. Published for use, not for copying:
+installing and running it is permitted; redistribution, derivative works, extracting
+its content into another product or dataset, and reverse engineering are not. No
+warranty. See the Portuguese text above for the governing terms.

package/README.md

@@ -2,9 +2,9 @@
 
 Skills com escopo explícito, conhecimento especializado preservado e fluxos comuns reutilizáveis.
 
-**Versão 0.12.2** ([mudanças](CHANGELOG.md)): o snapshot de cada sessão (`crow-skills events snapshot`) passa a trazer o pid do CLI de agente e o terminal dele (`pid`, `tty`), para o crow-term achar o painel de cada sessão. A 0.12.1 corrigiu a proteção de processos registrados e um teste instável; a 0.12.0 fez a crow-behaviour passar a encerrar a árvore inteira de todo processo que a execução inicia (com timeout, registro no ledger e verificação no fim) e `crow-skills resources --orphans` encontra e, com `--kill`, encerra só o que ficou órfão de ferramentas de agente. A 0.11.1 fez o Codex deixar de mostrar em dobro as skills que o Uniflow já projeta em `~/.codex/skills`. A 0.11.0 trouxe `crow-skills setup --yes`, que configura de uma vez todos os CLIs de agente da máquina, e `crow-skills upgrade --yes`, que atualiza tudo numa só passada; os hooks que o crow-skills grava já saem habilitados (no Codex, aprovados pelo próprio `codex app-server`, só os do crow-skills; `--no-trust` desliga) e `status`/`doctor` mostram se cada CLI vai rodá-los; a ajuda ficou curta e organizada por tarefa. A 0.10.1 passou a tratar swap e CPU como eixos de pressão no controle de recursos (swap quase cheio e carga alta reduzem agentes, jobs e workers; nenhuma recomendação cresce com a pressão), mostrou a CPU% dos CLIs de agente, trouxe `crow-skills resources --exec-prefix` para rodar jobs pesados em prioridade baixa e as regras da crow-behaviour sob pressão (reduzir já, um job pesado por vez, não repetir verificação, validação ampla no CI); os hooks do Codex vão para o `config.toml` quando o `hooks.json` é symlink. A 0.10.0 trouxe o crow-broadcast, que compartilha, de forma passiva, o que cada sessão e cada CLI (Claude Code, Codex, Gemini CLI, Antigravity, Devin, inclusive dentro do Uniflow) está fazendo nesta máquina: repositório, clone, branch, execução crow em andamento e arquivos em edição; o prompt recebe em toda mensagem um bloco com as sessões vivas que afetam este trabalho (ou uma linha dizendo que não há nenhuma), editar um arquivo que outra sessão tocou ou trocar de branch num clone em uso gera aviso (ou bloqueio, se configurado), e `crow-skills broadcast claim` reserva áreas; a crow-behaviour consulta isso antes de planejar e reserva as áreas que delega ([crow-broadcast](docs/broadcast.md)). A 0.9.0 trouxe o controle de memória da máquina: `crow-skills resources` mede memória, pressão e os CLIs de agente em execução e recomenda quantos agentes, jobs pesados e workers rodar em paralelo; a crow-behaviour consulta essa recomendação antes de cada fan-out (sob `warn` reduz, sob `critical` segue sequencial), limita workers de builds e testes, reutiliza um dev server por projeto e encerra o que abriu, e 15 especialistas que sobem processos pesados ganharam a regra correspondente; o hook de prompt e as status lines só avisam quando a máquina está sob pressão. A 0.8.0 trouxe `crow-skills mode on|off`, que liga e desliga a crow-behaviour em todas as sessões e CLIs (Claude Code, Codex, Gemini CLI, Antigravity, Devin) a partir do próximo prompt, com `/crow on|off` dentro da sessão e o indicador `▸▸ crow on` na status line; a crow-behaviour mostra o progresso como a lista de agentes do host (`● main`, `○ dono  atividade`); `crow-skills events` publica um barramento de eventos dos hooks para terminais; `crow-skills autoupdate on` atualiza o CLI e as skills gerenciadas todo dia e no login. A 0.7.1 trouxe as correções da revalidação no Codex às skills especialistas; a 0.7.0 tornou o Uniflow agente de instalação (`--agents uniflow`); a 0.6.1 passou a mostrar o progresso da crow-behaviour na própria conversa; a 0.6.0 trouxe as regras de entrega das 32 skills especialistas, a partir da [validação no Codex](docs/evaluations/2026-10-26-codex.md).
+**Versão 0.23.0**: o pacote passa a ser público no npm. A 0.22.0 deu conversa de verdade ao crow-broadcast (thread, resposta endereçada a quem perguntou, recibo de entrega e leitura, e entrega entre chamadas de ferramenta em vez de só no próximo prompt) e trouxe os micro-agents de trabalho braçal com contexto limpo. A 0.12.2 fez o snapshot de cada sessão (`crow-skills events snapshot`) passar a trazer o pid do CLI de agente e o terminal dele (`pid`, `tty`), para o crow-term achar o painel de cada sessão. A 0.12.1 corrigiu a proteção de processos registrados e um teste instável; a 0.12.0 fez a crow-behaviour passar a encerrar a árvore inteira de todo processo que a execução inicia (com timeout, registro no ledger e verificação no fim) e `crow-skills resources --orphans` encontra e, com `--kill`, encerra só o que ficou órfão de ferramentas de agente. A 0.11.1 fez o Codex deixar de mostrar em dobro as skills que o Uniflow já projeta em `~/.codex/skills`. A 0.11.0 trouxe `crow-skills setup --yes`, que configura de uma vez todos os CLIs de agente da máquina, e `crow-skills upgrade --yes`, que atualiza tudo numa só passada; os hooks que o crow-skills grava já saem habilitados (no Codex, aprovados pelo próprio `codex app-server`, só os do crow-skills; `--no-trust` desliga) e `status`/`doctor` mostram se cada CLI vai rodá-los; a ajuda ficou curta e organizada por tarefa. A 0.10.1 passou a tratar swap e CPU como eixos de pressão no controle de recursos (swap quase cheio e carga alta reduzem agentes, jobs e workers; nenhuma recomendação cresce com a pressão), mostrou a CPU% dos CLIs de agente, trouxe `crow-skills resources --exec-prefix` para rodar jobs pesados em prioridade baixa e as regras da crow-behaviour sob pressão (reduzir já, um job pesado por vez, não repetir verificação, validação ampla no CI); os hooks do Codex vão para o `config.toml` quando o `hooks.json` é symlink. A 0.10.0 trouxe o crow-broadcast, que compartilha, de forma passiva, o que cada sessão e cada CLI (Claude Code, Codex, Gemini CLI, Antigravity, Devin, inclusive dentro do Uniflow) está fazendo nesta máquina: repositório, clone, branch, execução crow em andamento e arquivos em edição; o prompt recebe em toda mensagem um bloco com as sessões vivas que afetam este trabalho (ou uma linha dizendo que não há nenhuma), editar um arquivo que outra sessão tocou ou trocar de branch num clone em uso gera aviso (ou bloqueio, se configurado), e `crow-skills broadcast claim` reserva áreas; a crow-behaviour consulta isso antes de planejar e reserva as áreas que delega (crow-broadcast). A 0.9.0 trouxe o controle de memória da máquina: `crow-skills resources` mede memória, pressão e os CLIs de agente em execução e recomenda quantos agentes, jobs pesados e workers rodar em paralelo; a crow-behaviour consulta essa recomendação antes de cada fan-out (sob `warn` reduz, sob `critical` segue sequencial), limita workers de builds e testes, reutiliza um dev server por projeto e encerra o que abriu, e 15 especialistas que sobem processos pesados ganharam a regra correspondente; o hook de prompt e as status lines só avisam quando a máquina está sob pressão. A 0.8.0 trouxe `crow-skills mode on|off`, que liga e desliga a crow-behaviour em todas as sessões e CLIs (Claude Code, Codex, Gemini CLI, Antigravity, Devin) a partir do próximo prompt, com `/crow on|off` dentro da sessão e o indicador `▸▸ crow on` na status line; a crow-behaviour mostra o progresso como a lista de agentes do host (`● main`, `○ dono  atividade`); `crow-skills events` publica um barramento de eventos dos hooks para terminais; `crow-skills autoupdate on` atualiza o CLI e as skills gerenciadas todo dia e no login. A 0.7.1 trouxe as correções da revalidação no Codex às skills especialistas; a 0.7.0 tornou o Uniflow agente de instalação (`--agents uniflow`); a 0.6.1 passou a mostrar o progresso da crow-behaviour na própria conversa; a 0.6.0 trouxe as regras de entrega das 32 skills especialistas, a partir da validação no Codex.
 
-**Reconstrução em andamento.** A primeira versão com 32 contratos genéricos não atende à preservação de capacidades solicitada. Não use esse número nem o mapeamento por categoria como prova de substituição das originais. A revisão passa a abranger cada definição e seus recursos, modos e dependências, sem número fixo de skills ou limite artificial de linhas. Veja [critérios e progresso](docs/reconstruction.md).
+**Reconstrução em andamento.** A primeira versão com 32 contratos genéricos não atende à preservação de capacidades solicitada. Não use esse número nem o mapeamento por categoria como prova de substituição das originais. A revisão passa a abranger cada definição e seus recursos, modos e dependências, sem número fixo de skills ou limite artificial de linhas. Veja critérios e progresso.
 
 ## Começar
 
@@ -14,7 +14,7 @@ Uma linha configura todos os CLIs de agente da máquina (Claude Code, Codex, Gem
 npm install -g @andespindola/crow-skills && crow-skills setup --yes
 ```
 
-O pacote é privado no npm: a instalação exige um `~/.npmrc` autenticado no escopo `@andespindola`. O tap do Homebrew foi aposentado na 0.16.1 e está congelado nessa versão — quem instalou por lá troca com `brew uninstall crow-skills` seguido da linha acima.
+O pacote é público no npm desde a 0.23.0: instala sem autenticação e sem `~/.npmrc` no escopo. O código-fonte não é aberto — o repositório é privado e o pacote é distribuído sob os termos de `LICENSE`. O tap do Homebrew foi aposentado na 0.16.1 e está congelado nessa versão — quem instalou por lá troca com `brew uninstall crow-skills` seguido da linha acima.
 
 `setup` detecta cada CLI (binário no PATH ou diretório de configuração), instala todas as skills, o guia, as integrações e os hooks do modo crow já habilitados, liga o modo crow e o autoupdate, e termina com uma tabela por CLI e o doctor. `crow-skills setup --dry-run` mostra o plano sem gravar nada; rodar de novo só corrige o que mudou. Para atualizar tudo depois: `crow-skills upgrade --yes`. `crow-skills` sozinho mostra a ajuda curta e o estado atual; `crow-skills help <comando>` detalha cada comando. Detalhes em [setup, upgrade e ajuda](docs/cli.md#configurar-a-máquina-setup).
 
@@ -35,11 +35,11 @@ Exemplos:
 - Dados Postgres: `crow-postgres` + teste do efeito real; não precisa carregar toda a biblioteca.
 - Revisão: `crow-security-review` não modifica ou executa o alvo. Implementação é outra tarefa.
 
-[Catálogo e ownership](docs/catalog.md) · [Playbooks](docs/playbooks.md) · [Contrato de composição](docs/composition.md) · [Migração](docs/migration.md)
+Catálogo e ownership · Playbooks · Contrato de composição
 
 ## Instalação e portabilidade
 
-O pacote de cada skill é somente sua pasta em `skills/`. O [CLI crow-skills](docs/cli.md) instala cópias completas e versionadas em agentes/escopos explícitos, com preview, saída JSON, detecção de conflitos e recuperação. Requer Python 3.10+; Git para fontes em clone, Node 18+ para o launcher npm; mutações em macOS/Linux. A distribuição npm privada `@andespindola/crow-skills` inclui um snapshot completo das skills, sem clone ou hooks que as instalem automaticamente. No [Uniflow](docs/cli.md#uniflow), `--agents uniflow --global` grava as skills no store dele (`~/.config/uniflow/skills`), sem tocar no resto da configuração. Em `--global`, instalar a crow-behaviour também grava o guia aditivo do agente (claude, codex, gemini, devin) para usar as skills; `--no-guide` desliga. As integrações de interface (status lines do Claude Code, do Codex e do Antigravity, hooks do modo crow em cada CLI, comando `/crow`, segmento tmux) seguem o mesmo fluxo, preservando a configuração existente; `--no-integrations` desliga. O [barramento de eventos](docs/events.md) e a atualização automática (`crow-skills autoupdate on`) estão no [CLI](docs/cli.md).
+O pacote de cada skill é somente sua pasta em `skills/`. O [CLI crow-skills](docs/cli.md) instala cópias completas e versionadas em agentes/escopos explícitos, com preview, saída JSON, detecção de conflitos e recuperação. Requer Python 3.10+; Git para fontes em clone, Node 18+ para o launcher npm; mutações em macOS/Linux. A distribuição npm pública `@andespindola/crow-skills` inclui um snapshot completo das skills, sem clone ou hooks que as instalem automaticamente. No [Uniflow](docs/cli.md#uniflow), `--agents uniflow --global` grava as skills no store dele (`~/.config/uniflow/skills`), sem tocar no resto da configuração. Em `--global`, instalar a crow-behaviour também grava o guia aditivo do agente (claude, codex, gemini, devin) para usar as skills; `--no-guide` desliga. As integrações de interface (status lines do Claude Code, do Codex e do Antigravity, hooks do modo crow em cada CLI, comando `/crow`, segmento tmux) seguem o mesmo fluxo, preservando a configuração existente; `--no-integrations` desliga. O barramento de eventos e a atualização automática (`crow-skills autoupdate on`) estão no [CLI](docs/cli.md).
 
 ```sh
 npm install -g @andespindola/crow-skills@0.12.2
@@ -72,10 +72,10 @@ python3 -m unittest discover -s tests -v
 
 O checker verifica frontmatter no subconjunto YAML simples usado aqui, catálogo, owners únicos, referências locais autocontidas, handoffs válidos, placeholders e exposição de caminhos privados/credenciais. Não impõe limites artificiais ao corpo, não interpreta instruções das skills nem chama ferramentas externas.
 
-Os testes incluem mutações do pacote e invariantes de composição. Não medem a qualidade das respostas de um modelo. Avaliações comportamentais observadas, quando disponíveis, ficam em [docs/evaluations](docs/evaluations/README.md); não confundir texto esperado de fixture com teste executado por agente.
+Os testes incluem mutações do pacote e invariantes de composição. Não medem a qualidade das respostas de um modelo. Avaliações comportamentais observadas, quando disponíveis, ficam no repositório, fora do pacote distribuído; não confundir texto esperado de fixture com teste executado por agente.
 
 ## Manutenção
 
 Fonte canônica: SKILL.md para instruções, catalog.json para papel/ownership/handoffs. O checker exige sincronismo de nome, descrição e saída. Altere o menor escopo que resolve a falha demonstrada. Veja [CONTRIBUTING.md](CONTRIBUTING.md).
 
-Sem alegação de ganho percentual ou auditoria integral da biblioteca anterior. [Proveniência e limites](docs/provenance.md).
+Sem alegação de ganho percentual ou auditoria integral da biblioteca anterior. Proveniência e limites.

package/catalog.json

@@ -36,7 +36,7 @@
     {
       "name": "crow-behaviour",
       "title": "Atuação coordenada",
-      "description": "Use PROATIVAMENTE, sem o usuário pedir, em QUALQUER pedido que não seja conversa pura, pergunta factual curta ou ajuste trivial e local — inclusive quando é um arquivo só, uma decisão só ou só um plano: implementar uma feature, refatorar, depurar, auditar, revisar, migrar, planejar, pesquisar a fundo, tarefa multi-etapa, com exploração e decisões, ou que exija verificação antes de entregar. Carregue-a ANTES de começar; na dúvida, carregue. Nunca pergunte ao usuário se deve usá-la nem ofereça um critério mais estreito: com o modo crow ON a decisão já está tomada. Uma vez ativa, segue em uso nos prompts seguintes da sessão — mesmo plano, mesmo ledger e mesma validação por fases, retomados por conta própria quando faltarem. Ao ativar: decomponha o trabalho, delegue com as capacidades reais do runtime, verifique de forma adversarial e sintetize evidências. Não simule agentes nem altere permissões.",
+      "description": "Use PROATIVAMENTE, sem o usuário pedir, em QUALQUER pedido que não seja conversa pura, pergunta factual curta ou ajuste trivial e local — inclusive quando é um arquivo só, uma decisão só ou só um plano: implementar uma feature, refatorar, depurar, auditar, revisar, migrar, planejar, pesquisar a fundo, tarefa multi-etapa, com exploração e decisões, ou que exija verificação antes de entregar. Carregue-a ANTES de começar; na dúvida, carregue. Nunca pergunte ao usuário se deve usá-la nem ofereça critério mais estreito: com o modo crow ON a decisão já está tomada. Uma vez ativa, segue em uso nos prompts seguintes da sessão — mesmo plano, mesmo ledger e mesma validação por fases, retomados por conta própria quando faltarem. Ao ativar: decomponha, delegue o braçal a micro-agents de escopo mínimo com as capacidades reais do runtime, verifique de forma adversarial e sintetize evidências. Planejar, decidir, verificar e registrar são seus; o executor informa, você registra. Não simule agentes nem altere permissões.",
       "role": "coordinator",
       "owns": "execution-ledger",
       "next": []

package/crow_skills/__init__.py

@@ -1,3 +1,3 @@
 """Portable, local-first installer for the crow-skills catalogue."""
 
-__version__ = "0.22.0"
+__version__ = "0.24.0"

package/crow_skills/cli.py

@@ -48,6 +48,9 @@ COMMANDS = {
     "status": ("Instalações, guias, integrações, modo e autoupdate, por agente.", ["crow-skills status", "crow-skills status --agents claude"]),
     "doctor": ("Como status, com healthy true/false: skills editadas/ausentes, guia alterado, hooks não aprovados, transação pendente.",
                ["crow-skills doctor", "crow-skills doctor --json"]),
+    "skills": ("Versão de cada skill instalada e se está na revisão da fonte atual (latest) ou atrasada; somente leitura.",
+               ["crow-skills skills", "crow-skills skills --outdated", "crow-skills skills --json",
+                "crow-skills skills --agents claude --check-npm"]),
     "info": ("Detalhes de uma skill do catálogo.", ["crow-skills info crow-backend"]),
     "related": ("Handoffs, overlays e disponibilidade de complementos de uma skill.", ["crow-skills related crow-backend --agents claude --global"]),
     "install": ("Instala skills escolhidas em agentes e escopo explícitos, com preview, backup e transação.",
@@ -151,6 +154,10 @@ def parser():
     child.add_argument("topic", nargs="?", help="Comando, ou flags")
     for name in ("list", "groups", "agents", "status", "doctor"):
         command_parser(sub, name, [common])
+    child = command_parser(sub, "skills", [common])
+    child.add_argument("--outdated", action="store_true", help="Só as skills que não estão na revisão da fonte atual")
+    child.add_argument("--check-npm", dest="check_npm", action="store_true",
+                       help="Também consultar o npm se o crow-skills instalado é a última versão publicada (única chamada de rede)")
     for name in ("info", "related"):
         child = command_parser(sub, name, [common])
         child.add_argument("name")
@@ -978,6 +985,160 @@ def group_coverage(rows):
             for v in by_target.values() if v["names"]]
 
 
+# Estado de versão de uma skill instalada, contra a fonte deste crow-skills. "latest" é o único
+# estado em dia; os demais ou pedem conserto (update/install) ou não são instalação gerenciada.
+SKILL_STATE_WORDS = {
+    "latest": "igual à fonte atual",
+    "desatualizada": "revisão/origem diferente da fonte atual (crow-skills update)",
+    "modificada": "editada no disco",
+    "desativada": "instalada, mas desabilitada",
+    "ausente": "registrada e não encontrada no disco",
+    "nao_gerenciada": "não gerenciada por este CLI",
+    "indeterminada": "não foi possível ler o destino",
+}
+SKILL_PROBLEM_STATES = ("desatualizada", "modificada", "ausente")
+
+
+def skill_state(row, source):
+    """Classifica UMA linha de store.status contra `source`. Regra única, usada por `skills`,
+    `status` e `doctor` — a visibilidade e o veredito nunca podem discordar."""
+    status = row.get("status")
+    if status == "installed":
+        if row.get("revision") == source.revision and row.get("source") == str(source.path):
+            return "latest"
+        return "desatualizada"
+    if status == "modified":
+        return "modificada"
+    if status == "disabled":
+        return "desativada"
+    if status == "missing":
+        return "ausente"
+    if status in ("unmanaged", "absent", "external_link", "uniflow_link"):
+        return "nao_gerenciada"
+    return "indeterminada"  # "unsafe" e qualquer estado novo: nunca contado como em dia
+
+
+def outdated_rows(rows, source):
+    """Só as linhas instaladas atrasadas em relação à fonte: o que `status`/`doctor` precisam avisar."""
+    return [r for r in rows if r.get("name") and skill_state(r, source) == "desatualizada"]
+
+
+def outdated_warning(rows, source):
+    """Aviso skills_outdated (ou None). Mesmo texto em status e doctor."""
+    outdated = outdated_rows(rows, source)
+    if not outdated:
+        return None
+    names = sorted({r["name"] for r in outdated})
+    agents = sorted({a for r in outdated for a in (r.get("agents") or [])})
+    return {"code": "skills_outdated", "skills": names, "agents": agents,
+            "message": str(len(names)) + " skill(s) instalada(s) estão atrasadas em relação à fonte atual ("
+                       + short_revision(source.revision) + " em " + str(source.path) + "): "
+                       + ", ".join(names) + ". Veja detalhes com crow-skills skills --outdated.",
+            "fix": fix_command(agents)}
+
+
+def fix_command(agents):
+    """O comando exato que conserta: o mesmo texto no rodapé de `skills` e no aviso de status/doctor."""
+    return "crow-skills update --all --agents " + (",".join(agents) or ",".join(AGENTS)) + " --global --yes"
+
+
+def short_revision(revision):
+    return (str(revision)[:12] if revision else "—")
+
+
+def npm_latest():
+    """Última versão publicada do pacote npm, ou um motivo. Única chamada de rede do comando;
+    sem npm ou sem rede devolve reason e NUNCA inventa um número."""
+    import shutil
+    import subprocess
+    npm = shutil.which("npm")
+    if not npm:
+        return {"checked": False, "latest": None, "reason": "npm não encontrado no PATH"}
+    try:
+        done = subprocess.run([npm, "view", autoupdate.PACKAGE, "version"], capture_output=True, text=True,
+                              timeout=20, stdin=subprocess.DEVNULL, errors="replace")
+    except (OSError, subprocess.SubprocessError):
+        return {"checked": False, "latest": None, "reason": "a consulta ao npm falhou ou excedeu o tempo"}
+    latest = (done.stdout or "").strip().splitlines()
+    if done.returncode != 0 or not latest:
+        return {"checked": False, "latest": None, "reason": "o npm não respondeu uma versão"}
+    return {"checked": True, "latest": ui.clean(latest[-1].strip()), "reason": None}
+
+
+def skills_command(args, home, store):
+    """Somente leitura: versão e estado de cada skill instalada, contra a fonte atual."""
+    source = Source(getattr(args, "source", DEFAULT_SOURCE), getattr(args, "ref", "HEAD"))
+    targets = scope(args, home, read=True)
+    rows = store.status(targets)
+    items = {}
+    for row in rows:
+        if not row.get("name"):
+            continue
+        state = skill_state(row, source)
+        # Uma skill é UMA linha; agentes se agregam. Estados divergentes entre agentes viram
+        # linhas separadas, porque um "latest" não pode esconder um "desatualizada" ao lado.
+        item = items.setdefault((row["name"], state),
+                                {"name": row["name"], "state": state, "agents": [], "revisions": []})
+        for agent in row.get("agents") or []:
+            if agent not in item["agents"]:
+                item["agents"].append(agent)
+        if row.get("revision") and row["revision"] not in item["revisions"]:
+            item["revisions"].append(row["revision"])
+    skills = []
+    for key in sorted(items):
+        item = items[key]
+        skills.append({"name": item["name"], "agents": sorted(item["agents"]), "state": item["state"],
+                       "meaning": SKILL_STATE_WORDS[item["state"]],
+                       "revision": item["revisions"][0] if len(item["revisions"]) == 1 else None,
+                       "revisions": sorted(item["revisions"])})
+    shown = [s for s in skills if s["state"] != "latest"] if getattr(args, "outdated", False) else skills
+    counts = {state: len([s for s in skills if s["state"] == state]) for state in SKILL_PROBLEM_STATES}
+    affected = sorted({a for s in skills if s["state"] in SKILL_PROBLEM_STATES for a in s["agents"]})
+    data = {"version": __version__, "source": str(source.path), "revision": source.revision,
+            "skills": shown, "counts": counts, "outdated_only": bool(getattr(args, "outdated", False)),
+            "fix": fix_command(affected) if any(counts.values()) else None}
+    if getattr(args, "check_npm", False):
+        data["npm"] = {**npm_latest(), "installed": __version__}
+        if data["npm"]["checked"]:
+            data["npm"]["up_to_date"] = data["npm"]["latest"] == __version__
+    return data
+
+
+def render_skills(data, stream=None):
+    stream = stream or sys.stdout
+    lines = [ui.paint("crow-skills " + data["version"], "bold", stream) + " · fonte " + ui.clean(data["source"]) +
+             " · revisão " + short_revision(data["revision"]), ""]
+    if data["skills"]:
+        table = [[s["name"], ",".join(s["agents"]),
+                  short_revision(s["revision"]) if s["revision"] else
+                  (",".join(short_revision(r) for r in s["revisions"]) or "—"),
+                  s["state"]] for s in data["skills"]]
+        lines += ui.table(table, ["skill", "agentes", "revisão", "estado"], stream)
+    elif data["outdated_only"]:
+        lines.append("  " + ui.mark("ok", stream) + " Nenhuma skill fora da revisão da fonte atual.")
+    else:
+        lines.append("  Nenhuma skill instalada; comece com: crow-skills setup --yes")
+    npm = data.get("npm")
+    if npm:
+        if not npm["checked"]:
+            lines += ["", "  npm: não foi possível conferir a última versão publicada (" + ui.clean(npm["reason"]) + ")."]
+        elif npm.get("up_to_date"):
+            lines += ["", "  " + ui.mark("ok", stream) + " npm: " + npm["latest"] + " é a última publicada."]
+        else:
+            lines += ["", "  " + ui.mark("warn", stream) + " npm: instalado " + npm["installed"] + ", publicado " +
+                      npm["latest"] + ".\n  Para corrigir: crow-skills upgrade --yes"]
+    counts = data["counts"]
+    if any(counts.values()):
+        lines += ["", ui.mark("warn", stream) + " " +
+                  ", ".join(str(counts[s]) + " " + s + ("s" if counts[s] != 1 else "")
+                            for s in SKILL_PROBLEM_STATES if counts[s]) +
+                  "\n  Para corrigir: " + data["fix"]]
+        if counts["modificada"] or counts["ausente"]:
+            # O comando acima não toca o que foi editado/removido sem autorização explícita.
+            lines.append("  Skill editada ou ausente só é substituída acrescentando --overwrite-modified.")
+    return "\n".join(lines)
+
+
 def groups_command(args):
     source = Source(getattr(args, "source", DEFAULT_SOURCE), getattr(args, "ref", "HEAD"), getattr(args, "fetch", False))
     available = groups_mod.load(source)
@@ -1046,6 +1207,8 @@ def run(args):
         return data
     if args.command == "autoupdate":
         return autoupdate_command(args, home, store, interactive)
+    if args.command == "skills":
+        return skills_command(args, home, store)
     if args.command in ("status", "doctor"):
         targets = scope(args, home, read=True)
         rows = unmanaged_projections(store, home, store.status(targets))
@@ -1086,6 +1249,13 @@ def run(args):
                                 "Codex continua carregando de lá.",
                      "fix": "crow-skills setup --agents codex --yes  (instala no diretório do Codex e migra), ou "
                             "crow-skills uninstall " + ",".join(leftovers) + " --dest " + str(legacy_shared_dir(home)) + " --yes"})
+        try:
+            current = Source(getattr(args, "source", DEFAULT_SOURCE), getattr(args, "ref", "HEAD"))
+        except (CrowError, OSError):
+            current = None  # sem fonte legível não há com o que comparar; nenhum aviso inventado
+        outdated = outdated_warning(rows, current) if current is not None else None
+        if outdated:
+            result.setdefault("warnings", []).append(outdated)
         result["groups"] = group_coverage(rows)
         try:
             result["autoupdate"] = autoupdate.status(store, home) if global_view else None
@@ -1095,7 +1265,10 @@ def run(args):
         result["hooks"] = [{"integration": r["integration"], "agents": r.get("agents"), "state": r["enabled"].get("state"),
                             "fix": r["enabled"].get("fix")} for r in hooks]
         if args.command == "doctor":
-            result.update(healthy=not pending and all(r["status"] not in ("modified", "missing", "unsafe", "external_link") for r in rows + guides)
+            # Uma skill instalada atrasada em relação à fonte não é "healthy": o doctor existe para
+            # dizer que falta rodar o update, não para dar ✓ com pacote velho no disco.
+            result.update(healthy=not pending and not outdated
+                          and all(r["status"] not in ("modified", "missing", "unsafe", "external_link") for r in rows + guides)
                           and (result["autoupdate"] or {}).get("healthy", True) is not False
                           and all(h["state"] not in machine.BAD_HOOKS for h in result["hooks"]),
                           agents=inventory(home))
@@ -1300,6 +1473,8 @@ def emit(command, data, as_json):
         print(machine.render_upgrade(data))
     elif command in ("status", "doctor"):
         print(render_status(data, doctor=command == "doctor"))
+    elif command == "skills":
+        print(render_skills(data))
     elif command == "progress":
         if data is not None:
             print(data["text"] or "crow: nenhuma execução registrada neste diretório.")

package/crow_skills/guide.py

@@ -256,6 +256,9 @@ def render_body(agent, catalog, revision, skills):
         "- Qualquer pedido que não seja conversa pura, pergunta factual curta ou ajuste trivial e local — inclusive quando é um arquivo só, uma decisão só ou só um plano: carregue a skill crow-behaviour ANTES de começar, por iniciativa própria, sem esperar pedido. Para carregar, " + mech["load"] + "; por exemplo, " + invoke(name="crow-behaviour") + ". Siga-a até a entrega.",
         "- Vale também quando a entrega é só um plano, um diagnóstico ou uma revisão, ou quando não há código no diretório: depurar, auditar, investigar, migrar ou planejar uma mudança continua entrando. Na dúvida, carregue.",
         "- Uma vez ativa, ela segue em uso nos prompts seguintes da sessão: mesmo plano, mesmo ledger e mesma validação por fases, e cada novo pedido entra como unidade nova em vez de recomeçar sem registro. Se perceber que parou de mantê-los, retome na mesma resposta, registre a lacuna e siga — sem pedir permissão.",
+        "- Com ela ativa, o braçal é delegado por padrão: unidade cujo resultado você consegue especificar e aceitar pela evidência vai para um micro-agent de escopo mínimo e focado, com uma saída e nada \"enquanto estiver lá\". Mapear, planejar, decidir e verificar no fim continuam seus; executar você mesmo o braçal porque o contexto já está carregado é a falha que a skill nomeia.",
+        "- O micro-agent não recebe responsabilidade além de executar o que foi delegado: não grava memória nem notas, não mantém nada em sincronia, não mexe em git, não avisa outras sessões e não amplia o escopo — ele informa tudo a você no retorno (o que mudou, a saída real, o que não verificou, o que falhou, o que ficou pela metade).",
+        "- Salvar na memória durável e manter tudo em sincronia é seu e não se delega, e o registro acontece à medida que os retornos chegam, não num mutirão no fim: o retorno do executor é a única fonte do registro, e retorno não registrado é trabalho que ninguém sabe que foi feito.",
         "- Conversa, pergunta factual curta ou ajuste trivial e local: responda direto, sem carregá-la.",
         "",
         "## Skills especialistas",

package/crow_skills/integrations.py

@@ -344,6 +344,53 @@ GEMINI_EVENTS = ["SessionStart", "BeforeAgent", "BeforeTool", "AfterTool", "Afte
 AGY_EVENTS = ["SessionStart", "PreToolUse", "PostToolUse", "PreInvocation", "PostInvocation", "Stop"]
 DEVIN_EVENTS = ["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "PermissionRequest", "SubagentStop", "Stop",
                 "SessionEnd"]
+_DEVIN_ACCEPTED = {}
+
+
+def devin_accepted():
+    """(eventos aceitos | None, motivo da falha): a sonda do devin, uma vez por binário no processo."""
+    binary = hooktrust.devin_binary()
+    # Pelo caminho RESOLVIDO: o devin se atualiza repontando ~/.local/bin/devin -> _versions/current,
+    # e uma imagem com mtimes normalizados (OCI, Nix) não mudaria a chave. Sem exists() antes do
+    # getmtime: entre os dois o symlink pode ser repontado, e aí a resposta é "não deu para perguntar".
+    try:
+        resolved = os.path.realpath(binary) if binary else None
+        key = (resolved, os.path.getmtime(resolved) if resolved else None)
+    except OSError as exc:
+        return None, "o binário do devin mudou enquanto era consultado (" + exc.__class__.__name__ + ")"
+    if key not in _DEVIN_ACCEPTED:
+        try:
+            _DEVIN_ACCEPTED[key] = (list(hooktrust.devin_hook_events(binary)), None)
+        except hooktrust.ProbeError as exc:
+            _DEVIN_ACCEPTED[key] = (None, str(exc))
+    return _DEVIN_ACCEPTED[key]
+
+
+def devin_events():
+    """(events, note): the DEVIN_EVENTS this devin really accepts, plus what was dropped and why.
+
+    devin discards its ENTIRE hooks block when it rejects a single event, so an event this build
+    does not know would silently turn off every crow hook while the config still looked installed.
+    The accepted list is read from devin (trust.devin_hook_events); when devin cannot be asked, the
+    conservative baseline is written instead of guessing."""
+    accepted, failure = devin_accepted()
+    allowed = accepted if accepted is not None else list(hooktrust.DEVIN_BASELINE)
+    events = [e for e in DEVIN_EVENTS if e in allowed]
+    dropped = [e for e in DEVIN_EVENTS if e not in allowed]
+    if not events and accepted is not None:
+        # Nenhum evento em comum. O baseline NÃO serve de plano B aqui: seriam eventos que este
+        # devin recusa, e um evento recusado derruba o bloco inteiro. Melhor não gravar nada.
+        return [], ("Este devin não aceita nenhum dos eventos que o crow-skills usa (aceita: "
+                    + ", ".join(accepted) + "); os hooks não foram gravados, porque um evento recusado "
+                    "faz o devin descartar o bloco hooks inteiro.")
+    note = None
+    if dropped and accepted is not None:
+        note = ("Este devin não conhece " + ", ".join(dropped) + "; os eventos foram omitidos. Um evento desconhecido "
+                "faz o devin descartar o bloco hooks inteiro, então todos os hooks do crow-skills ficariam sem rodar.")
+    elif dropped:
+        note = ("Não foi possível perguntar ao devin quais eventos ele aceita (" + (failure or "motivo desconhecido")
+                + "); escritos só os eventos que todo devin conhecido aceita, sem " + ", ".join(dropped) + ".")
+    return events, note
 AGY_KEY = "crow-skills"
 
 
@@ -410,7 +457,7 @@ def hook_entries(store, home, python, host):
     if host == "agy":
         return {e: ([{"matcher": "", "hooks": [{"type": "command", "command": command(e), "timeout": 3}]}] if e in AGY_GROUPED
                     else [{"type": "command", "command": command(e), "timeout": 3}]) for e in AGY_EVENTS}
-    return {e: [{"hooks": [{"type": "command", "command": command(e)}]}] for e in DEVIN_EVENTS}
+    return {e: [{"hooks": [{"type": "command", "command": command(e)}]}] for e in devin_events()[0]}
 
 
 def is_ours(entry, store):
@@ -540,6 +587,11 @@ def hooks_sync(name, store, home, record, desired, python, dry):
         return None, "remove", None
     if not quoted_ok(python, hook_script_path(store), home):
         return record, "skip", "Caminho do Python, do estado ou do home contém aspas/variáveis; hooks não configurados."
+    if spec["host"] == "devin":
+        events, devin_note = devin_events()
+        if not events:
+            # Gravar um bloco vazio diria "instalado" sem hook nenhum, e a nota se perderia.
+            return (record if desired else None), "skip", devin_note
     entries = hook_entries(store, home, python, spec["host"])
     wanted = refresh_in_place(data, entries, store, spec["layout"]) or add_hooks(stripped, entries, spec["layout"])
     if wanted == data:
@@ -552,6 +604,8 @@ def hooks_sync(name, store, home, record, desired, python, dry):
     note = None
     if spec["host"] == "codex":
         note = (codex_approval_note() + codex_hooks_feature(home)).strip() or None
+    elif spec["host"] == "devin":
+        note = devin_events()[1]
     if dry:
         return new_record, action, note
     tracked_write(store, path, dump(wanted), old, spec["backup"])
@@ -1278,9 +1332,59 @@ def sync(store, home, wanted, dry_run=False, python=None, trust=True):
     return report
 
 
+def devin_hooks_state(home, probe):
+    """Whether devin will run the hooks written in its config: {state, fix?}.
+
+    One event devin does not know makes it discard the whole hooks block, so a config that looks
+    installed can run nothing. Reported instead of a green tick; the events in the file are
+    compared with the list devin itself gives."""
+    base = hooktrust.non_codex_state("devin", home)
+    path = devin_dir(home) / "config.json"
+    try:
+        _, data, problem = read_json_object(protect(path, home), "~/.config/devin/config.json")
+    except CrowError as exc:
+        # Arquivo irregular (symlink, hard link, ilegível): antes isto estourava daqui e o chamador
+        # engolia a exceção, derrubando o relatório de integrações INTEIRO e ainda imprimindo healthy.
+        return dict(base, state="unknown", fix="~/.config/devin/config.json não pôde ser lido (" + str(exc) + ").")
+    if problem:
+        return dict(base, state="unknown", fix=problem)
+    if "hooks" not in data:
+        return base
+    block = data.get("hooks")
+    if not isinstance(block, dict):
+        # O devin exige um mapa: "invalid type: sequence, expected a map" e descarta o bloco todo.
+        return {"state": "feature_off",
+                "fix": ("A chave hooks de ~/.config/devin/config.json não é um objeto JSON; o devin descarta o bloco "
+                        "inteiro e nenhum hook roda. Corrija o arquivo e rode crow-skills integrations install.")}
+    if not block:
+        return base
+    written = list(block)
+    if not probe:
+        # Sem sonda dá para responder offline o caso comum: tudo o que está escrito é do conjunto
+        # que todo devin conhecido aceita. Só o que está fora disso precisa perguntar ao devin.
+        outside = [e for e in written if e not in hooktrust.DEVIN_BASELINE]
+        if not outside:
+            return base
+        return dict(base, state="unknown",
+                    fix=("Evento(s) fora do conjunto que todo devin aceita (" + ", ".join(outside)
+                         + "); rode crow-skills doctor para conferir com o devin instalado."))
+    accepted, failure = devin_accepted()  # mesma sonda em cache: instalar e relatar não paga duas vezes
+    if accepted is None:
+        return dict(base, state="unknown", fix="Não foi possível perguntar ao devin quais eventos ele aceita (" + str(failure) + ").")
+    foreign = [e for e in written if e not in accepted]
+    if foreign:
+        return {"state": "feature_off",
+                "fix": ("~/.config/devin/config.json tem evento(s) que este devin não conhece (" + ", ".join(foreign)
+                        + "); ele descarta o bloco hooks INTEIRO, então nenhum hook roda. Rode crow-skills integrations install "
+                        "para regravar só os eventos aceitos (ou remova os eventos que não são do crow-skills).")}
+    return base
+
+
 def hooks_enabled(name, store, home, record, probe=True):
     """Whether the CLI will actually run the crow hooks: {state, fix?} (see trust.py)."""
     host = HOOKS[name]["host"]
+    if host == "devin":
+        return devin_hooks_state(home, probe)
     if host != "codex":
         return hooktrust.non_codex_state(host, home)
     base = {}

package/crow_skills/storage.py

@@ -638,5 +638,9 @@ class Store:
                     status = "unsafe"
                 rows.append({"name": name, "target": str(target), "agents": target_info["agents"],
                              "status": status, "revision": record.get("revision") if record else None,
+                             # Origem e digest do pacote registrado: é o que permite dizer "atrasada em
+                             # relação a esta fonte" sem reabrir o pacote (a mesma regra de `plan`).
+                             "package_sha256": record.get("package_sha256") if record else None,
+                             "source": record.get("source") if record else None,
                              "activation_verified": False})
         return rows

package/crow_skills/trust.py

@@ -24,10 +24,12 @@ reported from their own feature flags.
 """
 import json
 import os
+import pathlib
 import queue
 import re
 import shutil
 import subprocess
+import tempfile
 import threading
 import time
 
@@ -50,6 +52,77 @@ def codex_binary():
     return shutil.which("codex")
 
 
+# The hook events every devin build known to the project accepts (measured on 3000.11.3, the
+# oldest installed here). Used only when devin cannot be asked; never a claim about the build
+# in front of us, which is what devin_hook_events() goes and reads.
+DEVIN_BASELINE = ("PreToolUse", "PostToolUse", "UserPromptSubmit", "Stop", "PostCompaction",
+                  "SessionStart", "SessionEnd", "PermissionRequest")
+DEVIN_PROBE_EVENT = "CrowSkillsCapabilityProbe"
+# Measured: `devin doctor` answers in 0.56 s. This sits on the install path, so the ceiling is
+# short on purpose — a wedged devin costs a conservative fallback, not a stalled install.
+DEVIN_PROBE_TIMEOUT = 8.0
+# Anchored on THREE things, because devin words every rejected enum the same way and emits the
+# others first (theme_mode, ProxyMode, UnicodeMode): the key must be "hooks", the refused variant
+# must be our probe event, and the list must end at devin's own ". Using the default", so a line
+# that was wrapped, truncated or colorized does not match at all. Not matching is a ProbeError and
+# a conservative fallback; a PARTIAL match would be a short list written as if complete, which is
+# the silent-disable this whole probe exists to prevent.
+_DEVIN_EXPECTED = re.compile(
+    r'invalid value for "hooks" in [^\n]*?: unknown variant `(?P<refused>[^`\n]*)`, '
+    r'expected one of (?P<accepted>`[^`\n]+`(?:, `[^`\n]+`)*)\. Using the default')
+
+
+def devin_binary():
+    """The devin executable, or None. CROW_SKILLS_DEVIN overrides PATH (empty: treat as absent)."""
+    override = os.environ.get("CROW_SKILLS_DEVIN")
+    if override is not None:
+        return override if override and os.path.isfile(override) and os.access(override, os.X_OK) else None
+    return shutil.which("devin")
+
+
+def devin_hook_events(binary=None, timeout=None):
+    """The hook events the installed devin accepts, asked of devin itself.
+
+    devin validates config.json's `hooks` against its own enum and, rejecting one event, names
+    every event it knows: "unknown variant `X`, expected one of `A`, `B`, ...". It also drops the
+    WHOLE hooks block when it rejects a single event ("Using the default ({})"), so writing an
+    event this build does not know silently disables every crow hook. One deliberately invalid
+    event in a throwaway config directory turns that refusal into a capability list; the probe
+    pins XDG_CONFIG_HOME at the throwaway, so the user's ~/.config/devin/config.json is never
+    read and never written.
+
+    Raises ProbeError with a short reason (never devin's whole output)."""
+    binary = binary or devin_binary()
+    timeout = DEVIN_PROBE_TIMEOUT if timeout is None else timeout
+    if not binary:
+        raise ProbeError("devin não encontrado no PATH")
+    with tempfile.TemporaryDirectory(prefix="crow-devin-probe-") as temp:
+        config = pathlib.Path(temp) / "devin"
+        config.mkdir()
+        (config / "config.json").write_text(json.dumps(
+            {"version": 1, "hooks": {DEVIN_PROBE_EVENT: [{"hooks": [{"type": "command", "command": "true"}]}]}}),
+            encoding="utf-8")
+        env = dict(os.environ, XDG_CONFIG_HOME=temp)
+        try:
+            done = subprocess.run([binary, "doctor"], cwd=temp, env=env, timeout=timeout,
+                                  stdin=subprocess.DEVNULL, capture_output=True, text=True,
+                                  encoding="utf-8", errors="replace")
+        except subprocess.TimeoutExpired:
+            raise ProbeError("devin doctor não respondeu em " + str(int(timeout)) + " s")
+        except OSError as exc:
+            raise ProbeError("devin doctor não iniciou (" + exc.__class__.__name__ + ")")
+    found = _DEVIN_EXPECTED.search((done.stderr or "") + "\n" + (done.stdout or ""))
+    if not found:
+        raise ProbeError("devin não listou os eventos aceitos de hooks")
+    if found.group("refused") != DEVIN_PROBE_EVENT:
+        # Outro evento foi recusado: a lista pode não ser a resposta à nossa sonda.
+        raise ProbeError("devin recusou " + (found.group("refused") or "um evento") + ", não a sonda")
+    events = re.findall(r"`([^`]+)`", found.group("accepted"))
+    if not events:
+        raise ProbeError("lista de eventos do devin vazia")
+    return events
+
+
 def camel(event):
     return event[:1].lower() + event[1:]
 

package/docs/cli-security.md

@@ -30,6 +30,6 @@ Esta tabela define ameaça/controle, não é um certificado de segurança. Resul
 
 ## Snapshot npm
 
-O launcher usa spawn sem shell e Python isolado (`-I`), evitando import do cwd/PYTHONPATH. Não há dependências npm nem hooks de instalação. Prepack verifica bytes commitados e rejeita arquivos extras nas globs de publicação; caches Python são explicitamente excluídos. O smoke valida o tarball inteiro contra allowlist/hashes antes de instalar em perfil isolado. Checksums não provam autoria: distribuição depende da integridade/autorização do registro npm. Publicação deve ser escopada e restricted, sem fallback público.
+O launcher usa spawn sem shell e Python isolado (`-I`), evitando import do cwd/PYTHONPATH. Não há dependências npm nem hooks de instalação. Prepack verifica bytes commitados e rejeita arquivos extras nas globs de publicação; caches Python são explicitamente excluídos. O smoke valida o tarball inteiro contra allowlist/hashes antes de instalar em perfil isolado. Checksums não provam autoria: distribuição depende da integridade/autorização do registro npm. Publicação deve ser escopada e pública (0.23.0), sem volta silenciosa para restricted: o prepack e o smoke reprovam. O smoke também varre o payload publicado em busca de caminho para ferramenta externa de engenharia reversa (invocação, verificação de presença no PATH, instalação por gerenciador de pacotes ou identificador de evidência dela) e reprova a publicação se encontrar, inclusive em documentação. Varredura não prova ausência de toda referência possível.
 
 Resultados, falhas corrigidas e limites: [avaliação do CLI](evaluations/2026-10-20-cli.md).