Honey Agent Skill by GreenPT

🍯 Honey (Encolhi a IA)

Escreva menos código e fale menos sobre ele. Honey (Encolhi a IA) por GreenPT é uma habilidade de codificação entre ferramentas que reduz o uso de tokens do agente de codificação de IA e os custos de API de LLM — fazendo os agentes emitirem menos código e menos prosa sem perder a correção. Funciona com Claude (claude.ai e a API), Claude Code, Cursor, GitHub Copilot, Codex, Gemini CLI, Windsurf, Cline, OpenClaw, oh-my-pi, Kiro, Kilo Code e Hermes Agent. Três alavancas independentes, aplicadas reflexivamente:

1. Menos código — YAGNI primeiro. Suba uma escada (precisa existir? → stdlib → nativo da linguagem → dependência existente → uma linha → bloco mínimo) e pare no primeiro degrau que funcionar. A linha mais barata é aquela que você nunca escreve.
2. Menos prosa — corte a enrolação, as hesitações, a narração de código que já fala por si só. Responda primeiro.
3. Transições mais densas entre agentes — quando o leitor é outro agente, não um humano, entregue a ele o formato mais eficiente em tokens que ele analisa sem perdas (JSON compacto / colunar, ou ESON). Reduz o tamanho da transição ~pela metade com zero perda de recuperação. Dispara apenas aqui — nunca como resposta voltada ao usuário.

Honey combina o que Ponytail (código mínimo) e Caveman (prosa concisa) fazem separadamente, e vai além:

• Auto-intensidade — lite / full / ultra escolhidos reflexivamente a partir da solicitação, sem custo de deliberação (nunca gasta tokens de raciocínio decidindo como cumprir — isso anularia o propósito em modelos de raciocínio).
• Exceções de segurança — validação de entrada, tratamento de erros, autenticação, segredos, migrações, exclusões e qualquer coisa que você pediu explicitamente nunca são comprimidos. Preguiçoso ≠ quebrado.
• Uma família de habilidades, não um único prompt — um núcleo sempre ativo mais satélites sob demanda (review, eco, gain, compress) e uma colmeia de subagentes somente leitura que retornam transições comprimidas. Veja Habilidades e subagentes.

Por quê

Volume é custo. Em sessões de codificação agêntica, o volume de código e prosa gerados é o que aumenta a conta — e a maior parte é desperdício.

Este repositório entrega um benchmark reproduzível (bench/) para você não precisar acreditar nos números: 23 tarefas em três tipos de trabalho — linha de base vs Caveman vs Ponytail vs Honey — mesmo modelo, mesmos prompts, apenas a habilidade muda. A correção é objetiva (testes de unidade, verificações estruturais / de acessibilidade e recuperação sem perdas de ida e volta para transições de agente); a qualidade é pontuada por um painel de juízes de 4 modelos entre famílias (mediana de Opus 4.8 + Sonnet 4.6

• Haiku 4.5 + GPT-5.5) sob uma rúbrica neutra que não menciona comprimento, então uma habilidade concisa não recebe vantagem indevida. Os números abaixo são os resultados confirmados (Claude Opus 4.8, 3 execuções cada) — execute cd bench && npm run bench para reproduzir.

Cada número é um delta pareado por tarefa vs linha de base — as execuções são colapsadas pela mediana, as tarefas são pareadas, e o número é a mediana desses deltas pareados com um teste Wilcoxon p bilateral. Não é uma razão de totais por braço: isso é dominado pela tarefa que por acaso é a mais longa, e é assim que ferramentas de economia de tokens acabam publicando números que ninguém consegue reproduzir. Os endpoints e a escada de execução são pré-registrados em bench/METHODOLOGY.md.

No Claude Opus 5 (23 tarefas × 3 execuções, 207 células, zero recusas ou truncamentos — full-opus5-lean):

	Δ LOC	Δ saída	Δ custo	Testes
Honey	−71% (p<0,001)	−38% (p<0,001)	−24% (p<0,001)	100%

