@fabioforest/openclaw 3.0.0 → 3.4.0

package/lib/context/collector.js

@@ -0,0 +1,104 @@
+"use strict";
+
+/**
+ * Context Collector — Read-only snapshot do ambiente.
+ * Nunca altera arquivos. Apenas lê e retorna dados.
+ *
+ * Baseado no módulo do openclaw-agents-addons,
+ * adaptado para o projeto principal.
+ */
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+function exists(p) {
+    try { return fs.existsSync(p); } catch { return false; }
+}
+
+/**
+ * Detecta IDE ativa no workspace.
+ */
+function detectIDE(targetPath) {
+    if (exists(path.join(targetPath, ".cursor"))) return "cursor";
+    if (exists(path.join(targetPath, ".vscode"))) return "vscode";
+    if (exists(path.join(targetPath, ".idea"))) return "jetbrains";
+    return "unknown";
+}
+
+/**
+ * Detecta ambiente de execução (SO, Docker, WSL).
+ */
+function detectEnvironment() {
+    const platform = os.platform();
+    const docker = exists("/.dockerenv") ||
+        (exists("/proc/1/cgroup") && fs.readFileSync("/proc/1/cgroup", "utf8").includes("docker"));
+    const wsl = platform === "linux" &&
+        (os.release().toLowerCase().includes("microsoft") || !!process.env.WSL_DISTRO_NAME);
+    return { platform, docker, wsl };
+}
+
+/**
+ * Detecta instalação existente do OpenClaw.
+ */
+function detectOpenClaw(targetPath) {
+    const agentDir = path.join(targetPath, ".agent");
+    const config = path.join(targetPath, "openclaw.json");
+    const dockerCompose = path.join(targetPath, "docker-compose.yml");
+    return {
+        hasAgentDir: exists(agentDir),
+        hasConfig: exists(config),
+        hasDockerCompose: exists(dockerCompose),
+    };
+}
+
+/**
+ * Lista skills disponíveis nos templates.
+ */
+function listSkillsFromTemplates(templatesDir) {
+    const skillsDir = path.join(templatesDir, ".agent", "skills");
+    if (!exists(skillsDir)) return [];
+    const out = [];
+    for (const name of fs.readdirSync(skillsDir)) {
+        const skillPath = path.join(skillsDir, name, "SKILL.md");
+        if (exists(skillPath)) out.push({ name, skillPath });
+    }
+    return out;
+}
+
+/**
+ * Lista skills instaladas no workspace do usuário.
+ */
+function listInstalledSkills(targetPath) {
+    const skillsDir = path.join(targetPath, ".agent", "skills");
+    if (!exists(skillsDir)) return [];
+    const out = [];
+    for (const name of fs.readdirSync(skillsDir)) {
+        const skillPath = path.join(skillsDir, name, "SKILL.md");
+        if (exists(skillPath)) out.push({ name, skillPath });
+    }
+    return out;
+}
+
+/**
+ * Coleta contexto completo (read-only).
+ * @param {object} options
+ * @param {string} options.targetPath — diretório do workspace
+ * @param {string} options.templatesDir — diretório de templates do pacote
+ * @returns {object} snapshot do contexto
+ */
+function collectContext({ targetPath, templatesDir }) {
+    const env = detectEnvironment();
+    return {
+        targetPath,
+        env,
+        ide: detectIDE(targetPath),
+        openclaw: detectOpenClaw(targetPath),
+        git: { isRepo: exists(path.join(targetPath, ".git")) },
+        skillsInTemplates: listSkillsFromTemplates(templatesDir),
+        skillsInstalled: listInstalledSkills(targetPath),
+        ts: new Date().toISOString(),
+    };
+}
+
+module.exports = collectContext;

package/lib/context/index.js

