wolverine-ai 6.2.3 → 6.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wolverine-ai",
-  "version": "6.2.3",
+  "version": "6.3.1",
   "description": "Self-healing Node.js server framework powered by AI. Catches crashes, diagnoses errors, generates fixes, verifies, and restarts — automatically.",
   "main": "src/index.js",
   "bin": {

package/src/backup/backup-manager.js

@@ -30,6 +30,7 @@ const NEVER_ROLLBACK = [
   "server/config/settings.json",
   "server/lib/db.js",
   "server/lib/redis.js",
+  "wolverine-claw/config/settings.json",
   ".env",
   ".env.local",
   ".wolverine/vault/master.key",
@@ -352,10 +353,9 @@ class BackupManager {
   }
 
   _collectServerFiles() {
-    const serverDir = path.join(this.projectRoot, "server");
-    if (!fs.existsSync(serverDir)) return [];
     const files = [];
     const SKIP = new Set(["node_modules", ".git", ".wolverine"]);
+    const maxFileSize = 10 * 1024 * 1024; // 10MB
 
     const walk = (dir) => {
       let entries;
@@ -365,11 +365,39 @@ class BackupManager {
         const fullPath = path.join(dir, entry.name);
         if (entry.isDirectory()) walk(fullPath);
         else {
-          try { if (fs.statSync(fullPath).size <= 10 * 1024 * 1024) files.push(fullPath); } catch {}
+          try { if (fs.statSync(fullPath).size <= maxFileSize) files.push(fullPath); } catch {}
         }
       }
     };
-    walk(serverDir);
+
+    // 1. server/ — user server code (original behavior)
+    const serverDir = path.join(this.projectRoot, "server");
+    if (fs.existsSync(serverDir)) walk(serverDir);
+
+    // 2. wolverine-claw/ — claw config, plugins, custom skills
+    //    Skip workspace/ (agent-generated files, can be large/numerous)
+    const clawDir = path.join(this.projectRoot, "wolverine-claw");
+    if (fs.existsSync(clawDir)) {
+      const clawSubdirs = ["config", "plugins", "skills"];
+      for (const sub of clawSubdirs) {
+        const subDir = path.join(clawDir, sub);
+        if (fs.existsSync(subDir)) walk(subDir);
+      }
+      // Also back up wolverine-claw/index.js directly
+      const clawIndex = path.join(clawDir, "index.js");
+      if (fs.existsSync(clawIndex)) files.push(clawIndex);
+    }
+
+    // 3. .openclaw/ — OpenClaw config (if user has one)
+    const openclawDir = path.join(this.projectRoot, ".openclaw");
+    if (fs.existsSync(openclawDir)) walk(openclawDir);
+
+    // 4. Top-level openclaw config files
+    for (const cfgName of ["openclaw.yml", "openclaw.yaml", ".openclaw.yml"]) {
+      const cfgPath = path.join(this.projectRoot, cfgName);
+      if (fs.existsSync(cfgPath)) files.push(cfgPath);
+    }
+
     return files;
   }
 }

package/src/claw/standalone-agent.js

@@ -2,10 +2,9 @@
  * Wolverine Claw Standalone Agent
  *
  * When OpenClaw isn't installed (or Node < 22), this provides a built-in
- * agentic terminal REPL using wolverine's own AI client. Users get an
- * interactive coding agent that can read/write/edit files, run commands,
- * search code, and self-heal — all powered by the same AI pipeline as
- * wolverine's server healing.
+ * agentic terminal REPL using wolverine's full agent engine — all 32 tools
+ * (file ops, shell, git, diagnostics, database, network, deps, research,
+ * advanced monitoring) powered by the same AI pipeline as server healing.
  *
  * This makes wolverine-claw work immediately without any external deps,
  * and openclaw becomes an optional enhancement for multi-channel support.
@@ -15,266 +14,11 @@ const fs = require("fs");
 const path = require("path");
 const readline = require("readline");
 const chalk = require("chalk");
-const { execSync } = require("child_process");
-
-// ── Tool Definitions ────────────────────────────────────────────
-
-function buildTools(cwd, workspacePath, config) {
-  const sandbox = config.security?.sandbox !== false;
-
-  function resolveSafe(filePath) {
-    const resolved = path.resolve(cwd, filePath);
-    if (sandbox) {
-      // In sandbox mode, allow cwd and workspace
-      if (!resolved.startsWith(cwd)) return null;
-      // Block protected paths
-      const rel = path.relative(cwd, resolved);
-      if (rel.startsWith("node_modules") || rel.startsWith(".env") || rel.startsWith("src/")) {
-        return null;
-      }
-    }
-    return resolved;
-  }
-
-  return [
-    {
-      name: "read_file",
-      description: "Read a file's contents. Use offset and limit for large files.",
-      input_schema: {
-        type: "object",
-        properties: {
-          path: { type: "string", description: "File path relative to project root" },
-          offset: { type: "number", description: "Start line (0-indexed)" },
-          limit: { type: "number", description: "Max lines to read" },
-        },
-        required: ["path"],
-      },
-      execute: ({ path: p, offset, limit }) => {
-        const resolved = resolveSafe(p);
-        if (!resolved) return `[ERROR] Access denied: ${p}`;
-        try {
-          let content = fs.readFileSync(resolved, "utf-8");
-          if (offset || limit) {
-            const lines = content.split("\n");
-            const start = offset || 0;
-            const end = limit ? start + limit : lines.length;
-            content = lines.slice(start, end).join("\n");
-          }
-          if (content.length > 8000) content = content.slice(0, 8000) + "\n... (truncated)";
-          return content;
-        } catch (e) { return `[ERROR] ${e.message}`; }
-      },
-    },
-    {
-      name: "write_file",
-      description: "Write content to a file. Creates directories if needed.",
-      input_schema: {
-        type: "object",
-        properties: {
-          path: { type: "string", description: "File path relative to project root" },
-          content: { type: "string", description: "File content" },
-        },
-        required: ["path", "content"],
-      },
-      execute: ({ path: p, content }) => {
-        const resolved = resolveSafe(p);
-        if (!resolved) return `[ERROR] Access denied: ${p}`;
-        try {
-          fs.mkdirSync(path.dirname(resolved), { recursive: true });
-          fs.writeFileSync(resolved, content);
-          return `Written: ${p} (${content.length} bytes)`;
-        } catch (e) { return `[ERROR] ${e.message}`; }
-      },
-    },
-    {
-      name: "edit_file",
-      description: "Find and replace text in a file. Surgical single-match edit.",
-      input_schema: {
-        type: "object",
-        properties: {
-          path: { type: "string", description: "File path relative to project root" },
-          find: { type: "string", description: "Exact text to find" },
-          replace: { type: "string", description: "Replacement text" },
-        },
-        required: ["path", "find", "replace"],
-      },
-      execute: ({ path: p, find, replace }) => {
-        const resolved = resolveSafe(p);
-        if (!resolved) return `[ERROR] Access denied: ${p}`;
-        try {
-          const content = fs.readFileSync(resolved, "utf-8");
-          if (!content.includes(find)) return `[ERROR] Text not found in ${p}`;
-          const count = content.split(find).length - 1;
-          if (count > 1) return `[ERROR] ${count} matches found — provide more context for a unique match`;
-          fs.writeFileSync(resolved, content.replace(find, replace));
-          return `Edited: ${p}`;
-        } catch (e) { return `[ERROR] ${e.message}`; }
-      },
-    },
-    {
-      name: "list_dir",
-      description: "List files and directories in a path.",
-      input_schema: {
-        type: "object",
-        properties: {
-          path: { type: "string", description: "Directory path relative to project root" },
-        },
-        required: ["path"],
-      },
-      execute: ({ path: p }) => {
-        const resolved = resolveSafe(p || ".");
-        if (!resolved) return `[ERROR] Access denied: ${p}`;
-        try {
-          const entries = fs.readdirSync(resolved, { withFileTypes: true });
-          return entries.map(e => {
-            const prefix = e.isDirectory() ? "[DIR]  " : "       ";
-            let size = "";
-            if (!e.isDirectory()) {
-              try { size = ` (${fs.statSync(path.join(resolved, e.name)).size}b)`; } catch {}
-            }
-            return `${prefix}${e.name}${size}`;
-          }).join("\n");
-        } catch (e) { return `[ERROR] ${e.message}`; }
-      },
-    },
-    {
-      name: "glob_files",
-      description: "Find files matching a glob pattern (e.g., **/*.js).",
-      input_schema: {
-        type: "object",
-        properties: {
-          pattern: { type: "string", description: "Glob pattern" },
-        },
-        required: ["pattern"],
-      },
-      execute: ({ pattern }) => {
-        try {
-          // Use Node's fs.globSync if available (Node 22+), else fallback to find
-          if (fs.globSync) {
-            const matches = fs.globSync(pattern, { cwd });
-            return matches.slice(0, 50).join("\n") || "No matches";
-          }
-          // Fallback: simple recursive walk with pattern matching
-          const simplePattern = pattern.replace(/\*\*/g, "").replace(/\*/g, "");
-          const ext = path.extname(simplePattern) || "";
-          const results = [];
-          function walk(dir, depth) {
-            if (depth > 5 || results.length > 50) return;
-            try {
-              for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
-                if (e.name.startsWith(".") || e.name === "node_modules") continue;
-                const full = path.join(dir, e.name);
-                if (e.isDirectory()) walk(full, depth + 1);
-                else if (!ext || e.name.endsWith(ext)) results.push(path.relative(cwd, full));
-              }
-            } catch {}
-          }
-          walk(cwd, 0);
-          return results.join("\n") || "No matches";
-        } catch (e) { return `[ERROR] ${e.message}`; }
-      },
-    },
-    {
-      name: "grep_code",
-      description: "Search file contents for a regex pattern.",
-      input_schema: {
-        type: "object",
-        properties: {
-          pattern: { type: "string", description: "Regex pattern to search for" },
-          path: { type: "string", description: "File or directory to search in (default: .)" },
-        },
-        required: ["pattern"],
-      },
-      execute: ({ pattern, path: searchPath }) => {
-        const resolved = resolveSafe(searchPath || ".");
-        if (!resolved) return `[ERROR] Access denied`;
-        try {
-          const result = execSync(
-            `grep -rn --include="*.js" --include="*.json" --include="*.ts" --include="*.md" "${pattern.replace(/"/g, '\\"')}" "${resolved}" 2>/dev/null | head -30`,
-            { encoding: "utf-8", timeout: 10000, cwd }
-          );
-          return result.trim() || "No matches";
-        } catch {
-          // grep returns exit 1 on no match
-          return "No matches";
-        }
-      },
-    },
-    {
-      name: "bash_exec",
-      description: "Execute a shell command. 30s timeout. Dangerous commands blocked.",
-      input_schema: {
-        type: "object",
-        properties: {
-          command: { type: "string", description: "Shell command to run" },
-        },
-        required: ["command"],
-      },
-      execute: ({ command }) => {
-        // Block dangerous commands
-        const blocked = ["rm -rf /", "rm -rf /*", "mkfs", "dd if=", "shutdown", "reboot",
-          "format c:", "git push --force", "npm publish", "> /dev/sda"];
-        for (const b of blocked) {
-          if (command.includes(b)) return `[ERROR] Blocked dangerous command: ${b}`;
-        }
-        try {
-          const result = execSync(command, {
-            encoding: "utf-8",
-            timeout: 30000,
-            cwd,
-            maxBuffer: 1024 * 1024,
-          });
-          const trimmed = result.trim();
-          if (trimmed.length > 4000) return trimmed.slice(0, 4000) + "\n... (truncated)";
-          return trimmed || "(no output)";
-        } catch (e) {
-          return `[ERROR] ${e.message?.split("\n")[0] || "Command failed"}`;
-        }
-      },
-    },
-    {
-      name: "done",
-      description: "Signal that you have completed the user's request. Include a summary.",
-      input_schema: {
-        type: "object",
-        properties: {
-          summary: { type: "string", description: "Summary of what was done" },
-        },
-        required: ["summary"],
-      },
-      execute: ({ summary }) => summary,
-    },
-  ];
-}
-
-// ── Agent Loop ──────────────────────────────────────────────────
-
-/**
- * Run one agent turn: send messages to AI, execute tool calls, return.
- */
-async function agentTurn(aiCall, model, systemPrompt, messages, tools, maxTokens) {
-  // Convert tools to AI format
-  const toolDefs = tools.map(t => ({
-    name: t.name,
-    description: t.description,
-    input_schema: t.input_schema,
-  }));
-
-  const result = await aiCall({
-    model,
-    messages,
-    tools: toolDefs,
-    maxTokens,
-    category: "tool",
-  });
-
-  return result;
-}
 
 // ── REPL ────────────────────────────────────────────────────────
 
 /**
- * Start the standalone agent REPL.
+ * Start the standalone agent REPL with all 32 wolverine tools.
  */
 async function startRepl(config, options = {}) {
   const cwd = options.cwd || process.cwd();
@@ -297,27 +41,78 @@ async function startRepl(config, options = {}) {
     process.exit(1);
   }
 
-  const tools = buildTools(cwd, workspacePath, config);
+  // Load the real AgentEngine + TOOL_DEFINITIONS from wolverine's agent
+  let AgentEngine, TOOL_DEFINITIONS;
+  try {
+    const agentMod = require("../agent/agent-engine");
+    AgentEngine = agentMod.AgentEngine;
+    TOOL_DEFINITIONS = agentMod.TOOL_DEFINITIONS;
+  } catch (e) {
+    console.error(chalk.red(`  [CLAW] Failed to load agent engine: ${e.message}`));
+    process.exit(1);
+  }
+
+  // Use the real Sandbox — same security as heal pipeline
+  const { Sandbox } = require("../security/sandbox");
+  const sandbox = new Sandbox(cwd);
 
-  const systemPrompt = `You are Wolverine Claw, an agentic AI coding assistant running inside the Wolverine self-healing framework.
+  // Instantiate the agent engine for tool execution
+  const engine = new AgentEngine({
+    cwd,
+    sandbox,
+    maxTurns,
+    maxTokens: 100000,
+  });
+
+  // Count tools by category
+  const toolNames = TOOL_DEFINITIONS.map(t => t.function.name);
+  const categories = {
+    file: ["read_file", "write_file", "edit_file", "glob_files", "grep_code"],
+    shell: ["bash_exec", "git_log", "git_diff"],
+    diagnostics: ["list_dir", "move_file", "check_port", "check_env", "inspect_env", "check_memory", "list_processes", "check_logs", "check_network"],
+    database: ["inspect_db", "run_db_fix"],
+    deps: ["audit_deps", "check_migration"],
+    research: ["web_fetch"],
+    advanced: ["verify_node_modules", "inspect_certificate", "inspect_cache", "disk_cleanup", "check_file_descriptors", "check_event_loop", "check_websocket"],
+    env: ["add_env_var"],
+    server: ["restart_service"],
+    control: ["done"],
+  };
 
-You have access to tools for reading, writing, editing files, searching code, and running shell commands. You operate in the project at: ${cwd}
+  const systemPrompt = `You are Wolverine Claw, an agentic AI coding assistant running inside the Wolverine self-healing framework.
 
-Your workspace for creating new files is: ${workspacePath}
+You have access to ${TOOL_DEFINITIONS.length} tools across ${Object.keys(categories).length} categories:
+- FILE: read_file, write_file, edit_file, glob_files, grep_code
+- SHELL & GIT: bash_exec, git_log, git_diff
+- DIAGNOSTICS: list_dir, move_file, check_port, check_env, inspect_env, check_memory, list_processes, check_logs, check_network
+- DATABASE: inspect_db, run_db_fix (always inspect_db FIRST)
+- DEPENDENCIES: audit_deps, check_migration
+- RESEARCH: web_fetch
+- ADVANCED: verify_node_modules, inspect_certificate, inspect_cache, disk_cleanup, check_file_descriptors, check_event_loop, check_websocket
+- ENVIRONMENT: add_env_var
+- SERVER: restart_service
+- CONTROL: done
+
+Project root: ${cwd}
+Workspace for new files: ${workspacePath}
 
 Guidelines:
-- Read files before editing them. Understand existing code before making changes.
-- Use edit_file for surgical changes, write_file for new files.
-- Use grep_code and glob_files to explore the codebase before making assumptions.
-- Use bash_exec for git, npm, and system commands.
-- When done with a task, use the done tool with a summary.
-- Be concise. Fix what's asked, don't add unnecessary changes.
-- Protected paths (read-only): src/, node_modules/, .env files.`;
+- Read files before editing. Understand existing code first.
+- Use edit_file (old_text/new_text) for surgical changes, write_file for new files.
+- Use grep_code and glob_files to explore the codebase.
+- Use bash_exec for git, npm, system commands.
+- Use inspect_db before run_db_fix. Always check before modifying.
+- Use audit_deps when dependency issues are suspected.
+- Use check_port for EADDRINUSE, check_network for connectivity, inspect_certificate for TLS.
+- When done with a task, call the done tool with a summary.
+- Be concise. Fix what's asked.`;
 
   console.log(chalk.blue.bold("\n  🐾 Wolverine Claw — Interactive Agent\n"));
   console.log(chalk.gray(`  Model:     ${model}`));
   console.log(chalk.gray(`  Workspace: ${workspacePath}`));
-  console.log(chalk.gray(`  Tools:     ${tools.length} (read, write, edit, list, glob, grep, bash, done)`));
+  console.log(chalk.gray(`  Tools:     ${TOOL_DEFINITIONS.length} across ${Object.keys(categories).length} categories`));
+  console.log(chalk.gray(`             file(5) shell(3) diagnostics(9) database(2) deps(2)`));
+  console.log(chalk.gray(`             research(1) advanced(7) env(1) server(1) control(1)`));
   console.log(chalk.gray(`  Max turns: ${maxTurns}`));
   console.log(chalk.gray(`  Type 'exit' or Ctrl+C to quit.\n`));
 
@@ -327,7 +122,6 @@ Guidelines:
     prompt: chalk.blue("  🐾 > "),
   });
 