Honey é o único braço sem nenhuma célula falhando — a linha de base sem habilidade falha em quatro. E o corte é maior no modelo mais novo, não menor: −71% de LOC no Opus 5 contra −39% no Opus 4.8. Isso contraria a orientação de prompting de 2026 de que modelos mais novos precisam de menos instrução, que testamos diretamente e rejeitamos — veja METHODOLOGY.md.

Um único número combinado esconde a história, porque as alavancas disparam de forma diferente por tipo de tarefa. Honey no Opus 4.8, onde o conjunto completo de concorrentes foi executado — Δ LOC mede a Alavanca 1 diretamente, Δ saída mede os tokens (código e a prosa ao redor):

Nível de tarefa	tarefas	Δ LOC	Δ saída
Código	14	−53% (p=0,002)	−39% (p=0,007)
Voltado ao usuário	7	−23% (p=0,022)	−7% (p=0,673 — um empate)
Agente para agente	2	— (sem código)	−49% (n=2, sem p)
suíte completa	23	−43% (p<0,001)	−29% (p=0,020)

Contra os concorrentes na suíte completa (vitória/derrota/empate do juiz por teste exato de sinal):

Variante	Δ LOC	Δ saída	Juiz V/D/E	Testes
Caveman	−28% (p<0,001)	−22% (p<0,001)	3/16/2, p=0,004	94%
Ponytail	−33% (p=0,028)	−7% (ns, p=0,267)	1/19/1, p<0,001	90%
Honey	−43% (p<0,001)	−29% (p=0,020)	8/11/2, p=0,648	100%

• Código — o corte mais profundo (−39%) com 100% de aprovação nos testes de unidade. A autoverificação obrigatória do Ponytail infla código trivial (+60% no Opus, +92% no GPT-5.5).
• Voltado ao usuário — a exceção impede que Honey comprima o polimento: o delta de saída aqui é um empate estatístico, e Honey mantém a única aprovação de 100% em acessibilidade enquanto Ponytail cai para 81% na lista de verificação estrutural/a11y.
• Agente para agente — sob consultas de retransmissão adversariais (ordinais, aninhadas, ausência, contagem entre campos), Honey é a única variante que permanece 100% sem perdas enquanto reduz aproximadamente pela metade o tamanho da transição; Caveman e Ponytail comprimem mais e perdem recuperação (67% / 50%). Sua maior e mais limpa vitória — em 2 tarefas, então sem valor de p.
• A qualidade é um empate no geral (p=0,648) — menos tokens sem custo mensurável de qualidade, não qualidade superior. Mas o empate na suíte completa é dois efeitos opostos se cancelando: no Opus, Honey vence voltado ao usuário 6/0/1 (p=0,031) e perde o juiz de código 2/11/1 (p=0,022) — em tarefas onde todas as variantes passam 100% dos testes de unidade, então isso é uma penalidade estilística por concisão, não por correção. Nenhum dos efeitos se replica no GPT-5.5 (p=0,375 / p=1,000), então trate a queda no juiz de código como sugestiva, não estabelecida. A média do juiz do Caveman também empata com a linha de base exatamente — mas, pareado, ele perde 16 de 23 tarefas (p=0,004). Médias escondem isso; testes de sinal não.
• A economia em dólares não é comprovada neste tamanho de amostra. −21% no Opus é p=0,104 — não significativo em 23 tarefas. O volume de saída caiu; a conta ainda não é uma afirmação.

O corte na saída se mantém no GPT-5.5 (−20%, p=0,004; tabela completa de dois provedores em bench/README.md), mas lá o custo vem +14% (ns) porque nenhum cache de prompt foi ativado naquele braço, então cada tarefa pagou o prompt da habilidade do zero. Honey é a única variante sem regressões de teste nas três camadas no Opus.

Medição agêntica de ponta a ponta (harness Cline)

npm run bench faz uma chamada de API por tarefa — limpo para isolar a alavanca de saída, mas nunca exercita um loop de agente, esquemas de ferramentas ou crescimento de contexto multi-turno, onde a conta de tokens de um agente real realmente mora. bench/src/cline-bench.js (npm run bench:cline) executa cada tarefa através da CLI do Cline headless, então os tokens medidos são agênticos de ponta a ponta — prompt do harness e cada iteração do loop incluídos. Honey é injetado como uma regra do Cline, recomendado como o skills/honey/cline-rule.md barato por turno (o núcleo operacional; o SKILL.md completo reenviado a cada turno infla a entrada). Veja bench/README.md.

