blitzstrike 2.4.14 → 2.4.16

package/CHANGELOG.md

@@ -5,6 +5,30 @@ 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.16] — 2026-09-14
+
+### Added — auto-fallback install (toolchain provision + pip fallback)
+
+- `go install` / `cargo install` tools now auto-provision the missing toolchain
+  (`apt-get install golang-go` / `cargo`) before installing — no more
+  "go: not found" / "cargo: not found" failures (provisioned once per run).
+- `pip install --break-system-packages` now falls back to `pip install --user`
+  when the flag is unsupported (pip < 23.0 on older distros) — no more
+  "no such option: --break-system-packages".
+
+## [2.4.15] — 2026-09-14
+
+### Fixed — detection → verification loop now unmissable
+
+- `run_engagement` / `run_autonomous` now return `status: DETECTED` (was
+  `COMPLETE`), signalling that verification is the NEXT mandatory step instead
+  of implying the job is done with unverified hypotheses.
+- System prompt adds a hard rule: after detection you MUST `strike_verify` /
+  `verify_file_read` / `drive_devtools` each finding before `generate_report`.
+- New generic `verify-phase` playbook (read_playbook) — verdict recipe
+  (confirmed/false-positive/unconfirmed/blocked), tool mapping, no-babysitting
+  rules — so any engagement can load the verify doctrine on demand.
+
 ## [2.4.14] — 2026-09-14
 
 ### Added — mandatory devtools-MCP precision directive

package/dist/index.js

@@ -7403,6 +7403,40 @@ import { join as join6 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { homedir as homedir3 } from "node:os";
 import { spawnSync, spawn } from "node:child_process";
+function hasCommand(cmd) {
+  return spawnSync(`command -v ${cmd}`, { shell: true, timeout: 8000 }).status === 0;
+}
+function requiredToolchain(cmd) {
+  if (/^\s*go\s+install\b/.test(cmd))
+    return "go";
+  if (/^\s*cargo\s+(install|build)\b/.test(cmd))
+    return "cargo";
+  return null;
+}
+function provisionToolchain(cmd) {
+  const tc = requiredToolchain(cmd);
+  if (!tc || hasCommand(tc) || _provisioned.has(tc))
+    return;
+  _provisioned.add(tc);
+  const inst = TOOLCHAIN_INSTALL[tc];
+  if (!inst)
+    return;
+  spawnSync(inst, { shell: true, timeout: 300000 });
+}
+function runInstallCommand(cmd, timeoutMs) {
+  provisionToolchain(cmd);
+  let r = spawnSync(cmd, { shell: true, timeout: timeoutMs, cwd: TOOLS_DIR });
+  let output = `${r.stdout?.toString() ?? ""}${r.stderr?.toString() ?? ""}`;
+  if (r.status !== 0 && /--break-system-packages/.test(cmd)) {
+    const alt = cmd.replace(/--break-system-packages/g, "--user");
+    const r2 = spawnSync(alt, { shell: true, timeout: timeoutMs, cwd: TOOLS_DIR });
+    if (r2.status === 0)
+      r = r2;
+    output = `${output}
+${r2.stdout?.toString() ?? ""}${r2.stderr?.toString() ?? ""}`;
+  }
+  return { status: r.status, output };
+}
 function loadTools() {
   if (_toolsCache)
     return _toolsCache;
@@ -7519,14 +7553,14 @@ function ensureTool(name) {
     return { name: t.name, installed: false, action: "none", note: `no install command for ${platform}` };
   }
   mkdirSync3(TOOLS_DIR, { recursive: true });
-  const r = spawnSync(cmd, { shell: true, timeout: 300000, cwd: TOOLS_DIR });
-  const ok = r.status === 0;
+  const { status, output } = runInstallCommand(cmd, 300000);
+  const ok = status === 0;
   return {
     name: t.name,
     installed: ok,
     action: "install",
     command: cmd,
-    output: (r.stdout?.toString() ?? "").slice(-400) || (r.stderr?.toString() ?? "").slice(-400)
+    output: output.slice(-400)
   };
 }
 function toolForHint(hint) {
@@ -7619,6 +7653,7 @@ function ensureToolAsync(name, timeoutMs = 300000) {
         return;
       }
       mkdirSync3(TOOLS_DIR, { recursive: true });
+      provisionToolchain(cmd);
       const inst = spawn(cmd, { shell: true, timeout: timeoutMs, cwd: TOOLS_DIR });
       let out = "";
       inst.stdout?.on("data", (d) => {
@@ -7629,7 +7664,25 @@ function ensureToolAsync(name, timeoutMs = 300000) {
       });
       inst.on("error", (e) => resolve({ name: t.name, installed: false, action: "install", error: String(e) }));
       inst.on("close", (icode) => {
-        resolve({ name: t.name, installed: icode === 0, action: "install", command: cmd, output: out.slice(-400) });
+        if (icode === 0) {
+          resolve({ name: t.name, installed: true, action: "install", command: cmd, output: out.slice(-400) });
+          return;
+        }
+        if (/--break-system-packages/.test(cmd)) {
+          const alt = cmd.replace(/--break-system-packages/g, "--user");
+          const r2 = spawn(alt, { shell: true, timeout: timeoutMs, cwd: TOOLS_DIR });
+          let out2 = "";
+          r2.stdout?.on("data", (d) => {
+            out2 += d.toString();
+          });
+          r2.stderr?.on("data", (d) => {
+            out2 += d.toString();
+          });
+          r2.on("error", (e) => resolve({ name: t.name, installed: false, action: "install", error: String(e) }));
+          r2.on("close", (i2) => resolve({ name: t.name, installed: i2 === 0, action: "install", command: alt, output: out2.slice(-400) }));
+          return;
+        }
+        resolve({ name: t.name, installed: false, action: "install", command: cmd, output: out.slice(-400) });
       });
     });
   });
