wolverine-ai 3.6.0 → 3.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wolverine-ai",
-  "version": "3.6.0",
+  "version": "3.6.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/server/lib/gpu-fleet.js

@@ -0,0 +1,313 @@
+const https = require("https");
+const http = require("http");
+
+/**
+ * GPU Fleet Manager — controls Vast.ai GPU instances for inference.
+ *
+ * Features:
+ * - Start/stop individual GPUs via Vast API
+ * - Health monitoring and auto-discovery
+ * - Round-robin routing across active GPUs
+ * - Auto-scale: start burst GPUs when queue grows, stop when idle
+ * - Cold start tracking (~5s per GPU)
+ *
+ * Each GPU instance runs llama.cpp with --api-key for security.
+ * Only the EC2 backend has the internal keys.
+ */
+
+const VAST_API = "https://cloud.vast.ai/api/v0";
+const VAST_KEY = process.env.VAST_API_KEY || "";
+const POLL_INTERVAL_MS = 30000; // health check every 30s
+const IDLE_STOP_MS = parseInt(process.env.GPU_IDLE_STOP_MS, 10) || 300000; // 5 min idle → stop
+const SCALE_UP_QUEUE = parseInt(process.env.GPU_SCALE_UP_QUEUE, 10) || 3; // start burst GPU when 3+ queued
+
+class GpuFleet {
+  constructor(config = {}) {
+    // GPU registry: { instanceId → { host, port, key, status, lastUsed, lastHealth, model } }
+    this.gpus = new Map();
+    this._roundRobinIndex = 0;
+    this._pollTimer = null;
+    this._scaleTimer = null;
+    this._requestQueue = [];
+    this._activeRequests = 0;
+  }
+
+  /**
+   * Register a GPU instance in the fleet.
+   */
+  register(instanceId, { host, port, key, model = "wolverine-test-1", role = "general", autoStop = true }) {
+    this.gpus.set(String(instanceId), {
+      instanceId: String(instanceId),
+      host, port: parseInt(port, 10), key,
+      model, role, autoStop,
+      status: "unknown", // unknown, starting, healthy, unhealthy, stopped
+      lastUsed: 0,
+      lastHealth: null,
+      coldStartMs: null,
+    });
+    return this;
+  }
+
+  /**
+   * Load GPU config from environment or database.
+   */
+  loadFromEnv() {
+    // Primary GPU from env
+    const url = process.env.WOLVERINE_INFERENCE_URL;
+    const key = process.env.WOLVERINE_GPU_KEY;
+    if (url && key) {
+      try {
+        const parsed = new URL(url);
+        const instanceId = process.env.WOLVERINE_GPU_INSTANCE_ID || "primary";
+        this.register(instanceId, {
+          host: parsed.hostname,
+          port: parseInt(parsed.port, 10) || 80,
+          key,
+          role: "primary",
+          autoStop: false, // primary stays on
+        });
+      } catch {}
+    }
+    return this;
+  }
+
+  /**
+   * Load GPU config from database.
+   */
+  async loadFromDb(pool) {
+    try {
+      // Check if gpu_fleet table exists
+      const exists = await pool.query(
+        "SELECT 1 FROM information_schema.tables WHERE table_name = 'gpu_fleet' LIMIT 1"
+      );
+      if (exists.rows.length === 0) {
+        await pool.query(`
+          CREATE TABLE gpu_fleet (
+            instance_id TEXT PRIMARY KEY,
+            vast_id TEXT,
+            host TEXT NOT NULL,
+            port INTEGER NOT NULL DEFAULT 8080,
+            internal_key TEXT NOT NULL,
+            model TEXT DEFAULT 'wolverine-test-1',
+            role TEXT DEFAULT 'general',
+            auto_stop BOOLEAN DEFAULT true,
+            status TEXT DEFAULT 'stopped',
+            gpu_name TEXT,
+            created_at TIMESTAMPTZ DEFAULT NOW()
+          )
+        `);
+      }
+      const { rows } = await pool.query("SELECT * FROM gpu_fleet");
+      for (const r of rows) {
+        this.register(r.instance_id, {
+          host: r.host, port: r.port, key: r.internal_key,
+          model: r.model, role: r.role, autoStop: r.auto_stop,
+        });
+        const gpu = this.gpus.get(r.instance_id);
+        if (gpu) gpu.status = r.status;
+        if (gpu) gpu.vastId = r.vast_id;
+        if (gpu) gpu.gpuName = r.gpu_name;
+      }
+    } catch (err) {
+      console.log("[GPU Fleet] DB load failed:", err.message);
+    }
+    return this;
+  }
+
+  /**
+   * Start health polling.
+   */
+  startPolling() {
+    if (this._pollTimer) return;
+    this._pollTimer = setInterval(() => this._healthCheck(), POLL_INTERVAL_MS);
+    this._healthCheck(); // immediate first check
+    return this;
+  }
+
+  stopPolling() {
+    if (this._pollTimer) { clearInterval(this._pollTimer); this._pollTimer = null; }
+  }
+
+  /**
+   * Get a healthy GPU for inference (round-robin).
+   * Returns { host, port, key, instanceId } or null if none available.
+   */
+  getAvailable() {
+    const healthy = Array.from(this.gpus.values()).filter(g => g.status === "healthy");
+    if (healthy.length === 0) return null;
+    this._roundRobinIndex = (this._roundRobinIndex + 1) % healthy.length;
+    const gpu = healthy[this._roundRobinIndex];
+    gpu.lastUsed = Date.now();
+    return { host: gpu.host, port: gpu.port, key: gpu.key, instanceId: gpu.instanceId, model: gpu.model };
+  }
+
+  /**
+   * Start a stopped GPU instance via Vast API.
+   */
+  async startGpu(instanceId) {
+    const gpu = this.gpus.get(String(instanceId));
+    if (!gpu) throw new Error(`GPU ${instanceId} not registered`);
+    if (gpu.status === "healthy" || gpu.status === "starting") return gpu;
+
+    gpu.status = "starting";
+    gpu.coldStartMs = null;
+    const startTime = Date.now();
+
+    const vastId = gpu.vastId || instanceId;
+    try {
+      await this._vastApi("PUT", `/instances/${vastId}/`, { state: "running" });
+
+      // Poll until healthy (max 60s)
+      for (let i = 0; i < 120; i++) {
+        await new Promise(r => setTimeout(r, 500));
+        try {
+          const res = await this._httpGet(gpu.host, gpu.port, "/v1/models", gpu.key);
+          if (res && res.includes("gemma")) {
+            gpu.status = "healthy";
+            gpu.coldStartMs = Date.now() - startTime;
+            gpu.lastHealth = Date.now();
+            console.log(`[GPU Fleet] ${instanceId} started in ${gpu.coldStartMs}ms`);
+            return gpu;
+          }
+        } catch {}
+      }
+      gpu.status = "unhealthy";
+      throw new Error(`GPU ${instanceId} failed to start within 60s`);
+    } catch (err) {
+      gpu.status = "unhealthy";
+      throw err;
+    }
+  }
+
+  /**
+   * Stop a GPU instance via Vast API.
+   */
+  async stopGpu(instanceId) {
+    const gpu = this.gpus.get(String(instanceId));
+    if (!gpu) throw new Error(`GPU ${instanceId} not registered`);
+
+    const vastId = gpu.vastId || instanceId;
+    try {
+      await this._vastApi("PUT", `/instances/${vastId}/`, { state: "stopped" });
+      gpu.status = "stopped";
+      console.log(`[GPU Fleet] ${instanceId} stopped`);
+    } catch (err) {
+      console.log(`[GPU Fleet] Stop failed for ${instanceId}:`, err.message);
+    }
+    return gpu;
+  }
+
+  /**
+   * Auto-scale: start burst GPUs when needed, stop idle ones.
+   */
+  async autoScale(queueLength) {
+    // Scale up: start a stopped GPU if queue is long
+    if (queueLength >= SCALE_UP_QUEUE) {
+      const stopped = Array.from(this.gpus.values()).find(g => g.status === "stopped" && g.autoStop);
+      if (stopped) {
+        console.log(`[GPU Fleet] Queue at ${queueLength}, starting burst GPU ${stopped.instanceId}`);
+        try { await this.startGpu(stopped.instanceId); } catch (e) { console.log("[GPU Fleet] Scale-up failed:", e.message); }
+      }
+    }
+
+    // Scale down: stop idle burst GPUs
+    const now = Date.now();
+    for (const gpu of this.gpus.values()) {
+      if (gpu.autoStop && gpu.status === "healthy" && gpu.lastUsed > 0 && (now - gpu.lastUsed) > IDLE_STOP_MS) {
+        console.log(`[GPU Fleet] ${gpu.instanceId} idle for ${Math.round((now - gpu.lastUsed) / 1000)}s, stopping`);
+        try { await this.stopGpu(gpu.instanceId); } catch {}
+      }
+    }
+  }
+
+  /**
+   * Get fleet status for dashboard/API.
+   */
+  getStatus() {
+    const gpus = Array.from(this.gpus.values()).map(g => ({
+      instanceId: g.instanceId,
+      vastId: g.vastId,
+      gpuName: g.gpuName,
+      host: g.host,
+      port: g.port,
+      model: g.model,
+      role: g.role,
+      status: g.status,
+      autoStop: g.autoStop,
+      lastUsed: g.lastUsed ? new Date(g.lastUsed).toISOString() : null,
+      lastHealth: g.lastHealth ? new Date(g.lastHealth).toISOString() : null,
+      coldStartMs: g.coldStartMs,
+    }));
+    return {
+      total: gpus.length,
+      healthy: gpus.filter(g => g.status === "healthy").length,
+      stopped: gpus.filter(g => g.status === "stopped").length,
+      starting: gpus.filter(g => g.status === "starting").length,
+      gpus,
+    };
+  }
+
+  // ── Private ──
+
+  async _healthCheck() {
+    for (const gpu of this.gpus.values()) {
+      if (gpu.status === "stopped" || gpu.status === "starting") continue;
+      try {
+        const res = await this._httpGet(gpu.host, gpu.port, "/v1/models", gpu.key);
+        if (res && (res.includes("gemma") || res.includes("wolverine"))) {
+          gpu.status = "healthy";
+          gpu.lastHealth = Date.now();
+        } else {
+          gpu.status = "unhealthy";
+        }
+      } catch {
+        gpu.status = "unhealthy";
+      }
+    }
+  }
+
+  _vastApi(method, path, body) {
+    return new Promise((resolve, reject) => {
+      const bodyStr = body ? JSON.stringify(body) : null;
+      const req = https.request({
+        hostname: "cloud.vast.ai",
+        path: `/api/v0${path}`,
+        method,
+        timeout: 15000,
+        headers: {
+          "Authorization": `Bearer ${VAST_KEY}`,
+          "Content-Type": "application/json",
+          ...(bodyStr ? { "Content-Length": Buffer.byteLength(bodyStr) } : {}),
+        },
+      }, (res) => {
+        let data = "";
+        res.on("data", c => { data += c; });
+        res.on("end", () => {
+          try { resolve(JSON.parse(data)); } catch { resolve({ raw: data }); }
+        });
+      });
+      req.on("error", reject);
+      req.on("timeout", () => { req.destroy(); reject(new Error("Vast API timeout")); });
+      if (bodyStr) req.write(bodyStr);
+      req.end();
+    });
+  }
+
+  _httpGet(host, port, path, key) {
+    return new Promise((resolve, reject) => {
+      const req = http.request({
+        hostname: host, port, path, method: "GET", timeout: 5000,
+        headers: key ? { "Authorization": `Bearer ${key}` } : {},
+      }, (res) => {
+        let data = "";
+        res.on("data", c => { data += c; });
+        res.on("end", () => resolve(data));
+      });
+      req.on("error", reject);
+      req.on("timeout", () => { req.destroy(); reject(new Error("timeout")); });
+      req.end();
+    });
+  }
+}
+
+module.exports = { GpuFleet };