ESON — Notação Estruturada Eficiente de Objetos

Honey inclui ESON, um formato sem dependências, primeiro-esquema, para transições de agente. Chaves de registro repetidas são emitidas uma vez; contagens de linhas declaradas capturam mensagens truncadas; células compatíveis com JSON preservam tipos. ESON é desenvolvido em seu próprio repositório — Green-PT/honey-eson: a especificação normativa, implementações de referência em JS + Python, vetores de conformidade, o primer canônico de LLM, o Perfil de Fio Honey e negociação. Honey fornece o codec em eso/.

O benchmark reproduzível ESON/TOON/JSON mede bytes, duas estimativas de tokenizador, velocidade do codec e recuperação sem perdas em cinco formatos de transição de agente. Execute-o com npm run bench:eso.

printf '%s' '{"from":"reviewer","findings":[{"sev":"H","issue":"expired token"}]}' | eson encode
eson decode < handoff.eson

CCR — para saída de ferramenta de array enorme e redundante

ESON é sem perdas, para transições onde cada linha importa. CCR (Compress-Cache-Retrieve) é a alavanca com perdas-mas-recuperável para o caso oposto: um array uniforme longo que você precisa ler, mas principalmente folhear — logs, resultados de varredura, fluxos de eventos. Ele mantém uma amostra informativa (endpoints, anomalias/pontos de mudança, cabeça/cauda), armazena em cache as linhas descartadas localmente e deixa um sentinela <<ccr:HASH N_rows_offloaded>>. Nada é perdido — retrieve restaura o original por hash sob demanda.

some-tool | eson crush          # → sampled view + sentinel; originals cached in .honey-ccr/
eson retrieve <hash>            # → the full original array, verbatim

Validado em um log de 90 linhas (opus-4.8 + gpt-5.5): −82% de tokens, precisão de resposta 96% apenas com compressão, 100% com recuperação — e a única falha comprimida foi uma recusa, não uma alucinação. Benchmarks: npm run bench:ccr (tokens) e npm run bench:ccr:comprehension (qualidade). A habilidade honey-ccr diz ao agente quando recorrer a ela.

Limitação conhecida (upstream): builds do Claude Code afetados por anthropics/claude-code#68951 (uma regressão presente desde ~2.1.121, ainda aberta) ignoram o updatedToolOutput de um hook PostToolUse para a ferramenta Bash embutida. Nessas versões, o hook de entrada é executado e guarda o original, mas o modelo ainda recebe a saída bruta não comprimida — honey avisa uma vez no início da sessão quando detecta uma versão afetada. Redirecionamento explícito (some-tool | eson crush) não é afetado: a compressão acontece antes de a saída sair da ferramenta. Separadamente, os hooks precisam de Node >= 14 no PATH com o qual o Claude Code os executa — sessões do aplicativo desktop herdam o PATH do launchd, não o do seu perfil de shell, então um /usr/local/bin/node desatualizado é comum; o hook agora avisa em vez de falhar silenciosamente.

PX — leituras renderizadas em imagem para grandes volumes densos somente leitura

A intuição: enviar um arquivo como texto custa por caractere; enviar uma imagem custa por pixel, não importa quanto texto esteja amontoado nela. Então uma "foto da página" custa ~5× menos que a própria página — e lê-la tem problemas de foto: a essência sobrevive, um número de série exato pode não sobreviver.

Concretamente: texto denso empacota ~3 caracteres por token de imagem vs ~1 como texto. PX explora essa lacuna no caminho de leitura: quando o agente precisa folhear algo enorme que nunca editará (código de fornecedor, um diff grande, documentação), ele renderiza em páginas PNG com o export e Reads do pxpipe as imagens em vez do texto.

npx pxpipe-proxy export --json --out "$TMPDIR" src/   # → page-*.png + factsheet.txt + token report

