wolverine-ai 4.5.3 → 4.6.0

package/bin/wolverine.js

@@ -27,6 +27,7 @@ ${chalk.bold("Options:")}
   --single         Force single-worker mode (no clustering)
   --workers <n>    Force specific worker count
   --info           Show system info and exit
+  --init           Scan server/ and build context map (routes, DB, config, deps)
 
 ${chalk.bold("Configuration:")}
   server/config/settings.json    Models, telemetry, limits, health checks
@@ -54,6 +55,25 @@ if (args.includes("--info")) {
   process.exit(0);
 }
 
+// --init: scan server/ and build context map
+if (args.includes("--init")) {
+  const { scan } = require("../src/core/server-context");
+  console.log(chalk.blue("\n  🔍 Scanning server/ directory...\n"));
+  const ctx = scan(process.cwd());
+  if (!ctx) {
+    console.log(chalk.yellow("  No server/ directory found."));
+    process.exit(1);
+  }
+  console.log(chalk.green(`  ✅ Server context built:`));
+  console.log(chalk.gray(`     Routes: ${ctx.routes.reduce((s, r) => s + r.endpoints.length, 0)}`));
+  console.log(chalk.gray(`     Middleware: ${ctx.middleware.length}`));
+  console.log(chalk.gray(`     Database: ${ctx.database.type || "none"}${ctx.database.tables.length > 0 ? ` (${ctx.database.tables.length} tables)` : ""}`));
+  console.log(chalk.gray(`     Env vars: ${ctx.envVars.length}`));
+  console.log(chalk.gray(`     Files: ${ctx.structure.length}`));
+  console.log(chalk.gray(`     Saved to: .wolverine/server-context.json\n`));
+  process.exit(0);
+}
+
 // --update: safe framework update
 if (args.includes("--update")) {
   const { safeUpdate } = require("../src/skills/update");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wolverine-ai",
-  "version": "4.5.3",
+  "version": "4.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": {

package/src/brain/brain.js

@@ -42,7 +42,7 @@ const SEED_DOCS = [
     metadata: { topic: "backup-system" },
   },
   {
-    text: "Wolverine security: file sandbox restricts all reads/writes to the project directory. Prompt injection detection runs on every error (regex layer + AI audit via AUDIT_MODEL). Rate limiter prevents error explosion cost with sliding window, min gap, hourly token budget, and exponential backoff for error loops.",
+    text: "Wolverine security: multi-layer defense. (1) File sandbox — restricts reads/writes to project dir, vault paths blocked. (2) Injection detector — ~50 regex patterns scan errors BEFORE AI sees them: prompt override, role hijack, code exec, env leak, bash escape, reverse shell, data exfiltration, destructive commands, framework source writes. Blocks heal entirely on detection. (3) Bash sandbox escape — _detectSandboxEscape checks every bash_exec: blocks cd outside project, writes to absolute paths, subshell escapes, curl @file exfil, pipe to tee outside project. (4) BLOCKED_COMMANDS — 18 patterns: rm -rf, mkfs, dd, shutdown, git push --force, npm publish, curl|bash, wget|sh, curl $(), cat .env, writes to src/. (5) Secret redactor — scrubs API keys, hex keys, vault paths from all output. (6) Rate limiter — sliding window + exponential backoff. (7) Adaptive rate limiter — auto-throttles server at 70%/85% CPU/memory thresholds.",
     metadata: { topic: "security" },
   },
   {
@@ -86,7 +86,7 @@ const SEED_DOCS = [
     metadata: { topic: "server-best-practices" },
   },
   {
-    text: "Wolverine editable scope: only files inside server/ can be modified by the agent. src/, bin/, tests/, .env, package.json, node_modules/ are all protected. The agent's _isProtectedPath guard blocks writes to anything outside server/. Direct edits target the script wolverine was launched with (server/index.js by default).",
+    text: "Wolverine editable scope: only files inside server/ can be modified by the agent. src/, bin/, tests/, .env, package.json, node_modules/, .wolverine/vault/ are all protected. The agent's _isProtectedPath guard blocks write_file/edit_file/move_file to protected paths. bash_exec additionally runs through _detectSandboxEscape which blocks shell commands that write outside the project via redirection, cp, mv, tee, or subshell. Vault files (master.key, eth.vault) are blocked by both sandbox and _isProtectedPath.",
     metadata: { topic: "editable-scope" },
   },
   {
@@ -110,7 +110,7 @@ const SEED_DOCS = [
     metadata: { topic: "sub-agent-workflow" },
   },
   {
-    text: "Sub-agent tool restrictions: explore gets read_file/glob/grep/git_log/git_diff/list_dir/check_env/check_port/check_memory/check_network/list_processes/inspect_db/audit_deps. plan gets read_file/glob/grep/list_dir/inspect_db/check_env/inspect_env/audit_deps/check_migration. fix gets read_file/write_file/edit_file/glob/grep/bash_exec/move_file/run_db_fix/audit_deps/restart_service. verify gets read_file/glob/grep/bash_exec/inspect_db/check_port/check_memory/check_logs. research gets read_file/grep/web_fetch/check_logs. security gets read_file/glob/grep/inspect_db/inspect_env. database gets read_file/write_file/edit_file/glob/grep/bash_exec/inspect_db/run_db_fix. 24 tools total, each sub-agent type gets tools relevant to its role.",
+    text: "Sub-agent tool restrictions: explore gets read_file/glob/grep/git_log/git_diff/list_dir/check_env/check_port/check_memory/check_network/list_processes/inspect_db/audit_deps/check_file_descriptors/inspect_cache. plan gets read_file/glob/grep/list_dir/inspect_db/check_env/inspect_env/audit_deps/check_migration/check_event_loop. fix gets read_file/write_file/edit_file/glob/grep/bash_exec/move_file/run_db_fix/audit_deps/restart_service/verify_node_modules/disk_cleanup. verify gets read_file/glob/grep/bash_exec/inspect_db/check_port/check_memory/check_logs/check_websocket/inspect_certificate. research gets read_file/grep/web_fetch/check_logs. security gets read_file/glob/grep/inspect_db/inspect_env/check_event_loop/inspect_certificate. database gets read_file/write_file/edit_file/glob/grep/bash_exec/inspect_db/run_db_fix/inspect_cache. 31 tools total across 9 categories.",
     metadata: { topic: "sub-agent-tools" },
   },
   {
@@ -138,9 +138,13 @@ const SEED_DOCS = [
     metadata: { topic: "prompt-caching" },
   },
   {
-    text: "Platform telemetry: lightweight background process, zero-config. Default platform: api.wolverinenode.xyz. Auto-registers on first run (retries every 60s until platform responds), saves key to .wolverine/platform-key. Heartbeat payload matches PLATFORM.md spec: instanceId, server (name/port/uptime/status/pid), process (memoryMB/cpuPercent), routes, repairs, usage (tokens/cost/calls/byCategory), brain, backups. Offline-resilient: queues up to 1440 heartbeats locally, drains on reconnect. No chalk dependency, cached version/key in memory, minimal IO. Opt out: WOLVERINE_TELEMETRY=false. Override URL: WOLVERINE_PLATFORM_URL.",
+    text: "Platform telemetry: lightweight background process, zero-config. Default platform: api.wolverinenode.xyz. Auto-registers on first run, heartbeats every 60s. Offline-resilient: queues up to 1440 heartbeats locally, drains on reconnect. Opt out: WOLVERINE_TELEMETRY=false.",
     metadata: { topic: "platform-telemetry" },
   },
+  {
+    text: "Server context scanner (wolverine --init): scans server/ directory on every startup to build .wolverine/server-context.json. Extracts routes (HTTP methods + paths from fastify/express), middleware stack, database type + tables, config structure, dependencies, env vars used (process.env.X patterns), and full file tree. Context summary auto-injected into agent's heal prompt so it knows the server's route map, DB schema, and dependencies without re-scanning. Manual scan: wolverine --init. Auto-scan: runs silently on every boot. The context is read-only — never modified by the agent.",
+    metadata: { topic: "server-context" },
+  },
   {
     text: "Telemetry architecture: 4 files, ~250 lines total. heartbeat.js sends one HTTP POST every 60s (5s timeout, non-blocking). register.js auto-registers and caches key in memory + disk. queue.js appends to JSONL file only on failure, trims lazily. telemetry.js collects from subsystems using optional chaining (no crashes if subsystem missing). All secrets redacted before sending. Response bodies drained immediately (res.resume). No blocking, no delays, no busy waits.",
     metadata: { topic: "telemetry-architecture" },
@@ -226,11 +230,11 @@ 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 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.",
+    text: "Agent tool details — FILE: read_file (offset/limit for large files), edit_file (surgical find-and-replace, single match), glob_files (pattern discovery, **/*.js), grep_code (regex search with context, sandbox-enforced reads), list_dir (directory listing with sizes, sandbox-checked), move_file (relocate/rename). SHELL: bash_exec (30s default, 60s cap, 18 blocked command patterns, sandbox escape detection for writes outside project, SSRF-protected). DATABASE: inspect_db (SQLite: tables/schema/query, no stacked queries via ; block), run_db_fix (auto-snapshots before/after, existence check before backup). DIAGNOSTICS: check_port (platform-aware, netstat/lsof), check_env (values redacted, secrets always show SET only), check_memory (RSS/heap/system, OOM warning), list_processes (platform-aware node processes), check_logs (journalctl/logfile with grep filter, capped 1-1000 lines), check_network (DNS/port/URL with sanitized inputs), inspect_env (names only, grouped by category). SERVER: restart_service (flag-file, not direct restart). DEPS: audit_deps (npm health score), check_migration (known upgrade paths). RESEARCH: web_fetch (SSRF blocklist for private IPs/metadata). ADVANCED: verify_node_modules (integrity vs package-lock, broken .bin, cross-platform), inspect_certificate (TLS connect, expiry/SAN/chain/self-signed), inspect_cache (Redis PING/INFO via raw TCP), disk_cleanup (safe targets: old backups + npm cache, dry-run default), check_file_descriptors (Linux /proc/fd count vs ulimit), check_event_loop (static scan for readFileSync/execSync/pbkdf2Sync patterns), check_websocket (real WS upgrade handshake test).",
     metadata: { topic: "agent-tools-detail" },
   },
   {
-    text: "Server problem categories the agent can fix: CODE BUGS (SyntaxError, TypeError, ReferenceError → edit_file), DEPENDENCIES (Cannot find module → npm install, corrupted node_modules → rm + reinstall), DATABASE (invalid entries → run_db_fix UPDATE, missing table → CREATE TABLE, schema mismatch → ALTER TABLE, constraint violation → fix data or schema), CONFIG (invalid JSON → edit_file, missing env vars → write .env, wrong port → edit config), FILESYSTEM (misplaced files → move_file, missing directories → bash_exec mkdir, wrong permissions → chmod), NETWORK (port conflict → check_port + kill, service down → restart, connection refused → check config), STATE (corrupted cache → delete + restart, stale locks → remove lock file, git conflicts → resolve markers), IDEMPOTENCY (double-fire → add idempotencyGuard middleware, missing idempotency key → add X-Idempotency-Key header support, duplicate DB entries → add UNIQUE constraint or use db.idempotent()). The agent investigates before fixing — reads files, checks directories, inspects databases, never guesses.",
+    text: "Server problem categories the agent can fix: CODE BUGS (SyntaxError/TypeError/ReferenceError → edit_file). DEPENDENCIES (Cannot find module → npm install, corrupted node_modules → verify_node_modules then rm + reinstall). DATABASE (invalid entries → inspect_db then run_db_fix, schema issues → ALTER TABLE, pool exhaustion → inspect_cache for Redis). CONFIG (invalid JSON → edit_file, missing env vars → inspect_env to check then write .env, wrong port → edit config). FILESYSTEM (misplaced files → move_file, missing dirs → bash_exec mkdir, EACCES → chmod, ENOSPC → disk_cleanup). NETWORK (port conflict → check_port + kill, ECONNREFUSED → check_network for DNS/connectivity, Redis down → inspect_cache). SSL/TLS (CERT_EXPIRED → inspect_certificate for details, self-signed → check chain). MEMORY (OOM/SIGKILL → check_memory for pressure, EMFILE → check_file_descriptors, event loop block → check_event_loop scan). WEBSOCKET (1006/disconnect → check_websocket handshake test). STATE (corrupted cache → delete + restart_service, stale locks → remove lock file). The agent investigates before fixing — reads files, checks diagnostics, inspects databases, never guesses.",
     metadata: { topic: "server-problems" },
   },
   {

package/src/core/runner.js

@@ -211,6 +211,16 @@ class WolverineRunner {
       console.log(chalk.yellow(`  ⚠️  Vault init failed (non-fatal): ${err.message}`));
     }
 
+    // Scan server context (routes, DB, config, deps) for agent knowledge
+    try {
+      const { scan, load } = require("./server-context");
+      const ctx = scan(this.cwd);
+      if (ctx) {
+        const routes = ctx.routes.reduce((s, r) => s + r.endpoints.length, 0);
+        console.log(chalk.gray(`  🗺️  Server context: ${routes} routes, ${ctx.structure.length} files, ${ctx.envVars.length} env vars`));
+      }
+    } catch {}
+
     // Log redactor stats
     const redactorStats = this.redactor.getStats();
     console.log(chalk.gray(`  🔐 Secret redactor: ${redactorStats.trackedSecrets} secrets tracked from ${redactorStats.envFiles} env file(s)`));

package/src/core/server-context.js

@@ -0,0 +1,229 @@
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * Server Context Scanner — builds a structured map of the server/ directory.
+ *
+ * Scans routes, middleware, config, database, dependencies, and file structure
+ * to give the AI agent full context when diagnosing errors.
+ *
+ * Runs automatically on startup (stored in .wolverine/server-context.json).
+ * Can be triggered manually: wolverine --init or require('./server-context').scan(cwd)
+ *
+ * The context is injected into the agent's system prompt so it knows the
+ * server's structure without re-scanning on every heal.
+ */
+
+const CONTEXT_PATH = ".wolverine/server-context.json";
+const MAX_FILE_SCAN = 200; // don't scan more than 200 files
+const SKIP_DIRS = new Set(["node_modules", ".git", ".wolverine", "dist", ".next", ".cache", "coverage", "__pycache__"]);
+
+function scan(cwd) {
+  const serverDir = path.join(cwd, "server");
+  if (!fs.existsSync(serverDir)) return null;
+
+  const context = {
+    scannedAt: new Date().toISOString(),
+    routes: [],
+    middleware: [],
+    database: { tables: [], config: null },
+    config: {},
+    dependencies: {},
+    structure: [],
+    exports: [],
+    envVars: [],
+  };
+
+  // 1. Scan routes
+  const routesDir = path.join(serverDir, "routes");
+  if (fs.existsSync(routesDir)) {
+    for (const file of _listFiles(routesDir, ".js")) {
+      try {
+        const code = fs.readFileSync(file, "utf-8");
+        const relPath = path.relative(cwd, file);
+        const methods = [];
+        // Match fastify.get/post/put/delete/patch or app.get/post etc
+        const routeRegex = /(?:fastify|app|router)\.(get|post|put|delete|patch|options|head)\s*\(\s*['"`]([^'"`]+)/gi;
+        let m;
+        while ((m = routeRegex.exec(code)) !== null) {
+          methods.push({ method: m[1].toUpperCase(), path: m[2] });
+        }
+        // Match fastify.register with prefix
+        const registerRegex = /register\s*\(.*?prefix\s*:\s*['"`]([^'"`]+)/gi;
+        while ((m = registerRegex.exec(code)) !== null) {
+          methods.push({ method: "REGISTER", path: m[1] });
+        }
+        if (methods.length > 0) {
+          context.routes.push({ file: relPath, endpoints: methods });
+        }
+      } catch {}
+    }
+  }
+
+  // 2. Scan middleware
+  const indexFile = path.join(serverDir, "index.js");
+  if (fs.existsSync(indexFile)) {
+    try {
+      const code = fs.readFileSync(indexFile, "utf-8");
+      // Find app.use() or fastify.register() calls
+      const mwRegex = /(?:app\.use|fastify\.register)\s*\(\s*(?:require\s*\(\s*['"`]([^'"`]+)['"`]\s*\)|(\w+))/gi;
+      let m;
+      while ((m = mwRegex.exec(code)) !== null) {
+        context.middleware.push(m[1] || m[2]);
+      }
+    } catch {}
+  }
+
+  // 3. Scan database
+  const dbFiles = [
+    path.join(serverDir, "lib", "db.js"),
+    path.join(serverDir, "db.js"),
+    path.join(serverDir, "models", "index.js"),
+    path.join(serverDir, "database.js"),
+  ];
+  for (const dbFile of dbFiles) {
+    if (!fs.existsSync(dbFile)) continue;
+    try {
+      const code = fs.readFileSync(dbFile, "utf-8");
+      // Detect database type
+      if (/require\s*\(\s*['"]pg['"]/.test(code)) context.database.type = "postgresql";
+      else if (/require\s*\(\s*['"]better-sqlite3['"]/.test(code)) context.database.type = "sqlite";
+      else if (/require\s*\(\s*['"]mysql/.test(code)) context.database.type = "mysql";
+      else if (/require\s*\(\s*['"]mongoose['"]/.test(code)) context.database.type = "mongodb";
+      else if (/require\s*\(\s*['"]ioredis['"]/.test(code)) context.database.hasRedis = true;
+      // Find CREATE TABLE statements
+      const tableRegex = /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?["`]?(\w+)/gi;
+      let m;
+      while ((m = tableRegex.exec(code)) !== null) {
+        context.database.tables.push(m[1]);
+      }
+      context.database.config = path.relative(cwd, dbFile);
+    } catch {}
+  }
+
+  // 4. Scan config
+  const settingsPath = path.join(serverDir, "config", "settings.json");
+  if (fs.existsSync(settingsPath)) {
+    try {
+      const settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+      // Only include non-secret top-level keys
+      context.config = Object.keys(settings).reduce((acc, k) => {
+        if (typeof settings[k] === "object") acc[k] = Object.keys(settings[k]);
+        else acc[k] = typeof settings[k];
+        return acc;
+      }, {});
+    } catch {}
+  }
+
+  // 5. Dependencies
+  const pkgPath = path.join(cwd, "package.json");
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+      context.dependencies = {
+        production: Object.keys(pkg.dependencies || {}),
+        dev: Object.keys(pkg.devDependencies || {}),
+        optional: Object.keys(pkg.optionalDependencies || {}),
+      };
+      context.nodeVersion = pkg.engines?.node || "unknown";
+      context.version = pkg.version;
+    } catch {}
+  }
+
+  // 6. File structure (server/ tree)
+  const tree = [];
+  let fileCount = 0;
+  const walk = (dir, depth) => {
+    if (depth > 4 || fileCount > MAX_FILE_SCAN) return;
+    try {
+      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (SKIP_DIRS.has(entry.name)) continue;
+        const rel = path.relative(cwd, path.join(dir, entry.name));
+        if (entry.isDirectory()) {
+          tree.push(rel + "/");
+          walk(path.join(dir, entry.name), depth + 1);
+        } else {
+          tree.push(rel);
+          fileCount++;
+        }
+      }
+    } catch {}
+  };
+  walk(serverDir, 0);
+  context.structure = tree;
+
+  // 7. Env vars used (scan for process.env.X patterns)
+  const envVars = new Set();
+  const scanForEnv = (dir) => {
+    if (!fs.existsSync(dir)) return;
+    for (const file of _listFiles(dir, ".js")) {
+      try {
+        const code = fs.readFileSync(file, "utf-8");
+        const envRegex = /process\.env\.([A-Z_][A-Z0-9_]*)/g;
+        let m;
+        while ((m = envRegex.exec(code)) !== null) envVars.add(m[1]);
+      } catch {}
+    }
+  };
+  scanForEnv(serverDir);
+  context.envVars = [...envVars].sort();
+
+  // Save
+  const outPath = path.join(cwd, CONTEXT_PATH);
+  fs.mkdirSync(path.dirname(outPath), { recursive: true });
+  fs.writeFileSync(outPath, JSON.stringify(context, null, 2), "utf-8");
+
+  return context;
+}
+
+/**
+ * Load cached context (fast — no rescan).
+ */
+function load(cwd) {
+  const ctxPath = path.join(cwd, CONTEXT_PATH);
+  if (!fs.existsSync(ctxPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(ctxPath, "utf-8"));
+  } catch { return null; }
+}
+
+/**
+ * Get a compact text summary for injecting into AI prompts.
+ */
+function getSummary(cwd) {
+  const ctx = load(cwd);
+  if (!ctx) return "";
+
+  const lines = [];
+  if (ctx.routes.length > 0) {
+    const allEndpoints = ctx.routes.flatMap(r => r.endpoints.map(e => `${e.method} ${e.path}`));
+    lines.push(`Routes (${allEndpoints.length}): ${allEndpoints.slice(0, 20).join(", ")}${allEndpoints.length > 20 ? ` +${allEndpoints.length - 20} more` : ""}`);
+  }
+  if (ctx.middleware.length > 0) lines.push(`Middleware: ${ctx.middleware.join(", ")}`);
+  if (ctx.database.type) lines.push(`Database: ${ctx.database.type}${ctx.database.tables.length > 0 ? ` (tables: ${ctx.database.tables.join(", ")})` : ""}${ctx.database.hasRedis ? " + Redis" : ""}`);
+  if (ctx.envVars.length > 0) lines.push(`Env vars used: ${ctx.envVars.slice(0, 15).join(", ")}${ctx.envVars.length > 15 ? ` +${ctx.envVars.length - 15} more` : ""}`);
+  if (ctx.structure.length > 0) lines.push(`Server files: ${ctx.structure.length}`);
+  if (ctx.version) lines.push(`Version: ${ctx.version}`);
+
+  return lines.length > 0 ? "SERVER CONTEXT:\n" + lines.join("\n") : "";
+}
+
+function _listFiles(dir, ext) {
+  const results = [];
+  let count = 0;
+  const walk = (d) => {
+    if (count > MAX_FILE_SCAN) return;
+    try {
+      for (const entry of fs.readdirSync(d, { withFileTypes: true })) {
+        if (SKIP_DIRS.has(entry.name)) continue;
+        const full = path.join(d, entry.name);
+        if (entry.isDirectory()) walk(full);
+        else if (!ext || entry.name.endsWith(ext)) { results.push(full); count++; }
+      }
+    } catch {}
+  };
+  walk(dir);
+  return results;
+}
+
+module.exports = { scan, load, getSummary, CONTEXT_PATH };

package/src/core/wolverine.js

@@ -208,6 +208,12 @@ async function _healImpl({ stderr, cwd, sandbox, notifier, rateLimiter, backupMa
   }
 
   let brainContext = "";
+  // Inject server context (routes, DB, config, deps) if available
+  try {
+    const { getSummary } = require("./server-context");
+    const serverCtx = getSummary(cwd);
+    if (serverCtx) brainContext += serverCtx + "\n\n";
+  } catch {}
   // Inject relevant skill context (claw-code: pre-enrich prompt with matched tools)
   if (skills) {
     const skillCtx = skills.buildContext(parsed.errorMessage);