@fabioforest/openclaw 3.8.0 → 3.10.0

package/README.md

@@ -425,6 +425,37 @@ Verifica conectividade, proxy, versões e integridade do ambiente.
 
 ---
 
+## 🤖 Agentes Especializados (Personas)
+
+O OpenClaw vem com **agentes pré-configurados** que combinam skills específicas para realizar funções complexas:
+
+| Persona | Foco | Skills Principais |
+|---------|------|-------------------|
+| **`sysadmin-proativo`** | Manutenção de servidores, logs, segurança | `vps-cloud-infra`, `openclaw-ops`, `openclaw-security` |
+| **`workflow-automator`** | Criação e execução de automações | `ai-capture`, `mission-control`, `openclaw-dev` |
+| **`setup-specialist`** | Onboarding e configuração inicial | `universal-setup`, `ai-provider-setup`, `openclaw-installation-debugger` |
+
+**Como usar:**
+Basta pedir no chat: *"Atue como sysadmin e verifique os logs do servidor"* ou *"Inicie o workflow-automator para criar uma automação de tickets"*. O `openclaw-router` ativará a persona correta.
+
+---
+
+## ⚡ Workflows Prontos
+
+Além de skills isoladas, o OpenClaw traz **fluxos de trabalho completos** (runbooks executáveis):
+
+| Workflow | Descrição | Comando Trigger |
+|----------|-----------|-----------------|
+| **`ai-capture`** | Captura inteligente de dados/tickets usando IA | *"Iniciar captura de dados"* |
+| **`doctor`** | Diagnóstico e reparo automático do ambiente | `openclaw doctor` |
+| **`healthcheck`** | Verificação rápida de saúde (API, DB, cache) | `openclaw healthcheck` |
+| **`restart-openclaw`** | Reinício seguro e auditado do serviço | `openclaw restart` |
+
+**Execução:**
+Workflows são arquivos `.md` em `.agent/workflows/` que o agente lê e executa passo a passo, garantindo consistência e auditoria.
+
+---
+
 ## 🔒 Segurança
 
 O OpenClaw segue 3 princípios fundamentais:

package/bin/openclaw.js