Medido: até −85% de tokens em uma única leitura. Benchmark de corpus de repositório (npm run bench:px, resultados): −79…85%, −82% em média (26,4 mil tokens de texto do Claude → 4,8 mil estimados de imagem); ~−75% no total por leitura após a ficha técnica + sobrecarga de relatório; a conta de proxy de ponta a ponta do próprio pxpipe mede −59…70% no nível de carga de trabalho completa.

Compreensão é uma história de Fable. O painel ao vivo de 4 modelos (node bench/px/comprehension.mjs — 10 perguntas byte-exatas, texto vs renderização):

modelo	texto	da renderização
Claude Fable 5	10/10	7/10
Claude Opus 4.8	10/10	4/10
Claude Sonnet 4.6	10/10	4/10
Claude Haiku 4.5	10/10	1/10
Somente modelos da classe Fable leem renders de forma utilizável — e mesmo o Fable não é byte-safe.
Perda em strings exatas — leituras incorretas são confabulações silenciosas (o Haiku respondeu a uma
pergunta-semente com 0x9e3779b9, uma constante que não está no arquivo), então a exportação
envia tokens de precisão verbatim (caminhos, SHAs, números) como texto factsheet.txt, e a
habilidade honey-px proíbe isso para arquivos que você editará, segredos ou leitores
não-Fable. Pela API bruta, prefixe o banner prompt.txt da exportação — a camada de
segurança do Fable recusa renders densos nus. Complementar ao CCR: o CCR descarta
linhas redundantes de forma recuperável; o PX mantém tudo à vista a preço de pixels. Em
/honey ultra, a habilidade central busca o PX automaticamente em leituras qualificadas
(grandes, densas, somente leitura); em outras intensidades, permanece sob demanda via honey-px.
Para a
versão completa no nível de protocolo (prompt do sistema, documentação de ferramentas, histórico), execute o proxy pxpipe
em si — Honey e pxpipe se empilham.

Escolha Honey quando quiser a melhor qualidade por token, especialmente no Claude Code.

Pré-compressão de entrada — um resultado negativo medido

As três alavancas acima cortam a saída. Há desperdício simétrico no lado da entrada — preenchimento, gentilezas e frases repetidas no próprio prompt. hooks/precompress.js é um compressor determinístico, sem modelo, que os remove antes de o prompt chegar ao LLM, protegendo código, caminhos, URLs, strings entre aspas duplas e números verbatim (nunca toca em um token que você precise exato).

printf '%s' 'Hi! Could you please write a function `add(a, b)` that returns their sum? Thanks so much in advance!' | node hooks/precompress-cli.js
# -> write a function `add(a, b)` that returns their sum? in advance!

É seguro e sem perdas (35/35 verificações de propriedade; em 10 tarefas testadas por unidade, a saída do modelo passa 100%→100% de prompts completos vs. comprimidos), e em prompts tagarelas corta bastante — −16,5% mediana em um corpus verboso escrito à mão.

Mas esse corpus o favorece. Medido em 266 prompts reais digitados por humanos de 35 sessões reais (bench/input/RESULTS.md), o corte é 2,5% total, mediana 0% — 219 de 266 prompts não comprimem nada, porque prompts reais já são concisos e carregam quase nenhum preenchimento. Compressão determinística sem modelo não consegue capturar reformulações reescritas (isso precisa de um modelo), então este é o teto real, não um problema de ajuste.

A conclusão honesta: o prompt é o alvo errado. O volume real de entrada em codificação agêntica é a saída de ferramentas (domínio do CCR) e contexto re-colado entre turnos — não gentilezas humanas. Isso é entregue como um filtro de CLI para o caso de prompt tagarela; não está conectado sempre ativo, porque em tráfego real economizaria ~nada. Mantido aqui como um resultado negativo medido, no espírito do repositório de não exagerar. Reproduza: node bench/input/tokens.mjs.

Habilidades e subagentes

Honey é um núcleo sempre ativo mais uma família de ferramentas sob demanda. O núcleo é um estilo de escrita (deve ser o padrão para valer a pena); o resto são ações que você usa em um momento específico.

