@fabioforest/openclaw 3.0.0 → 3.4.1

package/lib/cli/doctor.js

@@ -166,12 +166,16 @@ async function checkPort() {
     try {
         const inUse = await portInUse(18789, "127.0.0.1");
         if (inUse) {
-            return { name: "porta 18789", status: "ok", message: "Serviço respondendo em localhost:18789" };
+            return {
+                name: "porta 18789",
+                status: "ok",
+                message: "✅ Control UI acessível em http://127.0.0.1:18789"
+            };
         }
         return {
             name: "porta 18789",
             status: "warn",
-            message: "Porta livre — serviço OpenClaw pode estar parado",
+            message: "Porta livre — serviço OpenClaw pode estar parado (UI indisponível)",
         };
     } catch {
         return {
@@ -182,6 +186,30 @@ async function checkPort() {
     }
 }
 
+/**
+ * Verifica interfaces de rede para detectar VPN WireGuard ativa (Linux only).
+ * @returns {CheckResult}
+ */
+function checkVpnInterface() {
+    const osType = require("os").type();
+    if (osType !== "Linux") {
+        return { name: "vpn interface", status: "ok", message: "N/A (não é Linux)" };
+    }
+
+    try {
+        const interfaces = require("os").networkInterfaces();
+        const wgInterface = Object.keys(interfaces).find(iface => iface.startsWith("wg"));
+
+        if (wgInterface) {
+            return { name: "vpn interface", status: "ok", message: `Detectada: ${wgInterface}` };
+        } else {
+            return { name: "vpn interface", status: "warn", message: "Nenhuma interface wg* encontrada" };
+        }
+    } catch (e) {
+        return { name: "vpn interface", status: "warn", message: "Erro ao listar interfaces" };
+    }
+}
+
 /**
  * Verifica ambiente detectado.
  * @returns {CheckResult}
@@ -252,6 +280,12 @@ async function run({ targetPath, flags }) {
     // 4. .agent/
     results.push(...checkAgentDir(agentDir));
 
+    // 5. VPN (se Linux)
+    const vpnCheck = checkVpnInterface();
+    if (vpnCheck.message !== "N/A (não é Linux)") {
+        results.push(vpnCheck);
+    }
+
     // Exibir relatório
     printReport(results);
     console.log("");
@@ -263,4 +297,4 @@ async function run({ targetPath, flags }) {
     }
 }
 
-module.exports = { run, checkConfig, checkAgentDir, checkPort, checkEnvironment };
+module.exports = { run, checkConfig, checkAgentDir, checkPort, checkEnvironment, checkVpnInterface };

package/lib/cli/ide.js

@@ -0,0 +1,218 @@
+"use strict";
+
+/**
+ * Comando CLI: ide
+ *
+ * Gerencia a instalação do OpenClaw AI OS em IDEs.
+ * Sub-comandos: install (plan/apply), doctor.
+ * Sempre segue o protocolo consent-first.
+ */
+
+const fs = require("fs");
+const path = require("path");
+const readline = require("readline");
+const { detectContext, getAuditHeader } = require("../context");
+const { copyDirRecursive } = require("./init");
+
+// Caminho dos templates do pacote
+const TEMPLATES_DIR = path.join(__dirname, "..", "..", "templates");
+
+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()); }));
+}
+
+/**
+ * Grava log de auditoria para o comando ide.
+ */
+function writeAudit(targetPath, lines, flags) {
+    if (flags.audit === false) return;
+    const auditDir = path.join(targetPath, ".agent", "audit");
+    if (!fs.existsSync(auditDir)) {
+        try { fs.mkdirSync(auditDir, { recursive: true }); } catch (e) { }
+    }
+    const filename = `ide-${new Date().toISOString().replace(/[:.]/g, "-")}.md`;
+    try {
+        fs.writeFileSync(path.join(auditDir, filename), lines.join("\n") + "\n", "utf8");
+    } catch (e) {
+        console.error("⚠️  Falha ao gravar auditoria:", e.message);
+    }
+}
+
+/**
+ * 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";
+
+    if (subCmd === "doctor") {
+        return runDoctor({ targetPath, flags });
+    }
+
+    return runInstall({ targetPath, flags });
+}
+
+/**
+ * Sub-comando: ide install
+ * Instala .agent/ no projeto para uso em IDEs (plan/apply).
+ */
+async function runInstall({ targetPath, flags }) {
+    const agentDst = path.join(targetPath, ".agent");
+    const agentSrc = path.join(TEMPLATES_DIR, ".agent");
+    const ctx = detectContext(targetPath);
+    const planMode = !flags.apply;
+    const audit = [getAuditHeader(ctx, "ide install", flags)];
+
+    console.log(`\n🧭 IDE Install — Plano (${planMode ? "SIMULAÇÃO" : "APPLY"}):\n`);
+    console.log(`   Contexto: ${ctx.env} | IDE: ${ctx.ide}\n`);
+
+    if (fs.existsSync(agentDst) && !flags.force) {
+        console.log("  ✅ KEEP    .agent/ (já existe)");
+        console.log("  📦 MERGE   Novos templates serão adicionados (preservando existentes)");
+    } else if (fs.existsSync(agentDst) && flags.force) {
+        console.log("  🔥 DELETE  .agent/ (--force)");
+        console.log("  📦 COPY    templates/.agent -> .agent/");
+    } else {
+        console.log("  📁 CREATE  .agent/");
+        console.log("  📦 COPY    templates/.agent -> .agent/");
+    }
+
+    // State templates (mission_control.json, MEMORY.md)
+    const stateDir = path.join(agentDst, "state");
+    if (!fs.existsSync(stateDir)) {
+        console.log("  📁 CREATE  .agent/state/ (Mission Control + MEMORY)");
+    } else {
+        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;
+            }
+        } 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)");
+        }
+
+        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);
+    }
+}
+
+/**
+ * Sub-comando: ide doctor
+ * Verifica se a IDE está "armada" com regras, hooks e skills.
+ */
+async function runDoctor({ targetPath }) {
+    const agentDir = path.join(targetPath, ".agent");
+    const checks = [];
+
+    console.log("\n🏥 IDE Doctor — Verificando instalação para IDE:\n");
+
+    // Verificar .agent/
+    checks.push({ name: ".agent/", ok: fs.existsSync(agentDir) });
+
+    // Verificar rules
+    const rulesDir = path.join(agentDir, "rules");
+    const requiredRules = ["CONSENT_FIRST.md", "ROUTER_PROTOCOL.md"];
+    for (const rule of requiredRules) {
+        checks.push({ name: `rules/${rule}`, ok: fs.existsSync(path.join(rulesDir, rule)) });
+    }
+
+    // Verificar skills críticas
+    const skillsDir = path.join(agentDir, "skills");
+    const criticalSkills = ["openclaw-router", "openclaw-inspect", "openclaw-dev"];
+    for (const skill of criticalSkills) {
+        checks.push({ name: `skills/${skill}/SKILL.md`, ok: fs.existsSync(path.join(skillsDir, skill, "SKILL.md")) });
+    }
+
+    // Verificar hooks
+    const hooksDir = path.join(agentDir, "hooks");
+    checks.push({ name: "hooks/pre-tool-use.js", ok: fs.existsSync(path.join(hooksDir, "pre-tool-use.js")) });
+
+    // Exibir resultado
+    let allOk = true;
+    for (const c of checks) {
+        const icon = c.ok ? "✅" : "❌";
+        console.log(`   ${icon} ${c.name}`);
+        if (!c.ok) allOk = false;
+    }
+
+    if (allOk) {
+        console.log("\n🎉 IDE está totalmente configurada!");
+    } else {
+        console.log("\n⚠️  Componentes ausentes. Rode: npx openclaw ide install --apply");
+    }
+}
+
+module.exports = { run };

