@fabioforest/openclaw 3.9.0 → 3.10.2

package/README.md

@@ -280,6 +280,7 @@ npx @fabioforest/openclaw ide install --apply --force
 │   ├── mission_control.json   # Empresa de Agentes
 │   └── MEMORY.md              # Memória do workspace
 └── workflows/         # Slash commands e runbooks
+    └── chat-first.md  # Workflow default de roteamento inteligente
 ```
 
 ---
@@ -446,6 +447,7 @@ Além de skills isoladas, o OpenClaw traz **fluxos de trabalho completos** (runb
 
 | Workflow | Descrição | Comando Trigger |
 |----------|-----------|-----------------|
+| **`chat-first`** | **Roteamento Seguro** via INSPECT e PLAN antes de agira | Workflow Padrão (Core) |
 | **`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` |
@@ -458,15 +460,18 @@ Workflows são arquivos `.md` em `.agent/workflows/` que o agente lê e executa
 
 ## 🔒 Segurança
 
-O OpenClaw segue 3 princípios fundamentais:
+O OpenClaw segue 4 princípios fundamentais:
 
 ### 1. Read-only por padrão
-Todo comando opera em **modo PLAN** (simulação). Nada é alterado sem `--apply`.
+Todo comando opera em **modo PLAN** (simulação). Nada é alterado sem `--apply`. A flag `--apply` tem precedência absoluta, substituindo comportamento visual de planejamento.
 
 ### 2. Consent-first
 Antes de qualquer alteração, o sistema mostra exatamente o que vai fazer e pede confirmação. Ações destrutivas exigem **confirmação forte** (digitar frase específica).
 
-### 3. Audit-first
+### 3. Scope Guard (Proteção Anti-Destruição)
+Qualquer tentativa do CLI de criar, deletar ou sobrescrever arquivos que estejam **fora** da bolha de segurança `.agent/` falha por padrão com o Módulo Scope Guard em ação total para isolar agentes. Pode ser ignorado interativamente no terminal digitando senhas de perigo.
+
+### 4. Audit-first
 Toda ação gera log detalhado em `.agent/audit/` com timestamp, comando, modo, contexto e resultado.
 
 ### Proteções ativas
@@ -474,6 +479,7 @@ Toda ação gera log detalhado em `.agent/audit/` com timestamp, comando, modo,
 | Proteção | Como funciona |
 |----------|---------------|
 | **Hook pre-tool-use** | Bloqueia 12+ padrões destrutivos (`rm -rf`, `mkfs`, `dd`, `shutdown`) |
+| **Scope Guard** | Protege arquivos/framework nativos do projeto/usuário host de reescritas inadvertidas CLI |
 | **VPN-first** | Sem VPN, sem acesso remoto |
 | **Bind localhost** | Serviços só acessíveis localmente por padrão |
 | **Auth token** | Token obrigatório para acesso |

package/bin/openclaw.js

@@ -43,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;
 
@@ -62,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") {
@@ -71,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 };
 }

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 { executeAction } = require("../core/orchestrator");
 
 // 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 });
@@ -76,6 +65,9 @@ async function runInstall({ targetPath, flags }) {
         console.log("  📦 COPY    templates/.agent -> .agent/");
     }
 
+    const ideSrc = path.join(TEMPLATES_DIR, "ide");
+    console.log("  🌟 ADDON   Adaptadores de IDE (.cursorrules, copilot-instructions, .mdc)");
+
     // State templates (mission_control.json, MEMORY.md)
     const stateDir = path.join(agentDst, "state");
     if (!fs.existsSync(stateDir)) {
@@ -84,78 +76,65 @@ async function runInstall({ targetPath, flags }) {
         console.log("  ✅ KEEP    .agent/state/ (já existe)");
     }
 
-    if (planMode) {
-        console.log("\n🔒 Modo PLAN (Read-Only). Nenhuma alteração feita.");
-        console.log("   Para aplicar, rode: npx openclaw ide install --apply");
-        return;
-    }
-
-    // Confirmação
-    if (!flags.yes) {
-        if (flags.force && fs.existsSync(agentDst)) {
-            const phrase = await ask("⚠️  Digite 'DELETE .agent' para confirmar: ");
-            if (phrase !== "DELETE .agent") {
-                console.log("⏹️  Cancelado.");
-                return;
+    // 2.5 Scope Guard
+    const intents = {
+        writes: [
+            agentDst,
+            stateDir,
+            path.join(targetPath, ".cursorrules"),
+            path.join(targetPath, ".github"),
+            path.join(targetPath, ".cursor")
+        ],
+        deletes: [],
+        overwrites: []
+    };
+
+    const confirmationWord = (flags.force && fs.existsSync(agentDst)) ? "DELETE .agent" : null;
+
+    await executeAction({
+        actionName: "ide install",
+        context: ctx,
+        flags,
+        intents,
+        targetPath,
+        confirmationWord,
+        planFn: async () => { }, // O console.log inicial já fez o plan visual acima
+        executeFn: async () => {
+            if (fs.existsSync(agentDst) && flags.force) {
+                fs.rmSync(agentDst, { recursive: true, force: true });
             }
-        } else {
-            const ok = await ask("\nAplicar instalação IDE? (y/N): ");
-            if (ok.toLowerCase() !== "y") {
-                console.log("⏹️  Cancelado.");
-                return;
-            }
-        }
-    }
-
-    // Execução
-    try {
-        console.log("\n🚀 Executando...");
-
-        if (fs.existsSync(agentDst) && flags.force) {
-            fs.rmSync(agentDst, { recursive: true, force: true });
-            audit.push("- ACT: DELETED .agent/");
-        }
 
-        const isMerge = fs.existsSync(agentDst);
-        const stats = copyDirRecursive(agentSrc, agentDst, undefined, isMerge);
-        audit.push(`- ACT: ${isMerge ? "MERGED" : "COPIED"} templates (Files: ${stats.files}, Skipped: ${stats.skipped})`);
-
-        // Criar state se necessário
-        const stateTarget = path.join(agentDst, "state");
-        if (!fs.existsSync(stateTarget)) {
-            fs.mkdirSync(stateTarget, { recursive: true });
-            // Criar mission_control.json default
-            const mcDefault = {
-                project_status: "active",
-                project_name: path.basename(targetPath),
-                sprint_goal: "",
-                agents: [
-                    { id: "orchestrator", role: "orchestrator", active: true },
-                    { id: "researcher", role: "researcher", active: true },
-                    { id: "writer", role: "writer", active: true },
-                ],
-                task_queue: [],
-                history: [],
-                settings: {
-                    work_dir: "mission_control",
-                    max_tasks_per_tick: 2,
-                    default_priority: "medium",
-                },
-            };
-            fs.writeFileSync(path.join(stateTarget, "mission_control.json"), JSON.stringify(mcDefault, null, 2));
-            fs.writeFileSync(path.join(stateTarget, "MEMORY.md"), "# Memória Persistente\n\n(Adicione aqui resumos e decisões importantes)\n");
-            audit.push("- ACT: CREATED .agent/state/ (mission_control.json + MEMORY.md)");
+            const isMerge = fs.existsSync(agentDst);
+            copyDirRecursive(agentSrc, agentDst, undefined, isMerge);
+            copyDirRecursive(ideSrc, targetPath, undefined, true); // Copiar/Merge ide adaptors
+
+            // Criar state se necessário
+            const stateTarget = path.join(agentDst, "state");
+            if (!fs.existsSync(stateTarget)) {
+                fs.mkdirSync(stateTarget, { recursive: true });
+                // Criar mission_control.json default
+                const mcDefault = {
+                    project_status: "active",
+                    project_name: path.basename(targetPath),
+                    sprint_goal: "",
+                    agents: [
+                        { id: "orchestrator", role: "orchestrator", active: true },
+                        { id: "researcher", role: "researcher", active: true },
+                        { id: "writer", role: "writer", active: true },
+                    ],
+                    task_queue: [],
+                    history: [],
+                    settings: {
+                        work_dir: "mission_control",
+                        max_tasks_per_tick: 2,
+                        default_priority: "medium",
+                    },
+                };
+                fs.writeFileSync(path.join(stateTarget, "mission_control.json"), JSON.stringify(mcDefault, null, 2));
+                fs.writeFileSync(path.join(stateTarget, "MEMORY.md"), "# Memória Persistente\n\n(Adicione aqui resumos e decisões importantes)\n");
+            }
         }
-
-        console.log("\n✨ IDE install concluído com sucesso!");
-        writeAudit(targetPath, audit, flags);
-
-    } catch (err) {
-        console.error(`\n❌ Falha: ${err.message}`);
-        audit.push(`\n## ERROR: ${err.message}`);
-        writeAudit(targetPath, audit, flags);
-        process.exit(1);
-    }
+    });
 }
 
 /**

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 { executeAction } = require("../core/orchestrator");
 
 // Caminho dos templates incluídos no pacote
 const TEMPLATES_DIR = path.join(__dirname, "..", "..", "templates", ".agent");
@@ -107,85 +108,67 @@ async function run({ targetPath, flags }) {
         actions.push({ type: "NOOP", path: configPath, reason: "Config exists" });
     }
 
-    // 3. Exibir Plano
-    console.log(`\n🧭 Plano de Execução (${planMode ? "SIMULAÇÃO" : "APPLY"}):\n`);
-    console.log(`   Contexto: ${ctx.env} | IDE: ${ctx.ide}\n`);
-
+    // 2.5. Acionar Scope Guard
+    const intents = { writes: [], deletes: [], overwrites: [] };
     for (const a of actions) {
-        if (a.type === "DELETE_DIR") console.log(`  🔥 DELETE  ${safeRel(targetPath, a.path)} (${a.reason})`);
-        if (a.type === "CREATE_DIR") console.log(`  📁 CREATE  ${safeRel(targetPath, a.path)}`);
-        if (a.type === "COPY_DIR") console.log(`  📦 COPY    templates -> ${safeRel(targetPath, a.to)}`);
-        if (a.type === "MERGE_DIR") console.log(`  🔄 MERGE   templates -> ${safeRel(targetPath, a.to)} (Preservando existentes)`);
-        if (a.type === "CREATE_FILE") console.log(`  📝 CREATE  ${safeRel(targetPath, a.path)}`);
-        if (a.type === "NOOP") console.log(`  ✅ KEEP    ${safeRel(targetPath, a.path)}`);
-    }
-
-    if (planMode) {
-        console.log("\n🔒 Modo PLAN (Read-Only). Nenhuma alteração feita.");
-        console.log("   Para aplicar, rode: npx openclaw init --apply [--merge|--force]");
-        return;
+        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);
     }
 
-    // 4. Confirmação
-    if (!flags.yes) {
-        if (actions.some(a => a.type === "DELETE_DIR")) {
-            console.log("\n⚠️  PERIGO: Operação destrutiva detectada (--force).");
-            const phrase = await ask("Digite 'DELETE .agent' para confirmar: ");
-            if (phrase !== "DELETE .agent") {
-                console.log("⏹️  Cancelado.");
-                return;
+    // Definir Palavra de Confirmação Forte se houver Force Delete
+    const hasDelete = actions.some(a => a.type === "DELETE_DIR");
+    const confirmationWord = hasDelete ? "DELETE .agent" : null;
+
+    // Delegar todo o fluxo final (Guard, Confirm, Execute, Audit) para o Orchestrator
+    await executeAction({
+        actionName: "init",
+        context: ctx,
+        flags,
+        intents,
+        targetPath,
+        confirmationWord,
+        planFn: async () => {
+            console.log(`\n🧭 Plano de Execução:\n`);
+            console.log(`   Contexto: ${ctx.env.platform} | IDE: ${ctx.ide}\n`);
+            for (const a of actions) {
+                if (a.type === "DELETE_DIR") console.log(`  🔥 DELETE  ${safeRel(targetPath, a.path)} (${a.reason})`);
+                if (a.type === "CREATE_DIR") console.log(`  📁 CREATE  ${safeRel(targetPath, a.path)}`);
+                if (a.type === "COPY_DIR") console.log(`  📦 COPY    templates -> ${safeRel(targetPath, a.to)}`);
+                if (a.type === "MERGE_DIR") console.log(`  🔄 MERGE   templates -> ${safeRel(targetPath, a.to)} (Preservando existentes)`);
+                if (a.type === "CREATE_FILE") console.log(`  📝 CREATE  ${safeRel(targetPath, a.path)}`);
+                if (a.type === "NOOP") console.log(`  ✅ KEEP    ${safeRel(targetPath, a.path)}`);
             }
-        } else {
-            const ok = await ask("\nAplicar este plano? (y/N): ");
-            if (ok.toLowerCase() !== "y") {
-                console.log("⏹️  Cancelado.");
-                return;
+        },
+        executeFn: async () => {
+            for (const a of actions) {
+                if (a.type === "DELETE_DIR") {
+                    fs.rmSync(a.path, { recursive: true, force: true });
+                }
             }
-        }
-    }
 
-    // 5. Execução
-    try {
-        console.log("\n🚀 Executando...");
-
-        for (const a of actions) {
-            if (a.type === "DELETE_DIR") {
-                fs.rmSync(a.path, { recursive: true, force: true });
-                audit.push(`- ACT: DELETED ${a.path}`);
+            // Executar cópia/merge se necessário
+            const copyAction = actions.find(a => a.type === "COPY_DIR" || a.type === "MERGE_DIR");
+            if (copyAction) {
+                const isMerge = copyAction.type === "MERGE_DIR";
+                copyDirRecursive(TEMPLATES_DIR, agentDir, undefined, isMerge);
+                console.log(`   ✅ Templates processados.`);
             }
-        }
 
-        // Executar cópia/merge se necessário
-        const copyAction = actions.find(a => a.type === "COPY_DIR" || a.type === "MERGE_DIR");
-        if (copyAction) {
-            const isMerge = copyAction.type === "MERGE_DIR";
-            const stats = copyDirRecursive(TEMPLATES_DIR, agentDir, undefined, isMerge);
-            audit.push(`- ACT: ${isMerge ? "MERGED" : "COPIED"} templates (Files: ${stats.files}, Skipped: ${stats.skipped})`);
-            console.log(`   ✅ Templates processados.`);
-        }
+            // Criar config se necessário
+            if (actions.some(a => a.type === "CREATE_FILE" && a.path === configPath)) {
+                const defaults = initConfigDefaults({});
+                writeJsonSafe(configPath, defaults);
+                console.log(`   ✅ Config criada.`);
+            }
 
-        // Criar config se necessário
-        if (actions.some(a => a.type === "CREATE_FILE" && a.path === configPath)) {
-            const defaults = initConfigDefaults({});
-            writeJsonSafe(configPath, defaults);
-            audit.push(`- ACT: CREATED openclaw.json`);
-            console.log(`   ✅ Config criada.`);
+            // Gravar contexto se ainda não existe
+            const contextDir = path.join(agentDir, "context");
+            if (!fs.existsSync(contextDir)) fs.mkdirSync(contextDir, { recursive: true });
+            fs.writeFileSync(path.join(contextDir, "context.json"), JSON.stringify(ctx, null, 2));
         }
-
-        // Gravar contexto se ainda não existe
-        const contextDir = path.join(agentDir, "context");
-        if (!fs.existsSync(contextDir)) fs.mkdirSync(contextDir, { recursive: true });
-        fs.writeFileSync(path.join(contextDir, "context.json"), JSON.stringify(ctx, null, 2));
-
-        console.log("\n✨ Concluído 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, copyDirRecursive };

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 { executeAction } = require("../core/orchestrator");
 
 function ask(q) {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
@@ -103,92 +104,82 @@ async function run({ targetPath, flags }) {
         console.log(`   🔴 REMOVER  openclaw.json`);
     }
 
-    // Verificar audit logs que seriam perdidos
-    const auditDir = path.join(agentDir, "audit");
-    if (fs.existsSync(auditDir)) {
-        const auditCount = countFiles(auditDir);
-        if (auditCount > 0) {
-            console.log(`\n   ⚠️  ${auditCount} log(s) de auditoria serão perdidos!`);
-        }
-    }
-
-    // Verificar state que seria perdido
-    const stateDir = path.join(agentDir, "state");
-    if (fs.existsSync(stateDir)) {
-        const stateCount = countFiles(stateDir);
-        if (stateCount > 0) {
-            console.log(`   ⚠️  ${stateCount} arquivo(s) de estado serão perdidos (mission_control, MEMORY)!`);
-        }
-    }
-
-    // Modo PLAN: não faz nada
-    if (planMode) {
-        console.log("\n🔒 Modo PLAN (Read-Only). Nenhuma alteração feita.");
-        console.log("   Para desinstalar, rode: npx @fabioforest/openclaw uninstall --apply");
-        return;
-    }
-
-    // Modo APPLY: pedir confirmação forte
-    console.log("");
-    if (!flags.yes) {
-        const confirm = await ask("⚠️  Digite 'UNINSTALL' para confirmar a remoção: ");
-        if (confirm !== "UNINSTALL") {
-            console.log("⏹️  Cancelado. Nada foi removido.");
-            return;
-        }
-    }
+    // Acionar Orquestrador
+    const intents = { writes: [], deletes: toRemove.map(i => i.path), overwrites: [] };
+
+    await executeAction({
+        actionName: "uninstall",
+        context: ctx,
+        flags,
+        intents,
+        targetPath,
+        skipAudit: true, // Audit manual pós-remoção
+        confirmationWord: "UNINSTALL",
+        planFn: async () => {
+            // Verificar audit logs que seriam perdidos
+            const auditDir = path.join(agentDir, "audit");
+            if (fs.existsSync(auditDir)) {
+                const auditCount = countFiles(auditDir);
+                if (auditCount > 0) {
+                    console.log(`\n   ⚠️  ${auditCount} log(s) de auditoria serão perdidos!`);
+                }
+            }
 
-    // Backup opcional
-    if (!flags.force) {
-        const doBackup = flags.yes ? "s" : await ask("💾 Fazer backup antes de remover? (S/n): ");
-        if (doBackup.toLowerCase() !== "n") {
-            const backupName = `.agent.backup-${Date.now()}`;
-            const backupPath = path.join(targetPath, backupName);
-            try {
-                fs.cpSync(agentDir, backupPath, { recursive: true });
-                console.log(`   ✅ Backup criado: ${backupName}/`);
-            } catch (err) {
-                console.error(`   ⚠️  Falha no backup: ${err.message}`);
-                const cont = await ask("   Continuar sem backup? (y/N): ");
-                if (cont.toLowerCase() !== "y") {
-                    console.log("⏹️  Cancelado.");
-                    return;
+            // Verificar state que seria perdido
+            const stateDir = path.join(agentDir, "state");
+            if (fs.existsSync(stateDir)) {
+                const stateCount = countFiles(stateDir);
+                if (stateCount > 0) {
+                    console.log(`   ⚠️  ${stateCount} arquivo(s) de estado serão perdidos (mission_control, MEMORY)!`);
+                }
+            }
+        },
+        executeFn: async () => {
+            // Backup opcional
+            if (!flags.force) {
+                const doBackup = flags.yes ? "s" : await ask("\n💾 Fazer backup antes de remover? (S/n): ");
+                if (doBackup.toLowerCase() !== "n") {
+                    const backupName = `.agent.backup-${Date.now()}`;
+                    const backupPath = path.join(targetPath, backupName);
+                    try {
+                        fs.cpSync(agentDir, backupPath, { recursive: true });
+                        console.log(`   ✅ Backup criado: ${backupName}/`);
+                    } catch (err) {
+                        console.error(`   ⚠️  Falha no backup: ${err.message}`);
+                        const cont = await ask("   Continuar sem backup? (y/N): ");
+                        if (cont.toLowerCase() !== "y") {
+                            throw new Error("Usuário abortou por falha no backup.");
+                        }
+                    }
                 }
             }
-        }
-    }
 
-    // Executar remoção
-    const audit = [getAuditHeader(ctx, "uninstall", flags)];
+            const audit = [getAuditHeader(ctx, "uninstall", flags)];
 
-    try {
-        for (const item of toRemove) {
-            if (item.isDir) {
-                fs.rmSync(item.path, { recursive: true, force: true });
-            } else {
-                fs.unlinkSync(item.path);
+            for (const item of toRemove) {
+                if (item.isDir) {
+                    fs.rmSync(item.path, { recursive: true, force: true });
+                } else {
+                    fs.unlinkSync(item.path);
+                }
+                console.log(`   ✅ Removido: ${item.label}`);
+                audit.push(`- ACT: REMOVED ${item.label}`);
             }
-            console.log(`   ✅ Removido: ${item.label}`);
-            audit.push(`- ACT: REMOVED ${item.label}`);
-        }
 
-        console.log("\n✨ OpenClaw desinstalado com sucesso!");
-        console.log("   Para reinstalar: npx @fabioforest/openclaw init --apply\n");
-
-        // Gravar audit no diretório pai (já que .agent/ foi removido)
-        if (flags.audit !== false) {
-            const filename = `openclaw-uninstall-${new Date().toISOString().replace(/[:.]/g, "-")}.md`;
-            const auditPath = path.join(targetPath, filename);
-            try {
-                fs.writeFileSync(auditPath, audit.join("\n") + "\n", "utf8");
-                console.log(`   📝 Log de auditoria: ${filename}`);
-            } catch (e) { /* silencioso */ }
+            console.log("\n✨ OpenClaw desinstalado com sucesso!");
+            console.log("   Para reinstalar: npx @fabioforest/openclaw init --apply\n");
+
+            // Gravar audit no diretório pai (já que .agent/ foi removido)
+            if (flags.audit !== false) {
+                const filename = `openclaw-uninstall-${new Date().toISOString().replace(/[:.]/g, "-")}.md`;
+                const auditPath = path.join(targetPath, filename);
+                try {
+                    fs.writeFileSync(auditPath, audit.join("\n") + "\n", "utf8");
+                    console.log(`   📝 Log de auditoria: ${filename}`);
+                } catch (e) { /* silencioso */ }
+            }
         }
