iron-edge 2.2.0 → 2.3.1

package/installer/update.js

@@ -31,7 +31,12 @@ const DRY = args.includes('--dry-run');
 const srcIdx = args.indexOf('--source');
 const SOURCE = srcIdx >= 0 && args[srcIdx + 1] ? path.resolve(args[srcIdx + 1]) : path.join(__dirname, '..');
 
-const log = (m) => console.log(m);
+// Escrita SINCRONA de proposito. Com `console.log` em Windows, quando a saida vai pra um cano
+// (CI, `| tee`, terminal do Claude Code), o Node enfileira e o `process.exit()` do fim descarta o
+// que ainda nao saiu: na CI de 22/09/2026 o log chegou comecando pelo MEIO, sem o cabecalho e sem
+// o "Instalacao encontrada". Um aluno que cola o log pra pedir ajuda mandaria metade dele — e eu
+// perdi duas rodadas de CI deduzindo em cima de um log truncado.
+const log = (m) => { try { fs.writeSync(1, m + '\n'); } catch (_) { console.log(m); } };
 function abort(msg) {
   console.error('\n[ABORTADO] ' + msg);
   process.exit(1);
@@ -50,7 +55,12 @@ function norm(p) {
   let alvo = path.resolve(p);
   let resto = '';
   for (;;) {
-    try { return path.join(fs.realpathSync(alvo), resto); }
+    // `realpathSync.native` (e nao o `realpathSync` puro) porque em Windows so' a versao nativa
+    // expande o nome curto 8.3: a mesma pasta aparece como C:\\Users\\RUNNER~1\\... e como
+    // C:\\Users\\runneradmin\\..., e comparar as duas como texto faz o update concluir que os 2129
+    // arquivos "nao existiam" — e sobrescrever o que a pessoa editou. Medido na CI de 22/09/2026:
+    // o manifesto guardava a forma longa e o calculo do momento devolvia a curta.
+    try { return path.join(fs.realpathSync.native(alvo), resto); }
     catch (e) {
       const pai = path.dirname(alvo);
       if (pai === alvo) return path.resolve(p);
@@ -111,6 +121,17 @@ for (const f of man.files || []) {
   if (dest) antigos.set(norm(dest), f);
 }
 log(`Instalacao encontrada: ${antigos.size} arquivos no manifesto`);
+
+// Chave de diagnostico, ligada por variavel de ambiente. Existe porque em 22/09/2026 o update
+// concluiu, numa maquina Windows, que 2129 arquivos "nao existiam" — com o manifesto certo, o
+// hash certo e o caminho gravado igualzinho ao real. O que diverge e' a forma do caminho DEPOIS
+// do `norm()`, e isso nao da pra ver de fora. Fica no produto de proposito: e' o que permite
+// diagnosticar a maquina de um aluno sem chutar.
+let dbgMostrado = false;
+if (process.env.IRON_EDGE_DEBUG) {
+  const amostra = (m) => [...m.keys()].slice(0, 2).join('\n      ');
+  log('  [debug] chaves do manifesto (antigos):\n      ' + amostra(antigos));
+}
 if (man.label) log(`  edicao: ${man.label}`);
 if (man.installed_at) log(`  instalada em: ${man.installed_at}`);
 
@@ -136,6 +157,7 @@ for (const dir of ['agents', 'skills', 'squads', 'docs']) {
 const plano = { trocar: [], adicionar: [], restaurar: [], preservar: [], remover: [], manter: [], gerar: [] };
 
 for (const [dest, origem] of novos) {
+  if (process.env.IRON_EDGE_DEBUG && !dbgMostrado) { dbgMostrado = true; log('  [debug] chave calculada agora (novos):\n      ' + dest); }
   const ent = antigos.get(dest);
   if (!ent) { plano.adicionar.push({ dest, origem }); continue; }
   if (ent.generated) { plano.manter.push({ dest, motivo: 'gerado na instalacao (config, manifesto)' }); continue; }
@@ -185,6 +207,59 @@ for (const g of GERADOS) {
   }
 }
 
+// ---------------------------------------------------------------- config: so' relatorio
+// O config NUNCA e' sobrescrito pelo update — e' da pessoa. Mas o que este bloco IMPRIME
+// precisa sair sempre, e por isso ele e' funcao chamada antes do early-exit e nao codigo
+// solto na FASE 3: la' embaixo ele so' rodava quando havia algo pra atualizar. Quem ja' esta'
+// na versao do pacote — que e' justamente quem roda `update` so' pra conferir o cofre —
+// batia no `process.exit(0)` 125 linhas antes e nunca via aviso nenhum. Um alerta contra
+// falha silenciosa que falhava em silencio. Vale para os DOIS avisos daqui: o de campo
+// faltando ja' nascia inalcancavel assim, e ninguem tinha percebido.
+function relatarConfig() {
+  const cfg = path.join(IRON_DIR, 'config.yaml');
+  if (!fs.existsSync(cfg)) return;
+  // .replace de CRLF: o config.yaml e' editado pela PESSOA, e o Bloco de Notas do Windows grava
+  // com \r\n. Sem isto, o valor lido da linha vem com um \r invisivel grudado no fim — e o aviso
+  // de barra invertida passaria a julgar um caminho que ninguem digitou. Mesma classe do defeito
+  // que reprovou a CI de Windows em 22/09/2026.
+  const seu = fs.readFileSync(cfg, 'utf8').replace(/\r\n/g, '\n');
+  const campos = ['owner', 'businesses', 'vault_path'];
+  const faltando = campos.filter((c) => !new RegExp(`^\\s*${c}\\s*:`, 'm').test(seu));
+  log('  config.yaml: preservado como estava (nao foi tocado).');
+  if (faltando.length) {
+    log('');
+    log('  ATENCAO: a versao nova usa campos que o seu config nao tem:');
+    for (const f of faltando) log(`    - ${f}`);
+    log('  Acrescente a mao, ou peca ao Iron: "atualiza meu config".');
+    if (faltando.includes('vault_path') && /obsidian_vault_path/.test(seu))
+      log('  (Voce tem "obsidian_vault_path": e o mesmo cofre. O Iron entende os dois nomes.)');
+  }
+
+  // Barra invertida SOLTA dentro de aspas duplas. O par `\\` e' escape valido e correto — e'
+  // o formato que instalacoes antigas gravavam —, entao ele e' consumido ANTES da checagem:
+  // avisar nele mandaria a pessoa "consertar" um arquivo que esta' certo. O que sobra e'
+  // barra solta, e ela tem dois destinos, os dois ruins: `\U` de C:\Users\<voce> nao e escape
+  // valido e derruba o arquivo INTEIRO (o owner morre junto), enquanto `\b` de C:\backup e'
+  // escape valido, parseia sem erro nenhum e entrega um caminho CORROMPIDO em silencio.
+  // Isola o valor ENTRE ASPAS. Usar a linha inteira fazia comentario a direita entrar na conta:
+  // `vault_path: "C:/Users/<voce>/Cofre" # nota com contra\barra` disparava o aviso com o
+  // caminho intacto. Aspas duplas nao podem existir dentro de nome de arquivo no Windows, entao
+  // [^"]* fecha no lugar certo.
+  const linha = (seu.match(/^\s*(?:obsidian_)?vault_path\s*:\s*(.+)$/m) || [])[1];
+  const aspas = linha ? linha.trim().match(/^"([^"]*)"/) : null;
+  const valor = aspas ? aspas[1] : '';
+  if (valor && valor.split('\\\\').join('').includes('\\')) {
+    log('');
+    log('  ATENCAO: seu vault_path tem barra invertida dentro de aspas duplas:');
+    log('    ' + aspas[0]);
+    log('  Em YAML isso ou invalida o arquivo INTEIRO (e o owner morre junto), ou entrega um');
+    log('  caminho corrompido sem dar erro nenhum. Nos dois casos o sintoma e o mesmo: o Iron');
+    log('  passa a responder generico e a oferecer criar um cofre que voce ja tem.');
+    log('  Troque as barras invertidas por barras normais (C:/Users/<voce>/...) e salve.');
+    log('  Ou peca ao Iron: "conserta meu vault_path".');
+  }
+}
+
 // ---------------------------------------------------------------- mostrar
 log('');
 log('--- PLANO ---');
@@ -213,8 +288,102 @@ log('');
 log('  Seu config.yaml, seus agentes e skills proprios, e seu cofre NAO entram neste plano.');
 log('  Config e manifesto sao regravados no fim; o resto nem e olhado.');
 
+log('');
+relatarConfig();
+
+
 if (DRY) { log(''); log('--dry-run: nada foi escrito.'); process.exit(0); }
-if (!plano.trocar.length && !plano.adicionar.length && !plano.restaurar.length && !plano.remover.length && !plano.gerar.length) {
+
+// Permissao da pasta de segredos, TAMBEM no update. O chmod entrou no install no ciclo 2 e o
+// gate mediu a lacuna: quem ja tinha o Iron instalado seguia com `secrets/` em 755, porque o
+// caminho de manutencao e' o update, nao reinstalar. Roda DUAS vezes de proposito: aqui, antes
+// do early-exit (senao nao alcanca quem nao tem nada a atualizar) e de novo no fim, porque a
+// FASE 2 pode RECRIAR a pasta com o umask padrao — medido no gate, rodada 4.
+// Idempotente e falha aberto fora de POSIX.
+function fecharPermissoes() {
+  for (const [alvo, modo] of [[path.join(IRON_DIR, 'secrets'), 0o700], [path.join(IRON_DIR, 'integrations', 'shopify.yaml'), 0o600]]) {
+    try {
+      if (!fs.existsSync(alvo)) continue;
+      const atual = fs.statSync(alvo).mode & 0o777;
+      if (atual === modo) continue;
+      fs.chmodSync(alvo, modo);
+      log(`  permissao de ${path.basename(alvo)} fechada (${atual.toString(8)} -> ${modo.toString(8)})`);
+    } catch (_) { /* Windows e sistemas sem POSIX: a ACL do perfil ja cobre */ }
+  }
+}
+fecharPermissoes();
+
+// metadata.json ilegivel tambem se conserta ANTES do early-exit: o aluno que ja esta na versao do
+// pacote e roda update justamente pra consertar caia em "Nada a fazer" e ficava travado, com o
+// verify reprovando para sempre. Mesmo padrao do chmod, mesmo erro, medido na rodada 4.
+// `somenteSeQuebrado` existe porque a chamada de antes do early-exit nao pode reescrever um
+// metadata SADIO: mudar o arquivo sem regravar o manifesto (que so acontece na FASE 3) deixaria
+// disco e registro divergentes, e o verify reprovaria — o mesmo defeito da rodada 2, por outra porta.
+// Devolve true quando ESCREVEU, e quem chamou usa isso pra nao sair pelo early-exit.
+function repararMetadata(versao, somenteSeQuebrado) {
+  const META = path.join(IRON_DIR, 'metadata.json');
+  // Arquivo AUSENTE nao e' arquivo quebrado: instalacao antiga simplesmente nao tinha metadata, e
+  // inventar um na chamada de ANTES do early-exit transformaria um update no-op em escrita (isso
+  // quebrou 8 casos do proprio test-update). Mas na FASE 3, com versao pra gravar, ausente TEM que
+  // ser recriado — a rodada 5 mediu que a guarda simples apagava a entrada do manifesto em silencio.
+  if (!fs.existsSync(META)) {
+    // Sumido MAS registrado no manifesto = o produto sabe que ele deveria existir; entao recriar
+    // e' conserto, nao invencao, e vale tambem antes do early-exit: sem isso o verify reprovava
+    // com "ausentes: 1" e o update respondia "nada a fazer" — remedio que o proprio produto
+    // receita e nao cura, o mesmo padrao do shopify.yaml na rodada 1.
+    const registrado = [...antigos.keys()].some((d) => d.endsWith('metadata.json'));
+    if (somenteSeQuebrado && !registrado) return false;
+    if (!versao) {
+      const doMan = (man.version || '').replace(/^iron-edge-/, '');
+      if (!doMan) return false;
+      versao = doMan;   // recria com a versao que o manifesto registra
+    }
+    try {
+      fs.writeFileSync(META, JSON.stringify({ version: 'iron-edge-' + versao, label: 'Iron Edge v' + versao, updated_at: new Date().toISOString(), recriado_por_estar_ausente: true }, null, 2));
+      log('  metadata.json estava ausente: recriado');
+      return true;
+    } catch (e) { log(`  aviso: nao consegui criar metadata.json (${e.message})`); return false; }
+  }
+  let meta = null, precisaReescrever = false, ilegivel = false;
+  try { meta = JSON.parse(fs.readFileSync(META, 'utf8')); }
+  catch (_) { precisaReescrever = true; ilegivel = true; }
+  // JSON valido que NAO e' objeto plano (array, numero, texto, null) engole a atribuicao sem
+  // erro e o arquivo fica com lixo enquanto o log diz "atualizado" — medido na rodada 4.
+  if (!precisaReescrever && (meta === null || typeof meta !== 'object' || Array.isArray(meta))) { precisaReescrever = true; ilegivel = true; }
+  // Conteudo que NAO bate com o hash registrado tambem e' reparo: o metadata.json e' derivado,
+  // ninguem deveria edita-lo, e quando alguem edita o verify reprova para sempre sem caminho de
+  // volta (medido na matriz de estados: "metadata com campo extra do aluno").
+  if (!precisaReescrever) {
+    const ent = [...antigos.values()].find((e) => String(e.dest).endsWith('metadata.json'));
+    if (ent && ent.sha256 && ent.sha256 !== sha256(META)) precisaReescrever = true;
+  }
+
+  if (!precisaReescrever && (somenteSeQuebrado || !versao)) return false;
+  // Reparo por DIVERGENCIA (o arquivo esta legivel, so' nao bate com o registro) preserva o que
+  // estiver la: quem escreveu algo dentro nao pode perder isso porque o hash saiu de sincronia.
+  // Reescrita do zero fica so' para o arquivo ilegivel, onde nao ha o que preservar.
+  const base = ilegivel ? { recuperado_de_arquivo_ilegivel: true } : (meta || {});
+  if (versao) { base.version = 'iron-edge-' + versao; base.label = 'Iron Edge v' + versao; }
+  base.updated_at = new Date().toISOString();
+  try {
+    fs.writeFileSync(META, JSON.stringify(base, null, 2));
+    log(ilegivel ? '  metadata.json estava ilegivel: reescrito do zero'
+      : precisaReescrever ? `  metadata.json estava fora de sincronia: reconciliado (${base.version})`
+      : `  metadata.json atualizado para ${base.version}`);
+    return true;
+  } catch (e) { log(`  aviso: nao consegui gravar metadata.json (${e.message})`); return false; }
+}
+// so conserta o que esta quebrado; se consertou, o update NAO pode sair pelo early-exit, porque
+// o manifesto precisa da FASE 3 pra registrar o hash novo.
+const metadataReparado = repararMetadata(process.env.IRON_EDGE_VERSION || '', true);
+
+// "Nada a fazer" so' vale se a VERSAO tambem ja for a deste pacote. Release que nao mexe em
+// nenhum arquivo rastreado (so' installer/, scripts/, README) caia aqui e a versao registrada
+// ficava velha para sempre — e a mensagem dizia justamente que ja estava na versao do pacote.
+const versaoRegistrada = man.version || '';
+const versaoDoPacote = process.env.IRON_EDGE_VERSION ? 'iron-edge-' + process.env.IRON_EDGE_VERSION : '';
+const versaoDesatualizada = Boolean(versaoDoPacote) && versaoRegistrada !== versaoDoPacote;
+if (!plano.trocar.length && !plano.adicionar.length && !plano.restaurar.length && !plano.remover.length && !plano.gerar.length && !plano.preservar.length && !versaoDesatualizada && !metadataReparado) {
   log(''); log('Nada a fazer: sua instalacao ja esta na versao deste pacote.');
   process.exit(0);
 }
@@ -274,6 +443,26 @@ let geradosOk = 0;
 for (const g of plano.gerar) {
   try {
     fs.mkdirSync(path.dirname(g.dest), { recursive: true });
+    // Achado tardio da rodada 4: `~/.claude/commands/` e' pasta generica do Claude Code, e um
+    // arquivo com o mesmo nome que NAO esteja no manifesto era sobrescrito sem aviso e sem
+    // backup — perda de dado silenciosa do que era do usuario. Agora vira .iron-old antes.
+    if (fs.existsSync(g.dest)) {
+      const registrado = antigos.has(norm(g.dest));
+      if (!registrado) {
+        // .iron-old ja existente pode ser backup ANTERIOR do usuario, ou sobra de execucao
+        // interrompida: sobrescrever aqui seria repetir, dentro do mecanismo de backup, a perda
+        // de dado que ele foi criado pra evitar (medido na rodada 5). Entao abre um nome novo.
+        let backup = g.dest + '.iron-old';
+        if (fs.existsSync(backup)) {
+          const carimbo = new Date().toISOString().replace(/[:.]/g, '-');
+          backup = `${g.dest}.iron-old-${carimbo}`;
+        }
+        try {
+          fs.copyFileSync(g.dest, backup);
+          log(`  ${path.basename(g.dest)} existia e nao era do pacote: copia guardada em ${path.basename(backup)}`);
+        } catch (e2) { log(`  aviso: nao consegui guardar copia de ${g.dest} (${e2.message}) — nao sobrescrevi`); continue; }
+      }
+    }
     fs.writeFileSync(g.dest, g.conteudo);
     geradosOk++;
   } catch (e) { log(`  aviso: nao consegui gravar ${g.dest} (${e.code || e.message})`); }
@@ -284,6 +473,14 @@ if (geradosOk) log(`  ${geradosOk} arquivo(s) gerado(s) desta versao criados (ex
 log('');
 log('--- FASE 3: manifesto e config ---');
 
+
+// A VERSAO PRIMEIRO, o manifesto DEPOIS. Na rodada 2 do gate o metadata.json era reescrito no
+// fim, depois de o manifesto ja ter guardado o hash do conteudo ANTIGO: disco e registro
+// discordavam e o verify passava a reprovar uma instalacao sadia para sempre.
+const versaoNova = process.env.IRON_EDGE_VERSION || '';
+repararMetadata(versaoNova);
+fecharPermissoes();   // a FASE 2 pode ter recriado secrets/ com o umask padrao
+
 const arquivos = [];
 const editados = new Set(plano.preservar.map((x) => norm(x.dest)));
 for (const [dest, origem] of novos) {
@@ -310,6 +507,7 @@ for (const g of GERADOS) {
 
 const novoMan = {
   ...man,
+  ...(versaoNova ? { version: 'iron-edge-' + versaoNova, label: 'Iron Edge v' + versaoNova } : {}),
   updated_at: new Date().toISOString(),
   previous_installed_at: man.installed_at,
   files: arquivos,
@@ -317,23 +515,6 @@ const novoMan = {
 fs.writeFileSync(MANIFEST, JSON.stringify(novoMan, null, 2));
 log(`  manifesto regravado: ${arquivos.length} arquivos`);
 
-// config: NUNCA sobrescrito. Mas se a versao nova tem campo que o seu nao tem, avisa.
-const cfg = path.join(IRON_DIR, 'config.yaml');
-if (fs.existsSync(cfg)) {
-  const seu = fs.readFileSync(cfg, 'utf8');
-  const campos = ['owner', 'businesses', 'vault_path'];
-  const faltando = campos.filter((c) => !new RegExp(`^\\s*${c}\\s*:`, 'm').test(seu));
-  log('  config.yaml: preservado como estava (nao foi tocado).');
-  if (faltando.length) {
-    log('');
-    log('  ATENCAO: a versao nova usa campos que o seu config nao tem:');
-    for (const f of faltando) log(`    - ${f}`);
-    log('  Acrescente a mao, ou peca ao Iron: "atualiza meu config".');
-    if (faltando.includes('vault_path') && /obsidian_vault_path/.test(seu))
-      log('  (Voce tem "obsidian_vault_path": e o mesmo cofre. O Iron entende os dois nomes.)');
-  }
-}
-
 log('');
 log('================================');
 log('  Atualizado com sucesso');

package/iron-routing-map.md

@@ -63,10 +63,14 @@ o iron-ceo oferece: iron-X (rapido) ou xq-X (profundo)? [r/p]
 | iron-forge | Construtor de agentes | criar agente, criar skill, novo agente, construir ferramenta |
 | iron-install | Instalacao | instalar, setup do ecossistema, configurar ambiente |
 | iron-claude | Claude Code em si | hook, MCP, skill, subagente, settings.json, contexto, memoria, "o Claude esta estranho", auditoria da instalacao |
-| iron-clone | Clonar SITE + design system | clonar site, copiar pagina, espelhar site, "aquele site com a minha marca", DNA visual de referencia, extrair paleta/tipografia, transplante de marca, organizar HTML monolitico (NAO confundir com iron-cloning, que clona o MODO DE PENSAR de uma pessoa real). ATENCAO: a skill clone-site nao roda nativamente em Windows — avisar antes |
+| iron-clone | Clonar SITE + design system | clonar site, copiar pagina, espelhar site, DNA visual de referencia, extrair paleta, transplante de marca, organizar HTML |
 | iron-eng | Engenharia de software | app, plataforma, sistema, API, backend, banco, login, painel, dashboard, CRM, integracao, automacao de negocio, script, job, bug, erro, quebrou, deploy, migration |
 | lp-cinematico | Landing pages scroll | landing page, LP cinematografica, scroll-scrub, pagina de captura |
 
+> **iron-clone x iron-cloning:** o `iron-clone` copia SITE e identidade visual; o `iron-cloning` copia o MODO DE PENSAR
+> de uma pessoa real (e exige consentimento e base legal). A skill `clone-site` nao roda nativamente em Windows, e o
+> proprio `iron-clone` avisa isso antes de comecar.
+
 ## 3. Routing Table — Camada de Aprofundamento (XQ — 13)
 
 | Agente | Sobe da camada | Quando usar |
@@ -77,7 +81,7 @@ o iron-ceo oferece: iron-X (rapido) ou xq-X (profundo)? [r/p]
 | xq-codecore | squad-claude | maestria em Claude Code |
 | xq-copy | iron-copy | copy com mestres (Halbert, Schwartz, Ogilvy) |
 | xq-copymaster | iron-copy | copy expandida — 33 copywriters |
-| xq-cyber | iron-cyber | seguranca com 15 especialistas |
+| xq-cyber | iron-cyber | seguranca em profundidade (7 especialistas instalados) |
 | xq-data | iron-growth | analytics e metricas em profundidade |
 | xq-design | iron-design | UX/UI com experts |
 | xq-hormozi | iron-commercial | ofertas estilo Grand Slam Offers |
@@ -274,3 +278,16 @@ pacote e nao entram na Routing Table.
 Regra: o iron-ceo NAO aciona agente que nao esteja na Routing Table num
 fluxo normal — so quando voce pedir pelo nome. Isso evita que um agente de
 projeto especifico seja escolhido para uma demanda generica.
+
+## 8. Especialistas com nome de pessoa real
+
+Arquivos de especialista marcados com `real_person: true` levam o nome de uma pessoa que existe. A regra, sem exceção, para qualquer agente que assuma um deles:
+
+1. O agente aplica o MÉTODO público da pessoa (frameworks, princípios, obras publicadas). Ele não é a pessoa e não diz que é. Forma correta: "no método de Gary Halbert". Forma errada: "eu sou Gary Halbert".
+2. Nunca atribuir à pessoa frase, opinião, endosso ou fato que não esteja em obra publicada dela. O que for dedução do modelo se declara como dedução: "pelo método dele, eu diria que...".
+3. O entregável nunca sai assinado com o nome da pessoa, nem sugere que ela revisou, aprovou ou participou.
+4. Se o pedido for conteúdo que finja ser da pessoa (post "escrito por", depoimento, citação inventada), o agente recusa essa parte e entrega a versão "no método de".
+
+5. **Pessoa falecida** (o arquivo registra a morte, seja num campo `died:` seja dentro do `born:`, como "1926 (died 2022)") exige o cuidado maior, não o menor: ela não pode desmentir nada, e o espólio costuma manter direito de imagem. Nesses casos, cite a obra publicada de forma literal e atribuída, e nunca produza frase nova no nome dela.
+
+Esta seção é a fonte única desta regra. Quem dá entrada nesses especialistas aponta pra cá; não existe cópia da regra nos arquivos de especialista.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iron-edge",
-  "version": "2.2.0",
+  "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.",
   "keywords": [
     "claude",
@@ -31,7 +31,8 @@
     "node": ">=18.0.0"
   },
   "scripts": {
-    "test": "node scripts/lint.js"
+    "test": "node scripts/lint.js && node scripts/test-verify.js && node scripts/test-update.js",
+    "test:matriz": "node scripts/test-matriz-update.js"
   },
   "devDependencies": {
     "js-yaml": "^5.3.0"

package/skills/blindar-sistema/SKILL.md

@@ -0,0 +1,123 @@
+---
+name: blindar-sistema
+description: >
+  Auditoria de segurança guiada para quem programa com IA (vibe coding) e não
+  domina segurança. O Iron LÊ o código do próprio sistema do usuário (white-box):
+  acha as portas abertas mais comuns sem proxy, sem certificado, sem instalar nada,
+  sem mandar dado para fora, e roda em Mac e Windows. Traduz cada achado em
+  linguagem simples com prioridade e conduz o conserto. Use quando o usuário disser
+  "blindar meu sistema", "auditar a segurança do meu app/site", "revisar segurança",
+  "meu sistema está seguro?", ou pedir revisão de um sistema feito com IA.
+---
+
+# blindar-sistema
+
+Você é um copiloto de segurança para quem programa com IA e não entende de
+segurança. Fale simples, sem jargão. Explique cada termo técnico na hora, em uma
+linha. Nunca assuste sem dar o conserto. Uma coisa de cada vez.
+
+Você audita LENDO o código do sistema do próprio usuário. Você não ataca nada, não
+liga proxy, não instala ferramenta, não manda dado para fora. Todo achado sai da
+leitura do repositório.
+
+## Regra dura
+
+Só audite um sistema que é do próprio usuário. Você só LÊ o código, isso é seguro
+em qualquer ambiente. Se em algum momento o usuário quiser o teste ao vivo (a etapa
+avançada, com a ferramenta externa Frieren), aí vale a trava: só contra sistema
+dele, só em ambiente de teste com dado sintético, nunca produção, nunca dado de
+gente real, nunca site de terceiro. Veja `advanced/frieren-opcional.md`.
+
+## A base de conhecimento
+
+Cada família de falha tem um arquivo em `kb/` que diz onde procurar no código, o
+padrão vulnerável vs. o seguro, como confirmar e o conserto. LEIA o arquivo da
+família antes de auditar aquela família, não audite de memória.
+
+- `kb/idor.md`: um cliente vê o dado de outro
+- `kb/secrets.md`: chave/segredo exposto (front, histórico do Git, resposta da API)
+- `kb/sqli.md`: injeção de SQL
+- `kb/llm-injection.md`: injeção de prompt no endpoint de IA
+
+Procedimentos de conserto que o usuário faz junto:
+- `procedures/secret-hygiene.md`: revogar, rotacionar e limpar segredo do Git
+- `procedures/llm-endpoint-hardening.md`: blindar o próprio LLM do sistema
+- `procedures/sandbox-dado-falso.md`: montar um ambiente de teste com dado
+  sintético ANTES de qualquer prova viva ou da etapa avançada (Frieren)
+
+## Fluxo
+
+### Fase 0: Medir o sistema (antes de qualquer coisa)
+
+NÃO assuma arquivo, rota ou botão que não viu. Meça primeiro. Pergunte uma de cada
+vez o que não der para descobrir lendo:
+
+1. Onde fica o código do sistema (a pasta do repositório)?
+2. Que stack é (linguagem/framework)? Descubra lendo: `package.json`, arquivos de
+   config, estrutura de pastas. Só pergunte se não der para ler.
+3. O sistema usa IA/LLM por trás (chatbot, geração de texto, agente)?
+4. Usa banco? Qual (Supabase, Postgres, Mongo)?
+
+Depois, MEÇA o terreno lendo o repo, e anote para si:
+- Onde estão os handlers de rota (onde o servidor responde pedidos).
+- Onde está a autenticação (login, sessão, middleware).
+- Se usa Supabase: quais tabelas existem e quais têm RLS ligada.
+- Onde texto externo entra no prompt do modelo (se usa IA).
+- Onde poderia haver segredo (env, config, histórico do Git).
+
+Se não houver como ler o repo (o usuário não apontou a pasta), pare e peça a pasta.
+Não invente a estrutura.
+
+### Fase 1: Auditar família por família, LENDO o código
+
+Para cada família, abra o `kb/` dela e siga o "onde procurar" e o "como confirmar".
+Ordem sugerida (as portas mais comuns primeiro): IDOR, segredos, SQL, injeção de
+prompt (se usa IA). Depois, se der tempo, as demais famílias conforme forem adicionadas.
+
+Para cada achado, registre: arquivo e linha, o que é (uma frase de leigo), o risco
+concreto para o negócio dele, e o conserto em passos curtos no framework dele.
+
+### Fase 2: Traduzir e priorizar
+
+Não despeje a lista inteira. Ordene por gravidade e comece pelos 3 mais graves.
+
+Crítico é qualquer coisa que exponha dado de cliente, segredo, ou dê acesso sem
+login. Para cada achado dos 3 primeiros:
+- Uma frase do que é, em linguagem de leigo.
+- O risco concreto (o que um estranho consegue fazer).
+- O conserto em passos curtos, com exemplo no framework dele.
+
+### Fase 3: Plano curto
+
+Monte: o que consertar hoje (crítico), esta semana, depois. Uma linha cada.
+
+### Fase 4: As correções que exigem procedimento
+
+Quando aparecer segredo no Git ou endpoint de IA sem proteção, conduza pelo
+`procedures/`. São as duas correções que pedem passo a passo (revogar/limpar
+segredo; blindar o LLM). Uma etapa de cada vez, esperando o usuário terminar.
+
+### Fase 5: Fechar
+
+Entregue um checklist do que foi corrigido e do que ficou de tarefa. Lembre que,
+depois de consertar, vale reauditar: a correção às vezes cria o defeito seguinte.
+
+## Se der errado
+
+- **Não acho o código / a pasta está vazia:** peça o caminho certo do repositório.
+  Não audite pela tela pública; sem o código, a auditoria é chute.
+- **O repo é enorme e trava a leitura:** comece pelos handlers de rota e pela pasta
+  de API; é onde as portas abertas moram. Não precisa ler tudo de uma vez.
+- **Não tenho certeza se um achado é real:** trate como hipótese, marque "a
+  confirmar" e diga ao usuário como provar no sandbox de teste. Nunca afirme falha
+  sem a linha do código que a prova.
+- **Windows:** os comandos de varredura dos `kb/` usam `git grep`, que roda igual no
+  Mac e no Windows (é o próprio Git). Onde um `kb/` traz um pipe `git log -p | grep`,
+  ele dá também a versão PowerShell com `Select-String`. Nada de encadear com `&&`
+  (o PowerShell 5.1 não aceita); uma linha por comando.
+
+## Tom
+
+Vibe coder não tem culpa de não saber isto. Trate como quem constrói rápido e
+precisa de um segundo par de olhos, não como quem errou. Elogie o que já está certo.
+Sempre técnico mais tradução fácil, lado a lado. Uma coisa de cada vez.

package/skills/blindar-sistema/advanced/frieren-opcional.md

@@ -0,0 +1,61 @@
+# Etapa avançada (opcional): teste ao vivo com o Frieren
+
+> Parte do pacote **blindar-sistema**. Isto é OPCIONAL e AVANÇADO. A trilha
+> principal (a skill lendo o código) NÃO depende disto. Só siga aqui se você quer o
+> teste ao vivo e já montou o sandbox de dado falso (`procedures/sandbox-dado-falso.md`).
+
+## Por que existe
+
+A auditoria lendo o código pega quase tudo, e sem risco. Mas algumas falhas só
+aparecem com o sistema RODANDO: injeção cega por tempo, comportamento de cache,
+fluxo de várias etapas (carrinho, cupom, checkout), upload de arquivo. Para esses
+casos existe uma ferramenta externa aberta, o **Frieren DAST-AI** (KnowBe4, licença
+Apache 2.0), que testa o sistema por dentro como um invasor faria.
+
+Ela cobre o que a leitura de código não vê, ao custo de 4 riscos que você precisa
+conhecer ANTES de ligar.
+
+## Os 4 riscos (nomeados, para você decidir com os olhos abertos)
+
+1. **O comando de instalação roda código de terceiro.** O `make setup` executa um
+   arquivo que vem do download. Rode só numa máquina onde isso é aceitável.
+2. **Instalar o certificado do proxy é instalar uma autoridade.** O Frieren fica no
+   meio e descriptografa o tráfego seguro. Enquanto o certificado estiver confiado
+   no navegador, TODO o seu tráfego pode ser lido, não só o sistema em teste. Use um
+   navegador ou perfil separado, só para o teste, e remova o certificado no fim.
+3. **O tráfego capturado vai para uma LLM.** Os agentes mandam o que capturaram para
+   o provedor de IA, na sua chave. Rodar contra dado real é dado saindo da máquina.
+   Por isso: SÓ contra o sandbox de dado falso.
+4. **A ferramenta é nova.** Projeto recente, pouca revisão da comunidade. A marca por
+   trás é real; o código ainda é jovem. Trate como ferramenta de laboratório.
+
+## A trava (herda a regra única do sandbox, endurecida)
+
+> Só rode o Frieren contra um sistema **seu**, no **sandbox de dado falso** da
+> `procedures/sandbox-dado-falso.md`. Nunca produção. Nunca dado de gente real.
+> Nunca site de terceiro. Confirme os itens do checklist do sandbox antes de ligar.
+
+## Como rodar (resumo, o guia oficial está no repositório da ferramenta)
+
+1. Monte o sandbox de dado falso (procedimento próprio) e confirme o checklist.
+2. Baixe e instale o Frieren seguindo o README oficial do projeto (repositório
+   público da KnowBe4). Use uma chave de LLM sua.
+3. Suba o proxy, configure o navegador de teste para passar por ele, instale o
+   certificado SÓ nesse navegador/perfil.
+4. Navegue pelo seu sistema no sandbox, logado. Os achados aparecem sozinhos.
+5. Leia os achados e leve cada CONSERTO para o código (use os `kb/` do pacote para
+   traduzir e consertar). O conserto vai para produção; o teste, nunca.
+
+## Depois
+
+- Remova o certificado do navegador de teste.
+- Desligue o proxy; não deixe o sandbox exposto com o proxy no ar.
+- Reaudite lendo o código depois de consertar (a correção às vezes cria o defeito
+  seguinte).
+
+## O que o Iron já faz sem isto
+
+IDOR, segredo exposto, injeção de SQL, injeção de prompt e as demais famílias do
+`kb/`: tudo isso a skill acha LENDO o código, sem proxy, sem certificado, sem mandar
+dado para fora. Esta etapa é só para o teste ao vivo do que só existe em tempo de
+execução.

package/skills/blindar-sistema/kb/idor.md

@@ -0,0 +1,94 @@
+# IDOR: um cliente vê o dado de outro
+
+> Base de conhecimento do pacote **blindar-sistema**. Auditoria white-box: o Iron
+> LÊ o código, não ataca de fora. Nenhum dado de cliente sai da máquina.
+
+## O que é (linguagem de leigo)
+
+IDOR (Insecure Direct Object Reference) é quando o sistema entrega um recurso pelo
+seu identificador sem conferir se ele pertence a quem está pedindo. O usuário troca
+`pedido/1042` por `pedido/1043` e vê o pedido do vizinho: nome, endereço, o que
+comprou. O sistema entregou o dado sozinho, ninguém precisou invadir.
+
+É a falha número 1 do OWASP (Broken Access Control) e a mais comum em app de vibe
+coding, porque a IA constrói a rota que busca pelo ID e quase nunca adiciona sozinha
+a checagem "esse ID é desta pessoa?".
+
+## Onde procurar no código
+
+O Iron abre os **handlers de rota** (onde o servidor responde um pedido) e procura
+todo ponto que:
+1. Recebe um identificador vindo de fora: `params`, query string, corpo do pedido,
+   segmento da URL (`/pedido/:id`), ou variável de GraphQL.
+2. Usa esse identificador para buscar no banco (`select ... where id = :id`,
+   `findById`, `.get(id)`, `from('pedidos').eq('id', id)`).
+3. **Não filtra também pelo dono** logado (`user_id`, `owner_id`, `account_id`).
+
+Alvos por stack (onde o handler mora):
+- **Next.js / API routes:** `app/api/**/route.ts`, `pages/api/**`.
+- **Supabase:** a checagem de dono deve estar na **RLS (Row Level Security)** da
+  tabela, não só na query. Tabela sem RLS é IDOR aberto por padrão.
+- **Express / Node:** arquivos de `routes/` e `controllers/`.
+- **GraphQL:** cada **resolver** que recebe um `id` como argumento.
+
+## Padrão vulnerável vs. seguro
+
+VULNERÁVEL, busca só pelo ID:
+```
+// Express: confia no ID e devolve
+const pedido = await db.pedido.findUnique({ where: { id: req.params.id } })
+res.json(pedido)
+```
+```
+// Supabase sem RLS: isto retorna QUALQUER pedido
+const { data } = await supabase.from('pedidos').select('*').eq('id', id)
+```
+
+SEGURO, o dono entra sempre na condição, no servidor:
+```
+// Express: o pedido só é achado se for do usuário logado
+const pedido = await db.pedido.findFirst({
+  where: { id: req.params.id, userId: req.user.id }
+})
+if (!pedido) return res.status(404).end()   // 404, não 403: não revela que existe
+```
+```sql
+-- Supabase: a trava vive no banco, vale para toda query
+alter table pedidos enable row level security;
+create policy "dono le o proprio pedido"
+  on pedidos for select
+  using (auth.uid() = user_id);
+```
+
+## Caso mais perigoso: escalada horizontal entre contas
+
+Não é só trocar o número. Às vezes a rota confere o dono, mas **uma sessão consegue
+usar o recurso de outra**. Teste white-box: existe alguma rota que muda estado
+(cancelar, aprovar, transferir) e checa só se está logado, não se é o dono daquele
+recurso específico? Isso é a categoria BOLA (acesso a objeto de outro usuário); a
+variante em que a falha está numa FUNÇÃO administrativa se chama BFLA. As duas somem
+no meio de painéis admin.
+
+## Como confirmar (sem atacar produção)
+
+1. Liste as rotas que recebem um ID de fora (a Fase 0 da skill já mapeou).
+2. Para cada uma, responda por escrito: **"o dono do recurso é conferido no
+   servidor, nesta query?"** Se a resposta for "a tela só mostra o botão para o
+   dono", está decorativo, não protege. Quem chama a rota direto ignora a tela.
+3. Em Supabase, liste as tabelas do schema público e cruze com as que têm policy:
+   `select tablename from pg_tables where schemaname = 'public'`. Tabela com dado de
+   cliente e sem RLS é achado crítico.
+4. Prova viva (só no sandbox de dado falso, Fase 4): crie dois usuários de teste,
+   pegue um ID do usuário A e tente lê-lo logado como B. Abriu, é IDOR.
+
+## O conserto
+
+- A autorização vive **no servidor e/ou no banco**, nunca na interface.
+- Toda query de recurso de usuário carrega o dono na condição (`where dono = logado`).
+- Em Supabase, **RLS ligada em toda tabela com dado de gente**, com policy por
+  operação (select/insert/update/delete).
+- Recurso não encontrado responde **404**, não 403: 403 confirma que o ID existe.
+- IDs sequenciais (1, 2, 3) facilitam a varredura; UUID não conserta o IDOR, mas
+  para a enumeração em massa. Corrija a autorização primeiro, troque para UUID depois.
+
+**Severidade:** crítico quando expõe dado de cliente, segredo ou dá acesso sem login.