blitzstrike 1.0.48 → 1.0.51

package/CHANGELOG.md

@@ -5,6 +5,48 @@ 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)
+
+- **Failure Recovery** (`src/mission/recovery.ts`, §17):
+  - `diagnoseError()` — categorizes failures (network / permission /
+    missing_tool / invalid_args / scope / unknown).
+  - `recoveryDecision()` — network → retry (bounded); missing_tool → route to an
+    alternative agent; scope / permission / invalid_args → record (no retry).
+  - `AGENT_ALTERNATIVES` — fallback specialization per agent type.
+  - `recordFailure()` — a failed-approach record with a `future_policy` so the
+    autonomous system never blindly repeats the same mistake.
+- Mission Control now routes task failures through the recovery engine and
+  persists `failed_approaches` into the mission state.
+
 ## [1.0.48] — 2026-09-13
 
 ### Added — Autonomous Security Engine (phase 8: coverage-driven scheduler)

package/dist/index.js

@@ -17903,7 +17903,8 @@ function newMission(id, target, scope, mode, budget) {
     coverage: { dimensions: {} },
     memory_refs: [],
     termination_reason: null,
-    decision_log: []
+    decision_log: [],
+    failed_approaches: []
   };
 }
 
@@ -18257,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() {
@@ -18275,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();
@@ -18454,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 = {
@@ -18654,6 +18735,95 @@ var init_coverage = __esm(() => {
   };
 });
 
+// src/mission/recovery.ts
+function diagnoseError(error) {
+  const e = error.toLowerCase();
+  if (/network|connect|timeout|econn|enotfound|unreachable|dns|resolve|refused|abort/i.test(e))
+    return "network";
+  if (/permission|eacces|denied|forbidden|401|403/i.test(e))
+    return "permission";
+  if (/not (installed|found)|no such|command not found|missing tool/i.test(e))
+    return "missing_tool";
+  if (/invalid|argument|usage|required|schema|type/i.test(e))
+    return "invalid_args";
+  if (/scope|authorized|out of scope|unauthorized/i.test(e))
+    return "scope";
+  return "unknown";
+}
+function recoveryDecision(task, error) {
+  const category = diagnoseError(error);
+  switch (category) {
+    case "network":
+      return task.attempts < 3 ? { action: "retry", reason: "transient network failure — retry", alternative_agent: null } : { action: "record", reason: "persistent network failure", alternative_agent: null };
+    case "missing_tool":
+      return { action: "alternative", reason: "tool unavailable — try alternative", alternative_agent: AGENT_ALTERNATIVES[task.agent_type]?.[0] ?? null };
+    case "invalid_args":
+      return { action: "record", reason: "invalid arguments — cannot auto-recover", alternative_agent: null };
+    case "scope":
+      return { action: "record", reason: "out of scope — do not retry", alternative_agent: null };
+    case "permission":
+      return { action: "record", reason: "permission denied — cannot auto-recover", alternative_agent: null };
+    default:
+      return task.attempts < 2 ? { action: "retry", reason: "unknown failure — retry once", alternative_agent: null } : { action: "record", reason: "unknown failure — give up", alternative_agent: null };
+  }
+}
+function recordFailure(task, error) {
+  const category = diagnoseError(error);
+  return {
+    technique: `${task.agent_type}:${task.objective}`,
+    target: task.objective,
+    category,
+    reason: error,
+    attempts: task.attempts,
+    future_policy: category === "scope" ? "do not retry — out of scope" : category === "missing_tool" ? "route to an alternative agent next time" : category === "network" ? "retry with backoff" : "lower priority for this technique"
+  };
+}
+var AGENT_ALTERNATIVES;
+var init_recovery = __esm(() => {
+  AGENT_ALTERNATIVES = {
+    commander: [],
+    recon: ["api", "web"],
+    web: ["api", "recon"],
+    api: ["recon", "web"],
+    source: ["analysis"],
+    auth: ["analysis", "source"],
+    mobile: ["source"],
+    cloud: ["source"],
+    analysis: ["source"],
+    validator: ["reviewer"],
+    reviewer: ["validator"],
+    reporter: []
+  };
+});
+
+// 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) {
@@ -18774,8 +18944,29 @@ async function runMission(mission) {
           m = { ...m, report: r.output };
         }
       } else {
-        const failed = setTask(m.tasks, r.task.task_id, { status: r.task.attempts >= 2 ? "failed" : "retry", error: r.error ?? null });
-        m = { ...m, tasks: failed, decision_log: [...m.decision_log, { at: new Date().toISOString(), agent: r.task.agent_type, decision }] };
+        const rec = recoveryDecision(r.task, r.error ?? "unknown error");
+        const stamp = { at: new Date().toISOString(), agent: r.task.agent_type, decision };
+        if (rec.action === "retry") {
+          const retried = setTask(m.tasks, r.task.task_id, { status: "retry", error: r.error ?? null });
+          m = { ...m, tasks: retried, decision_log: [...m.decision_log, stamp] };
+        } else if (rec.action === "alternative" && rec.alternative_agent) {
+          const failed = setTask(m.tasks, r.task.task_id, { status: "failed", error: r.error ?? null });
+          const alt = createTask({ objective: `[alternative] ${r.task.objective}`, agent_type: rec.alternative_agent, risk: r.task.risk, priority: r.task.priority - 1 });
+          m = {
+            ...m,
+            tasks: [...failed, alt],
+            decision_log: [...m.decision_log, stamp],
+            failed_approaches: [...m.failed_approaches, recordFailure(r.task, r.error ?? "")]
+          };
+        } else {
+          const failed = setTask(m.tasks, r.task.task_id, { status: "failed", error: r.error ?? null });
+          m = {
+            ...m,
+            tasks: failed,
+            decision_log: [...m.decision_log, stamp],
+            failed_approaches: [...m.failed_approaches, recordFailure(r.task, r.error ?? "")]
+          };
+        }
       }
     }
     m.budget.used_tasks += batch.length;
@@ -18795,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 = {}) {
@@ -18816,6 +19011,8 @@ var init_control = __esm(() => {
   init_agents();
   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.48",
+  "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": {