@andespindola/crow-skills 0.10.0 → 0.10.1

package/README.md

@@ -2,7 +2,7 @@
 
 Skills com escopo explícito, conhecimento especializado preservado e fluxos comuns reutilizáveis.
 
-**Versão 0.10.0** ([mudanças](CHANGELOG.md)): o crow-broadcast compartilha, de forma passiva, o que cada sessão e cada CLI (Claude Code, Codex, Gemini CLI, Antigravity, Devin, inclusive dentro do Uniflow) está fazendo nesta máquina: repositório, clone, branch, execução crow em andamento e arquivos em edição; o prompt recebe um resumo só quando outra sessão viva está no mesmo repositório, editar um arquivo que outra sessão tocou ou trocar de branch num clone em uso gera aviso (ou bloqueio, se configurado), e `crow-skills broadcast claim` reserva áreas; a crow-behaviour consulta isso antes de planejar e reserva as áreas que delega ([crow-broadcast](docs/broadcast.md)). A 0.9.0 trouxe o controle de memória da máquina: `crow-skills resources` mede memória, pressão e os CLIs de agente em execução e recomenda quantos agentes, jobs pesados e workers rodar em paralelo; a crow-behaviour consulta essa recomendação antes de cada fan-out (sob `warn` reduz, sob `critical` segue sequencial), limita workers de builds e testes, reutiliza um dev server por projeto e encerra o que abriu, e 15 especialistas que sobem processos pesados ganharam a regra correspondente; o hook de prompt e as status lines só avisam quando a máquina está sob pressão. A 0.8.0 trouxe `crow-skills mode on|off`, que liga e desliga a crow-behaviour em todas as sessões e CLIs (Claude Code, Codex, Gemini CLI, Antigravity, Devin) a partir do próximo prompt, com `/crow on|off` dentro da sessão e o indicador `▸▸ crow on` na status line; a crow-behaviour mostra o progresso como a lista de agentes do host (`● main`, `○ dono  atividade`); `crow-skills events` publica um barramento de eventos dos hooks para terminais; `crow-skills autoupdate on` atualiza o CLI e as skills gerenciadas todo dia e no login. A 0.7.1 trouxe as correções da revalidação no Codex às skills especialistas; a 0.7.0 tornou o Uniflow agente de instalação (`--agents uniflow`); a 0.6.1 passou a mostrar o progresso da crow-behaviour na própria conversa; a 0.6.0 trouxe as regras de entrega das 32 skills especialistas, a partir da [validação no Codex](docs/evaluations/2026-10-26-codex.md).
+**Versão 0.10.1** ([mudanças](CHANGELOG.md)): o controle de recursos passa a tratar swap e CPU como eixos de pressão (swap quase cheio e carga alta reduzem agentes, jobs e workers; nenhuma recomendação cresce com a pressão), mostra a CPU% dos CLIs de agente, traz `crow-skills resources --exec-prefix` para rodar jobs pesados em prioridade baixa e as regras da crow-behaviour sob pressão (reduzir já, um job pesado por vez, não repetir verificação, validação ampla no CI); os hooks do Codex vão para o `config.toml` quando o `hooks.json` é symlink. A 0.10.0 trouxe o crow-broadcast, que compartilha, de forma passiva, o que cada sessão e cada CLI (Claude Code, Codex, Gemini CLI, Antigravity, Devin, inclusive dentro do Uniflow) está fazendo nesta máquina: repositório, clone, branch, execução crow em andamento e arquivos em edição; o prompt recebe um resumo só quando outra sessão viva está no mesmo repositório, editar um arquivo que outra sessão tocou ou trocar de branch num clone em uso gera aviso (ou bloqueio, se configurado), e `crow-skills broadcast claim` reserva áreas; a crow-behaviour consulta isso antes de planejar e reserva as áreas que delega ([crow-broadcast](docs/broadcast.md)). A 0.9.0 trouxe o controle de memória da máquina: `crow-skills resources` mede memória, pressão e os CLIs de agente em execução e recomenda quantos agentes, jobs pesados e workers rodar em paralelo; a crow-behaviour consulta essa recomendação antes de cada fan-out (sob `warn` reduz, sob `critical` segue sequencial), limita workers de builds e testes, reutiliza um dev server por projeto e encerra o que abriu, e 15 especialistas que sobem processos pesados ganharam a regra correspondente; o hook de prompt e as status lines só avisam quando a máquina está sob pressão. A 0.8.0 trouxe `crow-skills mode on|off`, que liga e desliga a crow-behaviour em todas as sessões e CLIs (Claude Code, Codex, Gemini CLI, Antigravity, Devin) a partir do próximo prompt, com `/crow on|off` dentro da sessão e o indicador `▸▸ crow on` na status line; a crow-behaviour mostra o progresso como a lista de agentes do host (`● main`, `○ dono  atividade`); `crow-skills events` publica um barramento de eventos dos hooks para terminais; `crow-skills autoupdate on` atualiza o CLI e as skills gerenciadas todo dia e no login. A 0.7.1 trouxe as correções da revalidação no Codex às skills especialistas; a 0.7.0 tornou o Uniflow agente de instalação (`--agents uniflow`); a 0.6.1 passou a mostrar o progresso da crow-behaviour na própria conversa; a 0.6.0 trouxe as regras de entrega das 32 skills especialistas, a partir da [validação no Codex](docs/evaluations/2026-10-26-codex.md).
 
 **Reconstrução em andamento.** A primeira versão com 32 contratos genéricos não atende à preservação de capacidades solicitada. Não use esse número nem o mapeamento por categoria como prova de substituição das originais. A revisão passa a abranger cada definição e seus recursos, modos e dependências, sem número fixo de skills ou limite artificial de linhas. Veja [critérios e progresso](docs/reconstruction.md).
 
