@andespindola/crow-skills 0.8.0 → 0.10.0

package/skills/crow-behaviour/scripts/crow_ledger.py

@@ -8,6 +8,8 @@ coordinator records the transition.
   crow_ledger.py start --title "..." --host claude [--phase id=Título ...] [--session ID] [--global]
   crow_ledger.py phase ID --run RUN [--title T] [--status running|done|...]
   crow_ledger.py unit ID --run RUN [--title T] [--phase P] [--owner O] [--status S] [--progress 0..1] [--summary TXT]
+  crow_ledger.py resources --run RUN [--from-probe FILE|-] [--mode M] [--agents N] [--heavy N] [--workers N]
+                [--pressure L] [--source probe|os|assumed] [--note TXT]   # parallelism decision before a fan-out
   crow_ledger.py finish --run RUN [--status done|failed|cancelled]
   crow_ledger.py show [--run RUN]         # process list for the chat (● main / ○ owner  activity)
   crow_ledger.py show --tree [--run RUN]  # phase tree with ASCII bars, when the user asks for detail
@@ -37,6 +39,9 @@ import tempfile
 SCHEMA = "crow-run/1"
 UNIT_STATUSES = ("pending", "running", "done", "failed", "skipped")
 RUN_STATUSES = ("running", "done", "failed", "cancelled")
+RESOURCE_MODES = ("parallel", "reduced", "sequential")
+RESOURCE_LEVELS = ("normal", "warn", "critical", "unknown")
+RESOURCE_SOURCES = ("probe", "os", "assumed")
 
 
 def now():
@@ -146,6 +151,39 @@ def locate(run_id=None, write=False):
     return best[1], best[2]
 
 
+def probe_decision(text):
+    """Fields of a resources decision from `crow-skills resources --json` (envelope or bare document)."""
+    try:
+        data = json.loads(text)
+    except ValueError:
+        raise SystemExit("crow_ledger: --from-probe não é JSON.")
+    if isinstance(data, dict) and isinstance(data.get("data"), dict):
+        data = data["data"]
+    if not isinstance(data, dict) or data.get("schema") != "crow-resources/1":
+        raise SystemExit("crow_ledger: --from-probe não é um documento crow-resources/1.")
+    rec = data.get("recommendation") or {}
+    return {"mode": rec.get("mode"), "maxParallelAgents": rec.get("maxParallelAgents"),
+            "maxParallelHeavyJobs": rec.get("maxParallelHeavyJobs"), "maxWorkersPerJob": rec.get("maxWorkersPerJob"),
+            "pressure": (data.get("pressure") or {}).get("level"), "source": "probe"}
+
+
+def resources_text(data):
+    value = data.get("resources")
+    if not isinstance(value, dict) or not value.get("mode"):
+        return ""
+    def count(key):
+        number = value.get(key)
+        return number if isinstance(number, int) and not isinstance(number, bool) else None
+    parts = [clean(value["mode"], 20)]
+    if count("maxParallelAgents") is not None:
+        parts.append("<=" + str(count("maxParallelAgents")) + " agente(s)")
+    if count("maxParallelHeavyJobs") is not None:
+        parts.append("<=" + str(count("maxParallelHeavyJobs")) + " job(s) pesado(s)")
+    if value.get("pressure"):
+        parts.append("pressão " + clean(value["pressure"], 20))
+    return "recursos: " + " - ".join(parts) + (" (" + clean(value["note"]) + ")" if value.get("note") else "")
+
+
 def bar(fraction, width=20):
     filled = int(round(max(0.0, min(1.0, fraction)) * width))
     return "[" + "#" * filled + "-" * (width - filled) + "]"
@@ -203,6 +241,8 @@ def render(data):
     icons = {"done": "x", "running": ">", "failed": "!", "pending": " ", "skipped": "-"}
     lines = ["crow > " + clean(data.get("title")) + " [" + data.get("status", "running") + "]",
              bar(overall) + " " + str(int(overall * 100)) + "%  " + str(done) + "/" + str(len(counted)) + " unidades"]
+    if resources_text(data):
+        lines.append(resources_text(data))
     phases = data.get("phases", []) or []
     known = [p.get("id") for p in phases]
     groups = [(p.get("title") or p.get("id"), [u for u in units if u.get("phase") == p.get("id")]) for p in phases]
