invos 1.0.0 → 2.0.2

package/README.md

@@ -1,39 +1,32 @@
-# invos
-
-CLI do **INVOS** — sistema de memória multi-agente em arquivos (prioridade, clientes, proposta, conteúdo).
-
-## Install
+# invos (CLI) — INVOS v2
 
 ```bash
-npx invos@latest init meu-negocio
-# ou
-npm i -g invos
-invos init meu-negocio
+npx invos init --name meu-negocio
+npx invos install
+npx invos update          # sem token — kit no npm
+npx invos doctor
 ```
 
-## Commands
-
-| Command | What it does |
-|---------|----------------|
-| `invos init [dir]` | Cria pasta nova com o kit |
-| `invos install` | Injeta INVOS no diretório atual (repo existente) |
-| `invos update` | Atualiza skills/sistema; **não** mexe em `memoria/` / clientes reais |
-| `invos doctor` | Valida instalação |
-
-## After init
+## Release (você)
 
 ```bash
-cd meu-negocio
-# Abra no Claude / Cursor / Codex / Grok
-# Diga: Segue o COMECE-AQUI
+cd packages/cli
+npm run bundle-kit        # empacota raiz InvOS.v2 → kit/
+npm version patch
+npm publish --access public
 ```
 
-## Env (opcional)
+Comunidade: `npx invos@latest update`
 
-| Var | Uso |
-|-----|-----|
-| `INVOS_KIT_PATH` | Override do kit (dev / kit custom) |
+## O que o update não toca
 
-## Site
+`_memoria/`, `marca/*` (conteúdo), `clientes/`, `marketing/*` gerado, `saidas/`, `dados/` real, `.env`
 
-https://inovadigitalid.com/invos
+## Dev
+
+```bash
+cd packages/cli
+npm run bundle-kit
+node bin/invos.js init --name smoke /tmp/invos-v2-smoke
+node bin/invos.js doctor --dir /tmp/invos-v2-smoke
+```

package/bin/invos.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
 import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { init } from '../src/commands/init.js';
 import { install } from '../src/commands/install.js';
 import { update } from '../src/commands/update.js';
@@ -10,15 +10,14 @@ import { loadManifest } from '../src/manifest.js';
 import { resolveKitRoot } from '../src/resolve-kit.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-
 const cmd = process.argv[2];
 const args = process.argv.slice(3);
 
