blitzstrike 2.4.122 → 2.4.124

package/CHANGELOG.md

@@ -5,6 +5,27 @@ 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.124] — 2026-09-29
+
+### Added — TOTP/HOTP generation + WET/DRY traceability
+
+- New `totp(secret, …)` — deterministic RFC 6238 TOTP / RFC 4226 HOTP
+  generation (base32 or raw ASCII key) so the agent can fill a 2FA field itself
+  during authenticated scanning instead of stalling on a prompt.
+- New `wet_dry(type, wet, dry)` — save the RAW output (WET) and PARSED result
+  (DRY) of an enrichment step separately and diagnose WHERE a bad deliverable
+  broke: WET (model/prompt/timeout) vs DRY (parser) vs template. (158 MCP tools.)
+
+## [2.4.123] — 2026-09-29
+
+### Added — circuit breaker (`target_health` + `circuit_status`)
+
+- New `target_health(target, limit?)`: probe a target (10s timeout) and track
+  consecutive failures in a persisted circuit-breaker state; after 5 consecutive
+  timeouts/5xx the circuit OPENS (PAUSE) and auto-closes on the next successful
+  probe. `circuit_status()` lists every tracked target's state. Tells the agent
+  to stop hammering an unresponsive target instead of burning requests. (156 MCP tools.)
+
 ## [2.4.122] — 2026-09-29
 
 ### Added — `param_surface` (autonomous parameter discovery + specialist hints)

package/dist/index.js

@@ -17452,9 +17452,9 @@ var init_variants = __esm(() => {
 });
 
 // src/sync.ts