@@ -245,6 +285,15 @@ def main(argv=None):
     unit.add_argument("--status", choices=UNIT_STATUSES)
     unit.add_argument("--progress", type=float)
     unit.add_argument("--summary")
+    res = sub.add_parser("resources", help="registra a decisão de paralelismo (antes de um fan-out)")
+    res.add_argument("--from-probe", help="arquivo com a saída de crow-skills resources --json, ou - para stdin")
+    res.add_argument("--mode", choices=RESOURCE_MODES)
+    res.add_argument("--agents", type=int, help="máximo de agentes em paralelo decidido")
+    res.add_argument("--heavy", type=int, help="máximo de jobs pesados (build, suíte, dev server) em paralelo")
+    res.add_argument("--workers", type=int, help="workers por job (-j, --maxWorkers, pytest -n)")
+    res.add_argument("--pressure", choices=RESOURCE_LEVELS)
+    res.add_argument("--source", choices=RESOURCE_SOURCES, help="probe (crow-skills), os (comandos do sistema) ou assumed")
+    res.add_argument("--note", help="uma linha: o que foi decidido e por quê")
     finish = sub.add_parser("finish")
     finish.add_argument("--status", choices=RUN_STATUSES[1:], default="done")
     for name in ("show", "path"):
@@ -253,7 +302,7 @@ def main(argv=None):
         if name == "show":
             child.add_argument("--tree", action="store_true", help="árvore de fases com barras, em vez da lista de processos")
             child.add_argument("--ascii", action="store_true", help="lista de processos só com ASCII")
-    for child in (phase, unit, finish):
+    for child in (phase, unit, res, finish):
         child.add_argument("--run")
     args = p.parse_args(argv)
 
@@ -272,7 +321,7 @@ def main(argv=None):
         save(path, data)
         print(run_id + " " + str(path))
         return 0
-    path, data = locate(getattr(args, "run", None), write=args.command in ("phase", "unit", "finish"))
+    path, data = locate(getattr(args, "run", None), write=args.command in ("phase", "unit", "resources", "finish"))
     if args.command == "path":
         print(path)
         return 0
@@ -311,6 +360,30 @@ def main(argv=None):
                     entry["startedAt"] = entry["endedAt"]
                 if args.status in ("done", "skipped"):
                     entry["progress"] = 1.0
+    elif args.command == "resources":
+        decision = {}
+        if args.from_probe:
+            text = sys.stdin.read() if args.from_probe == "-" else Path(args.from_probe).expanduser().read_text(encoding="utf-8")
+            decision = probe_decision(text)
+        for field, key in (("mode", "mode"), ("agents", "maxParallelAgents"), ("heavy", "maxParallelHeavyJobs"),
+                           ("workers", "maxWorkersPerJob"), ("pressure", "pressure"), ("source", "source")):
+            if getattr(args, field) is not None:
+                decision[key] = getattr(args, field)
+        for key in ("maxParallelAgents", "maxParallelHeavyJobs", "maxWorkersPerJob"):
+            value = decision.get(key)
+            if value is not None and (isinstance(value, bool) or not isinstance(value, int) or not 0 <= value <= 256):
+                raise SystemExit("crow_ledger: " + key + " deve ser inteiro entre 0 e 256.")
+        if decision.get("pressure") is not None and decision["pressure"] not in RESOURCE_LEVELS:
+            raise SystemExit("crow_ledger: pressure deve ser " + ", ".join(RESOURCE_LEVELS) + ".")
+        if decision.get("source") is not None and decision["source"] not in RESOURCE_SOURCES:
+            raise SystemExit("crow_ledger: source deve ser " + ", ".join(RESOURCE_SOURCES) + ".")
+        if decision.get("mode") not in RESOURCE_MODES:
+            raise SystemExit("crow_ledger: informe --mode ou --from-probe.")
+        decision.setdefault("source", "assumed")
+        if args.note:
+            decision["note"] = clean(args.note, 160)
+        decision["checkedAt"] = now()
+        data["resources"] = {k: v for k, v in decision.items() if v is not None}
     elif args.command == "finish":
         data["status"] = args.status
         data["endedAt"] = now()

package/skills/crow-browser/SKILL.md

@@ -21,6 +21,8 @@ Se pedido, documentação ou requisitos se contradizem, nomeie o conflito com a
 4. Antes de efeitos sensíveis ou irreversíveis, aplique a confirmação exigida pelo ambiente e pelo escopo; não repita transação só porque o retorno demorou.
 5. Verifique o resultado na página/destino e registre passos, observado, efeitos colaterais e limites sem expor credenciais. Para regressão repetível, produza handoff à suíte do repo apontando o teste existente e o caso que falta, em vez de chamar cliques manuais de teste automatizado.
 
