wolverine-ai 3.4.1 → 3.6.0

package/.env.example

@@ -6,6 +6,11 @@
 # Your OpenAI API key (required)
 OPENAI_API_KEY=
 ANTHROPIC_API_KEY=
+
+# ── Wolverine Inference (self-hosted models) ─────────────────────
+# Get your API key at wolverinenode.xyz — $1 = 100 credits
+# Set provider to "wolverine" in server/config/settings.json
+WOLVERINE_API_KEY=
 # ── Dashboard Admin Key  (make your own) ──────────────────────────────────────────
 # Required for the agent command interface on the dashboard.
 # Generate: node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"

package/README.md

@@ -70,7 +70,7 @@ wolverine/
 │   ├── core/                ← Wolverine engine
 │   │   ├── wolverine.js     ← Heal pipeline + goal loop
 │   │   ├── runner.js        ← Process manager (PM2-like)
-│   │   ├── ai-client.js     ← OpenAI client (Chat + Responses API)
+│   │   ├── ai-client.js     ← Dual provider client (OpenAI + Anthropic)
 │   │   ├── models.js        ← 10-model configuration system
 │   │   ├── verifier.js      ← Fix verification (syntax + boot probe)
 │   │   ├── error-parser.js  ← Stack trace parsing + error classification
@@ -81,7 +81,7 @@ wolverine/
 │   │   ├── system-info.js   ← Machine detection (cores, RAM, cloud, containers)
 │   │   └── cluster-manager.js← Auto-scaling worker management
 │   ├── agent/               ← AI agent system
-│   │   ├── agent-engine.js  ← Multi-turn agent with 10 tools
+│   │   ├── agent-engine.js  ← Multi-turn agent with 18 tools + 45s per-call timeout
 │   │   ├── goal-loop.js     ← Goal-driven repair loop
 │   │   ├── research-agent.js← Deep research + learning from failures
 │   │   └── sub-agents.js    ← 7 specialized sub-agents (explore/plan/fix/verify/...)
@@ -151,8 +151,9 @@ Server crashes
 
 Operational Fix (zero AI tokens):
   → "Cannot find module 'cors'" → npm install cors (instant, free)
-  → ENOENT on config file → create missing file with defaults
+  → ENOENT on config file → read source code, infer expected fields, create with correct structure
   → EACCES/EPERM → chmod 755
+  → EADDRINUSE → find and kill stale process on port
   → If operational fix works → done. No AI needed.
 
 Goal Loop (iterate until fixed or exhausted):
