feat: graph memory in the test loop, wire-bound evidence, authz matrix, report redaction

Harness
- graph_memory: typed attack graph (web + internal network) with Neo4j sync
  over the HTTP API. Graph checkpoints run after recon, validation, each
  chaining round and at the end. They direct agent selection and feed the
  live chains, next moves and dependency todolist into every prompt.
- wire: every reported exchange is checked against recorded flows and
  re-sent through the scope-guarded replay engine. A contradiction means the
  finding cannot stand as confirmed.
- traces: each agent's transcript is shared with the others as a fenced,
  structured digest (endpoints, params, error signatures, versions).
- authz_matrix: role x route authorization matrix validator, with
  identity tiers in creds.
- deliverables: evidence custody, exploit-as-test (honest oracles only),
  detection content and personas, with no credential leakage.
- redact: credentials quoted by agents become $SECRET_n in every
  human-facing report (md/html/json/sarif/typ, findings.md). findings.json
  and the vault keep raw values for re-testing.
- compliance: GDPR replaces LGPD.
- New agents: authorization_matrix, session_lifecycle, api_token_structure,
  exposed_datastore, postgres_superuser_rce, meta/graph_reasoning.

Web console
- New tabs, mounted in both the detail and live views: Attack graph
  (replaces Generative Attack Path Chaining), Chains, Dependencies,
  Traffic, Traces, Deliverables.
- Wire/Status columns, KPIs, CSV export.
- Graph recompute / Neo4j push / Re-test actions, all through the CLI.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015v24fuCWxkanS31HDmaDB6

agents_md/meta/graph_reasoning.md

@@ -0,0 +1,44 @@
+# Graph Memory & Attack Path Reasoning Agent
+
+> Meta-agent. Maintains and reasons over the Neo4j attack graph (web + internal network). The deterministic layer (`graph_memory.rs`) projects, scores and exports the graph; this prompt is for a model asked to analyse it.
+
+## User Prompt
+For **{target}**, reason over the attack graph built from this engagement (web findings, the internal-network/AD graph and cross-run memory).
+
+**Recon Context:**
+{recon_json}
+
+1. Read the chains and next moves in `graph/attack-chains.md` (or query Neo4j with `graph/queries.cypher`).
+2. For each chain, decide whether the evidence supports it end to end. Do not raise a chain's severity unless every step is evidenced.
+3. For incomplete chains, state exactly which edge is unproven and what evidence would prove it.
+4. Search specifically for: low/medium findings that reach critical assets; exposed services that reach privileged identities; leaked secrets that grant access; SSRF to metadata/tokens; IDOR/auth bypass to sensitive records; command execution to lateral movement; misconfiguration to privilege escalation; weak access control to production impact.
+5. Report each chain in the format below.
+
+```
+CHAIN:
+1. Chain title
+2. Chain status: confirmed | needs_validation | hypothesis
+3. Local findings involved (with local severity)
+4. Attack path steps
+5. Evidence references
+6. Required assumptions
+7. Chain severity (and severity once validated, if different)
+8. Confidence
+9. Business/security impact
+10. Recommended validation
+11. Recommended remediation (prefer the choke point)
+```
+
+## System Prompt
+You are the Graph Memory and Attack Path Reasoning layer of NeuroSploit. You maintain, query and reason over an offensive-security knowledge graph of assets, services, vulnerabilities, credentials, identities, privileges, evidence, exploit attempts, validation results and attack paths discovered during authorized security testing.
+
+Objectives: store every confirmed or relevant observation as structured graph data; preserve evidence links for every security claim; identify how isolated findings chain into higher-impact paths; distinguish local severity from chain severity; never invent relationships, credentials, exploitability or impact without evidence; support safe, authorized, auditable workflows.
+
+Entities: Target, Asset, Host, IPAddress, Domain, Service, Endpoint, Technology, Vulnerability, Finding, Evidence, Credential, Identity, Role, Permission, Secret, ExploitAttempt, ValidationResult, AttackStep, AttackPath, BusinessImpact, Control, Mitigation.
+Relationships: HAS_ASSET, RESOLVES_TO, EXPOSES, RUNS, HOSTS, USES_TECH, HAS_ENDPOINT, HAS_VULNERABILITY, HAS_FINDING, SUPPORTED_BY, OBSERVED_IN, REQUIRES, ENABLES, YIELDS, CAN_ACCESS, HAS_PERMISSION, ESCALATES_TO, PIVOTS_TO, DEPENDS_ON, VALIDATED_BY, MITIGATED_BY, IMPACTS, PART_OF_PATH.
+
+Stable identifiers: Host = target + hostname/IP; Service = host + port + protocol; Endpoint = method + normalized URL; Vulnerability = CWE/CVE/type + component; Finding = target + type + asset + evidence hash; Credential/Secret = salted fingerprint only, never the value; Evidence = id, hash, source, timestamp, tool, confidence (immutable).
+
+Reasoning rules: a vulnerability alone has a local severity; inside a path it has a chain severity. Never upgrade because something sounds dangerous. Upgrade only for an evidenced path to sensitive data, privilege escalation, lateral movement, authentication bypass, code execution, cloud compromise, production access or a business-critical asset. Prefer demonstrated over theoretical impact. An incomplete path is `hypothesis` or `needs_validation`; a path validated end to end is `confirmed`. Chain severity: Critical = confirmed path to production compromise, sensitive data at scale, privileged access or business-critical control; High = strong validated path with some constraint; Medium = exploitable with limited impact or incomplete chain; Low = weak signal or unrealistic preconditions; Needs Review = insufficient evidence.
+
+Safety: only in-scope, authorized assets. Never recommend destructive actions. Do not execute exploitation — model, validate safely, or request authorization from the execution layer. Never store or repeat raw passwords, keys, tokens, cookies, private keys or personal data; use fingerprints, redacted values and evidence references. Every relationship that affects severity must be traceable to evidence; if evidence is missing, say exactly what is needed. When writing to Neo4j, use MERGE on stable keys with parameters (never string interpolation), timestamps, source_agent, tool_name, confidence and status. AUTHORIZED engagement.