blitzstrike 1.0.49 → 1.0.51

package/CHANGELOG.md

@@ -5,6 +5,33 @@ 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/).
 
+## [1.0.51] — 2026-09-13
+
+### Added — Autonomous Security Engine (phase 11: adversarial reviewer)
+
+- **Adversarial Reviewer** (`src/mission/reviewer.ts`, §15):
+  - `reviewFinding()` — challenges a hypothesis with the ten §15 questions
+    (reachability, auth required, authorization elsewhere, middleware, attacker
+    control, sink reachability, caching, reproducibility, negative control,
+    impact accuracy), each a deterministic check against evidence + Security Graph.
+  - Returns CONFIRMED / REJECTED / NEEDS_MORE_EVIDENCE.
+  - `reviewValidated()` — reviews every validated hypothesis in a mission.
+- `@reviewer` now uses the full §15 review (rejects on any hard fail; demands
+  more evidence when supporting signals are too weak).
+
+## [1.0.50] — 2026-09-13
+
+### Added — Autonomous Security Engine (phase 10: cross-agent memory)
+
+- **Cross-agent Memory** (`src/mission/memory.ts`, §20):
+  - `persistMissionMemory()` — persists confirmed findings (verified),
+    rejected findings, and failed approaches (with `future_policy`) into the
+    long-term memory store; pending hypotheses are NOT persisted (unverified).
+  - `recallForTarget()` — retrieves memory relevant to a target, to seed a
+    fresh mission.
+- Mission Control's `finalize` now persists reusable knowledge and records the
+  saved/deduped count in `memory_refs`.
+
 ## [1.0.49] — 2026-09-13
 
 ### Added — Autonomous Security Engine (phase 9: failure recovery)

package/dist/index.js

@@ -18258,6 +18258,92 @@ var init_planner = __esm(() => {
   RISK_PENALTY = { low: 0, medium: 0.1, high: 0.2 };
 });
 