Nome	Tipo	O que faz
honey	habilidade central (sempre ativa)	as três alavancas, aplicadas reflexivamente a cada resposta — mais disciplina de custo de loop para execuções recorrentes de /loop. /honey [lite|full|ultra|off]
honey-chat	prompt independente	Honey para chat simples — o núcleo de prosa concisa, sem ferramentas necessárias. Cole skills/honey-chat/SKILL.md nas instruções personalizadas de um Projeto claude.ai, em um Estilo ou em um prompt de sistema da API (~500 tokens); COMPACT.md (≤1.500 caracteres) cabe nos campos de instruções personalizadas do ChatGPT/Gemini
honey-design	habilidade satélite	para UI voltada ao usuário (páginas de destino, componentes): mantém o polimento total do render, corta tokens escrevendo o design de forma densa (variáveis CSS, classes compartilhadas, clamp()) — mesmos pixels, menos tokens
honey-review	habilidade satélite	revisa um diff por excesso de engenharia + excesso de verbosidade; lista de exclusão concisa
honey-eco	habilidade satélite	CO₂ / $ / tokens economizados desta sessão, a partir do port EcoLogits commitado
honey-gain	habilidade satélite	o placar de benchmark commitado (lê bench/results/ em tempo de execução)
honey-debt	habilidade satélite	coleta todo marcador de atalho honey: em um registro de dívida, sinalizando os que não têm gatilho de revisão — para que uma simplificação deliberada não se torne permanente silenciosamente
honey-compress	habilidade satélite	reescreve um arquivo de memória relido (CLAUDE.md, AGENTS.md) de forma concisa para cortar tokens de entrada; faz backup do original
honey-memory	habilidade satélite	cria + mantém um PROJECT.md por projeto commitado para que agentes parem de redescobrir os mesmos fatos a cada sessão fria; armazena apenas contexto estável, que não está no código, mantido honesto por viver no git
honey-ccr	habilidade satélite	esmaga saída de ferramenta de array grande e redundante (logs, resultados de varredura) em uma visão amostrada; com perda, mas recuperável via eson crush/retrieve
honey-px	habilidade satélite	lê grandes volumes densos somente leitura como páginas PNG renderizadas (npx pxpipe-proxy export) — tokens de imagem escalam com pixels, não caracteres: até −85% em conteúdo denso em tokens (somente leitores classe Fable); com perda em strings exatas, nunca para arquivos que você editará
honey-loop	habilidade satélite	disciplina de custo para execuções recorrentes de /loop: ritmo ciente de cache (pule a zona morta de 300s), orientado a eventos em vez de polling, curto-circuito sem mudanças, identificador de estado compacto, condição de parada
honey-superpowers	habilidade satélite	empilha Honey em fluxos de trabalho de subagentes estilo Superpowers: a diretiva Honey para injetar em cada prompt de despacho (variantes de trabalhador e revisor). No Claude Code, o hook SubagentStart do plugin injeta automaticamente
honey-hive	habilidade guia	decide quando delegar à colmeia vs. trabalhar inline
hive-scout	subagente (haiku, somente leitura)	localiza símbolos / chamadores / configurações; retorna um mapa JSON compacto com chave por id
hive-reviewer	subagente (haiku, somente leitura)	revisa um diff/arquivos; retorna descobertas JSON colunares com chave por id
hive-builder	subagente (sonnet, ≤2 arquivos)	faz uma edição cirúrgica sob a escada; retorna um manifesto de mudança compacto

A colmeia é a Alavanca 3 com um runtime: cada subagente retorna um handoff comprimido, então o resultado injetado de volta no contexto do orquestrador é −44–53% menor com zero perda (npm run bench:hive). Ao vivo, as habilidades também se sustentam — honey −86%, honey-review −70%, hive-reviewer −43% tokens de saída com correção aprovada (npm run bench:skills). Veja bench/hive/RESULTS.md e bench/skills/RESULTS.md.