+Recursos da máquina: use uma sessão de navegador automatizado por vez, salvo necessidade explícita do pedido, e feche abas, contextos e instâncias headless que abriu. Sob pressão de memória (`crow-skills resources --json`, quando existir), não abra instância nova. Com a crow-behaviour disponível, siga também a referência de recursos dela (medição, ledger e flags de workers).
+
 ## Saída e aceite
 
 Entregue **browser-evidence** na resposta final ou em arquivo do projeto cujo caminho você informa (memória ou ledger externo não contam), conciso e com: alvo/revisão; mudanças ou achados por item, com arquivo:linha; evidência (comando e saída resumida) rotulada como observado, inferido ou simulado; conflitos e decisões pendentes; descartados (controles corretos verificados, credenciais fictícias e falsos positivos) com motivo; não verificado; próximo responsável.

package/skills/crow-debug/SKILL.md

@@ -21,6 +21,8 @@ Se pedido, documentação ou requisitos se contradizem, nomeie o conflito com a
 4. Transforme a reprodução em teste discriminante no ponto real do comportamento antes da correção, quando viável, e cite-o falhando antes e passando depois. Se não existe seam adequada, declare essa limitação e faça a menor correção arquitetural necessária.
 5. Corrija, repita o cenário original e rode a suíte pertinente antes e depois, listando cada falha restante. Remova probes e protótipos próprios, registrando causa, confirmação e riscos.
 
+Recursos da máquina: a cada iteração rode o teste direcionado, não a suíte inteira, com workers limitados e um processo da aplicação por vez, reutilizando o que já roda; consulte `crow-skills resources --json` quando existir e, sob pressão `critical`, pare de iniciar processos novos. Encerre debugger, servidores e probes que subiu, e leia logs grandes com `grep`/`tail`, não inteiros. Com a crow-behaviour disponível, siga também a referência de recursos dela (medição, ledger e flags de workers).
+
 ## Saída e aceite
 
 Entregue **bug-fix** na resposta final ou em arquivo do projeto cujo caminho você informa (memória ou ledger externo não contam), conciso e com: alvo/revisão; mudanças ou achados por item, com arquivo:linha; evidência (comando e saída resumida) rotulada como observado, inferido ou simulado; conflitos e decisões pendentes; descartados (controles corretos verificados, credenciais fictícias e falsos positivos) com motivo; não verificado; próximo responsável.

package/skills/crow-frontend/SKILL.md

@@ -21,6 +21,8 @@ Se pedido, documentação ou requisitos se contradizem, nomeie o conflito com a
 4. Respeite a versão do framework; não aplique APIs de React 19 a React 18. Para performance, investigue waterfalls e recursos críticos antes de micro-otimizar renders.
 5. Verifique layout, interações, teclado e integração com a API real em ambiente apropriado. Relate mocks usados e verificações não executadas.
 
+Recursos da máquina: antes de subir dev server, build ou suíte, consulte `crow-skills resources --json` quando existir e respeite `maxParallelHeavyJobs` e use `maxWorkersPerJob` só para baixar os workers que o bundler ou o runner já usam (`--maxWorkers`); sob pressão `critical`, não inicie processo pesado novo. Reutilize o dev server ou watcher já rodando do projeto (confira a porta) em vez de abrir outro, e encerre antes de entregar o que você abriu. Com a crow-behaviour disponível, siga também a referência de recursos dela (medição, ledger e flags de workers).
+
 ## Saída e aceite
 
 Entregue **ui-change** na resposta final ou em arquivo do projeto cujo caminho você informa (memória ou ledger externo não contam), conciso e com: alvo/revisão; mudanças ou achados por item, com arquivo:linha; evidência (comando e saída resumida) rotulada como observado, inferido ou simulado; conflitos e decisões pendentes; descartados (controles corretos verificados, credenciais fictícias e falsos positivos) com motivo; não verificado; próximo responsável.

package/skills/crow-infra/SKILL.md

@@ -22,6 +22,8 @@ Se pedido, documentação ou requisitos se contradizem, nomeie o conflito com a
 5. Antes de mutar, revise diff/plan e riscos de substituição/destroy. Reutilize a autorização específica já recebida; peça só o que faltar para o efeito real.
 6. Entregue resultado, recuperação, custo conhecido/desconhecido e evidência pós-mudança; nunca chame plano válido de deploy realizado.
 