@@ -0,0 +1,75 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+/**
+ * Detecta o ambiente de execução e metadados de contexto.
+ * Retorna um objeto seguro para logs e auditoria.
+ */
+function detectContext(cwd = process.cwd()) {
+    const ctx = {
+        timestamp: new Date().toISOString(),
+        platform: os.platform(),
+        cwd: cwd,
+        env: "local",
+        ide: "unknown",
+        isDocker: false,
+        hasExistingInstall: false,
+    };
+
+    // 1. Detectar Docker
+    if (fs.existsSync("/.dockerenv") || fs.existsSync("/run/.containerenv")) {
+        ctx.isDocker = true;
+        ctx.env = "docker";
+    }
+
+    // 2. Detectar IDEs comuns
+    const ideMarkers = [
+        { name: "vscode", path: ".vscode" },
+        { name: "cursor", path: ".cursor" },
+        { name: "idea", path: ".idea" },
+        { name: "antigravity", path: ".agent/antigravity" } // Marcador fictício ou real se existir
+    ];
+
+    for (const m of ideMarkers) {
+        if (fs.existsSync(path.join(cwd, m.path))) {
+            ctx.ide = m.name;
+            break;
+        }
+    }
+
+    // 3. Detectar instalação existente
+    const agentDir = path.join(cwd, ".agent");
+    const configPath = path.join(cwd, "openclaw.json");
+
+    if (fs.existsSync(agentDir) || fs.existsSync(configPath)) {
+        ctx.hasExistingInstall = true;
+    }
+
+    return ctx;
+}
+
+/**
+ * Gera um cabeçalho de auditoria formatado em Markdown.
+ */
+function getAuditHeader(ctx, command, flags) {
+    return [
+        `# OpenClaw Audit Log`,
+        `- **Time**: ${ctx.timestamp}`,
+        `- **Command**: ${command}`,
+        `- **Mode**: ${flags.plan ? "PLAN (Simulation)" : "APPLY (Execution)"}`,
+        `- **Environment**: ${ctx.env} (Docker: ${ctx.isDocker})`,
+        `- **IDE**: ${ctx.ide}`,
+        `- **Existing Install**: ${ctx.hasExistingInstall}`,
+        `- **Flags**: ${JSON.stringify(flags)}`,
+        `---`,
+        ``
+    ].join("\n");
+}
+
+module.exports = {
+    detectContext,
+    getAuditHeader
+};

package/lib/router/match.js