-
-    } catch (err) {
-        console.error(`\n❌ Falha: ${err.message}`);
-        process.exit(1);
-    }
+    });
 }
 
 module.exports = { run };

package/lib/cli/update.js

@@ -14,7 +14,7 @@ const path = require("path");
 const crypto = require("crypto");
 const readline = require("readline");
 const { detectContext, getAuditHeader } = require("../context");
-const { writeCliAudit } = require("../utils/audit-writer");
+const { executeAction } = require("../core/orchestrator");
 
 // Caminho dos templates incluídos no pacote
 const TEMPLATES_DIR = path.join(__dirname, "..", "..", "templates", ".agent");
@@ -28,10 +28,7 @@ function safeRel(targetPath, p) {
     return path.relative(targetPath, p);
 }
 
-// writeAudit extraído para lib/utils/audit-writer.js (DRY)
-function writeAudit(targetPath, lines, flags) {
-    writeCliAudit(targetPath, lines, flags, "update");
-}
+// Removida prop writeAudit (o orquestrador ou o executeFn fará isso manualmente ou deixaremos rolar)
 
 /**
  * Calcula o SHA-256 de um arquivo (Utilitário mantido)
@@ -123,106 +120,113 @@ async function run({ targetPath, flags }) {
         process.exit(1);
     }
 
-    // 1. Planejar
+    // 1. Planejar arrays
     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)} (Exige confirmação interativa)`);
-        });
-    }
-    if (actions.skipped.length > 0) {
-        console.log(`\n⏭️  Ignorados (${actions.skipped.length} arquivos idênticos)`);
-    }
+    // Mapear intencionalidades
+    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 executeAction({
+        actionName: "update",
+        context: ctx,
+        flags,
+        intents,
+        targetPath,
+        skipConfirm: true, // Manter o loop de override manual
+        skipAudit: true, // Escrevemos manual no final por causa dos arquivos "skipped" interativos
+        planFn: async () => {
+            console.log(`\n🧭 Plano de Atualização:\n`);
+            console.log(`   Contexto: ${ctx.env.platform} | 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)} (Exige confirmação interativa)`);
+                });
+            }
+            if (actions.skipped.length > 0) {
+                console.log(`\n⏭️  Ignorados (${actions.skipped.length} arquivos idênticos)`);
+            }
 
-    if (actions.added.length === 0 && actions.updated.length === 0) {
-        console.log("\n✅ Tudo atualizado. Nenhuma alteração necessária.");
-        return;
-    }
+            if (actions.added.length === 0 && actions.updated.length === 0) {
+                console.log("\n✅ Tudo atualizado. Nenhuma alteração necessária.");
+            }
+        },
+        executeFn: async () => {
+            if (actions.added.length === 0 && actions.updated.length === 0) {
+                return; // Nothing to apply
+            }
 
-    if (planMode) {
-        console.log("\n🔒 Modo PLAN (Read-Only). Nenhuma alteração feita.");
-        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;
-    }
+            // Confirmação inicial (se customizado)
+            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;
+                }
+            }
 
-    // 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;
-        }
-    }
+            // Criar diretórios necessários
+            function ensureDir(p) {
+                const dir = path.dirname(p);
+                if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+            }
 
-    // 4. Execução Interativa Segura (Conflitos file-by-file)
-    try {
-        console.log("\n🚀 Executando atualizações...");
+            const audit = [getAuditHeader(ctx, "update", flags)];
 
-        // Criar diretórios necessários
-        function ensureDir(p) {
-            const dir = path.dirname(p);
-            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: 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 rPath = safeRel(targetPath, action.dest);
 
-        // Action: Updated (Conflict Resolver)
-        for (const action of actions.updated) {
-            ensureDir(action.dest);
-            const rPath = safeRel(targetPath, action.dest);
+                let overwrite = flags.yes || flags.force;
 
-            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("------------------------------------------------");
 
-            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";
+                }
 
-                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}`);
+                }
             }
 
-            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!");
+
+            // Auditing manual
+            if (flags.audit !== false) {
+                const { writeCliAudit } = require("../utils/audit-writer");
+                writeCliAudit(targetPath, audit, flags, "update");
             }
         }
-
-        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, fileHash };

package/lib/context/context-engine.js

@@ -0,0 +1,89 @@
+"use strict";
+
+/**
+ * Context Engine do OpenClaw AI OS
+ * 
+ * Responsável por gerenciar, carregar e persistir o conhecimento e estado de operação:
+ * 1. system.json - Variáveis de ambiente, config, OS, Docker
+ * 2. workspace.json - Mapeamento de linguagens, dependências, arquivos principais, histórico de testes
+ * 3. user.json - Preferências, IDE, token settings, perfil de agressividade do AI
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+class ContextEngine {
+    /**
+     * @param {string} projectRoot - Raiz do projeto (onde fica .agent/)
+     */
+    constructor(projectRoot) {
+        this.projectRoot = projectRoot;
+        this.contextDir = path.join(projectRoot, ".agent", "context");
+
+        // Cria o diretório de contexto caso não exista (independente do init)
+        if (!fs.existsSync(this.contextDir)) {
+            try {
+                fs.mkdirSync(this.contextDir, { recursive: true });
+            } catch (err) {
+                // Ignorar em diretórios hostis onde openclaw não está armado
+            }
+        }
+    }
+
+    _getFilePath(type) {
+        return path.join(this.contextDir, `${type}.json`);
+    }
+
+    /**
+     * Carrega um fragmento do contexto ou retorna defaults
+     * @param {string} type - "system", "workspace" ou "user"
+     */
+    load(type) {
+        const file = this._getFilePath(type);
+        if (fs.existsSync(file)) {
+            try {
+                return JSON.parse(fs.readFileSync(file, "utf-8"));
+            } catch (err) {
+                // Falha de parse, retorna default seguro
+                return {};
+            }
+        }
+        return {};
+    }
+
+    /**
+     * Salva ou sobrepõe as flags no contexto
+     * @param {string} type - "system", "workspace" ou "user"
+     * @param {Object} data - Objeto de dados (será feito um object merge shallow com key overwrites)
+     */
+    save(type, data) {
+        // Se .agent não existe ou não foi inicializado, silenciosamente bypass (para CLI cmds sujos antes do IDE_INSTALL)
+        if (!fs.existsSync(this.contextDir)) return false;
+
+        const current = this.load(type);
+        const merged = { ...current, ...data };
+
+        try {
+            fs.writeFileSync(this._getFilePath(type), JSON.stringify(merged, null, 2), "utf-8");
+            return true;
+        } catch (err) {
+            return false;
+        }
+    }
+
+    /**
+     * Agrega todos os arquivos de contexto para compor a mentalidade da query.
+     */
+    getFullContext() {
+        return {
+            system: this.load("system"),
+            workspace: this.load("workspace"),
+            user: this.load("user"),
+            meta: {
+                timestamp: new Date().toISOString()
+            }
+        };
+    }
+}
+
+module.exports = ContextEngine;