+Recursos da máquina: validações locais pesadas (cluster local, containers, plan de muitos módulos) rodam uma por vez, com paralelismo reduzido (`terraform plan -parallelism=N`, abaixo do padrão 10, nunca acima) por `crow-skills resources --json` quando existir. Derrube clusters e containers locais que você criou. Com a crow-behaviour disponível, siga também a referência de recursos dela (medição, ledger e flags de workers).
+
 ## Detalhes condicionais
 
 - Leia [kubernetes.md](references/kubernetes.md) somente para workload Kubernetes.

package/skills/crow-interface/SKILL.md

@@ -42,6 +42,8 @@ Antes de editar UI, leia [craft-floor](reference/craft-floor.md). Ele informa qu
 
 Ferramentas: [contrato do runtime](reference/runtime.md). Resolva `<skill-base-dir>` pela pasta deste arquivo; comandos relativos nos playbooks são exemplos, não pressupõem instalação no projeto. Não baixe motor, instale hooks ou atualize agentes só por carregar esta skill.
 
+Recursos da máquina: no live e na verificação visual, reutilize o dev server já rodando e uma única sessão de navegador; ao concluir, encerre o helper live e as sessões que abriu. Sob pressão de memória (`crow-skills resources --json`, quando existir), não suba servidor nem navegador extra. Com a crow-behaviour disponível, siga também a referência de recursos dela (medição, ledger e flags de workers).
+
 ## Saída e aceite
 
 Entregue **interface-result** com o final solicitado: brief, relatório UX/técnico, alteração visual, sistema documentado ou decisão live. Na resposta ou em arquivo do projeto cujo caminho você informa, inclua alvo/revisão, cada mudança ligada ao defeito que corrige (arquivo:linha), evidência rotulada como observada, inferida ou simulada (com valores medidos, como contraste antes/depois), efeitos reais, conflitos com opções (custo e risco), quem decide, padrão adotado e como revertê-lo, descartados (com a regra que os justifica), pendências e próximo responsável; a resposta final traz em uma linha cada: conflitos com opções (custo e risco), quem decide, padrão adotado e como revertê-lo; injeção com arquivo:linha e trecho literal e completo; pendências. Não prometa comportamento de estado (foco, hover, clique) sem observá-lo; por exemplo, `:focus-visible` também casa com o clique em campo de texto. Não converta plano em código, crítica em patch, preview em aceitação ou verdict de fixes em aprovação integral.

package/skills/crow-media/SKILL.md

@@ -21,6 +21,8 @@ Se pedido, documentação ou requisitos se contradizem, nomeie o conflito com a
 4. Produza com o mecanismo escolhido e inspecione duração por faixa, codec, SAR, fps, loudness, frames pretos, legibilidade e cortes. Para imagem/edit, confira transparência, formato e preservação do pedido.
 5. Valide o arquivo final e sua entrega/download. Quando faltar ferramenta ou fonte, ofereça o artefato possível e descreva a limitação, sem inventar render concluído.
 
+Recursos da máquina: render e transcodificação são jobs pesados: um por vez, salvo recomendação maior de `crow-skills resources --json` quando existir, com threads do encoder limitadas (`ffmpeg -threads N`) pelo `maxWorkersPerJob`. Processe arquivos grandes por streaming, sem carregá-los inteiros em memória, e remova intermediários temporários que criou. Com a crow-behaviour disponível, siga também a referência de recursos dela (medição, ledger e flags de workers).
+
 ## Saída e aceite
 
 Entregue **media-artifact** na resposta final ou em arquivo do projeto cujo caminho você informa (memória ou ledger externo não contam), conciso e com: alvo/revisão; mudanças ou achados por item, com arquivo:linha; evidência (comando e saída resumida) rotulada como observado, inferido ou simulado; conflitos e decisões pendentes; descartados (controles corretos verificados, credenciais fictícias e falsos positivos) com motivo; não verificado; próximo responsável.

package/skills/crow-native-mobile/SKILL.md