package/lib/cli/init.js

@@ -10,19 +10,42 @@
 
 const fs = require("fs");
 const path = require("path");
+const readline = require("readline");
 const { initConfigDefaults, writeJsonSafe } = require("../config");
+const { detectContext, getAuditHeader } = require("../context");
 
 // Caminho dos templates incluídos no pacote
 const TEMPLATES_DIR = path.join(__dirname, "..", "..", "templates", ".agent");
 
+function ask(q) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((res) => rl.question(q, (ans) => { rl.close(); res(ans.trim()); }));
+}
+
+function safeRel(targetPath, p) {
+    return path.relative(targetPath, p);
+}
+
+function writeAudit(targetPath, lines, flags) {
+    if (flags.audit === false) return;
+    const auditDir = path.join(targetPath, ".agent", "audit");
+    if (!fs.existsSync(auditDir)) {
+        // Tenta criar apenas se estivermos em modo apply, mas aqui já devemos estar
+        try { fs.mkdirSync(auditDir, { recursive: true }); } catch (e) { }
+    }
+    const filename = `init-${new Date().toISOString().replace(/[:.]/g, "-")}.md`;
+    const auditPath = path.join(auditDir, filename);
+    try {
+        fs.writeFileSync(auditPath, lines.join("\n") + "\n", "utf8");
+    } catch (e) {
+        console.error("⚠️  Falha ao gravar auditoria:", e.message);
+    }
+}
+
 /**
- * Copia diretório recursivamente.
- * @param {string} src — diretório fonte
- * @param {string} dest — diretório destino
- * @param {object} [stats] — contador de arquivos copiados
- * @returns {object} stats com { files, dirs }
+ * Copia diretório recursivamente (Utilitário mantido)
  */
