@andespindola/crow-skills 0.23.0 → 0.25.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,173 @@ 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",
+    "via_uniflow": "projetada do seu store do Uniflow (gerenciada em --agents uniflow)",
+    "link_externo": "link no store do Uniflow para fora dele",
+    "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 == "uniflow_link":
+        # Projeção SAUDÁVEL do store do Uniflow: é a topologia normal de quem instala em uniflow e
+        # deixa os CLIs lerem de lá, e o resto do CLI já a conta como instalada (group_coverage).
+        # Chamar isso de "não gerenciada" assustava sem motivo — 33 skills em 4 agentes, aqui.
+        # Projeção quebrada, desabilitada ou para pacote não gerenciado não chega como uniflow_link:
+        # unmanaged_projections() a reescreve antes (modified/disabled/unmanaged).
+        return "via_uniflow"
+    if status == "external_link":
+        return "link_externo"
+    if status in ("unmanaged", "absent"):
+        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)
+    # A mesma correção que status/doctor aplicam: projeção do Uniflow quebrada, desabilitada ou para
+    # pacote não gerenciado não pode passar por projeção saudável.
+    rows = unmanaged_projections(store, home, 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 +1220,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 +1262,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 +1278,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 +1486,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.md

@@ -69,6 +69,8 @@ Nome: `@andespindola/crow-skills`; `publishConfig.access` é `public` desde a 0.
 
 A publicação é feita pelo workflow `.github/workflows/publish.yml` ao empurrar uma tag `vX.Y.Z` igual à `version` do `package.json` (ou por `workflow_dispatch` em `main`). Ele autentica por Trusted Publishing (OIDC), sem token npm em secret, e roda check, testes e o teste de instalação isolada antes de `npm publish`. O trusted publisher do pacote no npmjs.com deve apontar para `andersonflima/crow-skills` e `publish.yml`.
 
+Depois do `npm publish`, o pipeline confirma a versão no próprio registry: consulta `https://registry.npmjs.org/@andespindola%2Fcrow-skills` sem npm e sem credencial e espera a versão do `package.json` aparecer em `.versions` e virar o `dist-tags.latest`, tentando a cada 20 s por até 15 minutos e registrando cada tentativa no log. Isso existe porque o log do `npm publish` sozinho não distingue uma publicação real de um `--dry-run` (que imprime um `+ pacote@versao` praticamente igual) nem de um passo pulado por gate, que deixa o job verde sem ter publicado nada. Propagação de alguns minutos até dezenas de minutos é normal e **não** é falha: passado o teto, o job termina com sucesso e emite um aviso com o comando `curl -s https://registry.npmjs.org/@andespindola%2Fcrow-skills | jq -r '.["dist-tags"].latest'` para conferir depois.
+
 Depois de a versão estar publicada e a conta estar autenticada com acesso:
 
 ```sh
@@ -142,6 +144,8 @@ Desde a 0.8.0, a origem registrada é também uma identidade (`source_id`): `git
 ```sh
 crow-skills status --agents claude,codex --global
 crow-skills doctor --agents claude,codex --global --json
+crow-skills skills                                     # versão e estado de cada skill instalada
+crow-skills skills --outdated                          # só o que não está na revisão da fonte
 crow-skills uninstall crow-debug --agents claude --global --yes
 crow-skills rollback --transaction ID_RETORNADO --dry-run
 crow-skills rollback --transaction ID_RETORNADO --yes
@@ -161,6 +165,31 @@ crow-skills recover --yes
 
 Transações protegem contra falhas comuns/interrupção de processo, não contra toda falha de hardware/filesystem. Locks coordenam processos deste CLI no mesmo perfil, não um processo hostil ou editor concorrente com as mesmas permissões do usuário. Não edite a instalação enquanto a operação estiver aplicando.
 
+## Versões das skills (skills)
+
+```sh
+crow-skills skills                              # todas, por skill e agente
+crow-skills skills --outdated                   # só o que não está em dia
+crow-skills skills --agents claude --json       # para automação
+crow-skills skills --check-npm                  # também confere a última versão publicada no npm
+```
+
+`skills` é somente leitura: não grava estado, não instala e não consulta a rede (a única exceção é `--check-npm`). Mostra, no cabeçalho, a versão do crow-skills, o caminho da fonte e a revisão curta (12 hex) dela; depois uma linha por skill com `skill | agentes | revisão | estado`. Uma skill instalada em mais de um agente é uma linha só, com os agentes agregados; quando os estados divergem entre agentes, cada estado vira a sua linha.
+
+| Estado | Significado |
+|---|---|
+| `latest` | instalada e igual à fonte atual deste crow-skills: mesmo conteúdo, mesma revisão e mesma origem registrada. É o único estado em dia. |
+| `desatualizada` | instalada e íntegra, mas a revisão ou a origem registrada não é a da fonte atual: falta rodar `update`. |
+| `modificada` | editada no disco; `update` só a substitui com `--overwrite-modified`. |
+| `desativada` | instalada e desabilitada (por exemplo, pelo Uniflow). |
+| `ausente` | registrada no estado e não encontrada no disco. |
+| `nao_gerenciada` | o que está ali não é uma instalação gerenciada por este CLI (pacote de terceiros, link do Uniflow, destino vazio). |
+| `indeterminada` | não foi possível ler o destino com segurança (`unsafe`). |
+
+O rodapé só aparece quando há problema: quantas desatualizadas, modificadas e ausentes, e o comando exato que conserta, `crow-skills update --all --agents <agentes afetados> --global --yes` (com uma linha a mais lembrando que skill editada ou ausente só é substituída acrescentando `--overwrite-modified`). Com `--check-npm`, uma consulta a `npm view @andespindola/crow-skills version` diz se o CLI instalado é a última versão publicada; sem npm no PATH, sem rede ou com erro, o comando informa que não deu para conferir e nunca inventa um número.
+
+`status` e `doctor` usam a mesma classificação e passaram a avisar quando há skill instalada atrasada em relação à fonte: aviso `skills_outdated` (campos `skills`, `agents`, `message`, `fix`) no `--json` e a mesma linha com `Para corrigir:` na saída humana. O `doctor` fica `healthy:false` nesse estado — uma skill velha no disco não é mais `✓ healthy` — e volta a `healthy:true` depois do `update`.
+
 ## Automação por agente
 
 ```sh
@@ -348,9 +377,42 @@ Aplicadas por padrão junto com `install`/`update` em `--global` para os agentes
 | gemini-command | gemini (Gemini CLI) | `~/.gemini/commands/crow.toml` (arquivo próprio) | `/crow on\|off\|status` por `!{…}` (o Gemini pede confirmação do shell, salvo política que o permita) |
 | agy-hooks | gemini (Antigravity) | chave `crow-skills` em `~/.gemini/config/hooks.json` | modo por prompt (`PreInvocation` → `injectSteps`), `/crow …` interceptado quando o agy envia o texto (`lastUserInput`, 1.4.7+), eventos (`PreToolUse`/`PostToolUse` agrupados com `matcher`, como o agy exige) |
 | agy-statusline | gemini (Antigravity) | `statusLine` em `~/.gemini/antigravity-cli/settings.json` com `stack_with_default: true` | indicador e lista de processos empilhados sob a linha padrão do agy |
-| devin-hooks | devin | `hooks` em `~/.config/devin/config.json` | modo por prompt, `/crow …` interceptado, `systemMessage` quando muda, eventos |
+| devin-hooks | devin | `hooks` em `~/.config/devin/config.json` | modo por prompt, `/crow …` interceptado, `systemMessage` quando muda, eventos — só os que a build instalada aceita (veja "Eventos do devin") |
 | tmux-status | claude, codex, gemini (agy), devin | `~/.config/crow-skills/tmux.conf` (arquivo próprio) e um bloco `source-file -q` no fim do seu `tmux.conf` | `▸▸ crow on · crow ▸ …` acrescentado ao `status-right` (`set -ag`, sem substituir o seu), com o diretório do painel ativo |
 
+### Eventos do devin
+
+O devin valida a chave `hooks` contra o enum de eventos da build instalada e, ao recusar **um**
+evento, descarta o **bloco inteiro** ("Using the default ({}) for this setting"). Um evento que a
+sua build não conhece não degradaria um hook: desligaria todos, com o arquivo parecendo instalado.
+
+Por isso a lista não é presumida, é perguntada. Antes de gravar, o crow-skills põe um evento
+propositalmente inválido num `config.json` descartável, aponta `XDG_CONFIG_HOME` para ele e roda
+`devin doctor` (medido: 0,56 s, teto de 8 s): ao recusar, o devin nomeia todos os eventos que
+conhece. O seu `~/.config/devin/config.json` não é lido nem escrito nessa consulta, e só os eventos
+aceitos são gravados — os omitidos aparecem na nota da integração.
+
+A leitura dessa resposta é deliberadamente exigente, porque o devin usa a mesma frase para todo
+enum que recusa (`theme_mode`, `ProxyMode`) e os outros avisos saem antes. Só vale a mensagem que
+fala da chave `hooks`, que recusa exatamente o evento da sonda e cuja lista termina no
+`. Using the default` do próprio devin. Qualquer coisa fora disso — lista quebrada em duas linhas,
+texto colorido, mensagem traduzida — **não casa**, e não casar é tratado como "não deu para
+perguntar". Uma lista lida pela metade seria pior que falha nenhuma: gravaria quatro eventos como
+se fossem oito e os outros hooks desapareceriam em silêncio.
+
+Quando o devin não pode ser consultado (ausente do PATH, sem responder, binário trocado no meio da
+consulta), o crow-skills grava apenas os eventos que toda build conhecida aceita e diz isso, em vez
+de adivinhar. Se a resposta do devin for válida mas não tiver **nenhum** evento em comum com os que
+o crow-skills usa, nada é gravado e a integração é recusada com essa explicação — cair no conjunto
+conservador ali seria gravar justamente o que aquela build recusa.
+
+`crow-skills doctor` reconsulta e reporta `devin-hooks` como desabilitado, em vez de ✓, quando o
+arquivo tem evento que a build atual recusa (um downgrade do devin, por exemplo) ou quando a chave
+`hooks` não é um objeto JSON — o devin descarta o bloco nos dois casos. Arquivo ilegível ou com
+hard link vira "não verificado" com o motivo, sem derrubar o resto do relatório. O `status`, que não
+consulta o devin, responde verde offline quando tudo o que está escrito pertence ao conjunto
+conservador, e só pede o `doctor` quando há evento fora dele.
+
 Regras de preservação:
 
 - Antes de editar, o arquivo original vai para `~/.local/state/crow-skills/integrations/backups/` (privado). Gravação atômica, nunca através de symlink ou hard link; prompts compartilhados e `~/.config/uniflow` são recusados como no guia.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andespindola/crow-skills",
-  "version": "0.23.0",
+  "version": "0.25.0",
   "description": "Versioned, complementary agent skills with a protected multi-agent installer",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {
@@ -12,6 +12,7 @@
   },
   "files": [
     "LICENSE",
+    "THIRD-PARTY-NOTICES.md",
     "bin/npm-crow-skills.cjs",
     "crow_skills/*.py",
     "catalog.json",