iron-edge 1.2.0 → 2.0.0

package/installer/install.js

@@ -0,0 +1,518 @@
+#!/usr/bin/env node
+/**
+ * Iron Edge - Instalador assistido (install.js)
+ * Cross-platform (Mac + Windows via Node).
+ * v3 - com os 7 patches obrigatorios da auditoria operacional do Codex.
+ *
+ * Principios:
+ *  - NUNCA sobrescreve. Aborta se qualquer destino-alvo ja existe.
+ *  - Aborta em symlink/junction/reparse no destino (defesa dupla: lstat + realpath).
+ *  - Aborta se ancestral existe e NAO e diretorio.
+ *  - Anti-escape: cada destino tem que ficar dentro de ~/.iron ou ~/.claude.
+ *  - Payload E arquivos gerados passam pelas MESMAS validacoes (unificado).
+ *  - Bloqueia --source perigoso (HOME, ~/.iron, ~/.claude).
+ *  - Rejeita backslash em nomes do payload (compat Windows).
+ *  - Preflight completo ANTES de qualquer escrita. Sem update/uninstall.
+ *  - Manifesto com SHA-256 (gerados marcados generated:true).
+ *  - shopify.yaml nasce desativado. config em branco (sem PII).
+ *
+ * Uso: node install.js [--dry-run] [--source <dir>]
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+
+// identidade da edicao: vem do edition.json do payload (gerado pelo build);
+// os valores abaixo sao so fallback pra payload antigo sem o arquivo
+let IRON_VERSION = 'iron-edge-2.x';
+let IRON_VERSION_HUMAN = 'Iron Edge';
+
+function log(msg) { process.stdout.write(msg + '\n'); }
+function abort(msg) {
+  process.stderr.write('\n[ABORTADO] ' + msg + '\n');
+  process.exit(1);
+}
+
+const args = process.argv.slice(2);
+const DRY_RUN = args.includes('--dry-run');
+const srcIdx = args.indexOf('--source');
+let SOURCE = srcIdx >= 0 && args[srcIdx + 1] ? path.resolve(args[srcIdx + 1]) : __dirname;
+// Opera sobre o caminho FISICO: ancestral symlink herdado da maquina (perfil
+// corporativo redirecionado, /tmp do macOS) nao e ataque - e o chao em que o
+// aluno pisa. A defesa que importa (link DENTRO do payload ou dos destinos,
+// redirecionando escrita) continua nas checagens abaixo, agora fisico x fisico.
+try { SOURCE = fs.realpathSync.native(SOURCE); } catch (_) { /* preflight decide */ }
+try {
+  const ed = JSON.parse(fs.readFileSync(path.join(SOURCE, 'edition.json'), 'utf8'));
+  if (ed.label) IRON_VERSION_HUMAN = ed.label + ' v' + (ed.version || '');
+  if (ed.name) IRON_VERSION = ed.name + '-' + (ed.version || '');
+} catch (_) { /* payload sem edition.json: fica o fallback */ }
+
+let HOME = os.homedir();
+try { HOME = fs.realpathSync.native(HOME); } catch (_) {}
+const IRON_DIR = path.join(HOME, '.iron');
+const CLAUDE_DIR = path.join(HOME, '.claude');
+const AGENTS_DEST = path.join(CLAUDE_DIR, 'agents');
+const SKILLS_DEST = path.join(CLAUDE_DIR, 'skills');
+
+const ALLOWED_ROOTS = [IRON_DIR, AGENTS_DEST, SKILLS_DEST];
+
+const WIN_RESERVED = new Set([
+  'CON','PRN','AUX','NUL',
+  'COM1','COM2','COM3','COM4','COM5','COM6','COM7','COM8','COM9',
+  'LPT1','LPT2','LPT3','LPT4','LPT5','LPT6','LPT7','LPT8','LPT9'
+]);
+const WIN_INVALID_CHARS = /[<>:"|?*\x00-\x1f]/;
+
+function hasInvalidWindowsName(relPath) {
+  const parts = relPath.split(/[\\/]/).filter(Boolean);
+  for (const p of parts) {
+    if (WIN_INVALID_CHARS.test(p)) return `caractere invalido em "${p}"`;
+    if (p.endsWith('.') || p.endsWith(' ')) return `termina em ponto/espaco: "${p}"`;
+    const base = p.split('.')[0].toUpperCase();
+    if (WIN_RESERVED.has(base)) return `nome reservado do Windows: "${p}"`;
+  }
+  return null;
+}
+
+function isInsideAllowedRoot(dest) {
+  for (const root of ALLOWED_ROOTS) {
+    const rel = path.relative(root, dest);
+    if (rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel))) return true;
+  }
+  return false;
+}
+
+// PATCH 1+3: defesa dupla contra symlink/junction/reparse + ancestral nao-diretorio
+// retorna string de motivo se o caminho for "indireto", senao null
+function indirectPathReason(p) {
+  let st = null;
+  try { st = fs.lstatSync(p); } catch (e) { return null; } // nao existe = ok
+  if (st.isSymbolicLink()) return 'symlink';
+  try {
+    const real = fs.realpathSync.native(p);
+    const expected = path.resolve(p);
+    if (path.normalize(real).toLowerCase() !== path.normalize(expected).toLowerCase()) {
+      return 'caminho indireto (junction/reparse) real=' + real;
+    }
+  } catch (e) { /* deixa o resto do preflight decidir */ }
+  return null;
+}
+
+function walk(dir, baseDir, out) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const e of entries) {
+    const full = path.join(dir, e.name);
+    if (e.isSymbolicLink()) abort(`o payload contem um symlink (nao permitido): ${path.relative(baseDir, full)}`);
+    if (e.isDirectory()) walk(full, baseDir, out);
+    else if (e.isFile()) out.push(path.relative(baseDir, full));
+  }
+  return out;
+}
+
+function sha256(file) {
+  return crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+}
+
+function destFor(rel) {
+  const norm = rel.split(path.sep).join('/');
+  if (norm === 'iron-routing-map.md') return path.join(IRON_DIR, 'iron-routing-map.md');
+  if (norm === 'BUILD-REPORT.md') return path.join(IRON_DIR, 'BUILD-REPORT.md');
+  if (norm === 'edition.json') return path.join(IRON_DIR, 'edition.json');
+  if (norm.startsWith('agents/')) return path.join(AGENTS_DEST, norm.slice('agents/'.length));
+  if (norm.startsWith('skills/')) return path.join(SKILLS_DEST, norm.slice('skills/'.length));
+  if (norm.startsWith('squads/')) return path.join(IRON_DIR, norm.slice('squads/'.length));
+  // docs/ vai pra maquina DENTRO do manifesto, com hash como todo o resto: sem
+  // isso o `verify` passaria a mentir. Ate 22/08 o destFor devolvia null aqui e o
+  // instalador descartava a documentacao em silencio — quem instalava recebia os
+  // agentes e nunca o runbook que ensina a usa-los.
+  if (norm.startsWith('docs/')) {
+    // ⛔ interno/ e historico/ NUNCA vao pra maquina de ninguem: carregam nome de
+    // pessoa, de cliente e nota de processo da casa. O `files` do package.json ja
+    // os exclui do tarball npm, mas o instalador tambem roda a partir do repo e de
+    // zip de edicao — a guarda tem que estar NOS DOIS, senao depende de qual
+    // caminho a pessoa usou. (Defeito criado pela propria correcao de 22/08 que
+    // fez o instalador copiar docs/, e pego antes da reauditoria.)
+    if (/^docs\/(interno|historico)\//.test(norm)) return null;
+    return path.join(IRON_DIR, norm);
+  }
+  return null;
+}
+
+log('================================');
+log('  Iron Edge - Instalador');
+log('================================');
+log('Versao : ' + IRON_VERSION_HUMAN);
+log('Origem : ' + SOURCE);
+log('HOME   : ' + HOME);
+log('Destino ~/.iron   : ' + IRON_DIR);
+log('Destino ~/.claude : ' + CLAUDE_DIR);
+if (DRY_RUN) log('\nMODO: DRY-RUN (nada sera copiado)\n');
+
+// PATCH 5: bloquear SOURCE perigoso (HOME, dentro de ~/.iron ou ~/.claude)
+function isInsideOrEqual(child, parent) {
+  const rel = path.relative(parent, child);
+  return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
+}
+if (isInsideOrEqual(SOURCE, HOME) && (SOURCE === HOME || isInsideOrEqual(SOURCE, IRON_DIR) || isInsideOrEqual(SOURCE, CLAUDE_DIR))) {
+  abort(`--source perigoso: "${SOURCE}" esta dentro de HOME/.iron/.claude. Use o payload fora dessas pastas.`);
+}
+
+// AJUSTE 1 (Codex): o proprio SOURCE nao pode ser symlink/junction/reparse, e tem que ser diretorio real
+{
+  const srcReason = indirectPathReason(SOURCE);
+  if (srcReason) abort(`a pasta de origem (--source) e um caminho indireto (${srcReason}): ${SOURCE}`);
+  let srcStat = null;
+  try { srcStat = fs.lstatSync(SOURCE); } catch (e) { abort(`pasta de origem nao existe: ${SOURCE}`); }
+  if (!srcStat.isDirectory()) abort(`a origem (--source) nao e um diretorio: ${SOURCE}`);
+}
+
+for (const must of ['agents', 'iron-routing-map.md']) {
+  if (!fs.existsSync(path.join(SOURCE, must))) abort(`origem invalida: faltou "${must}" em ${SOURCE}`);
+}
+
+const allFiles = walk(SOURCE, SOURCE, []);
+
+// monta o plano do payload
+const payloadPlan = [];
+for (const rel of allFiles) {
+  // PATCH 6 (corrigido p/ Windows): rejeitar backslash REAL no nome, sem confundir com o separador do Windows
+  const relPosix = rel.split(path.sep).join('/');
+  if (relPosix.includes('\\')) abort(`nome de arquivo do payload contem backslash real no nome (invalido): ${relPosix}`);
+  const dest = destFor(rel);
+  if (!dest) continue;
+  payloadPlan.push({ rel, src: path.join(SOURCE, rel), dest, generated: false });
+}
+
+// PATCH 2+4+7: arquivos GERADOS entram como destinos de primeira classe, com as MESMAS validacoes
+const GENERATED = [
+  { rel: '(gerado) config.yaml', dest: path.join(IRON_DIR, 'config.yaml'), generated: true },
+  { rel: '(gerado) metadata.json', dest: path.join(IRON_DIR, 'metadata.json'), generated: true },
+  { rel: '(gerado) install-manifest.json', dest: path.join(IRON_DIR, 'install-manifest.json'), generated: true },
+  { rel: '(gerado) integrations/shopify.yaml', dest: path.join(IRON_DIR, 'integrations', 'shopify.yaml'), generated: true }
+];
+
+// LISTA UNIFICADA de todos os destinos (payload + gerados) - PATCH 1
+const allItems = payloadPlan.concat(GENERATED);
+
+// validacao unificada: anti-escape, nome Windows, colisao (payload x gerados juntos) - PATCH 2+4
+const lowerSeen = new Map();
+let totalBytes = 0;
+for (const item of allItems) {
+  if (!isInsideAllowedRoot(item.dest)) abort(`destino escaparia do root permitido (${item.rel}) -> ${item.dest}`);
+  const bad = hasInvalidWindowsName(path.relative(HOME, item.dest));
+  if (bad) abort(`nome invalido para Windows (${item.rel}): ${bad}`);
+  const lk = item.dest.toLowerCase();
+  if (lowerSeen.has(lk)) abort(`colisao case-insensitive: "${item.rel}" e "${lowerSeen.get(lk)}" -> mesmo destino`);
+  lowerSeen.set(lk, item.rel);
+  if (!item.generated) {
+    try { totalBytes += fs.statSync(item.src).size; } catch (e) {}
+  }
+}
+
+if (payloadPlan.length === 0) abort('nada para instalar (plano vazio).');
+
+log(`Arquivos a instalar: ${payloadPlan.length} (+ ${GENERATED.length} gerados)`);
+log(`Tamanho total do payload: ${(totalBytes / 1024).toFixed(1)} KB`);
+
+// PREFLIGHT unificado - todos os destinos (payload + gerados)
+log('\n--- PREFLIGHT (verificando destinos) ---');
+const conflicts = [];
+const checkedAncestors = new Map(); // AJUSTE 2 (Codex): cache por diretorio
+
+for (const item of allItems) {
+  const dest = item.dest;
+  // existe?
+  let st = null;
+  try { st = fs.lstatSync(dest); } catch (e) {}
+  if (st) conflicts.push((st.isSymbolicLink() ? 'SYMLINK' : 'JA EXISTE') + ': ' + dest);
+
+  // ancestrais: indireto (symlink/junction) OU existe e nao e diretorio - PATCH 3 + cache
+  // (usa isInsideOrEqual em vez de startsWith textual, p/ evitar falso positivo entre homes com prefixo comum)
+  let dir = path.dirname(dest);
+  while (isInsideOrEqual(dir, HOME) && dir !== HOME) {
+    if (checkedAncestors.has(dir)) {
+      const cached = checkedAncestors.get(dir);
+      if (cached) { conflicts.push(cached); break; }
+      dir = path.dirname(dir);
+      continue;
+    }
+    const reason = indirectPathReason(dir);
+    if (reason) {
+      const msg = `ANCESTRAL INDIRETO (${reason}): ${dir}`;
+      checkedAncestors.set(dir, msg);
+      conflicts.push(msg); break;
+    }
+    // ancestral existe mas nao e diretorio?
+    let notDir = null;
+    try {
+      const dst = fs.lstatSync(dir);
+      if (!dst.isDirectory() && !dst.isSymbolicLink()) {
+        notDir = `ANCESTRAL NAO E DIRETORIO: ${dir}`;
+      }
+    } catch (e) { /* nao existe = ok */ }
+    if (notDir) {
+      checkedAncestors.set(dir, notDir);
+      conflicts.push(notDir); break;
+    }
+    checkedAncestors.set(dir, null); // checado e limpo
+    dir = path.dirname(dir);
+  }
+}
+
+if (conflicts.length > 0) {
+  // dedup (ancestrais repetidos entre muitos arquivos)
+  const uniq = [...new Set(conflicts)];
+  log(`  Encontrados ${uniq.length} conflito(s) unico(s); mostrando primeiros 20:`);
+  for (const c of uniq.slice(0, 20)) log('  ' + c);
+  if (uniq.length > 20) log(`  ... e mais ${uniq.length - 20}`);
+  abort(`${uniq.length} conflito(s) no preflight. O instalador NUNCA sobrescreve.
+
+Se esta maquina JA TEM uma instalacao do Iron Edge, isso e esperado: esta versao
+nao instala por cima, para nada seu ser perdido.
+
+Como resolver sozinho, sem depender de ninguem:
+  1. COPIE o manifesto para fora ANTES de apagar qualquer coisa (a lista do que
+     remover mora dentro da pasta que vai sumir):
+         cp ~/.iron/install-manifest.json ./iron-manifest.json
+  2. Nessa copia, o campo "files" e a lista exata do que veio no pacote.
+     O que NAO estiver la foi voce que criou.
+  3. Guarde o que for seu (agente proprio, skill propria, o que voce editou).
+     "npx iron-edge verify" mostra o que voce alterou em relacao ao manifesto.
+  4. Apague em ~/.claude/agents e ~/.claude/skills SO os arquivos que estao na
+     lista. Depois, POR ULTIMO, apague a pasta ~/.iron inteira.
+  5. Rode a instalacao de novo.
+
+Se os conflitos acima NAO batem com uma instalacao que voce reconhece, pode ser
+sobra de uma instalacao que falhou no meio. Nesse caso os arquivos listados sao
+lixo e podem ser removidos.`);
+}
+log('  OK - nenhum destino existe, nenhum caminho indireto, nenhum ancestral invalido.');
+
+if (DRY_RUN) {
+  log('\n--- PLANO (dry-run) ---');
+  for (const item of payloadPlan.slice(0, 10)) log(`  ${item.rel}  ->  ${item.dest}`);
+  if (payloadPlan.length > 10) log(`  ... e mais ${payloadPlan.length - 10} arquivos`);
+  log('\n--- arquivos que SERAO gerados ---');
+  for (const g of GENERATED) log('  ' + g.dest);
+  log('\nDRY-RUN concluido. Nada foi copiado.');
+  process.exit(0);
+}
+
+// COPIAR (so chega aqui se TUDO passou)
+//
+// ATOMICO por rollback: se a copia falhar no meio (disco cheio, permissao,
+// arquivo travado por sync), desfazer o que ESTA execucao criou e abortar com
+// mensagem padronizada. Sem isso, um crash aqui deixava arquivos orfaos no HOME
+// e a tentativa seguinte os lia como "ja existe uma instalacao", mandando a
+// pessoa pedir um runbook de migracao que nao se aplica (gate de 22/08/2026).
+//
+// ⛔ O rollback so remove o que esta execucao criou, item por item, pela lista
+// que ele mesmo montou — NUNCA por pasta e NUNCA por padrao. O preflight ja
+// garantiu que nenhum desses destinos existia antes, entao nada do usuario pode
+// estar ali. Rollback que apaga demais e pior que o defeito que ele conserta.
+log('\n--- INSTALANDO ---');
+const manifest = [];
+const criados = [];
+const pastasCriadas = [];
+// registra so as pastas que ESTA execucao criou de fato — mkdirSync recursive nao
+// diz quais niveis eram novos, entao subimos a arvore ate achar uma que ja existia.
+const marcarPastas = (dir) => {
+  const novas = [];
+  let d = dir;
+  while (d && d !== path.dirname(d) && !fs.existsSync(d)) { novas.unshift(d); d = path.dirname(d); }
+  for (const n of novas) if (!pastasCriadas.includes(n)) pastasCriadas.push(n);
+};
+
+const rollback = (motivo) => {
+  log('\n[ABORTADO] ' + motivo);
+  log(`Desfazendo: ${criados.length} arquivo(s) e ${pastasCriadas.length} pasta(s) criados nesta execucao.`);
+  let removidos = 0, nuncaExistiu = 0, falhas = 0;
+  for (const f of criados.reverse()) {
+    try { fs.unlinkSync(f); removidos++; }
+    catch (e) {
+      // ENOENT = o destino entrou na lista antes da escrita e a escrita nunca chegou
+      // a criar o arquivo. Nao e' falha de remocao, e contar como tal fazia o
+      // instalador pedir "confira os que sobraram" por um arquivo que nunca existiu.
+      if (e.code === 'ENOENT') nuncaExistiu++; else falhas++;
+    }
+  }
+  // pastas por ultimo, da mais funda pra mais rasa, e so se vazias.
+  // rmdir NAO e' recursivo de proposito: se sobrou algo dentro, e' porque nao era
+  // desta execucao, e o rollback nao toca no que nao criou.
+  let pastasRemovidas = 0, pastasMantidas = 0;
+  for (const d of pastasCriadas.slice().reverse()) {
+    try { fs.rmdirSync(d); pastasRemovidas++; }
+    catch (e) { if (e.code !== 'ENOENT') pastasMantidas++; }
+  }
+  log(`  arquivos removidos: ${removidos}${falhas ? ' | nao removidos: ' + falhas : ''}`);
+  log(`  pastas removidas: ${pastasRemovidas}${pastasMantidas ? ' | mantidas (nao vazias): ' + pastasMantidas : ''}`);
+  // ⚠️ So diz que voltou ao estado anterior se voltou MESMO. Ate 24/08 dizia sempre,
+  // e deixava 165 pastas vazias no disco — falha em silencio na propria alegacao.
+  if (falhas || pastasMantidas) log('  A maquina NAO voltou inteira ao estado anterior. Confira o que sobrou antes de instalar de novo.');
+  else log('  A maquina voltou ao estado anterior. Pode tentar de novo.');
+  process.exit(1);
+};
+
+// ─── UM PORTAO SO PARA TODA ESCRITA ──────────────────────────────────────────
+//
+// Historico, porque explica a forma deste bloco: a atomicidade foi remendada
+// TRES vezes e o buraco reapareceu tres vezes, sempre alguns metros adiante —
+// primeiro o laco de copia ficou protegido e as pastas de estado nao; depois as
+// pastas entraram e a config ficou fora; depois a config entrou e as duas ultimas
+// escritas (metadata.json e install-manifest.json) ficaram descobertas. Com
+// `ulimit -f`, o manifesto final estourava, o rollback nunca rodava, e 2126
+// arquivos ficavam orfaos com uma mensagem dizendo que a maquina "ja tinha uma
+// instalacao".
+//
+// A causa nao era o ponto: era a FORMA. Try/catch por trecho protege o trecho que
+// alguem lembrou de embrulhar, e a proxima escrita que entrar no meio nasce
+// desprotegida. Entao agora existe UMA porta: nada e' escrito no disco fora de
+// `escrever()` e `criarPasta()`. Qualquer escrita nova, de qualquer autor, ja
+// nasce dentro do rollback — nao por disciplina de quem edita, por construcao.
+//
+// ⛔ O rollback so remove o que ESTA execucao criou, item por item, pela lista que
+// ele mesmo montou — nunca por pasta, nunca por padrao. O preflight ja garantiu
+// que nenhum destino existia antes, entao nada do usuario pode estar ali. Pasta
+// pre-existente nao entra na lista e nao e' tocada.
+//
+// ⚠️ O destino entra na lista ANTES da escrita, nao depois. Parece detalhe e nao e':
+// `writeFileSync` que estoura no meio (disco cheio, quota) ja CRIOU o arquivo, com
+// conteudo truncado. Se o registro so acontecesse no sucesso, esse arquivo ficava
+// fora da lista e sobrevivia ao rollback — medido: 200KB de manifesto pela metade
+// sobrando num HOME que devia ter voltado ao estado anterior. Registrar antes cobre
+// o caso; registrar um destino que nunca chegou a existir e' inofensivo, porque o
+// rollback ignora o que nao consegue remover.
+const escrever = (destino, conteudo, oQueE) => {
+  try {
+    marcarPastas(path.dirname(destino));
+    fs.mkdirSync(path.dirname(destino), { recursive: true });
+    criados.push(destino);
+    fs.writeFileSync(destino, conteudo);
+  } catch (e) { rollback(`falhou ao escrever ${oQueE}: ${e.code || e.message}`); }
+};
+const copiar = (origem, destino, oQueE) => {
+  try {
+    marcarPastas(path.dirname(destino));
+    fs.mkdirSync(path.dirname(destino), { recursive: true });
+    criados.push(destino);
+    fs.copyFileSync(origem, destino);
+  } catch (e) { rollback(`falhou ao escrever ${oQueE}: ${e.code || e.message}`); }
+};
+const criarPasta = (dir, oQueE) => {
+  try { marcarPastas(dir); fs.mkdirSync(dir, { recursive: true }); }
+  catch (e) { rollback(`falhou ao preparar ${oQueE}: ${e.code || e.message}`); }
+};
+// ─────────────────────────────────────────────────────────────────────────────
+
+for (const item of payloadPlan) {
+  copiar(item.src, item.dest, item.rel);
+  manifest.push({ rel: item.rel.split(path.sep).join('/'), dest: item.dest, sha256: sha256(item.dest), generated: false });
+}
+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');
+}
+
+// memoria por cargo do squad-engineering: pasta vazia, FORA do manifesto de propósito.
+// O que a maquina aprendeu nao e gerenciado pelo instalador — update de pacote nunca apaga.
+// Cada arquivo <cargo>.md nasce do template na primeira vez que o cargo roda.
+criarPasta(path.join(IRON_DIR, 'memory', 'squad-engineering'), 'a pasta de memoria');
+
+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 config (gerado na instalacao, em branco)',
+  'owner: ""',
+  'businesses: []',
+  '# focus: dev        # prioriza o iron-eng (engenharia de software) no roteamento.',
+  '#                   # a skill recorte preenche este campo; deixe comentado ate escolher.',
+  ''
+].join('\n'), 'a config inicial');
+
+const installedAt = new Date().toISOString();
+
+// PATCH 7: gerados entram no manifesto com generated:true
+function addGenerated(p) {
+  if (fs.existsSync(p)) manifest.push({ rel: path.relative(IRON_DIR, p), dest: p, sha256: sha256(p), generated: true });
+}
+
+const installManifest = {
+  product: 'iron-edge',
+  version: IRON_VERSION,
+  label: IRON_VERSION_HUMAN,
+  installed_at: installedAt,
+  platform: process.platform,
+  node: process.version,
+  home: HOME,
+  scopes: { iron_root: IRON_DIR, claude_agents: AGENTS_DEST, claude_skills: SKILLS_DEST },
+  files: manifest // sera reescrito abaixo ja com os gerados
+};
+
+// adiciona shopify + config no manifesto antes de gravar o manifesto em si
+addGenerated(shopifyYaml);
+addGenerated(configYaml);
+
+const metadataPath = path.join(IRON_DIR, 'metadata.json');
+escrever(metadataPath,
+  JSON.stringify({ version: IRON_VERSION, label: IRON_VERSION_HUMAN, installed_at: installedAt, platform: process.platform }, null, 2),
+  'o metadata');
+addGenerated(metadataPath);
+
+// grava o manifesto por ultimo (inclui tudo, menos o proprio manifesto que e auto-referente)
+const manifestPath = path.join(IRON_DIR, 'install-manifest.json');
+installManifest.files = manifest;
+escrever(manifestPath, JSON.stringify(installManifest, null, 2), 'o manifesto da instalacao');
+
+// VALIDACAO POS-INSTALL
+log('\n--- VALIDACAO POS-INSTALL ---');
+let errs = 0;
+
+const routingDest = path.join(IRON_DIR, 'iron-routing-map.md');
+if (!fs.existsSync(routingDest)) { log('  ERRO: routing-map nao chegou em ~/.iron/'); errs++; }
+else log('  OK: iron-routing-map.md em ~/.iron/');
+
+// hashes dos arquivos do payload
+let hashOk = 0;
+const payloadManifest = manifest.filter(f => !f.generated);
+for (const f of payloadManifest) {
+  if (fs.existsSync(f.dest) && sha256(f.dest) === f.sha256) hashOk++;
+  else { log(`  ERRO de hash: ${f.dest}`); errs++; }
+}
+log(`  OK: ${hashOk}/${payloadManifest.length} hashes de payload conferidos`);
+
+// PATCH 7: validar os arquivos GERADOS no pos-install
+for (const gp of [shopifyYaml, configYaml, metadataPath, manifestPath]) {
+  if (!fs.existsSync(gp)) { log(`  ERRO: gerado ausente: ${gp}`); errs++; }
+}
+if (/enabled:\s*false/.test(fs.readFileSync(shopifyYaml, 'utf8'))) log('  OK: shopify.yaml com enabled: false');
+else { log('  ERRO: shopify.yaml nao esta desativado'); errs++; }
+try { JSON.parse(fs.readFileSync(manifestPath, 'utf8')); log('  OK: install-manifest.json e JSON valido'); }
+catch (e) { log('  ERRO: install-manifest.json invalido'); errs++; }
+try { JSON.parse(fs.readFileSync(metadataPath, 'utf8')); log('  OK: metadata.json e JSON valido'); }
+catch (e) { log('  ERRO: metadata.json invalido'); errs++; }
+
+if (errs > 0) abort(`instalacao com ${errs} erro(s) de validacao.`);
+
+log('\n================================');
+log('  Iron Edge instalado com sucesso');
+log('================================');
+log(`Agentes : ${AGENTS_DEST}`);
+log(`Skills  : ${SKILLS_DEST}`);
+log(`Nucleo  : ${IRON_DIR}`);
+log(`Manifesto: ${manifestPath}`);
+log('\n--------------------------------');
+log('  PROXIMO PASSO');
+log('--------------------------------');
+log('1. Reabra o Claude Code (pra ele carregar os novos agentes).');
+log('2. Comece pelo iron-ceo: peca algo como');
+log('     "ative o iron-ceo" ou "chame o iron-ceo".');
+log('3. Se o iron-ceo responder com a saudacao, esta funcionando.');
+log('');