-  // Conversation history
   let messages = [];
 
   rl.prompt();
@@ -341,7 +135,6 @@ Guidelines:
       process.exit(0);
     }
 
-    // Special commands
     if (input === "/clear") {
       messages = [];
       console.log(chalk.gray("  Conversation cleared.\n"));
@@ -349,44 +142,35 @@ Guidelines:
       return;
     }
     if (input === "/status") {
-      console.log(chalk.gray(`  Messages: ${messages.length}, Model: ${model}`));
+      console.log(chalk.gray(`  Messages: ${messages.length}, Model: ${model}, Tools: ${TOOL_DEFINITIONS.length}`));
+      rl.prompt();
+      return;
+    }
+    if (input === "/tools") {
+      for (const [cat, names] of Object.entries(categories)) {
+        console.log(chalk.gray(`  ${cat}: ${names.join(", ")}`));
+      }
+      console.log("");
       rl.prompt();
       return;
     }
 
-    // Add user message
     messages.push({ role: "user", content: input });
 
-    // Agent loop
-    // aiCallWithHistory returns OpenAI-shaped responses:
-    //   {choices: [{message: {role, content, tool_calls}}], usage}
-    // Tool calls come as: {id, type:"function", function:{name, arguments:JSON_STRING}}
-    // Tool defs must be: {type:"function", function:{name, description, parameters}}
     let turn = 0;
     let done = false;
 
