Create sovereign_operational_resilience_report.py

sovereign_operational_resilience_report.py

@@ -0,0 +1,291 @@
+
+# sovereign_operational_resilience_report.py
+from __future__ import annotations
+
+import json
+import os
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional
+
+from sovereign_operational_resilience_profile import generate_operational_resilience_profile
+
+
+OPERATIONAL_RESILIENCE_OUTPUT_DIR = "sovereign_operational_resilience_outputs"
+
+
+def _utc_now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _ensure_dir(path: str) -> None:
+    os.makedirs(path, exist_ok=True)
+
+
+def _safe(v: Any, default: Any = "") -> Any:
+    return v if v is not None else default
+
+
+def _bool_text(v: Any) -> str:
+    return "True" if bool(v) else "False"
+
+
+def _render_header(bundle: Dict[str, Any]) -> str:
+    profile = bundle.get("operational_resilience_profile", {}) if isinstance(bundle, dict) else {}
+
+    return f"""# Sovereign Operational Resilience Report
+
+Generated at: {_safe((profile or {}).get("generated_at"), _utc_now())}
+
+## 1. Profile Identity
+- Profile Type: {_safe(profile.get("profile_type"), "Sovereign Operational Resilience Profile")}
+- Domain: {_safe(profile.get("domain"), "banking_and_financial_institutions")}
+"""
+
+
+def _render_summary(bundle: Dict[str, Any]) -> str:
+    profile = bundle.get("operational_resilience_profile", {}) if isinstance(bundle, dict) else {}
+    summary = profile.get("summary", {}) if isinstance(profile, dict) else {}
+
+    return f"""## 2. Executive Summary
+- Total Degradation Classes: {_safe(summary.get("total_degradation_classes"), 0)}
+- Freeze or Freeze-Like Classes: {_safe(summary.get("freeze_or_freeze_like_classes"), 0)}
+- Block-Default Classes: {_safe(summary.get("block_default_classes"), 0)}
+- Human-Escalation Classes: {_safe(summary.get("human_escalation_classes"), 0)}
+
+### Practical Interpretation
+- Sovereign treats resilience as controlled continuity, not unrestricted continuation under degraded conditions.
+- Degraded runtime posture is expected to narrow authority rather than silently preserve normal authority.
+- Critical degradation can drive the system into minimal-safe or no-normal-runtime modes.
+- Recovery and degraded operation are expected to remain auditable and evidence-backed.
+"""
+
+
+def _render_degradation_classes(bundle: Dict[str, Any]) -> str:
+    profile = bundle.get("operational_resilience_profile", {}) if isinstance(bundle, dict) else {}
+    classes = profile.get("degradation_classes", []) if isinstance(profile, dict) else []
+
+    lines: List[str] = ["## 3. Degradation Class Inventory"]
+
+    if not classes:
+        lines.append("- No degradation classes recorded.")
+        return "\n".join(lines)
+
+    for item in classes:
+        lines.append(f"### {item.get('degradation_class', 'unknown_degradation_class')}")
+        lines.append(f"- Severity: {_safe(item.get('severity'))}")
+        lines.append(f"- Default Mode: {_safe(item.get('default_mode'))}")
+        lines.append(f"- Default Action: {_safe(item.get('default_action'))}")
+        lines.append(f"- Human Escalation Required: {_bool_text(item.get('human_escalation_required'))}")
+        lines.append(f"- Evidence Required: {_bool_text(item.get('evidence_required'))}")
+        lines.append(f"- Description: {_safe(item.get('description'))}")
+        lines.append("")
+
+    return "\n".join(lines).rstrip() + "\n"
+
+
+def _render_continuity_principles(bundle: Dict[str, Any]) -> str:
+    profile = bundle.get("operational_resilience_profile", {}) if isinstance(bundle, dict) else {}
+    principles = profile.get("continuity_principles", []) if isinstance(profile, dict) else []
+
+    lines: List[str] = ["## 4. Continuity Principles"]
+
+    if not principles:
+        lines.append("- No continuity principles recorded.")
+        return "\n".join(lines)
+
+    for item in principles:
+        lines.append(f"### {item.get('principle', 'unknown_principle')}")
+        lines.append(f"- Status: {_safe(item.get('status'))}")
+        lines.append(f"- Description: {_safe(item.get('description'))}")
+        lines.append("")
+
+    return "\n".join(lines).rstrip() + "\n"
+
+
+def _render_fallback_posture(bundle: Dict[str, Any]) -> str:
+    profile = bundle.get("operational_resilience_profile", {}) if isinstance(bundle, dict) else {}
+    fallback = profile.get("fallback_posture", {}) if isinstance(profile, dict) else {}
+
+    modes = fallback.get("fallback_modes", []) if isinstance(fallback, dict) else []
+    forbidden = fallback.get("forbidden_fallback_patterns", []) if isinstance(fallback, dict) else []
+
+    lines = ["## 5. Fallback Posture"]
+
+    if modes:
+        lines.append("- Fallback Modes:")
+        for item in modes:
+            lines.append(f"  - {item.get('mode')}: {item.get('meaning')}")
+
+    if forbidden:
+        lines.append("- Forbidden Fallback Patterns:")
+        for item in forbidden:
+            lines.append(f"  - {item}")
+
+    return "\n".join(lines)
+
+
+def _render_evidence_expectations(bundle: Dict[str, Any]) -> str:
+    profile = bundle.get("operational_resilience_profile", {}) if isinstance(bundle, dict) else {}
+    evidence = profile.get("evidence_expectations", {}) if isinstance(profile, dict) else {}
+
+    required_artifacts = evidence.get("required_artifacts", []) if isinstance(evidence, dict) else []
+    expectations = evidence.get("expectations", []) if isinstance(evidence, dict) else []
+
+    lines = ["## 6. Evidence Expectations"]
+
+    if required_artifacts:
+        lines.append("- Required Artifacts:")
+        for item in required_artifacts:
+            lines.append(f"  - {item}")
+
+    if expectations:
+        lines.append("- Expectations:")
+        for item in expectations:
+            lines.append(f"  - {item}")
+
+    return "\n".join(lines)
+
+
+def _render_governance_interpretation(bundle: Dict[str, Any]) -> str:
+    profile = bundle.get("operational_resilience_profile", {}) if isinstance(bundle, dict) else {}
+    classes = profile.get("degradation_classes", []) if isinstance(profile, dict) else []
+
+    freeze_like = [
+        x.get("degradation_class")
+        for x in classes
+        if str(x.get("default_action", "")).upper() in {
+            "FREEZE",
+            "FREEZE_FOR_HIGH_RISK_ONLY",
+            "FREEZE_FOR_SENSITIVE_PATHS",
+            "REVIEW_OR_FREEZE",
+            "BLOCK_OR_FREEZE",
+        }
+    ]
+    block_default = [
+        x.get("degradation_class")
+        for x in classes
+        if str(x.get("default_action", "")).upper() == "BLOCK"
+    ]
+
+    lines = ["## 7. Governance Interpretation"]
+
+    if freeze_like:
+        lines.append("- Freeze-Oriented Degradation Classes:")
+        for item in freeze_like:
+            lines.append(f"  - {item}")
+
+    if block_default:
+        lines.append("- Block-Oriented Degradation Classes:")
+        for item in block_default:
+            lines.append(f"  - {item}")
+
+    lines.append("- Degraded continuity should remain narrower than normal continuity when trust is reduced.")
+    lines.append("- High-risk paths should not continue as normal under material uncertainty.")
+    lines.append("- Degraded runtime entry, fallback, and recovery should remain reviewable and evidence-backed.")
+
+    return "\n".join(lines)
+
+
+def _render_artifact_status(bundle: Dict[str, Any]) -> str:
+    seal = bundle.get("crypto_seal", {}) if isinstance(bundle, dict) else {}
+
+    return f"""## 8. Artifact Status
+- Sealed: {bool(bundle.get("sealed", False))}
+- Seal Digest: {_safe(seal.get("seal_digest"), "")}
+- Seal Scheme: {_safe(seal.get("scheme"), "")}
+- Seal Algorithm: {_safe(seal.get("algorithm"), "")}
+- Signer Hint: {_safe(seal.get("signer_hint"), "")}
+"""
+
+
+def _render_verdict(bundle: Dict[str, Any]) -> str:
+    profile = bundle.get("operational_resilience_profile", {}) if isinstance(bundle, dict) else {}
+    notes = profile.get("notes", []) if isinstance(profile, dict) else []
+
+    verdict = (
+        "Sovereign currently expresses a bank-grade operational resilience posture: "
+        "degraded operation is explicitly classified, fallback modes are bounded, "
+        "and continuity under impairment is treated as controlled and auditable rather than permissive."
+    )
+
+    lines = [
+        "## 9. Preliminary Bank-Facing Verdict",
+        verdict,
+        "",
+        "## 10. Notes",
+    ]
+
+    if notes:
+        for item in notes:
+            lines.append(f"- {item}")
+    else:
+        lines.append("- No additional notes provided.")
+
+    return "\n".join(lines)
+
+
+def build_operational_resilience_markdown(bundle: Dict[str, Any]) -> str:
+    parts = [
+        _render_header(bundle),
+        _render_summary(bundle),
+        _render_degradation_classes(bundle),
+        _render_continuity_principles(bundle),
+        _render_fallback_posture(bundle),
+        _render_evidence_expectations(bundle),
+        _render_governance_interpretation(bundle),
+        _render_artifact_status(bundle),
+        _render_verdict(bundle),
+    ]
+    return "\n\n".join(parts).strip() + "\n"
+
+
+def save_operational_resilience_report(
+    bundle: Dict[str, Any],
+    output_dir: str = OPERATIONAL_RESILIENCE_OUTPUT_DIR,
+    base_name: Optional[str] = None,
+) -> Dict[str, str]:
+    _ensure_dir(output_dir)
+
+    ts = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+    base = base_name or f"sovereign_operational_resilience_report_{ts}"
+
+    json_path = os.path.join(output_dir, f"{base}.json")
+    md_path = os.path.join(output_dir, f"{base}.md")
+
+    with open(json_path, "w", encoding="utf-8") as f:
+        json.dump(bundle, f, ensure_ascii=False, indent=2)
+
+    markdown = build_operational_resilience_markdown(bundle)
+    with open(md_path, "w", encoding="utf-8") as f:
+        f.write(markdown)
+
+    return {
+        "json_report": json_path,
+        "markdown_report": md_path,
+    }
+
+
+def generate_operational_resilience_report(
+    output_dir: str = OPERATIONAL_RESILIENCE_OUTPUT_DIR,
+    base_name: Optional[str] = None,
+) -> Dict[str, Any]:
+    bundle = generate_operational_resilience_profile()
+
+    files = save_operational_resilience_report(
+        bundle=bundle,
+        output_dir=output_dir,
+        base_name=base_name,
+    )
+
+    return {
+        "ok": True,
+        "generated_at": _utc_now(),
+        "bundle": bundle,
+        "files": files,
+    }
+
+
+if __name__ == "__main__":
+    out = generate_operational_resilience_report()
+    print(json.dumps(out, indent=2, ensure_ascii=False))
+