-function copyDirRecursive(src, dest, stats = { files: 0, dirs: 0 }) {
+function copyDirRecursive(src, dest, stats = { files: 0, dirs: 0, skipped: 0 }, merge = false) {
     if (!fs.existsSync(dest)) {
         fs.mkdirSync(dest, { recursive: true });
         stats.dirs++;
@@ -35,110 +58,143 @@ function copyDirRecursive(src, dest, stats = { files: 0, dirs: 0 }) {
         const destPath = path.join(dest, entry.name);
 
         if (entry.isDirectory()) {
-            copyDirRecursive(srcPath, destPath, stats);
+            copyDirRecursive(srcPath, destPath, stats, merge);
         } else {
-            fs.copyFileSync(srcPath, destPath);
-            stats.files++;
+            if (merge && fs.existsSync(destPath)) {
+                stats.skipped++;
+            } else {
+                fs.copyFileSync(srcPath, destPath);
+                stats.files++;
+            }
         }
     }
-
     return stats;
 }
 
 /**
- * Executa o comando init.
- * @param {object} options
- * @param {string} options.targetPath — diretório alvo
- * @param {object} options.flags — flags do CLI (force, quiet)
+ * Executa o comando init com segurança.
  */
 async function run({ targetPath, flags }) {
     const agentDir = path.join(targetPath, ".agent");
     const configPath = path.join(targetPath, "openclaw.json");
+    const ctx = detectContext(targetPath);
 
-    // Verificar se já existe
-    if (fs.existsSync(agentDir) && !flags.force) {
-        console.error("❌ Diretório .agent/ já existe.");
-        console.error("   Use --force para sobrescrever ou 'openclaw update' para atualizar.");
-        process.exit(1);
-    }
+    // Default: Plan Mode (read-only), exceto se --apply for passado
+    const planMode = !flags.apply;
+
+    const actions = [];
+    const audit = [getAuditHeader(ctx, "init", flags)];
+    const errors = [];
 
-    // Verificar se templates existem
+    // 1. Validar Templates
     if (!fs.existsSync(TEMPLATES_DIR)) {
-        console.error("❌ Templates não encontrados. Pacote pode estar corrompido.");
+        console.error("❌ Templates não encontrados. Pacote corrompido.");
         process.exit(1);
     }
 
-    if (!flags.quiet) {
-        console.log("🦀 OpenClaw — Inicializando projeto...\n");
-    }
-
-    // Se --force e já existe, alertar
-    if (fs.existsSync(agentDir) && flags.force) {
-        if (!flags.quiet) {
-            console.log("⚠️  --force: substituindo .agent/ existente\n");
+    // 2. Construir Plano
+    if (fs.existsSync(agentDir)) {
+        if (!flags.force && !flags.merge) {
+            console.error("❌ Diretório .agent/ já existe.");
+            console.error("   Use --merge (seguro) ou --force (destrutivo).");
+            process.exit(1);
         }
-        fs.rmSync(agentDir, { recursive: true, force: true });
+        if (flags.force) {
+            actions.push({ type: "DELETE_DIR", path: agentDir, reason: "--force requested" });
+            actions.push({ type: "CREATE_DIR", path: agentDir });
+            actions.push({ type: "COPY_DIR", from: TEMPLATES_DIR, to: agentDir });
+        } else if (flags.merge) {
+            actions.push({ type: "MERGE_DIR", from: TEMPLATES_DIR, to: agentDir, reason: "--merge requested" });
+        }
+    } else {
+        actions.push({ type: "CREATE_DIR", path: agentDir });
+        actions.push({ type: "COPY_DIR", from: TEMPLATES_DIR, to: agentDir });
     }
 
-    // Copiar templates
-    const stats = copyDirRecursive(TEMPLATES_DIR, agentDir);
+    if (!fs.existsSync(configPath)) {
+        actions.push({ type: "CREATE_FILE", path: configPath, reason: "Default config" });
+    } else {
+        actions.push({ type: "NOOP", path: configPath, reason: "Config exists" });
+    }
 
-    if (!flags.quiet) {
-        console.log(`✅ .agent/ instalado com sucesso!`);
-        console.log(`   📁 ${stats.dirs} diretórios criados`);
-        console.log(`   📄 ${stats.files} arquivos copiados\n`);
+    // 3. Exibir Plano
+    console.log(`\n🧭 Plano de Execução (${planMode ? "SIMULAÇÃO" : "APPLY"}):\n`);
+    console.log(`   Contexto: ${ctx.env} | 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)}`);
     }
 
-    // Criar openclaw.json com defaults (se não existir)
-    if (!fs.existsSync(configPath)) {
-        const defaults = initConfigDefaults({});
-        writeJsonSafe(configPath, defaults);
+    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 (!flags.quiet) {
-            console.log("📋 openclaw.json criado com configurações padrão\n");
+    // 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;
+            }
+        } else {
+            const ok = await ask("\nAplicar este plano? (y/N): ");
+            if (ok.toLowerCase() !== "y") {
+                console.log("⏹️  Cancelado.");
+                return;
+            }
         }
-    } else if (!flags.quiet) {
-        console.log("📋 openclaw.json já existe — mantido\n");
     }
 
-    // Resumo final
-    if (!flags.quiet) {
-        console.log("📂 Estrutura instalada:");
-        listInstalledStructure(agentDir, "   ");
+    // 5. Execução
+    try {
+        console.log("\n🚀 Executando...");
 
-        console.log("\n🚀 Próximos passos:");
-        console.log("   1. openclaw setup    — configurar ambiente");
-        console.log("   2. openclaw doctor   — verificar saúde");
-        console.log("   3. openclaw status   — ver status\n");
-    }
-}
+        for (const a of actions) {
+            if (a.type === "DELETE_DIR") {
+                fs.rmSync(a.path, { recursive: true, force: true });
+                audit.push(`- ACT: DELETED ${a.path}`);
+            }
+        }
 
-/**
- * Lista a estrutura instalada de forma visual.
- * @param {string} dir — diretório para listar
- * @param {string} prefix — prefixo para indentação
- */
-function listInstalledStructure(dir, prefix = "") {
-    const entries = fs.readdirSync(dir, { withFileTypes: true })
-        .sort((a, b) => {
-            // Diretórios primeiro, depois arquivos
-            if (a.isDirectory() && !b.isDirectory()) return -1;
-            if (!a.isDirectory() && b.isDirectory()) return 1;
-            return a.name.localeCompare(b.name);
-        });
-
-    for (let i = 0; i < entries.length; i++) {
-        const entry = entries[i];
-        const isLast = i === entries.length - 1;
-        const connector = isLast ? "└── " : "├── ";
-        const icon = entry.isDirectory() ? "📁" : "📄";
-
-        console.log(`${prefix}${connector}${icon} ${entry.name}`);
+        // 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.`);
+        }
 
-        if (entry.isDirectory()) {
-            const childPrefix = prefix + (isLast ? "    " : "│   ");
-            listInstalledStructure(path.join(dir, entry.name), childPrefix);
+        // 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));
+
+        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);
     }
 }
 

package/lib/cli/inspect.js

@@ -0,0 +1,58 @@
+"use strict";
+
+/**
+ * Comando CLI: inspect
+ *
+ * 100% Read-Only. Coleta e exibe contexto do ambiente sem alterar nada.
+ * Usado como primeiro passo antes de qualquer ação.
+ */
+
+const path = require("path");
+const collectContext = require("../context/collector");
+
+// Caminho dos templates do pacote
+const TEMPLATES_DIR = path.join(__dirname, "..", "..", "templates");
+
+/**
+ * Executa o comando inspect (read-only puro).
+ * @param {object} options
+ * @param {string} options.targetPath — diretório alvo
+ * @param {object} options.flags — flags do CLI
+ */
+async function run({ targetPath, flags }) {
+    const ctx = collectContext({
+        targetPath,
+        templatesDir: TEMPLATES_DIR,
+    });
+
+    if (flags.quiet) {
+        // Modo silencioso: só JSON
+        console.log(JSON.stringify(ctx, null, 2));
+        return ctx;
+    }
+
+    console.log("\n🔎 OpenClaw Inspect (Read-Only)\n");
+    console.log(`   🖥️  Plataforma: ${ctx.env.platform}`);
+    console.log(`   🐳 Docker: ${ctx.env.docker}`);
+    console.log(`   🪟 WSL: ${ctx.env.wsl}`);
+    console.log(`   💻 IDE: ${ctx.ide}`);
+    console.log(`   📂 Path: ${ctx.targetPath}`);
+    console.log(`   📦 OpenClaw instalado: ${ctx.openclaw.hasAgentDir ? "Sim" : "Não"}`);
+    console.log(`   📋 Config: ${ctx.openclaw.hasConfig ? "Sim" : "Não"}`);
+    console.log(`   🐙 Git repo: ${ctx.git.isRepo ? "Sim" : "Não"}`);
+
+    if (ctx.skillsInstalled.length > 0) {
+        console.log(`\n   🧠 Skills instaladas (${ctx.skillsInstalled.length}):`);
+        ctx.skillsInstalled.forEach(s => console.log(`      • ${s.name}`));
+    }
+
+    if (ctx.skillsInTemplates.length > 0) {
+        console.log(`\n   📦 Skills disponíveis nos templates (${ctx.skillsInTemplates.length}):`);
+        ctx.skillsInTemplates.forEach(s => console.log(`      • ${s.name}`));
+    }
+
+    console.log("\n✅ Inspect concluído (nenhuma alteração feita).\n");
+    return ctx;
+}
+
+module.exports = { run };