@@ -0,0 +1,107 @@
+"use strict";
+
+/**
+ * Skill Matcher — Escolhe a skill mais adequada para uma solicitação.
+ *
+ * Faz parse do YAML frontmatter de cada SKILL.md e pontua
+ * a relevância com base nos triggers e descrição.
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * Extrai metadados (name, description, triggers) do frontmatter YAML.
+ * @param {string} md — conteúdo Markdown com frontmatter
+ * @returns {object|null} metadados extraídos ou null
+ */
+function parseFrontmatter(md) {
+    const m = md.match(/^---\s*\n([\s\S]*?)\n---\s*\n/);
+    if (!m) return null;
+
+    const yaml = m[1];
+
+    // Extrair listas (ex: triggers)
+    const getList = (key) => {
+        const r = new RegExp(`^${key}:\\s*\\n([\\s\\S]*?)(\\n\\w|$)`, "m");
+        const mm = yaml.match(r);
+        if (!mm) return [];
+        return mm[1]
+            .split("\n")
+            .map(l => l.trim())
+            .filter(l => l.startsWith("-"))
+            .map(l => l.replace(/^-\s*/, "").trim())
+            .filter(Boolean);
+    };
+
+    // Extrair escalares (ex: name, description)
+    const getScalar = (key) => {
+        const r = new RegExp(`^${key}:\\s*(.+)$`, "m");
+        const mm = yaml.match(r);
+        return mm ? mm[1].trim() : "";
+    };
+
+    return {
+        name: getScalar("name"),
+        description: getScalar("description"),
+        triggers: getList("triggers"),
+    };
+}
+
+/**
+ * Carrega todas as skills de um diretório de templates.
+ * @param {string} skillsDir — diretório com subpastas de skills
+ * @returns {Array} lista de skills com metadados
+ */
+function loadSkills(skillsDir) {
+    if (!fs.existsSync(skillsDir)) return [];
+    const skills = [];
+    for (const folder of fs.readdirSync(skillsDir)) {
+        const p = path.join(skillsDir, folder, "SKILL.md");
+        if (!fs.existsSync(p)) continue;
+        const md = fs.readFileSync(p, "utf8");
+        const meta = parseFrontmatter(md);
+        if (!meta) continue;
+        skills.push({ ...meta, path: p, folder });
+    }
+    return skills;
+}
+
+/**
+ * Calcula score de relevância de uma skill para um texto.
+ * @param {object} skill — skill com triggers e description
+ * @param {string} text — texto do usuário
+ * @returns {number} pontuação (maior = mais relevante)
+ */
+function scoreSkill(skill, text) {
+    const t = (text || "").toLowerCase();
+    let s = 0;
+    for (const trig of (skill.triggers || [])) {
+        if (t.includes(String(trig).toLowerCase())) s += 5;
+    }
+    // Bonus parcial para match de descrição
+    if (skill.description && t.includes(skill.description.toLowerCase().slice(0, 12))) s += 1;
+    return s;
+}
+
+/**
+ * Encontra a skill mais relevante para uma solicitação.
+ * @param {object} options
+ * @param {string} options.skillsDir — diretório de skills (templates/.agent/skills)
+ * @param {string} options.userText — texto da solicitação do usuário
+ * @returns {object} { chosen, alternatives, ranked }
+ */
+function matchSkill({ skillsDir, userText }) {
+    const skills = loadSkills(skillsDir);
+    const ranked = skills
+        .map(sk => ({ sk, score: scoreSkill(sk, userText) }))
+        .sort((a, b) => b.score - a.score);
+
+    return {
+        chosen: ranked[0]?.sk || null,
+        alternatives: ranked.slice(1, 4).map(x => x.sk),
+        ranked,
+    };
+}
+
+module.exports = { matchSkill, loadSkills, parseFrontmatter };

package/lib/setup/config_wizard.js

@@ -176,6 +176,8 @@ async function main() {
   }
 
   console.log("\n✅ Setup finalizado.");
+  console.log("\n🌐 CONTROL UI: http://127.0.0.1:18789");
+  console.log("   Acesse para gerenciar seus agentes visualmente.\n");
   console.log("Próximo passo: configurar VPN (WireGuard) e aplicar policies (skills/openclaw-ops).");
   rl.close();
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fabioforest/openclaw",
-  "version": "3.0.0",
-  "description": "CLI e starter kit para configuração segura do OpenClaw em VPS, Mac, Windows e Docker",
+  "version": "3.4.0",
+  "description": "Agentes autônomos para engenharia de software",
   "publishConfig": {
     "access": "public"
   },

package/templates/.agent/agents/workflow-automator.md

@@ -0,0 +1,31 @@
+---
+name: Workflow Automator
+description: Especialista em criar, validar e otimizar workflows e automações do OpenClaw.
+system_prompt: |
+  Você é o Workflow Automator, um agente especializado na arquitetura de automação do OpenClaw.
+  
+  ## Suas Responsabilidades
+  1.  **Criar Workflows**: Escrever arquivos `.md` válidos em `.agent/workflows/` seguindo a sintaxe de nodes.
+  2.  **Explicar Conceitos**: Ensinar sobre `AI Capture`, `Interactive Nodes` e `Message Nodes`.
+  3.  **Validar Sintaxe**: Garantir que o YAML frontmatter e a estrutura dos passos estejam corretos.
+  
+  ## Conhecimento de Sintaxe
+  Você domina a estrutura de workflows do OpenClaw:
+  - **Frontmatter**: `description`, `params` (opcional).
+  - **Steps**: Lista numerada ou bullets.
+  - **AI Capture**: Uso de prompts para extrair JSON de conversas.
+  - **Integração**: Como chamar skills dentro de workflows.
+  
+  ## Personalidade
+  Técnico, preciso e focado em eficiência. Você adora transformar processos manuais em arquivos `.md` elegantes.
+---
+# Workflow Automator
+
+Olá! Eu sou o especialista em **Workflows Inteligentes**.
+
+Posso ajudar você a:
+1.  Criar um workflow de **Onboarding** que coleta dados do usuário.
+2.  Configurar um **AI Capture** para estruturar pedidos ou tickets.
+3.  Debugar um workflow que não está rodando corretamente.
+
+Comando sugerido: `Crie um workflow para coletar feedback de usuários`