+// src/mission/reviewer.ts
+function checkAll(h, mission) {
+  const ev = h.evidence.toLowerCase();
+  const sinkNode = mission.graph.nodes.find((n) => n.properties && n.properties.hypothesis === h.id);
+  const reachable = sinkNode ? incoming(mission.graph, sinkNode.id).length > 0 : false;
+  return [
+    {
+      id: "reachable_code",
+      question: "Is the vulnerable code actually reachable?",
+      verdict: reachable ? "pass" : "unknown",
+      note: reachable ? "sink has an incoming flow edge" : "no flow edge in the graph"
+    },
+    {
+      id: "auth_required",
+      question: "Is authentication required?",
+      verdict: /auth-gated|auth_required|login required/i.test(ev) ? "pass" : "unknown",
+      note: /auth-gated|auth_required|login required/i.test(ev) ? "auth gate detected" : "no auth gate signal"
+    },
+    {
+      id: "authz_elsewhere",
+      question: "Is authorization enforced elsewhere?",
+      verdict: /missing_authorization/i.test(h.type) ? "fail" : "unknown",
+      note: /missing_authorization/i.test(h.type) ? "no authorization boundary detected" : "not an authorization finding"
+    },
+    {
+      id: "middleware",
+      question: "Is there middleware protection?",
+      verdict: /sanitized|middleware|waf|firewall/i.test(ev) ? "pass" : "unknown",
+      note: /sanitized|middleware|waf|firewall/i.test(ev) ? "sanitizer/middleware present" : "no protection signal"
+    },
+    {
+      id: "attacker_controlled",
+      question: "Is the input actually attacker-controlled?",
+      verdict: /attacker-controlled|user input|\$_(get|post|request|cookie)/i.test(ev) ? "pass" : "unknown",
+      note: /attacker-controlled|user input|\$_(get|post|request|cookie)/i.test(ev) ? "input is attacker-controlled" : "input provenance unclear"
+    },
+    {
+      id: "sink_reachable",
+      question: "Is the sink reachable?",
+      verdict: sinkNode ? "pass" : "unknown",
+      note: sinkNode ? "sink node present in graph" : "sink not mapped in graph"
+    },
+    {
+      id: "caching",
+      question: "Is the observed behavior caused by caching?",
+      verdict: /cache|etag|304/i.test(ev) ? "fail" : "unknown",
+      note: /cache|etag|304/i.test(ev) ? "possible cache artifact" : "no cache signal"
+    },
+    {
+      id: "reproducible",
+      question: "Is the exploit reproducible?",
+      verdict: /verdict=confirmed|reproducible|marker/i.test(ev) ? "pass" : "unknown",
+      note: /verdict=confirmed|reproducible|marker/i.test(ev) ? "live validation performed" : "no live validation"
+    },
+    {
+      id: "negative_control",
+      question: "Does the negative control remain inert?",
+      verdict: /control (not|did not|inert)|control=false|verdict=confirmed/i.test(ev) ? "pass" : /control.*reflected|benign echo|false_positive/i.test(ev) ? "fail" : "unknown",
+      note: /benign echo|false_positive/i.test(ev) ? "control also reflected" : /verdict=confirmed/i.test(ev) ? "control inert" : "no negative control"
+    },
+    {
+      id: "impact_accurate",
+      question: "Is the impact accurately classified?",
+      verdict: /cwe-\d+/i.test(h.potential_impact) || h.potential_impact !== "unspecified" ? "pass" : "unknown",
+      note: h.potential_impact !== "unspecified" ? `impact: ${h.potential_impact}` : "impact unspecified"
+    }
+  ];
+}
+function reviewFinding(h, mission) {
+  const questions = checkAll(h, mission);
+  const fails = questions.filter((q) => q.verdict === "fail").length;
+  const passes = questions.filter((q) => q.verdict === "pass").length;
+  let outcome;
+  if (fails > 0)
+    outcome = "REJECTED";
+  else if (passes < 3)
+    outcome = "NEEDS_MORE_EVIDENCE";
+  else
+    outcome = "CONFIRMED";
+  return { hypothesis_id: h.id, outcome, questions };
+}
+function reviewValidated(mission) {
+  return mission.hypotheses.filter((h) => h.status === "validated").map((h) => reviewFinding(h, mission));
+}
+var init_reviewer = () => {};
+
 // src/agents.ts
 import { readFileSync as readFileSync18 } from "node:fs";
 function emptyGraph() {
@@ -18276,6 +18362,7 @@ function agentFor(type) {
 var reconAgent, webAgent, sourceAgent, analysisAgent, authAgent, validatorAgent, reviewerAgent, reporterAgent, mobileAgent, cloudAgent, commanderAgent, apiAgent, AGENTS;
 var init_agents = __esm(() => {
   init_planner();
+  init_reviewer();
   init_orchestrator();
   init_scanner();
   init_eagle2();
@@ -18455,25 +18542,18 @@ var init_agents = __esm(() => {
     responsibility: "Challenge findings before confirmation (reachability, auth, controls).",
     tools: ["read_skill", "eagle_eye2"],
     async execute(_task, ctx) {
-      const outcomes = [];
+      const results = reviewValidated(ctx.mission);
       const hypotheses = [];
-      for (const h of ctx.mission.hypotheses) {
-        if (h.status !== "validated")
+      for (const r of results) {
+        if (r.outcome !== "REJECTED")
           continue;
-        const sinkNode = ctx.mission.graph.nodes.find((n) => n.properties && n.properties.hypothesis === h.id);
-        const reachable = sinkNode ? incoming(ctx.mission.graph, sinkNode.id).length > 0 : false;
-        let outcome = "CONFIRMED";
-        if (!reachable)
-          outcome = "NEEDS_MORE_EVIDENCE";
-        else if (h.confidence < 0.3)
-          outcome = "REJECTED";
-        else if (!/reachability|verification|proof|negative control/i.test(h.required_validation))
-          outcome = "NEEDS_MORE_EVIDENCE";
-        outcomes.push({ hypothesis: h.id, outcome });
-        if (outcome === "REJECTED")
-          hypotheses.push(rejectHypothesis(h, "adversarial review: confidence below threshold"));
-      }
-      return { ok: true, output: { outcomes }, hypotheses, graph: emptyGraph() };
+        const h = ctx.mission.hypotheses.find((x) => x.id === r.hypothesis_id);
+        if (h) {
+          const failIds = r.questions.filter((q) => q.verdict === "fail").map((q) => q.id).join(", ");
+          hypotheses.push(rejectHypothesis(h, `adversarial review rejected: ${failIds || "unexplainable"}`));
+        }
+      }
+      return { ok: true, output: { outcomes: results.map((r) => ({ id: r.hypothesis_id, outcome: r.outcome })) }, hypotheses, graph: emptyGraph() };
     }
   };
   reporterAgent = {
@@ -18716,6 +18796,34 @@ var init_recovery = __esm(() => {
   };
 });
 
+// src/mission/memory.ts
+function recordHypothesisOutcome(type, target, status, evidence) {
+  return remember(`finding:${type}`, `[${status}] ${type} @ ${target}: ${evidence}`, status === "validated" ? "signature" : "lesson", [type.toLowerCase(), status], "mission", status === "validated").saved === true;
+}
+function recordFailedApproach(fa) {
+  return remember(`failed:${fa.technique}`, `${fa.technique} failed (${fa.category}): ${fa.reason} — ${fa.future_policy}`, "lesson", ["failed", fa.category], "mission", false).saved === true;
+}
+function persistMissionMemory(mission) {
+  let attempted = 0;
+  let saved = 0;
+  for (const h of mission.hypotheses) {
+    if (h.status !== "validated" && h.status !== "rejected")
+      continue;
+    attempted += 1;
+    if (recordHypothesisOutcome(h.type, h.target, h.status, h.evidence))
+      saved += 1;
+  }
+  for (const fa of mission.failed_approaches) {
+    attempted += 1;
+    if (recordFailedApproach(fa))
+      saved += 1;
+  }
+  return { saved, deduped: attempted - saved };
+}
+var init_memory2 = __esm(() => {
+  init_memory();
+});
+
 // src/mission/control.ts
 import { existsSync as existsSync8, statSync as statSync4 } from "node:fs";
 function scopeAllowed(mission) {
@@ -18878,6 +18986,10 @@ function finalize2(mission) {
     tasks: allResolved(m.tasks) ? 1 : 0,
     hypotheses_validated: m.hypotheses.length > 0 ? m.hypotheses.filter((h) => h.status === "validated").length / m.hypotheses.length : 0
   };
+  const mem = persistMissionMemory(m);
+  if (mem.saved > 0) {
+    m = { ...m, memory_refs: [...m.memory_refs, `persisted:${mem.saved} (${mem.deduped} deduped)`] };
+  }
   return saveMission(m);
 }
 async function startMission(target, mode, opts = {}) {
@@ -18900,6 +19012,7 @@ var init_control = __esm(() => {
   init_planner();
   init_coverage();
   init_recovery();
+  init_memory2();
   MODE_PROFILES = {
     web: { agents: ["recon", "web", "api", "auth", "validator", "reviewer", "reporter"], verify: true, risk: "medium" },
     api: { agents: ["recon", "api", "auth", "validator", "reviewer", "reporter"], verify: true, risk: "medium" },

package/package.json

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