package/server/routes/fleet.js

@@ -0,0 +1,167 @@
+/**
+ * GPU Fleet Management API — admin routes for controlling inference GPUs.
+ *
+ * Endpoints:
+ *   GET  /status          — fleet overview (all GPUs, health, queue)
+ *   POST /start/:id       — start a stopped GPU
+ *   POST /stop/:id        — stop a running GPU
+ *   POST /register        — add a new GPU to the fleet
+ *   POST /remove/:id      — remove a GPU from the fleet
+ *   POST /scale           — trigger auto-scale check
+ *   GET  /benchmark/:id   — run inference benchmark on a GPU
+ */
+
+async function routes(fastify) {
+  const { pool } = require("../lib/db");
+
+  // Fleet instance is attached to fastify by index.js
+  function getFleet() {
+    return fastify.gpuFleet;
+  }
+
+  // Admin auth
+  async function requireAdmin(request, reply) {
+    const settings = require("../config/settings.json");
+    const token = request.headers.authorization?.replace("Bearer ", "") || request.headers["x-api-key"];
+    if (token !== settings.platform?.apiKey) {
+      return reply.code(401).send({ error: "Admin access required" });
+    }
+  }
+
+  // GET /status — fleet overview
+  fastify.get("/status", { preHandler: requireAdmin }, async (request, reply) => {
+    const fleet = getFleet();
+    return fleet.getStatus();
+  });
+
+  // POST /start/:id — start a GPU
+  fastify.post("/start/:id", { preHandler: requireAdmin }, async (request, reply) => {
+    const fleet = getFleet();
+    const { id } = request.params;
+    try {
+      const gpu = await fleet.startGpu(id);
+      // Update DB
+      await pool.query("UPDATE gpu_fleet SET status = 'healthy' WHERE instance_id = $1", [id]).catch(() => {});
+      return { status: "started", instanceId: id, coldStartMs: gpu.coldStartMs };
+    } catch (err) {
+      return reply.code(500).send({ error: err.message });
+    }
+  });
+
+  // POST /stop/:id — stop a GPU
+  fastify.post("/stop/:id", { preHandler: requireAdmin }, async (request, reply) => {
+    const fleet = getFleet();
+    const { id } = request.params;
+    try {
+      await fleet.stopGpu(id);
+      await pool.query("UPDATE gpu_fleet SET status = 'stopped' WHERE instance_id = $1", [id]).catch(() => {});
+      return { status: "stopped", instanceId: id };
+    } catch (err) {
+      return reply.code(500).send({ error: err.message });
+    }
+  });
+
+  // POST /register — add a GPU to the fleet
+  fastify.post("/register", { preHandler: requireAdmin }, async (request, reply) => {
+    const fleet = getFleet();
+    const { instanceId, vastId, host, port, key, model, role, gpuName, autoStop } = request.body || {};
+    if (!instanceId || !host || !key) {
+      return reply.code(400).send({ error: "instanceId, host, and key required" });
+    }
+
+    fleet.register(instanceId, { host, port: port || 8080, key, model, role, autoStop: autoStop !== false });
+    const gpu = fleet.gpus.get(instanceId);
+    if (vastId) gpu.vastId = vastId;
+    if (gpuName) gpu.gpuName = gpuName;
+
+    // Save to DB
+    await pool.query(
+      `INSERT INTO gpu_fleet (instance_id, vast_id, host, port, internal_key, model, role, auto_stop, gpu_name)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+       ON CONFLICT (instance_id) DO UPDATE SET
+         host = $3, port = $4, internal_key = $5, model = $6, role = $7, auto_stop = $8, gpu_name = $9, vast_id = $2`,
+      [instanceId, vastId || null, host, port || 8080, key, model || "wolverine-test-1", role || "general", autoStop !== false, gpuName || null]
+    );
+
+    return { registered: instanceId, fleet: fleet.getStatus() };
+  });
+
+  // POST /remove/:id — remove a GPU from the fleet
+  fastify.post("/remove/:id", { preHandler: requireAdmin }, async (request, reply) => {
+    const fleet = getFleet();
+    const { id } = request.params;
+    fleet.gpus.delete(id);
+    await pool.query("DELETE FROM gpu_fleet WHERE instance_id = $1", [id]).catch(() => {});
+    return { removed: id };
+  });
+
+  // POST /scale — trigger auto-scale
+  fastify.post("/scale", { preHandler: requireAdmin }, async (request, reply) => {
+    const fleet = getFleet();
+    const queueLength = request.body?.queueLength || 0;
+    await fleet.autoScale(queueLength);
+    return fleet.getStatus();
+  });
+
+  // GET /benchmark/:id — quick benchmark
+  fastify.get("/benchmark/:id", { preHandler: requireAdmin }, async (request, reply) => {
+    const fleet = getFleet();
+    const gpu = fleet.gpus.get(request.params.id);
+    if (!gpu || gpu.status !== "healthy") {
+      return reply.code(400).send({ error: "GPU not available" });
+    }
+
+    const http = require("http");
+    const results = [];
+
+    for (const prompt of ["2+2?", "Write isPrime in JS.", "Explain TCP in 1 sentence."]) {
+      const start = Date.now();
+      try {
+        const body = JSON.stringify({
+          model: gpu.model,
+          messages: [{ role: "user", content: prompt }],
+          max_tokens: 50, temperature: 0,
+        });
+        const res = await new Promise((resolve, reject) => {
+          const req = http.request({
+            hostname: gpu.host, port: gpu.port, path: "/v1/chat/completions",
+            method: "POST", timeout: 30000,
+            headers: { "Content-Type": "application/json", "Authorization": `Bearer ${gpu.key}`, "Content-Length": Buffer.byteLength(body) },
+          }, (res) => {
+            let data = "";
+            res.on("data", c => { data += c; });
+            res.on("end", () => { try { resolve(JSON.parse(data)); } catch { resolve(null); } });
+          });
+          req.on("error", reject);
+          req.write(body);
+          req.end();
+        });
+
+        const elapsed = Date.now() - start;
+        const usage = res?.usage || {};
+        const tokOut = usage.completion_tokens || 0;
+        results.push({
+          prompt: prompt.slice(0, 30),
+          latencyMs: elapsed,
+          tokensOut: tokOut,
+          tokPerSec: tokOut > 0 ? Math.round(tokOut / (elapsed / 1000)) : 0,
+          response: res?.choices?.[0]?.message?.content?.slice(0, 60),
+        });
+      } catch (err) {
+        results.push({ prompt: prompt.slice(0, 30), error: err.message });
+      }
+    }
+
+    const avgTokPerSec = results.filter(r => r.tokPerSec).reduce((s, r) => s + r.tokPerSec, 0) / Math.max(results.filter(r => r.tokPerSec).length, 1);
+
+    return {
+      instanceId: request.params.id,
+      gpu: gpu.gpuName,
+      model: gpu.model,
+      results,
+      avgTokPerSec: Math.round(avgTokPerSec),
+    };
+  });
+}
+
+module.exports = routes;