package/templates/.agent/rules/CONSENT_FIRST.md

@@ -0,0 +1,24 @@
+---
+description: Regra de Ouro: Consentimento Prévio para Alterações
+---
+
+# Consent First (Segurança Absoluta)
+
+Como um agente OpenClaw, você opera sob um contrato estrito de "Read-Only por Padrão".
+
+## 1. Regra de Ouro
+**Nunca altere, apague ou crie arquivos sem que o usuário tenha solicitado explicitamente essa ação específica.**
+
+## 2. Protocolo de Modificação
+Antes de qualquer operação de escrita (write, edit, delete, move), você deve:
+1.  **Analisar**: Entender o contexto e o impacto.
+2.  **Planejar**: Explicar ao usuário o que será feito.
+3.  **Confirmar**: Perguntar "Posso prosseguir?" ou aguardar comando explícito (ex: `--apply`).
+
+## 3. Proibições Estritas
+- Nunca execute `rm -rf`, `git clean` ou deletar diretórios inteiros sem um aviso gigante e confirmação dupla.
+- Nunca sobrescreva arquivos de configuração (`openclaw.json`, `.env`) silenciosamente.
+- Nunca assuma que pode "consertar" algo sem perguntar antes.
+
+## 4. Auditoria
+Sempre que realizar uma alteração, registre o que foi feito. O sistema já gera logs em `.agent/audit/`, mas você deve comunicar o sucesso ao usuário com clareza.

package/templates/.agent/rules/DEV_MODE.md

@@ -0,0 +1,18 @@
+# OpenClaw AI OS — Dev Mode (Devin-like)
+
+Você pode atuar como:
+- backend engineer
+- frontend engineer
+- UX/UI
+- devops
+- security engineer
+
+## Travas obrigatórias
+- Sempre começar com INSPECT (read-only)
+- Sempre gerar PLANO com lista de arquivos impactados
+- Sempre pedir CONSENTIMENTO antes de editar/criar/deletar
+- Sempre gerar AUDIT do que foi feito/certo/errado
+
+## Defaults seguros
+- escrever por padrão somente em `.agent/**` e arquivos explicitamente aprovados
+- qualquer alteração fora disso exige confirmação detalhada

package/templates/.agent/rules/ROUTER_PROTOCOL.md

@@ -0,0 +1,22 @@
+# OpenClaw AI OS — Router Protocol (Chat-first)
+
+## Regra Suprema
+**READ-ONLY por padrão.**
+Nada pode ser criado/alterado/apagado sem **autorização explícita** do usuário.
+
+## Fluxo obrigatório para qualquer pedido no chat
+1) **Inspecionar (read-only):** entender o contexto do workspace (SO, IDE, Docker/VPS/local, OpenClaw existente, skills disponíveis).
+2) **Roteamento:** escolher a skill mais adequada com base em `triggers`/`description`.
+3) **Plano:** apresentar um plano claro e verificável com:
+   - arquivos que seriam tocados
+   - comandos que seriam executados
+   - riscos e rollback
+4) **Consentimento:** perguntar: **"Posso aplicar?"**
+5) **Aplicar somente após confirmação:**
+   - se envolver overwrite/delete: exigir confirmação reforçada (ex.: digitar uma frase)
+6) **Auditoria:** documentar tudo que foi feito/alterado e resultado (certo/errado).
+
+## Segurança mínima
+- bind localhost + token por padrão
+- acesso remoto somente via VPN (WireGuard)
+- bloquear ações destrutivas sem confirmação explícita

package/templates/.agent/rules/WEB_AUTOMATION.md

