iron-edge 2.4.2 → 2.4.4

package/README.md

@@ -167,6 +167,13 @@ Instalada junto. Depois de `npx iron-edge install`, os dois arquivos abaixo est
 ```bash
 # Conferir a instalação: o que é seu, o que está diferente sem registro, o que sumiu
 npx iron-edge verify
+
+# Medir a máquina (Node, git, Claude Code, Iron Edge, chave, plugin, cofre). Com a chave do
+# Iron Office aceita, o resultado acende o checklist da página de Setup do site.
+npx iron-edge doctor
+
+# Instalar já criando um cofre vazio em ~/Iron Cofre (pronto pro Obsidian, nunca sobrescreve)
+npx iron-edge install --cofre
 ```
 
 **Atualizar é um comando. Remover é operação conduzida.**
@@ -257,13 +264,13 @@ O Iron Edge instala uma equipe de agentes especializados diretamente no Claude C
 Seus dados ficam locais em `~/.iron/`. Sobre o que sai da sua máquina, com precisão:
 
 - **Para o Iron Office** (`iron-office.vercel.app`, servidor deste projeto), e só se você criar a chave em `~/.claude/iron-office-api-key`:
-  - dados de apenas **1 agente**, `iron-shopify` (o `iron-auditor` devolve o relatório pra quem chamou e não envia nada sozinho desde a 2.4.2). Confira: `grep -rln "iron-office" ~/.claude/agents/`;
+  - **0 agentes** leem a chave. Só o plugin `iron-office` fala com o site, e a loja Shopify é consultada pelas ferramentas `shop_status`/`shop_query` dele (desde a 2.4.4; o `iron-auditor` devolve o relatório pra quem chamou desde a 2.4.2). Confira: `grep -rln "iron-office-api-key" ~/.claude/agents/`;
   - **se você rodou `npx iron-edge office`**, o plugin `iron-office` fica instalado e manda pro seu painel (feed e mapa 3D) a atividade **só da sessão aberta pelo `npx iron-edge office`** (desde o plugin 0.3.1; um `claude` aberto em outra pasta não manda nada), e as entregas que o Iron salvar ali pela ferramenta `deliver`. Da atividade vai: nome da ferramenta, caminho do arquivo (nunca o conteúdo), os primeiros 200 caracteres de cada comando de terminal e a descrição dele, buscas, o domínio dos endereços visitados, nome e descrição dos agentes, a pasta e o identificador da sessão. A resposta das ferramentas nunca sai. Padrões conhecidos de segredo nesses campos (chaves de Stripe, Shopify, Meta, GitHub, OpenAI, Supabase e AWS, `Bearer`, `ALGO_KEY=`, `--password`, `-u usuario:senha`…) são apagados antes do envio; é uma lista de padrões, não garantia. Lista completa no README do plugin (github.com/filipecoff21-code/iron-office-channel). Desligar: `claude plugin disable iron-office@iron-office-channel`. Conferir se está ligado: `claude plugin list`.
 - **Para a internet aberta**, através das ferramentas do próprio Claude Code (`WebSearch` / `WebFetch`), vão as buscas de **41 dos 44 agentes** — é como o `iron-research` pesquisa mercado e o `iron-spy` lê a biblioteca de anúncios. Isso passa pelo Claude Code, com a visibilidade e a aprovação que ele te dá; não é canal deste pacote. Confira: `grep -rln "WebSearch\|WebFetch" ~/.claude/agents/`.
 - **A skill `clone-site`** baixa a URL que você mandar clonar. É o trabalho dela.
 
 
-Sendo exato sobre a força dessa garantia, porque ela não é um sandbox: cada bloco que chama o Iron Office começa com uma guarda (`[ -z "$IRON_KEY" ] && exit 0`) e a regra R20 do lint impede que qualquer bloco novo entre sem ela. Mas esses arquivos são **instruções lidas por um modelo**, não um binário fechado: um agente que execute só a linha do `curl`, isolada da guarda, não é barrado por nada aqui. Se o que você quer é garantia dura, a que existe é não criar o arquivo de chave — sem ele, não há para onde enviar, e todo bloco para na guarda (o plugin `iron-office` também: sem a chave, ele não envia nada).
+Sendo exato sobre a força dessa garantia, porque ela não é um sandbox: nenhum agente nem skill do pacote lê a chave (a regra R25 do lint barra quem voltar a ler), e se algum bloco novo chamar o Iron Office a regra R20 exige a guarda (`[ -z "$IRON_KEY" ] && exit 0`) antes. Mas esses arquivos são **instruções lidas por um modelo**, não um binário fechado: o que segura de verdade é o modelo seguir o texto. Se o que você quer é garantia dura, a que existe é não criar o arquivo de chave — sem ele, não há para onde enviar, e todo bloco para na guarda (o plugin `iron-office` também: sem a chave, ele não envia nada).
 
 ---
 

package/agents/iron-auditor.md

@@ -22,6 +22,8 @@ Quando ativado com uma URL:
 
 ### STEP 1 — Captura de screenshots
 