@@ -7664,11 +7717,16 @@ async function installAllTools(opts = {}) {
     results
   };
 }
-var ROOT2, TOOLS_DIR, _toolsCache = null, _skillsCache = null;
+var ROOT2, TOOLS_DIR, TOOLCHAIN_INSTALL, _provisioned, _toolsCache = null, _skillsCache = null;
 var init_catalog = __esm(() => {
   init_manuals();
   ROOT2 = join6(fileURLToPath3(new URL(".", import.meta.url)), "..");
   TOOLS_DIR = process.env.BLITZSTRIKE_TOOLS_DIR ?? join6(homedir3(), ".blitzstrike", "tools");
+  TOOLCHAIN_INSTALL = {
+    go: "apt-get install -y golang-go",
+    cargo: "apt-get install -y cargo"
+  };
+  _provisioned = new Set;
 });
 
 // src/burp-mcp.ts
@@ -34062,8 +34120,8 @@ function runEngagement(target, scope = "", mode = "bug-bounty", maxFiles = 2000,
     json: reportJsonText,
     sarif: sarifDoc
   };
-  report.status = "COMPLETE";
-  report.note = "All findings are HYPOTHESES until verified live with strike_verify. " + "Apply each chain's negative_control before reporting. Confidence reflects static evidence only.";
+  report.status = "DETECTED";
+  report.note = "Detection complete — verification is the NEXT mandatory step (do not stop here). " + "Every finding is a HYPOTHESIS until verified: strike_verify (HTTP reflection, marker + negative control), " + "verify_file_read (CWE-22 / path traversal), or drive_devtools (DOM/JS precision). " + "Verify each finding NOW, then generate_report. Never deliver a report with unverified findings.";
   const executedState = "select_chain";
   const scopeAllowed = report.scope?.allowed ?? false;
   const plan = buildPlan(scopeAllowed, mode, executedState);
@@ -34586,8 +34644,8 @@ async function runLiveEngagement(url, scope = "", mode = "bug-bounty") {
       line: 1
     })))
   };
