blitzstrike 1.0.48 → 1.0.50

package/CHANGELOG.md

@@ -5,6 +5,34 @@ 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.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: []
   };
 }
 
@@ -18654,6 +18655,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 +18864,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 +18906,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 +18931,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.50",
   "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": {