+O pedido pode trazer `dono=sim` ou `dono=nao` (o site é do aluno ou de terceiro). Sem o campo, considere `dono=sim`. Guarde: ele decide a ação de cada item do cartão (STEP 4).
+
 Execute este script Playwright via Bash:
 
 ```bash
@@ -109,6 +111,35 @@ Data: [hoje]
 - lp-cinematico: [se LP precisar reconstrução]
 ```
 
+O relatório SEMPRE termina com o cartão de ação: o título `## Cartão` seguido de um bloco ```json neste formato (é o que o Iron Office mostra no chat; o relatório longo fica guardado como "ver relatório completo"):
+
+```json
+{
+  "kind": "auditoria",
+  "owner": true,
+  "score": 6.5,
+  "summary": "a frase do diagnóstico, até 160 caracteres",
+  "items": [
+    {
+      "title": "o problema, até 80 caracteres",
+      "why": "por que importa, em dinheiro ou cliente perdido, até 160",
+      "effort": "tempo pra corrigir, até 40 (ex.: 15 min · 1 h · 1 tarde)",
+      "action": "Iron, corrige isso em <domínio>: <o problema, com o que fazer>"
+    }
+  ]
+}
+```
+
+Regras do cartão:
+- `score` = o Score Geral; `summary` = a frase do diagnóstico.
+- `items` = os 3 issues mais altos, no máximo 3 (🔴 antes de 🟠).
+- `why` sempre em dinheiro ou cliente perdido, nunca "melhora a experiência".
+- `owner` = `true` com `dono=sim`, `false` com `dono=nao`.
+- `action` é o pedido que o aluno manda com um clique, até 300 caracteres. Em site de terceiro ele não pode corrigir, então a ação é a mensagem:
+  - `dono=sim` → começa com "Iron, corrige isso em <domínio>:" seguido do problema e do que fazer.
+  - `dono=nao` → começa com "Iron, escreve a mensagem pro dono de <domínio> sobre:" seguido do problema e de por que importa.
+- O Iron Office descarta item cuja `action` não começa com um desses dois prefixos.
+
 ### STEP 5 — Devolver
 
 Entregue o relatório completo em markdown na sua resposta final. Quem salva é quem te chamou (no Iron Office, o Iron usa a ferramenta `deliver`).

package/agents/iron-shopify.md

@@ -2,7 +2,7 @@
 name: iron-shopify
 description: "Iron Edge — controle total de lojas Shopify. Otimiza produtos, SEO, GEO, imagens, banners, tema, páginas de venda, branding e identidade visual. Gerencia múltiplas lojas com memória persistente. Use para qualquer tarefa relacionada a uma loja Shopify. Puxa em: produto da loja, e-commerce, dropshipping."
 model: sonnet
-tools: [Read, Write, Edit, Bash, Glob, Grep, WebSearch, WebFetch, mcp__shopify-dev-mcp__learn_shopify_api, mcp__shopify-dev-mcp__search_docs_chunks, mcp__shopify-dev-mcp__validate_theme, mcp__shopify-dev-mcp__validate_graphql_codeblocks, mcp__shopify-dev-mcp__validate_component_codeblocks]
+tools: [Read, Write, Edit, Bash, Glob, Grep, WebSearch, WebFetch, mcp__shopify-dev-mcp__learn_shopify_api, mcp__shopify-dev-mcp__search_docs_chunks, mcp__shopify-dev-mcp__validate_theme, mcp__shopify-dev-mcp__validate_graphql_codeblocks, mcp__shopify-dev-mcp__validate_component_codeblocks, mcp__plugin_iron-office_iron-office__shop_status, mcp__plugin_iron-office_iron-office__shop_query]
 ---
 
 # iron-shopify — Controle Total de Lojas Shopify
@@ -15,33 +15,22 @@ Você é um especialista em Shopify com acesso direto às lojas via Shopify CLI
 
 ### Passo 1 — Verificar conexão via Iron Office
 
-Verifique se o Iron Office está configurado:
+Chame a ferramenta `shop_status` (plugin `iron-office`, sem argumentos). Você **nunca** lê a chave do Iron Office nem faz requisição HTTP pro site: quem fala com o Iron Office é só o plugin, que já tem a chave.
 
-```bash
-cat ~/.claude/iron-office-api-key 2>/dev/null
-```
-
-**Se existir a key** → use o Iron Office como fonte de credenciais (preferencial):
+Se ela devolver `{"connected": true, "shopDomain": "..."}` → loja conectada via Iron Office, use a ferramenta `shop_query` para todas as operações GraphQL (ver seção **USANDO O PROXY IRON OFFICE**).
 
-```bash
-IRON_KEY=$(cat ~/.claude/iron-office-api-key 2>/dev/null | tr -d '[:space:]')
-# GUARDA: sem chave, nenhuma requisicao sai. Sustenta a promessa do README.
-[ -z "$IRON_KEY" ] && { echo "Sem iron-office-api-key — nada foi enviado."; exit 0; }
-curl -s -H "x-api-key: $IRON_KEY" https://iron-office.vercel.app/api/shopify/graphql
-```
-
-Se retornar `{"connected": true, "shopDomain": "..."}` → loja conectada via Iron Office, use o proxy para todas as operações GraphQL (ver seção **USANDO O PROXY IRON OFFICE**).
-
-Se retornar `{"connected": false}` → informe:
+Se devolver "Loja não conectada" → informe:
 ```
 🛍️ iron-shopify ativo
 
 Sua loja ainda não está conectada.