@@ -30,7 +30,7 @@ Exemplos:
 O pacote de cada skill é somente sua pasta em `skills/`. O [CLI crow-skills](docs/cli.md) instala cópias completas e versionadas em agentes/escopos explícitos, com preview, saída JSON, detecção de conflitos e recuperação. Requer Python 3.10+; Git para fontes em clone, Node 18+ para o launcher npm; mutações em macOS/Linux. A distribuição npm privada `@andespindola/crow-skills` inclui um snapshot completo das skills, sem clone ou hooks que as instalem automaticamente. No [Uniflow](docs/cli.md#uniflow), `--agents uniflow --global` grava as skills no store dele (`~/.config/uniflow/skills`), sem tocar no resto da configuração. Em `--global`, instalar a crow-behaviour também grava o guia aditivo do agente (claude, codex, gemini, devin) para usar as skills; `--no-guide` desliga. As integrações de interface (status lines do Claude Code, do Codex e do Antigravity, hooks do modo crow em cada CLI, comando `/crow`, segmento tmux) seguem o mesmo fluxo, preservando a configuração existente; `--no-integrations` desliga. O [barramento de eventos](docs/events.md) e a atualização automática (`crow-skills autoupdate on`) estão no [CLI](docs/cli.md).
 
 ```sh
-npm install -g @andespindola/crow-skills@0.10.0
+npm install -g @andespindola/crow-skills@0.10.1
 crow-skills mode
 crow-skills progress
 ./bin/crow-skills list

package/crow_skills/__init__.py

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

package/crow_skills/cli.py

@@ -96,6 +96,8 @@ def parser():
     child = sub.add_parser("resources", parents=[common],
                            help="Memória, pressão, agentes em execução e paralelismo recomendado (somente leitura)")
     child.add_argument("--no-processes", action="store_true", help="Não varrer os processos dos CLIs de agente (mais rápido)")
+    child.add_argument("--exec-prefix", action="store_true",
+                       help="Só imprimir o prefixo que roda um job pesado em prioridade baixa neste sistema (taskpolicy/nice/ionice/start /low)")
     child = sub.add_parser("autoupdate", parents=[common], help="Atualização diária e no login do crow-skills e das skills gerenciadas")
     child.add_argument("action", choices=("on", "off", "status", "run"))
     child.add_argument("--git-pull", action="store_true", help="on: também atualizar um checkout git limpo em main/master (git pull --ff-only)")
@@ -622,6 +624,8 @@ def run(args):
     if args.command == "broadcast":
         return broadcast_command(args, home)
     if args.command == "resources":
+        if args.exec_prefix:
+            return resources.exec_prefix_data()
         data = resources.probe(home, processes=not args.no_processes)
         data["text"] = resources.render(data)
         return data

package/crow_skills/events.py

@@ -100,11 +100,14 @@ def resources_field(home):
     """crow-resources/1 subset for terminals: memory, pressure and the recommendation.
 
     Added in 0.9.0 without changing crow-snapshot/1: consumers that do not know the
-    field ignore it; the field carries its own schema for future changes.
+    field ignore it; the field carries its own schema for future changes. 0.10.1 adds
+    pressure.swap and cpu (additive).
     """
     data = resources.probe(home, processes=False, use_cache=True)
     return {"schema": data["schema"], "generatedAt": data["generatedAt"], "cached": data["cached"],
-            "memory": data["memory"], "pressure": {"level": data["pressure"]["level"], "reasons": data["pressure"]["reasons"]},
+            "memory": data["memory"], "pressure": {"level": data["pressure"]["level"], "reasons": data["pressure"]["reasons"],
+                                                   "swap": data["pressure"].get("swap")},
+            "cpu": {k: data["cpu"].get(k) for k in ("count", "load1", "load5", "load15", "loadPerCpu1", "loadPerCpu5", "level", "reasons")},
             "recommendation": data["recommendation"], "alert": resources.alert(data), "segment": resources.segment(data)}
 
 

package/crow_skills/integrations.py

@@ -60,6 +60,9 @@ BROADCAST_SCRIPT = "crow_broadcast.py"
 COMMAND_HEADER = "Gerenciado por crow-skills (comando /crow). Não edite; use crow-skills integrations."
 BEGIN = "# >>> crow-skills integrations (gerenciado; use crow-skills integrations uninstall) >>>"
 END = "# <<< crow-skills integrations <<<"
+# codex-hooks inside ~/.codex/config.toml, used when ~/.codex/hooks.json is a symlink (a dotfiles repo) or unsafe.
+HOOKS_BEGIN = "# >>> crow-skills codex-hooks (gerenciado; use crow-skills integrations uninstall) >>>"
+HOOKS_END = "# <<< crow-skills codex-hooks <<<"
 CODEX_ITEMS = ["model-with-reasoning", "context-remaining", "current-dir", "task-progress", "used-tokens"]
 SNIPPET_HEADER = "# Gerenciado por crow-skills (integração tmux). Não edite; use crow-skills integrations."
 UNSUPPORTED = {
@@ -494,6 +497,24 @@ def add_hooks(data, entries, layout):
 
 
 def hooks_sync(name, store, home, record, desired, python, dry):
+    if name == "codex-hooks":
+        unsafe = codex_hooks_json_unsafe(home)
+        if record and record.get("mode") != "toml" and unsafe:
+            # Installed into a regular hooks.json that has since become a symlink (moved into dotfiles):
+            # our entries live in the target now. Keep the record (and the script they call) until the
+            # user removes them; then the hooks move to config.toml on the next install.
+            left = codex_json_duplicates(home)
+            if left:
+                return record, "skip", ("~/.codex/hooks.json virou symlink (ou ficou inseguro) depois que o crow-skills gravou nele: "
+                                        + str(left) + " entrada(s) do crow-skills com crow_hook.py continuam no arquivo de destino, "
+                                        "que o crow-skills não edita. Remova-as de lá" + (" e rode crow-skills integrations install de novo: os hooks "
+                                        "passam para ~/.codex/config.toml." if desired else "; o registro e o script que elas chamam ficam "
+                                        "até isso, para o Codex não chamar um script apagado."))
+            record = None
+            if not desired:
+                return None, "skip", "Entradas do crow-skills já ausentes de ~/.codex/hooks.json; controle encerrado."
+        if (record or {}).get("mode") == "toml" or (unsafe and (desired or not record)):
+            return codex_hooks_toml_sync(store, home, record, desired, python, dry, unsafe)
     spec = HOOKS[name]
     target = spec["file"](home)
     if desired and not record and spec["requires"] is not None and not os.path.exists(spec["requires"](home)):
@@ -535,6 +556,192 @@ def hooks_sync(name, store, home, record, desired, python, dry):
     return new_record, action, note
 
 
+# --- codex-hooks in config.toml ------------------------------------------------------------------
+# Codex 0.165 reads hooks from hooks.json and from config.toml (HooksToml: one array of matcher
+# groups per event, each {matcher?, hooks: [{type = "command", command, timeout, async, ...}]};
+# the same schema as hooks.json, read from the binary). When ~/.codex/hooks.json is a symlink
+# (typically into a dotfiles repository) crow-skills never writes through it: the entries go to a
+# marked block at the end of config.toml, verified by parsing and restored byte for byte.
+
+def codex_hooks_json_unsafe(home):
+    """Why ~/.codex/hooks.json cannot be edited safely ("symlink" or a reason), or None."""
+    path = home / ".codex" / "hooks.json"
+    if os.path.islink(path):
+        return "symlink"
+    try:
+        read_regular(protect(path, home))
+    except CrowError as exc:
+        return str(exc)
+    return None
+
+
+def codex_json_duplicates(home):
+    """crow_hook.py entries in ~/.codex/hooks.json when crow-skills does not manage that file
+    (read only, through the symlink): with the config.toml block they would run twice."""
+    path = home / ".codex" / "hooks.json"
+    try:
+        if not os.path.exists(path) or os.path.getsize(path) > 1024 * 1024:
+            return 0
+        with open(path, "r", encoding="utf-8") as handle:
+            data = json.load(handle)
+    except (OSError, ValueError):
+        return 0
+    count = 0
+    hooks = data.get("hooks") if isinstance(data, dict) else None
+    for groups in (hooks.values() if isinstance(hooks, dict) else ()):
+        for group in groups if isinstance(groups, list) else []:
+            items = group.get("hooks") if isinstance(group, dict) else None
+            for item in items if isinstance(items, list) else []:
+                if isinstance(item, dict) and HOOK_SCRIPT in str(item.get("command", "")):
+                    count += 1
+    return count
+
+
+def toml_string(value):
+    return json.dumps(value, ensure_ascii=False)  # a JSON string is a valid TOML basic string
+
+
+def codex_hooks_block(entries):
+    lines = [HOOKS_BEGIN]
+    for event, groups in entries.items():
+        for group in groups:
+            lines.append("[[hooks." + event + "]]")
+            if "matcher" in group:
+                lines.append("matcher = " + toml_string(group["matcher"]))
+            for item in group["hooks"]:
+                lines.append("[[hooks." + event + ".hooks]]")
+                for key, value in item.items():
+                    lines.append(key + " = " + (("true" if value else "false") if isinstance(value, bool) else
+                                                str(value) if isinstance(value, int) else toml_string(value)))
+    return "\n".join(lines + [HOOKS_END]) + "\n"
+
+
+def without_groups(parsed, groups):
+    """parsed minus each of groups ({event: [group]}), each removed once by equality; None when
+    one of them is not there unchanged (edited, or keys appended to it)."""
+    result = deepcopy(parsed)
+    hooks = result.get("hooks")
+    for event, wanted in groups.items():
+        current = hooks.get(event) if isinstance(hooks, dict) else None
+        if not isinstance(current, list):
+            return None
+        for group in wanted:
+            if group not in current:
+                return None
+            del current[len(current) - 1 - current[::-1].index(group)]  # the last equal one: ours come after the user's
+        if not current:
+            del hooks[event]
+    return result
+
+
+def codex_hooks_toml_sync(store, home, record, desired, python, dry, unsafe):
+    label = "~/.codex/config.toml"
+    if tomllib is None:
+        return record, "skip", "Python 3.11+ (tomllib) é necessário para gravar os hooks do Codex em config.toml com verificação."
+    directory = home / ".codex"
+    if desired and not record and not directory.is_dir():
+        return None, "skip", "~/.codex/hooks.json: CLI não configurado neste perfil; nada alterado."
+    path = protect(directory / "config.toml", home)
+    old = read_regular(path)
+    try:
+        text = old.decode("utf-8") if old is not None else ""
+    except UnicodeDecodeError:
+        return record, "skip", "config.toml não é UTF-8; hooks do Codex não configurados."
+    span = marked(text, HOOKS_BEGIN, HOOKS_END)
+    stripped = text[:span[0]] + text[span[1]:] if span else text
+    try:
+        current = tomllib.loads(text)
+        base = tomllib.loads(stripped)
+    except tomllib.TOMLDecodeError:
+        return record, "skip", "config.toml não é TOML válido; hooks do Codex não configurados."
+    old_block = text[span[0]:span[1]] if span else None
+    if span and (not record or record.get("block_sha") != sha(old_block.encode("utf-8"))):
+        return (record if desired else None), "skip", ("Bloco codex-hooks do crow-skills em config.toml foi editado ou não tem registro; "
+                                                       "nada alterado. Remova o bloco manualmente e rode crow-skills integrations install.")
+    if span:
+        old_groups = tomllib.loads(old_block).get("hooks", {})
+        expected_base = without_groups(current, old_groups)
+        if expected_base is not None and "hooks" in expected_base and not expected_base["hooks"] and "hooks" not in base:
+            expected_base.pop("hooks")
+        if expected_base != base:
+            return (record if desired else None), "skip", ("Chaves acrescentadas logo depois do bloco codex-hooks em config.toml mudariam de "
+                                                           "tabela; nada alterado. Revise o arquivo manualmente.")
+    added_newline = (record or {}).get("added_newline", False)
+    if not desired:
+        if not record:
+            return None, "unchanged", None
+        if not span:
+            return None, "skip", "Bloco codex-hooks ausente de config.toml; controle encerrado."
+        result = stripped
+        if added_newline and span[1] == len(text) and result.endswith("\n"):
+            result = result[:-1]
+        if dry:
+            return None, "remove", None
+        backup(store, "codex-config", old)
+        if record.get("created_file") and not result.strip():
+            path.unlink()
+        else:
+            write(path, result.encode("utf-8"), old)
+        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."
+    entries = hook_entries(store, home, python, "codex")
+    block = codex_hooks_block(entries)
+    if span:
+        if old_block == block:
+            report_duplicates(home)
+            return record, "unchanged", None
+        result = text[:span[0]] + block + text[span[1]:]
+    else:
+        added_newline = bool(stripped) and not stripped.endswith("\n")
+        result = stripped + ("\n" if added_newline else "") + block
+    expected = deepcopy(base)
+    hooks = expected.setdefault("hooks", {})
+    try:
+        for event, groups in entries.items():
+            if not isinstance(hooks.setdefault(event, []), list):
+                raise ValueError(event)
+            hooks[event].extend(deepcopy(groups))
+        if tomllib.loads(result) != expected:
+            raise ValueError("diff")
+    except (tomllib.TOMLDecodeError, ValueError, AttributeError):
+        return record, "skip", ("A tabela [hooks] de config.toml tem um formato que o bloco do crow-skills não preservaria "
+                                "(por exemplo, hooks definidos inline); nada alterado.")
+    action = "update" if record else "install"
+    new_record = {"path": str(path), "mode": "toml", "added_newline": added_newline, "installed_at": now(),
+                  "block_sha": sha(block.encode("utf-8")),
+                  "created_file": record.get("created_file", False) if record and record.get("mode") == "toml" else old is None}
+    note = ("~/.codex/hooks.json " + ("é symlink" if unsafe == "symlink" else "não pode ser editado com segurança") +
+            "; os hooks do crow-skills foram gravados em ~/.codex/config.toml (bloco marcado) e o hooks.json não foi tocado. "
+            "Codex só executa hook novo ou alterado depois de aprovado: abra o Codex, rode /hooks e aprove as entradas do "
+            "crow-skills.") + codex_hooks_feature(home)
+    report_duplicates(home)
+    if dry:
+        return new_record, action, note.strip()
+    new_record["backup"] = backup(store, "codex-config", old)
+    write(path, result.encode("utf-8"), old)
+    return new_record, action, note.strip()
+
+
+# Findings that do not stop an integration but need the user (reported in "skipped").
+_WARNINGS = []
+
+
+def report_duplicates(home):
+    note = codex_duplicates_note(home)
+    if note:
+        _WARNINGS.append({"integration": "codex-hooks", "reason": note})
+
+
+def codex_duplicates_note(home):
+    count = codex_json_duplicates(home)
+    if not count:
+        return None
+    return ("~/.codex/hooks.json (não gerenciado pelo crow-skills) já tem " + str(count) +
+            " entrada(s) com crow_hook.py, provavelmente adicionadas à mão; com o bloco em config.toml elas rodariam em dobro. "
+            "Remova-as do hooks.json (ou do arquivo para onde o symlink aponta); o crow-skills não edita esse arquivo.")
+
+
 # --- /crow slash commands ------------------------------------------------------------------------
 
 COMMANDS = {
@@ -612,9 +819,9 @@ def command_sync(name, store, home, record, desired, python, dry):
 
 # --- codex ---------------------------------------------------------------------------------
 
-def marked(text):
-    begins = [m.start() for m in re.finditer(r"(?m)^" + re.escape(BEGIN) + r"\n", text)]
-    ends = [m.end() for m in re.finditer(r"(?m)^" + re.escape(END) + r"\n", text)]
+def marked(text, begin=BEGIN, end=END):
+    begins = [m.start() for m in re.finditer(r"(?m)^" + re.escape(begin) + r"\n", text)]
+    ends = [m.end() for m in re.finditer(r"(?m)^" + re.escape(end) + r"\n", text)]
     if not begins and not ends:
         return None
     if len(begins) != 1 or len(ends) != 1 or ends[0] <= begins[0]:
@@ -886,6 +1093,7 @@ def sync(store, home, wanted, dry_run=False, python=None):
             after["files"][record["path"]] = {"backup": record.get("backup"), "created_file": record.get("created_file", False),
                                               "written_sha": record["written_sha"]}
     global _FILES, _LIVE
+    del _WARNINGS[:]
     _FILES = {k: dict(v) for k, v in after["files"].items()}
     _LIVE = after["integrations"]
     with (nullcontext() if dry_run else store.lock()):
@@ -930,6 +1138,8 @@ def sync(store, home, wanted, dry_run=False, python=None):
                     if script.exists():
                         script.unlink()
                 remove_bytecode(store)
+    report["skipped"].extend(_WARNINGS)
+    del _WARNINGS[:]
     for key in ("changes", "skipped"):
         report[key].sort(key=lambda c: NAMES.index(c["integration"]) if c["integration"] in NAMES else 99)
     report["dry_run"] = dry_run
@@ -946,6 +1156,12 @@ def status(store, home):
             row["path"] = record.get("path") or record.get("conf")
             if name == "tmux-status" and not record.get("block"):
                 row["note"] = "tmux.conf é symlink; linha source-file adicionada manualmente pelo usuário."
+            if name == "codex-hooks" and record.get("mode") == "toml":
+                row["note"] = "Gravado em ~/.codex/config.toml (bloco marcado): ~/.codex/hooks.json é symlink ou inseguro e não é editado."
+                duplicates = codex_duplicates_note(home)
+                if duplicates:
+                    row["note"] += " " + duplicates
+                    row["duplicates"] = codex_json_duplicates(home)
         rows.append(row)
     for agent, reason in UNSUPPORTED.items():
         rows.append({"integration": UNSUPPORTED_ROW[agent], "agents": [agent], "status": "unsupported", "note": reason})