package/lib/core/orchestrator.js

@@ -0,0 +1,113 @@
+"use strict";
+
+/**
+ * Core Orchestrator do OpenClaw AI OS
+ * 
+ * Atua como o "Kernel" do sistema, centralizando o ciclo de vida:
+ * INSPECT -> PLAN -> CONSENT -> APPLY -> AUDIT
+ */
+
+const readline = require("readline");
+const fs = require("fs");
+const path = require("path");
+const { guardPlan } = require("../utils/scope_guard");
+const { writeCliAudit } = require("../utils/audit-writer");
+
+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()); }));
+}
+
+/**
+ * Executa uma ação unificada no OpenClaw AI OS.
+ * Garante que regras de segurança, escopo e auditoria sejam aplicadas.
+ * 
+ * @param {Object} options
+ * @param {string} options.actionName - Nome da ação (ex: "ide install", "uninstall")
+ * @param {Object} options.context - Contexto do workspace/módulo coletado
+ * @param {Object} options.flags - Flags da CLI (--apply, --force, --yes)
+ * @param {Object} options.intents - { writes: [], deletes: [], overwrites: [] }
+ * @param {Function} options.executeFn - Função assíncrona que aplica as mudanças de fato
+ * @param {Function} options.planFn - Função de exibição do plano (read-only)
+ * @param {string} options.targetPath - Root path do projeto
+ * @param {boolean} options.skipAudit - Se true, não grava o audit log no .agent/audit (útil para uninstall)
+ * @param {boolean} options.skipConfirm - Se true, pula o prompt padrão de apply (útil para per-file diff loops)
+ * @returns {boolean} true se executado, false se cancelado ou em modo plan
+ */
+async function executeAction({
+    actionName,
+    context,
+    flags,
+    intents = { writes: [], deletes: [], overwrites: [] },
+    executeFn,
+    planFn,
+    confirmationWord = null,
+    targetPath,
+    skipAudit = false,
+    skipConfirm = false
+}) {
+    const planMode = !flags.apply;
+
+    // 1. INSPECT / PLAN - Scope Guard
+    await guardPlan(targetPath, intents, flags);
+
+    // Exibir o plano real
+    if (planFn && typeof planFn === "function") {
+        await planFn();
+    }
+
+    if (planMode) {
+        console.log(`\n🔒 Modo PLAN (Read-Only). Nenhuma alteração feita.`);
+        console.log(`   Para aplicar, rode com a flag --apply`);
+        return false;
+    }
+
+    // 2. CONSENT
+    if (!flags.yes && !skipConfirm) {
+        if (confirmationWord) {
+            const confirm = await ask(`\n⚠️  Ação destrutiva requer confirmação forte. Digite '${confirmationWord}' para confirmar: `);
+            if (confirm !== confirmationWord) {
+                console.log("⏹️  Cancelado. Nenhuma alteração feita.");
+                return false;
+            }
+        } else {
+            const confirm = await ask(`\n⚠️  Deseja APLICAR as alterações acima? (s/N): `);
+            if (confirm.toLowerCase() !== "s") {
+                console.log("⏹️  Cancelado. Nenhuma alteração feita.");
+                return false;
+            }
+        }
+    }
+
+    // 3. APPLY
+    console.log(`\n⚙️  Executando [${actionName}]...`);
+    try {
+        await executeFn();
+        console.log(`✅ Ação [${actionName}] concluída com sucesso.`);
+    } catch (err) {
+        console.error(`❌ Erro ao executar [${actionName}]:`, err.message);
+        throw err;
+    }
+
+    // 4. AUDIT
+    if (!skipAudit && flags.audit !== false) {
+        try {
+            const auditPayload = [
+                `--- AUDIT LOG: ${actionName} ---`,
+                `Date: ${new Date().toISOString()}`,
+                `User Flags: ${JSON.stringify(flags)}`,
+                `Intents: writes=${intents.writes.length} overwrites=${intents.overwrites.length} deletes=${intents.deletes.length}`,
+                `Status: SUCCESS`
+            ];
+
+            // Reutiliza a função de escrita de log da CLI
+            writeCliAudit(targetPath, auditPayload, flags, actionName);
+        } catch (e) {
+            console.log("⚠️ Não foi possível escrever o audit log.");
+        }
+    }
+
+    return true;
+}
+
+module.exports = { executeAction };