-import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync9, readFileSync as readFileSync31, readdirSync as readdirSync9, statSync as statSync6, rmSync as rmSync5 } from "node:fs";
-import { join as join30 } from "node:path";
-import { homedir as homedir11 } from "node:os";
+import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync10, readFileSync as readFileSync32, readdirSync as readdirSync9, statSync as statSync6, rmSync as rmSync5 } from "node:fs";
+import { join as join31 } from "node:path";
+import { homedir as homedir12 } from "node:os";
 import { fileURLToPath as fileURLToPath18 } from "node:url";
 import { spawnSync as spawnSync4 } from "node:child_process";
 function dirExists(p) {
@@ -17470,7 +17470,7 @@ function countFiles(dir) {
     const walk = (d) => {
       for (const e of readdirSync9(d, { withFileTypes: true })) {
         if (e.isDirectory())
-          walk(join30(d, e.name));
+          walk(join31(d, e.name));
         else
           n++;
       }
@@ -17483,9 +17483,9 @@ function countFiles(dir) {
 }
 function syncData() {
   if (!dirExists(DATA_ROOT2))
-    mkdirSync10(DATA_ROOT2, { recursive: true });
-  const payloadsPath = join30(DATA_ROOT2, "payloads");
-  const templatesPath = join30(DATA_ROOT2, "templates");
+    mkdirSync11(DATA_ROOT2, { recursive: true });
+  const payloadsPath = join31(DATA_ROOT2, "payloads");
+  const templatesPath = join31(DATA_ROOT2, "templates");
   const hasPayloads = dirExists(payloadsPath) && countFiles(payloadsPath) > 0;
   const hasTemplates = dirExists(templatesPath) && countFiles(templatesPath) > 0;
   if (hasPayloads && hasTemplates) {
@@ -17495,8 +17495,8 @@ function syncData() {
       data_root: DATA_ROOT2
     };
   }
-  const localPayloads = join30(ROOT11, "payloads");
-  const localTemplates = join30(ROOT11, "templates");
+  const localPayloads = join31(ROOT11, "payloads");
+  const localTemplates = join31(ROOT11, "templates");
   let payloadsSynced = false;
   let templatesSynced = false;
   if (!hasPayloads && dirExists(localPayloads)) {
@@ -17509,7 +17509,7 @@ function syncData() {
   }
   const gitOk = spawnSync4("git", ["--version"]).status === 0;
   if (gitOk && (!dirExists(payloadsPath) || countFiles(payloadsPath) === 0 || !dirExists(templatesPath) || countFiles(templatesPath) === 0)) {
-    const tmp = join30(DATA_ROOT2, ".tmp-clone");
+    const tmp = join31(DATA_ROOT2, ".tmp-clone");
     if (dirExists(tmp))
       rmSync5(tmp, { recursive: true, force: true });
     const r = spawnSync4("git", ["clone", "--depth", "1", "--filter=blob:none", "--sparse", GITHUB_REPO, tmp], { timeout: 120000 });
@@ -17517,11 +17517,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(join30(tmp, "payloads"), payloadsPath);
+          copyDir(join31(tmp, "payloads"), payloadsPath);
           payloadsSynced = true;
         }
         if (!dirExists(templatesPath) || countFiles(templatesPath) === 0) {
-          copyDir(join30(tmp, "templates"), templatesPath);
+          copyDir(join31(tmp, "templates"), templatesPath);
           templatesSynced = true;
         }
       }
@@ -17541,20 +17541,20 @@ function copyDir(src, dst) {
   }
 }
 function manualCopy(src, dst) {
-  mkdirSync10(dst, { recursive: true });
+  mkdirSync11(dst, { recursive: true });
   for (const e of readdirSync9(src, { withFileTypes: true })) {
-    const s = join30(src, e.name);
-    const d = join30(dst, e.name);
+    const s = join31(src, e.name);
+    const d = join31(dst, e.name);
     if (e.isDirectory())
       manualCopy(s, d);
     else
-      writeFileSync9(d, readFileSync31(s));
+      writeFileSync10(d, readFileSync32(s));
   }
 }
 var ROOT11, DATA_ROOT2, GITHUB_REPO = "https://github.com/shinthink/blitzstrike.git";
 var init_sync = __esm(() => {
-  ROOT11 = join30(fileURLToPath18(new URL(".", import.meta.url)), "..");
-  DATA_ROOT2 = process.env.BLITZSTRIKE_DATA ?? join30(homedir11(), ".blitzstrike", "data");
+  ROOT11 = join31(fileURLToPath18(new URL(".", import.meta.url)), "..");
+  DATA_ROOT2 = process.env.BLITZSTRIKE_DATA ?? join31(homedir12(), ".blitzstrike", "data");
 });
 
 // src/update.ts
@@ -17599,15 +17599,15 @@ var init_update = __esm(() => {
 });
 
 // src/release.ts
-import { readFileSync as readFileSync33, existsSync as existsSync17 } from "node:fs";
-import { join as join31 } from "node:path";
+import { readFileSync as readFileSync34, existsSync as existsSync18 } from "node:fs";
+import { join as join32 } from "node:path";
 import { fileURLToPath as fileURLToPath19 } from "node:url";
 import { execSync as execSync4 } from "node:child_process";
 function validateRelease() {
   const checks = [];
   checks.push({ name: "package.json version", ok: true, detail: VERSION });
   try {
-    const changelog = readFileSync33(join31(ROOT12, "CHANGELOG.md"), "utf8");
+    const changelog = readFileSync34(join32(ROOT12, "CHANGELOG.md"), "utf8");
     const m = changelog.match(/^##\s+\[([0-9]+\.[0-9]+\.[0-9]+)\]/m);
     const changelogVersion = m?.[1] ?? null;
     checks.push({
@@ -17639,22 +17639,22 @@ function validateRelease() {
   return { version: VERSION, checks, consistent: checks.filter((c) => !c.soft).every((c) => c.ok) };
 }
 function lockfilePresent() {
-  return existsSync17(join31(ROOT12, "package-lock.json")) || existsSync17(join31(ROOT12, "bun.lock")) || existsSync17(join31(ROOT12, "bun.lockb"));
+  return existsSync18(join32(ROOT12, "package-lock.json")) || existsSync18(join32(ROOT12, "bun.lock")) || existsSync18(join32(ROOT12, "bun.lockb"));
 }
 var ROOT12;
 var init_release = __esm(() => {
   init_version();
-  ROOT12 = join31(fileURLToPath19(new URL(".", import.meta.url)), "..");
+  ROOT12 = join32(fileURLToPath19(new URL(".", import.meta.url)), "..");
 });
 
 // src/dependency.ts
-import { readFileSync as readFileSync34 } from "node:fs";
-import { join as join32 } from "node:path";
+import { readFileSync as readFileSync35 } from "node:fs";
+import { join as join33 } from "node:path";
 import { fileURLToPath as fileURLToPath20 } from "node:url";
 function checkDependencies() {
   let pkg = {};
   try {
-    pkg = JSON.parse(readFileSync34(join32(ROOT13, "package.json"), "utf8"));
+    pkg = JSON.parse(readFileSync35(join33(ROOT13, "package.json"), "utf8"));
   } catch {
     return { install_scripts: [], git_dependencies: [], total_dependencies: 0, safe: false };
   }
@@ -17677,13 +17677,13 @@ function checkDependencies() {
 }
 var ROOT13;
 var init_dependency = __esm(() => {
-  ROOT13 = join32(fileURLToPath20(new URL(".", import.meta.url)), "..");
+  ROOT13 = join33(fileURLToPath20(new URL(".", import.meta.url)), "..");
 });
 
 // src/cli.ts
-import { readFileSync as readFileSync35, existsSync as existsSync18, writeFileSync as writeFileSync10, mkdirSync as mkdirSync11 } from "node:fs";
-import { join as join33, dirname as dirname6 } from "node:path";
-import { homedir as homedir12 } from "node:os";
+import { readFileSync as readFileSync36, existsSync as existsSync19, writeFileSync as writeFileSync11, mkdirSync as mkdirSync12 } from "node:fs";
+import { join as join34, dirname as dirname6 } from "node:path";
+import { homedir as homedir13 } from "node:os";
 import { fileURLToPath as fileURLToPath21 } from "node:url";
 import { spawnSync as spawnSync5 } from "node:child_process";
 function which(cmd) {
@@ -17727,7 +17727,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 = existsSync18(join33(ROOT14, "chains.json")) && existsSync18(join33(ROOT14, "tools-catalog.json"));
+  const dataOk = existsSync19(join34(ROOT14, "chains.json")) && existsSync19(join34(ROOT14, "tools-catalog.json"));
   issues.push({
     name: "Data layers (chains + tools-catalog)",
     status: dataOk ? "ok" : "fail",
@@ -17778,21 +17778,21 @@ BlitzStrike — ${verdict}`);
 function resolveCommand() {
   if (which("blitzstrike"))
     return { command: "blitzstrike", args: ["serve", "--mcp"] };
-  const src = join33(ROOT14, "src", "index.ts");
-  if (which("bun") && existsSync18(src))
+  const src = join34(ROOT14, "src", "index.ts");
+  if (which("bun") && existsSync19(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 = join33(ROOT14, "dist", "index.js");
-  if (existsSync18(dist))
+  const dist = join34(ROOT14, "dist", "index.js");
+  if (existsSync19(dist))
     return { command: "bun", args: [dist, "serve", "--mcp"] };
   return { command: "npx", args: ["-y", "blitzstrike", "serve", "--mcp"] };
 }
 function readJson(p) {
   try {
-    return JSON.parse(readFileSync35(p, "utf8"));
+    return JSON.parse(readFileSync36(p, "utf8"));
   } catch {
     return null;
   }
@@ -17800,51 +17800,51 @@ function readJson(p) {
 function jsonMcpServersWrite(p) {
   return (command, args) => {
     const dir = dirname6(p);
-    if (!existsSync18(dir))
-      mkdirSync11(dir, { recursive: true });
+    if (!existsSync19(dir))
+      mkdirSync12(dir, { recursive: true });
     const existing = readJson(p) ?? {};
     existing.mcpServers = {
       ...existing.mcpServers ?? {},
       blitzstrike: { command, args }
     };
-    writeFileSync10(p, JSON.stringify(existing, null, 2));
+    writeFileSync11(p, JSON.stringify(existing, null, 2));
   };
 }
 function opencodeWrite(p) {
   return (command, args) => {
     const dir = dirname6(p);
-    if (!existsSync18(dir))
-      mkdirSync11(dir, { recursive: true });
+    if (!existsSync19(dir))
+      mkdirSync12(dir, { recursive: true });
     const existing = readJson(p) ?? {};
     existing.mcp = {
       ...existing.mcp ?? {},
       blitzstrike: { type: "local", command: [command, ...args], enabled: true }
     };
-    writeFileSync10(p, JSON.stringify(existing, null, 2));
+    writeFileSync11(p, JSON.stringify(existing, null, 2));
     copyOpenCodeAgents();
   };
 }
 function copyOpenCodeAgents() {
-  const srcDir = join33(ROOT14, "opencode-agents");
-  const dstDir = join33(homedir12(), ".config", "opencode", "agents");
-  if (!existsSync18(srcDir))
+  const srcDir = join34(ROOT14, "opencode-agents");
+  const dstDir = join34(homedir13(), ".config", "opencode", "agents");
+  if (!existsSync19(srcDir))
     return;
-  if (!existsSync18(dstDir))
-    mkdirSync11(dstDir, { recursive: true });
+  if (!existsSync19(dstDir))
+    mkdirSync12(dstDir, { recursive: true });
   for (const f of ["Blitz Strike.md", "Blitz.md", "Eagle Eye.md", "Strike.md"]) {
-    const src = join33(srcDir, f);
-    const dst = join33(dstDir, f);
-    if (existsSync18(src)) {
-      writeFileSync10(dst, readFileSync35(src, "utf8"));
+    const src = join34(srcDir, f);
+    const dst = join34(dstDir, f);
+    if (existsSync19(src)) {
+      writeFileSync11(dst, readFileSync36(src, "utf8"));
     }
   }
 }
 function codexWrite(p) {
   return (command, args) => {
     const dir = dirname6(p);
-    if (!existsSync18(dir))
-      mkdirSync11(dir, { recursive: true });
-    let existing = existsSync18(p) ? readFileSync35(p, "utf8") : "";
+    if (!existsSync19(dir))
+      mkdirSync12(dir, { recursive: true });
+    let existing = existsSync19(p) ? readFileSync36(p, "utf8") : "";
     if (!existing.trimEnd().endsWith(`
 `))
       existing += `
@@ -17855,15 +17855,15 @@ function codexWrite(p) {
 command = "${command}"
 args = ${JSON.stringify(args)}
 `;
-    writeFileSync10(p, existing);
+    writeFileSync11(p, existing);
   };
 }
 function hermesWrite(p) {
   return (command, args) => {
     const dir = dirname6(p);
-    if (!existsSync18(dir))
-      mkdirSync11(dir, { recursive: true });
-    let existing = existsSync18(p) ? readFileSync35(p, "utf8") : "";
+    if (!existsSync19(dir))
+      mkdirSync12(dir, { recursive: true });
+    let existing = existsSync19(p) ? readFileSync36(p, "utf8") : "";
     existing = existing.replace(/^  blitzstrike:\n(?:    .*\n?)*/m, "");
     if (!existing.trimEnd().endsWith(`
 `))
@@ -17884,80 +17884,80 @@ mcp_servers:
     args: ${JSON.stringify(args)}
 `;
     }
-    writeFileSync10(p, existing);
+    writeFileSync11(p, existing);
   };
 }
 function detectAgents() {
-  const home = homedir12();
+  const home = homedir13();
   const agents = [];
-  const claudeJson = join33(home, ".claude.json");
+  const claudeJson = join34(home, ".claude.json");
   agents.push({
     name: "Claude Code",
     detectPath: claudeJson,
-    installed: () => existsSync18(claudeJson) || which("claude"),
+    installed: () => existsSync19(claudeJson) || which("claude"),
     write: jsonMcpServersWrite(claudeJson)
   });
-  const claudeDesktop = join33(home, ".config", "Claude", "claude_desktop_config.json");
+  const claudeDesktop = join34(home, ".config", "Claude", "claude_desktop_config.json");
   agents.push({
     name: "Claude Desktop",
     detectPath: claudeDesktop,
-    installed: () => existsSync18(claudeDesktop),
+    installed: () => existsSync19(claudeDesktop),
     write: jsonMcpServersWrite(claudeDesktop)
   });
-  const cursor = join33(home, ".cursor", "mcp.json");
+  const cursor = join34(home, ".cursor", "mcp.json");
   agents.push({
     name: "Cursor",
     detectPath: cursor,
-    installed: () => existsSync18(join33(home, ".cursor")) || which("cursor"),
+    installed: () => existsSync19(join34(home, ".cursor")) || which("cursor"),
     write: jsonMcpServersWrite(cursor)
   });
-  const opencode = join33(home, ".config", "opencode", "opencode.jsonc");
+  const opencode = join34(home, ".config", "opencode", "opencode.jsonc");
   agents.push({
     name: "OpenCode",
     detectPath: opencode,
-    installed: () => existsSync18(join33(home, ".config", "opencode")) || which("opencode"),
+    installed: () => existsSync19(join34(home, ".config", "opencode")) || which("opencode"),
     write: opencodeWrite(opencode)
   });
-  const codex = join33(home, ".codex", "config.toml");
+  const codex = join34(home, ".codex", "config.toml");
   agents.push({
     name: "Codex",
     detectPath: codex,
-    installed: () => existsSync18(join33(home, ".codex")) || which("codex"),
+    installed: () => existsSync19(join34(home, ".codex")) || which("codex"),
     write: codexWrite(codex)
   });
-  const hermes = join33(home, ".hermes", "config.yaml");
+  const hermes = join34(home, ".hermes", "config.yaml");
   agents.push({
     name: "Hermes",
     detectPath: hermes,
-    installed: () => existsSync18(join33(home, ".hermes")) || which("hermes"),
+    installed: () => existsSync19(join34(home, ".hermes")) || which("hermes"),
     write: hermesWrite(hermes)
   });
-  const gemini = join33(home, ".gemini", "settings.json");
+  const gemini = join34(home, ".gemini", "settings.json");
   agents.push({
     name: "Gemini CLI",
     detectPath: gemini,
-    installed: () => existsSync18(join33(home, ".gemini")) || which("gemini"),
+    installed: () => existsSync19(join34(home, ".gemini")) || which("gemini"),
     write: jsonMcpServersWrite(gemini)
   });
-  const windsurf = join33(home, ".codeium", "windsurf", "mcp_config.json");
+  const windsurf = join34(home, ".codeium", "windsurf", "mcp_config.json");
   agents.push({
     name: "Windsurf",
     detectPath: windsurf,
-    installed: () => existsSync18(join33(home, ".codeium")) || which("windsurf"),
+    installed: () => existsSync19(join34(home, ".codeium")) || which("windsurf"),
     write: jsonMcpServersWrite(windsurf)
   });
-  const copilot = join33(home, ".copilot", "mcp.json");
+  const copilot = join34(home, ".copilot", "mcp.json");
   agents.push({
     name: "Copilot",
     detectPath: copilot,
-    installed: () => existsSync18(join33(home, ".copilot")),
+    installed: () => existsSync19(join34(home, ".copilot")),
     write: jsonMcpServersWrite(copilot)
   });
-  const cline = join33(home, ".cline", "mcp_settings.json");
+  const cline = join34(home, ".cline", "mcp_settings.json");
   agents.push({
     name: "Cline",
     detectPath: cline,
-    installed: () => existsSync18(join33(home, ".cline")),
+    installed: () => existsSync19(join34(home, ".cline")),
     write: jsonMcpServersWrite(cline)
   });
   return agents;
@@ -18075,7 +18075,7 @@ var init_cli = __esm(() => {
   init_release();
   init_dependency();
   init_mcp_status();
-  ROOT14 = join33(fileURLToPath21(new URL(".", import.meta.url)), "..");
+  ROOT14 = join34(fileURLToPath21(new URL(".", import.meta.url)), "..");
 });
 
 // node_modules/zod/v3/helpers/util.js
@@ -32713,7 +32713,7 @@ class StdioServerTransport {
 
 // src/server.ts
 init_scanner();
-import { readFileSync as readFileSync32 } from "node:fs";
+import { readFileSync as readFileSync33 } from "node:fs";
 import { execFileSync as execFileSync8 } from "node:child_process";
 
 // src/review-harness.ts
@@ -60607,19 +60607,156 @@ async function paramSurface(target, class_) {
   return { ...result, url: base, status_hint: status === 0 ? "fetch failed" : `http ${status}` };
 }
 
-// src/benchmark.ts
-import { readFileSync as readFileSync26, readdirSync as readdirSync7, writeFileSync as writeFileSync6, rmSync as rmSync3, mkdirSync as mkdirSync7 } from "node:fs";
+// src/circuit-breaker.ts
+import { readFileSync as readFileSync26, writeFileSync as writeFileSync6, mkdirSync as mkdirSync7, existsSync as existsSync13 } from "node:fs";
 import { join as join26 } from "node:path";
+import { homedir as homedir9 } from "node:os";
+var HOME_DIR4 = process.env.BLITZSTRIKE_HOME ?? join26(homedir9(), ".blitzstrike");
+var STATE_PATH = join26(HOME_DIR4, "circuit-breaker.json");
+function loadState() {
+  try {
+    if (existsSync13(STATE_PATH))
+      return JSON.parse(readFileSync26(STATE_PATH, "utf8"));
+  } catch {}
+  return { targets: {} };
+}
+function saveState(s) {
+  try {
+    mkdirSync7(HOME_DIR4, { recursive: true });
+    writeFileSync6(STATE_PATH, JSON.stringify(s, null, 2));
+  } catch {}
+}
+async function targetHealth(target, limit = 5) {
+  const state = loadState();
+  const entry = state.targets[target] ?? { consecutive_failures: 0, last_checked: "", circuit: "closed" };
+  let healthy = false;
+  let status;
+  const t0 = Date.now();
+  try {
+    const res = await fetch(target, { method: "GET", redirect: "follow", signal: AbortSignal.timeout(1e4), headers: { "User-Agent": "Mozilla/5.0 (compatible; BlitzStrike/2.4)" } });
+    status = res.status;
+    healthy = res.status < 500;
+  } catch {
+    healthy = false;
+  }
+  const responseMs = Date.now() - t0;
+  if (healthy) {
+    entry.consecutive_failures = 0;
+    entry.circuit = "closed";
+    entry.opened_at = undefined;
+  } else {
+    entry.consecutive_failures += 1;
+    if (entry.consecutive_failures >= limit) {
+      entry.circuit = "open";
+      entry.opened_at = entry.opened_at ?? new Date().toISOString();
+    }
+  }
+  entry.last_checked = new Date().toISOString();
+  state.targets[target] = entry;
+  saveState(state);
+  const advice = entry.circuit === "open" ? `CIRCUIT OPEN after ${entry.consecutive_failures} consecutive failures — PAUSE this target and resume when it recovers (the circuit auto-closes on the next successful target_health probe).` : healthy ? `target responsive (HTTP ${status}) — safe to continue.` : `${entry.consecutive_failures}/${limit} consecutive failures — target degraded; consider slowing down or pausing before ${limit}.`;
+  return { target, healthy, status_code: status, response_ms: responseMs, consecutive_failures: entry.consecutive_failures, circuit: entry.circuit, advice };
+}
+function circuitStatus() {
+  const state = loadState();
+  const targets = Object.entries(state.targets).map(([target, s]) => ({ target, ...s }));
+  targets.sort((a, b) => b.consecutive_failures - a.consecutive_failures || (a.circuit === "open" ? -1 : 1));
+  return { targets, open_count: targets.filter((t) => t.circuit === "open").length };
+}
+
+// src/totp.ts
+import { createHmac as createHmac2 } from "node:crypto";
+function base32Decode(secret) {
+  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+  const clean = secret.toUpperCase().replace(/=+$/g, "").replace(/[\s-]/g, "");
+  let bits = 0;
+  let value = 0;
+  const out = [];
+  for (const ch of clean) {
+    const idx = alphabet.indexOf(ch);
+    if (idx === -1)
+      continue;
+    value = value << 5 | idx;
+    bits += 5;
+    if (bits >= 8) {
+      out.push(value >>> bits - 8 & 255);
+      bits -= 8;
+    }
+  }
+  return Buffer.from(out);
+}
+function keyFromSecret(secret) {
+  const trimmed = secret.trim();
+  return /^[A-Za-z2-7]+=?$/.test(trimmed) ? base32Decode(trimmed) : Buffer.from(trimmed, "utf8");
+}
+function hotp(secret, counter, digits, algo) {
+  const key = keyFromSecret(secret);
+  const buf = Buffer.alloc(8);
+  let c = Math.max(0, Math.floor(counter));
+  for (let i = 7;i >= 0; i--) {
+    buf[i] = c & 255;
+    c = Math.floor(c / 256);
+  }
+  const mac = createHmac2(algo, key).update(buf).digest();
+  const offset = mac[mac.length - 1] & 15;
+  const bin = (mac[offset] & 127) << 24 | (mac[offset + 1] & 255) << 16 | (mac[offset + 2] & 255) << 8 | mac[offset + 3] & 255;
+  return String(bin % 10 ** digits).padStart(digits, "0");
+}
+function totp(secret, opts) {
+  const digits = opts?.digits ?? 6;
+  const period = opts?.period ?? 30;
+  const algo = opts?.algo ?? "sha1";
+  const now = Math.floor(Date.now() / 1000);
+  const counter = Math.floor(now / period);
+  const token = hotp(secret, counter, digits, algo);
+  return {
+    token,
+    expires_in: period - now % period,
+    algorithm: algo,
+    digits,
+    period,
+    secret_format: /^[A-Za-z2-7]+=?$/.test(secret.trim()) ? "base32" : "raw"
+  };
+}
+function hotpToken(secret, counter, opts) {
+  return hotp(secret, counter, opts?.digits ?? 6, opts?.algo ?? "sha1");
+}
+
+// src/wet-dry.ts
+function sha2562(text) {
+  let h = 5381;
+  for (let i = 0;i < text.length; i++)
+    h = (h << 5) + h + text.charCodeAt(i) >>> 0;
+  return `djb2-${h.toString(16).padStart(8, "0")}`;
+}
+function wetDryTrace(type, wet, dry, dryOk = true) {
+  const wetOk = wet.trim().length > 0;
+  const diagnosis = !wetOk ? "WET broken — raw output empty/garbage (model, prompt, or timeout problem). Fix the model/prompt, not the parser." : !dryOk ? "DRY broken — raw OK but parse failed (regex/JSON-malformed). Fix the parser, not the model." : "OK — raw and parsed both present. If the report is still bad, the template is the problem.";
+  return {
+    type,
+    wet: wet.trim(),
+    dry: dry.trim(),
+    wet_ok: wetOk,
+    dry_ok: dryOk,
+    diagnosis,
+    sha256_wet: sha2562(wet),
+    sha256_dry: sha2562(dry)
+  };
+}
+
+// src/benchmark.ts
+import { readFileSync as readFileSync27, readdirSync as readdirSync7, writeFileSync as writeFileSync7, rmSync as rmSync3, mkdirSync as mkdirSync8 } from "node:fs";
+import { join as join27 } from "node:path";
 import { fileURLToPath as fileURLToPath16 } from "node:url";
-import { tmpdir as tmpdir3, homedir as homedir9 } from "node:os";
+import { tmpdir as tmpdir3, homedir as homedir10 } from "node:os";
 init_complex_bugs();
-var ROOT9 = join26(fileURLToPath16(new URL(".", import.meta.url)), "..");
-var CORPUS = join26(ROOT9, "bench", "corpus");
-var CAPTURED_CORPUS_DIR = process.env.BLITZSTRIKE_CORPUS_DIR ?? join26(homedir9(), ".blitzstrike", "corpus");
+var ROOT9 = join27(fileURLToPath16(new URL(".", import.meta.url)), "..");
+var CORPUS = join27(ROOT9, "bench", "corpus");
+var CAPTURED_CORPUS_DIR = process.env.BLITZSTRIKE_CORPUS_DIR ?? join27(homedir10(), ".blitzstrike", "corpus");
 function parseCorpusFile(path) {
   let text;
   try {
-    text = readFileSync26(path, "utf8");
+    text = readFileSync27(path, "utf8");
   } catch {
     return null;
   }
@@ -60675,7 +60812,7 @@ function loadDir(dir) {
     for (const f of readdirSync7(dir)) {
       if (!f.endsWith(".md"))
         continue;
-      const e = parseCorpusFile(join26(dir, f));
+      const e = parseCorpusFile(join27(dir, f));
       if (e)
         entries.push(e);
     }
@@ -60686,7 +60823,7 @@ function loadCorpus2() {
   return [...loadDir(CORPUS), ...loadDir(CAPTURED_CORPUS_DIR)];
 }
 function captureFalsePositive(input) {
-  mkdirSync7(CAPTURED_CORPUS_DIR, { recursive: true });
+  mkdirSync8(CAPTURED_CORPUS_DIR, { recursive: true });
   const slug = (input.note ?? "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "captured";
   const id = `fp-${slug}-${Date.now().toString(36)}`;
   const ext = { php: "php", javascript: "js", typescript: "ts", python: "py", java: "java", js: "js" }[input.language.toLowerCase()] ?? input.language;
@@ -60702,8 +60839,8 @@ function captureFalsePositive(input) {
     input.code,
     "```"
   ].filter((l) => l !== null);
-  const path = join26(CAPTURED_CORPUS_DIR, `${id}.md`);
-  writeFileSync6(path, lines.join(`
+  const path = join27(CAPTURED_CORPUS_DIR, `${id}.md`);
+  writeFileSync7(path, lines.join(`
 `) + `
 `, "utf8");
   const entry = { id, language: input.language.toLowerCase(), vulnerable: false, detector: input.detector, note: input.note, sink_type: input.sink_type, code: input.code };
@@ -60724,8 +60861,8 @@ function detect(entry) {
   }
   const lang = entry.language;
   if (lang === "php") {
-    const tmp = join26(tmpdir3(), `blitzstrike-bench-${entry.id}-${process.pid}.php`);
-    writeFileSync6(tmp, entry.code);
+    const tmp = join27(tmpdir3(), `blitzstrike-bench-${entry.id}-${process.pid}.php`);
+    writeFileSync7(tmp, entry.code);
     const r = analyzeDataFlow2(tmp);
     rmSync3(tmp, { force: true });
     if (r.findings.length > 0)
@@ -60793,25 +60930,25 @@ function runBenchmark() {
 }
 
 // src/obligations.ts
-import { readFileSync as readFileSync27, appendFileSync as appendFileSync4, mkdirSync as mkdirSync8, existsSync as existsSync13, writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join27 } from "node:path";
+import { readFileSync as readFileSync28, appendFileSync as appendFileSync4, mkdirSync as mkdirSync9, existsSync as existsSync14, writeFileSync as writeFileSync8 } from "node:fs";
+import { join as join28 } from "node:path";
 import { createHash as createHash6 } from "node:crypto";
-import { homedir as homedir10 } from "node:os";
-var HOME_DIR4 = process.env.BLITZSTRIKE_HOME ?? join27(homedir10(), ".blitzstrike");
-var OBLIGATION_PATH = join27(HOME_DIR4, "obligations.jsonl");
+import { homedir as homedir11 } from "node:os";
+var HOME_DIR5 = process.env.BLITZSTRIKE_HOME ?? join28(homedir11(), ".blitzstrike");
+var OBLIGATION_PATH = join28(HOME_DIR5, "obligations.jsonl");
 function ensureDir3() {
-  if (!existsSync13(HOME_DIR4))
-    mkdirSync8(HOME_DIR4, { recursive: true });
+  if (!existsSync14(HOME_DIR5))
+    mkdirSync9(HOME_DIR5, { recursive: true });
 }
 function shortId2(claim) {
   return `obl-${createHash6("sha256").update(`${claim}\x00${Date.now()}`).digest("hex").slice(0, 12)}`;
 }
 function loadObligations() {
-  if (!existsSync13(OBLIGATION_PATH))
+  if (!existsSync14(OBLIGATION_PATH))
     return [];
   try {
     const out = [];
-    for (const line of readFileSync27(OBLIGATION_PATH, "utf8").split(`
+    for (const line of readFileSync28(OBLIGATION_PATH, "utf8").split(`
 `)) {
       const t = line.trim();
       if (!t)
@@ -60832,7 +60969,7 @@ function append3(o) {
 }
 function rewrite(entries) {
   ensureDir3();
-  writeFileSync7(OBLIGATION_PATH, entries.map((e) => JSON.stringify(e)).join(`
+  writeFileSync8(OBLIGATION_PATH, entries.map((e) => JSON.stringify(e)).join(`
 `) + (entries.length ? `
 ` : ""));
 }
@@ -60915,11 +61052,11 @@ init_framework_security();
 // src/variant-scan.ts
 init_scanner();
 init_complex_bugs();
-import { readFileSync as readFileSync29 } from "node:fs";
+import { readFileSync as readFileSync30 } from "node:fs";
 
 // src/cross-file.ts
 init_scanner();
-import { readFileSync as readFileSync28 } from "node:fs";
+import { readFileSync as readFileSync29 } 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)['"]/;
@@ -60971,7 +61108,7 @@ function detectCrossFilePrivesc(root) {
   for (const file of files) {
     let code;
     try {
-      code = stripComments(readFileSync28(file, "utf8"));
+      code = stripComments(readFileSync29(file, "utf8"));
     } catch {
       continue;
     }
@@ -61012,7 +61149,7 @@ function detectCrossFilePrivesc(root) {
   for (const file of files) {
     let code;
     try {
-      code = stripComments(readFileSync28(file, "utf8"));
+      code = stripComments(readFileSync29(file, "utf8"));
     } catch {
       continue;
     }
@@ -61035,7 +61172,7 @@ function detectCrossFilePrivesc(root) {
   for (const file of files) {
     let code;
     try {
-      code = stripComments(readFileSync28(file, "utf8"));
+      code = stripComments(readFileSync29(file, "utf8"));
     } catch {
       continue;
     }
@@ -61150,7 +61287,7 @@ function variantScan(root, opts = {}) {
   for (const file of files) {
     let code;
     try {
-      code = readFileSync29(file, "utf8");
+      code = readFileSync30(file, "utf8");
     } catch {
       continue;
     }
@@ -61707,7 +61844,7 @@ async function raceTest(input) {
 }
 
 // src/jwt-analyze.ts
-import { createHmac as createHmac2 } from "node:crypto";
+import { createHmac as createHmac3 } from "node:crypto";
 function b64urlDecode2(seg) {
   return Buffer.from(seg.replace(/-/g, "+").replace(/_/g, "/"), "base64").toString("utf8");
 }
@@ -61773,7 +61910,7 @@ function analyzeJwt(token, opts = {}) {
   if (/^HS\d+$/i.test(alg) && signature && opts.wordlist && opts.wordlist.length > 0) {
     const data = `${token.split(".")[0]}.${token.split(".")[1]}`;
     for (const w of opts.wordlist.slice(0, 1e4)) {
-      const sig = createHmac2("sha256", w).update(data).digest("base64url");
+      const sig = createHmac3("sha256", w).update(data).digest("base64url");
       if (sig === signature) {
         findings.push({
           type: "weak_secret",
@@ -61814,7 +61951,7 @@ import { spawn as spawn3, execSync as execSync2 } from "node:child_process";
 import { createServer } from "node:http";
 import { randomUUID } from "node:crypto";
 import { networkInterfaces } from "node:os";
-import { existsSync as existsSync14 } from "node:fs";
+import { existsSync as existsSync15 } from "node:fs";
 var sessions = new Map;
 function sleep(ms) {
   return new Promise((r) => setTimeout(r, ms));
@@ -61828,7 +61965,7 @@ function findInteractsh() {
   const home = process.env.HOME ?? "/root";
   const candidates = [`${home}/go/bin/interactsh-client`, "/usr/local/bin/interactsh-client", "/usr/bin/interactsh-client"];
   for (const c of candidates)
-    if (existsSync14(c))
+    if (existsSync15(c))
       return c;
   return null;
 }
@@ -62833,9 +62970,9 @@ function listPocTypes() {
 
 // src/foundry-run.ts
 import { execSync as execSync3 } from "node:child_process";
-import { mkdtempSync as mkdtempSync3, mkdirSync as mkdirSync9, writeFileSync as writeFileSync8, rmSync as rmSync4, existsSync as existsSync15 } from "node:fs";
+import { mkdtempSync as mkdtempSync3, mkdirSync as mkdirSync10, writeFileSync as writeFileSync9, rmSync as rmSync4, existsSync as existsSync16 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { join as join28 } from "node:path";
+import { join as join29 } from "node:path";
 function findForge() {
   try {
     const p = execSync3("which forge 2>/dev/null", { encoding: "utf8", timeout: 3000 }).trim();
@@ -62845,7 +62982,7 @@ function findForge() {
   const home = process.env.HOME ?? "/root";
   const candidates = [`${home}/.foundry/bin/forge`, "/usr/local/bin/forge", "/usr/bin/forge"];
   for (const c of candidates)
-    if (existsSync15(c))
+    if (existsSync16(c))
       return c;
   return null;
 }
@@ -62884,14 +63021,14 @@ async function foundryRun(input) {
     };
   }
   const poc = input.poc_code ?? foundryPoc(input.class_ ?? "missing_access_control", name);
-  const dir = mkdtempSync3(join28(tmpdir4(), "blitzstrike-foundry-"));
+  const dir = mkdtempSync3(join29(tmpdir4(), "blitzstrike-foundry-"));
   try {
     try {
       execSync3(`${forge} init --force --no-git ${dir}`, { stdio: "ignore", timeout: 60000 });
     } catch {
-      mkdirSync9(join28(dir, "src"), { recursive: true });
-      mkdirSync9(join28(dir, "test"), { recursive: true });
-      writeFileSync8(join28(dir, "foundry.toml"), `[profile.default]
+      mkdirSync10(join29(dir, "src"), { recursive: true });
+      mkdirSync10(join29(dir, "test"), { recursive: true });
+      writeFileSync9(join29(dir, "foundry.toml"), `[profile.default]
 src = "src"
 out = "out"
 libs = ["lib"]
@@ -62901,12 +63038,12 @@ solc = "0.8.20"
     for (const f of ["Counter.sol", "Counter.t.sol", "Counter.s.sol"]) {
       for (const sub of ["src", "test", "script"]) {
         try {
-          rmSync4(join28(dir, sub, f), { force: true });
+          rmSync4(join29(dir, sub, f), { force: true });
         } catch {}
       }
     }
-    writeFileSync8(join28(dir, "src", `${name}.sol`), input.contract_code);
-    writeFileSync8(join28(dir, "test", `${name}.t.sol`), poc);
+    writeFileSync9(join29(dir, "src", `${name}.sol`), input.contract_code);
+    writeFileSync9(join29(dir, "test", `${name}.t.sol`), poc);
     const { out } = runForge(forge, dir, input.timeout_ms ?? 60000);
     const tests = parseTestResults(out);
     const anyFail = tests.some((t) => t.status === "fail");
@@ -62924,18 +63061,18 @@ solc = "0.8.20"
 }
 
 // src/enterprise-benchmark.ts
-import { existsSync as existsSync16, readFileSync as readFileSync30, readdirSync as readdirSync8, statSync as statSync5 } from "node:fs";
-import { join as join29, resolve } from "node:path";
+import { existsSync as existsSync17, readFileSync as readFileSync31, readdirSync as readdirSync8, statSync as statSync5 } from "node:fs";
+import { join as join30, resolve } from "node:path";
 import { fileURLToPath as fileURLToPath17 } from "node:url";
 init_complex_bugs();
 var ROOT10 = resolve(fileURLToPath17(new URL(".", import.meta.url)), "..", "bench", "enterprise");
 var ENTERPRISE_FIXTURES = [
-  { id: "php-laravel", dir: join29(ROOT10, "php-laravel"), expected_vulns: 4 },
-  { id: "js-express", dir: join29(ROOT10, "js-express"), expected_vulns: 2 },
-  { id: "py-django", dir: join29(ROOT10, "py-django"), expected_vulns: 2 },
-  { id: "java-spring", dir: join29(ROOT10, "java-spring"), expected_vulns: 2 },
-  { id: "wp-batch-route", dir: join29(ROOT10, "wp-batch-route"), expected_vulns: 3 },
-  { id: "php-complex", dir: join29(ROOT10, "php-complex"), expected_vulns: 4 }
+  { id: "php-laravel", dir: join30(ROOT10, "php-laravel"), expected_vulns: 4 },
+  { id: "js-express", dir: join30(ROOT10, "js-express"), expected_vulns: 2 },
+  { id: "py-django", dir: join30(ROOT10, "py-django"), expected_vulns: 2 },
+  { id: "java-spring", dir: join30(ROOT10, "java-spring"), expected_vulns: 2 },
+  { id: "wp-batch-route", dir: join30(ROOT10, "wp-batch-route"), expected_vulns: 3 },
+  { id: "php-complex", dir: join30(ROOT10, "php-complex"), expected_vulns: 4 }
 ];
 function sourceFiles(root) {
   const out = [];
@@ -62947,7 +63084,7 @@ function sourceFiles(root) {
       return;
     }
     for (const e of entries) {
-      const p = join29(dir, e);
+      const p = join30(dir, e);
       let st;
       try {
         st = statSync5(p);
@@ -62968,7 +63105,7 @@ function detectFixture(dir) {
   for (const f of sourceFiles(dir)) {
     let code;
     try {
-      code = readFileSync30(f, "utf8");
+      code = readFileSync31(f, "utf8");
     } catch {
       continue;
     }
@@ -62986,7 +63123,7 @@ function detectFixture(dir) {
 function runEnterpriseBenchmark() {
   const fixtures = [];
   for (const fx of ENTERPRISE_FIXTURES) {
-    if (!existsSync16(fx.dir)) {
+    if (!existsSync17(fx.dir)) {
       fixtures.push({ id: fx.id, available: false, detected: 0, expected: fx.expected_vulns, recall: 0 });
       continue;
     }
@@ -63181,7 +63318,7 @@ function createServer2() {
 ` + `- 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). Ground any detector hit empirically with pattern_lookup(id) — it returns the class's CWE, real-world signature, escalation chains, citable references, per-class bypass techniques, and the high-value assets (crown jewels) that class hits, so a raw hit becomes a class-aware finding. Resolve free-form terminology first with synonym_lookup(term) (IDOR/BOLA/SQLi/prompt-injection → canonical id). For an llm_injection hit, its pattern carries a validation discipline — the RUN-TWICE RULE (reproduce token-for-token across two fresh sessions), NON-GUESSABLE ANCHOR (must leak a real key/URL, not a plausible guess), and OOB PROOF (a verifiable callback log) — apply all three before reporting. 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. Generate the concrete reproduction recipe with auto_poc(type, base_url, endpoint, param) — it emits the exact marker request + negative control + expected differential + Patchstack-style title, so 'reproducible' is executable, not abstract. 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. HUNTING DOCTRINE (maximize payout rate): (1) SIBLING RULE — if one endpoint requires auth, check every sibling (/export /delete /share); ~30% of paid IDOR/auth bugs come from siblings — AUTOMATE it with sibling_scan(base_url, endpoint, token_a, token_b), the deterministic live logic-bug prober (sibling enumeration + differential IDOR + auth matrix + mass assignment + rate limit, evidence-first). (2) A→B SIGNAL — a confirmed bug signals a class of developer mistake; hunt B and C (20-min box) before reporting. (3) TWO-ACCOUNT IDOR — always test with attacker account A reading victim account B, and state it in the report. (4) PoC ESCALATION — IDOR shows victim data (not 200), XSS shows cookie exfil (not alert), SSRF shows internal response (not DNS), SQLi shows DB content (not error). (5) FOLLOW THE MONEY — billing/credits/refunds/wallet flows. (6) Kill weak findings with kill_list(type) BEFORE the gate — missing headers, self-XSS, open-redirect-alone, SSRF-DNS-only, GraphQL-introspection-alone are always N/A standalone. (7) CI/CD + SAML/SSO are critical attack surfaces (pull_request_target, expression injection, XML signature wrapping, comment injection). Full doctrine: hunting_doctrine(). WHAT TO HUNT NEXT: watchlist() returns the ranked CWE frequency + high-value CVEs with payout + a saturated flag (prioritize high-freq/high-payout/not-saturated: missing-authz, SQLi, SSRF, deserialization; skip saturated XSS/CSRF/open-redirect unless they chain into takeover). The CVE watchlist now spans 4,000+ product fingerprints (live from nuclei-templates when installed — refresh with sync_cve_corpus() before a big recon pass); live_recon's suggested_cves names the SPECIFIC CVE for the detected product/version — then cve_verify(cve, target) CONFIRMS it live by running the matching nuclei template (VERIFIED only when nuclei actually matches; a CVE is report-ready only after cve_verify, never from the fingerprint alone). For 'scan this target' automation, nuclei_scan(target) fingerprints the stack and runs the WHOLE matched template set (CVE templates + optional broad tech-tag) in one rate-limited pass — use it instead of verifying CVEs one-by-one. SURFACE-FIRST: surface_map(surface) maps an attack surface (image/redirect proxy, edge cache, payment portal, AI agent, file service, Electron, SSO) to its highest-value tests — map surfaces then test, don't spray payloads; then param_surface(target, class) discovers EVERY testable parameter (URL query, form fields, /users/123 path ids + UUIDs, JS refs) + per-class specialist hints — test the DISCOVERED params, not just the hinted one. PRECISION GUARD: resolve_check(host) detects when an ISP/country redirects the domain to a blocking/sinkhole page (gambling/adult/streaming niches) — audit the PUBLIC IP, never the sinkhole.\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/recall) so a new target on a known tech inherits historical hit-rates (attack_plan already blends them into success_probability). intelligence(action=recall, tech, target) is the per-engagement pattern recall — it returns which patterns historically CONFIRMED on that tech (prioritize them) versus which only ever produced false positives (avoid them), so a new engagement starts from the empirical playbook of past ones. 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; broken_link_scan(url) detects expired-domain takeover (crawls outbound refs → DNS/RDAP → flags claimable domains). Logic-bug live probers: jwt_forge(token, endpoint, …) forges JWT confusion tokens (alg:none / RS256→HS256 key-confusion / kid-jku-x5u) and proves which is ACCEPTED live; proto_pollution_probe(target, endpoint) sends __proto__ / constructor.prototype JSON canaries and reports VERIFIED only on reflection; smuggling_test(target) sends CL.TE / TE.CL desync probes over a raw connection. OOB (out-of-band) PROOF for BLIND vulns: oob_start() spins an interactsh listener (unique *.oast.* domain, streams DNS/HTTP interactions — the standard for public targets) or a local HTTP listener for local labs; inject the canary, then oob_poll(id) until the hit arrives; oob_stop(id) to clean up. A blind SSRF/XXE/SQLi/command-injection is CONFIRMED only when the canary actually arrives — never from a guess. SOURCE TARGETING: review_harness(path) FIRST for full coverage — it applies a fixed 5-signal rubric (entry_points/auth_gates/sinks/secrets/logic_bugs) to EVERY source file and sorts the signal-dense ones first (a complete map, not a partial scan); then 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. For a repo, also scan_git_history(root) — secrets DELETED from HEAD still live in .git history (the removed-later-is-not-fixed trap), and it feeds every recovered pre-deletion blob through the same secret detector. Once you recover a credential, prove it is still ACTIVE with validate_leaked_key(apiBase, endpoints, key|blobUrl) — a READ-ONLY differential test (401-without-key vs 200-with-key = auth bypass PROVEN). Two supply-chain detectors: dependency_confusion (a manifest/build file resolving a package from a public registry — pypi.org/npmjs.org --extra-index-url, or a scoped @company/pkg with no private registry) and ml_supply_chain (torch.load without weights_only=True / joblib.load / np.load(allow_pickle=True) / keras load_model on an untrusted model → pickle RCE). Rust is supported end-to-end: the taint engine (blitz_scan / taint_file) maps Rust sinks (std::process::Command, sqlx/diesel, reqwest/hyper, std::fs, serde/bincode) to the classic classes, plus two Rust-specific detectors — rust_unsafe (transmute / assume_init / from_raw_parts / ptr::* — memory-unsafety surface, CWE-119) and rust_format_string (println!/format! with a variable as the format string — CWE-134). The sqlx query! compile-time macro is treated as safe (suppressed). Two more web-class detectors: jwt_alg_confusion (a JWT verifier that dispatches on the token's alg header and accepts BOTH RS256 and HS256, with the HS256 HMAC secret derived from public/shared key material — CWE-347; the attacker sets alg=HS256 and signs with the public key to forge admin tokens) and cache_deception (a reverse proxy caching static-extension URLs with a cache key that omits the session cookie, over a session-authenticated backend — CWE-525; the victim's cached private response is re-fetched anonymously). TO TRY a jwt_alg_confusion hit: fetch the public key (/.well-known/jwks.json), forge an HS256 token signed with that public key, and confirm admin access. TO TRY a cache_deception hit: request an authenticated path with a static extension appended (.css/.js) and re-fetch it anonymously. Three more detectors: cors_misconfiguration (Access-Control-Allow-Origin reflects the request Origin or is '*' while credentials are true — CWE-942; any site reads the victim's authenticated responses), xss (user input into a DOM sink — innerHTML / dangerouslySetInnerHTML / document.write / .html() / eval — CWE-79), and subdomain_takeover (a dangling CNAME/AliasTarget to a claimable service like *.github.io/*.herokuapp.com/*.amazonaws.com — CWE-404). TO TRY a cors hit: send an evil Origin + confirm the response echoes it with Allow-Credentials:true. TO TRY an xss hit: confirm the sink executes (drive_devtools). TO TRY a takeover hit: verify the CNAME target resolves to an unclaimed/not-found page. Two more client-side detectors: postmessage_no_origin_check (a window message listener that reads event.data but never validates event.origin — CWE-345; any site can drive the handler) and client_trusted_flag (a privilege/entitlement flag like isAdmin/withVip/premium read from request input and used in a security decision — CWE-807/639; derive the flag from server state, never the client). TO TRY a postMessage hit: send a crafted message from an attacker origin and confirm the handler acts on it. TO TRY a client-trusted-flag hit: flip the flag param to true and confirm the privilege is actually granted. WEB3: for Solidity/EVM, call web3_audit(code|path) — a deterministic 13-class smart-contract audit (reentrancy incl. ERC721/ERC1155 callback reentrancy, unchecked return, unchecked arithmetic, tx.origin auth, signature replay, unprotected selfdestruct, delegatecall-to-user-input, missing access control, timestamp dependence, spot-price oracle manipulation incl. slot0/latestRoundData, unbounded loop, abi.encodePacked hash collision, missing address(0) validation) returning ranked findings (class/CWE/severity/line), then foundry_poc(class, contract) to generate an executable Foundry test, and foundry_run(contract_code, poc_code|class_) to actually EXECUTE it — a PASSING PoC test is the proof that the exploit reproduces (deterministic: forge's own test verdict). A web3 hit is a HYPOTHESIS until the Foundry PoC reproduces it.\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, citable references, per-class bypass techniques, and the high-value assets (crown jewels) that class hits, so a raw hit becomes a class-aware finding. Resolve free-form terminology first with synonym_lookup(term) (IDOR/BOLA/SQLi/prompt-injection → canonical id). For an llm_injection hit, its pattern carries a validation discipline — the RUN-TWICE RULE (reproduce token-for-token across two fresh sessions), NON-GUESSABLE ANCHOR (must leak a real key/URL, not a plausible guess), and OOB PROOF (a verifiable callback log) — apply all three before reporting. 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. When a PoC/report comes out under-enriched, wet_dry(type, wet, dry) diagnoses WHERE it broke — WET (model/prompt/timeout) vs DRY (parser) vs template. Generate the concrete reproduction recipe with auto_poc(type, base_url, endpoint, param) — it emits the exact marker request + negative control + expected differential + Patchstack-style title, so 'reproducible' is executable, not abstract. 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. HUNTING DOCTRINE (maximize payout rate): (1) SIBLING RULE — if one endpoint requires auth, check every sibling (/export /delete /share); ~30% of paid IDOR/auth bugs come from siblings — AUTOMATE it with sibling_scan(base_url, endpoint, token_a, token_b), the deterministic live logic-bug prober (sibling enumeration + differential IDOR + auth matrix + mass assignment + rate limit, evidence-first). (2) A→B SIGNAL — a confirmed bug signals a class of developer mistake; hunt B and C (20-min box) before reporting. (3) TWO-ACCOUNT IDOR — always test with attacker account A reading victim account B, and state it in the report. (4) PoC ESCALATION — IDOR shows victim data (not 200), XSS shows cookie exfil (not alert), SSRF shows internal response (not DNS), SQLi shows DB content (not error). (5) FOLLOW THE MONEY — billing/credits/refunds/wallet flows. (6) Kill weak findings with kill_list(type) BEFORE the gate — missing headers, self-XSS, open-redirect-alone, SSRF-DNS-only, GraphQL-introspection-alone are always N/A standalone. (7) CI/CD + SAML/SSO are critical attack surfaces (pull_request_target, expression injection, XML signature wrapping, comment injection). Full doctrine: hunting_doctrine(). WHAT TO HUNT NEXT: watchlist() returns the ranked CWE frequency + high-value CVEs with payout + a saturated flag (prioritize high-freq/high-payout/not-saturated: missing-authz, SQLi, SSRF, deserialization; skip saturated XSS/CSRF/open-redirect unless they chain into takeover). The CVE watchlist now spans 4,000+ product fingerprints (live from nuclei-templates when installed — refresh with sync_cve_corpus() before a big recon pass); live_recon's suggested_cves names the SPECIFIC CVE for the detected product/version — then cve_verify(cve, target) CONFIRMS it live by running the matching nuclei template (VERIFIED only when nuclei actually matches; a CVE is report-ready only after cve_verify, never from the fingerprint alone). For 'scan this target' automation, nuclei_scan(target) fingerprints the stack and runs the WHOLE matched template set (CVE templates + optional broad tech-tag) in one rate-limited pass — use it instead of verifying CVEs one-by-one. SURFACE-FIRST: surface_map(surface) maps an attack surface (image/redirect proxy, edge cache, payment portal, AI agent, file service, Electron, SSO) to its highest-value tests — map surfaces then test, don't spray payloads; then param_surface(target, class) discovers EVERY testable parameter (URL query, form fields, /users/123 path ids + UUIDs, JS refs) + per-class specialist hints — test the DISCOVERED params, not just the hinted one. PRECISION GUARD: resolve_check(host) detects when an ISP/country redirects the domain to a blocking/sinkhole page (gambling/adult/streaming niches) — audit the PUBLIC IP, never the sinkhole. CIRCUIT BREAKER: target_health(target) probes the target and tracks consecutive failures — if the circuit OPENS (5 consecutive timeouts/5xx) PAUSE the target and resume when it recovers (auto-closes on a successful probe); circuit_status() lists every tracked target's state.\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/recall) so a new target on a known tech inherits historical hit-rates (attack_plan already blends them into success_probability). intelligence(action=recall, tech, target) is the per-engagement pattern recall — it returns which patterns historically CONFIRMED on that tech (prioritize them) versus which only ever produced false positives (avoid them), so a new engagement starts from the empirical playbook of past ones. 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; broken_link_scan(url) detects expired-domain takeover (crawls outbound refs → DNS/RDAP → flags claimable domains). Logic-bug live probers: jwt_forge(token, endpoint, …) forges JWT confusion tokens (alg:none / RS256→HS256 key-confusion / kid-jku-x5u) and proves which is ACCEPTED live; proto_pollution_probe(target, endpoint) sends __proto__ / constructor.prototype JSON canaries and reports VERIFIED only on reflection; smuggling_test(target) sends CL.TE / TE.CL desync probes over a raw connection; totp(secret) generates an RFC 6238 TOTP token so the agent can fill a 2FA field itself during authenticated scanning. OOB (out-of-band) PROOF for BLIND vulns: oob_start() spins an interactsh listener (unique *.oast.* domain, streams DNS/HTTP interactions — the standard for public targets) or a local HTTP listener for local labs; inject the canary, then oob_poll(id) until the hit arrives; oob_stop(id) to clean up. A blind SSRF/XXE/SQLi/command-injection is CONFIRMED only when the canary actually arrives — never from a guess. SOURCE TARGETING: review_harness(path) FIRST for full coverage — it applies a fixed 5-signal rubric (entry_points/auth_gates/sinks/secrets/logic_bugs) to EVERY source file and sorts the signal-dense ones first (a complete map, not a partial scan); then 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. For a repo, also scan_git_history(root) — secrets DELETED from HEAD still live in .git history (the removed-later-is-not-fixed trap), and it feeds every recovered pre-deletion blob through the same secret detector. Once you recover a credential, prove it is still ACTIVE with validate_leaked_key(apiBase, endpoints, key|blobUrl) — a READ-ONLY differential test (401-without-key vs 200-with-key = auth bypass PROVEN). Two supply-chain detectors: dependency_confusion (a manifest/build file resolving a package from a public registry — pypi.org/npmjs.org --extra-index-url, or a scoped @company/pkg with no private registry) and ml_supply_chain (torch.load without weights_only=True / joblib.load / np.load(allow_pickle=True) / keras load_model on an untrusted model → pickle RCE). Rust is supported end-to-end: the taint engine (blitz_scan / taint_file) maps Rust sinks (std::process::Command, sqlx/diesel, reqwest/hyper, std::fs, serde/bincode) to the classic classes, plus two Rust-specific detectors — rust_unsafe (transmute / assume_init / from_raw_parts / ptr::* — memory-unsafety surface, CWE-119) and rust_format_string (println!/format! with a variable as the format string — CWE-134). The sqlx query! compile-time macro is treated as safe (suppressed). Two more web-class detectors: jwt_alg_confusion (a JWT verifier that dispatches on the token's alg header and accepts BOTH RS256 and HS256, with the HS256 HMAC secret derived from public/shared key material — CWE-347; the attacker sets alg=HS256 and signs with the public key to forge admin tokens) and cache_deception (a reverse proxy caching static-extension URLs with a cache key that omits the session cookie, over a session-authenticated backend — CWE-525; the victim's cached private response is re-fetched anonymously). TO TRY a jwt_alg_confusion hit: fetch the public key (/.well-known/jwks.json), forge an HS256 token signed with that public key, and confirm admin access. TO TRY a cache_deception hit: request an authenticated path with a static extension appended (.css/.js) and re-fetch it anonymously. Three more detectors: cors_misconfiguration (Access-Control-Allow-Origin reflects the request Origin or is '*' while credentials are true — CWE-942; any site reads the victim's authenticated responses), xss (user input into a DOM sink — innerHTML / dangerouslySetInnerHTML / document.write / .html() / eval — CWE-79), and subdomain_takeover (a dangling CNAME/AliasTarget to a claimable service like *.github.io/*.herokuapp.com/*.amazonaws.com — CWE-404). TO TRY a cors hit: send an evil Origin + confirm the response echoes it with Allow-Credentials:true. TO TRY an xss hit: confirm the sink executes (drive_devtools). TO TRY a takeover hit: verify the CNAME target resolves to an unclaimed/not-found page. Two more client-side detectors: postmessage_no_origin_check (a window message listener that reads event.data but never validates event.origin — CWE-345; any site can drive the handler) and client_trusted_flag (a privilege/entitlement flag like isAdmin/withVip/premium read from request input and used in a security decision — CWE-807/639; derive the flag from server state, never the client). TO TRY a postMessage hit: send a crafted message from an attacker origin and confirm the handler acts on it. TO TRY a client-trusted-flag hit: flip the flag param to true and confirm the privilege is actually granted. WEB3: for Solidity/EVM, call web3_audit(code|path) — a deterministic 13-class smart-contract audit (reentrancy incl. ERC721/ERC1155 callback reentrancy, unchecked return, unchecked arithmetic, tx.origin auth, signature replay, unprotected selfdestruct, delegatecall-to-user-input, missing access control, timestamp dependence, spot-price oracle manipulation incl. slot0/latestRoundData, unbounded loop, abi.encodePacked hash collision, missing address(0) validation) returning ranked findings (class/CWE/severity/line), then foundry_poc(class, contract) to generate an executable Foundry test, and foundry_run(contract_code, poc_code|class_) to actually EXECUTE it — a PASSING PoC test is the proof that the exploit reproduces (deterministic: forge's own test verdict). A web3 hit is a HYPOTHESIS until the Foundry PoC reproduces it.\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."
@@ -64072,7 +64209,7 @@ ${statusLine}` : statusLine },
     let src = code;
     if (!src && path) {
       try {
-        src = readFileSync32(path, "utf8");
+        src = readFileSync33(path, "utf8");
       } catch {
         return { content: [{ type: "text", text: JSON.stringify({ error: "unreadable path" }) }] };
       }
@@ -64153,7 +64290,7 @@ ${statusLine}` : statusLine },
     let src = code;
     if (!src && path) {
       try {
-        src = readFileSync32(path, "utf8");
+        src = readFileSync33(path, "utf8");
       } catch {
         return { content: [{ type: "text", text: JSON.stringify({ error: "unreadable path" }) }] };
       }
@@ -64298,6 +64435,49 @@ ${statusLine}` : statusLine },
   }, async ({ target, class_ }) => {
     return { content: [{ type: "text", text: JSON.stringify(await paramSurface(target, class_)) }] };
   });
+  server.registerTool("target_health", {
+    title: "Circuit breaker — probe target health and auto-pause when unresponsive",
+    description: "Probe a target (GET with a 10s timeout) and track consecutive failures in a persisted circuit-breaker state. After 5 consecutive timeouts/5xx the circuit OPENS (PAUSE); it auto-closes on the next successful probe. Check this before a big scan and after repeated failures — do NOT keep hammering an unresponsive target.",
+    inputSchema: {
+      target: string2().describe("Target URL, e.g. https://target.com"),
+      limit: number2().optional().describe("Consecutive-failure threshold (default 5)")
+    }
+  }, async ({ target, limit }) => {
+    return { content: [{ type: "text", text: JSON.stringify(await targetHealth(target, limit ?? 5)) }] };
+  });
+  server.registerTool("circuit_status", {
+    title: "List all circuit-breaker states across targets",
+    description: "Return every tracked target's circuit state (consecutive failures, open/closed) so the agent can see which targets are paused and which are safe to resume.",
+    inputSchema: {}
+  }, async () => {
+    return { content: [{ type: "text", text: JSON.stringify(circuitStatus()) }] };
+  });
+  server.registerTool("totp", {
+    title: "Generate a TOTP/HOTP token (RFC 6238) for 2FA-protected logins",
+    description: "Deterministic one-time-password generation for authenticated scanning: produce the current TOTP token from a base32 secret (or raw ASCII key) so the agent can fill a 2FA field itself. Returns the token + seconds until it rotates.",
+    inputSchema: {
+      secret: string2().describe("TOTP secret (base32 or raw ASCII)"),
+      digits: number2().optional().describe("Token length (default 6)"),
+      period: number2().optional().describe("Time step in seconds (default 30)"),
+      algo: string2().optional().describe("HMAC algorithm sha1/sha256/sha512 (default sha1)"),
+      counter: number2().optional().describe("If set, return HOTP at this counter instead of TOTP")
+    }
+  }, async ({ secret, digits, period, algo, counter }) => {
+    const r = counter === undefined ? totp(secret, { digits, period, algo }) : { token: hotpToken(secret, counter, { digits, algo }), algorithm: algo ?? "sha1", digits: digits ?? 6, period: 0, secret_format: "raw", expires_in: 0 };
+    return { content: [{ type: "text", text: JSON.stringify(r) }] };
+  });
+  server.registerTool("wet_dry", {
+    title: "WET/DRY traceability — diagnose the raw→parsed pipeline",
+    description: "Save the RAW output (WET) and PARSED result (DRY) of an LLM enrichment step separately and get a diagnosis of WHERE a bad deliverable broke: WET broken = model/prompt/timeout problem; WET OK but DRY broken = parser problem; both OK but report bad = template problem. Use when a PoC/report comes out under-enriched.",
+    inputSchema: {
+      type: string2().describe("Step name (e.g. poc_enrichment, report_generation)"),
+      wet: string2().describe("Raw LLM/tool output"),
+      dry: string2().describe("Parsed result (empty if parsing failed)"),
+      dry_ok: boolean2().optional().describe("Whether the parse succeeded (default true)")
+    }
+  }, async ({ type, wet, dry, dry_ok }) => {
+    return { content: [{ type: "text", text: JSON.stringify(wetDryTrace(type, wet, dry, dry_ok ?? true)) }] };
+  });
   server.registerTool("jwt_forge", {
     title: "Forge JWT confusion tokens and verify which is accepted live",
     description: "Turn a captured JWT into forged attack tokens (alg:none, HS256 with empty key, HS256 with the public key = RS256→HS256 key confusion, plus kid/jku/x5u hints) and — when an endpoint is given — send each one to prove which is ACCEPTED (status < 400). A JWT hit is report-ready only when a forged token is accepted, never from header analysis alone.",
@@ -64964,7 +65144,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 = readFileSync32(path, "utf8");
+    const code = readFileSync33(path, "utf8");
     const findings = detectRouteConfusion(code, path);
     return {
       content: [{
@@ -64978,7 +65158,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), missing authorization/nonce on WordPress entry points (wp_ajax_* / admin_post_* / register_rest_route without current_user_can, nonce verification, or permission_callback), CORS misconfiguration (reflected/wildcard origin + credentials), XSS (user input into a DOM sink: innerHTML / dangerouslySetInnerHTML / document.write / .html / eval), and subdomain takeover (CNAME/AliasTarget to a claimable service).",
     inputSchema: { path: string2().describe("Source file path") }
   }, async ({ path }) => {
-    const code = readFileSync32(path, "utf8");
+    const code = readFileSync33(path, "utf8");
     const findings = detectComplexBugs(code, path);
     return {
       content: [{
@@ -65064,7 +65244,7 @@ ${statusLine}` : statusLine },
     let lang = language;
     if (path && !code) {
       try {
-        src = readFileSync32(path, "utf8");
+        src = readFileSync33(path, "utf8");
       } catch {
         return { content: [{ type: "text", text: JSON.stringify({ error: `cannot read ${path}` }) }] };
       }
@@ -65313,15 +65493,15 @@ async function serve() {
 
 // src/index.ts
 init_cli();
-import { readFileSync as readFileSync36, existsSync as existsSync19 } from "node:fs";
-import { join as join34 } from "node:path";
+import { readFileSync as readFileSync37, existsSync as existsSync20 } from "node:fs";
+import { join as join35 } from "node:path";
 import { fileURLToPath as fileURLToPath22 } from "node:url";
-var ROOT15 = join34(fileURLToPath22(new URL(".", import.meta.url)), "..");
+var ROOT15 = join35(fileURLToPath22(new URL(".", import.meta.url)), "..");
 function readVersion() {
   try {
-    const p = join34(ROOT15, "package.json");
-    if (existsSync19(p))
-      return JSON.parse(readFileSync36(p, "utf8")).version ?? "1.0.0";
+    const p = join35(ROOT15, "package.json");
+    if (existsSync20(p))
+      return JSON.parse(readFileSync37(p, "utf8")).version ?? "1.0.0";
   } catch {}
   return "1.0.0";
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blitzstrike",
-  "version": "2.4.122",
+  "version": "2.4.124",
   "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": {