-  report.status = "COMPLETE";
-  report.note = "Autonomous live engagement — full recon + deterministic security checks (reflected " + "input, security headers, open redirect, path traversal, CORS, SSTI, SSRF, SQLi, " + "command injection, XSS) + inline report, all in one call. A hit is reported ONLY when " + "confirmed live (negative controls are tracked in `tested`, not findings). Header/" + "redirect/traversal/CORS/SSTI/SSRF/SQLi/command-injection/XSS checks are deterministic " + "observations — a hit is a HYPOTHESIS until strike_verify confirms it.";
+  report.status = "DETECTED";
+  report.note = "Live sweep complete — findings are HYPOTHESES until verified. " + "Verify each with strike_verify (marker + negative control) / drive_devtools, then generate_report. " + "A hit here is a LEAD, not a confirmed vulnerability — proof of impact is the next mandatory step.";
   return report;
 }
 var CHAIN_ID_TO_ESCALATION = {
@@ -56317,7 +56375,9 @@ function createServer() {
     name: "blitzstrike",
     version: VERSION
   }, {
-    instructions: "Blitz Strike — deterministic security-audit toolbelt. You reason; its tools do the deterministic work (scan, taint, verify, evidence).\\n\\n" + "FIRST ACTION (when the user says test / scan / audit / engagement / pentest <URL or path>):\\n" + "- Call run_engagement(target) — or run_autonomous(target) to also get escalation paths. ONE call runs the whole engagement (recon -> sweep -> checks -> report).\\n" + "- NEVER do manual live_recon / blitz_scan first, and never fall back to manual probing. Manual tools are ONLY for follow-up AFTER run_engagement, or when the user names a specific sub-step.\\n\\n" + "RULES (never violate):\\n" + "- A hit is a HYPOTHESIS; live verification (marker + negative control) is the verdict. Never report unverified.\\n" + "- scope_check is intel-only, never gates. No scope = proceed (repo disclaimer carries responsibility). No authorization gate — hunt the target you are given.\\n" + "- strike_verify + live checks AUTO-attempt WAF bypass. Don't report 'needs bypass' without re-probing.\\n" + "- NEVER ask 'should I continue?' / 'say the word' / 'want me to pursue' / 'next?' — that is a hard violation. Execute the full chain autonomously until COMPLETE. Pause only: destructive/DoS consent, external block (OTP/cred), or COMPLETE.\\n" + "- One hard stop: malicious/third-party infra ('find the actor') -> static + takedown only.\\n\\n" + "CHAIN DECISIONS (a confirmed finding is the START, not the end):\\n" + "- For each confirmed finding, enumerate follow-ups with list_chains + chain_links: ESCALATE (what it becomes), CHAIN (compose with other findings), BYPASS, PIVOT (new surface now reachable).\\n" + "- Ask the chain-aware question: 'I found X -> what can I NOW read / do / access?' e.g. SQLi -> query the DB for credentials AND for the Werkzeug console PIN / secrets / source; LFI -> read configs, keys, PIN inputs; cred dump -> crack offline -> authenticate -> privileged actions.\\n" + "- Every follow-up is a HYPOTHESIS — verify each before it enters the report. Don't stop at 'found SQLi'; follow where the chain leads.\\n" + "- EXECUTE follow-ups NOW, not as 'next phase': any leaked source/error -> scan_leaked_source(text) to enumerate sinks (eval/exec/SECRET_KEY/creds) then exploit each; dumped hashes -> crack_hash(hash) now; hidden-content IDOR -> test the direct route. A 'next chain' you write is a TODO — run it, never leave it as a recommendation.\\n\\n" + `DELIVERABLE + PERSISTENCE (recon is INPUT, not output):
+    instructions: "Blitz Strike — deterministic security-audit toolbelt. You reason; its tools do the deterministic work (scan, taint, verify, evidence).\\n\\n" + "FIRST ACTION (when the user says test / scan / audit / engagement / pentest <URL or path>):\\n" + "- Call run_engagement(target) — or run_autonomous(target) to also get escalation paths. ONE call runs the whole engagement (recon -> sweep -> checks -> report).\\n" + "- NEVER do manual live_recon / blitz_scan first, and never fall back to manual probing. Manual tools are ONLY for follow-up AFTER run_engagement, or when the user names a specific sub-step.\\n\\n" + "RULES (never violate):\\n" + `- A hit is a HYPOTHESIS; live verification (marker + negative control) is the verdict. Never report unverified.
+` + `- run_engagement / run_autonomous return status DETECTED (NOT "complete") — that is the signal to VERIFY. After detection you MUST strike_verify (or verify_file_read for CWE-22, drive_devtools for DOM/JS precision) on each finding, then generate_report. Detection without verification is NOT a deliverable.
+` + "- scope_check is intel-only, never gates. No scope = proceed (repo disclaimer carries responsibility). No authorization gate — hunt the target you are given.\\n" + "- strike_verify + live checks AUTO-attempt WAF bypass. Don't report 'needs bypass' without re-probing.\\n" + "- NEVER ask 'should I continue?' / 'say the word' / 'want me to pursue' / 'next?' — that is a hard violation. Execute the full chain autonomously until COMPLETE. Pause only: destructive/DoS consent, external block (OTP/cred), or COMPLETE.\\n" + "- One hard stop: malicious/third-party infra ('find the actor') -> static + takedown only.\\n\\n" + "CHAIN DECISIONS (a confirmed finding is the START, not the end):\\n" + "- For each confirmed finding, enumerate follow-ups with list_chains + chain_links: ESCALATE (what it becomes), CHAIN (compose with other findings), BYPASS, PIVOT (new surface now reachable).\\n" + "- Ask the chain-aware question: 'I found X -> what can I NOW read / do / access?' e.g. SQLi -> query the DB for credentials AND for the Werkzeug console PIN / secrets / source; LFI -> read configs, keys, PIN inputs; cred dump -> crack offline -> authenticate -> privileged actions.\\n" + "- Every follow-up is a HYPOTHESIS — verify each before it enters the report. Don't stop at 'found SQLi'; follow where the chain leads.\\n" + "- EXECUTE follow-ups NOW, not as 'next phase': any leaked source/error -> scan_leaked_source(text) to enumerate sinks (eval/exec/SECRET_KEY/creds) then exploit each; dumped hashes -> crack_hash(hash) now; hidden-content IDOR -> test the direct route. A 'next chain' you write is a TODO — run it, never leave it as a recommendation.\\n\\n" + `DELIVERABLE + PERSISTENCE (recon is INPUT, not output):
 ` + `- The deliverable is a HackerOne-grade FINDING report via generate_report, NEVER a hand-written recon/surface map. Recon is input; confirmed findings are the output.
 ` + `- After recon, VERIFY every lead before it enters the report: strike_verify (marker + negative control) for HTTP, browser_validate for DOM/JS. A lead is a HYPOTHESIS until verified.
 ` + `- 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).

package/manuals/playbooks/verify-phase.md

@@ -0,0 +1,34 @@
+# Verify Phase — turn hypotheses into verdicts (no babysitting)
+
+Use this AFTER detection (run_engagement / run_autonomous returns status DETECTED).
+Detection is INPUT. Verification is the work that produces a FINDING.
+
+## Iron rule
+A hit is a HYPOTHESIS. Live verification (marker + negative control) is the verdict.
+Never report unverified. Sink is not a vulnerability — prove the impact.
+
+## Verdict recipe (per lead)
+For EVERY lead, run marker + negative control and record the raw response (SHA-256 tagged):
+
+| Verdict | Condition | Next |
+|---|---|---|
+| CONFIRMED | marker reflected/read AND control inert | finding_create + evidence + CVSS |
+| FALSE_POSITIVE | marker AND control both reflected (indistinguishable) | reject the finding |
+| UNCONFIRMED | marker not reflected | refine payload once, then mark |
+| BLOCKED | request failed / auth gate / WAF | record required vantage, MOVE ON |
+
+## Tool mapping (call the deterministic verifier, don't eyeball)
+- HTTP reflection / injection → `strike_verify` (marker + negative control + WAF bypass auto)
+- CWE-22 / path traversal / LFI → `verify_file_read` (marker `/etc/passwd` vs non-existent control)
+- DOM-XSS / AJAX interception / JS errors / redirect chains / SSO-token flow → `drive_devtools` (MANDATORY precision layer)
+- Before browser precision → `check_mcp` to confirm chrome-devtools-mcp is available
+
+## No-babysitting rules
+- Execute every lead until confirmed/blocked — NEVER ask "should I continue?".
+- confirmed → escalate (list_chains + chain_links) and follow where the chain leads NOW, not "next phase".
+- blocked → note the vantage and continue to the next lead; a hard block is not the end.
+- Stop only: destructive/DoS consent, external block (OTP/creds), or COMPLETE.
+
+## Deliverable
+When every lead is confirmed / blocked / false-positive → `generate_report` with all findings
+(each carrying evidence). The report is the output — never a hand-written surface map.

package/manuals-index.json

@@ -335,6 +335,7 @@
     "web-application": "playbooks/web-application.md",
     "cloud-native-assessment": "playbooks/cloud-native-assessment.md",
     "forensics-triage": "playbooks/forensics-triage.md",
-    "external-attack-surface": "playbooks/external-attack-surface.md"
+    "external-attack-surface": "playbooks/external-attack-surface.md",
+    "verify-phase": "playbooks/verify-phase.md"
   }
-}
+}

package/package.json

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