Em trabalho voltado ao usuário — onde a habilidade central gasta tokens porque polimento é a especificação — honey-design mantém o mesmo polimento renderizado por −19% tokens de saída vs. sem habilidade (juiz 92 vs 90), superando a habilidade central em ambos os eixos em 7 tarefas de página de destino/UI. Veja bench/results/honey-design.md.

Nota de honestidade. Versões anteriores deste README citavam qualidade 92% / 78% / 73% e tokens −57% / −65% / −70% de uma execução não publicada. Elas não se reproduzem — a variação real de qualidade é muito mais estreita e a economia de tokens depende do nível (e o Ponytail adiciona tokens em código simples).

Uma segunda correção, 2026-07-29: os números anteriores eram razões de totais de braço (sum(honey)/sum(baseline)), que uma tarefa longa pode dominar. Tudo acima agora é uma mediana pareada por tarefa com um valor-p. Isso moveu o destaque do honey de −15% para −29% — o método antigo estava subestimando — mas também aposentou dois números que se revelaram artefatos de outliers: a "saída −22%" do Ponytail é realmente −7% (ns), e a "qualidade empatada" do Caveman é uma perda de 16-de-23 tarefas (p=0,004). Método e endpoints pré-registrados: bench/METHODOLOGY.md. Regere qualquer figura offline com node bench/src/report.js --stamp full-opus48 --by-type.

Instalação

Claude Code (marketplace de plugins)

/plugin marketplace add Green-PT/honey-for-devs
/plugin install honey@greenpt

Depois execute /honey uma vez para ativar (/honey lite|full|ultra para definir intensidade, /honey off para parar). O estado persiste entre sessões — um hook SessionStart o reativa a cada sessão até você executar /honey off. Um selo 🍯 mostra o modo ativo na sua linha de status. Se seu cliente autocompletar /honey para honey:honey, é o mesmo comando.

Claude simples (claude.ai / API) — sem instalação

A edição de chat, skills/honey-chat/SKILL.md (~500 tokens), é o núcleo de prosa concisa com as alavancas de harness de agente removidas — nada nela precisa de ferramentas. Duas maneiras de usá-la:

• Instruções personalizadas de Projeto ou um Estilo (recomendado): cole o arquivo. As instruções se tornam parte do prompt do sistema, então Honey se aplica a cada mensagem em cada conversa — sempre ativo, sem necessidade de gatilho. O prefixo é cacheado no prompt, e os ~500 tokens de entrada são pagos muitas vezes pela saída reduzida pela metade.
• Skill enviada (planos pagos): compacte a pasta honey-chat/ e envie-a como uma Skill. Mais barata em repouso (apenas a descrição permanece no contexto), mas carrega somente quando Claude julga relevante — para um estilo de escrita sempre ativo, instruções de Projeto são o padrão melhor.

Na API, use o arquivo como (parte do) seu prompt system. Fixe a intensidade adicionando uma linha: Default to honey ultra ou Default to honey lite.

Outras UIs de chat (ChatGPT, Gemini, …): o prompt é agnóstico de modelo — nada nele é específico do Claude. Campos de instruções personalizadas da web geralmente limitam a entrada (ChatGPT: 1.500 caracteres), então cole a edição compacta, skills/honey-chat/COMPACT.md (≤1.500 caracteres, protegida por teste), no campo "Como você gostaria que o ChatGPT respondesse?" do ChatGPT ou no campo de informações salvas/instruções do Gemini. Mesmas regras, condensadas; onde o campo permite mais (Projetos Claude, prompts de sistema da API), prefira o SKILL.md completo.

Instalador de uma linha (assistente interativo)

Em um terminal, ele pergunta quais agentes você usa, se deseja conectar o selo de CO₂, soltar arquivos de regras por repositório e seu modo padrão — então configura exatamente isso. O assistente pergunta em /dev/tty, então funciona através de curl | bash. CI/pipes e --yes recorrem à detecção automática.

macOS / Linux / WSL / Git Bash:

curl -fsSL https://raw.githubusercontent.com/Green-PT/honey-for-devs/main/install.sh | bash

Windows (PowerShell 5.1+):

irm https://raw.githubusercontent.com/Green-PT/honey-for-devs/main/install.ps1 | iex