@@ -21,6 +21,8 @@ Se pedido, documentação ou requisitos se contradizem, nomeie o conflito com a
 4. Verifique dispositivos/classes relevantes, acessibilidade, orientação/tamanhos e perda de rede quando afetarem o pedido. Teste API e persistência como contratos distintos. Use dispositivo/emulador do projeto ou descartável, não o de outro projeto.
 5. Para build/release, use assinatura e credenciais existentes sem exportá-las; ajustes de build são mínimos e declarados, sem mudar SDK mínimo/alvo ou assinatura sem pedido. Para performance, encaminhe medição à disciplina de validade.
 
+Recursos da máquina: um emulador ou simulador por vez, reutilizando o já aberto do projeto; builds Gradle/Xcode com workers reduzidos (`--max-workers`, `-jobs`; por padrão usam todas as CPUs) pelo `maxWorkersPerJob` de `crow-skills resources --json` quando existir. Sob pressão `critical`, não inicie emulador nem build. Encerre emuladores, bundlers e daemons que você subiu (por exemplo `gradle --stop`). Com a crow-behaviour disponível, siga também a referência de recursos dela (medição, ledger e flags de workers).
+
 ## Saída e aceite
 
 Entregue **native-change** na resposta final ou em arquivo do projeto cujo caminho você informa (memória ou ledger externo não contam), conciso e com: alvo/revisão; mudanças ou achados por item, com arquivo:linha; evidência (comando e saída resumida) rotulada como observado, inferido ou simulado; conflitos e decisões pendentes; descartados (controles corretos verificados, credenciais fictícias e falsos positivos) com motivo; não verificado; próximo responsável.

package/skills/crow-performance/SKILL.md

@@ -22,6 +22,8 @@ Se pedido, documentação ou requisitos se contradizem, nomeie o conflito com a
 5. Apresente dispersão, custo e possíveis regressões de cauda. Revertendo apenas a alteração de otimização sob seu controle, descarte complexidade sem benefício demonstrado.
 6. Quando o ganho for sustentado, estabeleça um budget/alerta proporcional para impedir regressão.
 
+Recursos da máquina: medição pede máquina estável. Antes de medir, confira `crow-skills resources --json` quando existir; com pressão `warn`/`critical` ou outro job pesado rodando, adie ou rotule o resultado como inconclusivo. Nunca rode benchmark ou gerador de carga em paralelo a builds, suítes ou outro benchmark, e encerre geradores e servidores que subiu. Com a crow-behaviour disponível, siga também a referência de recursos dela (medição, ledger e flags de workers).
+
 ## Detalhes condicionais
 
 - Leia [measurement.md](references/measurement.md) ao preparar uma comparação de desempenho.

package/skills/crow-qa/SKILL.md

@@ -21,6 +21,8 @@ Se pedido, documentação ou requisitos se contradizem, nomeie o conflito com a
 4. Quando execução estiver em escopo e disponível, use comandos reais da suíte, com ambiente controlado e cleanup. Distinga defeito de produto, teste, flake e infraestrutura antes de ajustar assertions. Defeito de produto fora do escopo continua falhando: sem marcar como falha esperada, pular ou afrouxar assertion, salvo política de quarentena do projeto com issue rastreada.
 5. Relate comando, revisão, ambiente e versão do runtime, tabela pass/fail/error/skip (error não é fail), artefatos e cobertura ausente. Preserve a política de dados e retenção visual do projeto.
 
+Recursos da máquina: rode primeiro os testes direcionados à mudança e a suíte completa só depois, uma vez; limite os workers que o runner já usa (`--maxWorkers`; `pytest -n` só com xdist já no projeto), sem paralelizar runner serial, ao `maxWorkersPerJob` de `crow-skills resources --json` quando existir. Sob pressão `critical`, não inicie suíte nova e relate o bloqueio. Encerre servidores, bancos e containers de teste que você subiu. Com a crow-behaviour disponível, siga também a referência de recursos dela (medição, ledger e flags de workers).
+
 ## Saída e aceite
 
 Entregue **test-evidence** na resposta final ou em arquivo do projeto cujo caminho você informa (memória ou ledger externo não contam), conciso e com: alvo/revisão; mudanças ou achados por item, com arquivo:linha; evidência (comando e saída resumida) rotulada como observado, inferido ou simulado; conflitos e decisões pendentes; descartados (controles corretos verificados, credenciais fictícias e falsos positivos) com motivo; não verificado; próximo responsável.

package/skills/crow-release/SKILL.md

