wolverine-ai 4.0.5 → 4.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wolverine-ai",
-  "version": "4.0.5",
+  "version": "4.2.0",
   "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/core/error-hook.js

@@ -34,7 +34,15 @@ Module._load = function (request, parent, isMain) {
       _hookFastify(instance);
       return instance;
     };
-    Object.keys(originalFastify).forEach((key) => { wrapped[key] = originalFastify[key]; });
+    // #23: Copy all own properties (including non-enumerable and symbols) to preserve prototype chain
+    for (const key of Object.getOwnPropertyNames(originalFastify)) {
+      if (key !== "length" && key !== "name" && key !== "prototype") {
+        try { wrapped[key] = originalFastify[key]; } catch {}
+      }
+    }
+    for (const sym of Object.getOwnPropertySymbols(originalFastify)) {
+      try { wrapped[sym] = originalFastify[sym]; } catch {}
+    }
     wrapped.default = wrapped; // ESM compat
     return wrapped;
   }
@@ -48,7 +56,15 @@ Module._load = function (request, parent, isMain) {
       _hookExpress(app);
       return app;
     };
-    Object.keys(originalExpress).forEach((key) => { wrapped[key] = originalExpress[key]; });
+    // #23: Copy all own properties (including non-enumerable and symbols)
+    for (const key of Object.getOwnPropertyNames(originalExpress)) {
+      if (key !== "length" && key !== "name" && key !== "prototype") {
+        try { wrapped[key] = originalExpress[key]; } catch {}
+      }
+    }
+    for (const sym of Object.getOwnPropertySymbols(originalExpress)) {
+      try { wrapped[sym] = originalExpress[sym]; } catch {}
+    }
     return wrapped;
   }
 