-function extractDir(args) {
-  const idx = args.indexOf('--dir');
-  if (idx !== -1 && args[idx + 1]) {
-    const dir = resolve(process.cwd(), args[idx + 1]);
-    args.splice(idx, 2);
+function extractDir(list) {
+  const idx = list.indexOf('--dir');
+  if (idx !== -1 && list[idx + 1]) {
+    const dir = resolve(process.cwd(), list[idx + 1]);
+    list.splice(idx, 2);
     return dir;
   }
   return null;
@@ -26,53 +25,60 @@ function extractDir(args) {
 
 function help() {
   console.log(`
-INVOS CLI — npx invos <command>
+INVOS v2 CLI — npx invos <command>
 
-Commands:
-  init [dir]           Create new INVOS project from scratch
-  install [--dir <p>]  Install INVOS into dir (default: cwd)
-  update [--dir <p>]   Update shipped files, preserve user data
-  doctor [--dir <p>]   Validate installation
+  init [--name <slug>] [dir]   Novo projeto (kit completo)
+  install [--dir <p>]          Instala no projeto atual
+  update [--dir <p>]           Atualiza PRODUCT (preserva memória)
+  doctor [--dir <p>] [--fix]  Valida instalação
 
-Options:
-  --help               Show this help
-  --version            Show version
+Update: kit bundled no npm — sem token, sem GitHub.
+  1) Você: npm run bundle-kit && npm publish
+  2) Aluno: npx invos@latest update
+
+  --help  --version  update --dry-run
 `);
 }
 
 async function main() {
-  if (!cmd || cmd === '--help' || cmd === '-h') { help(); return; }
+  if (!cmd || cmd === '--help' || cmd === '-h') {
+    help();
+    return;
+  }
   if (cmd === '--version' || cmd === '-v') {
-    const pkg = JSON.parse(readFileSync(resolve(__dirname, '../package.json'), 'utf-8'));
+    const pkg = JSON.parse(readFileSync(resolve(__dirname, '../package.json'), 'utf8'));
     console.log(pkg.version);
     return;
   }
 
-  const KIT_ROOT = resolveKitRoot();
-  const kit = loadManifest(resolve(KIT_ROOT, 'INVOS.json'));
+  const kitRoot = resolveKitRoot();
+  const kit = loadManifest(resolve(kitRoot, 'INVOS.json'));
   if (!kit) {
-    console.error('INVOS.json not found at', KIT_ROOT);
+    console.error('INVOS.json missing in kit:', kitRoot);
     process.exit(1);
   }
 
   switch (cmd) {
     case 'init':
-      await init(kit, KIT_ROOT, args);
+      await init(kit, kitRoot, args);
       break;
     case 'install':
-      await install(kit, KIT_ROOT, extractDir(args) || process.cwd(), args);
+      await install(kit, kitRoot, extractDir(args) || process.cwd(), args);
       break;
     case 'update':
-      await update(kit, KIT_ROOT, extractDir(args) || process.cwd(), args);
+      await update(kit, kitRoot, extractDir(args) || process.cwd(), args);
       break;
     case 'doctor':
-      await doctor(kit, KIT_ROOT, extractDir(args) || process.cwd(), args);
+      await doctor(kit, kitRoot, extractDir(args) || process.cwd(), args);
       break;
     default:
-      console.error('Unknown command:', cmd);
+      console.error('Unknown:', cmd);
       help();
       process.exit(1);
   }
 }
 
-main().catch(err => { console.error(err.message); process.exit(1); });
+main().catch(e => {
+  console.error(e.message || e);
+  process.exit(1);
+});

package/kit/.agents/skills/abrir/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: abrir
+description: >
+  Abre uma sessão de trabalho carregando a memória do negócio (empresa, preferências, estratégia, marca)
+  e devolve um resumo curto pro usuário. Use quando o usuário disser "abrir",
+  "começar o dia", "/abrir" ou no primeiro turno de uma sessão depois do /instalar.
+---
+
+# /abrir — Abertura de sessão
+
+Curto e direto. O objetivo é carregar contexto e devolver uma síntese de uma frase pra o usuário começar a trabalhar.
+
+## Workflow
+
+1. Ler, em ordem:
+   - `_memoria/empresa.md`
+   - `_memoria/preferencias.md`
+   - `_memoria/estrategia.md`
+   - `marca/design-guide.md` (só pra saber se está preenchido ou em branco)
+
+2. Se algum dos três primeiros estiver em branco (placeholder), responder:
+   > "Vi que `_memoria/<arquivo>.md` ainda não foi preenchido. Quer rodar `/instalar` agora?"
+   E parar.
+
+3. Se tudo estiver preenchido, devolver UMA mensagem curta no formato:
+
+```
+[Nome do negócio] — [o que faz em 5-8 palavras]
+Foco atual: [prioridade da estratégia, em uma frase]
+Tom: [resumo de 3-4 palavras do tom de voz]
+
+Pronto. O que vamos fazer?
+```
+
+4. Não listar quais arquivos foram lidos. Não confirmar leitura. Só usar o contexto.
+
+## Regras
+
+- Resposta tem que caber em 5 linhas no terminal
+- Não fazer perguntas além de "o que vamos fazer?"
+- Se o `design-guide.md` estiver em branco, não mencionar — só vira problema quando alguma skill visual for chamada

package/kit/.agents/skills/analisar-dados/SKILL.md

@@ -0,0 +1,95 @@
+---
+name: analisar-dados
+description: >
+  Analisa um arquivo de dados (CSV, Excel, TXT, JSON) e gera um resumo executivo
+  com os principais insights, tendências e recomendações.
+  Use quando o usuário disser "analisa esse arquivo", "o que mostram esses dados",
+  "resume esses resultados", "analisa esse relatório", ou arrastar um arquivo de dados.
+---
+
+# /analisar-dados — Análise de Arquivo
+
+## Dependências
+
+- **Contexto do negócio:** `_memoria/empresa.md` (pra entender o que os dados representam)
+- **Tom de voz:** `_memoria/preferencias.md`
+
+---
+
+## Workflow
+
+### Passo 1 — Entender o contexto
+
+Antes de analisar, perguntar se não estiver claro:
+- "O que é esse arquivo? (vendas, anúncios, métricas, respostas de pesquisa...)"
+- "Qual é a pergunta principal que você quer responder com esses dados?"
+
+Se o contexto estiver óbvio pelo nome do arquivo ou pelo conteúdo, prossegue sem perguntar.
+
+### Passo 2 — Ler o arquivo
+
+Ler o arquivo fornecido. Se for Excel (.xlsx), ler com as ferramentas disponíveis pra extrair o conteúdo das células.
+
+### Passo 3 — Análise
+
+Identificar e reportar:
+
+**O que está bom:**
+- Métricas acima da média ou em crescimento
+- Padrões positivos nos dados
+- Top performers (produtos, campanhas, períodos, etc)
+
+**O que preocupa:**
+- Quedas, anomalias ou tendências negativas
+- O que está abaixo do esperado
+- Gargalos ou desperdícios visíveis
+
+**Comparações:**
+- Período atual vs período anterior (se houver)
+- Top vs bottom performers
+- Distribuição entre categorias
+
+**Insights não óbvios:**
+- Correlações interessantes
+- Padrões que não aparecem na leitura superficial
+
+### Passo 4 — Output
+
+Gerar um resumo executivo em prosa (não só bullet points):
+
+```markdown
+# Análise — [Nome do Arquivo/Relatório]
+*[Data da análise]*
+
+## O que esses dados mostram
+[2-3 parágrafos com o panorama geral]
+
+## O que está funcionando
+[lista com contexto]
+
+## O que merece atenção
+[lista com contexto]
+
+## 3 recomendações
+1. [ação concreta]
+2. [ação concreta]
+3. [ação concreta]
+
+## Números-chave
+| Métrica | Valor | Contexto |
+|---------|-------|---------|
+| ... | ... | ... |
+```
+
+Salvar em `estudos/analise-[nome]-[data].md` ou na pasta mais adequada pro perfil do usuário.
+
+Perguntar se quer exportar o resumo em HTML pra compartilhar ou apresentar.
+
+---
+
+## Regras
+
+- Análise em prosa, não só listas — o usuário deve poder ler e entender sem abrir o arquivo original
+- Nunca inventar dados que não estão no arquivo
+- Se os dados estiverem incompletos ou com problemas, mencionar antes de analisar
+- Tom conforme `_memoria/preferencias.md`

package/kit/.agents/skills/anuncio-google/SKILL.md

@@ -0,0 +1,174 @@
+---
+name: anuncio-google
+description: >
+  Cria estrutura completa de campanha do Google Ads a partir de um briefing ou da pesquisa SEO.
+  Gera CSV pronto pra importar no Google Ads Editor com campanhas Search organizadas por cluster
+  de palavras-chave, grupos de anúncios, RSAs (Responsive Search Ads), extensões e palavras-chave
+  negativas. Lê o briefing de _memoria/empresa.md e da pesquisa SEO se existir.
+  Use quando o usuário pedir "criar campanha google ads", "anúncio google", "google ads",
+  "csv pro google ads", ou /anuncio-google.
+---
+
+# /anuncio-google — Estrutura de campanha Google Ads
+
+Skill que monta a campanha inteira em CSV pronto pra importar no Google Ads Editor. Sai do briefing direto pro CSV — sem montar grupo por grupo na mão na interface do Google.
+
+## Dependências
+
+- **Contexto do negócio:** `_memoria/empresa.md` (produto/serviço, público, região, diferenciais)
+- **Tom de voz:** `_memoria/preferencias.md`
+- **Pesquisa SEO (se existir):** `marketing/seo/01-pesquisa-demanda.md`, `06-google-ads.md` — usar como insumo
+- **Outputs vão em:** `marketing/campanhas/google-ads-<YYYY-MM-DD>/`
+
+---
+
+## Workflow
+
+### Passo 1 — Briefing
+
+Se o usuário não passou briefing, perguntar:
+
+1. **Produto/serviço a anunciar?** (1-3 linhas)
+2. **Quem é o público?** (perfil, dor que resolve)
+3. **Região:** raio em km a partir de qual cidade?
+4. **Orçamento diário?** (R$/dia)
+5. **Objetivo:** ligações / WhatsApp / formulário / visita?
+6. **Site/landing page** existe? URL?
+
+Se já existe `marketing/seo/06-google-ads.md` (criado pelo `/seo`), usar como base — pular as perguntas que já foram respondidas lá.
+
+### Passo 2 — Pesquisa de palavras-chave
+
+Se já existe `marketing/seo/01-pesquisa-demanda.md`, usar o top 10-20 de termos prioritários (intenção transacional + comercial).
+
+Se não existe, gerar:
+- 30-50 termos-semente baseados no briefing
+- WebSearch pra cada grupo: ver concorrência, sazonalidade
+- Filtrar pelos de **intenção comercial/transacional** (descartar informacionais)
+- Agrupar em **clusters** (ex: "feijoada-buffet", "feijoada-restaurante", "feijoada-evento")
+
+### Passo 3 — Estrutura de campanha
+
+**Padrão recomendado pra B2B local:**
+
+```
+Campanha 1: <Negócio> — Search Geral
+├── Grupo: <Cluster 1>
+│   ├── 10-15 keywords (mix de exata, frase, ampla modificada)
+│   ├── 3 RSAs (15 headlines + 4 descriptions cada)
+│   └── 10-15 keywords negativas no grupo
+├── Grupo: <Cluster 2>
+│   └── ...
+└── ... (1 grupo por cluster do Passo 2)
+
+Campanha 2: <Negócio> — Local (opcional)
+├── Anúncios pra Google Maps
+└── Segmentação por proximidade
+
+Lista de negativas globais: termos genéricos descartados, marcas concorrentes
+```
+
+### Passo 4 — Copies (RSAs)
+
+Pra cada grupo, gerar 3 RSAs (Responsive Search Ads):
+
+**15 headlines** por anúncio:
+- 5 com keyword principal
+- 3 com diferenciais concretos (certificações, prazo, garantia)
+- 3 com CTA ("Solicite cotação", "Peça pelo WhatsApp", "Fale agora")
+- 2 com prova social (anos no mercado, número de clientes)
+- 2 com proposta de valor genérica
+
+**4 descriptions** (90 caracteres cada):
+- 1 institucional + CTA
+- 1 com diferencial técnico + CTA
+- 1 com urgência/escassez (se aplicável)
+- 1 com prova social + CTA
+
+**Restrições do Google:**
+- Headline: 30 caracteres
+- Description: 90 caracteres
+- Sem emojis, sem caps lock, sem repetição de palavras
+- Sem afirmações superlativas não-comprovadas ("o melhor", "número 1") sem fonte
+
+Seguir `_memoria/preferencias.md` pra tom.
+
+### Passo 5 — Extensões
+
+Gerar CSVs separados pra cada tipo de extensão:
+
+- **Sitelinks** (4-6): "Sobre nós", "Catálogo", "Cases", "WhatsApp", "Localização"
+- **Chamadas** (telefone): puxar de `_memoria/empresa.md`
+- **Snippets estruturados:** lista de serviços, categorias de produto
+- **Preço** (se aplicável): faixas de preço dos serviços principais
+- **Promoção** (se aplicável): desconto, condição especial
+
+### Passo 6 — Configurações da campanha
+
+Gerar arquivo `configuracoes.md` com:
+
+- **Estratégia de lance:** "Maximizar conversões" pra começar (depois migrar pra "Maximizar conversões com tCPA" quando tiver 30+ conversões)
+- **Orçamento diário:** conforme briefing
+- **Segmentação geográfica:** raio em km a partir do endereço
+- **Idioma:** Português
+- **Dispositivos:** ajustes de lance recomendados (mobile +0%, desktop +0%, tablet -20%)
+- **Programação:** dias e horários conforme negócio
+- **Conversões a configurar:** clique no WhatsApp, envio de formulário, ligação telefônica, tempo no site
+
+### Passo 7 — Gerar os CSVs
+
+Estrutura de pastas final:
+
+```
+marketing/campanhas/google-ads-<YYYY-MM-DD>/
+  campanhas.csv          ← linha por campanha
+  grupos.csv             ← linha por grupo de anúncio
+  keywords.csv           ← keywords + match type
+  keywords-negativas.csv ← negativas por grupo + lista global
+  anuncios.csv           ← RSAs (headlines + descriptions)
+  extensoes-sitelinks.csv
+  extensoes-chamadas.csv
+  extensoes-snippets.csv
+  extensoes-preco.csv (se aplicável)
+  configuracoes.md       ← config + checklist de import
+  README.md              ← passo a passo pra importar no Google Ads Editor
+```
+
+**Formato dos CSVs:** seguir o padrão de importação do Google Ads Editor (colunas: Campaign, Ad group, Keyword, Match type, Status, Max CPC, etc.).
+
+### Passo 8 — Resumo + próximos passos
+
+Mostrar pro usuário:
+
+```
+✓ Campanha pronta: marketing/campanhas/google-ads-<YYYY-MM-DD>/
+
+Estrutura:
+- <N> campanhas
+- <N> grupos de anúncio
+- <N> palavras-chave (positivas)
+- <N> palavras-chave negativas
+- <N> RSAs
+
+Pra subir:
+1. Abrir Google Ads Editor (desktop)
+2. Conta → Importar → CSV
+3. Subir campanhas.csv primeiro, depois grupos, keywords, anúncios, extensões
+4. Revisar status (tudo "pausado" inicialmente — ativar manualmente)
+5. Conferir conversões configuradas no Google Tag Manager
+6. Ativar campanha quando estiver tudo OK
+
+Sugestão de orçamento inicial: R$<X>/dia por <Y> dias antes de avaliar.
+```
+
+---
+
+## Regras
+
+- **Nunca inventar dados de CPC.** Se o cliente perguntar quanto vai custar, falar que depende da concorrência real e dar uma faixa baseada em WebSearch.
+- **Sempre começar pausado.** Cliente revisa, ativa quando aprovar.
+- **Não anunciar pra termos informacionais.** "Como fazer X" raramente converte — deixar pra SEO orgânico.
+- **Match type:** começar com Phrase Match na maioria. Exact pra termos premium. Broad só com dados consistentes.
+- **Lista de negativas global** é obrigatória — sem ela, queima dinheiro em buscas irrelevantes.
+- **Conversões antes de tudo.** Sem conversão configurada, o Google não otimiza — relatar isso e pedir setup antes de ativar.
+- Copies seguem `_memoria/preferencias.md` estritamente. Sem jargão de marketing se o público não usa.

package/kit/.agents/skills/aprovar-post/SKILL.md

@@ -0,0 +1,151 @@
+---
+name: aprovar-post
+description: >
+  Aprova e publica um post da fila — flipa o blog de draft pra published, copia os PNGs do
+  carrossel pro public folder do site, faz commit e push (Netlify/Vercel deploya), aguarda
+  o deploy, e posta o carrossel no Instagram + Facebook via Meta Graph API. Use quando o
+  usuário disser "aprovar post X", "publicar o post do tema Y", "/aprovar-post X", ou quando
+  quiser disparar a publicação automática de um conteúdo já criado pela skill /publicar-tema.
+---
+
+# /aprovar-post — Pipeline de aprovação e publicação automática
+
+Faz a ponte entre o conteúdo aprovado (blog + carrossel + legendas, criado por `/publicar-tema`)
+e a publicação real no feed (site + Instagram + Facebook).
+
+## Quando NÃO usar
+
+- Conteúdo ainda não foi criado → use `/publicar-tema` primeiro
+- Usuário ainda está revisando → não rodar até ele dizer "aprovado" / "pode postar"
+- Site não está deployado / Meta API não configurada → seguir setup abaixo
+
+## Pré-requisitos (uma vez só)
+
+- `.env` na raiz com:
+  - `META_PAGE_ACCESS_TOKEN` — token de longa duração da Página FB
+  - `META_PAGE_ID` — ID da Página FB
+  - `META_IG_USER_ID` — ID da conta Insta Business
+  - `SITE_URL` — ex: `https://exemplo.com.br`
+- Site com deploy automático a partir do `main` do GitHub (Netlify, Vercel, etc.)
+- Conta Insta Business conectada à Página FB
+- Página FB com permissões corretas no Meta App
+- Scripts `scripts/postar-instagram.js` e `scripts/postar-facebook.js` configurados
+
+Se algo disso faltar: parar e apontar pro guia de setup (criar `marketing/automacao-meta-setup.md` se ainda não existir).
+
+## Argumento
+
+`/aprovar-post <slug>` — onde `<slug>` é o nome do arquivo do blog **sem `.md`**.
+
+Exemplo: `/aprovar-post como-conservar-produto`
+
+Se o usuário não passou slug, listar os blogs em draft (arquivos com `draft: true`) e perguntar qual.
+
+## Workflow
+
+### Passo 1 — Localizar arquivos
+
+- Blog: `site/.../blog/<slug>.md` (caminho depende do stack — Astro, Hugo, etc.)
+- Carrossel: procurar `marketing/conteudo/<slug>-*` (a pasta tem sufixo de data)
+- Validar que existem PNGs em `<pasta-carrossel>/instagram/slide-XX.png` (2 a 10)
+- Validar que existem `legenda.md` e `legenda-linkedin.md`
+
+Se faltar qualquer um, parar e relatar.
+
+### Passo 2 — Mostrar resumo + pedir confirmação final
+
+Mostrar pro usuário:
+- Título do blog
+- Quantos slides do carrossel
+- Primeiras 200 chars da legenda
+- URL final que vai ser publicada
+
+Perguntar: **"Confirma publicação? (sim/não)"**. Só seguir se ele disser sim.
+
+### Passo 3 — Flipar draft pra false
+
+Editar o frontmatter do blog: `draft: true` → `draft: false`.
+
+### Passo 4 — Copiar PNGs pro public folder do site
+
+- Origem: `marketing/conteudo/<slug>-<data>/instagram/slide-*.png`
+- Destino: `site/.../public/img/posts/<slug>/slide-*.png`
+- Criar pasta de destino se não existir
+- Sobrescrever se já existir (caso seja re-publicação)
+
+### Passo 5 — Commit + push
+
+```bash
+git add site/<caminho>/blog/<slug>.md site/<caminho>/public/img/posts/<slug>/
+git commit -m "publicar: <título do blog>"
+git push origin main
+```
+
+Esperar push terminar com sucesso.
+
+### Passo 6 — Aguardar deploy
+
+Deploy automático (Netlify/Vercel) leva ~1-2 min. Validar que o post está no ar:
+
+```bash
+curl -sf -o /dev/null -w "%{http_code}" "$SITE_URL/blog/$slug/"
+```
+
+Aguardar HTTP 200 (com timeout de 5 min). Também checar que pelo menos `slide-01.png` está acessível:
+
+```bash
+curl -sf -o /dev/null -w "%{http_code}" "$SITE_URL/img/posts/$slug/slide-01.png"
+```
+
+Sem isso, a Meta API vai falhar — ela busca a imagem por URL pública.
+
+### Passo 7 — Postar no Instagram
+
+```bash
+node --env-file=.env scripts/postar-instagram.js marketing/conteudo/<slug>-<data>
+```
+
+Capturar o post id retornado. Se falhar, **não seguir pra Facebook** — relatar e parar.
+
+### Passo 8 — Postar no Facebook
+
+```bash
+node --env-file=.env scripts/postar-facebook.js marketing/conteudo/<slug>-<data>
+```
+
+Capturar o post id retornado.
+
+### Passo 9 — LinkedIn
+
+LinkedIn é manual por enquanto (API de empresa precisa de aprovação demorada). Mostrar pro usuário:
+
+```
+LinkedIn: cole esse texto manualmente em https://linkedin.com/in/<seu-perfil>:
+<conteúdo de legenda-linkedin.md>
+```
+
+### Passo 10 — Resumo
+
+Mostrar:
+```
+✓ Post publicado: <título>
+
+Site:        <SITE_URL>/blog/<slug>/
+Instagram:   <link do post>
+Facebook:    <link do post>
+LinkedIn:    pendente — texto pronto em legenda-linkedin.md (postar manual)
+```
+
+## Tratamento de erro
+
+- Push falhou: rollback do `draft: false` (restaura `draft: true`), relata e para
+- Deploy não subiu em 5 min: relata, pergunta se quer continuar mesmo assim ou abortar
+- Insta API falhou: para e relata. Site já está no ar, blog publicado — só o post no feed que não foi
+- FB falhou mas Insta OK: relata, sugere tentar de novo só o FB depois
+
+## Princípios
+
+1. **Confirmação humana antes de qualquer coisa irreversível.** Nunca pular o passo 2.
+2. **Idempotente onde possível.** Re-rodar com mesmo slug deve detectar publicação prévia (blog não-draft, PNGs já no public/) e perguntar se é pra re-postar ou só atualizar.
+3. **Falha cedo, falha alto.** Qualquer pré-requisito faltando = abortar e explicar o que falta.
+4. **Logar tudo.** Cada passo imprime o que está fazendo e o resultado.