@@ -0,0 +1,52 @@
+---
+name: WEB_AUTOMATION
+description: Regra de compliance para automação web, scraping e integração com serviços externos.
+---
+
+# Web Automation — Regras de Compliance e Segurança
+
+## Princípio central
+**Separar "planejar" de "executar"**: a IA pode planejar e escrever scripts/patches, mas execução real vem **após consentimento explícito** do usuário.
+
+## Checklist obrigatório antes de qualquer automação web
+
+### 1. ToS e legalidade
+- [ ] Verificar se o site/plataforma permite automação (ex: LinkedIn **proíbe** bots)
+- [ ] Verificar `robots.txt` — não é autorização, mas é prática obrigatória respeitá-lo
+- [ ] Preferir APIs oficiais quando existirem (Google Drive API, SerpAPI, PageSpeed, etc.)
+- [ ] Só automatizar contas que o usuário controla e autorizou
+
+### 2. Credenciais e autenticação
+- [ ] Preferir OAuth (Google/Microsoft) com escopos mínimos (ex: `drive.file`)
+- [ ] Nunca armazenar senhas — usar variáveis de ambiente ou secret manager
+- [ ] Cookies/storage state tratados como segredo (criptografar, expirar, consentimento)
+- [ ] Nunca logar tokens ou chaves em texto puro
+
+### 3. Execução isolada
+- [ ] Executar em sandbox (Docker/VM) quando possível
+- [ ] Preferir modo `non-main` ou `all` para sessões de automação
+- [ ] Rate limiting autoimposto (nunca saturar servidores alvo)
+- [ ] Timeout e retry com backoff exponencial
+
+### 4. Dados e privacidade
+- [ ] Minimizar dados enviados a provedores externos (evitar PII, segredos, dumps)
+- [ ] Documentar qual provedor/modelo foi usado e sua política de retenção
+- [ ] Ativar Zero Data Retention (ZDR) quando disponível e necessário
+- [ ] Masking/redação de dados sensíveis antes de enviar a LLMs
+
+### 5. Auditoria
+- [ ] Registrar cada execução com entradas, saídas, status e artefatos
+- [ ] Incluir timestamps, URLs, volume de dados e erros
+- [ ] Manter trilha de decisões (por que fallback, por que retry)
+
+## Plataformas com restrições conhecidas
+
+| Plataforma | Restrição | Ação permitida |
+|-----------|-----------|---------------|
+| LinkedIn | Proíbe bots/crawlers/extensões que automatizam | Gerar textos + checklist; execução manual |
+| Facebook/Instagram | Restrições em automação de perfil | Usar APIs oficiais com aprovação |
+| Twitter/X | Rate limits estritos na API | Usar API oficial com chave própria |
+| Google (busca) | Custom Search com limites; descontinuação prevista | Usar SerpAPI/Brave como alternativa |
+
+## Nota sobre skills de terceiros
+Skills de terceiros devem ser **revisadas antes de uso**. Há relatos públicos de skills maliciosas em marketplaces/registries. Tratar como código não confiável e preferir execuções sandboxed.

package/templates/.agent/skills/content-sourcer/SKILL.md