@@ -94,9 +110,13 @@ function _hookExpress(app) {
   // Wrap app.listen to inject error middleware AFTER all user middleware
   const originalListen = app.listen;
   app.listen = function (...args) {
-    app.use(function _wolverineErrorHook(err, req, res, next) {
-      _reportError(req.originalUrl || req.url, req.method, err);
-      next(err);
+    // #24: Use process.nextTick to ensure our error middleware is added AFTER
+    // any middleware registered synchronously after listen() is called
+    process.nextTick(() => {
+      app.use(function _wolverineErrorHook(err, req, res, next) {
+        _reportError(req.originalUrl || req.url, req.method, err);
+        next(err);
+      });
     });
     return originalListen.apply(this, args);
   };
@@ -114,7 +134,8 @@ function _reportError(url, method, error) {
     let file = null, line = null;
     if (error.stack) {
       for (const frame of error.stack.split("\n")) {
-        const m = frame.match(/\(([^)]+):(\d+):(\d+)\)/) || frame.match(/at\s+([^\s(]+):(\d+):(\d+)/);
+        // #25: Second regex uses (.+) instead of ([^\s(]+) to handle Windows paths with spaces
+        const m = frame.match(/\(([^)]+):(\d+):(\d+)\)/) || frame.match(/at\s+(.+):(\d+):(\d+)/);
         if (m && !m[1].includes("node_modules") && !m[1].includes("node:")) {
           file = m[1]; line = parseInt(m[2], 10); break;
         }

package/src/core/runner.js

@@ -284,7 +284,9 @@ class WolverineRunner {
     this._clearStabilityTimer();
     // Clear any pending heals — restart is a clean slate
     this._pendingErrorHeal = null;
-    this._healInProgress = false;
+    // #1: Don't clear _healInProgress here — only the heal function itself should clear it
+    // #6: Clear stale heal status so dashboard doesn't show phantom heals
+    this._healStatus = null;
 
     if (this.child) {
       const oldChild = this.child;
@@ -295,11 +297,9 @@ class WolverineRunner {
       const onExit = () => {
         if (spawned) return; // Prevent double-spawn from exit + force-kill timeout
         spawned = true;
+        // #7: Don't call _ensurePortFree() here — _spawn() already calls it
         // Give port time to fully release (TIME_WAIT)
-        setTimeout(() => {
-          this._ensurePortFree();
-          setTimeout(() => this._spawn(), 500);
-        }, 500);
+        setTimeout(() => this._spawn(), 500);
       };
 
       oldChild.removeAllListeners("exit");
@@ -314,7 +314,7 @@ class WolverineRunner {
         }
       }, 3000);
     } else {
-      this._ensurePortFree();
+      // #7: Don't call _ensurePortFree() here — _spawn() already calls it
       setTimeout(() => this._spawn(), 500);
     }
   }
@@ -394,7 +394,12 @@ class WolverineRunner {
       process.stderr.write(text);
     });
 
-    this._startStabilityTimer();
+    // #27: Only start stability timer if there's a backup to promote — don't clear
+    // an existing timer on every spawn (e.g., auto-update restart shouldn't reset
+    // the stability countdown for a previously healed backup)
+    if (this._lastBackupId) {
+      this._startStabilityTimer();
+    }
 
     // Start process monitor (memory, CPU, heartbeat)
     if (this.child && this.child.pid) {
@@ -418,32 +423,46 @@ class WolverineRunner {
     this.healthMonitor.stop();
     this.healthMonitor.reset();
     this.healthMonitor.start(async (reason) => {
-      if (this._healInProgress || !this.running) return;
-      console.log(chalk.red(`\n🚨 Health check triggered heal (reason: ${reason})`));
-      this.logger.error(EVENT_TYPES.HEALTH_UNRESPONSIVE, `Server unresponsive: ${reason}`, { reason });
-      this.healthMonitor.stop();
-
-      // Kill the hung process — remove exit listener to prevent double-heal
-      if (this.child) {
-        const pid = this.child.pid;
-        this.child.removeAllListeners("exit");
-        this._killProcessTree(pid, "SIGKILL");
-        this.child = null;
-      }
+      try {
+        if (this._healInProgress || !this.running) return;
+        // #26: Claim the heal lock immediately — prevents exit event from starting
+        // a concurrent heal between our check and the child kill below
+        this._healInProgress = true;
+        console.log(chalk.red(`\n🚨 Health check triggered heal (reason: ${reason})`));
+        this.logger.error(EVENT_TYPES.HEALTH_UNRESPONSIVE, `Server unresponsive: ${reason}`, { reason });
+        this.healthMonitor.stop();
+
+        // Kill the hung process — remove exit listener to prevent double-heal
+        if (this.child) {
+          const pid = this.child.pid;
+          this.child.removeAllListeners("exit");
+          this._killProcessTree(pid, "SIGKILL");
+          this.child = null;
+        }
 
-      // Synthesize error context for the heal pipeline
-      this._stderrBuffer = `Server became unresponsive. Health check failed: ${reason}\n` +
-        `The server was running but stopped responding to HTTP requests.\n` +
-        `Possible causes: infinite loop, deadlock, memory exhaustion, blocked event loop.`;
+        // Synthesize error context for the heal pipeline
+        this._stderrBuffer = `Server became unresponsive. Health check failed: ${reason}\n` +
+          `The server was running but stopped responding to HTTP requests.\n` +
+          `Possible causes: infinite loop, deadlock, memory exhaustion, blocked event loop.`;
 
-      this.retryCount++;
-      if (this.retryCount > this.maxRetries) {
-        console.log(chalk.red(`\n🛑 Max retries reached.`));
-        this._logRollbackHint();
-        this.running = false;
-        return;
+        this.retryCount++;
+        if (this.retryCount > this.maxRetries) {
+          console.log(chalk.red(`\n🛑 Max retries reached.`));
+          this._logRollbackHint();
+          this.running = false;
+          this._healInProgress = false;
+          return;
+        }
+        // Release lock so _healAndRestart can acquire it
+        this._healInProgress = false;
+        await this._healAndRestart();
+      } catch (err) {
+        // #5: Prevent unhandled errors in health callback from crashing the parent
+        console.log(chalk.red(`  ⚠️  Health callback error: ${err.message}`));
+        this._healInProgress = false;
+        this._healStatus = null;
+        if (this.running) this._spawn();
       }
-      await this._healAndRestart();
     });
 
     this.child.on("exit", async (code, signal) => {
@@ -459,6 +478,13 @@ class WolverineRunner {
         return;
       }
 
+      // #28: SIGKILL = likely OOM — synthesize useful stderr for the heal pipeline
+      if (signal === "SIGKILL" && (!this._stderrBuffer.trim() || this._stderrBuffer.trim().length < 10)) {
+        this._stderrBuffer = `Process killed by SIGKILL (possible OOM). Memory limit may have been exceeded. Check memory usage patterns and reduce memory consumption.\nExit code: ${code}, Signal: ${signal}`;
+        console.log(chalk.red(`\n💀 Process killed by SIGKILL (possible OOM)`));
+        this.logger.error(EVENT_TYPES.PROCESS_CRASH, "SIGKILL — possible OOM", { exitCode: code, signal });
+      }
+
       // Killed by signal with no stderr — just restart, don't waste tokens healing
       if (!this._stderrBuffer.trim() || this._stderrBuffer.trim().length < 10) {
         console.log(chalk.yellow(`\n⚠️  Process killed (code: ${code}, signal: ${signal}) — no error to heal, restarting`));
@@ -483,13 +509,28 @@ class WolverineRunner {
       }
 
       this.retryCount++;
-      await this._healAndRestart();
+      // #3: Guard against unhandled rejections — don't let heal errors crash the parent
+      try {
+        await this._healAndRestart();
+      } catch (healErr) {
+        console.log(chalk.red(`  ⚠️  Heal error (recovering): ${healErr.message}`));
+        this._healInProgress = false;
+        this._healStatus = null;
+        if (this.running) this._spawn(); // restart without healing
+      }
     });
 
     this.child.on("error", (err) => {
       console.log(chalk.red(`Failed to start process: ${err.message}`));
       this.logger.error(EVENT_TYPES.PROCESS_CRASH, `Failed to start: ${err.message}`);
-      this.running = false;
+      // #10: Retry spawn after delay instead of permanently dying
+      if (this.running && this.retryCount < this.maxRetries) {
+        this.retryCount++;
+        console.log(chalk.yellow(`   Retrying spawn in 5s (attempt ${this.retryCount}/${this.maxRetries})...`));
+        setTimeout(() => { if (this.running) this._spawn(); }, 5000);
+      } else {
+        this.running = false;
+      }
     });
 
     // IPC channel: child reports caught 500 errors (Fastify/Express)
@@ -519,6 +560,8 @@ class WolverineRunner {
 
   async _healAndRestart() {
     if (this._healInProgress) return;
+    // #9: Bail if stop() was called during the window between crash and heal
+    if (this._shuttingDown) return;
     this._healInProgress = true;
     this._healStatus = { active: true, error: this._stderrBuffer.slice(0, 200), phase: "diagnosing", startedAt: Date.now() };
 
@@ -545,6 +588,8 @@ class WolverineRunner {
     }
 
     try {
+      // #9: Check again before expensive heal — stop() may have been called during loop guard
+      if (this._shuttingDown) { this._healInProgress = false; return; }
       const result = await heal({
         stderr: this._stderrBuffer,
         cwd: this.cwd,
@@ -584,6 +629,8 @@ class WolverineRunner {
         this._healStatus = null;
         // Clear pending errors — the heal fixed the root cause, stale errors are irrelevant
         this._pendingErrorHeal = null;
+        // #9: Don't restart if stop() was called while heal was running
+        if (this._shuttingDown) return;
         // Use restart() to properly kill old child before spawning — prevents EADDRINUSE
         this.restart();
       } else {
@@ -626,9 +673,14 @@ class WolverineRunner {
         }
       }
     } catch (err) {
-      console.log(chalk.red(`\n🐺 Wolverine encountered an error: ${err.message}`));
+      // #4: Don't permanently die on transient errors — restart without healing
+      console.log(chalk.red(`\n🐺 Wolverine heal error (recovering): ${err.message}`));
       this._healInProgress = false;
-      this.running = false;
+      this._healStatus = null;
+      if (this.running) {
+        console.log(chalk.yellow("   Restarting without healing..."));
+        this._spawn();
+      }
     }
   }
 
@@ -646,6 +698,15 @@ class WolverineRunner {
     }
     this._healInProgress = true;
 
+    // #8: Safety timeout — if heal hangs, force-release the lock after 6 minutes
+    const healTimeout = setTimeout(() => {
+      if (this._healInProgress) {
+        console.log(chalk.red(`  ⚠️  _healFromError safety timeout (6min) — releasing heal lock`));
+        this._healInProgress = false;
+        this._healStatus = null;
+      }
+    }, 360000);
+
     console.log(chalk.yellow(`\n🐺 Wolverine healing caught error on ${routePath}...`));
     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 });
@@ -700,6 +761,7 @@ class WolverineRunner {
         routeContext: { path: routePath, method: errorDetails?.method },
       });
 
+      clearTimeout(healTimeout);
       if (result.healed) {
         console.log(chalk.green(`\n🐺 Wolverine healed ${routePath} via ${result.mode}! Restarting...\n`));
         this.retryCount = 0; // Fresh start after successful heal
@@ -721,6 +783,7 @@ class WolverineRunner {
         this._healStatus = null;
       }
     } catch (err) {
+      clearTimeout(healTimeout);
       console.log(chalk.red(`\n🐺 Error during heal: ${err.message}`));
       this._healInProgress = false;
       this._healStatus = null;

package/src/core/verifier.js

@@ -23,6 +23,8 @@ const BOOT_PROBE_TIMEOUT_MS = 10000; // 10 seconds
  */
 function syntaxCheck(scriptPath) {
   return new Promise((resolve) => {
+    // #21: Guard against double resolve from exit + error firing in sequence
+    let settled = false;
     const child = spawn("node", ["--check", scriptPath], {
       stdio: ["ignore", "ignore", "pipe"],
       timeout: 5000,
@@ -32,6 +34,8 @@ function syntaxCheck(scriptPath) {
     child.stderr.on("data", (data) => { stderr += data.toString(); });
 
     child.on("exit", (code) => {
+      if (settled) return;
+      settled = true;
       resolve({
         valid: code === 0,
         error: code !== 0 ? stderr.trim() : undefined,
@@ -39,6 +43,8 @@ function syntaxCheck(scriptPath) {
     });
 
     child.on("error", (err) => {
+      if (settled) return;
+      settled = true;
       resolve({ valid: false, error: err.message });
     });
   });
@@ -71,6 +77,8 @@ function bootProbe(scriptPath, cwd, originalErrorSignature) {
     child.on("exit", (code) => {
       if (settled) return;
       settled = true;
+      // #19: Always ensure the child is killed after settling (handles orphan sub-processes)
+      try { child.kill("SIGTERM"); } catch {}
 
       if (code === 0) {
         resolve({ status: "alive" });
@@ -101,6 +109,8 @@ function bootProbe(scriptPath, cwd, originalErrorSignature) {
     child.on("error", (err) => {
       if (settled) return;
       settled = true;
+      // #19: Always ensure the child is killed after settling
+      try { child.kill("SIGTERM"); } catch {}
       resolve({ status: "crashed", stderr: err.message, sameError: false, exitCode: null });
     });
 
@@ -192,9 +202,10 @@ async function verifyFix(scriptPath, cwd, originalErrorSignature, routeContext)
     const relPath = path.relative(cwd, changedFile).replace(/\\/g, "/");
     if (relPath.startsWith("server/") && relPath.endsWith(".js")) {
       try {
-        const { execSync } = require("child_process");
+        const { execFileSync } = require("child_process");
+        // #22: Use execFileSync with args array to prevent path injection via relPath
         const testCode = `try{require('./${relPath}');console.log('MODULE_OK')}catch(e){console.error(e.message);process.exit(1)}`;
-        const out = execSync(`node -e "${testCode}"`, {
+        const out = execFileSync("node", ["-e", testCode], {
           cwd, timeout: 5000, encoding: "utf-8",
           env: { ...process.env, NODE_PATH: path.join(cwd, "node_modules") },
         });
@@ -237,6 +248,14 @@ function routeProbe(scriptPath, cwd, routeContext) {
     child.stdout.on("data", (d) => { stdout += d.toString(); });
     child.stderr.on("data", (d) => { stderr += d.toString(); });
 
+    // #20: Handle spawn errors (e.g., node binary not found)
+    child.on("error", (err) => {
+      clearInterval(checkPort);
+      if (settled) return;
+      settled = true;
+      resolve({ status: "failed", statusCode: 0, body: err.message });
+    });
+
     child.on("exit", () => {
       if (settled) return;
       settled = true;

package/src/core/wolverine.js

@@ -35,6 +35,17 @@ async function heal(opts) {
     if (err.message === "timeout") {
       console.log(chalk.red(`\n🐺 Heal timed out after ${HEAL_TIMEOUT_MS / 1000}s`));
       if (opts.logger) opts.logger.error(EVENT_TYPES.HEAL_FAILED, `Heal timed out after ${HEAL_TIMEOUT_MS / 1000}s`);
+      // #11: Rollback on timeout — the background _healImpl may have partially applied patches
+      if (opts.backupManager) {
+        try {
+          const all = opts.backupManager.getAll();
+          const latest = all.find(b => b.status === "unstable");
+          if (latest) {
+            opts.backupManager.rollbackTo(latest.id);
+            console.log(chalk.yellow(`  ↩️  Rolled back to ${latest.id} (timeout cleanup)`));
+          }
+        } catch {}
+      }
       return { healed: false, explanation: `Heal timed out after ${HEAL_TIMEOUT_MS / 1000}s` };
     }
     throw err;
@@ -154,7 +165,7 @@ async function _healImpl({ stderr, cwd, sandbox, notifier, rateLimiter, backupMa
   // 4c. Pre-heal operational fix — detect common non-code errors
   // Some crashes aren't code bugs (missing npm packages, missing config files).
   // Fix these directly without wasting AI tokens.
-  const opsFix = await tryOperationalFix(parsed, cwd, logger);
+  const opsFix = await tryOperationalFix(parsed, cwd, logger, sandbox);
   if (opsFix.fixed) {
     console.log(chalk.green(`  ⚡ Operational fix applied: ${opsFix.action}`));
     if (logger) logger.info(EVENT_TYPES.HEAL_SUCCESS, `Operational fix: ${opsFix.action}`, { action: opsFix.action });
@@ -286,8 +297,15 @@ async function _healImpl({ stderr, cwd, sandbox, notifier, rateLimiter, backupMa
     goal: `Fix: ${parsed.errorMessage.slice(0, 80)}`,
 
     onAttempt: async (iteration, researchCtx, priorAttempts) => {
-      // Create backup for this attempt
-      const bid = backupManager.createBackup(`heal attempt ${iteration}: ${parsed.errorMessage.slice(0, 60)}`);
+      // #12: Create backup for this attempt — if backup fails, skip the attempt entirely
+      let bid;
+      try {
+        bid = backupManager.createBackup(`heal attempt ${iteration}: ${parsed.errorMessage.slice(0, 60)}`);
+      } catch (backupErr) {
+        console.log(chalk.red(`  ⚠️  Backup creation failed: ${backupErr.message} — skipping attempt`));
+        if (logger) logger.error(EVENT_TYPES.BACKUP_CREATED, `Backup failed: ${backupErr.message}`);
+        return { healed: false, explanation: `Backup creation failed: ${backupErr.message}` };
+      }
       backupManager.setErrorSignature(bid, errorSignature);
       if (logger) logger.info(EVENT_TYPES.BACKUP_CREATED, `Backup ${bid} (iteration ${iteration})`, { backupId: bid });
 
@@ -312,7 +330,7 @@ async function _healImpl({ stderr, cwd, sandbox, notifier, rateLimiter, backupMa
             errorMessage: parsed.errorMessage, stackTrace: parsed.stackTrace,
             extraContext: envContext,
           });
-          rateLimiter.record(errorSignature);
+          // #15: Don't record rate limit until AFTER verification — failed attempts shouldn't exhaust the limit
 
           // Execute shell commands first (npm install, mkdir, etc.)
           if (repair.commands && Array.isArray(repair.commands)) {
@@ -351,6 +369,7 @@ async function _healImpl({ stderr, cwd, sandbox, notifier, rateLimiter, backupMa
           const verification = await verifyFix(parsed.filePath, cwd, errorSignature, routeContext);
           if (verification.verified) {
             backupManager.markVerified(bid);
+            rateLimiter.record(errorSignature);
             rateLimiter.clearSignature(errorSignature);
             // Track tool operations: file read + patch + verify + any commands
             // These are the same operations an agent would do with read_file/write_file/bash_exec
@@ -360,10 +379,11 @@ async function _healImpl({ stderr, cwd, sandbox, notifier, rateLimiter, backupMa
             return { healed: true, explanation: repair.explanation, backupId: bid, mode: "fast" };
           }
 
-          backupManager.rollbackTo(bid);
+          // #13: Safe rollback — wrap in try/catch to prevent rollback-of-rollback loop
+          try { backupManager.rollbackTo(bid); } catch (rbErr) { console.log(chalk.red(`  ⚠️  Rollback failed: ${rbErr.message}`)); }
           return { healed: false, explanation: `Fast path: ${verification.status}` };
         } catch (err) {
-          backupManager.rollbackTo(bid);
+          try { backupManager.rollbackTo(bid); } catch (rbErr) { console.log(chalk.red(`  ⚠️  Rollback failed: ${rbErr.message}`)); }
           return { healed: false, explanation: `Fast path error: ${err.message}` };
         }
       } else if (iteration <= 2) {
@@ -519,7 +539,7 @@ async function _healImpl({ stderr, cwd, sandbox, notifier, rateLimiter, backupMa
  * Try to fix common operational errors without AI.
  * Returns { fixed: boolean, action: string }
  */
-async function tryOperationalFix(parsed, cwd, logger) {
+async function tryOperationalFix(parsed, cwd, logger, sandbox) {
   const { execSync } = require("child_process");
   const msg = parsed.errorMessage || "";
 
@@ -552,9 +572,14 @@ async function tryOperationalFix(parsed, cwd, logger) {
 
     // Only auto-create if it's inside the project and looks like a config/data file
     const rel = path.relative(cwd, missingFile).replace(/\\/g, "/");
-    if (!rel.startsWith("..") && /\.(json|yaml|yml|toml|ini|conf|cfg|env|log|txt|csv|db|sqlite)$/i.test(missingFile)) {
+    // #18: Validate through sandbox to prevent creating files outside allowed paths
+    let safePath = missingFile;
+    if (sandbox) {
+      try { safePath = sandbox.resolve(missingFile); } catch { safePath = null; }
+    }
+    if (safePath && !rel.startsWith("..") && /\.(json|yaml|yml|toml|ini|conf|cfg|env|log|txt|csv|db|sqlite)$/i.test(missingFile)) {
       try {
-        fs.mkdirSync(path.dirname(missingFile), { recursive: true });
+        fs.mkdirSync(path.dirname(safePath), { recursive: true });
         const ext = path.extname(missingFile).toLowerCase();
 
         // For JSON config files, try to infer expected structure from the code or error message
@@ -587,7 +612,7 @@ async function tryOperationalFix(parsed, cwd, logger) {
           content = defaults[ext] || "";
         }
 
-        fs.writeFileSync(missingFile, content, "utf-8");
+        fs.writeFileSync(safePath, content, "utf-8");
         console.log(chalk.blue(`  📄 Created missing file: ${rel}`));
         return { fixed: true, action: `Created missing file: ${rel} with ${content === "{}" ? "empty" : "inferred"} config` };
       } catch {}
@@ -646,10 +671,13 @@ function _inferJsonConfig(missingFile, cwd, parsed) {
   const sourceFile = parsed.filePath;
   if (!sourceFile) return null;
 
+  // #17: Escape all regex special characters in basename to prevent regex injection
+  const escapedBasename = basename.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
   try {
     const source = fs.readFileSync(sourceFile, "utf-8");
     // Look for property accesses on the loaded config: config.apiUrl, config.timeout, etc.
-    const configVarMatch = source.match(new RegExp(`(?:const|let|var)\\s+(\\w+)\\s*=\\s*(?:require|JSON\\.parse).*${basename.replace(".", "\\.")}`));
+    const configVarMatch = source.match(new RegExp(`(?:const|let|var)\\s+(\\w+)\\s*=\\s*(?:require|JSON\\.parse).*${escapedBasename}`));
     if (!configVarMatch) return null;
 
     const varName = configVarMatch[1];

package/src/templates/server/config/settings.json

@@ -6,14 +6,14 @@
   },
 
   "models": {
-    "reasoning": "gpt-4o",
-    "coding": "gpt-4o",
-    "chat": "gpt-4o-mini",
+    "reasoning": "claude-sonnet-4-6",
+    "coding": "claude-sonnet-4-6",
+    "chat": "gpt-5.4-mini",
     "tool": "gpt-4o-mini",
     "classifier": "gpt-4o-mini",
-    "audit": "gpt-4o-mini",
-    "compacting": "gpt-4o-mini",
-    "research": "gpt-4o"
+    "audit": "wolverine-test-1",
+    "compacting": "wolverine-test-1",
+    "research": "claude-sonnet-4-6"
   },
 
   "embedding": "wolverine-embedding-1",