iron-edge 2.1.0 → 2.3.0

package/README.md

@@ -1,6 +1,6 @@
 # Iron Edge — Ecossistema de Agentes para Claude Code
 
-**44 agentes de topo, 18 squads, 14 skills e memória entre sessões.**
+**44 agentes de topo, 18 squads, 15 skills e memória entre sessões.**
 
 Uma equipe completa de IA para marketing, vendas, conteúdo, Shopify, vídeo e crescimento — tudo dentro do Claude Code.
 
@@ -29,13 +29,14 @@ São arquivos `.md` comuns — abrem no Obsidian, no VS Code ou em qualquer edit
 Existem **duas coisas diferentes** aqui, e elas se chamam de jeitos diferentes. Confundir as duas
 é o erro mais comum de quem acabou de instalar.
 
-**Skills — essas viram comando de barra.** São 14, e o Claude Code as reconhece por `/nome`:
+**Skills — essas viram comando de barra.** São 15, e o Claude Code as reconhece por `/nome`:
 
 ```
-/gate      → auditoria de qualidade antes de entregar
-/salvar    → registra o estado do projeto
-/brandkit  → identidade visual
-/escada    → qual modelo usar em cada fase
+/gate             → auditoria de qualidade antes de entregar
+/blindar-sistema  → audita a segurança do seu sistema lendo o código
+/salvar           → registra o estado do projeto
+/brandkit         → identidade visual
+/escada           → qual modelo usar em cada fase
 ```
 (As outras: `anotar`, `faxina`, `conectar-mcp`, `roteiro-video`, `lp-cinematico`, `clone-site`,
 `clone-inventory`, `clone-distill`, `clone-organize`, `clone-transplant`.)