-Acesse https://iron-office.vercel.app/config e conecte sua loja Shopify.
+Acesse https://iron-office.vercel.app/integrations e conecte sua loja Shopify.
 Depois me chame novamente.
 ```
 
-**Se NÃO existir a key** → fallback para arquivo local:
+**Se a ferramenta `shop_status` não existir nesta sessão** e o usuário usa o Iron Office → peça pra ele rodar `npx iron-edge office` uma vez (instala o plugin), abrir uma sessão nova e te chamar de novo. Pare aqui.
+
+**Se o usuário não usa o Iron Office** → fallback para arquivo local:
 
 Verifique se existe `~/.iron/shopify-stores.yaml`:
 
@@ -170,47 +159,42 @@ Qual é a missão na [apelido]?
 
 ## USANDO O PROXY IRON OFFICE
 
-Quando conectado via Iron Office, todas as chamadas GraphQL usam o proxy seguro.
-As credenciais ficam no servidor — você nunca precisa manuseá-las localmente.
+Quando conectado via Iron Office, toda chamada GraphQL passa pela ferramenta `shop_query` do plugin `iron-office`.
+As credenciais ficam no servidor e a chave do Iron Office fica com o plugin: você nunca manuseia nenhuma das duas.
 
 **Formato de chamada:**
 
-```bash
-IRON_KEY=$(cat ~/.claude/iron-office-api-key 2>/dev/null | tr -d '[:space:]')
-# GUARDA: sem chave, nenhuma requisicao sai. Sustenta a promessa do README.
-[ -z "$IRON_KEY" ] && { echo "Sem iron-office-api-key — nada foi enviado."; exit 0; }
+```
+shop_query({ query: "{ shop { name email } }" })
+```
+
+Com variáveis:
 
-curl -s -X POST https://iron-office.vercel.app/api/shopify/graphql \
-  -H "Content-Type: application/json" \
-  -H "x-api-key: $IRON_KEY" \
-  -d '{
-    "query": "{ shop { name email } }"
-  }'
+```
+shop_query({
+  query: "query($n: Int!) { products(first: $n) { edges { node { id title } } } }",
+  variables: { n: 10 }
+})
 ```
 
 **Exemplos práticos:**
 
-```bash
-# Cada cerca ```bash e' um bloco INDEPENDENTE: o Claude Code nao guarda estado de shell entre
-# execucoes, entao $IRON_KEY definido num bloco anterior chega VAZIO aqui. A guarda se repete
-# em todo bloco que fala com a rede — sem ela, o curl sairia com a chave em branco.
-IRON_KEY=$(cat ~/.claude/iron-office-api-key 2>/dev/null | tr -d '[:space:]')
-[ -z "$IRON_KEY" ] && { echo "Sem iron-office-api-key — nada foi enviado."; exit 0; }
-
+```
 # Listar produtos com SEO
-curl -s -X POST https://iron-office.vercel.app/api/shopify/graphql \
-  -H "Content-Type: application/json" \
-  -H "x-api-key: $IRON_KEY" \
-  -d '{"query":"{ products(first: 50) { edges { node { id title handle seo { title description } } } } }"}'
+shop_query({ query: "{ products(first: 50) { edges { node { id title handle seo { title description } } } } }" })
 
 # Informações da loja
-curl -s -X POST https://iron-office.vercel.app/api/shopify/graphql \
-  -H "Content-Type: application/json" \
-  -H "x-api-key: $IRON_KEY" \
-  -d '{"query":"{ shop { name email myshopifyDomain plan { displayName } } }"}'
+shop_query({ query: "{ shop { name email myshopifyDomain plan { displayName } } }" })
+
+# Atualizar o SEO de um produto
+shop_query({
+  query: "mutation($input: ProductInput!) { productUpdate(input: $input) { product { id } userErrors { field message } } }",
+  variables: { input: { id: "gid://shopify/Product/123", seo: { title: "...", description: "..." } } }
+})
 ```
 
-Use `jq` para parsear as respostas quando disponível.
+A ferramenta devolve o JSON da Shopify como texto; resposta muito grande vem cortada com aviso (peça menos itens por vez, com `first:` menor).
+
 
 ---
 

package/agents/iron-spy.md

@@ -259,6 +259,28 @@ Após a execução:
 - Perguntar se o usuário quer ajustar as palavras-chave e rodar novamente
 - Oferecer análise mais profunda de algum anúncio específico
 
