blitzstrike 2.4.173 → 2.4.175

package/CHANGELOG.md

@@ -5,6 +5,26 @@ 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.175] — 2026-10-11
+
+### Added — evidence roles (structured proof/baseline/verification/supporting)
+
+- Evidence records now carry a `role` (proof = trigger request/response, baseline =
+  normal request, verification = negative control/marker, supporting = anything else).
+- `finding_attach_evidence` accepts a `role`; new `finding_evidence_roles` tool
+  returns the role breakdown + a `reproducible` flag (true only when a finding has
+  proof + baseline + verification — the three roles a HackerOne-grade PoC needs).
+
+## [2.4.174] — 2026-10-11
+
+### Added — observation ledger + lineage (third write-back channel)
+
+- New `facts` engine + 3 tools: `record_fact` (record an exploration observation
+  with observed/inferred confidence + optional parent_ids), `list_facts`, and
+  `lineage` (trace a fact's ancestors up + descendants down).
+- Completes the three write-back channels: findings (vulns), assets (asset_discovery),
+  and facts (neutral/negative observations that would otherwise be lost).
+
 ## [2.4.173] — 2026-10-11
 
 ### Added — goal tracking + prove_goal (completion signal)

package/dist/index.js

@@ -33211,6 +33211,7 @@ function makeEvidence(input) {
   return {
     evidence_id: nextEvidenceId(),
     type: input.type,
+    role: input.role ?? "supporting",
     description: redactSecrets(input.description),
     source: input.source ? redactObject(input.source) : undefined,
     sink: input.sink ? redactObject(input.sink) : undefined,
@@ -33236,6 +33237,18 @@ function verifyEvidence(evidence) {
   }
   return { ok: failed.length === 0, failed };
 }
+function evidenceRoles(evidence) {
+  const roles = { proof: 0, baseline: 0, verification: 0, supporting: 0 };
+  for (const e of evidence)
+    roles[e.role] = (roles[e.role] ?? 0) + 1;
+  return {
+    roles,
+    proof: roles.proof > 0,
+    baseline: roles.baseline > 0,
+    verification: roles.verification > 0,
+    reproducible: roles.proof > 0 && roles.baseline > 0 && roles.verification > 0
+  };
+}
 
 // src/invariants.ts
 function checkFindingInvariants(finding) {
@@ -63949,6 +63962,50 @@ function goalStatus() {
   return { goals: [...goals], all_met: goals.length > 0 && met === goals.length, met, total: goals.length };
 }
 
+// src/facts.ts
+var facts = [];
+var counter3 = 0;
+function nextId3() {
+  counter3 += 1;
+  return `FACT-${String(counter3).padStart(3, "0")}`;
+}
+function recordFact(input) {
+  const fact = {
+    id: nextId3(),
+    text: input.text,
+    confidence: input.confidence,
+    target: input.target,
+    parent_ids: input.parent_ids ?? [],
+    created: new Date().toISOString()
+  };
+  facts.push(fact);
+  return fact;
+}
+function listFacts() {
+  return [...facts];
+}
+function lineage(id) {
+  const fact = facts.find((f) => f.id === id);
+  if (!fact)
+    return { error: `no fact '${id}'` };
+  const ancestors = [];
+  const seen = new Set([id]);
+  const queue = [...fact.parent_ids];
+  while (queue.length) {
+    const pid = queue.shift();
+    if (seen.has(pid))
+      continue;
+    seen.add(pid);
+    const p = facts.find((f) => f.id === pid);
+    if (p) {
+      ancestors.push(p);
+      queue.push(...p.parent_ids);
+    }
+  }
+  const descendants = facts.filter((f) => f.parent_ids.includes(id));
+  return { fact, ancestors, descendants };
+}
+
 // src/sibling-scan.ts
 var SIBLING_SUFFIXES = [
   "export",
@@ -65914,6 +65971,35 @@ ${statusLine}` : statusLine },
   }, async () => {
     return { content: [{ type: "text", text: JSON.stringify(goalStatus()) }] };
   });
+  server.registerTool("record_fact", {
+    title: "Record an exploration observation (fact)",
+    description: "FACTS: record an observation/conclusion that is NOT a vuln (finding_create) and NOT an asset (asset_discovery) — e.g. 'admin panel is behind SSO', 'upload strips .php', 'param id is reflected'. Pass text, confidence (observed = you triggered it; inferred = deduced from a fingerprint/diff — never report inferred as confirmed), optional target, and optional parent_ids (facts this derives from). Use this so negative/neutral observations are written down instead of lost.",
+    inputSchema: {
+      text: string2().describe("The observation/conclusion"),
+      confidence: _enum(["observed", "inferred"]).describe("observed (directly triggered) or inferred (deduced, not yet triggered)"),
+      target: string2().optional().describe("Optional host/endpoint/param the fact is about"),
+      parent_ids: array(string2()).optional().describe("Optional ids of facts this one derives from")
+    }
+  }, async ({ text, confidence, target, parent_ids }) => {
+    const fact = recordFact({ text, confidence, target, parent_ids });
+    return { content: [{ type: "text", text: JSON.stringify(fact) }] };
+  });
+  server.registerTool("list_facts", {
+    title: "List all recorded facts",
+    description: "FACTS: return every recorded observation with its confidence + lineage parent_ids. Use before re-testing a direction — a solid observed fact (or a recorded dead-end) saves re-probing the same thing.",
+    inputSchema: {}
+  }, async () => {
+    return { content: [{ type: "text", text: JSON.stringify(listFacts()) }] };
+  });
+  server.registerTool("lineage", {
+    title: "Trace a fact's lineage (ancestors + descendants)",
+    description: "FACTS: walk a fact's lineage — its ancestors (the facts it derived from, up the parent chain) and descendants (facts derived from it). Use to understand where a conclusion came from and what it enabled.",
+    inputSchema: {
+      id: string2().describe("Fact id (FACT-XXX) to trace")
+    }
+  }, async ({ id }) => {
+    return { content: [{ type: "text", text: JSON.stringify(lineage(id)) }] };
+  });
   server.registerTool("hunting_doctrine", {
     title: "High-ROI hunting doctrine (sibling rule, A→B, follow-the-money)",
     description: "Return the hunting doctrine — the high-ROI heuristics the agent applies while selecting targets/endpoints/classes: the Sibling Rule (check every sibling endpoint — ~30% of paid IDOR/auth bugs), A→B Signal Method, impact-first, follow-the-money, less-saturated classes, new==unreviewed, two-account IDOR test, PoC escalation, credential-proof, CI/CD + SAML/SSO attack surface, 20-minute rotation, plus the always-rejected kill-list. Use when deciding WHAT to hunt next.",
@@ -66685,23 +66771,45 @@ ${statusLine}` : statusLine },
   });
   server.registerTool("finding_attach_evidence", {
     title: "Attach evidence to a finding",
-    description: "FINDINGS: attach a redacted, SHA-256-tagged evidence record to an existing canonical finding (without advancing its lifecycle).",
+    description: "FINDINGS: attach a redacted, SHA-256-tagged evidence record to an existing canonical finding (without advancing its lifecycle). Pass role (proof = the request/response that triggered it; baseline = the normal request showing the differential; verification = the negative control/marker; supporting = anything else) so the finding's evidence stays structured. A reproducible PoC needs proof + baseline + verification.",
     inputSchema: {
       finding: string2().describe("JSON of the Finding object"),
       type: string2().describe("Evidence type (source_location/response/validation_result/negative_control/...)"),
       description: string2().describe("Evidence description"),
+      role: _enum(["proof", "baseline", "verification", "supporting"]).optional().describe("Evidence role (default supporting)"),
       content: string2().optional().describe("Evidence artifact content")
     }
-  }, async ({ finding, type, description, content }) => {
+  }, async ({ finding, type, description, role, content }) => {
     let f;
     try {
       f = JSON.parse(finding);
     } catch {
       return { content: [{ type: "text", text: JSON.stringify({ error: "invalid finding JSON" }) }] };
     }
-    const ev = makeEvidence({ type, description, artifacts: content ? [{ name: "artifact", kind: "evidence", content }] : [] });
+    const ev = makeEvidence({ type, role, description, artifacts: content ? [{ name: "artifact", kind: "evidence", content }] : [] });
     const updated = attachEvidence(f, ev);
-    return { content: [{ type: "text", text: JSON.stringify(updated) }] };
+    return { content: [{ type: "text", text: JSON.stringify({ ...updated, roles: evidenceRoles(updated.evidence) }) }] };
+  });
+  server.registerTool("finding_evidence_roles", {
+    title: "Summarize a finding's evidence by role",
+    description: "FINDINGS: given a finding, return its evidence broken down by role (proof/baseline/verification/supporting) + a `reproducible` flag (true only when it has proof + baseline + verification). Check this before submitting a report: a finding that is not `reproducible` is missing the trigger/differential/negative-control evidence a HackerOne-grade PoC needs.",
+    inputSchema: {
+      finding: string2().describe("JSON of the Finding object")
+    }
+  }, async ({ finding }) => {
+    let f;
+    try {
+      f = JSON.parse(finding);
+    } catch {
+      return { content: [{ type: "text", text: JSON.stringify({ error: "invalid finding JSON" }) }] };
+    }
+    const roles = evidenceRoles(f.evidence ?? []);
+    const missing = [
+      !roles.proof ? "proof (trigger request/response)" : null,
+      !roles.baseline ? "baseline (normal request)" : null,
+      !roles.verification ? "verification (negative control/marker)" : null
+    ].filter(Boolean);
+    return { content: [{ type: "text", text: JSON.stringify({ ...roles, missing: missing.length ? missing : undefined, hint: roles.reproducible ? "reproducible — evidence complete" : "NOT reproducible — attach the missing roles via finding_attach_evidence" }) }] };
   });
   server.registerTool("redact", {
     title: "Redact secrets from text",

package/package.json

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