@fabioforest/openclaw 3.0.0 → 3.4.1

package/lib/cli/orchestrate.js

@@ -6,6 +6,19 @@ const initCmd = require("./init");
 const doctorCmd = require("./doctor");
 const debugCmd = require("./debug");
 
+const readline = require("readline");
+
+function askQuestion(query) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => rl.question(query, (ans) => {
+        rl.close();
+        resolve(ans);
+    }));
+}
+
 module.exports = {
     run: async function ({ targetPath, flags }) {
         const agentDir = path.join(targetPath, ".agent");
@@ -15,29 +28,44 @@ module.exports = {
         if (!fs.existsSync(agentDir)) {
             console.log("⚠️  Instalação não encontrada.");
             console.log("🚀 Iniciando processo de instalação (init)...");
-
-            // Repassa flags, força path atual
             await initCmd.run({ targetPath, flags });
             return;
         }
 
-        console.log("✅ Instalação detectada.");
-        console.log("🏥 Executando verificação de saúde (doctor)...");
+        console.log("✅ Instalação detectada! Contexto preservado.");
+        console.log("   (Arquivos em .agent/ encontrados)\n");
 
-        try {
-            // Doctor lança erro ou exit(1) se falhar? 
-            // Precisamos capturar o exit code do doctor se ele for desenhado para matar o processo.
-            // O doctor atual usa exit(1) em erros críticos ou apenas loga?
-            // Vamos checar o doctor depois. Por enquanto, assumimos que ele roda.
+        console.log("O que deseja fazer?");
+        console.log("  [1] 🏥 Verificar Saúde (Doctor) - Recomendado");
+        console.log("  [2] 🔄 Atualizar (Safe Merge) - Adiciona novidades, mantém edições");
+        console.log("  [3] ⚠️  Reinstalar (Force) - ALERTA: Sobrescreve TUDO");
+        console.log("  [4] 🚪 Sair\n");
 
-            await doctorCmd.run({ targetPath, flags });
+        const ans = await askQuestion("Escolha uma opção [1-4]: ");
+        const choice = ans.trim();
 
-            console.log("\n✨ Sistema parece saudável.");
-        } catch (err) {
-            console.log("\n❌ Doctor encontrou problemas ou falhou.");
-            console.log("🔍 Iniciando diagnóstico avançado (debug)...");
+        console.log(""); // quebra de linha
 
-            await debugCmd.run({ targetPath, flags });
+        if (choice === "1" || choice === "") {
+            console.log("🏥 Iniciando Doctor...");
+            await doctorCmd.run({ targetPath, flags });
+        } else if (choice === "2") {
+            console.log("🔄 Iniciando Safe Merge...");
+            // Como o usuário já confirmou interativamente aqui, passamos apply + yes
+            const safeFlags = { ...flags, merge: true, apply: true, yes: true };
+            await initCmd.run({ targetPath, flags: safeFlags });
+        } else if (choice === "3") {
+            const confirm = await askQuestion("Tem certeza? Isso apagará todas as suas customizações em .agent/. Digite 'sim' para confirmar: ");
+            if (confirm.toLowerCase() === "sim") {
+                console.log("⚠️  Iniciando Reinstalação Forçada...");
+                // Aqui passamos force, apply e yes (já confirmou a string "sim")
+                const forceFlags = { ...flags, force: true, apply: true, yes: true };
+                await initCmd.run({ targetPath, flags: forceFlags });
+            } else {
+                console.log("⏹️  Cancelado.");
+            }
+        } else {
+            console.log("👋 Saindo.");
         }
     }
 };

package/lib/cli/update.js

@@ -12,14 +12,38 @@
 const fs = require("fs");
 const path = require("path");
 const crypto = require("crypto");
+const readline = require("readline");
+const { detectContext, getAuditHeader } = require("../context");
 
 // Caminho dos templates incluídos no pacote
 const TEMPLATES_DIR = path.join(__dirname, "..", "..", "templates", ".agent");
 
+function ask(q) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((res) => rl.question(q, (ans) => { rl.close(); res(ans.trim()); }));
+}
+
+function safeRel(targetPath, p) {
+    return path.relative(targetPath, p);
+}
+
+function writeAudit(targetPath, lines, flags) {
+    if (flags.audit === false) return;
+    const auditDir = path.join(targetPath, ".agent", "audit");
+    if (!fs.existsSync(auditDir)) {
+        try { fs.mkdirSync(auditDir, { recursive: true }); } catch (e) { }
+    }
+    const filename = `update-${new Date().toISOString().replace(/[:.]/g, "-")}.md`;
+    const auditPath = path.join(auditDir, filename);
+    try {
+        fs.writeFileSync(auditPath, lines.join("\n") + "\n", "utf8");
+    } catch (e) {
+        console.error("⚠️  Falha ao gravar auditoria:", e.message);
+    }
+}
+
 /**
- * Calcula o SHA-256 de um arquivo.
- * @param {string} filePath — caminho do arquivo
- * @returns {string} hash em hex
+ * Calcula o SHA-256 de um arquivo (Utilitário mantido)
  */
 function fileHash(filePath) {
     const content = fs.readFileSync(filePath);
@@ -27,14 +51,13 @@ function fileHash(filePath) {
 }
 
 /**
- * Compara e atualiza um diretório recursivamente.
- * @param {string} src — diretório fonte (template)
- * @param {string} dest — diretório destino (instalado)
- * @param {object} stats — contadores { updated, skipped, added }
+ * Analisa atualizações necessárias.
+ * Retorna lista de ações planejadas.
  */
-function updateDirRecursive(src, dest, stats) {
+function planUpdates(src, dest, actions = { added: [], updated: [], skipped: [] }) {
     if (!fs.existsSync(dest)) {
-        fs.mkdirSync(dest, { recursive: true });
+        // Diretório não existe no destino, será criado implicitamente na cópia
+        // Mas a lógica recursiva precisa entrar
     }
 
     const entries = fs.readdirSync(src, { withFileTypes: true });
@@ -44,79 +67,122 @@ function updateDirRecursive(src, dest, stats) {
         const destPath = path.join(dest, entry.name);
 
         if (entry.isDirectory()) {
-            updateDirRecursive(srcPath, destPath, stats);
+            if (!fs.existsSync(destPath)) {
+                // Diretório novo, tudo dentro será added
+                // Simplificação: marcar diretório como added e não recursar? 
+                // Melhor recursar para listar arquivos
+            }
+            planUpdates(srcPath, destPath, actions);
         } else {
             if (!fs.existsSync(destPath)) {
-                // Arquivo novo — copiar
-                fs.copyFileSync(srcPath, destPath);
-                stats.added.push(path.relative(dest, destPath) || entry.name);
+                actions.added.push({ src: srcPath, dest: destPath });
             } else {
-                // Arquivo já existe — comparar hashes
                 const srcHash = fileHash(srcPath);
                 const destHash = fileHash(destPath);
-
                 if (srcHash === destHash) {
-                    // Idêntico — nada a fazer
-                    stats.skipped.push(path.relative(dest, destPath) || entry.name);
+                    actions.skipped.push({ src: srcPath, dest: destPath });
                 } else {
-                    // Diferente — arquivo foi customizado ou template atualizado
-                    // Preserva o original do usuário fazendo backup
-                    const backupPath = destPath + ".bak";
-                    fs.copyFileSync(destPath, backupPath);
-                    fs.copyFileSync(srcPath, destPath);
-                    stats.updated.push(path.relative(dest, destPath) || entry.name);
+                    actions.updated.push({ src: srcPath, dest: destPath });
                 }
             }
         }
     }
+    return actions;
 }
 
 /**
- * Executa o comando update.
- * @param {object} options
- * @param {string} options.targetPath — diretório alvo
- * @param {object} options.flags — flags do CLI
+ * Executa o comando update com segurança.
  */
 async function run({ targetPath, flags }) {
     const agentDir = path.join(targetPath, ".agent");
+    const ctx = detectContext(targetPath);
+
+    // Default: Plan Mode
+    const planMode = !flags.apply;
 
     if (!fs.existsSync(agentDir)) {
         console.error("❌ Diretório .agent/ não encontrado.");
-        console.error("   Rode 'openclaw init' primeiro para instalar os templates.");
+        console.error("   Rode 'openclaw init' primeiro.");
         process.exit(1);
     }
-
     if (!fs.existsSync(TEMPLATES_DIR)) {
-        console.error("❌ Templates não encontrados. Pacote pode estar corrompido.");
+        console.error("❌ Templates não encontrados.");
         process.exit(1);
     }
 
-    if (!flags.quiet) {
-        console.log("\n🔄 OpenClaw Update — Atualizando templates...\n");
+    // 1. Planejar
+    const actions = planUpdates(TEMPLATES_DIR, agentDir);
+    const audit = [getAuditHeader(ctx, "update", flags)];
+
+    // 2. Exibir Plano
+    console.log(`\n🧭 Plano de Atualização (${planMode ? "SIMULAÇÃO" : "APPLY"}):\n`);
+    console.log(`   Contexto: ${ctx.env} | IDE: ${ctx.ide}\n`);
+
+    if (actions.added.length > 0) {
+        console.log(`📄 Novos (${actions.added.length}):`);
+        actions.added.forEach(a => console.log(`   + CREATE ${safeRel(targetPath, a.dest)}`));
+    }
+    if (actions.updated.length > 0) {
+        console.log(`\n🔄 Modificados (${actions.updated.length}):`);
+        actions.updated.forEach(a => console.log(`   ~ UPDATE ${safeRel(targetPath, a.dest)} (Backup gerado)`));
+    }
+    if (actions.skipped.length > 0) {
+        console.log(`\n⏭️  Ignorados (${actions.skipped.length} arquivos idênticos)`);
     }
 
-    const stats = { updated: [], skipped: [], added: [] };
-    updateDirRecursive(TEMPLATES_DIR, agentDir, stats);
+    if (actions.added.length === 0 && actions.updated.length === 0) {
+        console.log("\n✅ Tudo atualizado. Nenhuma alteração necessária.");
+        return;
+    }
+
+    if (planMode) {
+        console.log("\n🔒 Modo PLAN (Read-Only). Nenhuma alteração feita.");
+        console.log("   Para aplicar, rode: npx openclaw update --apply");
+        return;
+    }
 
-    if (!flags.quiet) {
-        if (stats.added.length > 0) {
-            console.log(`📄 Novos (${stats.added.length}):`);
-            stats.added.forEach((f) => console.log(`   + ${f}`));
+    // 3. Confirmação
+    if (!flags.yes) {
+        const ok = await ask("\nAplicar este plano? (y/N): ");
+        if (ok.toLowerCase() !== "y") {
+            console.log("⏹️  Cancelado.");
+            return;
+        }
+    }
+
+    // 4. Execução
+    try {
+        console.log("\n🚀 Executando atualizações...");
+
+        // Criar diretórios necessários
+        function ensureDir(p) {
+            const dir = path.dirname(p);
+            if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
         }
 
-        if (stats.updated.length > 0) {
-            console.log(`\n🔄 Atualizados (${stats.updated.length}):`);
-            stats.updated.forEach((f) => console.log(`   ~ ${f} (backup: ${f}.bak)`));
+        for (const action of actions.added) {
+            ensureDir(action.dest);
+            fs.copyFileSync(action.src, action.dest);
+            audit.push(`- ACT: CREATED ${safeRel(targetPath, action.dest)}`);
         }
 
-        if (stats.skipped.length > 0) {
-            console.log(`\n⏭️  Sem alteração (${stats.skipped.length}):`);
-            stats.skipped.forEach((f) => console.log(`   = ${f}`));
+        for (const action of actions.updated) {
+            ensureDir(action.dest);
+            const backupPath = action.dest + ".bak";
+            fs.copyFileSync(action.dest, backupPath);
+            fs.copyFileSync(action.src, action.dest);
+            audit.push(`- ACT: UPDATED ${safeRel(targetPath, action.dest)} (Backup: ${path.basename(backupPath)})`);
         }
 
-        const total = stats.added.length + stats.updated.length;
-        console.log(`\n✅ Update concluído: ${total} alterações, ${stats.skipped.length} mantidos\n`);
+        console.log("\n✨ Atualização concluída com sucesso!");
+        writeAudit(targetPath, audit, flags);
+
+    } catch (err) {
+        console.error(`\n❌ Falha na execução: ${err.message}`);
+        audit.push(`\n## ERROR: ${err.message}`);
+        writeAudit(targetPath, audit, flags);
+        process.exit(1);
     }
 }
 
-module.exports = { run, updateDirRecursive, fileHash };
+module.exports = { run, fileHash };

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.1",
+  "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.