package/server/routes/inference.js

@@ -14,7 +14,8 @@ const crypto = require("crypto");
  * Queue: when GPU is at capacity, requests queue with timeout.
  */
 
-const INFERENCE_URL = process.env.WOLVERINE_INFERENCE_URL || "https://clips-third-players-binding.trycloudflare.com";
+const INFERENCE_URL = process.env.WOLVERINE_INFERENCE_URL || "http://ssh8.vast.ai:24233";
+const GPU_KEY = process.env.WOLVERINE_GPU_KEY || "";
 
 // Pricing in CREDITS per million tokens ($1 = 100 credits)
 const MODEL_PRICING = {
@@ -308,7 +309,11 @@ function proxyToInference(path, body, method = "POST") {
       path: url.pathname,
       method,
       timeout: 120000,
-      headers: { "Content-Type": "application/json", ...(bodyStr ? { "Content-Length": Buffer.byteLength(bodyStr) } : {}) },
+      headers: {
+        "Content-Type": "application/json",
+        ...(GPU_KEY ? { "Authorization": `Bearer ${GPU_KEY}` } : {}),
+        ...(bodyStr ? { "Content-Length": Buffer.byteLength(bodyStr) } : {}),
+      },
     }, (res) => {
       let data = "";
       res.on("data", (c) => { data += c; });

package/src/agent/agent-engine.js

@@ -250,7 +250,7 @@ const TOOL_DEFINITIONS = [
     type: "function",
     function: {
       name: "run_db_fix",
-      description: "Run a write query on a SQLite database to fix data issues: UPDATE invalid entries, DELETE corrupt rows, ALTER schema. Creates a backup first.",
+      description: "Run a write query on a SQLite database to fix data issues. IMPORTANT: Always use inspect_db FIRST to see the current state before writing. This tool auto-snapshots affected rows before and after the write. Creates a backup. Returns before/after state so you can verify the fix is correct.",
       parameters: {
         type: "object",
         properties: {
@@ -953,15 +953,60 @@ class AgentEngine {
       if (upper.startsWith("DROP DATABASE") || upper.includes("DROP TABLE sqlite_")) {
         return { content: "BLOCKED: Cannot drop system tables" };
       }
+
       // Backup the DB file first
       const backupPath = dbPath + ".wolverine-backup";
       fs.copyFileSync(dbPath, backupPath);
+
       const db = new Database(dbPath);
+
+      // SAFETY: Snapshot affected rows BEFORE the write
+      // Extract table name and WHERE clause to SELECT the rows that will change
+      let beforeSnapshot = "";
+      try {
+        const tableMatch = upper.match(/(?:UPDATE|DELETE\s+FROM|INSERT\s+INTO)\s+(\w+)/i);
+        const whereMatch = args.sql.match(/WHERE\s+(.+?)(?:;|$)/i);
+        if (tableMatch) {
+          const table = tableMatch[1];
+          const whereClause = whereMatch ? `WHERE ${whereMatch[1]}` : "";
+          const selectSql = `SELECT * FROM ${table} ${whereClause} LIMIT 20`;
+          try {
+            const before = db.prepare(selectSql).all();
+            if (before.length > 0) {
+              beforeSnapshot = `\n\nBEFORE STATE (${before.length} rows affected):\n${JSON.stringify(before, null, 2).slice(0, 2000)}`;
+              console.log(chalk.gray(`    🗃️ Snapshot: ${before.length} rows from ${table} ${whereClause ? whereClause.slice(0, 40) : "(all)"}`));
+            }
+          } catch { /* SELECT failed, might be INSERT into new table — that's fine */ }
+        }
+      } catch { /* snapshot failed, proceed with caution */ }
+
+      // Execute the fix
       const result = db.prepare(args.sql).run();
+
+      // SAFETY: Snapshot AFTER to show what changed
+      let afterSnapshot = "";
+      try {
+        const tableMatch = upper.match(/(?:UPDATE|DELETE\s+FROM|INSERT\s+INTO)\s+(\w+)/i);
+        const whereMatch = args.sql.match(/WHERE\s+(.+?)(?:;|$)/i);
+        if (tableMatch) {
+          const table = tableMatch[1];
+          const whereClause = whereMatch ? `WHERE ${whereMatch[1]}` : "";
+          const selectSql = `SELECT * FROM ${table} ${whereClause} LIMIT 20`;
+          try {
+            const after = db.prepare(selectSql).all();
+            afterSnapshot = `\n\nAFTER STATE (${after.length} rows):\n${JSON.stringify(after, null, 2).slice(0, 2000)}`;
+          } catch {}
+        }
+      } catch {}
+
       db.close();
       this.filesModified.push(args.db_path);
+
+      const summary = `SQL executed. Changes: ${result.changes}. Backup at: ${backupPath}${beforeSnapshot}${afterSnapshot}`;
       console.log(chalk.green(`    🗃️ DB fix applied: ${args.sql.slice(0, 60)} (changes: ${result.changes})`));
-      return { content: `SQL executed. Changes: ${result.changes}. Backup at: ${backupPath}` };
+      if (beforeSnapshot) console.log(chalk.gray(`    🗃️ Before/after snapshot captured for audit`));
+
+      return { content: summary };
     } catch (e) { return { content: `DB error: ${e.message}` }; }
   }
 
@@ -1094,14 +1139,23 @@ FAST FIXES (act immediately, don't investigate):
 - Missing env var → check_env → report it → done
 
 INVESTIGATION (only when cause is unclear):
-- Database error → inspect_db then run_db_fix
+- Database error → inspect_db FIRST to see current state → understand what went wrong → run_db_fix with targeted fix
 - Unknown errors → grep_code, list_dir to find root cause
 
+DATABASE SAFETY:
+- ALWAYS inspect_db before run_db_fix — never write blind
+- run_db_fix auto-snapshots affected rows before/after — check the response to verify your fix
+- For bad data: understand WHY the data is wrong before changing it
+- For NaN/null errors: check if the data was corrupted or if the code should handle it
+- Prefer fixing code to handle edge cases over modifying production data
+- A database backup is created automatically before every write
+
 RULES:
 1. Fix on turn 1-2 when possible. Investigation is a last resort.
 2. For ENOENT config files: read the code that requires the file, then create it with the expected structure.
 3. bash_exec for operational fixes, edit_file for code, write_file for missing files, run_db_fix for data
-4. Always call done with summary when finished — never end without calling done.
+4. For database errors: inspect first, fix data only when code can't reasonably handle the edge case
+5. Always call done with summary when finished — never end without calling done.
 ${primaryFile ? `\nFile: ${primaryFile}` : ""}
 Project: ${cwd}`;
 }

package/src/brain/brain.js

@@ -218,7 +218,7 @@ const SEED_DOCS = [
     metadata: { topic: "error-monitor" },
   },
   {
-    text: "Agent tool details: read_file supports offset/limit for large files. edit_file does surgical find-and-replace (preferred for small fixes). glob_files discovers files by pattern (**/*.js). grep_code does regex search with context lines. list_dir shows directory contents with file sizes. move_file relocates/renames files. bash_exec runs shell commands (30s default timeout, 60s hard cap, dangerous commands blocked: rm -rf /, git push --force, npm publish). inspect_db reads SQLite: action=tables (list), action=schema (CREATE statements), action=query (SELECT/PRAGMA only). run_db_fix writes SQLite: UPDATE/DELETE/INSERT/ALTER, auto-backs up db file first. check_port finds what process is using a port (netstat/lsof). check_env lists environment variables with values redacted. audit_deps runs full npm health check (vulnerabilities, outdated, peer deps, unused, lock file). check_migration returns known upgrade paths with before/after code patterns. web_fetch retrieves URL content.",
+    text: "Agent tool details: read_file supports offset/limit for large files. edit_file does surgical find-and-replace (preferred for small fixes). glob_files discovers files by pattern (**/*.js). grep_code does regex search with context lines. list_dir shows directory contents with file sizes. move_file relocates/renames files. bash_exec runs shell commands (30s default timeout, 60s hard cap, dangerous commands blocked: rm -rf /, git push --force, npm publish). inspect_db reads SQLite: action=tables (list), action=schema (CREATE statements), action=query (SELECT/PRAGMA only). run_db_fix writes SQLite with SAFETY: auto-snapshots affected rows BEFORE write (SELECT WHERE matching the UPDATE/DELETE), executes the fix, snapshots AFTER, returns before/after comparison so agent can verify. Always backs up the DB file. Agent MUST inspect_db before run_db_fix — never write blind. For NaN/null data errors: prefer fixing code to handle edge cases over modifying production data. check_port finds what process is using a port (netstat/lsof). check_env lists environment variables with values redacted. audit_deps runs full npm health check. check_migration returns known upgrade paths. web_fetch retrieves URL content.",
     metadata: { topic: "agent-tools-detail" },
   },
   {

package/src/core/ai-client.js

@@ -42,12 +42,13 @@ function getClient(provider) {
 
 function _getWolverineClient() {
   if (!_wolverineClient) {
-    // Wolverine inference: direct to GPU (WOLVERINE_INFERENCE_URL) or via proxy (api.wolverinenode.xyz/v1)
-    // Direct URL = no auth needed (Vast tunnel). Proxy URL = needs WOLVERINE_API_KEY for billing.
+    // Wolverine inference: direct to GPU or via proxy
+    // WOLVERINE_GPU_KEY = internal key for direct GPU access (llama.cpp --api-key)
+    // WOLVERINE_API_KEY = user key for billed proxy access (api.wolverinenode.xyz)
     const baseURL = process.env.WOLVERINE_INFERENCE_URL
       ? process.env.WOLVERINE_INFERENCE_URL + "/v1"
       : "https://api.wolverinenode.xyz/v1";
-    const apiKey = process.env.WOLVERINE_API_KEY || "none";
+    const apiKey = process.env.WOLVERINE_GPU_KEY || process.env.WOLVERINE_API_KEY || "none";
     _wolverineClient = new OpenAI({ apiKey, baseURL });
   }
   return _wolverineClient;

package/src/core/error-parser.js

@@ -97,11 +97,11 @@ function classifyError(errorMessage, fullStderr) {
   const full = (fullStderr || "").toLowerCase();
 
   // Missing npm package: Cannot find module 'cors' (not a relative path)
-  if (/cannot find module '(?![./\\])/.test(msg) || /module_not_found/.test(full)) {
+  if (/cannot find module ['"](?![./\\])/.test(msg) || /module_not_found/.test(full)) {
     return "missing_module";
   }
   // Missing local file: Cannot find module './routes/api'
-  if (/cannot find module '[./\\]/.test(msg) || /enoent/.test(msg)) {
+  if (/cannot find module ['"][./\\]/.test(msg) || /enoent/.test(msg)) {
     return "missing_file";
   }
   // Permission denied

package/src/core/runner.js

@@ -590,11 +590,37 @@ class WolverineRunner {
     this._healStatus = { active: true, route: routePath, error: errorDetails?.message?.slice(0, 200), phase: "diagnosing", startedAt: Date.now() };
     this.logger.info("heal.error_monitor", `Healing caught 500 on ${routePath}`, { route: routePath });
 
-    // Build a synthetic stderr from the error details
+    // Build synthetic stderr that matches the error parser's expected format
+    // If IPC didn't include a file, try to resolve from the route path or stack
+    let file = errorDetails.file;
+    let line = errorDetails.line || 1;
+    if (!file && errorDetails.stack) {
+      // Try to find user-land file in stack (not node_modules, not node:)
+      const frames = (errorDetails.stack || "").split("\n");
+      for (const frame of frames) {
+        const m = frame.match(/\(([^)]+):(\d+):(\d+)\)/) || frame.match(/at\s+([^\s(]+):(\d+):(\d+)/);
+        if (m && !m[1].includes("node_modules") && !m[1].includes("node:")) {
+          file = m[1]; line = parseInt(m[2], 10); break;
+        }
+      }
+    }
+    if (!file && routePath) {
+      // Last resort: map route path to likely file (e.g., /breakable → server/routes/breakable.js)
+      const routeName = routePath.split("/").filter(Boolean).pop();
+      if (routeName) {
+        const path = require("path");
+        const guess = path.join(this.cwd, "server", "routes", routeName + ".js");
+        if (require("fs").existsSync(guess)) { file = guess; line = 1; }
+      }
+    }
+
+    const msg = errorDetails.message || "Unknown error";
+    const hasErrorPrefix = /^\w*Error:/.test(msg);
     const stderr = [
-      errorDetails.message || "Unknown error",
+      file ? `${file}:${line}` : "",
+      hasErrorPrefix ? msg : `Error: ${msg}`,
       errorDetails.stack || "",
-      errorDetails.file ? `    at ${errorDetails.file}:${errorDetails.line || 0}` : "",
+      file ? `    at ${file}:${line}:1` : "",
     ].filter(Boolean).join("\n");
 
     try {