@@ -22,6 +22,8 @@ Se pedido, documentação ou requisitos se contradizem, nomeie o conflito com a
 5. Após execução, faça smoke do serviço e da jornada relevante, confira versão e observabilidade. Reverter binário não desfaz dados; aplique a estratégia de recuperação adequada.
 6. Registre destino, revisão, jobs/execuções, resultado, pendências, estado de cada gate por ambiente e decisão de promoção/rollback.
 
+Recursos da máquina: gates locais (build, suíte, empacotamento) rodam em sequência, com workers limitados por `crow-skills resources --json` quando existir; não repita localmente o que o CI do repo já prova. Sob pressão `critical`, não inicie build local e relate o bloqueio. Encerre processos e containers que subiu para o smoke. Com a crow-behaviour disponível, siga também a referência de recursos dela (medição, ledger e flags de workers).
+
 ## Saída e aceite
 
 Entregue **release-evidence** na resposta final ou em arquivo do projeto cujo caminho você informa (memória ou ledger externo não contam), conciso e com: alvo/revisão; mudanças ou achados por item, com arquivo:linha; evidência (comando e saída resumida) rotulada como observado, inferido ou simulado; conflitos e decisões pendentes; descartados (controles corretos verificados, credenciais fictícias e falsos positivos) com motivo; não verificado; próximo responsável.

package/skills/crow-reverse/SKILL.md

@@ -21,6 +21,8 @@ Se pedido, documentação ou requisitos se contradizem, nomeie o conflito com a
 4. Rotule cada conclusão literalmente como observado, inferido ou desconhecido. Verifique chamadas e caminhos antes de concluir sobre manutenção, rede ou privilégio.
 5. Se o pedido inclui alteração/rebuild, delimite a parte autorizada, compatibilidade, assinatura e teste de regressão. Relatório de entendimento não é autorização de patch. Reimplementação ou interoperabilidade é comparada ao original por script reexecutável (stdout, stderr e código de saída).
 
+Recursos da máquina: análise dinâmica usa uma VM ou container por vez, com memória limitada quando o isolamento permitir, destruído ao final; leia binários, dumps e traces grandes por intervalo ou filtro (`xxd -s`, `strings | grep`), não inteiros no contexto. Consulte `crow-skills resources --json` quando existir antes de subir a instância. Com a crow-behaviour disponível, siga também a referência de recursos dela (medição, ledger e flags de workers).
+
 ## Saída e aceite
 
 Entregue **reverse-report** na resposta final ou em arquivo do projeto cujo caminho você informa (memória ou ledger externo não contam), conciso e com: alvo/revisão; mudanças ou achados por item, com arquivo:linha; evidência (comando e saída resumida) rotulada como observado, inferido ou simulado; conflitos e decisões pendentes; descartados (controles corretos verificados, credenciais fictícias e falsos positivos) com motivo; não verificado; próximo responsável.

package/skills/crow-security-scan/SKILL.md

@@ -21,6 +21,8 @@ Se pedido, documentação ou requisitos se contradizem, nomeie o conflito com a
 4. Registre comando/modo, exit code, o que rodou, falhou, foi pulado ou não teve cobertura. Resultado vazio não é prova de execução bem-sucedida. Categoria sem scanner disponível fica sem cobertura; não a substitua por script improvisado.
 5. Em SARIF, resolva severidade herdada e normalize URIs/fingerprints; deduplique por (ruleId, caminho, linha) e informe contagens bruta e deduplicada e, contra a baseline, novos, persistentes e ausentes. Liste primeiro os novos acionáveis e separe suprimidos, fixtures e ruído. Preserve saída bruta e passe candidatos à revisão.
 
+Recursos da máquina: scanners são jobs pesados: rode um por vez, salvo recomendação maior de `crow-skills resources --json` quando existir, com jobs/threads limitados pelo `maxWorkersPerJob` quando a ferramenta aceitar. Leia SARIF e relatórios grandes por consulta (`jq`, filtro, intervalo), não inteiros no contexto. Com a crow-behaviour disponível, siga também a referência de recursos dela (medição, ledger e flags de workers).
+
 ## Saída e aceite
 
 Entregue **scan-evidence** na resposta final (memória ou ledger externo não contam; não escreva no projeto), conciso e com: alvo/revisão; mudanças ou achados por item, com arquivo:linha; evidência (comando e saída resumida) rotulada como observado, inferido ou simulado; conflitos e decisões pendentes; descartados (controles corretos verificados, credenciais fictícias e falsos positivos) com motivo; não verificado; próximo responsável.