blitzstrike 2.4.57 → 2.4.59

package/CHANGELOG.md

@@ -5,6 +5,40 @@ All notable changes to Blitz Strike are documented here.
 The format follows [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/).
 
+## [2.4.59] — 2026-09-14
+
+### Added — Severity calibration + engagement scaffold + data health
+
+- New `severity_calibrate` MCP tool (src/severity.ts): maps a detector type to a
+  platform-neutral priority tier (P1–P5) + a VRT-style category + rationale, with
+  an optional CVSS cross-reference — a finding is reported at the severity a triager
+  would assign, not the detector's raw default.
+- New `engagement_scaffold` MCP tool: opens an engagement and emits a deterministic
+  folder layout (scope.md, findings/, evidence/, reports/, notes/) + a pre-filled
+  scope.md template, so a hunt starts with structure instead of improvisation.
+- New `data_refresh` MCP tool (src/datarefresh.ts): re-loads every data layer
+  (chains, patterns, CWE map) and verifies cross-references, surfacing stale/broken
+  data instead of silently producing bad grounding.
+- System prompt updated to drive the full grounding→gate→calibrate→scaffold flow.
+
+## [2.4.58] — 2026-09-14
+
+### Added — Empirical grounding v1 (pattern library + submission gate)
+
+- New `intelligence/patterns.json` — the empirical grounding layer: all 16 detector
+  types are traced to their CWE, real-world signature, the escalation chains they
+  compose into (cross-ref chains.json), and citable references (CWE/OWASP). Detection
+  is now derived from disclosed-report-class knowledge, not abstract heuristics alone.
+- New `src/patterns.ts` + `pattern_lookup` MCP tool — returns a detector hit's empirical
+  grounding (CWE, real-world signature, chains, references) to turn a raw hit into a
+  class-aware finding.
+- New `submission_gate` MCP tool — a deterministic 7-question gate (reproducible,
+  in-scope, real-impact, no-privileged-assumption, verified-live, evidence-redacted,
+  severity-derived); one false = the finding does not ship. Formally enforces
+  "never report unverified".
+- Inventory self-test extended: every detector type must be empirically grounded in
+  patterns.json AND CWE-mapped (drift fails at build time).
+
 ## [2.4.57] — 2026-09-14
 
 ### Added — Secret detection v2 (single taxonomy + format + entropy tiers)

package/dist/index.js

@@ -15490,10 +15490,10 @@ async function checkMcpServers() {
 var init_mcp_status = () => {};
 
 // src/sync.ts
-import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync8, readFileSync as readFileSync22, readdirSync as readdirSync7, statSync as statSync4, rmSync as rmSync4 } from "node:fs";
-import { join as join19 } from "node:path";
+import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync8, readFileSync as readFileSync24, readdirSync as readdirSync7, statSync as statSync4, rmSync as rmSync4 } from "node:fs";
+import { join as join21 } from "node:path";
 import { homedir as homedir10 } from "node:os";
