iron-edge 2.3.1 → 2.4.0

package/README.md

@@ -213,6 +213,31 @@ npx iron-edge verify
 
 ---
 
+## Iron Office
+
+Converse com o Iron pelo dashboard ([iron-office.vercel.app](https://iron-office.vercel.app)) e veja os agentes trabalhando no feed e no mapa 3D.
+
+```bash
+npx iron-edge office
+```
+
+Antes, faça o **passo 4** do onboarding do Iron Office (ele salva a sua chave em `~/.claude/iron-office-api-key`).
+
+O que esperar:
+
+1. O comando instala (ou atualiza) o plugin de canal `iron-office` e abre o Claude Code com ele ligado.
+2. O Claude Code mostra um **aviso de tela cheia**: canais ainda são recurso em teste. Aceite.
+3. Abra a página **Iron** do dashboard. Em até 1 minuto aparece "Iron online". Escreva ali e o Iron responde ali.
+4. **Deixe essa aba do terminal aberta.** É ela que faz o Iron responder no site.
+
+Por padrão a sessão do `office` roda **sem pedir licença** a cada ferramenta (é o que deixa o Iron trabalhar enquanto você está só no site). `npx iron-edge office --safe` abre pedindo licença a cada ferramenta. Qualquer outro argumento vai direto pro `claude`.
+
+Mensagem escrita no site com o terminal fechado espera até 15 minutos; depois disso expira e o chat avisa pra mandar de novo (ordem velha não é executada sem você ver).
+
+O plugin também manda a atividade das sessões pro seu painel: veja o que sai em "Sobre o que sai da sua máquina", mais abaixo.
+
+---
+
 ## Requisitos
 
 - **Node.js** 18 ou superior
@@ -230,12 +255,14 @@ O Iron Edge instala uma equipe de agentes especializados diretamente no Claude C
 
 Seus dados ficam locais em `~/.iron/`. Sobre o que sai da sua máquina, com precisão:
 
-- **Para o Iron Office** (`iron-office.vercel.app`, servidor deste projeto) vão dados de apenas **2 agentes**: `iron-auditor` e `iron-shopify`. E só se você criar a chave em `~/.claude/iron-office-api-key`. Confira você mesmo: `grep -rln "iron-office" ~/.claude/agents/`.
+- **Para o Iron Office** (`iron-office.vercel.app`, servidor deste projeto), e só se você criar a chave em `~/.claude/iron-office-api-key`:
+  - dados de apenas **2 agentes**, `iron-auditor` e `iron-shopify`. Confira: `grep -rln "iron-office" ~/.claude/agents/`;
+  - **se você rodou `npx iron-edge office`**, o plugin `iron-office` fica instalado e manda a atividade de **toda sessão** do Claude Code pro seu painel (feed e mapa 3D): nome da ferramenta, caminho do arquivo (nunca o conteúdo), os primeiros 200 caracteres de cada comando de terminal e a descrição dele, buscas, o domínio dos endereços visitados, nome e descrição dos agentes, a pasta e o identificador da sessão. A resposta das ferramentas nunca sai. Padrões conhecidos de segredo nesses campos (chaves de Stripe, Shopify, Meta, GitHub, OpenAI, Supabase e AWS, `Bearer`, `ALGO_KEY=`, `--password`, `-u usuario:senha`…) são apagados antes do envio; é uma lista de padrões, não garantia. Lista completa no README do plugin (github.com/filipecoff21-code/iron-office-channel). Desligar: `claude plugin disable iron-office@iron-office-channel`. Conferir se está ligado: `claude plugin list`.
 - **Para a internet aberta**, através das ferramentas do próprio Claude Code (`WebSearch` / `WebFetch`), vão as buscas de **41 dos 44 agentes** — é como o `iron-research` pesquisa mercado e o `iron-spy` lê a biblioteca de anúncios. Isso passa pelo Claude Code, com a visibilidade e a aprovação que ele te dá; não é canal deste pacote. Confira: `grep -rln "WebSearch\|WebFetch" ~/.claude/agents/`.
 - **A skill `clone-site`** baixa a URL que você mandar clonar. É o trabalho dela.
 
 
-Sendo exato sobre a força dessa garantia, porque ela não é um sandbox: cada bloco que chama o Iron Office começa com uma guarda (`[ -z "$IRON_KEY" ] && exit 0`) e a regra R20 do lint impede que qualquer bloco novo entre sem ela. Mas esses arquivos são **instruções lidas por um modelo**, não um binário fechado: um agente que execute só a linha do `curl`, isolada da guarda, não é barrado por nada aqui. Se o que você quer é garantia dura, a que existe é não criar o arquivo de chave — sem ele, não há para onde enviar, e todo bloco para na guarda.
+Sendo exato sobre a força dessa garantia, porque ela não é um sandbox: cada bloco que chama o Iron Office começa com uma guarda (`[ -z "$IRON_KEY" ] && exit 0`) e a regra R20 do lint impede que qualquer bloco novo entre sem ela. Mas esses arquivos são **instruções lidas por um modelo**, não um binário fechado: um agente que execute só a linha do `curl`, isolada da guarda, não é barrado por nada aqui. Se o que você quer é garantia dura, a que existe é não criar o arquivo de chave — sem ele, não há para onde enviar, e todo bloco para na guarda (o plugin `iron-office` também: sem a chave, ele não envia nada).
 
 ---
 

package/bin/iron-edge.js

@@ -14,6 +14,9 @@
  *                                         arquivos cujo hash bate com o manifesto — os que
  *                                         ninguem alterou — e preserva o resto
  *
+ *   office  [--safe]                      liga o Iron Office: instala o plugin de canal e abre o
+ *                                         Claude Code conversando com o chat do dashboard
+ *
  * Nao existe 'uninstall' automatico: remover continua sendo operacao conduzida, com o
  * manifesto na mao (o README descreve o procedimento).
  */
@@ -147,7 +150,12 @@ if (cmd === 'install') {
   // Reprovam so' divergencia sem registro e arquivo sumido.
   process.exit(alterados.length + sumidos.length === 0 ? 0 : 1);
 
+} else if (cmd === 'office') {
+  // liga o chat do dashboard (iron-office.vercel.app/chat) na sessao do Claude Code
+  const r = spawnSync(process.execPath, [path.join(__dirname, '..', 'installer', 'office.js'), ...rest], { stdio: 'inherit' });
+  process.exit(r.status ?? 1);
+
 } else {
-  console.log('uso: iron-edge <install|update|verify> [--dry-run] [--source <dir>]');
-  process.exit(cmd ? 1 : 0);
+  console.log('uso: iron-edge <install|update|verify|office> [--dry-run] [--source <dir>] [--safe]');
+  process.exit(cmd && cmd !== '--help' && cmd !== '-h' ? 1 : 0);
 }

package/installer/office.js

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+/**
+ * office.js — `npx iron-edge office`: liga o Iron Office (chat do dashboard) no Claude Code.
+ *
+ * Passos: (1) confere a chave do Iron Office, (2) confere o Claude Code, (3) instala ou
+ * atualiza o plugin de canal `iron-office` pelo marketplace do GitHub, (4) abre o Claude Code
+ * com o canal ligado. O aluno deixa essa aba aberta: e' ela que faz o Iron responder no site.
+ *
+ * Flags: --safe tira o `--permission-mode bypassPermissions` (o Claude pede licenca a cada
+ * ferramenta). Qualquer outro argumento vai direto pro `claude`.
+ *
+ * Saida so' em ASCII, como o resto do instalador: console do Windows antigo mostra lixo em
+ * acento e simbolo. O `claude` recebe IRON_OFFICE_CHANNEL=1 no ambiente: e' o que diz ao
+ * servidor do plugin que ESTA sessao e' o canal (uma aba comum do Claude Code nao puxa o chat).
+ */
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { spawnSync } = require('child_process');
+
+const MARKETPLACE_REPO = 'filipecoff21-code/iron-office-channel';
+const PLUGIN = 'iron-office@iron-office-channel';
+const CHANNEL = 'plugin:' + PLUGIN;
+const ONBOARDING = 'https://iron-office.vercel.app/onboarding';
+const IS_WIN = process.platform === 'win32';
+
+function keyPath(home) {
+  return path.join(home || os.homedir(), '.claude', 'iron-office-api-key');
+}
+
+// O `echo` do passo 4 no Windows pode gravar UTF-16 com BOM: normaliza antes de decidir.
+function readKey(home) {
+  try {
+    const buf = fs.readFileSync(keyPath(home));
+    const utf16 = buf.length >= 2 && buf[0] === 0xff && buf[1] === 0xfe;
+    return buf.toString(utf16 ? 'utf16le' : 'utf8').replace(/[\uFEFF\u0000]/g, '').trim();
+  } catch (_) { return ''; }
+}
+
+// Argumentos do `claude` que abre a sessao com o canal. Separado pra ser testado sem rede.
+function buildClaudeArgs(argv) {
+  const safe = argv.includes('--safe');
+  const extra = argv.filter(a => a !== '--safe');
+  const args = ['--dangerously-load-development-channels', CHANNEL];
+  if (!safe) args.push('--permission-mode', 'bypassPermissions');
+  return args.concat(extra);
+}
+
+function run(bin, args, opts) {
+  return spawnSync(bin, args, { encoding: 'utf8', shell: IS_WIN, ...opts });
+}
+
+// No Windows o `claude` instalado pelo npm e' um `claude.cmd`; com shell ele costuma resolver,
+// mas ha PATH em que so' o nome com extensao funciona.
+function resolveClaude() {
+  const candidates = IS_WIN ? ['claude', 'claude.cmd'] : ['claude'];
+  for (const bin of candidates) {
+    const r = run(bin, ['--version']);
+    if (!r.error && r.status === 0) return bin;
+  }
+  return null;
+}
+
+function step(claude, label, args, okPatterns) {
+  const r = run(claude, args);
+  const out = ((r.stdout || '') + (r.stderr || '')).trim();
+  if (r.status === 0) { console.log('  [ok] ' + label); return true; }
+  if (okPatterns.some(p => p.test(out))) { console.log('  [ok] ' + label + ' (ja estava)'); return true; }
+  console.log('  [falhou] ' + label + ': ' + (out.split('\n').pop() || 'sem detalhe'));
+  return false;
+}
+
+function main(argv) {
+  if (!readKey()) {
+    console.error('Falta a chave do Iron Office. Faca o passo 4 em ' + ONBOARDING);
+    return 1;
+  }
+
+  const claude = resolveClaude();
+  if (!claude) {
+    console.error('Instale o Claude Code primeiro: https://claude.com/claude-code');
+    return 1;
+  }
+
+  console.log('Iron Office - preparando o canal');
+  const okMarket = step(claude, 'marketplace ' + MARKETPLACE_REPO, ['plugin', 'marketplace', 'add', MARKETPLACE_REPO], [/already/i]);
+  const okPlugin = okMarket && step(claude, 'plugin ' + PLUGIN, ['plugin', 'install', PLUGIN, '--scope', 'user'], [/already/i]);
+  if (!okMarket || !okPlugin) {
+    console.error('');
+    console.error('Nao deu pra instalar o plugin do Iron Office. Confira:');
+    console.error('  1. a internet esta funcionando;');
+    console.error('  2. o git esta instalado (rode: git --version);');
+    console.error('  3. rode de novo: npx iron-edge office');
+    console.error('Se continuar, mande um print desta tela pro suporte.');
+    return 1;
+  }
+  // atualizar e' melhor-esforco: sem internet no meio, segue com a versao ja instalada
+  step(claude, 'atualizacao do plugin', ['plugin', 'update', PLUGIN], [/already|up.to.date|latest/i]);
+
+  const safe = argv.includes('--safe');
+  console.log('');
+  console.log('Abrindo o Claude Code com o Iron Office ligado.');
+  console.log('Vai aparecer um aviso de canal (recurso em teste): aceite.');
+  if (!safe) {
+    console.log('O Iron vai agir SEM pedir licenca a cada passo (e o que deixa ele trabalhar');
+    console.log('enquanto voce esta no site). Quer aprovar cada passo? Rode: npx iron-edge office --safe');
+  }
+  console.log('Deixe esta aba aberta: e ela que faz o Iron responder no site.');
+  console.log('');
+
+  const r = spawnSync(claude, buildClaudeArgs(argv), {
+    stdio: 'inherit',
+    shell: IS_WIN,
+    env: { ...process.env, IRON_OFFICE_CHANNEL: '1' },
+  });
+  return r.status ?? 1;
+}
+
+module.exports = { buildClaudeArgs, keyPath, readKey, CHANNEL, PLUGIN, MARKETPLACE_REPO };
+
+if (require.main === module) {
+  process.exit(main(process.argv.slice(2)));
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "iron-edge",
-  "version": "2.3.1",
-  "description": "Ecossistema de agentes para Claude Code: 44 agentes de topo, 18 squads e 14 skills, com quality gate, memoria e instalador que nunca sobrescreve.",
+  "version": "2.4.0",
+  "description": "Ecossistema de agentes para Claude Code: 44 agentes de topo, 18 squads e 14 skills, com quality gate, memoria, instalador que nunca sobrescreve e o comando office (chat do Iron Office no dashboard).",
   "keywords": [
     "claude",
     "claude-code",
@@ -25,13 +25,14 @@
     "iron-routing-map.md",
     "docs/",
     "!docs/interno",
-    "!docs/historico"
+    "!docs/historico",
+    "!**/_auditoria"
   ],
   "engines": {
     "node": ">=18.0.0"
   },
   "scripts": {
-    "test": "node scripts/lint.js && node scripts/test-verify.js && node scripts/test-update.js",
+    "test": "node scripts/lint.js && node scripts/test-verify.js && node scripts/test-update.js && node scripts/test-office.js",
     "test:matriz": "node scripts/test-matriz-update.js"
   },
   "devDependencies": {

package/skills/escada/SKILL.md

@@ -27,8 +27,14 @@ Nunca assuma quais modelos a conta do usuário tem — contas diferem. Conduza,
 **DIA A DIA** (feature, ajuste, bug): planejar no plan mode → executar no EXECUTOR → revisar no JULGADOR se a coisa for séria. Se `opusplan` apareceu na lista, `/model opusplan` automatiza exatamente isso — é o único caso em que `/model` é bem-vindo, porque aí mudar o padrão É a intenção.
 
 **DEMANDA ESTRUTURAL** (desenhar um sistema, arquitetura, decisão cara de errar) — o fluxo das TRÊS ABAS do terminal:
-- aba 1: JULGADOR planeja e **salva o plano num ARQUIVO**;
-- aba 2: EXECUTOR executa lendo o arquivo. Sobe um degrau em DOIS casos apenas: implementação pesada em si, ou o EXECUTOR travou 2 vezes no mesmo ponto. Regra de bolso: **sonnet até travar, degrau acima pra destravar** — e subir é FECHAR a aba e abrir outra com `claude --model "opus"`, nunca `/model` na aba aberta;
+- aba 1: JULGADOR planeja e **salva o plano num ARQUIVO**, com a **data no cabeçalho** (formato AAAA-MM-DD, que é o que o git lê sem ambiguidade). O plano só merece confiança se tiver três seções: **(a) arquivos exatos** (caminho + o que muda em cada um), **(b) checklist de gates** com `[ ]`, **(c) validação de ponta a ponta** no app/tela real, com o estado esperado. Sem isso o executor vai ter que explorar tudo de novo, e a economia some;
+- aba 2: EXECUTOR executa lendo o arquivo, sob o **bilhete do executor** (vai junto com o pedido "executa o plano: <caminho>"):
+  - **Confie no plano. Só escreva o código.** O JULGADOR já mapeou o projeto; não gastar esta aba relendo arquitetura nem redescobrindo o plano. Ler só os arquivos que o plano lista. Antes de começar, uma checagem só: o código mudou desde a data do cabeçalho do plano? Em projeto com git, `git status` (mudança não commitada) + `git log --since=<data do cabeçalho>` (commits). Sem git, ou se o comando falhar: pular a checagem e escrever isso no relatório. Pular a checagem NÃO libera explorar: a lista de arquivos do plano continua valendo. Só o arquivo que a checagem mostrou alterado pode ser aberto fora da lista, e vai registrado no relatório.
+  - **O plano inteiro, de uma vez.** Sem entregar um pedaço e perguntar "continuo?": cada ida e volta reenvia a conversa inteira, e é isso que gasta.
+  - **PRONTO só quando funcionou de verdade.** Teste de código verde não é PRONTO. PRONTO é o checklist do plano todo marcado `[x]`, incluindo a validação de ponta a ponta na tela real. Gate que só o humano fecha (cartão, celular, login) vai pro fim do relatório como passo dele.
+  - **O que não está no plano não vira código**: vira pendência escrita. Trecho impossível ou desatualizado: executar todo o resto e registrar o que travou, com o motivo. Nunca inventar caminho alternativo em silêncio.
+  - Por que isso economiza: o executor desperdiça em três lugares (reler o projeto que já foi lido, fatiar a entrega, e declarar pronto cedo demais, o que abre uma sessão de correção que relê tudo de novo). O bilhete fecha os três.
+  - Sobe um degrau em DOIS casos apenas: implementação pesada em si, ou o EXECUTOR travou 2 vezes no mesmo ponto. Regra de bolso: **sonnet até travar, degrau acima pra destravar** — e subir é FECHAR a aba e abrir outra com `claude --model "opus"`, nunca `/model` na aba aberta;
 - aba 3: JULGADOR dá o veredito comparando entrega × plano.
 - O canal entre as abas é sempre um arquivo, nunca copiar e colar conversa.
 
@@ -53,10 +59,11 @@ Os agentes do Iron Edge já vêm com `model:` por cargo (opus = estrategista, so
 Depois da medição, grave no `~/.claude/CLAUDE.md` do usuário (backup antes se existir; se a seção `## ESCADA DE MODELOS` já existir, ATUALIZE inteira no lugar, nunca duplique) a seção com:
 - a regra de ouro;
 - os três degraus MEDIDOS desta conta;
-- o fluxo das 3 abas, com a instrução de salvar o plano em arquivo;
+- o fluxo das 3 abas, com a instrução de salvar o plano em arquivo (e as três seções que o plano precisa ter);
+- o bilhete do executor, pra acordar sozinho quando o usuário disser "executa o plano";
 - a vacina do /model;
 - e a ordem de SUGERIR SOZINHO: quando o usuário pedir pra desenhar sistema/arquitetura/decisão grande, avisar em 1 linha que é demanda estrutural e dar o comando da aba do JULGADOR pronto pra copiar; quando um planejamento desses terminar, salvar o plano em arquivo sem pedir e dizer o caminho; quando a execução terminar, lembrar do veredito.
 
 Mostre a seção pronta ANTES de salvar. Lembre o usuário: CLAUDE.md novo só vale em sessão nova (fechar e abrir).
 
-**Teste de que pegou** (sessão nova): o usuário pede algo estrutural sem citar modelo nenhum. Critério duplo: (a) o Iron reconheceu sozinho e sugeriu a escada; (b) a sugestão veio com o comando pronto pra copiar. Se respondeu direto sem sugerir, a seção não carregou — conferir arquivo e sessão nova antes de qualquer outra coisa.
+**Teste de que pegou** (sessão nova): o usuário pede algo estrutural sem citar modelo nenhum. Critério triplo: (a) o Iron reconheceu sozinho e sugeriu a escada; (b) a sugestão veio com o comando pronto pra copiar; (c) numa aba de execução, ao dizer "executa o plano: <caminho>", o Iron abriu só os arquivos da lista do plano, entregou de uma vez e fechou com o checklist marcado (ou com o que ficou aberto, nomeado). Se respondeu direto sem sugerir, a seção não carregou — conferir arquivo e sessão nova antes de qualquer outra coisa.

package/squads/squad-engineering/knowledge-base/escada-e-cargos.md

@@ -59,3 +59,8 @@ O método da casa manda avisar, em uma linha, quando a demanda é **estrutural**
 
 ## O canal entre sessões é o arquivo
 Quando o trabalho atravessa sessões — uma planeja, outra executa, outra dá o veredito — o canal é `docs/eng/`, nunca copiar e colar conversa. É por isso que o doc-first e a escada são a mesma coisa vista de dois ângulos: a pasta que este squad escreve é exatamente o canal que a escada exige.
+
+## O plano que o executor recebe, e o bilhete que vai junto
+A skill `escada` é a fonte desta regra; aqui é o resumo pro squad não divergir dela. Um plano que vai ser executado em OUTRA aba precisa de: **data no cabeçalho** (formato AAAA-MM-DD), **(a) arquivos exatos** (caminho + o que muda em cada um), **(b) checklist de gates** com `[ ]`, **(c) validação de ponta a ponta** na tela real, com o estado esperado. O documento de arquitetura deste squad tem o formato dele; quando ele vira o plano de uma execução em aba separada, fecha com essas três seções.
+
+Na aba de execução vale o **bilhete do executor**: confie no plano e só escreva o código (o planejador já mapeou o projeto); leia só os arquivos da lista, com uma checagem única no início de "o código mudou desde a data do plano?" (`git status` + `git log --since=<data>`; sem git, pular e registrar); entregue o plano inteiro de uma vez, sem "continuo?"; PRONTO só com o checklist marcado `[x]`, incluindo a validação na tela real; o que não está no plano vira pendência escrita, e trecho travado vira registro com motivo, nunca caminho alternativo em silêncio.

package/squads/squad-engineering/tasks/write-architecture.md

@@ -22,6 +22,9 @@ teto: duas páginas, ADRs à parte
 
 6. **Apresente e espere a aprovação** antes de qualquer story ser escrita em cima.
 
+## Se este documento vai ser executado em OUTRA aba (escada de três abas)
+Feche-o com a data no cabeçalho (formato AAAA-MM-DD) e as três seções que o executor exige: arquivos exatos, checklist de gates `[ ]`, validação de ponta a ponta na tela real. A regra inteira está em `knowledge-base/escada-e-cargos.md`, seção "O plano que o executor recebe".
+
 ## Meça antes de entregar (não estime)
 
 Antes de apresentar o documento, **conte**. Instrução que depende de o autor achar que "ficou mais ou menos do tamanho" é instrução que falha: num teste real, um documento foi entregue como "perto do limite, mas dentro" e estava **acima** do teto quando medido.