Windows (irm | iex) executa não interativamente; clone e execute node bin/install.js para o assistente. Adicione bash -s -- --yes para pular prompts. Requer Node.js no seu PATH. Seguro para reexecutar; pula ferramentas que você não tem.

Toda plataforma suportada

Plataforma	Instalação
Claude Code	/plugin marketplace add Green-PT/honey-for-devs depois /plugin install honey@greenpt
Codex	codex plugin marketplace add Green-PT/honey-for-devs depois codex plugin add honey@greenpt
oh-my-pi (omp)	omp plugin marketplace add Green-PT/honey-for-devs depois omp plugin install honey@greenpt
GitHub Copilot CLI	copilot plugin marketplace add Green-PT/honey-for-devs depois copilot plugin install honey@greenpt
Gemini CLI	gemini extensions install https://github.com/Green-PT/honey-for-devs
OpenClaw	clawhub install honey (companheiros: clawhub install honey-review, …)
Hermes Agent	node bin/install.js --only hermes — copia .hermes/skills/ para ~/.hermes/skills/; ative com /honey (workspace AGENTS.md é sempre ativo)
Cursor	copie .cursor/rules/honey.mdc para seu projeto
Windsurf	copie .windsurf/rules/honey.md para seu projeto
Cline	copie .clinerules/honey.md para seu projeto (ciente de tokens: o skills/honey/cline-rule.md compacto)
GitHub Copilot (editor)	copie .github/copilot-instructions.md para seu projeto
Kiro	copie .kiro/steering/honey.md (projeto ou ~/.kiro/steering/)
OpenCode	node bin/install.js --only opencode — copia AGENTS.md para ~/.config/opencode/AGENTS.md (sempre ativo em todo projeto) e skills/ para ~/.config/opencode/skills/ como habilidades nativas; verifique com opencode debug skill
Kilo Code	copie .kilo/rules/honey.md para seu projeto (descoberta automática; .kilocode/rules/ também funciona)
Aider / Zed / qualquer leitor de AGENTS.md	copie AGENTS.md para seu projeto

Todas essas também são tratadas automaticamente pelo instalador de uma linha. Veja INSTALL.md para etapas manuais, flags e desinstalação.

Selo de carbono (Claude Code)

Quando Honey está ativo, a linha de status também mostra uma estimativa de CO₂ ao vivo para a sessão e o CO₂/$ economizado vs. uma linha de base sem Honey:

🍯 honey:full · 🌿 44g CO₂ (saved ~26g · $0.18)

(Ilustrativo — uma sessão Opus de ~2 mil tokens de saída.) A estimativa é uma portabilidade fiel de EcoLogits v0.8.2 (verificada para corresponder exatamente ao pacote). Os parâmetros do modelo vêm do próprio registro do EcoLogits (hooks/eco-models.json, exportado por scripts/build-eco-models.py) — correspondidos por ID exato, com fallback para um alias por família para modelos de fronteira novos demais para o registro. As matrizes energéticas variam por provedor — Anthropic na AWS Trainium (~500 gCO₂/kWh), OpenAI na Azure (~400), Google na GCP (~330). Aliases, matrizes e economias por modo ficam em hooks/eco-config.json.

O selo em si é renderizado apenas no Claude Code (ele lê o transcript do Claude Code, onde todo modelo é um modelo Claude). A troca de provedor importa para o scripts/eco_report.py, que roda contra qualquer transcript — CLIs do Codex/Gemini precisariam cada uma do próprio hook de statusline para exibir um selo ao vivo ali.

Os parâmetros são especulativos — a Anthropic não divulga nenhum. O coeficiente bruto do EcoLogits é um limite superior de fluxo único (batch-size-1) — ele dá a uma requisição o conjunto inteiro de GPUs para a geração completa (para Opus, ~1,9 tok/s, ~30× mais lento que a realidade), o que sozinho é ~1,4 kg por 1M de tokens de saída. A produção atende muitas requisições concorrentemente, então o selo divide esse teto por uma concorrência efetiva de batch (serving_concurrency, padrão 32 — calibrada para que a taxa de transferência modelada corresponda ao atendimento real de ~50–70 tok/s) para mostrar o impacto servido realista. eco_report.py imprime tanto o valor servido quanto o teto de fluxo único. Trate-os como um intervalo, não como uma leitura de medidor.