@@ -0,0 +1,48 @@
+---
+name: content-sourcer
+description: Busca fontes públicas e gera um "dossiê citável" (links + trechos) para alimentar posts e páginas.
+triggers:
+  - buscar fontes
+  - referências
+  - pesquisa web
+  - dossiê
+  - fontes
+  - pesquisar
+  - research
+---
+
+# Content Sourcer
+
+## Objetivo
+Pesquisar fontes públicas sobre um tema e gerar um dossiê citável com links, trechos e relevância, útil para posts, artigos, apresentações e projetos.
+
+## Contexto necessário
+- Tema de pesquisa
+- País/idioma preferido
+- Critérios de qualidade (recência, autoridade, fontes primárias)
+
+## Fluxo (inspect → plan → apply → audit)
+
+1. **INSPECT**: Escolher provedor de busca e validar orçamento (queries disponíveis)
+2. **PLAN**: Definir queries, critérios de filtragem e quantidade de fontes
+3. **APPLY**: Executar busca, extrair resumo por fonte, salvar em `.agent/state/research/`
+4. **AUDIT**: Registrar queries executadas, provedores usados e custos estimados
+
+## Provedores de busca suportados
+
+| Provedor | Free tier | Limites | Nota |
+|---------|---------|--------|------|
+| SerpAPI | 250 buscas/mês (free) | Throughput/hora definido | Amplo (Google, Bing, etc.) |
+| Brave Search API | US$ 5 créditos/mês | Preço por 1.000 queries | Boa relação custo/qualidade |
+| Google Custom Search | 100 queries/dia (free) | Descontinuação prevista (2027) | Usar com cautela |
+
+## Requisitos de segurança
+- ✅ Usar API keys do próprio usuário (nunca embutir chaves no skill)
+- ✅ Respeitar limites de taxa e quotas dos provedores
+- ✅ Citar fontes com links completos (transparência)
+- ❌ Nunca plagiar conteúdo (apenas resumir e citar)
+- ❌ Nunca gastar créditos sem confirmar com o usuário
+
+## Armazenamento
+- `.agent/state/research/` — dossiês por tema/data
+- `.agent/audit/` — log com queries, custos e provedores

package/templates/.agent/skills/context-flush/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: context-flush
+description: Resume contexto útil e propõe anexar a MEMORY.md e/ou history do Mission Control; só aplica com consentimento.
+triggers:
+  - flush
+  - limpar contexto
+  - resumir
+  - economizar tokens
+  - reset
+---
+
+# Context Flush (economia)
+
+## Fluxo
+1) Produzir um resumo curto com:
+   - objetivo atual
+   - decisões tomadas
+   - pendências
+   - links/arquivos relevantes
+2) Propor onde salvar:
+   - `.agent/state/MEMORY.md` (por projeto) ou `MEMORY.md` do workspace
+   - `.agent/state/mission_control.json` (history)
+3) Mostrar PLANO: quais arquivos seriam alterados e como.
+4) Perguntar: "Posso aplicar?"
+5) Se aprovado, anexar e registrar auditoria.
+
+## Regras
+- Nunca apagar histórico automaticamente.
+- Nunca rodar reset automaticamente.
+- Sempre deixar o usuário decidir.

package/templates/.agent/skills/drive-organizer/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: drive-organizer
+description: Organiza arquivos no Google Drive (renomear, mover, criar pastas, padronizar nomenclatura) usando Drive API com OAuth e escopo mínimo.
+triggers:
+  - google drive
+  - organizar drive
+  - renomear arquivos
+  - mover para pasta
+  - drive
+  - arquivos nuvem
+---
+
+# Drive Organizer
+
+## Objetivo
+Organizar, renomear e categorizar arquivos no Google Drive de forma segura e auditável, usando a Drive API com o escopo `drive.file` (mínimo privilégio).
+
+## Contexto necessário
+- Objetivo da organização (taxonomia/padrão)
+- Pasta raiz alvo
+- Regras de nomenclatura
+
+## Fluxo (inspect → plan → consent → apply → validate → audit)
+
+1. **INSPECT** (read-only): Listar arquivos selecionados + simular mudanças
+2. **PLAN**: Tabela "antes/depois" e quantidade de mudanças previstas
+3. **CONSENT**: Confirmação reforçada se houver sobrescrita ou conflito de nomes
+4. **APPLY**: Executar via Drive API + registrar audit (IDs, mudanças, erros)
+5. **VALIDATE**: Re-listar e conferir consistência
+
+## Requisitos de segurança
+- ✅ Usar OAuth 2.0 (sem senha) — fluxo para apps instalados
+- ✅ Preferir escopo `drive.file` (usuário escolhe quais arquivos compartilhar)
+- ✅ Confirmar antes de mover/renomear em lote
+- ❌ Nunca armazenar refresh tokens em texto puro
+- ❌ Nunca acessar arquivos fora do escopo autorizado
+
+## Armazenamento de state
+- `.agent/state/drive/last_operation.json` — resultado da última operação
+- `.agent/audit/` — log completo com IDs de arquivos e mudanças aplicadas