-    // Build OpenAI-format tool definitions once
-    const toolDefs = tools.map(t => ({
-      type: "function",
-      function: {
-        name: t.name,
-        description: t.description,
-        parameters: t.input_schema,
-      },
-    }));
-
     while (turn < maxTurns && !done) {
       turn++;
       try {
         const response = await aiCallWithHistory({
           model,
           messages: [{ role: "system", content: systemPrompt }, ...messages],
-          tools: toolDefs,
+          tools: TOOL_DEFINITIONS,
           maxTokens: 4096,
           category: "tool",
         });
 
-        // Extract from OpenAI-shaped response
         const msg = response.choices?.[0]?.message;
         if (!msg) {
           console.log(chalk.yellow("  (empty response)\n"));
@@ -397,14 +181,11 @@ Guidelines:
         const textContent = msg.content || "";
         const toolCalls = msg.tool_calls || [];
 
-        // Handle text content
         if (textContent) {
           console.log(chalk.white(`\n  ${textContent.replace(/\n/g, "\n  ")}\n`));
         }
 
-        // Handle tool calls
         if (toolCalls.length > 0) {
-          // Store assistant message with tool calls
           messages.push({
             role: "assistant",
             content: textContent || null,
@@ -420,33 +201,36 @@ Guidelines:
                 : (tc.function?.arguments || tc.input || {});
             } catch { toolInput = {}; }
 
-            const tool = tools.find(t => t.name === toolName);
-
-            if (!tool) {
-              console.log(chalk.yellow(`  [tool] Unknown: ${toolName}`));
-              messages.push({ role: "tool", tool_call_id: tc.id, content: `[ERROR] Unknown tool: ${toolName}` });
-              continue;
-            }
-
             if (toolName === "done") {
-              const summary = tool.execute(toolInput);
+              const summary = toolInput.summary || toolInput.message || "Task completed.";
               console.log(chalk.green(`  ✅ ${summary}\n`));
               messages.push({ role: "tool", tool_call_id: tc.id, content: summary });
               done = true;
               break;
             }
 
-            console.log(chalk.gray(`  [${toolName}] ${JSON.stringify(toolInput).slice(0, 100)}`));
-            const toolResult = tool.execute(toolInput);
-            const displayResult = toolResult.length > 200
-              ? toolResult.slice(0, 200) + "..."
+            console.log(chalk.gray(`  [${toolName}] ${JSON.stringify(toolInput).slice(0, 120)}`));
+
+            // Execute via the real AgentEngine — same tools as heal pipeline
+            let toolResult;
+            try {
+              const result = await engine._executeTool({
+                function: { name: toolName, arguments: JSON.stringify(toolInput) },
+              });
+              toolResult = typeof result === "string" ? result : (result?.content || JSON.stringify(result));
+            } catch (e) {
+              toolResult = `[ERROR] ${e.message}`;
+            }
+
+            // Cap display output
+            const displayResult = toolResult.length > 300
+              ? toolResult.slice(0, 300) + "..."
               : toolResult;
             console.log(chalk.gray(`  → ${displayResult.replace(/\n/g, "\n    ")}`));
 
             messages.push({ role: "tool", tool_call_id: tc.id, content: toolResult });
           }
         } else if (textContent) {
-          // Text-only response, no tool calls — done for this turn
           messages.push({ role: "assistant", content: textContent });
           done = true;
         } else {
@@ -476,7 +260,6 @@ Guidelines:
       process.send({ type: "claw_health", status: "running", detail: "standalone-agent", timestamp: Date.now() });
     } catch {}
 
-    // Heartbeat
     setInterval(() => {
       try {
         process.send({ type: "claw_heartbeat", uptime: process.uptime(), memory: process.memoryUsage(), timestamp: Date.now() });
@@ -485,4 +268,16 @@ Guidelines:
   }
 }
 
-module.exports = { startRepl, buildTools };
+/**
+ * Get tool definitions for external use (e.g., tests).
+ */
+function getToolDefinitions() {
+  try {
+    const { TOOL_DEFINITIONS } = require("../agent/agent-engine");
+    return TOOL_DEFINITIONS;
+  } catch {
+    return [];
+  }
+}
+
+module.exports = { startRepl, getToolDefinitions };

package/wolverine-claw/plugins/wolverine-integration.js

@@ -1,14 +1,21 @@
 /**
  * Wolverine Integration Plugin for OpenClaw
  *
- * Gives the claw agent access to wolverine's self-healing capabilities:
- * - Brain: semantic memory, project context, and learning
- * - Backup: workspace snapshots and rollback
- * - Healing: error diagnosis and auto-fix pipeline
- * - Health: process monitoring and status reporting
+ * Two integration layers:
  *
- * This plugin registers as an OpenClaw skill/extension, adding wolverine-specific
- * tools to the agent's toolkit.
+ * 1. TOOLS — 7 wolverine tools injected into the agent toolkit
+ *    (backup, rollback, brain search/learn, health, self-heal)
+ *
+ * 2. HOOKS — taps into OpenClaw's 28-hook plugin system for deep
+ *    error observability and self-healing triggers:
+ *    - after_tool_call: catch skill/tool failures
+ *    - agent_end: catch agent crashes and timeouts
+ *    - before_tool_call: detect and report tool loops
+ *    - message_sent: catch channel send failures
+ *    - llm_output: catch provider errors, failovers, billing blocks
+ *    - subagent_ended: catch subagent failures
+ *    - gateway_start/gateway_stop: lifecycle tracking
+ *    - session_end: session error tracking
  */
 
 const path = require("path");
@@ -16,51 +23,348 @@ const fs = require("fs");
 
 const PLUGIN_NAME = "wolverine-integration";
 
+// ── Error tracking state ────────────────────────────────────────
+
+const _errorCounts = {
+  tool: 0,
+  agent: 0,
+  channel: 0,
+  llm: 0,
+  subagent: 0,
+  total: 0,
+};
+
+const _recentErrors = []; // last 50 errors for context
+const MAX_RECENT = 50;
+
+function _trackError(category, summary, detail) {
+  _errorCounts[category] = (_errorCounts[category] || 0) + 1;
+  _errorCounts.total++;
+
+  const entry = {
+    category,
+    summary: summary?.slice(0, 200),
+    timestamp: Date.now(),
+    detail: detail?.slice?.(0, 500),
+  };
+  _recentErrors.push(entry);
+  if (_recentErrors.length > MAX_RECENT) _recentErrors.shift();
+
+  return entry;
+}
+
+// ── Main registration ───────────────────────────────────────────
+
 /**
  * Register the wolverine integration with the OpenClaw gateway.
+ * Supports both Plugin SDK (api.registerPluginHook) and basic EventEmitter.
  */
 async function register(gateway, config) {
   const projectRoot = path.resolve(__dirname, "../..");
 
-  // Register wolverine tools as OpenClaw tools/skills
+  // Register wolverine tools
   const tools = buildWolverineTools(projectRoot, config);
+  _registerTools(gateway, tools);
 
-  if (gateway.registerTools) {
-    gateway.registerTools(PLUGIN_NAME, tools);
-  } else if (gateway.addTools) {
-    gateway.addTools(tools);
-  } else if (gateway.skills?.register) {
-    gateway.skills.register(PLUGIN_NAME, {
-      description: "Wolverine self-healing integration — backup, brain, and health tools",
-      tools,
-    });
-  }
-
-  // Hook into gateway events for self-healing
-  if (gateway.on) {
-    gateway.on("error", (err) => handleGatewayError(err, projectRoot));
-    gateway.on("agent:error", (err) => handleAgentError(err, projectRoot));
-    gateway.on("skill:error", (err) => handleSkillError(err, projectRoot));
+  // Register into OpenClaw Plugin SDK hooks (preferred)
+  const api = _getPluginApi(gateway);
+  if (api) {
+    _registerPluginHooks(api, projectRoot, config);
+    console.log("[CLAW] Wolverine plugin hooks registered (Plugin SDK)");
   }
+  // Also register EventEmitter hooks (fallback / additional coverage)
+  _registerEventHooks(gateway, projectRoot);
 
-  // Periodic health reporting
+  // Periodic health reporting with error stats
   const healthInterval = setInterval(() => {
     reportToWolverine("claw_heartbeat", {
       uptime: process.uptime(),
       memory: process.memoryUsage(),
+      errorCounts: { ..._errorCounts },
       timestamp: Date.now(),
     });
   }, 30000);
 
-  // Cleanup on shutdown
   if (gateway.on) {
     gateway.on("shutdown", () => clearInterval(healthInterval));
   }
 }
 
+// ── Plugin SDK Hooks ────────────────────────────────────────────
+
 /**
- * Build wolverine-specific tools for the OpenClaw agent.
+ * Get the Plugin SDK API from the gateway (if available).
  */
+function _getPluginApi(gateway) {
+  // OpenClaw exposes plugin registration via multiple paths
+  if (gateway.pluginApi) return gateway.pluginApi;
+  if (gateway.api) return gateway.api;
+  if (gateway.plugins?.api) return gateway.plugins.api;
+  if (typeof gateway.registerPluginHook === "function") return gateway;
+  return null;
+}
+
+/**
+ * Register all wolverine hooks into the OpenClaw Plugin SDK.
+ */
+function _registerPluginHooks(api, projectRoot, config) {
+  const registerHook = api.registerPluginHook || api.register;
+  if (typeof registerHook !== "function") return;
+
+  const reg = (name, handler, priority) => {
+    try {
+      registerHook.call(api, name, { handler, priority: priority || 100 });
+    } catch (e) {
+      // Hook not supported in this OpenClaw version — skip silently
+      try {
+        registerHook.call(api, name, handler);
+      } catch {}
+    }
+  };
+
+  // ── after_tool_call: catch skill and tool failures ──────────
+  reg("after_tool_call", (event, ctx) => {
+    if (!event) return;
+    const hasError = event.error || event.status === "error" || event.exitCode;
+
+    if (hasError) {
+      const toolName = event.toolName || event.name || "unknown";
+      const errorMsg = event.error?.message || event.error || event.stderr || "Tool failed";
+      const entry = _trackError("tool", `Tool ${toolName} failed: ${errorMsg}`);
+
+      console.error(`[CLAW] Tool error: ${toolName} — ${errorMsg.slice(0, 100)}`);
+
+      // Skill errors are wrapped as tool errors — detect them
+      const isSkill = toolName.includes("skill") || event.source === "skill";
+
+      reportToWolverine("route_error", {
+        path: `claw://tool/${toolName}`,
+        method: isSkill ? "SKILL" : "TOOL",
+        statusCode: 500,
+        message: `${isSkill ? "Skill" : "Tool"} ${toolName}: ${errorMsg}`.slice(0, 500),
+        stack: event.error?.stack || event.stderr || null,
+        file: event.file || null,
+        line: null,
+        timestamp: Date.now(),
+      });
+    }
+  });
+
+  // ── agent_end: catch agent failures and timeouts ────────────
+  reg("agent_end", (event, ctx) => {
+    if (!event) return;
+    const hasError = event.error || event.status === "error" || event.lifecycle === "error";
+
+    if (hasError) {
+      const reason = event.reason || event.error?.message || "Agent failed";
+      const isTimeout = reason.includes("timeout") || event.reason === "timeout";
+      const entry = _trackError("agent", `Agent ${isTimeout ? "timeout" : "error"}: ${reason}`);
+
+      console.error(`[CLAW] Agent ${isTimeout ? "timeout" : "error"}: ${reason.slice(0, 100)}`);
+
+      reportToWolverine("route_error", {
+        path: "claw://agent",
+        method: isTimeout ? "TIMEOUT" : "AGENT",
+        statusCode: isTimeout ? 408 : 500,
+        message: reason.slice(0, 500),
+        stack: event.error?.stack || null,
+        file: null,
+        line: null,
+        timestamp: Date.now(),
+      });
+    }
+  });
+
+  // ── before_tool_call: detect tool loops ─────────────────────
+  reg("before_tool_call", (event, ctx) => {
+    if (!event) return;
+
+    // OpenClaw's loop detection may have already flagged this
+    if (event.block || event.loopDetected) {
+      const toolName = event.toolName || event.name || "unknown";
+      const reason = event.blockReason || event.reason || "Loop detected";
+      _trackError("tool", `Tool loop blocked: ${toolName} — ${reason}`);
+
+      console.warn(`[CLAW] Tool loop blocked: ${toolName} — ${reason}`);
+
+      reportToWolverine("claw_warning", {
+        category: "tool_loop",
+        tool: toolName,
+        reason,
+        timestamp: Date.now(),
+      });
+    }
+  });
+
+  // ── message_sent: catch channel send failures ───────────────
+  reg("message_sent", (event, ctx) => {
+    if (!event) return;
+    const failed = event.success === false || event.error;
+
+    if (failed) {
+      const channel = event.channelId || event.channel || "unknown";
+      const errorMsg = event.error?.message || event.error || "Send failed";
+      _trackError("channel", `Channel ${channel}: ${errorMsg}`);
+
+      console.error(`[CLAW] Channel send failed: ${channel} — ${errorMsg.slice(0, 100)}`);
+
+      reportToWolverine("claw_warning", {
+        category: "channel_failure",
+        channel,
+        error: errorMsg.slice(0, 500),
+        timestamp: Date.now(),
+      });
+    }
+  });
+
+  // ── llm_output: catch provider errors and failovers ─────────
+  reg("llm_output", (event, ctx) => {
+    if (!event) return;
+    const hasError = event.error || event.failover;
+
+    if (hasError) {
+      const provider = event.provider || event.model || "unknown";
+      const reason = event.failoverReason || event.error?.message || event.error || "LLM error";
+      const status = event.httpCode || event.status;
+      _trackError("llm", `LLM ${provider}: ${reason} (${status || "?"})`);
+
+      // Billing errors (402) are critical — stop healing
+      const isBilling = status === 402 || reason.includes("billing");
+      // Rate limits (429) are transient
+      const isRateLimit = status === 429 || reason.includes("rate_limit");
+
+      if (isBilling) {
+        console.error(`[CLAW] BILLING ERROR: ${provider} — ${reason}`);
+        reportToWolverine("claw_critical", {
+          category: "billing",
+          provider,
+          error: reason.slice(0, 500),
+          timestamp: Date.now(),
+        });
+      } else if (!isRateLimit) {
+        // Don't spam wolverine with rate limit warnings
+        console.warn(`[CLAW] LLM error: ${provider} — ${reason.slice(0, 100)}`);
+        reportToWolverine("claw_warning", {
+          category: "llm_error",
+          provider,
+          status,
+          error: reason.slice(0, 500),
+          timestamp: Date.now(),
+        });
+      }
+    }
+  });
+
+  // ── subagent_ended: catch subagent failures ─────────────────
+  reg("subagent_ended", (event, ctx) => {
+    if (!event) return;
+    const failed = event.status === "error" || event.status === "timeout" || event.error;
+
+    if (failed) {
+      const agentId = event.subagentId || event.runId || "unknown";
+      const errorMsg = event.error?.message || event.error || `Subagent ${event.status}`;
+      _trackError("subagent", `Subagent ${agentId}: ${errorMsg}`);
+
+      console.error(`[CLAW] Subagent failed: ${agentId} — ${errorMsg.slice(0, 100)}`);
+
+      reportToWolverine("route_error", {
+        path: `claw://subagent/${agentId}`,
+        method: "SUBAGENT",
+        statusCode: 500,
+        message: errorMsg.slice(0, 500),
+        stack: event.error?.stack || null,
+        file: null,
+        line: null,
+        timestamp: Date.now(),
+      });
+    }
+  });
+
+  // ── gateway_start: lifecycle tracking ───────────────────────
+  reg("gateway_start", (event, ctx) => {
+    console.log("[CLAW] OpenClaw gateway started — wolverine watching");
+    reportToWolverine("claw_health", {
+      status: "running",
+      detail: "gateway_start",
+      timestamp: Date.now(),
+    });
+  });
+
+  // ── gateway_stop: lifecycle tracking ────────────────────────
+  reg("gateway_stop", (event, ctx) => {
+    console.log("[CLAW] OpenClaw gateway stopping");
+    reportToWolverine("claw_health", {
+      status: "stopping",
+      detail: "gateway_stop",
+      errorCounts: { ..._errorCounts },
+      timestamp: Date.now(),
+    });
+  });
+
+  // ── session_end: track session errors ───────────────────────
+  reg("session_end", (event, ctx) => {
+    if (event?.error) {
+      console.warn(`[CLAW] Session error: ${event.error?.message || event.error}`);
+    }
+  });
+}
+
+// ── EventEmitter fallback hooks ─────────────────────────────────
+
+/**
+ * Register basic EventEmitter hooks (works with all versions).
+ */
+function _registerEventHooks(gateway, projectRoot) {
+  if (!gateway.on) return;
+
+  gateway.on("error", (err) => {
+    const msg = err?.message || String(err);
+    _trackError("agent", `Gateway error: ${msg}`);
+    console.error(`[CLAW] Gateway error: ${msg}`);
+
+    reportToWolverine("route_error", {
+      path: "claw://gateway",
+      method: "INTERNAL",
+      statusCode: 500,
+      message: msg.slice(0, 500),
+      stack: err?.stack || null,
+      file: null,
+      line: null,
+      timestamp: Date.now(),
+    });
+  });
+
+  // These may or may not exist depending on OpenClaw version
+  const optionalEvents = ["agent:error", "skill:error", "channel:error", "channel:disconnect"];
+  for (const evt of optionalEvents) {
+    try {
+      gateway.on(evt, (err) => {
+        const msg = err?.message || String(err);
+        const category = evt.split(":")[0];
+        _trackError(category === "skill" ? "tool" : "agent", `${evt}: ${msg}`);
+        console.error(`[CLAW] ${evt}: ${msg.slice(0, 100)}`);
+      });
+    } catch {}
+  }
+}
+
+// ── Tool registration ───────────────────────────────────────────
+
+function _registerTools(gateway, tools) {
+  if (gateway.registerTools) {
+    gateway.registerTools(PLUGIN_NAME, tools);
+  } else if (gateway.addTools) {
+    gateway.addTools(tools);
+  } else if (gateway.skills?.register) {
+    gateway.skills.register(PLUGIN_NAME, {
+      description: "Wolverine self-healing integration — backup, brain, health, and error pipeline",
+      tools,
+    });
+  }
+}
+
+// ── Wolverine tools for the agent ───────────────────────────────
+
 function buildWolverineTools(projectRoot, config) {
   return [
     {
@@ -163,7 +467,7 @@ function buildWolverineTools(projectRoot, config) {
     },
     {
       name: "wolverine_health",
-      description: "Get wolverine system health status (process, memory, backups, heal history)",
+      description: "Get wolverine system health status including error tracking from all OpenClaw subsystems",
       parameters: { type: "object", properties: {} },
       execute: async () => {
         const status = {
@@ -171,6 +475,8 @@ function buildWolverineTools(projectRoot, config) {
           memory: `${Math.round(process.memoryUsage().heapUsed / 1024 / 1024)}MB`,
           pid: process.pid,
           nodeVersion: process.version,
+          errors: { ..._errorCounts },
+          recentErrors: _recentErrors.slice(-5).map(e => `[${e.category}] ${e.summary}`),
         };
 
         try {
@@ -211,7 +517,6 @@ function buildWolverineTools(projectRoot, config) {
         required: ["error"],
       },
       execute: async ({ error, file }) => {
-        // Report to parent wolverine process for healing
         reportToWolverine("route_error", {
           path: "claw://agent",
           method: "INTERNAL",
@@ -225,50 +530,20 @@ function buildWolverineTools(projectRoot, config) {
         return "Error reported to wolverine healing pipeline.";
       },
     },
+    {
+      name: "wolverine_error_stats",
+      description: "Get error statistics from all OpenClaw subsystems (tools, agent, channels, LLM, subagents)",
+      parameters: { type: "object", properties: {} },
+      execute: async () => {
+        return JSON.stringify({
+          counts: { ..._errorCounts },
+          recent: _recentErrors.slice(-10),
+        }, null, 2);
+      },
+    },
   ];
 }
 
-/**
- * Handle gateway errors — report to wolverine for healing.
- */
-function handleGatewayError(err, projectRoot) {
-  console.error(`[CLAW] Gateway error: ${err.message}`);
-  reportToWolverine("route_error", {
-    path: "claw://gateway",
-    method: "INTERNAL",
-    statusCode: 500,
-    message: err.message,
-    stack: err.stack,
-    file: null,
-    line: null,
-    timestamp: Date.now(),
-  });
-}
-
-/**
- * Handle agent errors.
- */
-function handleAgentError(err, projectRoot) {
-  console.error(`[CLAW] Agent error: ${err.message}`);
-  reportToWolverine("route_error", {
-    path: "claw://agent",
-    method: "INTERNAL",
-    statusCode: 500,
-    message: err.message,
-    stack: err.stack,
-    file: null,
-    line: null,
-    timestamp: Date.now(),
-  });
-}
-
-/**
- * Handle skill errors.
- */
-function handleSkillError(err, projectRoot) {
-  console.warn(`[CLAW] Skill error (non-fatal): ${err.message}`);
-}
-
 /**
  * Report to wolverine parent process via IPC.
  */