-import { fileURLToPath as fileURLToPath9 } from "node:url";
+import { fileURLToPath as fileURLToPath11 } from "node:url";
 import { spawnSync as spawnSync4 } from "node:child_process";
 function dirExists(p) {
   try {
@@ -15508,7 +15508,7 @@ function countFiles(dir) {
     const walk = (d) => {
       for (const e of readdirSync7(d, { withFileTypes: true })) {
         if (e.isDirectory())
-          walk(join19(d, e.name));
+          walk(join21(d, e.name));
         else
           n++;
       }
@@ -15522,8 +15522,8 @@ function countFiles(dir) {
 function syncData() {
   if (!dirExists(DATA_ROOT2))
     mkdirSync9(DATA_ROOT2, { recursive: true });
-  const payloadsPath = join19(DATA_ROOT2, "payloads");
-  const templatesPath = join19(DATA_ROOT2, "templates");
+  const payloadsPath = join21(DATA_ROOT2, "payloads");
+  const templatesPath = join21(DATA_ROOT2, "templates");
   const hasPayloads = dirExists(payloadsPath) && countFiles(payloadsPath) > 0;
   const hasTemplates = dirExists(templatesPath) && countFiles(templatesPath) > 0;
   if (hasPayloads && hasTemplates) {
@@ -15533,8 +15533,8 @@ function syncData() {
       data_root: DATA_ROOT2
     };
   }
-  const localPayloads = join19(ROOT7, "payloads");
-  const localTemplates = join19(ROOT7, "templates");
+  const localPayloads = join21(ROOT7, "payloads");
+  const localTemplates = join21(ROOT7, "templates");
   let payloadsSynced = false;
   let templatesSynced = false;
   if (!hasPayloads && dirExists(localPayloads)) {
@@ -15547,7 +15547,7 @@ function syncData() {
   }
   const gitOk = spawnSync4("git", ["--version"]).status === 0;
   if (gitOk && (!dirExists(payloadsPath) || countFiles(payloadsPath) === 0 || !dirExists(templatesPath) || countFiles(templatesPath) === 0)) {
-    const tmp = join19(DATA_ROOT2, ".tmp-clone");
+    const tmp = join21(DATA_ROOT2, ".tmp-clone");
     if (dirExists(tmp))
       rmSync4(tmp, { recursive: true, force: true });
     const r = spawnSync4("git", ["clone", "--depth", "1", "--filter=blob:none", "--sparse", GITHUB_REPO, tmp], { timeout: 120000 });
@@ -15555,11 +15555,11 @@ function syncData() {
       const sparse = spawnSync4("git", ["-C", tmp, "sparse-checkout", "set", "payloads", "templates"], { timeout: 120000 });
       if (sparse.status === 0) {
         if (!dirExists(payloadsPath) || countFiles(payloadsPath) === 0) {
-          copyDir(join19(tmp, "payloads"), payloadsPath);
+          copyDir(join21(tmp, "payloads"), payloadsPath);
           payloadsSynced = true;
         }
         if (!dirExists(templatesPath) || countFiles(templatesPath) === 0) {
-          copyDir(join19(tmp, "templates"), templatesPath);
+          copyDir(join21(tmp, "templates"), templatesPath);
           templatesSynced = true;
         }
       }
@@ -15581,18 +15581,18 @@ function copyDir(src, dst) {
 function manualCopy(src, dst) {
   mkdirSync9(dst, { recursive: true });
   for (const e of readdirSync7(src, { withFileTypes: true })) {
-    const s = join19(src, e.name);
-    const d = join19(dst, e.name);
+    const s = join21(src, e.name);
+    const d = join21(dst, e.name);
     if (e.isDirectory())
       manualCopy(s, d);
     else
-      writeFileSync8(d, readFileSync22(s));
+      writeFileSync8(d, readFileSync24(s));
   }
 }
 var ROOT7, DATA_ROOT2, GITHUB_REPO = "https://github.com/shinthink/blitzstrike.git";
 var init_sync = __esm(() => {
-  ROOT7 = join19(fileURLToPath9(new URL(".", import.meta.url)), "..");
-  DATA_ROOT2 = process.env.BLITZSTRIKE_DATA ?? join19(homedir10(), ".blitzstrike", "data");
+  ROOT7 = join21(fileURLToPath11(new URL(".", import.meta.url)), "..");
+  DATA_ROOT2 = process.env.BLITZSTRIKE_DATA ?? join21(homedir10(), ".blitzstrike", "data");
 });
 
 // src/update.ts
@@ -15637,15 +15637,15 @@ var init_update = __esm(() => {
 });
 
 // src/release.ts
-import { readFileSync as readFileSync24, existsSync as existsSync12 } from "node:fs";
-import { join as join20 } from "node:path";
-import { fileURLToPath as fileURLToPath10 } from "node:url";
+import { readFileSync as readFileSync26, existsSync as existsSync12 } from "node:fs";
+import { join as join22 } from "node:path";
+import { fileURLToPath as fileURLToPath12 } from "node:url";
 import { execSync as execSync2 } from "node:child_process";
 function validateRelease() {
   const checks = [];
   checks.push({ name: "package.json version", ok: true, detail: VERSION });
   try {
-    const changelog = readFileSync24(join20(ROOT8, "CHANGELOG.md"), "utf8");
+    const changelog = readFileSync26(join22(ROOT8, "CHANGELOG.md"), "utf8");
     const m = changelog.match(/^##\s+\[([0-9]+\.[0-9]+\.[0-9]+)\]/m);
     const changelogVersion = m?.[1] ?? null;
     checks.push({
@@ -15677,22 +15677,22 @@ function validateRelease() {
   return { version: VERSION, checks, consistent: checks.filter((c) => !c.soft).every((c) => c.ok) };
 }
 function lockfilePresent() {
-  return existsSync12(join20(ROOT8, "package-lock.json")) || existsSync12(join20(ROOT8, "bun.lock")) || existsSync12(join20(ROOT8, "bun.lockb"));
+  return existsSync12(join22(ROOT8, "package-lock.json")) || existsSync12(join22(ROOT8, "bun.lock")) || existsSync12(join22(ROOT8, "bun.lockb"));
 }
 var ROOT8;
 var init_release = __esm(() => {
   init_version();
-  ROOT8 = join20(fileURLToPath10(new URL(".", import.meta.url)), "..");
+  ROOT8 = join22(fileURLToPath12(new URL(".", import.meta.url)), "..");
 });
 
 // src/dependency.ts
-import { readFileSync as readFileSync25 } from "node:fs";
-import { join as join21 } from "node:path";
-import { fileURLToPath as fileURLToPath11 } from "node:url";
+import { readFileSync as readFileSync27 } from "node:fs";
+import { join as join23 } from "node:path";
+import { fileURLToPath as fileURLToPath13 } from "node:url";
 function checkDependencies() {
   let pkg = {};
   try {
-    pkg = JSON.parse(readFileSync25(join21(ROOT9, "package.json"), "utf8"));
+    pkg = JSON.parse(readFileSync27(join23(ROOT9, "package.json"), "utf8"));
   } catch {
     return { install_scripts: [], git_dependencies: [], total_dependencies: 0, safe: false };
   }
@@ -15715,14 +15715,14 @@ function checkDependencies() {
 }
 var ROOT9;
 var init_dependency = __esm(() => {
-  ROOT9 = join21(fileURLToPath11(new URL(".", import.meta.url)), "..");
+  ROOT9 = join23(fileURLToPath13(new URL(".", import.meta.url)), "..");
 });
 
 // src/cli.ts
-import { readFileSync as readFileSync26, existsSync as existsSync13, writeFileSync as writeFileSync9, mkdirSync as mkdirSync10 } from "node:fs";
-import { join as join22, dirname as dirname2 } from "node:path";
+import { readFileSync as readFileSync28, existsSync as existsSync13, writeFileSync as writeFileSync9, mkdirSync as mkdirSync10 } from "node:fs";
+import { join as join24, dirname as dirname4 } from "node:path";
 import { homedir as homedir11 } from "node:os";
-import { fileURLToPath as fileURLToPath12 } from "node:url";
+import { fileURLToPath as fileURLToPath14 } from "node:url";
 import { spawnSync as spawnSync5 } from "node:child_process";
 function which(cmd) {
   return spawnSync5("sh", ["-c", 'command -v "$1" >/dev/null 2>&1', "sh", cmd]).status === 0;
@@ -15765,7 +15765,7 @@ async function runDoctor() {
     detail: h1 ? `X-HackerOne-Research: ${h1}` : "H1_USERNAME not set",
     fix: h1 ? undefined : "export H1_USERNAME=<your-hackerone-username> (adds X-HackerOne-Research to outbound requests)"
   });
-  const dataOk = existsSync13(join22(ROOT10, "chains.json")) && existsSync13(join22(ROOT10, "tools-catalog.json"));
+  const dataOk = existsSync13(join24(ROOT10, "chains.json")) && existsSync13(join24(ROOT10, "tools-catalog.json"));
   issues.push({
     name: "Data layers (chains + tools-catalog)",
     status: dataOk ? "ok" : "fail",
@@ -15816,28 +15816,28 @@ BlitzStrike — ${verdict}`);
 function resolveCommand() {
   if (which("blitzstrike"))
     return { command: "blitzstrike", args: ["serve", "--mcp"] };
-  const src = join22(ROOT10, "src", "index.ts");
+  const src = join24(ROOT10, "src", "index.ts");
   if (which("bun") && existsSync13(src))
     return { command: "bun", args: ["run", src, "serve", "--mcp"] };
   if (which("npx"))
     return { command: "npx", args: ["-y", "blitzstrike", "serve", "--mcp"] };
   if (which("bunx"))
     return { command: "bunx", args: ["blitzstrike", "serve", "--mcp"] };
-  const dist = join22(ROOT10, "dist", "index.js");
+  const dist = join24(ROOT10, "dist", "index.js");
   if (existsSync13(dist))
     return { command: "bun", args: [dist, "serve", "--mcp"] };
   return { command: "npx", args: ["-y", "blitzstrike", "serve", "--mcp"] };
 }
 function readJson(p) {
   try {
-    return JSON.parse(readFileSync26(p, "utf8"));
+    return JSON.parse(readFileSync28(p, "utf8"));
   } catch {
     return null;
   }
 }
 function jsonMcpServersWrite(p) {
   return (command, args) => {
-    const dir = dirname2(p);
+    const dir = dirname4(p);
     if (!existsSync13(dir))
       mkdirSync10(dir, { recursive: true });
     const existing = readJson(p) ?? {};
@@ -15850,7 +15850,7 @@ function jsonMcpServersWrite(p) {
 }
 function opencodeWrite(p) {
   return (command, args) => {
-    const dir = dirname2(p);
+    const dir = dirname4(p);
     if (!existsSync13(dir))
       mkdirSync10(dir, { recursive: true });
     const existing = readJson(p) ?? {};
@@ -15863,26 +15863,26 @@ function opencodeWrite(p) {
   };
 }
 function copyOpenCodeAgents() {
-  const srcDir = join22(ROOT10, "opencode-agents");
-  const dstDir = join22(homedir11(), ".config", "opencode", "agents");
+  const srcDir = join24(ROOT10, "opencode-agents");
+  const dstDir = join24(homedir11(), ".config", "opencode", "agents");
   if (!existsSync13(srcDir))
     return;
   if (!existsSync13(dstDir))
     mkdirSync10(dstDir, { recursive: true });
   for (const f of ["Blitz Strike.md", "Blitz.md", "Eagle Eye.md", "Strike.md"]) {
-    const src = join22(srcDir, f);
-    const dst = join22(dstDir, f);
+    const src = join24(srcDir, f);
+    const dst = join24(dstDir, f);
     if (existsSync13(src)) {
-      writeFileSync9(dst, readFileSync26(src, "utf8"));
+      writeFileSync9(dst, readFileSync28(src, "utf8"));
     }
   }
 }
 function codexWrite(p) {
   return (command, args) => {
-    const dir = dirname2(p);
+    const dir = dirname4(p);
     if (!existsSync13(dir))
       mkdirSync10(dir, { recursive: true });
-    let existing = existsSync13(p) ? readFileSync26(p, "utf8") : "";
+    let existing = existsSync13(p) ? readFileSync28(p, "utf8") : "";
     if (!existing.trimEnd().endsWith(`
 `))
       existing += `
@@ -15898,10 +15898,10 @@ args = ${JSON.stringify(args)}
 }
 function hermesWrite(p) {
   return (command, args) => {
-    const dir = dirname2(p);
+    const dir = dirname4(p);
     if (!existsSync13(dir))
       mkdirSync10(dir, { recursive: true });
-    let existing = existsSync13(p) ? readFileSync26(p, "utf8") : "";
+    let existing = existsSync13(p) ? readFileSync28(p, "utf8") : "";
     existing = existing.replace(/^  blitzstrike:\n(?:    .*\n?)*/m, "");
     if (!existing.trimEnd().endsWith(`
 `))
@@ -15928,74 +15928,74 @@ mcp_servers:
 function detectAgents() {
   const home = homedir11();
   const agents = [];
-  const claudeJson = join22(home, ".claude.json");
+  const claudeJson = join24(home, ".claude.json");
   agents.push({
     name: "Claude Code",
     detectPath: claudeJson,
     installed: () => existsSync13(claudeJson) || which("claude"),
     write: jsonMcpServersWrite(claudeJson)
   });
-  const claudeDesktop = join22(home, ".config", "Claude", "claude_desktop_config.json");
+  const claudeDesktop = join24(home, ".config", "Claude", "claude_desktop_config.json");
   agents.push({
     name: "Claude Desktop",
     detectPath: claudeDesktop,
     installed: () => existsSync13(claudeDesktop),
     write: jsonMcpServersWrite(claudeDesktop)
   });
-  const cursor = join22(home, ".cursor", "mcp.json");
+  const cursor = join24(home, ".cursor", "mcp.json");
   agents.push({
     name: "Cursor",
     detectPath: cursor,
-    installed: () => existsSync13(join22(home, ".cursor")) || which("cursor"),
+    installed: () => existsSync13(join24(home, ".cursor")) || which("cursor"),
     write: jsonMcpServersWrite(cursor)
   });
-  const opencode = join22(home, ".config", "opencode", "opencode.jsonc");
+  const opencode = join24(home, ".config", "opencode", "opencode.jsonc");
   agents.push({
     name: "OpenCode",
     detectPath: opencode,
-    installed: () => existsSync13(join22(home, ".config", "opencode")) || which("opencode"),
+    installed: () => existsSync13(join24(home, ".config", "opencode")) || which("opencode"),
     write: opencodeWrite(opencode)
   });
-  const codex = join22(home, ".codex", "config.toml");
+  const codex = join24(home, ".codex", "config.toml");
   agents.push({
     name: "Codex",
     detectPath: codex,
-    installed: () => existsSync13(join22(home, ".codex")) || which("codex"),
+    installed: () => existsSync13(join24(home, ".codex")) || which("codex"),
     write: codexWrite(codex)
   });
-  const hermes = join22(home, ".hermes", "config.yaml");
+  const hermes = join24(home, ".hermes", "config.yaml");
   agents.push({
     name: "Hermes",
     detectPath: hermes,
-    installed: () => existsSync13(join22(home, ".hermes")) || which("hermes"),
+    installed: () => existsSync13(join24(home, ".hermes")) || which("hermes"),
     write: hermesWrite(hermes)
   });
-  const gemini = join22(home, ".gemini", "settings.json");
+  const gemini = join24(home, ".gemini", "settings.json");
   agents.push({
     name: "Gemini CLI",
     detectPath: gemini,
-    installed: () => existsSync13(join22(home, ".gemini")) || which("gemini"),
+    installed: () => existsSync13(join24(home, ".gemini")) || which("gemini"),
     write: jsonMcpServersWrite(gemini)
   });
-  const windsurf = join22(home, ".codeium", "windsurf", "mcp_config.json");
+  const windsurf = join24(home, ".codeium", "windsurf", "mcp_config.json");
   agents.push({
     name: "Windsurf",
     detectPath: windsurf,
-    installed: () => existsSync13(join22(home, ".codeium")) || which("windsurf"),
+    installed: () => existsSync13(join24(home, ".codeium")) || which("windsurf"),
     write: jsonMcpServersWrite(windsurf)
   });
-  const copilot = join22(home, ".copilot", "mcp.json");
+  const copilot = join24(home, ".copilot", "mcp.json");
   agents.push({
     name: "Copilot",
     detectPath: copilot,
-    installed: () => existsSync13(join22(home, ".copilot")),
+    installed: () => existsSync13(join24(home, ".copilot")),
     write: jsonMcpServersWrite(copilot)
   });
-  const cline = join22(home, ".cline", "mcp_settings.json");
+  const cline = join24(home, ".cline", "mcp_settings.json");
   agents.push({
     name: "Cline",
     detectPath: cline,
-    installed: () => existsSync13(join22(home, ".cline")),
+    installed: () => existsSync13(join24(home, ".cline")),
     write: jsonMcpServersWrite(cline)
   });
   return agents;
@@ -16113,7 +16113,7 @@ var init_cli = __esm(() => {
   init_release();
   init_dependency();
   init_mcp_status();
-  ROOT10 = join22(fileURLToPath12(new URL(".", import.meta.url)), "..");
+  ROOT10 = join24(fileURLToPath14(new URL(".", import.meta.url)), "..");
 });
 
 // node_modules/zod/v3/helpers/util.js
@@ -30751,7 +30751,7 @@ class StdioServerTransport {
 
 // src/server.ts
 init_scanner();
-import { readFileSync as readFileSync23 } from "node:fs";
+import { readFileSync as readFileSync25 } from "node:fs";
 
 // src/recon.ts
 var TIMEOUT_MS = 25000;
@@ -35526,6 +35526,41 @@ function engagementStatus() {
     next_phase: next
   };
 }
+function scaffoldEngagement(target, scope = [], out_of_scope = []) {
+  const state = startEngagement(target, "live");
+  const scopeLines = (scope.length ? scope : [target]).map((s) => `- ${s}`).join(`
+`);
+  const oosLines = (out_of_scope.length ? out_of_scope : ["(none declared)"]).map((s) => `- ${s}`).join(`
+`);
+  const scopeMd = [
+    `# Engagement scope`,
+    ``,
+    `**Target:** ${target}`,
+    ``,
+    `## In scope`,
+    scopeLines,
+    ``,
+    `## Out of scope`,
+    oosLines,
+    ``,
+    `## Accepted impact classes`,
+    `- (paste the program's vulnerability-type / accepted-impact list here)`,
+    ``,
+    `## Testing rules`,
+    `- (paste rate limits, prohibited areas, and any special rules here)`,
+    ``
+  ].join(`
+`);
+  return {
+    id: state.id,
+    target,
+    scope,
+    out_of_scope,
+    structure: ["scope.md", "findings/", "evidence/", "reports/", "notes/"],
+    scope_md: scopeMd,
+    state
+  };
+}
 
 // src/incremental.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
@@ -57195,18 +57230,181 @@ function nextSteps(ctx) {
   return steps;
 }
 
-// src/benchmark.ts
-import { readFileSync as readFileSync17, readdirSync as readdirSync5, writeFileSync as writeFileSync6, rmSync as rmSync3, mkdirSync as mkdirSync7 } from "node:fs";
-import { join as join16 } from "node:path";
+// src/patterns.ts
+import { readFileSync as readFileSync17 } from "node:fs";
+import { join as join16, dirname as dirname2 } from "node:path";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
+var __dirname2 = dirname2(fileURLToPath8(import.meta.url));
+var _doc = null;
+function load3() {
+  if (_doc)
+    return _doc;
+  try {
+    _doc = JSON.parse(readFileSync17(join16(__dirname2, "..", "intelligence", "patterns.json"), "utf8"));
+  } catch {
+    _doc = { patterns: [] };
+  }
+  return _doc;
+}
+function patternLookup(id) {
+  const p = load3().patterns.find((x) => x.id === id.toLowerCase());
+  return p ?? null;
+}
+function listPatterns() {
+  return load3().patterns;
+}
+function submissionGate(input) {
+  const questions = [
+    {
+      q: "Reproducible — a copy-paste-ready request or step list triggers it?",
+      pass: input.reproducible !== false,
+      reason: "Without an exact reproduction the finding is a hypothesis, not a result."
+    },
+    {
+      q: "In scope — the vulnerable asset is in the engagement scope?",
+      pass: input.in_scope !== false,
+      reason: "Out-of-scope assets must not be submitted."
+    },
+    {
+      q: "Real impact — maps to an accepted-impact class, not informational?",
+      pass: input.real_impact !== false,
+      reason: "Informational-only findings dilute the validity ratio."
+    },
+    {
+      q: "No privileged assumption — works without unrealistic attacker prerequisites?",
+      pass: input.no_privileged_assumption !== false,
+      reason: "'Admin can do X' is a centralization risk, not a vulnerability."
+    },
+    {
+      q: "Verified live — confirmed with a marker + negative control, not just a static hint?",
+      pass: input.verified_live !== false,
+      reason: "A static hit is a hypothesis until verified live (strike_verify / browser_validate)."
+    },
+    {
+      q: "Evidence attached AND redacted — secrets/PII stripped, integrity-tagged?",
+      pass: input.evidence_redacted !== false,
+      reason: "Evidence must carry SHA-256-tagged, redacted records — no leaked secrets or victim PII."
+    },
+    {
+      q: "Severity derived — CVSS/confidence computed, not guessed?",
+      pass: input.severity_derived !== false,
+      reason: "Severity is not confidence; derive it, don't assert it."
+    }
+  ];
+  const failed = questions.find((q) => !q.pass);
+  return {
+    verdict: failed ? "fail" : "pass",
+    passed: questions.filter((q) => q.pass).length,
+    total: questions.length,
+    questions,
+    ...failed ? { blocker: failed.q } : {}
+  };
+}
+
+// src/severity.ts
+var VRT_MAP = {
+  sql_injection: { vrt: "injection > sql_injection", priority: "P1", severity: "critical", rationale: "SQL injection reaches sensitive data or enables admin takeover." },
+  ssti: { vrt: "injection > server_side_template_injection", priority: "P1", severity: "critical", rationale: "SSTI evaluates expressions server-side → code execution." },
+  deserialization: { vrt: "injection > insecure_deserialization", priority: "P1", severity: "critical", rationale: "Deserialization escalated via a gadget chain → code execution." },
+  xxe: { vrt: "injection > xml_external_entity", priority: "P1", severity: "critical", rationale: "XXE reads local files or reaches internal services." },
+  file_upload: { vrt: "insecure_design > unrestricted_file_upload", priority: "P1", severity: "critical", rationale: "A web-reachable uploaded file of an executable type → code execution." },
+  priv_esc: { vrt: "broken_access_control > privilege_escalation", priority: "P1", severity: "critical", rationale: "A user self-assigns an elevated role → full account/tenant takeover." },
+  path_confusion: { vrt: "broken_access_control > path_traversal", priority: "P2", severity: "high", rationale: "Path traversal reads files or writes outside the intended directory; P1 if it reaches an RCE chain." },
+  ssrf: { vrt: "insecure_design > server_side_request_forgery", priority: "P2", severity: "high", rationale: "SSRF reaches internal services; P1 when it hits cloud metadata and exfiltrates credentials." },
+  mass_assignment: { vrt: "broken_access_control > mass_assignment", priority: "P2", severity: "high", rationale: "Attacker sets a privileged field (role/is_admin) → privilege escalation." },
+  missing_authz: { vrt: "broken_access_control > missing_authorization", priority: "P2", severity: "high", rationale: "A state-changing action lacks a capability/ownership check." },
+  type_juggling: { vrt: "authentication > authentication_bypass", priority: "P2", severity: "high", rationale: "Loose comparison collapses a hash/secret → authentication bypass." },
+  hardcoded_secret: { vrt: "sensitive_data_exposure > hardcoded_credentials", priority: "P2", severity: "high", rationale: "A committed credential is usable by anyone with repo access → account/cloud takeover." },
+  prototype_pollution: { vrt: "injection > prototype_pollution", priority: "P2", severity: "high", rationale: "Object prototype corruption can escalate to code execution in gadget-heavy runtimes." },
+  crlf_injection: { vrt: "injection > crlf_injection", priority: "P3", severity: "medium", rationale: "Header injection enables cookie poisoning or cache poisoning." },
+  missing_nonce: { vrt: "broken_access_control > cross_site_request_forgery", priority: "P3", severity: "medium", rationale: "A state-changing action lacks an anti-CSRF token." },
+  wrong_sanitizer: { vrt: "injection > improper_input_validation", priority: "P3", severity: "medium", rationale: "A value sanitized for the wrong context still reaches the sink; severity follows the sink." }
+};
+function severityCalibrate(input) {
+  const type = input.type?.toLowerCase() ?? "";
+  const entry = VRT_MAP[type];
+  if (input.informational) {
+    return {
+      type,
+      vrt_category: "informational",
+      priority: "P5",
+      severity: "informational",
+      rationale: "Marked informational — excluded from the validity ratio.",
+      ...input.cvss != null ? { cvss_severity: cvssSeverity(input.cvss) } : {}
+    };
+  }
+  if (!entry) {
+    return {
+      type,
+      vrt_category: "unclassified",
+      priority: "P4",
+      severity: "low",
+      rationale: `No VRT mapping for '${type}'; defaulting to low until classified.`,
+      ...input.cvss != null ? { cvss_severity: cvssSeverity(input.cvss) } : {}
+    };
+  }
+  return {
+    type,
+    vrt_category: entry.vrt,
+    priority: entry.priority,
+    severity: entry.severity,
+    rationale: entry.rationale,
+    ...input.cvss != null ? { cvss_severity: cvssSeverity(input.cvss) } : {}
+  };
+}
+function listSeverityMap() {
+  return Object.entries(VRT_MAP).map(([type, e]) => ({ type, priority: e.priority, vrt: e.vrt }));
+}
+
+// src/datarefresh.ts
+import { readFileSync as readFileSync18 } from "node:fs";
+import { join as join17, dirname as dirname3 } from "node:path";
+import { fileURLToPath as fileURLToPath9 } from "node:url";
+var __dirname3 = dirname3(fileURLToPath9(import.meta.url));
+function loadJson2(rel) {
+  try {
+    return JSON.parse(readFileSync18(join17(__dirname3, "..", rel), "utf8"));
+  } catch {
+    return null;
+  }
+}
+function dataRefresh() {
+  const chains = loadJson2("chains.json");
+  const patterns = loadJson2("intelligence/patterns.json");
+  const cwe = loadJson2("intelligence/cwe_map.json");
+  const chainList = chains?.chains ?? [];
+  const patternList = patterns?.patterns ?? [];
+  const cweList = cwe?.mapping ?? [];
+  const chainIds = new Set(chainList.map((c) => c.id));
+  const cweIds = new Set(cweList.map((m) => m.id));
+  const brokenChainRefs = patternList.flatMap((p) => (p.chain_templates ?? []).filter((c) => !chainIds.has(c)).map((c) => `${p.id} -> ${c}`));
+  const missingCwe = patternList.map((p) => p.id).filter((id) => !cweIds.has(id));
+  return {
+    layers: {
+      chains: chainIds.size,
+      patterns: patternList.length,
+      cwe: cweIds.size
+    },
+    consistency: {
+      ok: brokenChainRefs.length === 0 && missingCwe.length === 0,
+      broken_chain_refs: brokenChainRefs,
+      missing_cwe: missingCwe
+    }
+  };
+}
+
+// src/benchmark.ts
+import { readFileSync as readFileSync19, readdirSync as readdirSync5, writeFileSync as writeFileSync6, rmSync as rmSync3, mkdirSync as mkdirSync7 } from "node:fs";
+import { join as join18 } from "node:path";
+import { fileURLToPath as fileURLToPath10 } from "node:url";
 import { tmpdir as tmpdir3, homedir as homedir8 } from "node:os";
-var ROOT5 = join16(fileURLToPath8(new URL(".", import.meta.url)), "..");
-var CORPUS = join16(ROOT5, "bench", "corpus");
-var CAPTURED_CORPUS_DIR = process.env.BLITZSTRIKE_CORPUS_DIR ?? join16(homedir8(), ".blitzstrike", "corpus");
+var ROOT5 = join18(fileURLToPath10(new URL(".", import.meta.url)), "..");
+var CORPUS = join18(ROOT5, "bench", "corpus");
+var CAPTURED_CORPUS_DIR = process.env.BLITZSTRIKE_CORPUS_DIR ?? join18(homedir8(), ".blitzstrike", "corpus");
 function parseCorpusFile(path) {
   let text;
   try {
-    text = readFileSync17(path, "utf8");
+    text = readFileSync19(path, "utf8");
   } catch {
     return null;
   }
@@ -57262,7 +57460,7 @@ function loadDir(dir) {
     for (const f of readdirSync5(dir)) {
       if (!f.endsWith(".md"))
         continue;
-      const e = parseCorpusFile(join16(dir, f));
+      const e = parseCorpusFile(join18(dir, f));
       if (e)
         entries.push(e);
     }
@@ -57289,7 +57487,7 @@ function captureFalsePositive(input) {
     input.code,
     "```"
   ].filter((l) => l !== null);
-  const path = join16(CAPTURED_CORPUS_DIR, `${id}.md`);
+  const path = join18(CAPTURED_CORPUS_DIR, `${id}.md`);
   writeFileSync6(path, lines.join(`
 `) + `
 `, "utf8");
@@ -57311,7 +57509,7 @@ function detect(entry) {
   }
   const lang = entry.language;
   if (lang === "php") {
-    const tmp = join16(tmpdir3(), `blitzstrike-bench-${entry.id}-${process.pid}.php`);
+    const tmp = join18(tmpdir3(), `blitzstrike-bench-${entry.id}-${process.pid}.php`);
     writeFileSync6(tmp, entry.code);
     const r = analyzeDataFlow2(tmp);
     rmSync3(tmp, { force: true });
@@ -57380,12 +57578,12 @@ function runBenchmark() {
 }
 
 // src/obligations.ts
-import { readFileSync as readFileSync18, appendFileSync as appendFileSync4, mkdirSync as mkdirSync8, existsSync as existsSync10, writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join17 } from "node:path";
+import { readFileSync as readFileSync20, appendFileSync as appendFileSync4, mkdirSync as mkdirSync8, existsSync as existsSync10, writeFileSync as writeFileSync7 } from "node:fs";
+import { join as join19 } from "node:path";
 import { createHash as createHash6 } from "node:crypto";
 import { homedir as homedir9 } from "node:os";
-var HOME_DIR4 = process.env.BLITZSTRIKE_HOME ?? join17(homedir9(), ".blitzstrike");
-var OBLIGATION_PATH = join17(HOME_DIR4, "obligations.jsonl");
+var HOME_DIR4 = process.env.BLITZSTRIKE_HOME ?? join19(homedir9(), ".blitzstrike");
+var OBLIGATION_PATH = join19(HOME_DIR4, "obligations.jsonl");
 function ensureDir3() {
   if (!existsSync10(HOME_DIR4))
     mkdirSync8(HOME_DIR4, { recursive: true });
@@ -57398,7 +57596,7 @@ function loadObligations() {
     return [];
   try {
     const out = [];
-    for (const line of readFileSync18(OBLIGATION_PATH, "utf8").split(`
+    for (const line of readFileSync20(OBLIGATION_PATH, "utf8").split(`
 `)) {
       const t = line.trim();
       if (!t)
@@ -57497,11 +57695,11 @@ function openCount() {
 
 // src/variant-scan.ts
 init_scanner();
-import { readFileSync as readFileSync20 } from "node:fs";
+import { readFileSync as readFileSync22 } from "node:fs";
 
 // src/cross-file.ts
 init_scanner();
-import { readFileSync as readFileSync19 } from "node:fs";
+import { readFileSync as readFileSync21 } from "node:fs";
 var PUBLIC_HOOK_RE = /(?:wp_ajax_nopriv_\w+|admin_post_nopriv_\w+|init|template_redirect|wp_loaded|parse_request|user_register|um_user_register|register_new_user|authenticate)/;
 var PRIV_SINK_RE = /\b(set_role|add_role|remove_role|set_user_role|wp_set_current_user|wp_set_auth_cookie|wp_insert_user|wp_create_user|wp_update_user)\s*\(/;
 var ROLE_META_RE = /update_user_meta\s*\(\s*[^,]+,\s*['"](wp_capabilities|role|roles|capabilities|wp_user_level)['"]/;
@@ -57553,7 +57751,7 @@ function detectCrossFilePrivesc(root) {
   for (const file of files) {
     let code;
     try {
-      code = stripComments(readFileSync19(file, "utf8"));
+      code = stripComments(readFileSync21(file, "utf8"));
     } catch {
       continue;
     }
@@ -57594,7 +57792,7 @@ function detectCrossFilePrivesc(root) {
   for (const file of files) {
     let code;
     try {
-      code = stripComments(readFileSync19(file, "utf8"));
+      code = stripComments(readFileSync21(file, "utf8"));
     } catch {
       continue;
     }
@@ -57617,7 +57815,7 @@ function detectCrossFilePrivesc(root) {
   for (const file of files) {
     let code;
     try {
-      code = stripComments(readFileSync19(file, "utf8"));
+      code = stripComments(readFileSync21(file, "utf8"));
     } catch {
       continue;
     }
@@ -57732,7 +57930,7 @@ function variantScan(root, opts = {}) {
   for (const file of files) {
     let code;
     try {
-      code = readFileSync20(file, "utf8");
+      code = readFileSync22(file, "utf8");
     } catch {
       continue;
     }
@@ -58392,16 +58590,16 @@ function analyzeJwt(token, opts = {}) {
 }
 
 // src/enterprise-benchmark.ts
-import { existsSync as existsSync11, readFileSync as readFileSync21, readdirSync as readdirSync6, statSync as statSync3 } from "node:fs";
-import { join as join18, resolve } from "node:path";
+import { existsSync as existsSync11, readFileSync as readFileSync23, readdirSync as readdirSync6, statSync as statSync3 } from "node:fs";
+import { join as join20, resolve } from "node:path";
 var ROOT6 = resolve(process.cwd(), "bench", "enterprise");
 var ENTERPRISE_FIXTURES = [
-  { id: "php-laravel", dir: join18(ROOT6, "php-laravel"), expected_vulns: 4 },
-  { id: "js-express", dir: join18(ROOT6, "js-express"), expected_vulns: 2 },
-  { id: "py-django", dir: join18(ROOT6, "py-django"), expected_vulns: 2 },
-  { id: "java-spring", dir: join18(ROOT6, "java-spring"), expected_vulns: 2 },
-  { id: "wp-batch-route", dir: join18(ROOT6, "wp-batch-route"), expected_vulns: 3 },
-  { id: "php-complex", dir: join18(ROOT6, "php-complex"), expected_vulns: 4 }
+  { id: "php-laravel", dir: join20(ROOT6, "php-laravel"), expected_vulns: 4 },
+  { id: "js-express", dir: join20(ROOT6, "js-express"), expected_vulns: 2 },
+  { id: "py-django", dir: join20(ROOT6, "py-django"), expected_vulns: 2 },
+  { id: "java-spring", dir: join20(ROOT6, "java-spring"), expected_vulns: 2 },
+  { id: "wp-batch-route", dir: join20(ROOT6, "wp-batch-route"), expected_vulns: 3 },
+  { id: "php-complex", dir: join20(ROOT6, "php-complex"), expected_vulns: 4 }
 ];
 function sourceFiles(root) {
   const out = [];
@@ -58413,7 +58611,7 @@ function sourceFiles(root) {
       return;
     }
     for (const e of entries) {
-      const p = join18(dir, e);
+      const p = join20(dir, e);
       let st;
       try {
         st = statSync3(p);
@@ -58434,7 +58632,7 @@ function detectFixture(dir) {
   for (const f of sourceFiles(dir)) {
     let code;
     try {
-      code = readFileSync21(f, "utf8");
+      code = readFileSync23(f, "utf8");
     } catch {
       continue;
     }
@@ -58629,8 +58827,7 @@ function createServer() {
 ` + `- A hard block (Cloudflare/WAF/IP-block/captcha) is NOT the end: mark the finding blocked + note the required vantage (residential / authorized / correct-SNI / --resolve direct-to-origin), then CONTINUE to the next lead (origin bypass, non-prod cluster, mobile APK, subdomain).
 ` + `- Keep trying every lead AND every chain step until each is verified/executed or blocked, THEN generate_report. Never deliver a bare surface map, and never stop at 'found X' when X enables more.
 
-` + "TWO PATHS:\\n" + "- Source path on disk -> blitz_scan / taint_file / eagle_eye2 (static).\\n" + "- Live URL -> live_recon / active_scan / strike_verify (web-hunting).\\n\\n" + `DEEPEN A FINDING: attack_plan(target, tech, params) to get the prioritized vector plan (decide what to test next with data); list_chains (escalation), chain_links (compose), technique_lookup(cls), payload_lookup, bypass_lookup (blocked). Phase doctrine: read_skill(bs-orchestrate-engagement | bs-web-hunting | bs-source-audit | bs-verify-finding). Campaign plan: read_playbook(target-type). On any failure call retry_guidance(signal) / model_fallback(signal) before giving up.
-` + "KNOWLEDGE BASE (discover, don't guess): skillLookup(topic) / listSkills for the 40 attack-path + hunting skills (ap-*, hp-*, bs-*); list_attack_vectors / attack_vectors(cat) for the 34-category vector taxonomy; taxonomy(kind) for OWASP/CWE/ASVS/API-top-10; read_playbook(type) for the 17 campaign playbooks; list_manuals / read_tool_manual for 317 tool references; list_tools / run_catalog_tool for the 141-tool catalog. Every tool, skill, and data layer is reachable from these. CROSS-TARGET INTELLIGENCE: strike_resolve auto-records confirmed/false_positive verdicts into the empirical ledger; query it with intelligence(action=hit_rates/top_vectors) so a new target on a known tech inherits historical hit-rates (attack_plan already blends them into success_probability). LIVE PENTEST + TARGETING (black-box, WAF-safe): cache_gap(base_url, endpoint) fuzzes path-normalization + static-extension variants for cache deception/poisoning; blind_oracle(base_url, param, value) detects which SINK a param reaches (sql/ssti/xss) via benign arithmetic (id=1+0, test${7*7}) WITHOUT a malicious payload; param_precedence(base_url, param, A, B) maps duplicate-parameter precedence (first/last-wins) for WAF-bypass. SOURCE TARGETING: action_surface(code) maps every wp_ajax_* action to its vuln class + DERIVED priority (what to look for WHERE); security_state(sanitizers, sink) gives a wrong-context sanitization verdict; framework_knowledge(framework) returns auth/nonce primitives for 9 frameworks; variant_scan(root, signature) mass-sweeps an install base for ONE bug family; patch_analyze(old, new) REVERSES a security patch into the 0-day, and its mine_signature feeds variant_scan to sweep unpatched copies. All of these are DETECTION HINTS — verify each live (strike_verify / browser_validate) before it enters the report. NEWEST DETECTORS — understand AND try them: variant_scan also emits priv_esc (privilege escalation — a role/capability/user change fed by request input, traced cross-file via reverse call-graph, e.g. set_role($id, sanitize_key($_POST['um-role'])) or update_user_meta(...,'wp_capabilities', $_POST[...])) and flags uploadAllow=>array('all') unrestricted-upload configs as file_upload (the file-manager/connector shape). TO TRY a priv_esc hit: submit the role field with 'administrator' (or send wp_capabilities meta) and confirm the account actually gains admin. TO TRY an unrestricted-upload hit: POST a .php/.phtml and confirm it lands web-reachable + executes. variant_scan also emits hardcoded_secret (CWE-798) in three tiers: a secret field (api_key/db_password/access_token/aws_*) assigned a literal (HIGH), a known secret FORMAT (JWT eyJ…/AWS AKIA…/GitHub ghp_…/Slack xoxb-…/…) regardless of name (HIGH), or a high-entropy suspect token (MEDIUM — verify before reporting). Verify a frontend/JS secret live via drive_devtools (inspect the JS bundle / network response and confirm the key is actually exposed), and for a backend secret confirm it is reachable/valid. A static hit is a HYPOTHESIS until verified live — never report unverified.\n" + `PRECISION ANALYSIS — chrome-devtools MCP is MANDATORY, not optional:
+` + "TWO PATHS:\\n" + "- Source path on disk -> blitz_scan / taint_file / eagle_eye2 (static).\\n" + "- Live URL -> live_recon / active_scan / strike_verify (web-hunting).\\n\\n" + "DEEPEN A FINDING: attack_plan(target, tech, params) to get the prioritized vector plan (decide what to test next with data); list_chains (escalation), chain_links (compose), technique_lookup(cls), payload_lookup, bypass_lookup (blocked). Ground any detector hit empirically with pattern_lookup(id) — it returns the class's CWE, real-world signature, escalation chains, and citable references, so a raw hit becomes a class-aware finding. BEFORE generating a report, run submission_gate(...) and only ship a finding that passes all 7 questions (reproducible, in-scope, real-impact, no-privileged-assumption, verified-live, evidence-redacted, severity-derived); one false = kill it. Calibrate severity with severity_calibrate(type, cvss) to get a P1–P5 tier + VRT-style category. Start each engagement with engagement_scaffold(target, scope) for the folder + scope.md structure, and check data_refresh() to confirm the data layers are consistent. Phase doctrine: read_skill(bs-orchestrate-engagement | bs-web-hunting | bs-source-audit | bs-verify-finding). Campaign plan: read_playbook(target-type). On any failure call retry_guidance(signal) / model_fallback(signal) before giving up.\n" + "KNOWLEDGE BASE (discover, don't guess): skillLookup(topic) / listSkills for the 40 attack-path + hunting skills (ap-*, hp-*, bs-*); list_attack_vectors / attack_vectors(cat) for the 34-category vector taxonomy; taxonomy(kind) for OWASP/CWE/ASVS/API-top-10; read_playbook(type) for the 17 campaign playbooks; list_manuals / read_tool_manual for 317 tool references; list_tools / run_catalog_tool for the 141-tool catalog. Every tool, skill, and data layer is reachable from these. CROSS-TARGET INTELLIGENCE: strike_resolve auto-records confirmed/false_positive verdicts into the empirical ledger; query it with intelligence(action=hit_rates/top_vectors) so a new target on a known tech inherits historical hit-rates (attack_plan already blends them into success_probability). LIVE PENTEST + TARGETING (black-box, WAF-safe): cache_gap(base_url, endpoint) fuzzes path-normalization + static-extension variants for cache deception/poisoning; blind_oracle(base_url, param, value) detects which SINK a param reaches (sql/ssti/xss) via benign arithmetic (id=1+0, test${7*7}) WITHOUT a malicious payload; param_precedence(base_url, param, A, B) maps duplicate-parameter precedence (first/last-wins) for WAF-bypass. SOURCE TARGETING: action_surface(code) maps every wp_ajax_* action to its vuln class + DERIVED priority (what to look for WHERE); security_state(sanitizers, sink) gives a wrong-context sanitization verdict; framework_knowledge(framework) returns auth/nonce primitives for 9 frameworks; variant_scan(root, signature) mass-sweeps an install base for ONE bug family; patch_analyze(old, new) REVERSES a security patch into the 0-day, and its mine_signature feeds variant_scan to sweep unpatched copies. All of these are DETECTION HINTS — verify each live (strike_verify / browser_validate) before it enters the report. NEWEST DETECTORS — understand AND try them: variant_scan also emits priv_esc (privilege escalation — a role/capability/user change fed by request input, traced cross-file via reverse call-graph, e.g. set_role($id, sanitize_key($_POST['um-role'])) or update_user_meta(...,'wp_capabilities', $_POST[...])) and flags uploadAllow=>array('all') unrestricted-upload configs as file_upload (the file-manager/connector shape). TO TRY a priv_esc hit: submit the role field with 'administrator' (or send wp_capabilities meta) and confirm the account actually gains admin. TO TRY an unrestricted-upload hit: POST a .php/.phtml and confirm it lands web-reachable + executes. variant_scan also emits hardcoded_secret (CWE-798) in three tiers: a secret field (api_key/db_password/access_token/aws_*) assigned a literal (HIGH), a known secret FORMAT (JWT eyJ…/AWS AKIA…/GitHub ghp_…/Slack xoxb-…/…) regardless of name (HIGH), or a high-entropy suspect token (MEDIUM — verify before reporting). Verify a frontend/JS secret live via drive_devtools (inspect the JS bundle / network response and confirm the key is actually exposed), and for a backend secret confirm it is reachable/valid. A static hit is a HYPOTHESIS until verified live — never report unverified.\n" + `PRECISION ANALYSIS — chrome-devtools MCP is MANDATORY, not optional:
 ` + `- When a lead needs DOM/JS precision — DOM-XSS sink execution, AJAX endpoint + payload interception, JS runtime errors, redirect chains, SSO/token flow, or anything a static HTML glance cannot prove — call drive_devtools(target). It spawns chrome-devtools-mcp and drives a REAL headless browser (navigate -> list_network_requests -> list_console_messages -> evaluate_script), giving reproducible evidence instead of a guess.
 ` + `- Before calling it, check_mcp() to confirm the browser MCP is available; if not, blitzstrike install-tools or npm i -g chrome-devtools-mcp. Never substitute eyeballing minified JS or a static sink guess when a live browser can PROVE it. This is the precision + consistency layer.
 ` + "EXTERNAL MCP SERVERS (verified, connect them — NOT one-shot CLIs): chrome-devtools-mcp (29 tools: list_network_requests/get_network_request for raw HTTP interception, list_console_messages for JS errors + DOM-XSS, evaluate_script to run JS, take_screenshot) -> stdio chrome-devtools-mcp --headless --chromeArg=--no-sandbox --chromeArg=--disable-gpu (as root/container this is MANDATORY or the browser crashes; add --proxyServer http://127.0.0.1:8080 to route through Burp, --acceptInsecureCerts for bad TLS). burp-suite-mcp (proxy history + active scan + repeater) -> NOT npm: build the JAR (git clone https://github.com/PortSwigger/mcp-server.git && cd mcp-server && ./gradlew embedProxyJar), load it in Burp Extensions, then connect the client to http://127.0.0.1:9876 (SSE) or the stdio proxy java -jar mcp-proxy-all.jar --sse-url http://127.0.0.1:9876."
@@ -58985,6 +59182,69 @@ ${statusLine}` : statusLine },
       content: [{ type: "text", text: JSON.stringify(listChains()) }]
     };
   });
+  server.registerTool("pattern_lookup", {
+    title: "Empirical pattern lookup",
+    description: "GROUNDING: return the empirical grounding for a detector type / vuln class — its CWE, its real-world signature, the escalation chains it composes into (cross-ref chains.json), and citable references. Use to turn a raw detector hit into a grounded, class-aware finding. Pass 'list' to enumerate all grounded classes.",
+    inputSchema: {
+      id: string2().describe("Detector/vuln class id (sql_injection, ssrf, idor-like missing_authz, …), or 'list'")
+    }
+  }, async ({ id }) => {
+    if (id === "list")
+      return { content: [{ type: "text", text: JSON.stringify(listPatterns()) }] };
+    const p = patternLookup(id);
+    if (!p)
+      return { content: [{ type: "text", text: JSON.stringify({ error: `no pattern for '${id}'`, known: listPatterns().map((x) => x.id) }) }] };
+    return { content: [{ type: "text", text: JSON.stringify(p) }] };
+  });
+  server.registerTool("submission_gate", {
+    title: "Submission gate (7 questions)",
+    description: "GATE: run the deterministic 7-question checklist on a finding before it ships. Questions: reproducible? in-scope? real impact? no privileged assumption? verified live? evidence redacted? severity derived? One false = fail (kill the finding). Pass booleans you can honestly assert true; omit/leave false any you cannot.",
+    inputSchema: {
+      type: string2().optional().describe("Detector/vuln class id"),
+      severity: string2().optional().describe("Finding severity"),
+      reproducible: boolean2().optional().describe("Exact request/step list is copy-paste ready"),
+      in_scope: boolean2().optional().describe("Vulnerable asset is in engagement scope"),
+      real_impact: boolean2().optional().describe("Maps to an accepted-impact class"),
+      no_privileged_assumption: boolean2().optional().describe("Works without unrealistic prerequisites"),
+      verified_live: boolean2().optional().describe("Confirmed with marker + negative control"),
+      evidence_redacted: boolean2().optional().describe("Evidence attached, secrets/PII redacted"),
+      severity_derived: boolean2().optional().describe("Severity derived via CVSS/confidence")
+    }
+  }, async (args) => {
+    return { content: [{ type: "text", text: JSON.stringify(submissionGate(args)) }] };
+  });
+  server.registerTool("severity_calibrate", {
+    title: "Severity calibration (VRT-style)",
+    description: "SEVERITY: calibrate a finding to a platform-neutral priority tier (P1–P5) + a VRT-style category, so it is reported at the severity a triager would assign. Maps a detector type (sql_injection, ssrf, ssti, …) to its category + rationale; pass a CVSS score to cross-reference, or 'list' to enumerate every calibrated class.",
+    inputSchema: {
+      type: string2().optional().describe("Detector/vuln class id, or 'list'"),
+      severity: string2().optional().describe("Detector-reported severity (informational for reference)"),
+      cvss: number2().min(0).max(10).optional().describe("CVSS base score (0–10) to cross-reference"),
+      informational: boolean2().optional().describe("True if the finding is informational-only")
+    }
+  }, async ({ type, severity, cvss, informational }) => {
+    if (type === "list")
+      return { content: [{ type: "text", text: JSON.stringify(listSeverityMap()) }] };
+    return { content: [{ type: "text", text: JSON.stringify(severityCalibrate({ type, severity, cvss, informational })) }] };
+  });
+  server.registerTool("engagement_scaffold", {
+    title: "Engagement scaffold",
+    description: "SCAFFOLD: open an engagement and emit a deterministic folder layout (scope.md, findings/, evidence/, reports/, notes/) + a pre-filled scope.md template. Returns the engagement id + initial state so the hunt starts with structure, not improvisation.",
+    inputSchema: {
+      target: string2().describe("The in-scope target (domain/URL/program)"),
+      scope: array(string2()).optional().describe("In-scope assets/domains"),
+      out_of_scope: array(string2()).optional().describe("Out-of-scope assets")
+    }
+  }, async ({ target, scope, out_of_scope }) => {
+    return { content: [{ type: "text", text: JSON.stringify(scaffoldEngagement(target, scope ?? [], out_of_scope ?? [])) }] };
+  });
+  server.registerTool("data_refresh", {
+    title: "Data-layer health check",
+    description: "HEALTH: re-load every data layer (chains, patterns, CWE map) and verify cross-references — a pattern pointing at a missing chain, or a detector without a CWE mapping. Returns counts + any broken reference, so stale data is surfaced instead of silently producing bad grounding.",
+    inputSchema: {}
+  }, async () => {
+    return { content: [{ type: "text", text: JSON.stringify(dataRefresh()) }] };
+  });
   server.registerTool("fofa_search", {
     title: "FOFA asset search",
     description: "STRIKE: search the FOFA asset index (needs FOFA_EMAIL + FOFA_KEY).",
@@ -59369,7 +59629,7 @@ ${statusLine}` : statusLine },
     let src = code;
     if (!src && path) {
       try {
-        src = readFileSync23(path, "utf8");
+        src = readFileSync25(path, "utf8");
       } catch {
         return { content: [{ type: "text", text: JSON.stringify({ error: "unreadable path" }) }] };
       }
@@ -59987,7 +60247,7 @@ ${statusLine}` : statusLine },
     description: "Route confusion (separate class from source→sink taint): detect attacker-controlled dispatch (call_user_func/forward/dispatch), dynamic method calls ($obj->$m()), dynamic include (LFI), batch/proxy forwarding without per-route auth re-check, and route matching without path normalization.",
     inputSchema: { path: string2().describe("Source file path (PHP)") }
   }, async ({ path }) => {
-    const code = readFileSync23(path, "utf8");
+    const code = readFileSync25(path, "utf8");
     const findings = detectRouteConfusion(code, path);
     return {
       content: [{
@@ -60001,7 +60261,7 @@ ${statusLine}` : statusLine },
     description: "Complex-bug detection beyond taint: deserialization→POP gadget chain (unserialize + magic method), type juggling (loose ==/!= vs hash/secret), mass assignment (extract/parse_str without a safe flag), prototype pollution (unsafe merge of request data), CRLF/header injection (user input into a header), path confusion (user input into a file path without canonicalization), SSRF (user-controlled URL with no host allowlist), XXE (user XML parsed without disabling entities), SSTI (user input into a template render with no sandbox), wrong-context sanitization (sanitize_text_field() into a SQL query), and missing authorization/nonce on WordPress entry points (wp_ajax_* / admin_post_* / register_rest_route without current_user_can, nonce verification, or permission_callback).",
     inputSchema: { path: string2().describe("Source file path") }
   }, async ({ path }) => {
-    const code = readFileSync23(path, "utf8");
+    const code = readFileSync25(path, "utf8");
     const findings = detectComplexBugs(code, path);
     return {
       content: [{
@@ -60087,7 +60347,7 @@ ${statusLine}` : statusLine },
     let lang = language;
     if (path && !code) {
       try {
-        src = readFileSync23(path, "utf8");
+        src = readFileSync25(path, "utf8");
       } catch {
         return { content: [{ type: "text", text: JSON.stringify({ error: `cannot read ${path}` }) }] };
       }
@@ -60328,15 +60588,15 @@ async function serve() {
 
 // src/index.ts
 init_cli();
-import { readFileSync as readFileSync27, existsSync as existsSync14 } from "node:fs";
-import { join as join23 } from "node:path";
-import { fileURLToPath as fileURLToPath13 } from "node:url";
-var ROOT11 = join23(fileURLToPath13(new URL(".", import.meta.url)), "..");
+import { readFileSync as readFileSync29, existsSync as existsSync14 } from "node:fs";
+import { join as join25 } from "node:path";
+import { fileURLToPath as fileURLToPath15 } from "node:url";
+var ROOT11 = join25(fileURLToPath15(new URL(".", import.meta.url)), "..");
 function readVersion() {
   try {
-    const p = join23(ROOT11, "package.json");
+    const p = join25(ROOT11, "package.json");
     if (existsSync14(p))
-      return JSON.parse(readFileSync27(p, "utf8")).version ?? "1.0.0";
+      return JSON.parse(readFileSync29(p, "utf8")).version ?? "1.0.0";
   } catch {}
   return "1.0.0";
 }

package/intelligence/patterns.json

@@ -0,0 +1,151 @@
+{
+  "$schema": "blitzstrike-patterns-v1",
+  "version": "1.0.0",
+  "_comment": "Empirical grounding layer. Every detector type is traced to its real-world bug class (CWE), its real-world signature, the chains it composes into (cross-ref chains.json), and a citable reference. Detection is derived from this data, never hardcoded. References are public standards (CWE/OWASP) and disclosed-report classes — no vendor/product framing.",
+  "patterns": [
+    {
+      "id": "sql_injection",
+      "name": "SQL Injection",
+      "cwe": "CWE-89",
+      "real_world": "User input is interpolated into a SQL query by string concatenation instead of parameterization. The single most-reported web class; real disclosures range from boolean/UNION extraction to stacked queries for admin takeover.",
+      "detection_signatures": ["raw string-interpolated query into a SQL sink", "no prepare()/parameterization", "cross-file: concatenated variable with no visible source"],
+      "chain_templates": ["sqli_to_rce", "sqli_to_hash_dump_and_crack", "sql_injection_to_rce", "second_order_sqli"],
+      "references": ["CWE-89", "OWASP A03:2021 Injection"]
+    },
+    {
+      "id": "ssrf",
+      "name": "Server-Side Request Forgery",
+      "cwe": "CWE-918",
+      "real_world": "A server fetches an attacker-supplied URL with no host allowlist, letting it reach cloud metadata endpoints, internal services, or the loopback interface.",
+      "detection_signatures": ["server-side fetch of a request-controlled URL", "no host/allowlist validation"],
+      "chain_templates": ["ssrf_cloud_metadata", "ssrf_to_redis_rce", "blind_ssrf_to_oob_exfil"],
+      "references": ["CWE-918", "OWASP A10:2021 SSRF"]
+    },
+    {
+      "id": "ssti",
+      "name": "Server-Side Template Injection",
+      "cwe": "CWE-1336",
+      "real_world": "User input reaches a template engine (Jinja2, Twig, Freemarker, ERB, …) that evaluates expressions, yielding code execution via template syntax like {{7*7}}.",
+      "detection_signatures": ["template render of request input", "expression evaluation in a template engine"],
+      "chain_templates": ["ssti_template_injection_rce", "ssti_to_full_rce"],
+      "references": ["CWE-1336", "OWASP A03:2021 Injection"]
+    },
+    {
+      "id": "xxe",
+      "name": "XML External Entity Injection",
+      "cwe": "CWE-611",
+      "real_world": "An XML parser resolves external entities, letting an attacker read local files or hit internal URLs via DOCTYPE entity definitions.",
+      "detection_signatures": ["XML parse without disabling external entities", "DOCTYPE/ENTITY processing"],
+      "chain_templates": ["xxe_to_ssrf_and_file_read"],
+      "references": ["CWE-611", "OWASP A03:2021 Injection"]
+    },
+    {
+      "id": "deserialization",
+      "name": "Insecure Deserialization",
+      "cwe": "CWE-502",
+      "real_world": "Attacker-controlled serialized data is deserialized and escalated through a magic-method gadget chain (__destruct/__wakeup/__toString) into code execution or object injection.",
+      "detection_signatures": ["unserialize()/pickle.loads/yaml.load of request data", "a magic-method gadget in scope"],
+      "chain_templates": ["deserialization_pop_chain", "deserialization_to_rce", "appkey_leak_deserialization_rce"],
+      "references": ["CWE-502", "OWASP A08:2021 Software and Data Integrity Failures"]
+    },
+    {
+      "id": "type_juggling",
+      "name": "PHP Type Juggling (Loose Comparison)",
+      "cwe": "CWE-697",
+      "real_world": "A loose comparison (==) between user input and a hash/secret collapses via the 0e magic-hash or numeric-string coercion, bypassing authentication.",
+      "detection_signatures": ["loose comparison == of user input against a secret/hash", "0e-prefixed or numeric-string coercion"],
+      "chain_templates": ["php_type_juggling_auth_bypass"],
+      "references": ["CWE-697", "OWASP A07:2021 Identification and Authentication Failures"]
+    },
+    {
+      "id": "mass_assignment",
+      "name": "Mass Assignment",
+      "cwe": "CWE-915",
+      "real_world": "Request data is bound to model fields without an allowlist (extract()/parse_str/framework mass-assign), letting an attacker set privileged fields like role or is_admin.",
+      "detection_signatures": ["extract()/parse_str of request data without a safe flag", "model binding without an allowlist"],
+      "chain_templates": ["mass_assignment_to_admin_takeover", "extract_variable_injection_lfi"],
+      "references": ["CWE-915", "OWASP API6:2023 Unrestricted Access to Sensitive Business Flows"]
+    },
+    {
+      "id": "prototype_pollution",
+      "name": "Prototype Pollution",
+      "cwe": "CWE-1321",
+      "real_world": "A deep merge of request data into an object pollutes Object.prototype, corrupting logic and escalating to code execution in gadget-heavy runtimes.",
+      "detection_signatures": ["deep merge/extend of request data into objects", "__proto__ / constructor.prototype assignment"],
+      "chain_templates": ["prototype_pollution_to_rce"],
+      "references": ["CWE-1321"]
+    },
+    {
+      "id": "crlf_injection",
+      "name": "CRLF Injection / Header Injection",
+      "cwe": "CWE-93",
+      "real_world": "Request-controlled newlines are written into an HTTP header, enabling response splitting, cookie injection, or cache poisoning.",
+      "detection_signatures": ["request input reaches a header without CR/LF stripping"],
+      "chain_templates": ["cache_poisoning_xss", "cache_poison_to_stored_xss"],
+      "references": ["CWE-93", "OWASP A03:2021 Injection"]
+    },
+    {
+      "id": "path_confusion",
+      "name": "Path Traversal / Path Confusion",
+      "cwe": "CWE-22",
+      "real_world": "A request-controlled path is normalized or resolved without confinement (../, %2e%2e, absolute paths), reading or writing files outside the intended directory.",
+      "detection_signatures": ["request input reaches a file path without confinement"],
+      "chain_templates": ["path_traversal_file_write", "path_traversal_to_credential_theft", "lfi_log_poison_rce", "lfi_to_rce_via_log_poisoning"],
+      "references": ["CWE-22", "OWASP A01:2021 Broken Access Control"]
+    },
+    {
+      "id": "wrong_sanitizer",
+      "name": "Wrong-Context Sanitization",
+      "cwe": "CWE-20",
+      "real_world": "A value is sanitized for one context (e.g. HTML) but reaches a sink that needs a different context (e.g. SQL), so the sanitizer provides no real protection.",
+      "detection_signatures": ["a sanitizer/validator for context X feeding a sink that requires context Y"],
+      "chain_templates": ["second_order_sqli"],
+      "references": ["CWE-20", "OWASP A03:2021 Injection"]
+    },
+    {
+      "id": "missing_authz",
+      "name": "Missing Authorization (Broken Access Control)",
+      "cwe": "CWE-862",
+      "real_world": "A state-changing handler lacks a capability/ownership check, letting an unauthenticated or low-privilege caller perform an admin action.",
+      "detection_signatures": ["state-changing operation with no current_user_can/is_user_logged_in check"],
+      "chain_templates": ["idor_to_admin_takeover", "mass_assignment_to_admin_takeover", "idor_object_reference"],
+      "references": ["CWE-862", "OWASP A01:2021 Broken Access Control"]
+    },
+    {
+      "id": "missing_nonce",
+      "name": "Missing Nonce (CSRF)",
+      "cwe": "CWE-352",
+      "real_world": "A state-changing action lacks an anti-CSRF token, letting a victim's browser perform the action on their behalf via a forged request.",
+      "detection_signatures": ["state-changing operation with no nonce/referer verification"],
+      "chain_templates": ["nonce_harvest_auth_bypass"],
+      "references": ["CWE-352", "OWASP A01:2021 Broken Access Control"]
+    },
+    {
+      "id": "file_upload",
+      "name": "Unrestricted File Upload",
+      "cwe": "CWE-434",
+      "real_world": "A file is uploaded with an attacker-controlled name/extension and no server-side filetype whitelist, landing web-reachable for code execution.",
+      "detection_signatures": ["move_uploaded_file/wp_upload_bits with attacker-controlled name", "no extension/mime whitelist", "uploadAllow=all connector config"],
+      "chain_templates": ["upload_polyglot_rce", "file_upload_to_rce", "split_controller_upload_bypass"],
+      "references": ["CWE-434", "OWASP A04:2021 Insecure Design"]
+    },
+    {
+      "id": "priv_esc",
+      "name": "Privilege Escalation",
+      "cwe": "CWE-269",
+      "real_world": "A role/capability/user change is fed by request input and reachable from a public entry point with no capability check, letting a user self-assign admin.",
+      "detection_signatures": ["set_role/add_role/add_cap of request input", "cross-file: sink reachable from public hook with no capability check"],
+      "chain_templates": ["mass_assignment_to_admin_takeover", "idor_to_admin_takeover"],
+      "references": ["CWE-269", "OWASP A01:2021 Broken Access Control"]
+    },
+    {
+      "id": "hardcoded_secret",
+      "name": "Hardcoded Credentials",
+      "cwe": "CWE-798",
+      "real_world": "A secret (API key, database password, access token, private key) is committed in source, exposing it to anyone with repo access. Real disclosures regularly turn a leaked key into account takeover or cloud compromise.",
+      "detection_signatures": ["secret field assigned a literal", "known secret format (JWT/AWS/GitHub/Slack/…) in source", "high-entropy token under a non-obvious name"],
+      "chain_templates": ["api_key_leak_to_account_takeover", "appkey_leak_deserialization_rce", "default_creds_to_internal_pivot"],
+      "references": ["CWE-798", "OWASP A02:2021 Cryptographic Failures"]
+    }
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blitzstrike",
-  "version": "2.4.57",
+  "version": "2.4.59",
   "description": "Blitz Strike — a universal MCP security-audit toolbelt. BLITZ sweeps the attack surface, EAGLE-EYE traces source-to-sink, STRIKE verifies live. 57 attack chains, 130-tool catalog, intelligence data layer. One server, every agent.",
   "type": "module",
   "bin": {