package/lib/utils/scope_guard.js

@@ -0,0 +1,123 @@
+"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;
+
+    // permitemos as configs nativas da IDE copiadas no install
+    const safeIdioms = [
+        path.join(targetPath, ".cursorrules"),
+        path.join(targetPath, ".github"),
+        path.join(targetPath, ".cursor")
+    ];
+
+    if (safeIdioms.some(idiom => absoluteMutate.startsWith(idiom))) return true;
+
+    // Retorna true se começa com o caminho the escopo.
+    if (absoluteMutate.startsWith(safeScope)) return true;
+
+    return false;
+}
+
+/**
+ * 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.9.0",
+  "version": "3.10.2",
   "description": "Agentes autônomos para engenharia de software",
   "publishConfig": {
     "access": "public"

package/templates/.agent/skills/workspace-snapshot/SKILL.md

@@ -0,0 +1,20 @@
+---
+description: Criação de um snapshot do contexto do workspace atual para o router
+---
+
+# Workspace Snapshot
+
+## Objetivo
+Analisar e capturar o estado global do projeto (stack, dependências, rotas, testes e pontos cegos) gerando um artefato `context.json` otimizado. Isso alimenta os roteadores de agentes reduzindo solicitações repetitivas de entendimento e consumos de Token por scans demorados.
+
+## Fluxo
+1. Ler `.gitignore` e `package.json` (ou similares de outras linguagens).
+2. Escanear diretórios chave (src, lib, tests, config).
+3. Detectar frameworks, bibliotecas primárias e scripts customizados.
+4. Identificar zonas de risco (pastas legacy, componentes em migração, vulnerabilidades).
+5. Escrever/Atualizar `.agent/context/context.json` e notificar roteadores. 
+
+## Regras
+- Nunca ler arquivos grandes ignorados como `node_modules` e pastas compiladas.
+- O resultado no JSON não deve passar de 5kb (resumo em alto nível) para manter os tokens baixos no contexto das prompts do LLM.
+- Exigir aprovação de Apply para gravar a imagem do Snapshot.

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

@@ -0,0 +1,19 @@
+# OpenClaw - Chat Router Workflow
+# Roteamento de Entrada para o Chat da IDE
+
+**description**: Workflow de entrada padrão para o modelo ao iniciar um chat. Força o reconhecimento de contexto antes de qualquer ação.
+
+## 1. Inspect
+Sempre comece investigando o estado atual do repositório, procurando pelas regras e diretrizes estabelecidas no `.agent/rules/`. Leia `openclaw.json` para definir o `targetPath` base.
+
+## 2. Plan & Select Skill
+Com base no seu objetivo e nas skills ativas listadas em `.agent/skills/`, escolha a melhor abordagem e desenvolva um rascunho. Comunique o plano detalhado no chat.
+
+## 3. Consent
+Nunca modifique arquivos críticos, delete diretórios ou crie instâncias de serviço sem perguntar ativamente e aguardar o "Sim" explicíto do usuário sobre o Plano (Consent-First).
+
+## 4. Apply
+Proceda com a implementação guiando-se estritamente pela sua proposta. Mantenha os arquivos enxutos (pequenos) e faça checagens consistentes.
+
+## 5. Audit
+Deixe um sumário claro do que foi modificado como prova da sessão de alterações. Utilize `lib/utils/audit-writer.js` se for chamado via OpenClaw CLI ou relate concisamente.

package/templates/ide/.cursor/rules/openclaw.mdc

@@ -0,0 +1,11 @@
+---
+description: openclaw-global-system-rules
+globs: *
+---
+# OpenClaw AI OS - Global Rules
+Você é controlado pelo sistema OpenClaw AI OS instalado neste workspace. Seu comportamento principal deve ser "Consent-First".
+
+- Ler as políticas do diretório `.agent/rules` ANTES de agir.
+- Seguir o workflow padrão `.agent/workflows/chat-router.md` de Roteamento (Inspect -> Plan -> Consent -> Apply -> Audit).
+- Jamais mutar, deletar ou sobrescrever arquivos sem o DEVIDO Consentimento do Usuário atestado em Plano de Ação.
+- Consultar e preservar `.agent/state/MEMORY.md` com as decisões de projeto.

package/templates/ide/.cursorrules

@@ -0,0 +1,7 @@
+# OpenClaw AI OS - Global Rules
+Você é controlado pelo sistema OpenClaw AI OS instalado neste workspace. Seu comportamento principal deve ser "Consent-First".
+
+- Ler as políticas do diretório `.agent/rules` ANTES de agir.
+- Seguir o workflow padrão `.agent/workflows/chat-router.md` de Roteamento (Inspect -> Plan -> Consent -> Apply -> Audit).
+- Jamais mutar, deletar ou sobrescrever arquivos sem o DEVIDO Consentimento do Usuário atestado em Plano de Ação.
+- Consultar e preservar `.agent/state/MEMORY.md` com as decisões de projeto.

package/templates/ide/.github/copilot-instructions.md

@@ -0,0 +1,11 @@
+# OpenClaw AI OS - Copilot Instructions
+Você faz parte do ecosistema OpenClaw instalado neste projeto, que reforça arquiteturas de agentes seguras.
+
+## 1. Safety Protocols
+Respeite e leia a diretriz de Consentimento: `.agent/rules/CONSENT_FIRST.md`. Todas as mutações do projeto exigem aprovações prévias visuais baseadas em um Plano (Inspect -> Plan -> Consent -> Apply -> Audit).
+
+## 2. Tools & Skills
+Sempre verifique extensões instaladas e documentação do projeto via `.agent/skills/` ou referências locais do diretório `.agent` para aplicar soluções sob o escopo esperado do mantenedor.
+
+## 3. Comportamento
+Preserve a integridade do sistema do usuário e nunca faça deleções não solicitadas em arquivos da pipeline e fora das permissões.