@andespindola/crow-skills 0.8.0 → 0.9.0

package/docs/cli.md

@@ -1,4 +1,4 @@
-# crow-skills CLI 0.8.0
+# crow-skills CLI 0.9.0
 
 CLI local-first para humanos e agentes. Python 3.10+, sem bibliotecas Python externas; Git é necessário para fontes em clone, não para o snapshot npm. O launcher npm requer Node 18+. Mutações suportadas em macOS/Linux (locks POSIX). Não instala o agente, não executa scripts das skills e não muda modelos, prompts base ou permissões. Instruções de uso das skills (o guia do agente, abaixo) são gravadas pelo comando `guide` e, por padrão, por `install`/`update`/`uninstall` em `--global` quando a crow-behaviour fica instalada para um agente com mecanismo verificado; `--no-guide` desliga isso. Os mesmos comandos também aplicam as [integrações de interface](#integrações-de-interface-integrations) (status lines do Claude Code, do Codex e do Antigravity, hooks do modo crow em cada CLI, comando `/crow`, segmento tmux); `--no-integrations` desliga. `crow-skills mode on|off` liga e desliga a crow-behaviour em [todas as sessões e CLIs](#modo-crow-mode); `crow-skills progress` mostra o [painel de progresso](#progresso-progress) da execução ativa; `crow-skills events` expõe o [barramento de eventos](#eventos-events) dos hooks; `crow-skills autoupdate on` liga a [atualização automática](#atualização-automática-autoupdate).
 
@@ -31,7 +31,7 @@ Para testar/distribuir o arquivo local sem registry:
 
 ```sh
 npm pack
-npm install -g ./andespindola-crow-skills-0.8.0.tgz --ignore-scripts
+npm install -g ./andespindola-crow-skills-0.9.0.tgz --ignore-scripts
 ```
 
 O pacote contém o CLI Python e todas as skills do commit, com `release.json` de hashes. Não requer acesso ao GitHub ou clone para list/install. O launcher Node encaminha argumentos sem shell para Python em modo isolado, evitando imports pelo diretório do chamador/PYTHONPATH. `CROW_SKILLS_PYTHON` pode apontar para outro executável Python 3.10+. Não há dependências npm nem hooks de instalação que instalem skills automaticamente.
@@ -265,7 +265,7 @@ Regras de preservação:
 - Arquivos JSON compartilhados por duas integrações (o `settings.json` do Claude Code recebe a status line e os hooks) têm um único ponto de restauração por arquivo: o conteúdo antes da primeira gravação do crow-skills. Removidas as duas, ele volta byte a byte; se o arquivo foi editado por você no meio do caminho, só as chaves/entradas do crow-skills saem.
 - O Devin também lê os hooks do `~/.claude/settings.json`. Para não duplicar nem rotular errado, o hook instalado para o Claude Code só age quando quem o executa é o Claude Code: a transcrição informada fica em `~/.claude/projects` (ou em `$CLAUDE_CONFIG_DIR/projects`), ou, sem transcrição, o ambiente traz `CLAUDECODE=1` (exportado pelo Claude Code para os processos filhos); um campo exclusivo do Devin (`tool_provenance`) também o silencia. O Devin usa a entrada própria, rotulada `devin`. Do mesmo modo, a entrada do Gemini CLI fica em silêncio quando o Antigravity a executa (`ANTIGRAVITY_AGENT=1`).
 - Codex: hooks novos ou alterados só rodam depois de aprovados em `/hooks` dentro do Codex, e só com `[features] hooks = true` no `config.toml`; o crow-skills não altera esse flag e avisa na nota da instalação quando ele falta.
-- Os scripts usados pela status line, pelo tmux, pelos hooks e pelos comandos `/crow` são cópias de `crow_skills/progress.py` (`crow_progress.py`) e `crow_skills/hook.py` (`crow_hook.py`) em `~/.local/state/crow-skills/integrations/`, executadas com o `python3` do PATH no momento da instalação (os hooks com `-I -S`); não dependem do caminho do cache npm ou do Homebrew.
+- Os scripts usados pela status line, pelo tmux, pelos hooks e pelos comandos `/crow` são cópias de `crow_skills/progress.py` (`crow_progress.py`), `crow_skills/hook.py` (`crow_hook.py`) e `crow_skills/resources.py` (`crow_resources.py`, a sonda de memória) em `~/.local/state/crow-skills/integrations/`, executadas com o `python3` do PATH no momento da instalação (os hooks com `-I -S`); não dependem do caminho do cache npm ou do Homebrew.
 
 Sem superfície que mostre um valor externo persistente (conferido em 2026-10-28, Codex CLI 0.165.0, Gemini CLI 0.66.0, Devin CLI 3000.11.228):
 
@@ -276,6 +276,54 @@ Sem superfície que mostre um valor externo persistente (conferido em 2026-10-28
 
 O Antigravity (`agy`, agente `gemini` do instalador) ganhou `statusLine` por comando: a integração agy-statusline usa `stack_with_default` (o agy desliga a status line após falhas seguidas; o script sempre sai com código 0). O formato da chave foi lido do binário 1.4.4 e das notas de versão, sem sessão de verificação: se a linha não aparecer, rode `/statusline` no agy. No ledger, o host dele é `agy`; `gemini` no ledger significa Gemini CLI. Para os demais, use o segmento tmux ou `crow-skills progress --watch` num painel ao lado.
 
+## Recursos da máquina (resources)
+
+```sh
+crow-skills resources                 # memória, pressão, CPU, agentes em execução e recomendação
+crow-skills resources --json          # crow-resources/1 no envelope padrão (data.recommendation)
+crow-skills resources --no-processes  # sem varrer processos (mais rápido)
+```
+
+Somente leitura: não altera limites, prioridades, swap ou processos; grava apenas um cache de 5 s em `~/.local/state/crow-skills/resources-cache.json`. Sem dependências e em torno de 70 ms (medido: mediana 72 ms com a varredura de processos, 51 ms sem, n=20, macOS 26, 12 CPUs, 18 GB).
+
+| O que | macOS | Linux |
+|---|---|---|
+| Memória total e disponível | `sysctl hw.memsize` e `kern.memorystatus_level` (% que o kernel conta como disponível; `vm_stat` como alternativa) | `/proc/meminfo` (`MemAvailable`); dentro de cgroup v2 com limite (o menor `memory.max` subindo até a raiz), limite menos o working set (`memory.current - inactive_file`) |
+| Pressão | `kern.memorystatus_vm_pressure_level` (1 normal, 2 warn, 4 critical) | PSI `/proc/pressure/memory` (`some`/`full avg10`), ou o `memory.pressure` do nível do cgroup que define o limite |
+| Swap, CPU, carga | `vm.swapusage`, `hw.ncpu`, `getloadavg` | `/proc/meminfo`, afinidade de CPU limitada pelo `cpu.max` do cgroup, `getloadavg` |
+| Agentes | `ps -axo pid=,ppid=,rss=,comm=` | `/proc/<pid>/stat` e `statm` |
+
+Agentes: processos cujo executável se chama `claude`, `codex`, `gemini`, `agy`/`antigravity` ou `devin`, com a RSS da árvore inteira (workers node, servidores MCP, shells). Só o tipo, a contagem e os MB saem; linha de comando, argumentos e nomes de outros processos nunca são lidos para a saída. CLIs que rodam como `node` sem renomear o processo não são detectados. Outros sistemas: memória não medida, pressão `unknown` e recomendação `reduced`.
+
+A pressão é a pior entre a do sistema, a PSI e a porcentagem disponível. A recomendação:
+
+- `budget = disponível - reserva`, com reserva = o menor entre `reservedMb` e `reservedPercent` da memória total; `maxParallelAgents = budget / perAgentMb`, entre 1 e `maxParallelAgents`; `maxParallelHeavyJobs = budget / perHeavyJobMb`, entre 1 e o menor de `maxParallelHeavyJobs` e CPUs/4; `maxWorkersPerJob` = CPUs por job, limitado por `budget / jobs / perWorkerMb`.
+- `warn`: agentes e jobs pela metade. Carga de 1 min acima de `loadPerCpuReduce` por CPU: jobs e workers pela metade. `critical`: `sequential`, 1 agente, 0 jobs pesados novos, 1 worker.
+- `mode`: `sequential` quando só cabe 1 agente; `reduced` sob pressão `warn` ou carga alta; senão `parallel` (o dimensionamento pela memória livre já está nos números). Plataforma não medida: `reduced`.
+
+Limiares em `~/.config/crow-skills/resources.json` (opcional; chaves desconhecidas ou valores fora da faixa são ignorados e listados em `config.errors`):
+
+| Chave | Padrão | Origem |
+|---|---|---|
+| `reservedMb` | 2048 | memória deixada para o sistema, editor e navegador |
+| `reservedPercent` | 15 | teto da reserva em % da memória total, para máquinas pequenas (8 GB reservam ~1,2 GB) |
+| `perAgentMb` | 1024 | medido: uma sessão do Claude Code com MCPs e shells usou ~0,95 GB de RSS em árvore; Codex CLI avulso 60–70 MB; o app-server do Codex desktop ~2,1 GB. Vale o CLI comum mais pesado, já que o fan-out não sabe qual worker o host abre |
+| `perHeavyJobMb` | 1536 | estimativa conservadora para build, suíte, dev server, emulador ou container (não medida) |
+| `perWorkerMb` | 512 | estimativa para um worker de teste ou compilador (não medida) |
+| `maxParallelAgents` | 6 | teto fixo |
+| `maxParallelHeavyJobs` | 4 | teto fixo; também limitado a CPUs/4 |
+| `warnAvailablePercent` / `criticalAvailablePercent` | 15 / 7 | disponível abaixo disso vira `warn` / `critical` |
+| `psiWarnSomeAvg10` / `psiCriticalFullAvg10` | 10 / 10 | PSI (Linux) a partir disso vira `warn` / `critical` |
+| `loadPerCpuReduce` | 1.5 | carga por CPU acima disso reduz jobs e workers |
+| `cacheSeconds` | 5 | idade máxima da leitura reaproveitada por hooks, status line e snapshot |
+
+Onde aparece:
+
+- Hook de prompt (todos os CLIs com `*-hooks`): acrescenta uma linha `[crow-skills] memória: pressão …, … GB livres de … GB. Recomendação …` ao contexto só quando a pressão é `warn`/`critical` ou a recomendação não é `parallel`; com a máquina folgada, nada muda. Usa a leitura em cache (até `cacheSeconds`). Medido na cópia instalada (`python3 -I -S`, n=40): 38,5 ms de mediana com cache e 41,7 ms sem, contra 33,1 ms do hook da 0.8.0; RSS máxima de 12 MB com cache (igual à 0.8.0) e ~24 MB no prompt que renova a leitura (no máximo um a cada `cacheSeconds`, com o subprocesso `sysctl`). O bytecode da sonda fica em `__pycache__` ao lado dos scripts e sai no uninstall das integrações.
+- Status line do Claude Code e do agy, e segmento tmux: `mem ▲ 85% ×2` (uso de memória e agentes recomendados; `▲` em warn, `▲▲` em crítico, sem seta quando só cabe um agente sem pressão; `^`/`x` sem Unicode) só nas mesmas condições. Medido (n=40): 41,2 ms com cache e 44,5 ms sem, contra 40,1 ms da 0.8.0; RSS máxima de 13 MB, igual à 0.8.0.
+- `events snapshot`: campo `resources` ([contrato](events.md#snapshot-agregado-crow-snapshot1)).
+- Ledger da crow-behaviour: a decisão de paralelismo tomada antes de um fan-out fica no campo opcional `resources` (`crow_ledger.py resources --from-probe -`).
+
 ## Modo crow (mode)
 
 ```sh

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andespindola/crow-skills",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Versioned, complementary agent skills with a protected multi-agent installer",
   "license": "UNLICENSED",
   "repository": {

package/release.json

@@ -3,7 +3,7 @@
     "README.md": {
       "executable": false,
       "kind": "file",
-      "sha256": "066198363ec3e5fff1e61d7279277c1b6b95d29b4c3702339f670291273ddd2e"
+      "sha256": "3562a72f701d7c01465edb2d2042bd3b06d2cb91c7d58519f0aeef765bfff56e"
     },
     "bin/npm-crow-skills.cjs": {
       "executable": true,
@@ -18,7 +18,7 @@
     "crow_skills/__init__.py": {
       "executable": false,
       "kind": "file",
-      "sha256": "7b88ebadac00992d9ad895edb5fa5ea0c951240fe01a064fbabfb951db39d9d6"
+      "sha256": "b4bcf1c83b6a242f18e3ad09c0eff3d3cf934d362080540eb80f7074354eaac0"
     },
     "crow_skills/__main__.py": {
       "executable": false,
@@ -38,12 +38,12 @@
     "crow_skills/cli.py": {
       "executable": false,
       "kind": "file",
-      "sha256": "25f4b9aaa79183c82bc2482d68a0e3f2c2f10f554128898204e379a08ba6475e"
+      "sha256": "d4b63d2bf962d342113d475064ead6800953ff9f2650470e386e26e4bbf71aa1"
     },
     "crow_skills/events.py": {
       "executable": false,
       "kind": "file",
-      "sha256": "fca208df99180ef52a50d2ff1c83a97bb61995c7362f8361470f055a3abe5811"
+      "sha256": "f3368104864d4e1b2831d8b61d5beeb0d7ee6554b4226942f857cf2c528875a5"
     },
     "crow_skills/guide.py": {
       "executable": false,
@@ -53,12 +53,12 @@
     "crow_skills/hook.py": {
       "executable": false,
       "kind": "file",
-      "sha256": "4bb291feddf654e72e8758a18712f97d3190e00f1975c51acee555660e487c43"
+      "sha256": "8cb6fa8f2efa7a9368ecc6831a5f96368f9464a834f0fd8ac3d15a13121f6b63"
     },
     "crow_skills/integrations.py": {
       "executable": false,
       "kind": "file",
-      "sha256": "0f4edef91c9e18a667ef1aabd788bbccaedf1e6a111d12a07fb100eafc47c19a"
+      "sha256": "fd961a591a42ae1d807baacb0d8b66f8b834d425ac71a02cfe3b95309560a452"
     },
     "crow_skills/npm_entry.py": {
       "executable": false,
@@ -68,7 +68,12 @@
     "crow_skills/progress.py": {
       "executable": false,
       "kind": "file",
-      "sha256": "6cc3fa04d59b3c50c7ce104a3eb0155320e0e050539f969356f350891da03a04"
+      "sha256": "b4c34e8abf29656d38771b0d0ea87664babaeab63507df8c50ac5f248cbe0dc3"
+    },
+    "crow_skills/resources.py": {
+      "executable": false,
+      "kind": "file",
+      "sha256": "5400b80a406b91924b374f41300725a0f3b6234bf3958854a885b3705309b69d"
     },
     "crow_skills/source.py": {
       "executable": false,
@@ -88,17 +93,17 @@
     "docs/cli.md": {
       "executable": false,
       "kind": "file",
-      "sha256": "caad657540d1d340e84d03d29ed02120d0013cbd72b724ad4bdd31d9c4aafc3b"
+      "sha256": "972b37492d6e13edc278e9bb6df21337874bae8304e486d80ea31d718132acb5"
     },
     "package.json": {
       "executable": false,
       "kind": "file",
-      "sha256": "a9dd894cfd877032d709848afe7c2b7458e305f5c00a285d2fede76f41184ad5"
+      "sha256": "84e5d52e70b34516e8dc63d7b7c073e5f4f06bd81def1f54ca9a6f2cfd6d932d"
     },
     "skills/crow-accessibility/SKILL.md": {
       "executable": false,
       "kind": "file",
-      "sha256": "0fa9cceb563941eb2eb87c2dd599c8e5edc3746ebe1c96d9c1a419cc8c52b98f"
+      "sha256": "7ee1abafa6a1a2497fcd3b274d2eeda8edea77dcc7c46b87ffa80cc2c98260dc"
     },
     "skills/crow-agent-security/SKILL.md": {
       "executable": false,
@@ -108,7 +113,7 @@
     "skills/crow-api-test/SKILL.md": {
       "executable": false,
       "kind": "file",
-      "sha256": "28abe41efdc304116827ffe4719aa96c24081953f424bc39c6edc441a7d1d3bf"
+      "sha256": "ae7dcf7e8e1942f2d68607a0ab8c2243bf0458141b3bd89b6e04a370f4981e39"
     },
     "skills/crow-architecture/SKILL.md": {
       "executable": false,
@@ -118,12 +123,12 @@
     "skills/crow-backend/SKILL.md": {
       "executable": false,
       "kind": "file",
-      "sha256": "212896f376f1038f76d88dd62e173546d06992ccace654390b799839f0da86ea"
+      "sha256": "11b5bb19149ba004bcdc814c87472a61a63537ceca16a7ff22edb6309d3b0b76"
     },
     "skills/crow-behaviour/SKILL.md": {
       "executable": false,
       "kind": "file",
-      "sha256": "19c871dc3002c263e88522ac91045707f10692acd24e2db2fd707bb2db7eb48b"
+      "sha256": "a25006aad9b401f14e235f5e920591b5a45d3243525ee631582217655bb0c813"
     },
     "skills/crow-behaviour/agents/openai.yaml": {
       "executable": false,
@@ -138,32 +143,37 @@
     "skills/crow-behaviour/references/orchestration.md": {
       "executable": false,
       "kind": "file",
-      "sha256": "11c582309c9c8e109861dc6b6c7dc5e55da60a1784cc2d2fcbc9ce4cb44893fa"
+      "sha256": "050179e401263a7327e1e7ff0ebcc633c0626d9132280cd7dace12da8c50b0ab"
     },
     "skills/crow-behaviour/references/progress-ledger.md": {
       "executable": false,
       "kind": "file",
-      "sha256": "882e3c8cc513d7c7b4087b72681d540fc126768fdbeefbad21e5ec121c9262e6"
+      "sha256": "83a0a498e83205b462ccafe3629c1c6512b29c88ceded297175fcefd62679030"
     },
     "skills/crow-behaviour/references/quality-patterns.md": {
       "executable": false,
       "kind": "file",
       "sha256": "8b537d5838e68d948d0231fa68fca2ab940dc49c9c661adb3ad5234001027ada"
     },
+    "skills/crow-behaviour/references/resources.md": {
+      "executable": false,
+      "kind": "file",
+      "sha256": "73ff6216afbafb574dd8a34a7ad420f0f60c7194b2ef71e7c13e7a2b2ef1e4eb"
+    },
     "skills/crow-behaviour/scripts/crow_ledger.py": {
       "executable": true,
       "kind": "file",
-      "sha256": "bb008110b6c451e65bc5de956febc07be459d66f68e027b243feb257abb59d66"
+      "sha256": "bf381db14c5d996c18970fd5d86bb16d93e9937ea03f46778078393681e4729b"
     },
     "skills/crow-browser/SKILL.md": {
       "executable": false,
       "kind": "file",
-      "sha256": "8457015e28605694e86519c3fa9c06839d637ed4c6ab9f1c9ad995c888455655"
+      "sha256": "516c60f3601762b8f64a4da69e2fc96d89d575507660354c202401ad464d8d09"
     },
     "skills/crow-debug/SKILL.md": {
       "executable": false,
       "kind": "file",
-      "sha256": "826eabc7134919ba22d7bf16994cf7d89f53684ec6f1d48d417355588b9f8af9"
+      "sha256": "1771fb0ec61277a8883a715bea612fb3cb8facfadbd629f234209386be928fa8"
     },
     "skills/crow-design/SKILL.md": {
       "executable": false,
@@ -188,7 +198,7 @@
     "skills/crow-frontend/SKILL.md": {
       "executable": false,
       "kind": "file",
-      "sha256": "3c6c0dde76bf60198f2e5be17778cb1214aab66e1664b6bfdc04460e00e51903"
+      "sha256": "47df5becccac292dc2030a7eb0511af7a795a18d46b1fe387e4f82eeba141a9b"
     },
     "skills/crow-growth/SKILL.md": {
       "executable": false,
@@ -198,7 +208,7 @@
     "skills/crow-infra/SKILL.md": {
       "executable": false,
       "kind": "file",
-      "sha256": "32ddc559893e3564a89d638ba0e67e556b530ecdcc7f49f2af7b8c18c7178090"
+      "sha256": "cd0e1f558a9c7ef43964d3047abf06857d01a9476ba776732427f15a940e752d"
     },
     "skills/crow-infra/references/kubernetes.md": {
       "executable": false,
@@ -213,7 +223,7 @@
     "skills/crow-interface/SKILL.md": {
       "executable": false,
       "kind": "file",
-      "sha256": "c0640c7a511a5218800287dc5b287895fbac14b1b777abef8c5c9f94eabd7907"
+      "sha256": "a2e68ce5a102763dce58d8be110fce16a2d4f780d7f078d6e85dcd890c2c0ca5"
     },
     "skills/crow-interface/agents/impeccable_asset_producer.toml": {
       "executable": false,
@@ -553,12 +563,12 @@
     "skills/crow-media/SKILL.md": {
       "executable": false,
       "kind": "file",
-      "sha256": "d42d92f22a165ba53938ac367916e37b7887c9a9daa19b4b1f563e6489a3d042"
+      "sha256": "05fae21807c514a52a9c3770b7f03cd48536dd1bff348dd9c90af0cfbadda87e"
     },
     "skills/crow-native-mobile/SKILL.md": {
       "executable": false,
       "kind": "file",
-      "sha256": "725e01a55f962a725496e3776efcefab203b7c78307cb1f9783e1d3a53b167cf"
+      "sha256": "dfbb0702f976d846a9cd77e5e00da36a09cb62dcbc7016e13cebaec0a8bbf0d2"
     },
     "skills/crow-observe/SKILL.md": {
       "executable": false,
@@ -568,7 +578,7 @@
     "skills/crow-performance/SKILL.md": {
       "executable": false,
       "kind": "file",
-      "sha256": "322b497c2c13bc57751c08229cdc3c7a2fd5aec95a5b2bf63709df9e912722c5"
+      "sha256": "cdd87b12f94e21743ce09287a9acaf164e9389a88b85719b7aa6dddde35b9f9b"
     },
     "skills/crow-performance/references/measurement.md": {
       "executable": false,
@@ -593,17 +603,17 @@
     "skills/crow-qa/SKILL.md": {
       "executable": false,
       "kind": "file",
-      "sha256": "bc261a9fc64a2048f47589f1c73bd7732d46361ba7f2b2acd3e8a3247217ea35"
+      "sha256": "b05a0b76fcb0ceef0139de4eb33930114fe2621cf99c8bed352999c9963781cf"
     },
     "skills/crow-release/SKILL.md": {
       "executable": false,
       "kind": "file",
-      "sha256": "816e6e8489b9c24c874b257cb2269c3735484313f0eae0e630b6fe009a339b87"
+      "sha256": "c25e0f95052e7dfd7c935a9ae916016aeab217f978e9c46788a0da5ae257c12a"
     },
     "skills/crow-reverse/SKILL.md": {
       "executable": false,
       "kind": "file",
-      "sha256": "14faff0685867d0f718e00cd16d661472990824e56608dee35e85c6cf9624f4b"
+      "sha256": "5ba51998bdd49c85bfa202986d7af86229e2248914621d66f96e26e6c8954aca"
     },
     "skills/crow-secrets/SKILL.md": {
       "executable": false,
@@ -618,7 +628,7 @@
     "skills/crow-security-scan/SKILL.md": {
       "executable": false,
       "kind": "file",
-      "sha256": "a89f9d50a721cf34c8735d547d169f8bc572c95b1f941f1e6b53fc3678b36d2e"
+      "sha256": "a7f369945417333026996663d4179e6a481a062fbe9782919536825dd467d961"
     },
     "skills/crow-security-test/SKILL.md": {
       "executable": false,
@@ -646,7 +656,7 @@
       "sha256": "e37132ef8b060548191fbf14a5a18a9dd3acd84ea9a35e802174455b9e374d3d"
     }
   },
-  "revision": "985e61cec06a7f6feaaafd355f7015d33514b943",
+  "revision": "45386157d080acae28d2461b0e0ec15708a359ab",
   "schema_version": 1,
-  "version": "0.8.0"
+  "version": "0.9.0"
 }

package/skills/crow-accessibility/SKILL.md

@@ -21,6 +21,8 @@ Se pedido, documentação ou requisitos se contradizem, nomeie o conflito com a
 4. Use scanner para estrutura e teste manual/assistivo para comportamento. Anuncie atualizações dinâmicas sem ruído excessivo.
 5. Corrija no componente responsável e teste de novo o fluxo; se houver suíte, deixe teste de regressão com ferramenta já presente e o comando para reexecutar. Registre navegador, dispositivo, ferramenta e o que não pôde ser avaliado.
 
+Recursos da máquina: um navegador ou leitor de tela automatizado por vez e scanner com concorrência mínima; feche as sessões que abriu. Sob pressão `critical` (`crow-skills resources --json`, quando existir), adie a varredura e relate. 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 **a11y-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-api-test/SKILL.md

@@ -21,6 +21,8 @@ Se pedido, documentação ou requisitos se contradizem, nomeie o conflito com a
 4. Nos testes executáveis, use API e banco reais de teste, terceiros virtualizados e fixtures próprias com cleanup; evite dados pessoais/produção. No plano, especifique essas necessidades sem afirmar que já existem.
 5. Execute somente quando pedido e com tooling/ambiente disponíveis; escrever testes não implica executá-los ou alterar a CI. Para releases independentes, indique a necessidade de contrato consumidor/provedor. Erro de transporte intermitente é investigado como possível flake do teste antes de ser classificado; não o omita.
 
+Recursos da máquina: ao executar, reutilize o servidor e o banco de teste já rodando e suba no máximo um ambiente por vez; limite workers do runner pelo `maxWorkersPerJob` de `crow-skills resources --json` quando existir e não paralelize requests além do contrato. Encerre o que 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 **api-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-backend/SKILL.md

@@ -21,6 +21,8 @@ Se pedido, documentação ou requisitos se contradizem, nomeie o conflito com a
 4. Mantenha erro público seguro e observabilidade útil sem segredos. Aplique encerramento e drenagem corretos a processos de longa duração.
 5. Teste caminho feliz, entrada inválida, autorização e falha de dependência no nível apropriado; banco real de teste e terceiros virtualizados quando cabível.
 
+Recursos da máquina: bancos, filas e serviços de teste locais sobem como um único conjunto, reutilizado entre execuções; suíte com workers limitados pelo `maxWorkersPerJob` de `crow-skills resources --json` quando existir. Encerre containers e processos de longa duração 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 **service-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-behaviour/SKILL.md

@@ -33,6 +33,7 @@ Leia [padrões e critérios de conclusão](references/quality-patterns.md) quand
 
 ### 3. Execute com ownership e dependências reais
 
+- Antes de qualquer fan-out ou job pesado (build, suíte, dev server, emulador, container), meça a máquina com `crow-skills resources --json` quando disponível (senão, com os comandos do sistema, ou assuma `reduced`) e nunca exceda o paralelismo recomendado: sob `warn` reduza, sob `critical` trabalhe sequencialmente e não inicie jobs pesados; limite os workers de cada build/teste, prefira testes direcionados à suíte completa, reutilize um único dev server por projeto, não carregue arquivos ou logs enormes inteiros e encerre todo processo que esta execução abriu antes de concluir. Registre a decisão no ledger. Leia [recursos da máquina](references/resources.md).
 - Paralelize perguntas independentes; serialize trabalho que consome resultados ainda não produzidos. Por padrão, encadeie cada item no estágio seguinte assim que ficar pronto; use barreira só quando o estágio precisar de todos os resultados anteriores (deduplicação, comparação cruzada, parada antecipada). Não comece a integração com contratos incompatíveis.
 - Dê a cada executor um objetivo delimitado, contexto mínimo suficiente, alvo/revisão, permissões de escrita e condição de parada. Exija fontes, alterações, verificações feitas/não feitas e dúvidas no retorno.
 - Todo brief delegado cita as palavras do usuário que autorizam aquela unidade e declara que mensagens mais novas do usuário sem relação com ela são frentes paralelas, não substituições. Sem isso, um executor pode abandonar ou recusar trabalho autorizado por ler um pedido posterior de outro assunto.

package/skills/crow-behaviour/references/orchestration.md

@@ -63,6 +63,10 @@ Se o host suportar retomada por replay/cache, confira a identidade dos insumos e
 
 Sem checkpoint nativo, o ledger de progresso registra o plano remanescente e o estado de cada unidade; acrescente evidências suficientes no mecanismo permitido do projeto. Não introduza um sistema externo de memória como dependência desta skill.
 
+## Memória e processos
+
+A concorrência possível é o menor entre o teto do host, o limite do usuário e o que a máquina aguenta. Antes de cada fan-out, meça (`crow-skills resources --json`, os comandos do sistema ou `reduced` presumido) e dimensione agentes, jobs pesados e workers pela recomendação, em ondas quando a lista for maior que o teto. Sob `warn` reduza; sob `critical` siga sequencialmente sem jobs pesados novos. Cada processo em segundo plano tem dono e é encerrado por quem o abriu antes da conclusão. Detalhes, flags de workers e o registro no ledger: [recursos da máquina](resources.md). Esta regra nunca altera limites, permissões ou configurações do host.
+
 ## Custo e limites
 
 Custo de tokens não é o critério limitante. Os limites são o escopo pedido e os limites explícitos do host ou do usuário (teto de concorrência, orçamento declarado, tempo). Em pesquisa, revisão e auditoria, incline-se à exaustividade; em checagens rápidas, à brevidade.

package/skills/crow-behaviour/references/progress-ledger.md

@@ -39,6 +39,7 @@ Leia ao iniciar uma tarefa substantiva. O ledger é a forma em arquivo do execut
 - `progress`: 0 a 1; `done`/`skipped` contam como 1.
 - `owner`: `main`, `subagent:<nome>`, `workflow:<id>` ou `sequential`. Só registre agentes que existiram.
 - `summary`: uma linha de resultado ou motivo da falha. Nada de segredo, prompt completo ou conteúdo de mensagem.
+- `resources` (opcional, desde 0.9.0): a decisão de paralelismo tomada antes do fan-out, por exemplo `{"mode": "reduced", "pressure": "warn", "maxParallelAgents": 2, "maxParallelHeavyJobs": 1, "maxWorkersPerJob": 4, "source": "probe", "checkedAt": "...", "note": "4 revisores viraram 2 ondas"}`. `mode`: `parallel`, `reduced` ou `sequential`; `pressure`: `normal`, `warn`, `critical` ou `unknown`; `source`: `probe` (crow-skills), `os` (comandos do sistema) ou `assumed`. Ledgers sem o campo continuam válidos; leitores ignoram valores fora desse formato.
 
 ## Quando gravar
 
@@ -47,6 +48,7 @@ O coordenador é o único que grava; workers informam e o coordenador registra.
 - início da execução (fases conhecidas, unidades da primeira fase);
 - unidade criada, iniciada, concluída, falhada ou pulada;
 - nova fase dimensionada após ler a anterior;
+- decisão de paralelismo antes de cada fan-out (`resources`; veja [recursos da máquina](resources.md));
 - encerramento (`done`, `failed` ou `cancelled`, com `endedAt`).
 
 O script incluído faz isso sem dependências além do Python 3: `scripts/crow_ledger.py`, dentro da pasta desta skill. Use o caminho da pasta que o host informou ao carregar a skill.
@@ -56,6 +58,7 @@ python3 <pasta-da-skill>/scripts/crow_ledger.py start --title "Paridade" --host
 # imprime "<run-id> <caminho>"; guarde o run-id e passe-o em toda chamada seguinte
 python3 <pasta-da-skill>/scripts/crow_ledger.py unit u1 --run <run-id> --phase d --title "Mapear CLI" --owner subagent:leitor --status running
 python3 <pasta-da-skill>/scripts/crow_ledger.py unit u1 --run <run-id> --status done --summary "3 pontos de extensão"
+crow-skills resources --json | python3 <pasta-da-skill>/scripts/crow_ledger.py resources --run <run-id> --from-probe - --note "2 ondas de 2"
 python3 <pasta-da-skill>/scripts/crow_ledger.py show --run <run-id>          # bloco de processos para o chat
 python3 <pasta-da-skill>/scripts/crow_ledger.py show --tree --run <run-id>   # árvore de fases, se o usuário pedir detalhe
 python3 <pasta-da-skill>/scripts/crow_ledger.py finish --run <run-id> --status done

package/skills/crow-behaviour/references/resources.md

@@ -0,0 +1,44 @@
+# Recursos da máquina
+
+Leia antes de qualquer fan-out (subagentes, workflow, shells paralelos) e antes de iniciar build, suíte de testes, dev server, watcher, emulador, navegador ou container. Orquestrar não pode travar a máquina do usuário: cada agente, worker e processo em segundo plano disputa a mesma memória.
+
+## Medir antes de paralelizar
+
+1. Com o CLI do crow-skills disponível, rode `crow-skills resources --json` e use `data.recommendation`: `mode` (`parallel`, `reduced` ou `sequential`), `maxParallelAgents`, `maxParallelHeavyJobs` e `maxWorkersPerJob`. Leva menos de 100 ms e não altera nada além de um cache em `~/.local/state/crow-skills`.
+2. Sem o CLI, meça com o sistema: macOS `sysctl kern.memorystatus_vm_pressure_level kern.memorystatus_level hw.memsize` (1 normal, 2 warn, 4 critical; o level é o % disponível); Linux `/proc/meminfo` (MemAvailable) e `/proc/pressure/memory` (PSI). Aplique os mesmos limites abaixo.
+3. Sem nenhuma medida possível, assuma `reduced`: no máximo 2 agentes e 1 job pesado por vez.
+4. Se o host injetar a linha `[crow-skills] memória: ...` no prompt, ela já é a medida atual; não repita a sonda só para confirmá-la.
+
+Meça de novo antes de cada nova rodada de fan-out e quando um job pesado terminar; a recomendação vale para aquele momento, e outras sessões do usuário consomem a mesma máquina.
+
+## Limites que você aplica
+
+- Nunca exceda a recomendação: agentes simultâneos ≤ `maxParallelAgents`; jobs pesados simultâneos (build, suíte completa, dev server, emulador, container, navegador automatizado) ≤ `maxParallelHeavyJobs`, somando todos os seus agentes.
+- `warn` ou `reduced`: reduza o fan-out ao recomendado, rode jobs pesados um de cada vez quando o limite for 1, encerre o que não usa antes de abrir outro.
+- `critical` ou `sequential` com `maxParallelHeavyJobs` 0: trabalhe sequencialmente, não inicie job pesado novo, termine ou pare os que esta execução abriu e retome quando a pressão cair. Avise o usuário em uma linha.
+- Uma unidade com teto menor que a lista de itens vira lotes: processe em ondas do tamanho permitido, sem pré-lançar a fila inteira.
+- Os limites do host e do usuário continuam valendo; a recomendação só reduz, nunca autoriza mais concorrência do que o host permite.
+
+## Jobs pesados com workers limitados
+
+`maxWorkersPerJob` é um teto: use-o só para baixar a concorrência que a ferramenta ou o projeto já usa, nunca para paralelizar um comando serial. Ferramentas que por padrão usam todas as CPUs: `ninja -jN`, `cargo build -j N`, `cargo test -- --test-threads=N`, `jest --maxWorkers=N`, `vitest --maxWorkers=N`, `go test -p N`, `gradle --max-workers=N`, `xcodebuild -jobs N`, `ffmpeg -threads N`. Já paralelas por configuração do projeto: reduza o valor existente (`make -jN`, `mvn -T N`, `pytest -n N` só se o projeto já usa pytest-xdist; `terraform plan -parallelism=N` só abaixo do padrão 10). Comandos seriais (`make` sem `-j`, `mvn` sem `-T`, `pytest` sem xdist) ficam como estão. Containers: limite memória e CPU no `docker run --memory/--cpus` ou no compose quando o projeto já usa limites. Sem flag conhecida, rode o comando padrão do projeto sem aumentar a concorrência.
+
+- Rode primeiro os testes direcionados à mudança (arquivo, pacote, filtro por nome); a suíte completa vem depois, uma vez, quando os direcionados passarem e o plano exigir.
+- Um dev server ou watcher por projeto: antes de subir outro, procure o que já está rodando (porta, processo ou registro do próprio host) e reutilize-o. Não abra um por agente.
+- Containers, emuladores e navegadores: um por vez salvo necessidade do teste; feche abas e sessões ao terminar a verificação.
+
+## Encerrar o que você abriu
+
+Antes de concluir a execução (e ao cancelar), pare cada processo em segundo plano, dev server, watcher, navegador, emulador ou container que esta execução iniciou, pelo id que você registrou ao iniciá-lo; confirme que saiu. Não mate processos que você não iniciou: liste-os ao usuário se estiverem pesando. Registre no relato final o que subiu e encerrou.
+
+## Contexto e memória do próprio agente
+
+Não carregue arquivos, logs ou dumps enormes inteiros no contexto nem em memória: use `head`/`tail`, `grep`, leitura por intervalo, paginação ou streaming, e peça aos workers trechos e posições em vez de conteúdo completo.
+
+## Registrar a decisão
+
+Antes do fan-out, grave a decisão no ledger: `crow-skills resources --json | python3 <pasta-da-skill>/scripts/crow_ledger.py resources --run <run-id> --from-probe - --note "<o que foi decidido>"`; sem o CLI, `crow_ledger.py resources --run <run-id> --mode reduced --agents 2 --heavy 1 --source os|assumed --note "..."`. O campo é opcional e ledgers antigos continuam válidos.
+
+## Limites desta regra
+
+Esta regra só reduz a sua própria concorrência. Não altera limites, permissões, swap, prioridades, sandbox ou configurações do host, não instala ferramenta de monitoramento e não encerra processos alheios. Os limiares ficam em `~/.config/crow-skills/resources.json`, que só o usuário edita.

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.