@@ -32,6 +32,7 @@ const COMMANDS = {
     inspect: "../lib/cli/inspect",
     assist: "../lib/cli/assist",
     ide: "../lib/cli/ide",
+    setup: "../lib/cli/setup",
 };
 
 /**
@@ -42,7 +43,8 @@ const COMMANDS = {
 function parseArgs(argv) {
     const flags = {
         plan: true, // Default: PLAN mode (read-only)
-        audit: true // Default: Generate audit logs
+        audit: true, // Default: Generate audit logs
+        _: [] // Captura subcomandos/args
     };
     let command = null;
 
@@ -61,7 +63,6 @@ function parseArgs(argv) {
             flags.quiet = true;
         } else if (arg === "--apply") {
             flags.apply = true;
-            flags.plan = false; // Apply overrides Plan default
         } else if (arg === "--plan") {
             flags.plan = true;
         } else if (arg === "--yes" || arg === "-y") {
@@ -70,13 +71,21 @@ function parseArgs(argv) {
             flags.audit = false;
         } else if (arg === "--merge") {
             flags.merge = true;
-        } else if (!arg.startsWith("-") && !command) {
-            command = arg;
+        } else if (!arg.startsWith("-")) {
+            if (!command) {
+                command = arg;
+            } else {
+                flags._.push(arg); // Captura subcomandos/args
+            }
         }
     }
 
-    // Se apply foi passado, plan é false (a menos que forçado explicitamente, mas apply vence na lógica acima)
-    // Se o usuário não passar nada, plan=true (default)
+    // Regra de precedência: apply sempre vence plan
+    if (flags.apply) flags.plan = false;
+
+    // Constrói ajudantes semânticos a partir de _
+    flags.subcommand = flags._[0] || null;
+    flags.args = flags._.slice(1);
 
     return { command, flags };
 }
@@ -145,18 +154,6 @@ async function main() {
     // Resolver caminho de destino
     const targetPath = path.resolve(flags.path || ".");
 
-    // Comando setup — roda wizard diretamente
-    if (command === "setup") {
-        const wizardPath = path.join(__dirname, "..", "lib", "setup", "config_wizard.js");
-        try {
-            require(wizardPath);
-        } catch (err) {
-            console.error(`❌ Erro ao rodar setup wizard: ${err.message}`);
-            process.exit(1);
-        }
-        return;
-    }
-
     // Verificar se o comando existe
     if (!COMMANDS[command]) {
         console.error(`❌ Comando desconhecido: "${command}"`);

package/lib/cli/ide.js

@@ -14,6 +14,7 @@ const readline = require("readline");
 const { detectContext, getAuditHeader } = require("../context");
 const { copyDirRecursive } = require("./init");
 const { writeCliAudit } = require("../utils/audit-writer");
+const { guardPlan } = require("../utils/scope_guard");
 
 // Caminho dos templates do pacote
 const TEMPLATES_DIR = path.join(__dirname, "..", "..", "templates");
@@ -28,21 +29,9 @@ function writeAudit(targetPath, lines, flags) {
     writeCliAudit(targetPath, lines, flags, "ide");
 }
 
-/**
- * Executa o comando ide.
- * Uso: openclaw ide install [--apply] [--force]
- *      openclaw ide doctor
- *
- * @param {object} options
- * @param {string} options.targetPath — diretório alvo
- * @param {object} options.flags — flags do CLI
- */
 async function run({ targetPath, flags }) {
-    // Detectar sub-comando a partir de args restantes
-    // O bin/openclaw.js passa o comando "ide", então precisamos
-    // verificar os args para o sub-comando
-    const args = process.argv.slice(3);
-    const subCmd = args.find(a => !a.startsWith("-")) || "install";
+    // Detectar sub-comando alinhado com o parseArgs global
+    const subCmd = flags.subcommand || "install";
 
     if (subCmd === "doctor") {
         return runDoctor({ targetPath, flags });
@@ -84,6 +73,16 @@ async function runInstall({ targetPath, flags }) {
         console.log("  ✅ KEEP    .agent/state/ (já existe)");
     }
 
+    // 2.5 Scope Guard
+    const intents = { writes: [agentDst, stateDir], deletes: [], overwrites: [] };
+    // Se for um force, significa que um overwrite/delete de diretório ocorrerá
+    if (fs.existsSync(agentDst) && flags.force) {
+        intents.deletes.push(agentDst);
+        intents.overwrites.push(agentDst);
+    }
+
+    await guardPlan(targetPath, intents, flags);
+
     if (planMode) {
         console.log("\n🔒 Modo PLAN (Read-Only). Nenhuma alteração feita.");
         console.log("   Para aplicar, rode: npx openclaw ide install --apply");
@@ -173,7 +172,7 @@ async function runDoctor({ targetPath }) {
 
     // Verificar rules
     const rulesDir = path.join(agentDir, "rules");
-    const requiredRules = ["CONSENT_FIRST.md", "ROUTER_PROTOCOL.md"];
+    const requiredRules = ["CONSENT_FIRST.md", "ROUTER_PROTOCOL.md", "SECURITY.md", "WEB_AUTOMATION.md"];
     for (const rule of requiredRules) {
         checks.push({ name: `rules/${rule}`, ok: fs.existsSync(path.join(rulesDir, rule)) });
     }
@@ -189,6 +188,11 @@ async function runDoctor({ targetPath }) {
     const hooksDir = path.join(agentDir, "hooks");
     checks.push({ name: "hooks/pre-tool-use.js", ok: fs.existsSync(path.join(hooksDir, "pre-tool-use.js")) });
 
+    // Verificar State Persistence
+    const stateDir = path.join(agentDir, "state");
+    checks.push({ name: "state/mission_control.json", ok: fs.existsSync(path.join(stateDir, "mission_control.json")) });
+    checks.push({ name: "state/MEMORY.md", ok: fs.existsSync(path.join(stateDir, "MEMORY.md")) });
+
     // Exibir resultado
     let allOk = true;
     for (const c of checks) {

package/lib/cli/init.js

@@ -14,6 +14,7 @@ const readline = require("readline");
 const { initConfigDefaults, writeJsonSafe } = require("../config");
 const { detectContext, getAuditHeader } = require("../context");
 const { writeCliAudit } = require("../utils/audit-writer");
+const { guardPlan } = require("../utils/scope_guard");
 
 // Caminho dos templates incluídos no pacote
 const TEMPLATES_DIR = path.join(__dirname, "..", "..", "templates", ".agent");
@@ -107,6 +108,17 @@ async function run({ targetPath, flags }) {
         actions.push({ type: "NOOP", path: configPath, reason: "Config exists" });
     }
 
+    // 2.5. Acionar Scope Guard
+    const intents = { writes: [], deletes: [], overwrites: [] };
+    for (const a of actions) {
+        if (a.type === "DELETE_DIR") intents.deletes.push(a.path);
+        if (a.type === "CREATE_DIR") intents.writes.push(a.path);
+        if (a.type === "CREATE_FILE") intents.writes.push(a.path);
+        if (a.type === "COPY_DIR" || a.type === "MERGE_DIR") intents.writes.push(a.to);
+    }
+
+    await guardPlan(targetPath, intents, flags);
+
     // 3. Exibir Plano
     console.log(`\n🧭 Plano de Execução (${planMode ? "SIMULAÇÃO" : "APPLY"}):\n`);
     console.log(`   Contexto: ${ctx.env} | IDE: ${ctx.ide}\n`);
@@ -122,7 +134,7 @@ async function run({ targetPath, flags }) {
 
     if (planMode) {
         console.log("\n🔒 Modo PLAN (Read-Only). Nenhuma alteração feita.");
-        console.log("   Para aplicar, rode: npx openclaw init --apply [--merge|--force]");
+        console.log("   Para aplicar, rode o comando com --apply");
         return;
     }
 

package/lib/cli/setup.js

@@ -0,0 +1,25 @@
+const path = require("path");
+
+module.exports = {
+  async run({ targetPath, flags, templatesDir }) {
+    // Regras propostas pelo usuario:
+    // - default é PLAN (flags.plan true no bin/openclaw.js)
+    // - APPLY só com --apply
+    // - Não alterar nada fora de --apply
+    const wizard = require(path.join(__dirname, "..", "setup", "config_wizard.js"));
+
+    const base = targetPath || process.cwd();
+
+    // Mantendo consistência com os outros comandos que exportam .run() e recebem { targetPath, flags }
+    return wizard({
+      base,
+      flags: {
+        plan: flags.plan !== false,   // default true
+        apply: !!flags.apply,         // só executa com apply
+        yes: !!flags.yes,             // skip prompts (ainda assim não faz nada se não apply)
+        force: !!flags.force,         // para ações destrutivas (se você quiser usar)
+      },
+      templatesDir,
+    });
+  }
+};

package/lib/cli/uninstall.js

@@ -15,6 +15,7 @@ const fs = require("fs");
 const path = require("path");
 const readline = require("readline");
 const { detectContext, getAuditHeader } = require("../context");
+const { guardPlan } = require("../utils/scope_guard");
 
 function ask(q) {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
@@ -103,6 +104,10 @@ async function run({ targetPath, flags }) {
         console.log(`   🔴 REMOVER  openclaw.json`);
     }
 
+    // Acionar Scope Guard para todos os deletes listados
+    const intents = { writes: [], deletes: toRemove.map(i => i.path), overwrites: [] };
+    await guardPlan(targetPath, intents, flags);
+
     // Verificar audit logs que seriam perdidos
     const auditDir = path.join(agentDir, "audit");
     if (fs.existsSync(auditDir)) {

package/lib/cli/update.js

@@ -15,6 +15,7 @@ const crypto = require("crypto");
 const readline = require("readline");
 const { detectContext, getAuditHeader } = require("../context");
 const { writeCliAudit } = require("../utils/audit-writer");
+const { guardPlan } = require("../utils/scope_guard");
 
 // Caminho dos templates incluídos no pacote
 const TEMPLATES_DIR = path.join(__dirname, "..", "..", "templates", ".agent");
@@ -41,14 +42,36 @@ function fileHash(filePath) {
     return crypto.createHash("sha256").update(content).digest("hex");
 }
 
+/**
+ * Simples gerador de diff rústico mas efetivo para CLI
+ */
+function simpleDiff(oldStr, newStr) {
+    const oldLines = oldStr.split("\n");
+    const newLines = newStr.split("\n");
+    let diffStr = "";
+
+    const maxLength = Math.max(oldLines.length, newLines.length);
+    let diffCount = 0;
+
+    for (let i = 0; i < maxLength && diffCount < 10; i++) {
+        if (oldLines[i] !== newLines[i]) {
+            if (oldLines[i] !== undefined) diffStr += `\x1b[31m- ${oldLines[i]}\x1b[0m\n`;
+            if (newLines[i] !== undefined) diffStr += `\x1b[32m+ ${newLines[i]}\x1b[0m\n`;
+            diffCount++;
+        }
+    }
+    if (diffCount >= 10) diffStr += `\x1b[90m... (diff truncado para 10 linhas)\x1b[0m\n`;
+
+    return diffStr || "  (Nenhuma diferença detetada no payload comparável)";
+}
+
 /**
  * Analisa atualizações necessárias.
  * Retorna lista de ações planejadas.
  */
 function planUpdates(src, dest, actions = { added: [], updated: [], skipped: [] }) {
     if (!fs.existsSync(dest)) {
-        // Diretório não existe no destino, será criado implicitamente na cópia
-        // Mas a lógica recursiva precisa entrar
+        // Diretório não existe no destino, será acompanhado na copia de arquivos
     }
 
     const entries = fs.readdirSync(src, { withFileTypes: true });
@@ -105,6 +128,12 @@ async function run({ targetPath, flags }) {
     const actions = planUpdates(TEMPLATES_DIR, agentDir);
     const audit = [getAuditHeader(ctx, "update", flags)];
 
+    // 1.5 Acionar Scope Guard
+    const intents = { writes: [], deletes: [], overwrites: [] };
+    for (const a of actions.added) intents.writes.push(a.dest);
+    for (const a of actions.updated) intents.overwrites.push(a.dest);
+    await guardPlan(targetPath, intents, 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`);
@@ -115,7 +144,9 @@ async function run({ targetPath, flags }) {
     }
     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)`));
+        actions.updated.forEach(a => {
+            console.log(`   ~ UPDATE ${safeRel(targetPath, a.dest)} (Exige confirmação interativa)`);
+        });
     }
     if (actions.skipped.length > 0) {
         console.log(`\n⏭️  Ignorados (${actions.skipped.length} arquivos idênticos)`);
@@ -128,20 +159,21 @@ async function run({ targetPath, flags }) {
 
     if (planMode) {
         console.log("\n🔒 Modo PLAN (Read-Only). Nenhuma alteração feita.");
-        console.log("   Para aplicar, rode: npx openclaw update --apply");
+        console.log("   Dica: a opção --merge foi desativada no modo interativo para forçar diff por arquivo.");
+        console.log("   Para aplicar e resolver conflitos: npx openclaw update --apply");
         return;
     }
 
-    // 3. Confirmação
-    if (!flags.yes) {
-        const ok = await ask("\nAplicar este plano? (y/N): ");
+    // 3. Confirmação inicial
+    if (!flags.yes && actions.updated.length === 0) {
+        const ok = await ask("\nAplicar e copiar arquivos novos? (y/N): ");
         if (ok.toLowerCase() !== "y") {
             console.log("⏹️  Cancelado.");
             return;
         }
     }
 
-    // 4. Execução
+    // 4. Execução Interativa Segura (Conflitos file-by-file)
     try {
         console.log("\n🚀 Executando atualizações...");
 
@@ -151,18 +183,42 @@ async function run({ targetPath, flags }) {
             if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
         }
 
+        // Action: Added
         for (const action of actions.added) {
             ensureDir(action.dest);
             fs.copyFileSync(action.src, action.dest);
             audit.push(`- ACT: CREATED ${safeRel(targetPath, action.dest)}`);
         }
 
+        // Action: Updated (Conflict Resolver)
         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 rPath = safeRel(targetPath, action.dest);
+
+            let overwrite = flags.yes || flags.force;
+
+            if (!overwrite) {
+                console.log(`\n⚠️ CONFLITO DETECTADO: ${rPath}`);
+                console.log("------------------------------------------------");
+                const oldContent = fs.readFileSync(action.dest, "utf-8");
+                const newContent = fs.readFileSync(action.src, "utf-8");
+                console.log(simpleDiff(oldContent, newContent));
+                console.log("------------------------------------------------");
+
+                const ans = await ask(`Substituir a sua versão de ${rPath} pelo código acima? [y/N]: `);
+                overwrite = ans.toLowerCase() === "y";
+            }
+
+            if (overwrite) {
+                const backupPath = action.dest + ".bak";
+                fs.copyFileSync(action.dest, backupPath);
+                fs.copyFileSync(action.src, action.dest);
+                console.log(`✅ Sobrescrito: ${rPath} (Backup guardado localmente: .bak)`);
+                audit.push(`- ACT: UPDATED ${rPath} (Backup: ${path.basename(backupPath)})`);
+            } else {
+                console.log(`⏭️  Ignorado (Mantido customização em ${rPath})`);
+                audit.push(`- ACT: SKIPPED UPDATE FOR CUSTOMIZED FILE ${rPath}`);
+            }
         }
 
         console.log("\n✨ Atualização concluída com sucesso!");

package/lib/setup/config_wizard.js

@@ -1,188 +1,266 @@
-#!/usr/bin/env node
-/**
- * OpenClaw OS - Universal Setup Wizard
- * 
- * Orquestrador principal que delega para os módulos lib/:
- * - detect.js  → detecção de ambiente (Docker/WSL2/Mac/Linux/VPS)
- * - config.js  → leitura/escrita JSON atômica + defaults
- * - security.js → tokens, masking e verificação de porta
- * - channels.js → validação e configuração de canais
- * 
- * Princípios:
- * - Seguro por padrão: bind localhost + auth token
- * - Cross-platform: detecção automática de ambiente
- * - Não destrutivo: nunca sobrescreve sem confirmação
- * 
- * @module config_wizard
- * @version 2.0.0
- * @author OpenClaw DevOps
- */
+// lib/setup/config_wizard.js
 const fs = require("fs");
 const os = require("os");
 const path = require("path");
-const readline = require("readline");
+const crypto = require("crypto");
 
-// Módulos extraídos para lib/ — cada um com responsabilidade única
+// Módulos extraídos para lib/
 const { detectEnvironment } = require("../detect");
-const { readJsonSafe, writeJsonSafe, ensureFile, initConfigDefaults } = require("../config");
+const { readJsonSafe, writeJsonSafe, initConfigDefaults } = require("../config");
 const { mask, generateToken, portInUse } = require("../security");
 const { supportedChannels, configureChannel } = require("../channels");
 
-/** Interface readline para perguntas interativas */
-const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-
-/**
- * Faz uma pergunta ao usuário via stdin e retorna a resposta trimada.
- * @param {string} q - A pergunta a ser exibida
- * @returns {Promise<string>} Resposta do usuário (trimada)
- */
-function ask(q) { return new Promise(res => rl.question(q, ans => res(ans.trim()))); }
-
-/**
- * Função principal do wizard de setup.
- * Orquestra todo o fluxo interativo:
- * 1. Detecta ambiente
- * 2. Configura gateway (bind + auth)
- * 3. Gera/solicita token de autenticação
- * 4. Sugere sandbox em VPS
- * 5. Configura canais (Telegram/Discord/WhatsApp)
- * 6. Configura allowlist de filesystem
- * 7. Cria arquivos de persistência (MEMORY.md, SOUL.md, AGENTS.md)
- * 8. Verifica porta 18789
- * 9. Sugere hardening em VPS
- * @returns {Promise<void>}
- */
-async function main() {
-  console.log("\n🧠 OpenClaw OS — Universal Setup Wizard\n");
-
-  // --- 1. Detecção de ambiente (delegado para lib/detect) ---
+// util simples
+function exists(p) { try { return fs.existsSync(p); } catch { return false; } }
+
+async function ask(prompt) {
+  const readline = require("readline");
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((res) => rl.question(prompt, (ans) => { rl.close(); res(ans.trim()); }));
+}
+
+// CONSENT-FIRST: cria arquivo somente com apply + confirmação
+async function ensureFileWithConsent({ filePath, content, flags }) {
+  if (exists(filePath)) {
+    console.log(`✅ KEEP   ${path.basename(filePath)} (já existe)`);
+    return { changed: false };
+  }
+
+  console.log(`📝 PLAN   criar ${path.basename(filePath)} (não existe)`);
+
+  if (!flags.apply) {
+    return { changed: false, planned: true };
+  }
+
+  if (!flags.yes) {
+    const ok = (await ask(`Criar ${path.basename(filePath)}? (y/N): `)).toLowerCase() === "y";
+    if (!ok) {
+      console.log(`⏹️  SKIP  ${path.basename(filePath)}`);
+      return { changed: false };
+    }
+  }
+
+  fs.writeFileSync(filePath, content, "utf8");
+  console.log(`✅ DONE  ${path.basename(filePath)}`);
+  return { changed: true };
+}
+
+function deepClone(obj) {
+  return JSON.parse(JSON.stringify(obj));
+}
+
+function diffKeys(before, after) {
+  // diff simples: mostra chaves alteradas
+  const changes = [];
+  const walk = (a, b, prefix = "") => {
+    const keys = new Set([...Object.keys(a || {}), ...Object.keys(b || {})]);
+    for (const k of keys) {
+      const p = prefix ? `${prefix}.${k}` : k;
+      const va = a ? a[k] : undefined;
+      const vb = b ? b[k] : undefined;
+      const oba = va && typeof va === "object" && !Array.isArray(va);
+      const obb = vb && typeof vb === "object" && !Array.isArray(vb);
+      if (oba && obb) walk(va, vb, p);
+      else if (JSON.stringify(va) !== JSON.stringify(vb)) changes.push(p);
+    }
+  };
+  walk(before, after, "");
+  return changes;
+}
+
+module.exports = async function configWizard({ base, flags, templatesDir } = {}) {
+  const targetBase = base || process.cwd();
+  const f = flags || { plan: true, apply: false, yes: false, force: false };
+
+  // Segurança: default é PLAN (se alguém chamar sem flags)
+  if (!("apply" in f) && !("plan" in f)) {
+    f.plan = true;
+    f.apply = false;
+  }
+
+  console.log("\n🧙 OpenClaw Setup Wizard — CONSENT-FIRST");
+  console.log(`📍 Base: ${targetBase}`);
+  console.log(`🧪 Mode: ${f.apply ? "APPLY" : "PLAN (read-only)"}`);
+
   const env = detectEnvironment();
-  console.log(`Ambiente detectado: ${env}`);
-
-  const base = process.cwd();
-  const configPath = path.join(base, "openclaw.json");
-
-  // --- 2. Leitura da configuração existente (delegado para lib/config) ---
-  let config = {};
-  if (fs.existsSync(configPath)) {
-    const parsed = readJsonSafe(configPath);
-    if (!parsed) {
-      console.error("✖ openclaw.json existe mas não é um JSON válido. Corrija e rode novamente.");
-      process.exit(2);
+  console.log(`🌍 Ambiente: ${env}`);
+
+  const configPath = path.join(targetBase, "openclaw.json");
+  const hasConfig = exists(configPath);
+
+  // 1) Inspecionar contexto
+  console.log("\n1) Contexto:");
+  console.log(`- openclaw.json: ${hasConfig ? "encontrado" : "não encontrado"}`);
+
+  // Se não tem config, em PLAN só sugere; em APPLY pergunta se quer criar.
+  let config = hasConfig ? readJsonSafe(configPath) : null;
+  if (!config) {
+    console.log("\n📝 PLAN   criar openclaw.json (não existe ou inválido)");
+    if (!f.apply) {
+      console.log("ℹ️  Dica: rode `openclaw setup --apply` para criar/configurar.");
+    } else {
+      if (!f.yes) {
+        const ok = (await ask("Criar openclaw.json básico? (y/N): ")).toLowerCase() === "y";
+        if (!ok) {
+          console.log("❎ Cancelado. Nenhuma alteração feita.");
+          return;
+        }
+      }
+      config = {};
     }
-    config = parsed;
   }
 
-  // Inicializa seções padrão sem sobrescrever existentes
-  config = initConfigDefaults(config);
+  // Se chegou aqui e config ainda é null (por PLAN, por exemplo), vamos simular o defaults para o diff
+  if (!config) config = {};
 
-  let needWrite = !fs.existsSync(configPath);
+  // 2) Propor ajustes seguros (NÃO aplicar ainda)
+  const before = deepClone(config);
 
-  // --- 3. gateway.bind: segurança por padrão (localhost only) ---
-  const desiredBind = "127.0.0.1";
-  if (config.gateway.bind !== desiredBind) {
-    const ans = await ask(`gateway.bind está "${config.gateway.bind ?? "(vazio)"}". Ajustar para "${desiredBind}"? (y/n): `);
-    if (ans.toLowerCase() === "y") { config.gateway.bind = desiredBind; needWrite = true; }
-  } else {
-    console.log("✔ gateway.bind já está seguro (127.0.0.1)");
+  config = initConfigDefaults(config);
+
+  // gateway.bind seguro
+  config.gateway = config.gateway || {};
+  config.gateway.bind = config.gateway.bind || "127.0.0.1";
+  if (config.gateway.bind !== "127.0.0.1") {
+    if (f.apply) {
+      const ans = f.yes ? "y" : await ask(`gateway.bind está "${config.gateway.bind}". Ajustar para "127.0.0.1"? (y/n): `);
+      if (ans.toLowerCase() === "y") config.gateway.bind = "127.0.0.1";
+    } else {
+      config.gateway.bind = "127.0.0.1"; // Simulando a mudança para o diff no modo PLAN
+    }
   }
 
-  // --- 4. auth.mode: token obrigatório ---
-  const desiredAuthMode = "token";
-  if (config.auth.mode !== desiredAuthMode) {
-    const ans = await ask(`auth.mode está "${config.auth.mode ?? "(vazio)"}". Ajustar para "${desiredAuthMode}"? (y/n): `);
-    if (ans.toLowerCase() === "y") { config.auth.mode = desiredAuthMode; needWrite = true; }
-  } else {
-    console.log("✔ auth.mode já está em token");
+  // auth mode seguro
+  config.auth = config.auth || {};
+  config.auth.mode = config.auth.mode || "token";
+  if (config.auth.mode !== "token") {
+    if (f.apply) {
+      const ans = f.yes ? "y" : await ask(`auth.mode está "${config.auth.mode}". Ajustar para "token"? (y/n): `);
+      if (ans.toLowerCase() === "y") config.auth.mode = "token";
+    } else {
+      config.auth.mode = "token"; // Simulação
+    }
   }
 
-  // --- 5. Geração de token de autenticação (delegado para lib/security) ---
-  if (config.auth.mode === "token") {
-    config.auth.token = config.auth.token || "";
-    if (!config.auth.token) {
-      const ans = await ask("Nenhum token encontrado. Gerar um token seguro automaticamente? (y/n): ");
-      if (ans.toLowerCase() === "y") {
-        config.auth.token = generateToken();
-        console.log(`✔ Token gerado: ${mask(config.auth.token)} (salvo no openclaw.json)`);
-        needWrite = true;
+  if (!config.auth.token) {
+    // gera token somente se APPLY e com consentimento
+    if (f.apply) {
+      if (!f.yes) {
+        const ok = (await ask("Gerar token de auth automaticamente? (y/N): ")).toLowerCase() === "y";
+        if (ok) config.auth.token = generateToken();
       } else {
-        const manual = await ask("Cole um token: ");
-        if (manual) { config.auth.token = manual; needWrite = true; }
+        config.auth.token = generateToken();
       }
     } else {
-      console.log(`✔ Token já configurado (${mask(config.auth.token)})`);
+      config.auth.token = "<TOKEN_GERADO_NO_APPLY>"; // Simulação para o diff
+    }
+  }
+
+  // 3) Canais: apenas PLANO por padrão; em APPLY perguntar
+  console.log("\n2) Canais disponíveis:", supportedChannels().join(", "));
+  if (!f.apply) {
+    console.log("🧭 PLAN   (não vou alterar canais sem --apply)");
+  } else {
+    const pick = f.yes ? "" : await ask(`Qual canal ativar? (${supportedChannels().join("/")}/nenhum): `);
+    const channelChoice = (pick || "").toLowerCase();
+    if (supportedChannels().includes(channelChoice)) {
+      if (!f.yes) console.log(`ℹ️  Vou configurar '${channelChoice}'.`);
+      await configureChannel(config, channelChoice, ask);
     }
   }
 
-  // --- 6. Sandbox: sugestão para VPS rodando como root ---
-  if (env === "linux-vps-root") {
-    if (config.sandbox.mode !== "non-main") {
-      const ans = await ask(`Detectei VPS/root. Ativar sandbox mode "non-main" para isolar execuções? (y/n): `);
-      if (ans.toLowerCase() === "y") { config.sandbox.mode = "non-main"; needWrite = true; }
+  // Filesystem allowlist
+  if (f.apply) {
+    console.log("\n📁 Acesso a arquivos locais (mínimo necessário)");
+    console.log("Adicione apenas pastas que o OpenClaw realmente precisa acessar.");
+    const addPath = await ask("Adicionar uma pasta allowlist agora? (caminho ou ENTER para pular): ");
+    if (addPath) {
+      const resolved = addPath.replace(/^~\//, os.homedir() + path.sep);
+      config.filesystem.allowlist.push(resolved);
+      console.log(`✔ Allowlist adicionada: ${resolved}`);
     }
   }
 
-  // --- 7. Configuração de canais (delegado para lib/channels) ---
-  console.log("\n📣 Canais (opcional)");
-  const channelList = supportedChannels().join("/");
-  const ch = await ask(`Ativar agora? (${channelList}/nenhum): `);
-  const channelChoice = ch.toLowerCase();
+  // 4) Mostrar plano de mudanças no JSON
+  const changedPaths = diffKeys(before, config);
+  console.log("\n3) Plano de mudanças em openclaw.json:");
+  if (changedPaths.length === 0) console.log("- (nenhuma mudança necessária)");
+  else changedPaths.forEach(p => console.log(`- ${p}`));
 
-  if (supportedChannels().includes(channelChoice)) {
-    // configureChannel recebe uma função ask injetável (testável)
-    const configured = await configureChannel(config, channelChoice, ask);
-    if (configured) needWrite = true;
+  // 5) Aplicar mudanças somente com consentimento
+  if (!f.apply) {
+    console.log("\n✅ Setup finalizado em PLAN. Nenhuma alteração aplicada.");
   } else {
-    console.log("↪ Pulando canais.");
+    let shouldWrite = true;
+    if (changedPaths.length > 0) {
+      if (!f.yes) {
+        const ok = (await ask("\nAplicar alterações em openclaw.json? (y/N): ")).toLowerCase() === "y";
+        if (!ok) {
+          console.log("❎ Cancelado. openclaw.json não será alterado.");
+          shouldWrite = false;
+        }
+      }
+      if (shouldWrite) {
+        writeJsonSafe(configPath, config);
+        console.log(`✅ DONE  openclaw.json atualizado em ${configPath}`);
+      }
+    } else {
+      if (!hasConfig && shouldWrite) {
+        writeJsonSafe(configPath, config);
+        console.log(`✅ DONE  openclaw.json criado em ${configPath}`);
+      }
+    }
   }
 
-  // --- 8. Filesystem allowlist: princípio do menor privilégio ---
-  console.log("\n📁 Acesso a arquivos locais (mínimo necessário)");
-  console.log("Adicione apenas pastas que o OpenClaw realmente precisa acessar.");
-  const addPath = await ask("Adicionar uma pasta allowlist agora? (caminho ou ENTER para pular): ");
-  if (addPath) {
-    const resolved = addPath.replace(/^~\//, os.homedir() + path.sep);
-    config.filesystem.allowlist.push(resolved);
-    needWrite = true;
-    console.log(`✔ Allowlist adicionada: ${resolved}`);
-  }
+  // 6) Persistência por projeto (IDE option B): somente com consentimento
+  const agentDir = path.join(targetBase, ".agent");
+  const stateDir = path.join(agentDir, "state");
+
+  console.log("\n4) Persistência por projeto (.agent/state):");
+  console.log("🧭 PLAN   criar MEMORY.md / SOUL.md / AGENTS.md somente com consentimento");
 
-  // --- 9. Arquivos de persistência (delegado para lib/config.ensureFile) ---
-  ensureFile(path.join(base, "MEMORY.md"), "# MEMORY.md\n\n- Preferências e notas persistentes do OpenClaw.\n");
-  ensureFile(path.join(base, "SOUL.md"), "# SOUL.md\n\n- Identidade e regras de comportamento (ver AGENTS.md).\n");
-  ensureFile(path.join(base, "AGENTS.md"), "# AGENTS.md\n\nVocê é um SysAdmin Proativo. Use VPN-first, bind localhost e token.\n");
-
-  // --- 10. Checagem de porta (delegado para lib/security.portInUse) ---
-  const port = 18789;
-  console.log("\n🔎 Checagens rápidas");
-  const inUse = await portInUse("127.0.0.1", port);
-  if (inUse) console.log(`ℹ Porta ${port} respondeu em 127.0.0.1 (ok se OpenClaw está rodando).`);
-  else console.log(`ℹ Porta ${port} não respondeu em 127.0.0.1 (ok se ainda não iniciou).`);
-
-  // --- 11. Hardening: recomendações para VPS ---
-  if (env === "linux-vps-root") {
-    console.log("\n🛡 Hardening (recomendado)");
-    console.log("- Crie um usuário não-root (ex: clawuser) e desative login por senha no SSH.");
-    console.log("- Ative firewall (UFW) e fail2ban.");
-    console.log("- Exponha publicamente apenas WireGuard (UDP) se usar VPN.");
+  // Só criamos state se já existir .agent ou se usuário quiser criar (em apply)
+  if (f.apply && !exists(agentDir)) {
+    if (!f.yes) {
+      const ok = (await ask("Criar pasta .agent/ (para estado por projeto)? (y/N): ")).toLowerCase() === "y";
+      if (ok) fs.mkdirSync(stateDir, { recursive: true });
+    } else {
+      fs.mkdirSync(stateDir, { recursive: true });
+    }
   }
 
-  // --- 12. Persistência da configuração (delegado para lib/config.writeJsonSafe) ---
-  if (needWrite) {
-    writeJsonSafe(configPath, config);
-    console.log("\n✔ openclaw.json atualizado/criado com segurança.");
+  if (exists(agentDir) || exists(stateDir)) {
+    if (!exists(stateDir) && f.apply) fs.mkdirSync(stateDir, { recursive: true });
+
+    await ensureFileWithConsent({
+      filePath: path.join(stateDir, "MEMORY.md"),
+      content: "# MEMORY.md (por projeto)\n\n- Resumos úteis, decisões e preferências persistentes do projeto.\n",
+      flags: f
+    });
+
+    await ensureFileWithConsent({
+      filePath: path.join(stateDir, "SOUL.md"),
+      content: "# SOUL.md\n\n- Identidade e regras de comportamento do agente.\n",
+      flags: f
+    });
+
+    await ensureFileWithConsent({
+      filePath: path.join(stateDir, "AGENTS.md"),
+      content: "# AGENTS.md\n\n- Agentes e personas disponíveis neste projeto.\n",
+      flags: f
+    });
   } else {
-    console.log("\n✔ Nenhuma alteração necessária no openclaw.json.");
+    console.log("ℹ️  .agent não existe neste projeto. (ok) — nada será criado em PLAN.");
   }
 
-  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();
-}
+  // Checagens adicionais informativas (Healthcheck da porta)
+  if (f.apply) {
+    const port = 18789;
+    console.log("\n🔎 Checagens rápidas");
+    const inUse = await portInUse("127.0.0.1", port);
+    if (inUse) console.log(`ℹ Porta ${port} respondeu em 127.0.0.1 (ok se OpenClaw está rodando).`);
+    else console.log(`ℹ Porta ${port} não respondeu em 127.0.0.1 (ok se ainda não iniciou).`);
+  }
 
-main().catch((e) => {
-  console.error("✖ Erro:", e && e.message ? e.message : e);
-  process.exit(1);
-});
+  console.log("\n✅ Wizard concluído.");
+};

package/lib/utils/scope_guard.js

@@ -0,0 +1,112 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const readline = require("readline");
+
+/**
+ * Utilitário para prompt interativo.
+ */
+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.trim());
+    }));
+}
+
+/**
+ * Valida se um caminho pretendido está dentro do diretório seguro.
+ * @param {string} targetPath - Caminho do projeto destino.
+ * @param {string} fileToMutate - O arquivo/pasta a ser mexido.
+ * @returns {boolean} - True se .agent/** ou default safe.
+ */
+function isPathInSafeScope(targetPath, fileToMutate) {
+    // Escopo seguro default: pasta `.agent` na raiz do targetPath
+    const safeScope = path.join(targetPath, ".agent");
+    const absoluteMutate = path.resolve(targetPath, fileToMutate);
+
+    // Arquivos no diretório pai principal que não deveriam ser bloqueados:
+    // Padrão do projeto autoriza explicitamente "openclaw.json", ".env.example" no wizard? 
+    // Para simplificar, focamos na "prisão" primária.
+
+    // allow openclaw.json default config
+    if (absoluteMutate === path.join(targetPath, "openclaw.json")) return true;
+
+    // Retorna true se começa com o caminho the escopo.
+    return absoluteMutate.startsWith(safeScope);
+}
+
+/**
+ * Escudo de Proteção "Scope Guard"
+ * Evita que o CLI apague ou modifique arquivos da aplicação nativa (ex: index.js, package.json do usuário).
+ * 
+ * @param {string} targetPath - Caminho de execução (process.cwd geralmente)
+ * @param {object} intents - Objeto contendo listas { writes: [], deletes: [], overwrites: [] } com paths relativos ou absolutos
+ * @param {object} flags - As CLI Flags (`force`, `yes`, `apply`)
+ */
+async function guardPlan(targetPath, intents = { writes: [], deletes: [], overwrites: [] }, flags = {}) {
+    const outOfScope = {
+        writes: intents.writes.filter(p => !isPathInSafeScope(targetPath, p)),
+        deletes: intents.deletes.filter(p => !isPathInSafeScope(targetPath, p)),
+        overwrites: intents.overwrites.filter(p => !isPathInSafeScope(targetPath, p)),
+    };
+
+    const totalRisks = outOfScope.writes.length + outOfScope.deletes.length + outOfScope.overwrites.length;
+
+    // Se tudo ok (nenhuma fuga da jail), permitimos silenciosamente sem drama
+    if (totalRisks === 0) return true;
+
+    console.log("\n🛡️  [SCOPE GUARD ALERTA DE SEGURANÇA]");
+    console.log("-----------------------------------------");
+    console.log(`Detectado tentativa de alterar dados FORA do sandbox (.agent/**).`);
+
+    if (outOfScope.writes.length > 0) {
+        console.log("⚠️ Arquivos a GERAR fora do escopo:", outOfScope.writes);
+    }
+    if (outOfScope.overwrites.length > 0) {
+        console.log("🧨 Arquivos a SOBRESCREVER fora do escopo:", outOfScope.overwrites);
+    }
+    if (outOfScope.deletes.length > 0) {
+        console.log("🔥 DELETE SOLICITADO fora do escopo:", outOfScope.deletes);
+    }
+    console.log("-----------------------------------------\n");
+
+    // Lógica para modo interativo. Se flag Force vier sem ask, permitimos por conta-risco.
+    if (flags.force) {
+        console.log("⚠️ Flag --force detectada. Destravando ação destrutiva fora da sandbox.");
+        return true;
+    }
+
+    if (flags.yes) {
+        console.log("❌ Bloqueado! Não permitimos escapes da sandbox via '--yes'. Você deve rodar o processo interativamente ou usar --force.");
+        process.exit(1);
+    }
+
+    // Interactive confirmation com hard-stop (obriga escrever DESTRUCTIVE para deletes/overwrites)
+    if (outOfScope.deletes.length > 0 || outOfScope.overwrites.length > 0) {
+        const ans = await askQuestion("Perigo crítico. Para aprovar sobrescritas ou apagamentos fora do .agent, digite 'DESTRUCTIVE': ");
+        if (ans !== "DESTRUCTIVE") {
+            console.log("⏹️ Cancelado pelo Módulo Scope Guard.");
+            process.exit(1);
+        }
+        return true;
+    }
+
+    // Para WRITES brandos: conf simples
+    const ans = await askQuestion("Aprovar criação de novas rotas fora do sandbox? [y/N]: ");
+    if (ans.toLowerCase() !== "y") {
+        console.log("⏹️ Cancelado pelo Módulo Scope Guard.");
+        process.exit(1);
+    }
+
+    return true;
+}
+
+module.exports = {
+    guardPlan,
+    isPathInSafeScope
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fabioforest/openclaw",
-  "version": "3.8.0",
+  "version": "3.10.0",
   "description": "Agentes autônomos para engenharia de software",
   "publishConfig": {
     "access": "public"
@@ -44,4 +44,4 @@
   "engines": {
     "node": ">=18"
   }
-}
+}

package/templates/.agent/workflows/chat-first.md

@@ -0,0 +1,16 @@
+---
+description: Roteamento de Skill Padrão e Seguro (Chat-first Workflow)
+---
+# Chat-first Workflow (Roteamento Inteligente)
+
+O OpenClaw adota um fluxo "chat-first" nas interações com o desenvolvedor, onde o Agent sempre entra como o Roteador central (descrito em `.agent/skills/openclaw-router/SKILL.md`) antes de selecionar qualquer action.
+
+## Passos Operacionais (Agent Actions)
+1. **INSPECT**: A partir do prompt do usuário, identifique a real necessidade invocando a análise do repositório/arquivos locais. Nunca tome decisões sem checar o ambiente `.agent/`.
+2. **ROUTE**: Baseado na intenção identificada, ative mentalmente a Skill correspondente. Se o usuário pedir um script de deploy, ative `devops-toolkit`. Se pedir frontend component, ative `openclaw-dev`.
+3. **PLAN**: Com a Skill ativada, escreva um `.md` no diretório temporário/contextual descrevendo sua tática baseada nas regras do repositório para resolver o problema, solicitando feedback com o comando correspondente ao final da sua mensagem (`/plan`, `/execute`).
+4. **CONSENT**: Aguarde a confirmação de que o plano pode ser seguido (salvo explicitamente em `--yes` outputs passados pelo desenvolvedor).
+5. **APPLY**: Execute os comandos na máquina, gere ou atualize código.
+6. **AUDIT**: Notifique via CLI Audit (se usando CLI) ou inclua logs para os registros em `MEMORY.md`.
+
+> **MANDATORY**: Nunca gere ou modifique configurações sem antes consultar e entender o projeto através do `inspect` e da lista de Skills aprovadas (em `openclaw.json` ou `AGENTS.md`).