Para o detalhamento completo (uso + incorporado + energia primária) execute o pacote real:

pip install ecologits
python scripts/eco_report.py        # newest session, or --transcript PATH

honey-usage — uso real de tokens em seus agentes de codificação

honey-usage (bin/usage.js, inspirado em tokscale) lê os dados de sessão que seus agentes de codificação já gravam em disco e relata o uso real de tokens — tokens, USD aproximado e CO₂ servido — por aplicativo e modelo. Zero dependências, sem rede, nada sai da sua máquina.

App	Fonte
claude (Claude Code)	$CLAUDE_CONFIG_DIR ou ~/.claude — projects/**/*.jsonl
codex (Codex CLI)	$CODEX_HOME ou ~/.codex — sessions/**/*.jsonl
opencode (OpenCode)	($XDG_DATA_HOME ou ~/.local/share)/opencode/opencode.db (sistema sqlite3)

Apps sem dados são ignorados; adicionar outro é um pequeno scanner que retorna registros {app, model, ts, input, output, cacheRead, cacheWrite, cost}.

honey-usage                                  # table by app + model, totals row
honey-usage --json                           # same aggregation as JSON
honey-usage --daily --since 2026-08-01       # per-day breakdown, date-filtered
honey-usage --client codex,opencode --today  # scope by app and local day

APP     MODEL        INPUT      OUTPUT   CACHE-R      CACHE-W     USD     CO2
claude  claude-opus-5  85,540  4,296,591  1,814,741,458  44,864,917  $1295.62  94.45kg
...

Detalhes que mantêm os números honestos:

• Dedup — o Claude Code repete registros de assistente entre tentativas e continuações; cada (message.id, requestId) conta uma vez, globalmente.
• Custo ciente de cache — tarifas de bench/pricing.json (gravações/leituras de cache são cobradas como multiplicadores da tarifa de entrada; modelos desconhecidos caem para _default, então trate $ como aproximado). Os cached_input_tokens do Codex são separados de input_tokens e precificados como leituras de cache; linhas do OpenCode usam o custo registrado pelo próprio app.
• CO₂ — a mesma estimativa servida do EcoLogits que o selo (hooks/eco.js), a partir dos tokens de saída; as ressalvas do selo se aplicam.
• Economias são limitadas pelo registro — o relatório padrão não tem coluna "economizado": ele mostra o que foi realmente gasto, e os logs do app não registram se o Honey estava ativo. honey-usage --savings reivindica economias apenas para sessões que o hook SessionStart registrou em $CLAUDE_CONFIG_DIR/.honey-usage-ledger.jsonl (Claude Code, desde que o Honey foi instalado — histórico anterior a isso nunca é reivindicado), e apenas para modelos com um carimbo de benchmark comprometido (hooks/eco-config.json savings_provenance). Todo o resto é anotado em rodapé, não estimado. Os números permanecem contrafactuais modelados (est. modeled from bench/results/… — not measured), mesma base do selo.

Como ele se mantém sincronizado

A skill é criada uma vez em skills/honey/SKILL.md. Cada arquivo de regras por plataforma (e AGENTS.md) é gerado a partir dele:

node scripts/build-rules.js          # regenerate all rule files
node scripts/build-rules.js --check  # CI: fail if any copy drifted

Os pacotes de skill do OpenClaw (.openclaw/skills/) e Hermes (.hermes/skills/) são gerados da mesma forma a partir de skills/; execute novamente node scripts/build-openclaw-skills.js / node scripts/build-hermes-skills.js após alterar uma skill. tests/openclaw-skills.test.js e tests/hermes-skills.test.js falham se uma cópia commitada estiver desatualizada.

Licença

MIT — veja LICENSE.

Os dados de estimativa de carbono e coeficientes em hooks/eco-models.json e hooks/eco.js são derivados de EcoLogits e permanecem sob a MPL-2.0. Veja NOTICE para detalhes.