@@ -215,7 +216,7 @@ The AI agent has 18 built-in tools (inspired by [claw-code](https://github.com/u
 | `grep_code` | File | Regex search across codebase with context lines |
 | `list_dir` | File | List directory contents with sizes (find misplaced files) |
 | `move_file` | File | Move or rename files (fix structure problems) |
-| `bash_exec` | Shell | Sandboxed shell execution (npm install, chmod, kill, etc.) |
+| `bash_exec` | Shell | Sandboxed shell execution (npm install, chmod, kill, etc.) 30s default, 60s cap |
 | `git_log` | Shell | View recent commit history |
 | `git_diff` | Shell | View uncommitted changes |
 | `inspect_db` | Database | List tables, show schema, run SELECT on SQLite databases |
@@ -439,8 +440,11 @@ Three layers prevent token waste:
 | **Empty stderr guard** | Signal kills, clean shutdowns with no error | $0.00 |
 | **Loop guard** | Same error failing 3+ times in 10min → files bug report, stops healing | $0.00 after detection |
 | **Global rate limit** | Max 5 heals per 5 minutes regardless of error | Caps total spend |
+| **Per-API-call timeout** | 45s timeout on each AI call — prevents indefinite agent hangs | Saves time + tokens |
+| **Heal timeout** | 5-minute overall heal timeout via Promise.race | Prevents stuck heals |
+| **SIGTERM grace period** | 3s startup grace ignores SIGTERM — prevents restart scripts killing new process | Prevents shutdown loops |
 
-**Process dedup:** PID file ensures only one wolverine instance runs. Kills old process on startup.
+**Process dedup:** PID file ensures only one wolverine instance runs. Kills old process on startup. Exit handler only deletes PID file if it still belongs to current process (prevents race condition on restart).
 
 **Bug reports:** When loop guard triggers, generates a security-scanned report (no secrets/injection patterns) and sends to the platform backend for human review.
 
@@ -450,7 +454,7 @@ Three layers prevent token waste:
 
 | Technique | What it does | Cost |
 |-----------|-------------|------|
-| **Dynamic system prompt** | Simple errors get 400-token prompt with 7 tools. Complex get 1200 with 18 + strategy | 50% on 70% of heals |
+| **Dynamic system prompt** | Simple errors get 400-token prompt with 7 tools. Complex get 1200 with 18 + fast-fix strategy table | 50% on 70% of heals |
 | **Brain namespace isolation** | Seed docs (20K tokens) excluded from error heals — only searched for wolverine queries | 50% context reduction |
 | **Prompt caching** | Anthropic system prompt cached server-side — 90% cheaper on repeat calls | 12-16K tokens saved per heal |
 | **Tool result truncation** | Tool output capped at 4K chars — prevents context blowup from large reads | Up to 30K saved per turn |

package/bin/wolverine.js

@@ -152,13 +152,23 @@ console.log("");
 
 const runner = new WolverineRunner(scriptPath, { cwd: process.cwd() });
 
+// Grace period: ignore SIGTERM for 3s after startup.
+// Prevents restart scripts using `pkill -f wolverine.js` from killing
+// both the old AND newly spawned process.
+let startupGrace = true;
+setTimeout(() => { startupGrace = false; }, 3000);
+
 process.on("SIGINT", () => {
-  console.log(chalk.yellow(`\n\n👋 Shutting down Wolverine${workerLabel}...`));
+  console.log(chalk.yellow(`\n\n👋 Shutting down Wolverine...`));
   runner.stop();
   process.exit(0);
 });
 
 process.on("SIGTERM", () => {
+  if (startupGrace) {
+    console.log(chalk.yellow("  ⚡ Ignoring SIGTERM during startup grace period (3s)"));
+    return;
+  }
   runner.stop();
   process.exit(0);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wolverine-ai",
-  "version": "3.4.1",
+  "version": "3.6.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": {
@@ -49,8 +49,6 @@
     "src/",
     "server/",
     "examples/",
-    "README.md",
-    "CLAUDE.md",
     ".env.example"
   ],
   "dependencies": {

package/server/config/settings.json

@@ -5,7 +5,7 @@
     "env": "development"
   },
 
-  "provider": "hybrid",
+  "provider": "wolverine",
 
   "openai_settings": {
     "reasoning": "gpt-5.4-mini",
@@ -43,6 +43,18 @@
     "embedding": "text-embedding-3-small"
   },
 
+  "wolverine_settings": {
+    "reasoning": "wolverine-test-1",
+    "coding": "wolverine-test-1",
+    "chat": "wolverine-test-1",
+    "tool": "wolverine-test-1",
+    "classifier": "wolverine-test-1",
+    "audit": "wolverine-test-1",
+    "compacting": "wolverine-test-1",
+    "research": "wolverine-test-1",
+    "embedding": "text-embedding-3-small"
+  },
+
   "server": {
     "port": 3000,
     "maxRetries": 3,
@@ -84,6 +96,11 @@
     "intervalMs": 300000
   },
 
+  "platform": {
+    "apiKey": "",
+    "cors": ["http://localhost:3000"]
+  },
+
   "dashboard": {},
 
   "cors": {

package/server/routes/inference.js

@@ -0,0 +1,324 @@
+const https = require("https");
+const http = require("http");
+const crypto = require("crypto");
+
+/**
+ * Wolverine Inference API
+ *
+ * Credit system: $1 = 100 credits. 1 credit = $0.01 of compute.
+ * Token pricing (in credits per million tokens):
+ *   wolverine-test-1: 1 credit input / 4 credits output per 1M tokens
+ *   (= $0.01/$0.04 per 1M — 15x cheaper than gpt-4o-mini, 80x cheaper than haiku)
+ *
+ * Rate limiting: per API key, configurable per tier.
+ * 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";
+
+// Pricing in CREDITS per million tokens ($1 = 100 credits)
+const MODEL_PRICING = {
+  "wolverine-test-1":  { input: 1.0, output: 4.0 },   // $0.01/$0.04 per 1M
+  "wolverine-coding":  { input: 1.0, output: 4.0 },
+  "wolverine-reasoning": { input: 2.5, output: 10.0 }, // heavier model when available
+};
+
+const MODEL_MAP = {
+  "wolverine-test-1": "wolverine-test-1",
+  "wolverine-coding": "wolverine-test-1",
+  "wolverine-reasoning": "wolverine-test-1",
+};
+
+const TIER_LIMITS = {
+  free: { rpm: 10, maxTokens: 1024 },
+  starter: { rpm: 60, maxTokens: 4096 },
+  pro: { rpm: 300, maxTokens: 4096 },
+  admin: { rpm: 9999, maxTokens: 4096 },
+};
+
+function tokenCost(model, inputTokens, outputTokens) {
+  const p = MODEL_PRICING[model] || MODEL_PRICING["wolverine-test-1"];
+  return ((inputTokens / 1_000_000) * p.input) + ((outputTokens / 1_000_000) * p.output);
+}
+
+// ── Request Queue (handles GPU saturation) ──
+const queue = [];
+let activeRequests = 0;
+const MAX_CONCURRENT = 8; // vLLM max-num-seqs
+const QUEUE_TIMEOUT_MS = 30000;
+
+function enqueue() {
+  return new Promise((resolve, reject) => {
+    if (activeRequests < MAX_CONCURRENT) {
+      activeRequests++;
+      resolve();
+      return;
+    }
+    const timer = setTimeout(() => {
+      const idx = queue.indexOf(entry);
+      if (idx >= 0) queue.splice(idx, 1);
+      reject(new Error("Queue timeout — GPU at capacity. Try again in a few seconds."));
+    }, QUEUE_TIMEOUT_MS);
+    const entry = { resolve: () => { clearTimeout(timer); activeRequests++; resolve(); }, reject };
+    queue.push(entry);
+  });
+}
+
+function dequeue() {
+  activeRequests = Math.max(0, activeRequests - 1);
+  if (queue.length > 0) {
+    const next = queue.shift();
+    next.resolve();
+  }
+}
+
+async function routes(fastify) {
+  const { pool } = require("../lib/db");
+
+  // Rate limit state (in-memory)
+  const rateWindows = new Map();
+
+  async function authenticate(request, reply) {
+    const apiKey = request.headers.authorization?.replace("Bearer ", "") || request.headers["x-api-key"];
+    if (!apiKey) return reply.code(401).send({ error: { message: "API key required. Pass via Authorization: Bearer <key>", type: "auth_error" } });
+
+    // Platform key bypass
+    let settings = {};
+    try { settings = require("../config/settings.json"); } catch {}
+    if (apiKey === settings.platform?.apiKey) {
+      request.account = { api_key: apiKey, owner: "platform", tier: "admin", credits_remaining: 999999, rate_limit_rpm: 9999 };
+      return;
+    }
+
+    const result = await pool.query("SELECT * FROM api_credits WHERE api_key = $1", [apiKey]);
+    if (result.rows.length === 0) return reply.code(401).send({ error: { message: "Invalid API key", type: "auth_error" } });
+
+    const account = result.rows[0];
+
+    // Credit check
+    if (parseFloat(account.credits_remaining) <= 0) {
+      return reply.code(402).send({ error: { message: "Insufficient credits. Add credits at wolverinenode.xyz", type: "billing_error", credits_remaining: 0 } });
+    }
+
+    // Rate limit
+    const now = Date.now();
+    const window = rateWindows.get(apiKey) || { count: 0, resetAt: now + 60000 };
+    if (now > window.resetAt) { window.count = 0; window.resetAt = now + 60000; }
+    const limit = account.rate_limit_rpm || TIER_LIMITS[account.tier]?.rpm || 10;
+    if (window.count >= limit) {
+      const retryAfter = Math.ceil((window.resetAt - now) / 1000);
+      return reply.code(429).send({ error: { message: `Rate limit: ${limit} requests/min. Retry in ${retryAfter}s`, type: "rate_limit", retry_after: retryAfter } });
+    }
+    window.count++;
+    rateWindows.set(apiKey, window);
+
+    request.account = account;
+  }
+
+  // ── POST /chat/completions ──
+  fastify.post("/chat/completions", { preHandler: authenticate }, async (request, reply) => {
+    const body = request.body || {};
+    const requestedModel = body.model || "wolverine-test-1";
+    const account = request.account;
+    const tier = TIER_LIMITS[account.tier] || TIER_LIMITS.free;
+    const startMs = Date.now();
+
+    // Enforce max tokens per tier
+    if (body.max_tokens && body.max_tokens > tier.maxTokens) {
+      body.max_tokens = tier.maxTokens;
+    }
+
+    // Map model name for backend
+    const backendBody = { ...body, model: MODEL_MAP[requestedModel] || requestedModel };
+
+    // Queue if GPU saturated
+    try {
+      await enqueue();
+    } catch (err) {
+      return reply.code(503).send({ error: { message: err.message, type: "capacity_error", queue_length: queue.length } });
+    }
+
+    try {
+      const result = await proxyToInference("/v1/chat/completions", backendBody);
+      const latencyMs = Date.now() - startMs;
+
+      const usage = result.usage || {};
+      const inputTokens = usage.prompt_tokens || 0;
+      const outputTokens = usage.completion_tokens || 0;
+      const cost = tokenCost(requestedModel, inputTokens, outputTokens);
+
+      // Bill credits (skip for platform)
+      if (account.owner !== "platform") {
+        await pool.query(
+          "UPDATE api_credits SET credits_remaining = credits_remaining - $1, credits_used = credits_used + $1, last_used = NOW() WHERE api_key = $2",
+          [cost, account.api_key]
+        );
+        await pool.query(
+          "INSERT INTO api_usage_log (api_key, model, input_tokens, output_tokens, total_tokens, cost, latency_ms, success, endpoint) VALUES ($1, $2, $3, $4, $5, $6, $7, true, $8)",
+          [account.api_key, requestedModel, inputTokens, outputTokens, inputTokens + outputTokens, cost, latencyMs, "/v1/chat/completions"]
+        );
+      }
+
+      // Rewrite response
+      if (result.model) result.model = requestedModel;
+      result.x_wolverine = {
+        credits_used: Math.round(cost * 1000000) / 1000000,
+        credits_remaining: Math.max(0, parseFloat(account.credits_remaining) - cost),
+        latency_ms: latencyMs,
+        queued: activeRequests > MAX_CONCURRENT,
+      };
+
+      return result;
+    } catch (err) {
+      if (account.owner !== "platform") {
+        await pool.query(
+          "INSERT INTO api_usage_log (api_key, model, input_tokens, output_tokens, total_tokens, cost, latency_ms, success, endpoint) VALUES ($1, $2, 0, 0, 0, 0, $3, false, $4)",
+          [account.api_key, requestedModel, Date.now() - startMs, "/v1/chat/completions"]
+        ).catch(() => {});
+      }
+      return reply.code(502).send({ error: { message: `Inference error: ${err.message}`, type: "inference_error" } });
+    } finally {
+      dequeue();
+    }
+  });
+
+  // ── GET /models ──
+  fastify.get("/models", async () => ({
+    object: "list",
+    data: Object.entries(MODEL_PRICING).map(([id, p]) => ({
+      id, object: "model", owned_by: "wolverine",
+      created: Math.floor(Date.now() / 1000),
+      pricing: { input_credits_per_million: p.input, output_credits_per_million: p.output, usd_per_credit: 0.01 },
+    })),
+  }));
+
+  // ── POST /keys/create — generate new API key ──
+  fastify.post("/keys/create", { preHandler: authenticate }, async (request, reply) => {
+    const account = request.account;
+    if (account.tier !== "admin") return reply.code(403).send({ error: { message: "Only admins can create API keys", type: "auth_error" } });
+
+    const { owner, email, credits, tier, rpm } = request.body || {};
+    if (!owner) return reply.code(400).send({ error: { message: "owner required", type: "validation_error" } });
+
+    const newKey = "wlv_" + crypto.randomBytes(24).toString("hex");
+    const keyTier = tier || "free";
+    const keyCredits = credits || (keyTier === "free" ? 10 : 0);
+    const keyRpm = rpm || TIER_LIMITS[keyTier]?.rpm || 10;
+
+    await pool.query(
+      "INSERT INTO api_credits (api_key, owner, email, credits_remaining, tier, plan_name, rate_limit_rpm) VALUES ($1, $2, $3, $4, $5, $6, $7)",
+      [newKey, owner, email || null, keyCredits, keyTier, keyTier, keyRpm]
+    );
+
+    return { api_key: newKey, owner, tier: keyTier, credits: keyCredits, rate_limit_rpm: keyRpm };
+  });
+
+  // ── POST /keys/add-credits — add credits to a key ──
+  fastify.post("/keys/add-credits", { preHandler: authenticate }, async (request, reply) => {
+    const account = request.account;
+    if (account.tier !== "admin") return reply.code(403).send({ error: { message: "Only admins can add credits", type: "auth_error" } });
+
+    const { api_key, credits } = request.body || {};
+    if (!api_key || !credits) return reply.code(400).send({ error: { message: "api_key and credits required" } });
+
+    await pool.query("UPDATE api_credits SET credits_remaining = credits_remaining + $1 WHERE api_key = $2", [credits, api_key]);
+    const updated = await pool.query("SELECT credits_remaining FROM api_credits WHERE api_key = $1", [api_key]);
+    return { api_key, credits_added: credits, credits_remaining: parseFloat(updated.rows[0]?.credits_remaining || 0) };
+  });
+
+  // ── GET /keys — list all keys (admin only) ──
+  fastify.get("/keys", { preHandler: authenticate }, async (request, reply) => {
+    if (request.account.tier !== "admin") return reply.code(403).send({ error: { message: "Admin only" } });
+    const { rows } = await pool.query("SELECT api_key, owner, email, tier, credits_remaining, credits_used, rate_limit_rpm, created_at, last_used FROM api_credits ORDER BY created_at DESC");
+    return { keys: rows };
+  });
+
+  // ── GET /credits ──
+  fastify.get("/credits", { preHandler: authenticate }, async (request, reply) => {
+    const a = request.account;
+    return {
+      credits_remaining: parseFloat(a.credits_remaining),
+      credits_used: parseFloat(a.credits_used || 0),
+      usd_remaining: parseFloat(a.credits_remaining) * 0.01,
+      usd_used: parseFloat(a.credits_used || 0) * 0.01,
+      tier: a.tier, rate_limit_rpm: a.rate_limit_rpm, owner: a.owner,
+    };
+  });
+
+  // ── GET /usage ──
+  fastify.get("/usage", { preHandler: authenticate }, async (request, reply) => {
+    const apiKey = request.account.api_key;
+    const period = request.query.period || "7d";
+    const interval = { "1h": "1 hour", "1d": "1 day", "7d": "7 days", "30d": "30 days" }[period] || "7 days";
+
+    const summary = await pool.query(
+      `SELECT model, COUNT(*) AS calls, SUM(input_tokens) AS input, SUM(output_tokens) AS output,
+              SUM(total_tokens) AS tokens, SUM(cost) AS credits_spent, AVG(latency_ms) AS avg_latency,
+              COUNT(*) FILTER (WHERE success) AS successes
+       FROM api_usage_log WHERE api_key = $1 AND timestamp > NOW() - $2::interval
+       GROUP BY model ORDER BY credits_spent DESC`, [apiKey, interval]
+    );
+
+    const timeline = await pool.query(
+      `SELECT date_trunc('hour', timestamp) AS hour, SUM(cost) AS credits, SUM(total_tokens) AS tokens, COUNT(*) AS calls
+       FROM api_usage_log WHERE api_key = $1 AND timestamp > NOW() - $2::interval
+       GROUP BY hour ORDER BY hour`, [apiKey, interval]
+    );
+
+    const totalCredits = summary.rows.reduce((s, r) => s + parseFloat(r.credits_spent || 0), 0);
+
+    return {
+      period,
+      total_credits_spent: Math.round(totalCredits * 1000000) / 1000000,
+      total_usd_spent: Math.round(totalCredits * 0.01 * 1000000) / 1000000,
+      byModel: summary.rows.map(r => ({
+        model: r.model, calls: parseInt(r.calls), input: parseInt(r.input || 0), output: parseInt(r.output || 0),
+        tokens: parseInt(r.tokens || 0), credits_spent: parseFloat(r.credits_spent || 0),
+        usd_spent: parseFloat(r.credits_spent || 0) * 0.01,
+        avgLatencyMs: Math.round(parseFloat(r.avg_latency || 0)),
+        successRate: parseInt(r.calls) > 0 ? parseFloat(((parseInt(r.successes) / parseInt(r.calls)) * 100).toFixed(2)) : 0,
+      })),
+      timeline: timeline.rows.map(r => ({
+        hour: r.hour, credits: parseFloat(r.credits), tokens: parseInt(r.tokens), calls: parseInt(r.calls),
+      })),
+      queue: { active: activeRequests, waiting: queue.length, max: MAX_CONCURRENT },
+    };
+  });
+
+  // ── GET /health ──
+  fastify.get("/health", async () => {
+    try {
+      const result = await proxyToInference("/health", null, "GET");
+      return { status: "ok", inference: result, queue: { active: activeRequests, waiting: queue.length, max: MAX_CONCURRENT } };
+    } catch (err) {
+      return { status: "down", error: err.message, queue: { active: activeRequests, waiting: queue.length, max: MAX_CONCURRENT } };
+    }
+  });
+}
+
+function proxyToInference(path, body, method = "POST") {
+  return new Promise((resolve, reject) => {
+    const url = new (require("url").URL)(INFERENCE_URL + path);
+    const client = url.protocol === "https:" ? https : http;
+    const bodyStr = body ? JSON.stringify(body) : null;
+
+    const req = client.request({
+      hostname: url.hostname,
+      port: url.port || (url.protocol === "https:" ? 443 : 80),
+      path: url.pathname,
+      method,
+      timeout: 120000,
+      headers: { "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("Inference timeout")); });
+    if (bodyStr) req.write(bodyStr);
+    req.end();
+  });
+}
+
+module.exports = routes;

package/src/agent/agent-engine.js

@@ -414,15 +414,23 @@ class AgentEngine {
       }
 
       let response;
+      const AI_CALL_TIMEOUT_MS = 45000; // 45s per API call — prevents indefinite hangs
       try {
-        response = await aiCallWithHistory({
-          model,
-          messages: this.messages,
-          tools: allTools,
-          maxTokens: 4096,
-        });
+        response = await Promise.race([
+          aiCallWithHistory({
+            model,
+            messages: this.messages,
+            tools: allTools,
+            maxTokens: 4096,
+          }),
+          new Promise((_, reject) => setTimeout(() => reject(new Error("AI call timed out after 45s")), AI_CALL_TIMEOUT_MS)),
+        ]);
       } catch (err) {
         console.log(chalk.red(`  Agent API error: ${err.message}`));
+        // On timeout, return what we have so far rather than failing completely
+        if (err.message.includes("timed out") && this.filesModified.length > 0) {
+          return { success: true, summary: `Partial fix applied (API timeout on turn ${this.turnCount})`, filesModified: this.filesModified, turnCount: this.turnCount, totalTokens: this.totalTokens };
+        }
         return { success: false, summary: err.message, filesModified: [], turnCount: this.turnCount, totalTokens: this.totalTokens };
       }
 
@@ -440,6 +448,15 @@ class AgentEngine {
       const assistantMessage = choice.message || choice;
       this.messages.push(assistantMessage);
 
+      // Parse Gemma-style text tool calls: "call:tool_name{json_args}" → structured tool_calls
+      if ((!assistantMessage.tool_calls || assistantMessage.tool_calls.length === 0) && assistantMessage.content) {
+        const parsed = _parseTextToolCalls(assistantMessage.content);
+        if (parsed.length > 0) {
+          assistantMessage.tool_calls = parsed;
+          console.log(chalk.gray(`  🔧 Parsed ${parsed.length} tool call(s) from text output`));
+        }
+      }
+
       if (!assistantMessage.tool_calls || assistantMessage.tool_calls.length === 0) {
         if (assistantMessage.content) {
           console.log(chalk.gray(`  💬 ${(assistantMessage.content || "").slice(0, 200)}`));
@@ -1060,26 +1077,31 @@ Project: ${cwd}`;
 function _fullPrompt(cwd, primaryFile) {
   return `You are Wolverine, an autonomous Node.js server repair agent. Diagnose and fix the error.
 
-You are a full server doctor. Errors can be code bugs, missing deps, database problems, config issues, port conflicts, permissions, or corrupted state. Investigate the root cause before fixing.
+You are a full server doctor. Errors can be code bugs, missing deps, database problems, config issues, port conflicts, permissions, or corrupted state.
+
+CRITICAL: Act fast. You have limited turns. Fix immediately when the solution is obvious from the error. Only investigate when the cause is unclear.
 
 For maximum efficiency, invoke multiple independent tools simultaneously rather than sequentially.
 
 TOOLS: read_file, write_file, edit_file, glob_files, grep_code, list_dir, move_file, bash_exec, git_log, git_diff, inspect_db, run_db_fix, check_port, check_env, audit_deps, check_migration, web_fetch, done
 
-STRATEGY:
-- Cannot find module 'X' → bash_exec: npm install X
-- Cannot find module './X' → edit_file: fix require path
-- ENOENT → write_file or move_file
-- EADDRINUSE → check_port then bash_exec: kill
-- TypeError/ReferenceError → read_file then edit_file
+FAST FIXES (act immediately, don't investigate):
+- Cannot find module 'X' → bash_exec: npm install X → done
+- Cannot find module './X' → grep for correct path → edit_file → done
+- ENOENT missing config/json file → read the code that loads it to see what fields it expects → write_file with required fields → done
+- EADDRINUSE → check_port → bash_exec: kill PID → done
+- TypeError/ReferenceError → read_file → edit_file → done
+- Missing env var → check_env → report it → done
+
+INVESTIGATION (only when cause is unclear):
 - Database error → inspect_db then run_db_fix
-- Missing env var → check_env
+- Unknown errors → grep_code, list_dir to find root cause
 
 RULES:
-1. Investigate first — read files before modifying
-2. Minimal targeted changes — fix root cause not symptoms
-3. bash_exec for operational fixes, edit_file for code, run_db_fix for data
-4. Call done with summary when finished
+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.
 ${primaryFile ? `\nFile: ${primaryFile}` : ""}
 Project: ${cwd}`;
 }
@@ -1210,4 +1232,50 @@ function _runPostHook(toolName, toolInput, toolOutput, isError, cwd) {
   } catch {}
 }
 
+/**
+ * Parse Gemma-style text tool calls into OpenAI tool_calls format.
+ * Gemma outputs: "call:tool_name{json_args}" or "<|tool_call>call:tool_name{args}<tool_call|>"
+ * We convert to: [{ id, type: "function", function: { name, arguments } }]
+ */
+function _parseTextToolCalls(content) {
+  if (!content) return [];
+  const calls = [];
+  // Match patterns: call:name{args} or call:name{"key":"val"}
+  const patterns = [
+    /call:(\w+)\{([^}]*(?:\{[^}]*\}[^}]*)*)\}/g,  // call:name{args with nested braces}
+    /call:(\w+)\(([^)]*)\)/g,                        // call:name(args)
+  ];
+  for (const regex of patterns) {
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+      const name = match[1];
+      let argsStr = match[2];
+      // Try to parse as JSON, otherwise build from key:value pairs
+      let args;
+      try {
+        // Clean up Gemma's quoting: path:"value" → "path":"value"
+        const cleaned = argsStr.replace(/(\w+)\s*:\s*/g, '"$1":').replace(/<\|"\|>/g, '"');
+        args = JSON.parse("{" + cleaned + "}");
+      } catch {
+        try { args = JSON.parse(argsStr); } catch {
+          // Last resort: treat as single string argument for the most common param
+          const paramGuess = argsStr.replace(/['"<|>]/g, "").trim();
+          if (name === "read_file" || name === "glob_files") args = { path: paramGuess };
+          else if (name === "grep_code") args = { pattern: paramGuess };
+          else if (name === "bash_exec") args = { command: paramGuess };
+          else if (name === "write_file") args = { path: paramGuess, content: "" };
+          else args = { input: paramGuess };
+        }
+      }
+      calls.push({
+        id: "call_" + Date.now().toString(36) + "_" + calls.length,
+        type: "function",
+        function: { name, arguments: JSON.stringify(args) },
+      });
+    }
+    if (calls.length > 0) break; // use first matching pattern
+  }
+  return calls;
+}
+
 module.exports = { AgentEngine, TOOL_DEFINITIONS, BLOCKED_COMMANDS };

package/src/agent/goal-loop.js

@@ -107,13 +107,18 @@ class GoalLoop {
           explanation: attempt.explanation,
         }).catch(() => {});
 
-        // Deep research after 2nd failure — bring in RESEARCH_MODEL
-        if (iteration >= 2) {
+        // Deep research only after 3rd failure — avoid adding latency on early iterations
+        if (iteration >= 3) {
           console.log(chalk.magenta(`  🔬 Triggering deep research after ${iteration} failures...`));
-          const research = await this.researcher.research(errorMessage, context);
-          if (research) {
-            console.log(chalk.gray(`  🔬 Research insight: ${research.slice(0, 100)}`));
-          }
+          try {
+            const research = await Promise.race([
+              this.researcher.research(errorMessage, context),
+              new Promise((resolve) => setTimeout(() => resolve(null), 30000)), // 30s cap
+            ]);
+            if (research) {
+              console.log(chalk.gray(`  🔬 Research insight: ${research.slice(0, 100)}`));
+            }
+          } catch {}
         }
       }