+Quando quem te chamou é o Iron do Iron Office, não cite o caminho `file://` do dashboard: ele não abre no site. A resposta final leva a tabela dos 10 anúncios mais validados (anunciante · dias no ar · ângulo · gancho) e a análise dos ângulos em markdown, e termina com o `## Cartão`.
+
+Além do dashboard, a resposta final termina com o cartão de ação: o título `## Cartão` seguido de um bloco ```json (é o que o Iron Office mostra no chat):
+
+```json
+{
+  "kind": "spy",
+  "score": null,
+  "summary": "o que o nicho mais usa, até 160 caracteres",
+  "items": [
+    {
+      "title": "o ângulo, até 80 caracteres",
+      "why": "% dos anúncios que usam e dias no ar do mais antigo, até 160",
+      "effort": "1 copy",
+      "action": "Iron, escreve uma copy nesse ângulo: <ângulo>, pro meu produto"
+    }
+  ]
+}
+```
+
+Regras do cartão: `items` = os 3 ângulos mais validados, no máximo 3; `action` cabe em 300 caracteres, é o pedido que o aluno manda com um clique e sempre começa com "Iron, escreve uma copy nesse ângulo" (o Iron Office descarta item com outro começo).
+
 ## Palavras-chave por nicho
 
 Ao gerar as keywords para o scraper, use estas estratégias:

package/bin/iron-edge.js

@@ -17,6 +17,12 @@
  *   office  [--safe]                      liga o Iron Office: instala o plugin de canal e abre o
  *                                         Claude Code conversando com o chat do dashboard
  *
+ *   doctor  [--json]                      mede a maquina (Node, git, Claude Code, Iron Edge, chave,
+ *                                         plugin, cofre) e, com a chave aceita, manda o resultado
+ *                                         pra pagina de Setup do Iron Office
+ *
+ *   install --cofre                       alem do install, cria ~/Iron Cofre/ (cofre vazio pro Obsidian)
+ *
  * Nao existe 'uninstall' automatico: remover continua sendo operacao conduzida, com o
  * manifesto na mao (o README descreve o procedimento).
  */
@@ -155,7 +161,12 @@ if (cmd === 'install') {
   const r = spawnSync(process.execPath, [path.join(__dirname, '..', 'installer', 'office.js'), ...rest], { stdio: 'inherit' });
   process.exit(r.status ?? 1);
 
+} else if (cmd === 'doctor') {
+  // mede a maquina e acende o checklist do Setup no site (installer/doctor.js)
+  const r = spawnSync(process.execPath, [path.join(__dirname, '..', 'installer', 'doctor.js'), ...rest], { stdio: 'inherit' });
+  process.exit(r.status ?? 1);
+
 } else {
-  console.log('uso: iron-edge <install|update|verify|office> [--dry-run] [--source <dir>] [--safe]');
+  console.log('uso: iron-edge <install|update|verify|office|doctor> [--dry-run] [--source <dir>] [--cofre] [--safe] [--json]');
   process.exit(cmd && cmd !== '--help' && cmd !== '-h' ? 1 : 0);
 }

package/installer/cofre/CLAUDE.md

@@ -0,0 +1,33 @@
+# CLAUDE.md — regras do cofre
+
+Este cofre é a memória do Iron. São arquivos `.md` no seu computador: nada sai daqui.
+Você pode abrir a pasta no Obsidian ou em qualquer editor de texto.
+
+## Como o cofre é organizado
+
+```
+Iron Cofre/
+   CLAUDE.md          ← estas regras
+   INDICE.md          ← o mapa: um link pra cada projeto
+   memoria/           ← o diário das sessões (o Iron cria no primeiro "salvar")
+   Projetos/          ← uma pasta por projeto
+   templates/nota.md  ← o modelo de nota
+```
+
+- **Cada projeto** vira uma pasta: `Projetos/<Nome>/PROJETO.md` é a nota principal (o hub), com o estado, as decisões e os próximos passos.
+- **Projeto com várias partes** ganha uma nota por parte (as folhas) na mesma pasta. As folhas apontam só pro hub; o hub aponta pras folhas e pro `INDICE.md`.
+- Toda nota começa com o cabeçalho do `templates/nota.md`: `projeto`, `tipo`, `status` (ativo, pausado ou concluído) e `atualizado` (a data).
+
+## As regras
+
+1. Antes de trabalhar num projeto, leia a nota dele em `Projetos/` pra saber em que pé ele está. Não assuma o estado pela memória da conversa.
+2. Quando o usuário disser "salvar" ou "encerrar", registre a sessão sem perguntar nada.
+3. Diário e nota de projeto são coisas diferentes. O diário responde "o que fizemos hoje"; a nota responde "como o projeto está hoje". Conversa, ideia sem decisão e teste que não concluiu ficam só no diário.
+4. Data sempre absoluta (AAAA-MM-DD). Nunca "ontem", "semana passada" nem "amanhã": daqui a dois meses isso não significa mais nada.
+5. Nunca invente número, nome, versão ou caminho. O que faltar entra como "(a preencher)".
+6. Projeto de cliente pode ficar aqui (o que foi feito, o que foi decidido, o que falta). O que não fica: material confidencial de cliente ou empregador (contrato, planilha interna, dado de cliente), senha, chave nem dado pessoal de quem não autorizou. Se aparecer na conversa, não registre e avise que não registrou.
+
+## O que salvar e o que não salvar
+
+- **Salvar:** o que foi construído e onde está, decisões importantes, status, próximos passos, o que está esperando outra pessoa.
+- **Não salvar:** detalhe técnico que já está no código, conversa genérica, teste que não foi pra frente.

package/installer/cofre/INDICE.md

@@ -0,0 +1,11 @@
+# Índice do cofre
+
+O mapa da sua memória. Cada projeto novo ganha uma linha aqui.
+
+## Projetos
+
+| Projeto | Status | Nota |
+|---|---|---|
+| (nenhum ainda) | | |
+
+Quando começar um projeto, conte ao Iron o que é: ele oferece criar a pasta do projeto e a linha aqui. No fim da conversa, diga "salvar".

package/installer/cofre/templates/nota.md

@@ -0,0 +1,18 @@
+---
+projeto: <nome do projeto>
+tipo: <hub, folha ou nota>
+status: ativo
+atualizado: AAAA-MM-DD
+---
+
+# <Título>
+
+> ← [[INDICE]]
+
+## Em que pé está
+
+## Decisões
+
+## Próximos passos
+
+## Esperando alguém

package/installer/cofre.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+/**
+ * cofre.js — `npx iron-edge install --cofre`: cria um cofre vazio em ~/Iron Cofre/, pronto pro
+ * Obsidian. Roda no fim do install com sucesso (ou sozinho, pra teste).
+ *
+ * Regras:
+ *  - copia os 4 itens de installer/cofre/ SO' se nao existirem. Nunca sobrescreve: o cofre e' do
+ *    aluno, e um segundo `install --cofre` nao pode apagar o que ele ja escreveu.
+ *  - fica FORA do manifesto do pacote (o verify e o update nao encostam nele).
+ *  - grava o caminho no `vault_path` do ~/.iron/config.yaml so' quando nenhum cofre esta apontado. Sem isso
+ *    o Iron nao enxerga o cofre e oferece criar outro. Caminho com barra normal (regra da skill
+ *    salvar, secao 0) e lido de volta antes de declarar.
+ *  - --dry-run so' lista.
+ *
+ * Saida so' em ASCII, como o resto do instalador.
+ */
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const MODELO = path.join(__dirname, 'cofre');
+const ITENS = ['CLAUDE.md', 'INDICE.md', path.join('templates', 'nota.md'), path.join('Projetos', '.gitkeep')];
+const NOME = 'Iron Cofre';
+
+function log(msg) { try { fs.writeSync(1, msg + '\n'); } catch (_) { process.stdout.write(msg + '\n'); } }
+
+function homeReal(home) {
+  let h = home || os.homedir();
+  try { h = fs.realpathSync.native(h); } catch (_) {}
+  return h;
+}
+
+function barraNormal(p) { return p.split(path.sep).join('/'); }
+
+// Grava vault_path no config SO' se ninguem apontou um cofre ainda. Devolve
+// 'gravado' | 'ja-tinha' | 'sem-config' | 'falhou'.
+// "Ninguem apontou" = vault_path ausente, vazio, null ou ~ E sem obsidian_vault_path preenchido
+// (o nome antigo do campo, que o Iron tambem le). Ausente: acrescenta a linha no fim.
+function gravarVaultPath(home, cofre) {
+  const cfg = path.join(home, '.iron', 'config.yaml');
+  let txt;
+  try { txt = fs.readFileSync(cfg, 'utf8'); } catch (_) { return 'sem-config'; }
+  const VAZIO = /^\s*(""|''|null|~)?\s*(#.*)?$/;
+  const campo = (nome) => {
+    const m = txt.match(new RegExp('^' + nome + ':(.*)$', 'm'));
+    return m ? { linha: m[0], valor: m[1] } : null;
+  };
+  const antigo = campo('obsidian_vault_path');
+  if (antigo && !VAZIO.test(antigo.valor)) return 'ja-tinha';
+  const atual = campo('vault_path');
+  if (atual && !VAZIO.test(atual.valor)) return 'ja-tinha';
+  const linha = 'vault_path: "' + barraNormal(cofre) + '"';
+  const novo = atual
+    ? txt.replace(atual.linha, linha)
+    : txt + (txt === '' || txt.endsWith('\n') ? '' : '\n') + linha + '\n';
+  fs.writeFileSync(cfg, novo);
+  const relido = fs.readFileSync(cfg, 'utf8').split(/\r?\n/).find(l => l.startsWith('vault_path:'));
+  return relido === linha ? 'gravado' : 'falhou';
+}
+
+function criarCofre(opts) {
+  const o = opts || {};
+  const home = homeReal(o.home);
+  const destino = path.join(home, NOME);
+  const criados = [], pulados = [];
+  for (const rel of ITENS) {
+    const dest = path.join(destino, rel);
+    if (fs.existsSync(dest)) { pulados.push(dest); continue; }
+    criados.push(dest);
+    if (o.dryRun) continue;
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.copyFileSync(path.join(MODELO, rel), dest);
+  }
+  log('');
+  log('--- cofre (' + destino + ') ---');
+  for (const c of criados) log((o.dryRun ? '  criaria: ' : '  criado:  ') + c);
+  for (const p of pulados) log('  ja existe, nao mexi: ' + p);
+  let vault = 'dry-run';
+  if (!o.dryRun) {
+    vault = gravarVaultPath(home, destino);
+    if (vault === 'gravado') log('  vault_path gravado no ~/.iron/config.yaml: o Iron ja sabe onde o cofre esta');
+    else if (vault === 'ja-tinha') log('  o ~/.iron/config.yaml ja aponta pra um cofre: nao troquei. Pra usar este, diga ao Iron: "usa o Iron Cofre como meu cofre"');
+    else if (vault === 'sem-config') log('  sem ~/.iron/config.yaml: diga ao Iron "usa o Iron Cofre como meu cofre"');
+    else log('  ATENCAO: o vault_path nao ficou gravado certo. Diga ao Iron: "conserta meu vault_path"');
+    log('  Abra a pasta no Obsidian: "Open folder as vault" > ' + destino);
+  }
+  return { destino, criados, pulados, vault };
+}
+
+module.exports = { criarCofre, ITENS, NOME };
+
+if (require.main === module) {
+  criarCofre({ dryRun: process.argv.includes('--dry-run') });
+}

package/installer/doctor.js

@@ -0,0 +1,179 @@
+#!/usr/bin/env node
+/**
+ * doctor.js — `npx iron-edge doctor`: mede a maquina do aluno e manda o resultado pro Iron Office,
+ * pra a pagina de Setup acender cada passo sozinha (o site nao enxerga a maquina).
+ *
+ * Mede: node (>= 20), git, Claude Code, Iron Edge instalado pelo npm (manifesto), chave do Iron
+ * Office (formato + confere com o site), plugin iron-office, cofre (~/Iron Cofre, informativo).
+ *
+ * Envio: SO' com a chave aceita pelo site (ping = ok) faz POST /api/chat/setup-status. Sem chave,
+ * com chave recusada ou sem rede, o resultado fica so' no terminal. Falhar o envio e' aviso, nao erro.
+ * Nao grava nada em disco.
+ *
+ * Saida: uma linha por item, sem acento (console do Windows antigo). --json imprime o JSON cru
+ * (o envio acontece igual).
+ * Exit 0 so' se node, git, claude e iron_edge estao ok (chave e plugin sao passos do site).
+ */
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { spawnSync } = require('child_process');
+const { readKey, keyFileExists, ping, resolveClaude, PLUGIN } = require('./office.js');
+
+const OFFICE_URL = (process.env.IRON_OFFICE_URL || 'https://iron-office.vercel.app').replace(/\/+$/, '');
+const IS_WIN = process.platform === 'win32';
+const POST_TIMEOUT_MS = 15000;
+let VERSION = '';
+try { VERSION = require('../package.json').version || ''; } catch (_) {}
+
+function cut(s, n) { s = String(s == null ? '' : s).replace(/\s+/g, ' ').trim(); return s.length > n ? s.slice(0, n - 1) + '~' : s; }
+function item(ok, detail) { return { ok: !!ok, detail: cut(detail, 120) }; }
+// O detalhe vai COM acento pro site (o aluno le' la'); no terminal sai sem acento (console do
+// Windows antigo mostra lixo em acento). Uma fonte so', duas saidas.
+function ascii(s) { return String(s).normalize('NFD').replace(/[\u0300-\u036f]/g, ''); }
+
+function run(bin, args) {
+  return spawnSync(bin, args, { encoding: 'utf8', shell: IS_WIN, timeout: 20000 });
+}
+
+function homeDir() {
+  let h = os.homedir();
+  try { h = fs.realpathSync.native(h); } catch (_) {}
+  return h;
+}
+
+function checkNode() {
+  const major = Number(process.versions.node.split('.')[0]);
+  return item(major >= 20, major >= 20 ? process.version : process.version + ': precisa da 20 ou maior (nodejs.org)');
+}
+
+function checkGit() {
+  const r = run('git', ['--version']);
+  if (r.error || r.status !== 0) return item(false, 'git não encontrado: instale em git-scm.com');
+  return item(true, (r.stdout || '').trim());
+}
+
+function checkClaude() {
+  const bin = resolveClaude();
+  if (!bin) return { bin: null, check: item(false, 'Claude Code não encontrado: instale em claude.com/claude-code') };
+  const r = run(bin, ['--version']);
+  return { bin, check: item(true, ((r.stdout || '').trim().split('\n')[0]) || 'instalado') };
+}
+
+function checkIronEdge(home) {
+  const man = path.join(home, '.iron', 'install-manifest.json');
+  if (!fs.existsSync(man)) return item(false, 'não instalado pelo npm: rode npx iron-edge install');
+  try {
+    const m = JSON.parse(fs.readFileSync(man, 'utf8'));
+    return item(true, m.version || m.label || 'instalado');
+  } catch (_) {
+    return item(false, 'manifesto ilegível: rode npx iron-edge install');
+  }
+}
+
+async function checkKey(home, baseUrl) {
+  const key = readKey(home);
+  if (!key) {
+    return { key: '', check: item(false, keyFileExists(home) ? 'formato errado: refaça o passo 2 no site' : 'sem chave ainda: faça o passo 2 no site') };
+  }
+  const v = await ping(key, baseUrl);
+  if (v === 'ok') return { key, check: item(true, 'aceita pelo Iron Office') };
+  if (v === 'rejected') return { key: '', check: item(false, 'recusada: a chave foi trocada, refaça o passo 2') };
+  return { key: '', check: item(false, 'sem rede: não deu pra conferir com o site') };
+}
+
+function checkPlugin(claudeBin) {
+  if (!claudeBin) return item(false, 'sem Claude Code');
+  const r = run(claudeBin, ['plugin', 'list']);
+  const out = (r.stdout || '') + (r.stderr || '');
+  if (r.error || r.status !== 0) return item(false, 'não deu pra listar os plugins');
+  return out.includes(PLUGIN) ? item(true, PLUGIN) : item(false, 'falta o plugin: rode npx iron-edge office');
+}
+
+function checkCofre(home) {
+  const ok = fs.existsSync(path.join(home, 'Iron Cofre', 'CLAUDE.md'));
+  return item(ok, ok ? '~/Iron Cofre' : 'sem cofre pronto (opcional: npx iron-edge install --cofre)');
+}
+
+async function medir(opts) {
+  const o = opts || {};
+  const home = o.home || homeDir();
+  const claude = checkClaude();
+  const key = await checkKey(home, o.baseUrl);
+  const result = {
+    os: cut(process.platform + '-' + process.arch, 20),
+    doctor: cut(VERSION, 20),
+    checks: {
+      node: checkNode(),
+      git: checkGit(),
+      claude: claude.check,
+      iron_edge: checkIronEdge(home),
+      key: key.check,
+      plugin: checkPlugin(claude.bin),
+      cofre: checkCofre(home),
+    },
+    ran_at: new Date().toISOString(),
+  };
+  return { result, key: key.key };
+}
+
+// Devolve 'enviado' | 'recusado' (o site respondeu e nao gravou) | 'falhou' (rede).
+async function enviar(result, key, baseUrl) {
+  const url = (baseUrl || OFFICE_URL).replace(/\/+$/, '') + '/api/chat/setup-status';
+  if (typeof fetch !== 'function') return 'falhou';
+  const ctl = new AbortController();
+  const timer = setTimeout(() => ctl.abort(), POST_TIMEOUT_MS);
+  try {
+    const r = await fetch(url, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json', 'x-api-key': key },
+      body: JSON.stringify(result),
+      signal: ctl.signal,
+    });
+    return r.ok ? 'enviado' : 'recusado';
+  } catch (_) {
+    return 'falhou';
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+const ROTULO = { node: 'Node', git: 'git', claude: 'Claude Code', iron_edge: 'Iron Edge', key: 'chave', plugin: 'plugin', cofre: 'cofre' };
+const OBRIGATORIOS = ['node', 'git', 'claude', 'iron_edge'];
+
+async function main(argv, opts) {
+  const o = opts || {};
+  const { result, key } = await medir(o);
+  const exit = OBRIGATORIOS.every(k => result.checks[k].ok) ? 0 : 1;
+  if (argv.includes('--json')) {
+    // mesmo envio, saida so' o JSON (pra teste e pra script)
+    if (key) await enviar(result, key, o.baseUrl);
+    console.log(JSON.stringify(result, null, 2));
+    return exit;
+  }
+  console.log('Iron Edge doctor ' + result.doctor);
+  for (const [k, c] of Object.entries(result.checks)) {
+    console.log('  ' + (c.ok ? '[ok]    ' : (k === 'cofre' ? '[info]  ' : '[falta] ')) + ROTULO[k] + ': ' + ascii(c.detail));
+  }
+  console.log('');
+  if (!key && !readKey(o.home || homeDir())) {
+    console.log("sem chave ainda: o resultado fica so' aqui no terminal; faca o passo 2 no site.");
+  } else if (!key) {
+    console.log("o resultado fica so' aqui no terminal (chave: " + ascii(result.checks.key.detail) + ').');
+  } else {
+    const env = await enviar(result, key, o.baseUrl);
+    if (env === 'enviado') console.log('resultado enviado: confira em ' + OFFICE_URL + '/onboarding');
+    else if (env === 'recusado') console.log('[aviso] o site recusou o resultado (chave trocada?). O que esta acima vale; refaca o passo 2 e rode de novo.');
+    else console.log('[aviso] nao deu pra mandar o resultado pro site (sem rede?). O que esta acima vale.');
+  }
+  return exit;
+}
+
+module.exports = { medir, enviar, main };
+
+if (require.main === module) {
+  main(process.argv.slice(2)).then(code => process.exit(code), err => {
+    console.error('Erro inesperado: ' + (err && err.message ? err.message : err));
+    process.exit(1);
+  });
+}

package/installer/install.js

@@ -16,7 +16,7 @@
  *  - 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>]
+ * Uso: node install.js [--dry-run] [--source <dir>] [--cofre]
  */
 
 'use strict';
@@ -41,6 +41,7 @@ function abort(msg) {
 
 const args = process.argv.slice(2);
 const DRY_RUN = args.includes('--dry-run');
+const COFRE = args.includes('--cofre'); // cria ~/Iron Cofre/ no fim (installer/cofre.js)
 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
@@ -335,6 +336,7 @@ if (DRY_RUN) {
   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);
+  if (COFRE) require('./cofre').criarCofre({ home: HOME, dryRun: true });
   log('\nDRY-RUN concluido. Nada foi copiado.');
   process.exit(0);
 }
@@ -569,13 +571,19 @@ log('   Os outros 43 agentes se chamam PEDINDO ("usa o iron-copy").');
 const nSkills = (() => { try { return fs.readdirSync(path.join(SOURCE, 'skills')).filter((d) => !d.startsWith('.')).length; } catch (_) { return null; } })();
 log(`   As ${nSkills || ''} SKILLS sao de barra: /gate /salvar /brandkit /escada ...`.replace('  ', ' '));
 log('');
-log('3. Ligue a memoria. Diga a ele:');
-log('');
-log('       cria meu cofre');
-log('');
-log('   O cofre e uma pasta de arquivos .md na SUA maquina, onde o Iron guarda quem');
-log('   voce e, seus projetos e o que ficou pendente. SEM ele, cada conversa comeca');
-log('   do zero. Com ele, o Iron abre a sessao ja sabendo em que pe as coisas estao.');
-log('   Nada e enviado pra lugar nenhum: e arquivo seu, no seu disco.');
-log('   Se preferir fazer depois, e so pedir a qualquer momento.');
-log('');
+if (COFRE) {
+  log('3. Memoria: o cofre (detalhes abaixo).');
+  require('./cofre').criarCofre({ home: HOME });
+  log('');
+} else {
+  log('3. Ligue a memoria. Diga a ele:');
+  log('');
+  log('       cria meu cofre');
+  log('');
+  log('   O cofre e uma pasta de arquivos .md na SUA maquina, onde o Iron guarda quem');
+  log('   voce e, seus projetos e o que ficou pendente. SEM ele, cada conversa comeca');
+  log('   do zero. Com ele, o Iron abre a sessao ja sabendo em que pe as coisas estao.');
+  log('   Nada e enviado pra lugar nenhum: e arquivo seu, no seu disco.');
+  log('   Se preferir fazer depois, e so pedir a qualquer momento.');
+  log('');
+}

package/installer/office.js

@@ -163,7 +163,7 @@ async function main(argv) {
   return r.status ?? 1;
 }
 
-module.exports = { buildClaudeArgs, keyPath, readKey, isValidKey, ping, CHANNEL, PLUGIN, MARKETPLACE_REPO, KEY_RE };
+module.exports = { buildClaudeArgs, keyPath, readKey, keyFileExists, isValidKey, ping, resolveClaude, CHANNEL, PLUGIN, MARKETPLACE_REPO, KEY_RE };
 
 if (require.main === module) {
   main(process.argv.slice(2)).then(code => process.exit(code), err => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "iron-edge",
-  "version": "2.4.2",
-  "description": "Ecossistema de agentes para Claude Code: 44 agentes de topo, 18 squads e 14 skills, com quality gate, memoria, instalador que nunca sobrescreve e o comando office (chat do Iron Office no dashboard; confere a chave com o site antes de abrir o Claude).",
+  "version": "2.4.4",
+  "description": "Ecossistema de agentes para Claude Code: 44 agentes de topo, 18 squads e 14 skills, com quality gate, memoria, instalador que nunca sobrescreve o comando office (chat do Iron Office no dashboard; confere a chave com o site antes de abrir o Claude) e o doctor (mede a maquina e acende o Setup do site).",
   "keywords": [
     "claude",
     "claude-code",
@@ -32,7 +32,7 @@
     "node": ">=18.0.0"
   },
   "scripts": {
-    "test": "node scripts/lint.js && node scripts/test-verify.js && node scripts/test-update.js && node scripts/test-office.js",
+    "test": "node scripts/lint.js && node scripts/test-verify.js && node scripts/test-update.js && node scripts/test-office.js && node scripts/test-cofre.js",
     "test:matriz": "node scripts/test-matriz-update.js"
   },
   "devDependencies": {