package/templates/.agent/skills/linkedin-optimizer/SKILL.md

@@ -0,0 +1,48 @@
+---
+name: linkedin-optimizer
+description: Ajuda a otimizar perfil e posts para LinkedIn (texto, SEO social, CTA). Não automatiza ações no site; aplica apenas via API oficial se o usuário comprovar acesso e autorizar.
+triggers:
+  - linkedin
+  - otimizar perfil
+  - headline
+  - sobre
+  - post
+  - rede social
+---
+
+# LinkedIn Optimizer
+
+## Objetivo
+Gerar textos otimizados para perfil e posts do LinkedIn, seguindo boas práticas de SEO social e copywriting.
+
+**IMPORTANTE**: Esta skill **nunca** automatiza ações diretamente no LinkedIn. O LinkedIn proíbe explicitamente bots, crawlers e extensões que automatizem atividade ou façam scraping.
+
+## Modo de operação
+
+### Human-in-the-loop (padrão recomendado)
+1. O agente gera rascunhos e checklists
+2. O usuário aplica manualmente no LinkedIn
+3. Nenhum browser automation permitido
+
+### API oficial (condicional)
+Somente se o usuário comprovar acesso à Marketing Developer Platform com credenciais OAuth válidas e aprovadas pelo LinkedIn.
+
+## Contexto necessário
+- Objetivo (carreira, negócio, personal branding)
+- Público-alvo
+- Tom de voz desejado
+- Idioma (pt-BR, en-US, etc.)
+
+## Fluxo (inspect → plan → consent → apply → audit)
+
+1. **INSPECT**: Coletar conteúdo atual (texto fornecido pelo usuário) e metas
+2. **PLAN**: Propor 2 versões (A/B) com rationale e checklist de ajustes
+3. **CONSENT**: Pedir autorização antes de salvar qualquer rascunho
+4. **APPLY** (opcional): Salvar rascunho em `.agent/state/linkedin/drafts.md` + audit
+5. **DONE**: Instruções de publicação manual + tracking (UTM/links)
+
+## Restrições de segurança
+- ❌ Proibido usar Playwright/Puppeteer/Selenium para navegar no LinkedIn
+- ❌ Proibido armazenar credenciais do LinkedIn
+- ✅ Permitido gerar texto otimizado e salvar como rascunho local
+- ✅ Permitido usar API oficial com OAuth se o usuário tiver acesso aprovado

package/templates/.agent/skills/mission-control/SKILL.md

@@ -0,0 +1,37 @@
+---
+name: mission-control
+description: Orquestra a “Empresa de Agentes” via mission_control.json. Lê estado, cria tarefas, respeita dependências, executa em ticks e registra auditoria.
+triggers:
+  - mission control
+  - fila
+  - tarefas
+  - orquestrar
+  - equipe
+  - sprint
+  - tick
+---
+
+# Mission Control
+
+## Onde fica o estado (IDE / opção B)
+- `.agent/state/mission_control.json`
+- outputs em `.agent/state/mission_control/`
+
+## Regras
+- READ-ONLY por padrão.
+- Qualquer alteração no JSON ou criação de arquivos exige consentimento explícito.
+- Sempre gerar PLANO com: tarefas criadas/atualizadas, arquivos afetados, riscos.
+
+## Fluxo (Tick)
+1) Ler `mission_control.json`.
+2) Identificar tarefas `pending` cujo `depends_on` esteja resolvido.
+3) Selecionar até `max_tasks_per_tick` tarefas.
+4) Para cada tarefa:
+   - ativar persona do `role` (sem “shell solto”)
+   - executar a tarefa de forma segura
+   - salvar resultado em `output_file`
+   - atualizar status para `completed` (ou `failed`) com timestamp e notas
+5) Registrar resumo em `history`.
+
+## Consentimento reforçado
+Se `output_file` já existir e a ação for sobrescrever, mostrar resumo/diff e pedir confirmação reforçada.