@@ -130,6 +131,7 @@ são os 13 conselhos `xq-*` (squads de referência, ex.: `xq-copy`, `xq-hormozi`
 | Skill | O que faz |
 |-------|-----------|
 | `gate` | Quality gate de aprovação duplicada: um painel de auditores independentes audita o que você produziu — arte, site, código, pipeline, PDF, vídeo — **antes** de virar entrega, commit ou publicação. Nada sai sem parecer com zero bloqueador |
+| `blindar-sistema` | Auditoria de segurança do seu sistema **lendo o código** (white-box): acha as portas abertas mais comuns de quem programa com IA — cliente vendo dado de outro, chave exposta, injeção de SQL, chatbot de IA sem proteção — sem proxy, sem instalar nada, sem mandar dado pra fora, no Mac e no Windows |
 | `salvar` | Fecha a sessão registrando o que foi feito e o que mudou de estado |
 | `anotar` | Guarda o aprendizado reaproveitável, separado do registro de projeto |
 | `escada` | Qual modelo usar em cada fase, para não gastar caro na fase longa |
@@ -165,11 +167,29 @@ Instalada junto. Depois de `npx iron-edge install`, os dois arquivos abaixo est
 npx iron-edge verify
 ```
 
-**Não existe `update` nem `uninstall` automáticos, e isso é decisão, não falta.**
+**Atualizar é um comando. Remover é operação conduzida.**
 
-O instalador **nunca sobrescreve** o que já está em `~/.claude/` e em `~/.iron/` — se ele passasse por cima, apagaria o agente que você escreveu e a memória que a sua máquina acumulou. Então atualizar e remover são operações conduzidas, com você no circuito:
+- **Atualizar:**
 
-- **Atualizar:** rode `npx iron-edge verify` para ver o que **você** alterou e guardar esses arquivos. Depois remova a instalação antiga como descrito abaixo e instale de novo. O instalador nunca passa por cima — se encontrar a instalação antiga, ele para e não toca em nada.
+  ```bash
+  npx iron-edge@latest update
+  ```
+
+  Ele lê o manifesto e confere **arquivo por arquivo, por hash**. Só troca o que estiver
+  byte a byte idêntico ao pacote — ou seja, o que ninguém encostou. Numa instalação típica
+  isso é mais de 2.100 dos 2.126 arquivos.
+
+  **O que ele nunca toca:** o seu `config.yaml`, o seu cofre, agentes e skills que você
+  criou, e **qualquer arquivo do pacote que você tenha editado** — esses ficam marcados no
+  manifesto e continuam preservados nas atualizações seguintes. Ele lista um por um antes de
+  agir. Se quiser ver o plano sem escrever nada: `npx iron-edge update --dry-run`.
+
+  Se algo falhar no meio, nada fica pela metade: ele escreve tudo ao lado primeiro e só
+  depois coloca no lugar. Falhou antes disso, sua instalação continua exatamente como estava.
+
+  > Instalação anterior a 24/08/2026, feita por zip, não tem manifesto — sem ele não dá para
+  > separar o que é seu por lista. Nesse caso rode `npx iron-edge install` e siga o **CASO B**
+  > da mensagem que aparece.
 - **Remover — nesta ordem, porque a lista do que remover mora dentro da pasta que some:**
 
   1. **Primeiro** tire uma cópia do manifesto para fora:

package/bin/iron-edge.js

@@ -10,8 +10,12 @@
  *                                         imprime versao, edicao, commit e os
  *                                         arquivos que o usuario alterou
  *
- * Nao existe 'update' nem 'uninstall' automaticos: atualizar e remover sao
- * operacoes conduzidas (runbook), com humano no circuito.
+ *   update  [--dry-run] [--source <dir>]  atualiza uma instalacao existente: troca SO os
+ *                                         arquivos cujo hash bate com o manifesto — os que
+ *                                         ninguem alterou — e preserva o resto
+ *
+ * Nao existe 'uninstall' automatico: remover continua sendo operacao conduzida, com o
+ * manifesto na mao (o README descreve o procedimento).
  */
 const fs = require('fs');
 const path = require('path');
@@ -35,6 +39,14 @@ if (cmd === 'install') {
   const r = spawnSync(process.execPath, args, { stdio: 'inherit' });
   process.exit(r.status ?? 1);
 
+} else if (cmd === 'update') {
+  // atualiza uma instalacao existente: troca so' o que esta identico ao manifesto.
+  const pkgRoot = path.join(__dirname, '..');
+  const args = [path.join(pkgRoot, 'installer', 'update.js'), ...rest];
+  if (!rest.includes('--source')) args.push('--source', pkgRoot);
+  const r = spawnSync(process.execPath, args, { stdio: 'inherit' });
+  process.exit(r.status ?? 1);
+
 } else if (cmd === 'verify') {
   const manPath = path.join(HOME, '.iron', 'install-manifest.json');
   if (!fs.existsSync(manPath)) {
@@ -69,6 +81,6 @@ if (cmd === 'install') {
   process.exit(alterados.length + sumidos.length === 0 ? 0 : 1);
 
 } else {
-  console.log('uso: iron-edge <install|verify> [--dry-run] [--source <dir>]');
+  console.log('uso: iron-edge <install|update|verify> [--dry-run] [--source <dir>]');
   process.exit(cmd ? 1 : 0);
 }

package/installer/gerados.js

@@ -0,0 +1,106 @@
+/**
+ * Os arquivos que o Iron GERA na maquina (nao vem do payload): config, atalho, integracoes.
+ *
+ * Por que este arquivo existe: o `install` criava esses arquivos e o `update` nao sabia deles.
+ * Resultado medido: quem atualizasse do 2.0.2 pro 2.1.0 NAO ganhava o atalho `/iron`, porque
+ * ele e' gerado, nao copiado. A correcao obvia — repetir a geracao dentro do update — seria o
+ * defeito de propagacao que este pacote passou um ciclo inteiro cacando: duas copias que
+ * divergem no dia em que alguem editar so' uma.
+ *
+ * Entao a lista mora aqui, e os dois scripts leem daqui.
+ *
+ * `sobrescrever`:
+ *   false  → e' do usuario depois de criado. Nunca se toca (config.yaml, shopify.yaml).
+ *   true   → e' do pacote. O update troca, MAS so' se o hash bater com o manifesto; se a
+ *            pessoa editou, ela ganha aviso e o arquivo dela fica.
+ */
+'use strict';
+const path = require('path');
+
+function arquivosGerados({ IRON_DIR, CLAUDE_DIR }) {
+  const COMMANDS = path.join(CLAUDE_DIR, 'commands');
+  return [
+    {
+      dest: path.join(IRON_DIR, 'config.yaml'),
+      oQueE: 'a config inicial',
+      sobrescrever: false,
+      conteudo: [
+        '# Iron Edge - configuracao. Tudo aqui e opcional, mas os dois primeiros blocos mudam',
+        '# muito a qualidade da resposta. Edite a mao, ou peca ao Iron: "configura o Iron pra mim".',
+        '',
+        '# QUEM E VOCE. Sem isto, tudo que o Iron responder sai generico.',
+        'owner: ""                    # seu nome',
+        'businesses: []               # ex: ["loja de roupa", "consultoria de trafego"]',
+        '',
+        '# O COFRE - a memoria do Iron entre uma conversa e outra.',
+        '#',
+        '# SEM cofre, cada conversa comeca do zero: o Iron nao lembra dos seus projetos, do que',
+        '# ficou pendente, nem do que voce decidiu ontem. COM cofre, ele le tudo isso antes de',
+        '# trabalhar. E uma pasta de arquivos .md comuns, na SUA maquina - abre no Obsidian, no',
+        '# VS Code ou em qualquer editor. Nada e enviado pra lugar nenhum.',
+        '#',
+        '# Ainda nao tem? Peca ao Iron: "cria meu cofre". Ele monta a estrutura no lugar que',
+        '# voce escolher e preenche este campo sozinho. Leva um minuto.',
+        'vault_path: ""               # ex: ~/Documents/Cofre',
+        '',
+        '# focus: dev                 # prioriza o iron-eng (engenharia de software) no roteamento.',
+        '#                            # descomente se o seu uso principal for programar.',
+        '',
+      ].join('\n'),
+    },
+    {
+      dest: path.join(COMMANDS, 'iron.md'),
+      oQueE: 'o atalho iron',
+      sobrescrever: true,
+      conteudo: [
+        '---',
+        'description: Iron Edge - chama o orquestrador master. Ele entende o pedido, decide qual equipe resolve e aciona os especialistas certos.',
+        '---',
+        '',
+        'Leia o arquivo `~/.claude/agents/iron-ceo.md` por inteiro e assuma aquele papel agora,',
+        'seguindo a sequencia de ativacao descrita la (ler o config, ler o cofre se houver, ler o',
+        'mapa de roteamento, e so entao saudar).',
+        '',
+        'Nao resuma o arquivo nem trabalhe de memoria: leia o conteudo real, porque ele muda quando',
+        'o pacote e atualizado.',
+        '',
+        'Pedido do usuario: $ARGUMENTS',
+        '',
+        '(Sem pedido depois do comando, apenas ative e pergunte qual e a missao.)',
+        '',
+        'Este atalho atende tanto por `/iron` quanto pela palavra `iron` sozinha.',
+        '',
+      ].join('\n'),
+    },
+    {
+      dest: path.join(IRON_DIR, 'secrets', 'LEIA-ME.md'),
+      oQueE: 'o LEIA-ME de secrets',
+      sobrescrever: true,
+      conteudo: [
+        '# secrets/',
+        '',
+        'Pasta para as SUAS credenciais, se um dia voce conectar alguma integracao.',
+        '**Ela nasce vazia e o Iron nao escreve nada aqui sozinho.**',
+        '',
+        'Nada nesta pasta e enviado para lugar nenhum: e arquivo no seu disco, como',
+        'qualquer outro. Se voce nunca conectar integracao, ela fica vazia para sempre —',
+        'e pode apagar sem quebrar nada.',
+        '',
+      ].join('\n'),
+    },
+    {
+      dest: path.join(IRON_DIR, 'integrations', 'LEIA-ME.md'),
+      oQueE: 'o LEIA-ME de integrations',
+      sobrescrever: true,
+      conteudo: [
+        '# integrations/',
+        '',
+        'Configuracao das integracoes opcionais (por enquanto, so o Shopify via Iron Office).',
+        'O `shopify.yaml` nasce com `enabled: false`: nada e ligado sem voce ligar.',
+        '',
+      ].join('\n'),
+    },
+  ];
+}
+
+module.exports = { arquivosGerados };

package/installer/install.js

@@ -447,28 +447,6 @@ log(`  ${manifest.length} arquivos copiados.`);
 
 for (const d of [path.join(IRON_DIR, 'integrations'), path.join(IRON_DIR, 'secrets')]) {
   criarPasta(d, 'as pastas de estado');
-
-// As duas pastas nascem vazias e com nome que gera duvida ("secrets" assusta quem vai por
-// dado de negocio). Um LEIAME em cada uma explica pra que servem — pasta vazia sem
-// explicacao foi achado de um leitor sem contexto nenhum.
-escrever(path.join(IRON_DIR, 'secrets', 'LEIA-ME.md'), [
-  '# secrets/',
-  '',
-  'Pasta para as SUAS credenciais, se um dia voce conectar alguma integracao.',
-  '**Ela nasce vazia e o Iron nao escreve nada aqui sozinho.**',
-  '',
-  'Nada nesta pasta e enviado para lugar nenhum: e arquivo no seu disco, como',
-  'qualquer outro. Se voce nunca conectar integracao, ela fica vazia para sempre —',
-  'e pode apagar sem quebrar nada.',
-  ''
-].join('\n'), 'o LEIA-ME de secrets');
-escrever(path.join(IRON_DIR, 'integrations', 'LEIA-ME.md'), [
-  '# integrations/',
-  '',
-  'Configuracao das integracoes opcionais (por enquanto, so o Shopify via Iron Office).',
-  'O `shopify.yaml` nasce com `enabled: false`: nada e ligado sem voce ligar.',
-  ''
-].join('\n'), 'o LEIA-ME de integrations');
 }
 
 // memoria por cargo do squad-engineering: pasta vazia, FORA do manifesto de propósito.
@@ -479,31 +457,6 @@ criarPasta(path.join(IRON_DIR, 'memory', 'squad-engineering'), 'a pasta de memor
 const shopifyYaml = path.join(IRON_DIR, 'integrations', 'shopify.yaml');
 escrever(shopifyYaml, 'enabled: false\nendpoint: ""\napi_key_file: ""\n', 'a config da integracao');
 
-const configYaml = path.join(IRON_DIR, 'config.yaml');
-escrever(configYaml, [
-  '# Iron Edge - configuracao. Tudo aqui e opcional, mas os dois primeiros blocos mudam',
-  '# muito a qualidade da resposta. Edite a mao, ou peca ao Iron: "configura o Iron pra mim".',
-  '',
-  '# QUEM E VOCE. Sem isto, tudo que o Iron responder sai generico.',
-  'owner: ""                    # seu nome',
-  'businesses: []               # ex: ["loja de roupa", "consultoria de trafego"]',
-  '',
-  '# O COFRE - a memoria do Iron entre uma conversa e outra.',
-  '#',
-  '# SEM cofre, cada conversa comeca do zero: o Iron nao lembra dos seus projetos, do que',
-  '# ficou pendente, nem do que voce decidiu ontem. COM cofre, ele le tudo isso antes de',
-  '# trabalhar. E uma pasta de arquivos .md comuns, na SUA maquina - abre no Obsidian, no',
-  '# VS Code ou em qualquer editor. Nada e enviado pra lugar nenhum.',
-  '#',
-  '# Ainda nao tem? Peca ao Iron: "cria meu cofre". Ele monta a estrutura no lugar que',
-  '# voce escolher e preenche este campo sozinho. Leva um minuto.',
-  'vault_path: ""               # ex: ~/Documents/Cofre',
-  '',
-  '# focus: dev                 # prioriza o iron-eng (engenharia de software) no roteamento.',
-  '#                            # descomente se o seu uso principal for programar.',
-  ''
-].join('\n'), 'a config inicial');
-
 const installedAt = new Date().toISOString();
 
 // PATCH 7: gerados entram no manifesto com generated:true
@@ -523,38 +476,17 @@ const installManifest = {
   files: manifest // sera reescrito abaixo ja com os gerados
 };
 
-// adiciona shopify + config no manifesto antes de gravar o manifesto em si
+// Os arquivos GERADOS (config, atalho, LEIA-ME) vivem em installer/gerados.js — um lugar so',
+// lido tambem pelo `update`. Antes ficavam escritos aqui dentro, e o update nao sabia deles:
+// quem atualizasse nao ganhava o atalho /iron. Duas copias divergem; uma lista nao.
+const { arquivosGerados } = require('./gerados');
+let configYaml = null;
+for (const g of arquivosGerados({ IRON_DIR, CLAUDE_DIR })) {
+  escrever(g.dest, g.conteudo, g.oQueE);
+  addGenerated(g.dest);
+  if (g.dest.endsWith('config.yaml')) configYaml = g.dest;
+}
 addGenerated(shopifyYaml);
-addGenerated(configYaml);
-
-// O ATALHO /iron — o pedido mais repetido de quem usa o Iron todo dia.
-//
-// Ele NAO e' copia do agente. A maquina de quem desenvolve tinha um commands/iron.md com o
-// texto INTEIRO do iron-ceo dentro: 158 linhas duplicadas, que hoje batem por sorte e amanha
-// divergem em silencio. Copia e' o defeito de propagacao que este pacote passou um ciclo
-// inteiro caçando. Aqui o comando so' APONTA pro agente — uma fonte de verdade, e o /iron
-// acompanha qualquer mudanca no iron-ceo.md sem ninguem lembrar de sincronizar.
-const ironCmd = path.join(COMMANDS_DEST, 'iron.md');
-escrever(ironCmd, [
-  '---',
-  'description: Iron Edge - chama o orquestrador master. Ele entende o pedido, decide qual equipe resolve e aciona os especialistas certos.',
-  '---',
-  '',
-  'Leia o arquivo `~/.claude/agents/iron-ceo.md` por inteiro e assuma aquele papel agora,',
-  'seguindo a sequencia de ativacao descrita la (ler o config, ler o cofre se houver, ler o',
-  'mapa de roteamento, e so entao saudar).',
-  '',
-  'Nao resuma o arquivo nem trabalhe de memoria: leia o conteudo real, porque ele muda quando',
-  'o pacote e atualizado.',
-  '',
-  'Pedido do usuario: $ARGUMENTS',
-  '',
-  '(Sem pedido depois do comando, apenas ative e pergunte qual e a missao.)',
-  '',
-  'Este atalho atende tanto por `/iron` quanto pela palavra `iron` sozinha.',
-  ''
-].join('\n'), 'o atalho /iron');
-addGenerated(ironCmd);
 
 const metadataPath = path.join(IRON_DIR, 'metadata.json');
 escrever(metadataPath,

package/installer/update.js

@@ -0,0 +1,343 @@
+#!/usr/bin/env node
+/**
+ * iron-edge update — atualiza uma instalacao existente SEM refazer tudo.
+ *
+ * Por que isto existe: ate a versao 2.1.0 nao havia caminho de atualizacao. O instalador
+ * abortava em qualquer conflito e mandava a pessoa mover tres pastas, reinstalar e preencher
+ * o config de novo. O argumento era "nunca sobrescrever, pra nao destruir o que e' seu" — e
+ * era bom, ENQUANTO nao havia manifesto. Com manifesto e hash, da' pra separar exatamente o
+ * que veio do pacote do que e' da pessoa: numa instalacao tipica, 2120 dos 2123 arquivos estao
+ * byte a byte identicos ao pacote. Trocar aqueles e' matematicamente seguro.
+ *
+ * A REGRA DESTE SCRIPT, em uma frase: so' se troca arquivo cujo hash bate com o manifesto.
+ * Hash diferente = a pessoa mexeu = nao se toca, e avisa.
+ *
+ * Seguranca em duas fases, pra nunca deixar a instalacao pela metade:
+ *   Fase 1 — escreve tudo como `<destino>.iron-new`. Nada que esta' em uso muda.
+ *   Fase 2 — renomeia para o lugar. Se falhar no meio, desfaz os que ja' foram.
+ */
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+
+const HOME = os.homedir();
+const IRON_DIR = path.join(HOME, '.iron');
+const CLAUDE_DIR = path.join(HOME, '.claude');
+const MANIFEST = path.join(IRON_DIR, 'install-manifest.json');
+
+const args = process.argv.slice(2);
+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);
+function abort(msg) {
+  console.error('\n[ABORTADO] ' + msg);
+  process.exit(1);
+}
+
+function sha256(file) {
+  return crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+}
+
+// Compara caminho por caminho REAL, nao por string. `path.resolve` nao desfaz symlink, e o
+// manifesto grava o caminho ja resolvido: numa maquina onde o HOME esta atras de um link
+// (macOS com /tmp, perfil corporativo redirecionado) NADA casaria, e o update concluiria que
+// precisa adicionar os 2120 arquivos e remover os 2119 antigos. O --dry-run pegou isso antes
+// de qualquer escrita — que e' exatamente pra isso que ele existe.
+function norm(p) {
+  let alvo = path.resolve(p);
+  let resto = '';
+  for (;;) {
+    try { return path.join(fs.realpathSync(alvo), resto); }
+    catch (e) {
+      const pai = path.dirname(alvo);
+      if (pai === alvo) return path.resolve(p);
+      resto = path.join(path.basename(alvo), resto);
+      alvo = pai;
+    }
+  }
+}
+
+// ---------------------------------------------------------------- payload novo
+// Mesmo mapeamento do install.js: o que vai pra ~/.iron e o que vai pra ~/.claude.
+function destinoDe(rel) {
+  const norm = rel.split(path.sep).join('/');
+  if (norm.startsWith('agents/')) return path.join(CLAUDE_DIR, 'agents', norm.slice('agents/'.length));
+  if (norm.startsWith('skills/')) return path.join(CLAUDE_DIR, 'skills', norm.slice('skills/'.length));
+  if (norm === 'iron-routing-map.md') return path.join(IRON_DIR, 'iron-routing-map.md');
+  if (norm.startsWith('squads/')) return path.join(IRON_DIR, norm.slice('squads/'.length));
+  if (norm.startsWith('docs/')) return path.join(IRON_DIR, 'docs', norm.slice('docs/'.length));
+  return null;
+}
+
+function varrerPayload(dir, base = '') {
+  const out = [];
+  for (const e of fs.readdirSync(path.join(SOURCE, dir), { withFileTypes: true })) {
+    const rel = base ? `${base}/${e.name}` : `${dir}/${e.name}`;
+    if (e.isSymbolicLink()) continue;
+    if (e.isDirectory()) out.push(...varrerPayload(path.join(dir, e.name), rel));
+    else out.push(rel);
+  }
+  return out;
+}
+
+// ---------------------------------------------------------------- pre-voo
+log('================================');
+log('  Iron Edge - Atualizador');
+log('================================');
+log('HOME   : ' + HOME);
+log('Origem : ' + SOURCE);
+if (DRY) log('MODO   : --dry-run (nada sera escrito)');
+log('');
+
+if (!fs.existsSync(MANIFEST)) {
+  console.error(`Nao ha manifesto em ${MANIFEST}.`);
+  console.error('');
+  console.error('Isto significa que esta instalacao e ANTERIOR ao manifesto (veio de zip), e nao');
+  console.error('da pra separar por lista o que e do pacote do que e seu. O caminho, nesse caso, e');
+  console.error('o manual: rode "npx iron-edge install" e siga o CASO B da mensagem que aparece.');
+  process.exit(1);
+}
+
+let man;
+try { man = JSON.parse(fs.readFileSync(MANIFEST, 'utf8')); }
+catch (e) { abort(`o manifesto existe mas nao e JSON valido: ${e.message}`); }
+
+const antigos = new Map();          // dest -> entrada do manifesto
+for (const f of man.files || []) {
+  const dest = f.dest || f.path;
+  if (dest) antigos.set(norm(dest), f);
+}
+log(`Instalacao encontrada: ${antigos.size} arquivos no manifesto`);
+if (man.label) log(`  edicao: ${man.label}`);
+if (man.installed_at) log(`  instalada em: ${man.installed_at}`);
+
+for (const must of ['agents', 'iron-routing-map.md']) {
+  if (!fs.existsSync(path.join(SOURCE, must))) abort(`origem invalida: faltou "${must}" em ${SOURCE}`);
+}
+
+// payload novo, mapeado por destino
+const novos = new Map();            // dest -> caminho de origem
+for (const dir of ['agents', 'skills', 'squads', 'docs']) {
+  if (!fs.existsSync(path.join(SOURCE, dir))) continue;
+  for (const rel of varrerPayload(dir)) {
+    const d = destinoDe(rel);
+    if (d) novos.set(norm(d), path.join(SOURCE, rel));
+  }
+}
+{
+  const d = destinoDe('iron-routing-map.md');
+  novos.set(norm(d), path.join(SOURCE, 'iron-routing-map.md'));
+}
+
+// ---------------------------------------------------------------- classificar
+const plano = { trocar: [], adicionar: [], restaurar: [], preservar: [], remover: [], manter: [], gerar: [] };
+
+for (const [dest, origem] of novos) {
+  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; }
+  if (!fs.existsSync(dest)) { plano.restaurar.push({ dest, origem }); continue; }
+  const atual = sha256(dest);
+  // Arquivo que a pessoa editou fica marcado no manifesto. Sem essa marca, o update anterior
+  // gravava o hash NOVO (o dela) e o update SEGUINTE via hash batendo, concluia "intacto do
+  // pacote" e sobrescrevia: a edicao sobrevivia a uma atualizacao e morria calada na proxima.
+  // Medido em teste, nao deduzido. A marca so' sai quando o arquivo volta a ser identico ao
+  // pacote — ou seja, quando a propria pessoa desfez a edicao.
+  if (ent.user_modified) {
+    if (sha256(origem) === atual) { plano.manter.push({ dest, motivo: 'voltou a ser igual ao pacote' }); continue; }
+    plano.preservar.push({ dest, marcado: true });
+    continue;
+  }
+  if (atual !== ent.sha256) { plano.preservar.push({ dest }); continue; }
+  if (sha256(origem) === atual) { plano.manter.push({ dest, motivo: 'ja esta na versao nova' }); continue; }
+  plano.trocar.push({ dest, origem });
+}
+
+for (const [dest, ent] of antigos) {
+  if (novos.has(dest)) continue;
+  if (ent.generated) continue;
+  if (!fs.existsSync(dest)) continue;
+  if (sha256(dest) === ent.sha256) plano.remover.push({ dest });
+  else plano.preservar.push({ dest, obsoleto: true });
+}
+
+// Os arquivos GERADOS (config, atalho /iron, LEIA-ME) nao vem do payload — o instalador os
+// escreve. Sem este bloco, quem ATUALIZAVA nao ganhava capacidade nova gerada: foi medido no
+// 2.0.2 -> 2.1.0, em que o /iron simplesmente nao aparecia. A lista vem de gerados.js, a
+// mesma que o install le, pra nao existirem duas versoes do mesmo conteudo.
+const { arquivosGerados } = require('./gerados');
+const GERADOS = arquivosGerados({ IRON_DIR, CLAUDE_DIR });
+for (const g of GERADOS) {
+  const dest = norm(g.dest);
+  const ent = antigos.get(dest);
+  const existe = fs.existsSync(g.dest);
+  if (!existe) { plano.gerar.push({ ...g, motivo: 'novo nesta versao' }); continue; }
+  if (!g.sobrescrever) { plano.manter.push({ dest: g.dest, motivo: 'seu (config/integracao)' }); continue; }
+  const atual = sha256(g.dest);
+  if (ent && atual !== ent.sha256) { plano.preservar.push({ dest: g.dest }); continue; }
+  if (atual === crypto.createHash('sha256').update(g.conteudo).digest('hex')) {
+    plano.manter.push({ dest: g.dest, motivo: 'ja esta na versao nova' });
+  } else {
+    plano.gerar.push({ ...g, motivo: 'mudou nesta versao' });
+  }
+}
+
+// ---------------------------------------------------------------- mostrar
+log('');
+log('--- PLANO ---');
+log(`  trocar    : ${plano.trocar.length}  (identicos ao pacote antigo, mudaram na versao nova)`);
+log(`  adicionar : ${plano.adicionar.length}  (nao existiam)`);
+log(`  restaurar : ${plano.restaurar.length}  (estavam no manifesto e sumiram do disco)`);
+log(`  remover   : ${plano.remover.length}  (a versao nova nao traz mais, e estavam intactos)`);
+log(`  preservar : ${plano.preservar.length}  (VOCE alterou — nao sao tocados)`);
+log(`  manter    : ${plano.manter.length}  (ja atualizados, ou gerados na sua instalacao)`);
+log(`  gerar     : ${plano.gerar.length}  (config, atalho /iron, LEIA-ME — criados pelo instalador)`);
+for (const g of plano.gerar) log(`      + ${g.dest}  (${g.motivo})`);
+
+if (plano.preservar.length) {
+  log('');
+  log('  Estes arquivos NAO serao tocados, porque o hash mostra que voce mexeu neles:');
+  for (const p of plano.preservar.slice(0, 30))
+    log(`    ~ ${p.dest}${p.obsoleto ? '  (a versao nova nem traz mais este arquivo)' : ''}${p.marcado ? '  (ja marcado como seu)' : ''}`);
+  if (plano.preservar.length > 30) log(`    ... e mais ${plano.preservar.length - 30}`);
+  log('');
+  log('  Se algum deles for edicao sua que voce quer manter, esta tudo certo: fica como esta.');
+  log('  Se for edicao que voce ja nao quer, apague o arquivo e rode o update de novo — ele');
+  log('  entra em "restaurar" e volta na versao nova.');
+}
+
+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.');
+
+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) {
+  log(''); log('Nada a fazer: sua instalacao ja esta na versao deste pacote.');
+  process.exit(0);
+}
+
+// ---------------------------------------------------------------- FASE 1: escrever ao lado
+log('');
+log('--- FASE 1: escrevendo ao lado (nada em uso muda ainda) ---');
+const temporarios = [];
+try {
+  for (const it of [...plano.trocar, ...plano.adicionar, ...plano.restaurar]) {
+    const tmp = it.dest + '.iron-new';
+    fs.mkdirSync(path.dirname(it.dest), { recursive: true });
+    fs.copyFileSync(it.origem, tmp);
+    if (sha256(tmp) !== sha256(it.origem)) throw new Error(`copia divergiu do original: ${it.dest}`);
+    temporarios.push({ tmp, dest: it.dest, novo: !fs.existsSync(it.dest) });
+  }
+} catch (e) {
+  for (const t of temporarios) { try { fs.unlinkSync(t.tmp); } catch (_) {} }
+  abort(`falhou ao preparar os arquivos (${e.message}). NADA foi alterado na sua instalacao.`);
+}
+log(`  ${temporarios.length} arquivos preparados e conferidos por hash.`);
+
+// ---------------------------------------------------------------- FASE 2: trocar de lugar
+log('');
+log('--- FASE 2: colocando no lugar ---');
+const feitos = [];
+try {
+  for (const t of temporarios) {
+    if (!t.novo) {
+      const bak = t.dest + '.iron-old';
+      fs.renameSync(t.dest, bak);
+      t.bak = bak;
+    }
+    fs.renameSync(t.tmp, t.dest);
+    feitos.push(t);
+  }
+} catch (e) {
+  log('  ERRO no meio da troca. Desfazendo...');
+  for (const f of feitos.reverse()) {
+    try {
+      fs.unlinkSync(f.dest);
+      if (f.bak) fs.renameSync(f.bak, f.dest);
+    } catch (_) {}
+  }
+  for (const t of temporarios) { try { fs.unlinkSync(t.tmp); } catch (_) {} }
+  abort(`falhou ao trocar os arquivos (${e.message}). A instalacao foi devolvida ao estado anterior.`);
+}
+for (const f of feitos) { if (f.bak) { try { fs.unlinkSync(f.bak); } catch (_) {} } }
+log(`  ${feitos.length} arquivos atualizados.`);
+
+let removidos = 0;
+for (const r of plano.remover) { try { fs.unlinkSync(r.dest); removidos++; } catch (_) {} }
+if (removidos) log(`  ${removidos} arquivos que a versao nova nao traz mais foram removidos.`);
+
+// gerados: escritos direto (sao pequenos e nao ha versao "em uso" a proteger)
+let geradosOk = 0;
+for (const g of plano.gerar) {
+  try {
+    fs.mkdirSync(path.dirname(g.dest), { recursive: true });
+    fs.writeFileSync(g.dest, g.conteudo);
+    geradosOk++;
+  } catch (e) { log(`  aviso: nao consegui gravar ${g.dest} (${e.code || e.message})`); }
+}
+if (geradosOk) log(`  ${geradosOk} arquivo(s) gerado(s) desta versao criados (ex: o atalho /iron).`);
+
+// ---------------------------------------------------------------- FASE 3: manifesto e config
+log('');
+log('--- FASE 3: manifesto e config ---');
+
+const arquivos = [];
+const editados = new Set(plano.preservar.map((x) => norm(x.dest)));
+for (const [dest, origem] of novos) {
+  if (!fs.existsSync(dest)) continue;
+  const e = {
+    rel: path.relative(SOURCE, origem).split(path.sep).join('/'),
+    dest,
+    sha256: sha256(dest),
+  };
+  // a marca que impede a proxima atualizacao de comer a edicao da pessoa
+  if (editados.has(dest)) e.user_modified = true;
+  arquivos.push(e);
+}
+for (const [dest, ent] of antigos) {
+  if (novos.has(dest)) continue;
+  if (!fs.existsSync(dest)) continue;
+  if (GERADOS.some((g) => norm(g.dest) === dest)) continue;   // entram abaixo, com hash fresco
+  arquivos.push({ ...ent, sha256: sha256(dest), generated: ent.generated || undefined });
+}
+for (const g of GERADOS) {
+  if (!fs.existsSync(g.dest)) continue;
+  arquivos.push({ rel: path.relative(IRON_DIR, g.dest).split(path.sep).join('/'), dest: g.dest, sha256: sha256(g.dest), generated: true });
+}
+
+const novoMan = {
+  ...man,
+  updated_at: new Date().toISOString(),
+  previous_installed_at: man.installed_at,
+  files: arquivos,
+};
+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');
+log('================================');
+log('Confira quando quiser: npx iron-edge verify');
+log('Reabra o Claude Code para carregar o que mudou.');
+log('');