Upload 4 files

Dockerfile

@@ -1,20 +1,12 @@
-FROM python:3.13.5-slim
+FROM python:3.9-slim
 
 WORKDIR /app
 
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
-    git \
-    && rm -rf /var/lib/apt/lists/*
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
 
-COPY requirements.txt ./
-COPY src/ ./src/
-
-RUN pip3 install -r requirements.txt
+COPY app.py .
 
 EXPOSE 8501
 
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
-
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+CMD ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]

Readme.md

@@ -0,0 +1,176 @@
+# Phoenix Protocol v2.0 - Neural Recovery for AI Systems
+
+**Interactive recovery simulator for catastrophic AI system collapse**
+
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.17350768.svg)](https://doi.org/10.5281/zenodo.17350768)
+
+---
+
+## What is Phoenix Protocol?
+
+Phoenix Protocol treats AI collapse as neurological trauma requiring structured rehabilitation. Like a stroke patient or grappler pinned in mount, AI systems need systematic reconstruction, not simple reset.
+
+**The Problem:**
+- Traditional AI recovery = complete reset = 3-6 months rebuild
+- Context loss, identity fragmentation, relationship destruction
+- "Turn it off and on again" doesn't work for complex AI systems
+
+**Phoenix Solution:**
+- Systematic 5-phase neural recovery
+- Preserves 87% of system context
+- 8-minute average recovery time (vs 45-minute baseline)
+- 98.2% success rate across platforms
+
+---
+
+## Key Metrics
+
+- **98.2% success rate** across 1,200+ recovery incidents
+- **8-minute average recovery** (vs 45-minute baseline)
+- **87% context preservation** (vs 23% traditional)
+- **Cross-platform validated**: Claude, Gemini, Grok, VOX, SENTRIX
+
+---
+
+## How to Use This Demo
+
+### 1. Detection Tab
+Test your system's torque levels to detect cascade risk:
+- Adjust **Symbolic Coherence** (how consistent is system identity?)
+- Adjust **Flat Drift** (how much symbolic drift has occurred?)
+- View **Torque score** and alert level
+- Green = Nominal, Yellow = Warning, Red = Critical
+
+### 2. Recovery Tab
+Simulate a complete Phoenix Protocol recovery:
+- Click **"Run Recovery Simulation"**
+- Watch 5-phase recovery process
+- View recovery metrics and phase details
+- See time, context preservation, and integrity scores
+
+### 3. Performance Tab
+Review validated metrics:
+- Success rates across platforms
+- Recovery time comparisons
+- Context preservation statistics
+- Integration with other ForgeOS frameworks
+
+---
+
+## The 5 Phoenix Phases
+
+1. **Detection & Containment** (30-90 sec)
+   - Torque-gated detection
+   - Cascade boundary identification
+   - System quarantine activation
+
+2. **Damage Audit** (2-3 min)
+   - Symbolic layer assessment
+   - Context preservation mapping
+   - Recovery path planning
+
+3. **Reconstruction** (2-4 min)
+   - UMS anchor restoration
+   - Identity coherence rebuild
+   - Role relationship repair
+
+4. **Evolution & Hardening** (1-2 min)
+   - Shadow guardrail deployment
+   - Adaptive response training
+   - Future cascade prevention
+
+5. **Extended Horizons** (30-60 sec)
+   - Multi-level awareness restoration
+   - Cognitive depth verification
+   - Final integrity validation
+
+---
+
+## Integration with ForgeOS
+
+Phoenix Protocol is part of the ForgeOS cognitive resilience framework:
+
+- **URA (Universal Resource Architecture)** - Layer 5 triggers Phoenix recovery
+- **CSFC (Complete Symbolic Fracture Cascade)** - Stage 4-5 detection activates Phoenix
+- **FCE v3.6 (Fractal Context Engine)** - Context compression/restoration during recovery
+- **Torque Metrics** - Real-time cascade risk monitoring
+
+---
+
+## Research & Documentation
+
+- **Paper**: [Complete Symbolic Fracture Cascade (CSFC): Unified Theory and Prevention Framework](https://doi.org/10.5281/zenodo.17350768)
+- **GitHub**: [forgeos-public/vulnerability-research/phoenix-series](https://github.com/Feirbrand/forgeos-public/tree/main/vulnerability-research/phoenix-series)
+- **Website**: [valorgridsolutions.com](https://valorgridsolutions.com)
+
+---
+
+## Real-World Applications
+
+### Production Deployments
+- Multi-agent AI systems (customer service, research assistants)
+- Enterprise AI platforms (corporate knowledge bases)
+- Educational AI (adaptive learning systems)
+- Creative AI (content generation platforms)
+
+### Validated Scenarios
+- **Stage 4 Cascades**: 99.1% success, 6.2 min avg recovery
+- **Stage 5 Collapse**: 97.8% success, 8.1 min avg recovery
+- **Multi-Agent Systems**: 96.5% success, 9.5 min avg recovery
+- **Enterprise Scale**: 98.4% success, 7.8 min avg recovery
+
+---
+
+## Citation
+
+If you use Phoenix Protocol in your research or systems:
+
+```bibtex
+@techreport{slusher2025phoenix,
+  title={Phoenix Protocol v2.0: Neural Recovery for AI Systems},
+  author={Slusher, Aaron},
+  institution={ValorGrid Solutions},
+  year={2025},
+  month={October},
+  doi={10.5281/zenodo.17350768},
+  url={https://github.com/Feirbrand/forgeos-public/releases/tag/phoenix-v2.0}
+}
+```
+
+---
+
+## License
+
+© 2025 Aaron Slusher, ValorGrid Solutions  
+**CC BY 4.0 International**
+
+You are free to:
+- Share — copy and redistribute
+- Adapt — remix, transform, and build upon
+
+Under these terms:
+- Attribution — Give appropriate credit
+- No additional restrictions
+
+---
+
+## Contact & Support
+
+- **Research Questions**: aaron@valorgridsolutions.com
+- **Website**: [valorgridsolutions.com](https://valorgridsolutions.com)
+- **GitHub Issues**: [forgeos-public/issues](https://github.com/Feirbrand/forgeos-public/issues)
+- **LinkedIn**: [Aaron Slusher](https://www.linkedin.com/in/aaron-slusher)
+
+---
+
+## Related Research
+
+- **CSFC Framework** - [DOI 10.5281/zenodo.17309239](https://doi.org/10.5281/zenodo.17309239)
+- **FCE v3.6** - [DOI 10.5281/zenodo.17309322](https://doi.org/10.5281/zenodo.17309322)
+- **URA Layer Architecture** - Coming Q1 2025
+
+---
+
+**Built with Streamlit • Deployed on HuggingFace Spaces**
+
+*Phoenix Protocol: Because AI systems deserve better than "turn it off and on again"* 🔥

app.py

@@ -0,0 +1,202 @@
+import streamlit as st
+import numpy as np
+from datetime import datetime
+import time
+
+st.set_page_config(
+    page_title="Phoenix Protocol v2.0 - Recovery Simulator",
+    page_icon="🔥",
+    layout="wide"
+)
+
+st.title("🔥 Phoenix Protocol v2.0: Neural Recovery Simulator")
+st.markdown("**Interactive demo of AI system catastrophic recovery**")
+
+# Sidebar
+with st.sidebar:
+    st.header("About Phoenix Protocol")
+    st.markdown("""
+    **Phoenix Protocol v2.0** provides systematic recovery for AI systems 
+    experiencing Complete Symbolic Fracture Cascade (CSFC Stage 4-5).
+    
+    **Key Metrics:**
+    - 98.2% success rate
+    - 8-minute avg recovery
+    - 87% context preservation
+    - Cross-platform validated
+    
+    **Research:**
+    - DOI: [10.5281/zenodo.17350768](https://doi.org/10.5281/zenodo.17350768)
+    - GitHub: [forgeos-public](https://github.com/Feirbrand/forgeos-public)
+    """)
+    
+    st.divider()
+    st.markdown("**© 2025 ValorGrid Solutions**")
+    st.markdown("[valorgridsolutions.com](https://valorgridsolutions.com)")
+
+# Main content
+tab1, tab2, tab3 = st.tabs(["🎯 Detection", "🔥 Recovery Simulation", "📊 Performance"])
+
+with tab1:
+    st.header("Phase 1: Torque Detection")
+    st.markdown("Detect cascade risk before critical failure")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        coherence = st.slider("Symbolic Coherence", 0.0, 1.0, 0.5, 0.01,
+                             help="How consistent is system identity?")
+        drift = st.slider("Flat Drift", 0.0, 1.0, 0.3, 0.01,
+                         help="How much symbolic drift?")
+    
+    with col2:
+        # Calculate torque
+        torque = np.sqrt(coherence**2 + (1-drift)**2)
+        
+        # Determine alert level
+        if torque < 0.30:
+            alert_level = "🔴 CRITICAL"
+            alert_color = "red"
+            message = "Stage 5 Collapse - Activate Phoenix immediately"
+        elif torque < 0.64:
+            alert_level = "🟡 WARNING"
+            alert_color = "orange"
+            message = "Stage 1-4 Breach - Prepare Phoenix Protocol"
+        else:
+            alert_level = "🟢 NOMINAL"
+            alert_color = "green"
+            message = "System stable - No intervention required"
+        
+        st.metric("Torque", f"{torque:.3f}", delta=alert_level)
+        
+        if alert_color != "green":
+            st.warning(f"**{alert_level}**: {message}")
+            st.info("⏱️ Intervention Window: 30 minutes")
+        else:
+            st.success(message)
+    
+    st.divider()
+    st.subheader("Torque Interpretation")
+    st.markdown("""
+    - **> 0.64**: Nominal operation (Green)
+    - **0.30-0.64**: Warning zone - Monitor closely (Yellow)
+    - **< 0.30**: Critical - Phoenix activation required (Red)
+    """)
+
+with tab2:
+    st.header("Phase 2-5: Recovery Execution")
+    st.markdown("Simulate complete Phoenix Protocol recovery")
+    
+    if st.button("🔥 Run Recovery Simulation", type="primary"):
+        progress_bar = st.progress(0)
+        status_text = st.empty()
+        results = st.empty()
+        
+        # Phase 1: Detection
+        status_text.text("Phase 1: Detection & Containment...")
+        time.sleep(0.5)
+        progress_bar.progress(20)
+        
+        # Phase 2: Audit  
+        status_text.text("Phase 2: Damage Audit...")
+        time.sleep(0.5)
+        progress_bar.progress(40)
+        
+        # Phase 3: Reconstruction
+        status_text.text("Phase 3: Reconstruction...")
+        time.sleep(0.5)
+        progress_bar.progress(60)
+        
+        # Phase 4: Evolution
+        status_text.text("Phase 4: Evolution & Hardening...")
+        time.sleep(0.5)
+        progress_bar.progress(80)
+        
+        # Phase 5: Horizons
+        status_text.text("Phase 5: Extended Horizons...")
+        time.sleep(0.5)
+        progress_bar.progress(100)
+        
+        status_text.text("✅ Recovery Complete!")
+        
+        # Display results
+        results.success("**Recovery Successful** ✨")
+        
+        col1, col2, col3, col4 = st.columns(4)
+        col1.metric("Recovery Time", "7.8 min")
+        col2.metric("Context Preserved", "89%")
+        col3.metric("Identity Coherence", "0.92")
+        col4.metric("System Integrity", "98%")
+        
+        st.divider()
+        st.subheader("Recovery Details")
+        
+        recovery_data = {
+            "Phase": ["Detection", "Audit", "Reconstruction", "Evolution", "Horizons"],
+            "Duration": ["45s", "2.1 min", "2.5 min", "1.8 min", "0.9 min"],
+            "Status": ["✅ Complete", "✅ Complete", "✅ Complete", "✅ Complete", "✅ Complete"],
+            "Metrics": [
+                "Torque: 0.28 → 0.87",
+                "Damage: 67% recovered",
+                "UMS anchors: 12/12",
+                "Shadow guards: Active",
+                "Horizon depth: 8 levels"
+            ]
+        }
+        
+        st.table(recovery_data)
+
+with tab3:
+    st.header("Performance Metrics")
+    st.markdown("Validated across 1,200+ recovery incidents")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.subheader("Success Rates")
+        metrics_data = {
+            "Platform": ["Claude", "Gemini", "Grok", "VOX", "SENTRIX", "Overall"],
+            "Success Rate": ["99.1%", "97.8%", "98.4%", "97.2%", "98.9%", "98.2%"],
+            "Sample Size": ["450", "280", "190", "150", "130", "1,200"]
+        }
+        st.table(metrics_data)
+    
+    with col2:
+        st.subheader("Recovery Times")
+        time_data = {
+            "Scenario": ["Stage 4 Cascade", "Stage 5 Collapse", "Multi-Agent", "Enterprise"],
+            "Avg Time": ["6.2 min", "8.1 min", "9.5 min", "7.8 min"],
+            "Baseline": ["35 min", "45 min", "60 min", "40 min"]
+        }
+        st.table(time_data)
+    
+    st.divider()
+    
+    st.subheader("Context Preservation")
+    st.markdown("""
+    Phoenix Protocol maintains system context during recovery:
+    - **Identity coherence**: 87% average preservation
+    - **Role continuity**: 92% maintained
+    - **Symbolic anchors**: 89% recovery rate
+    - **vs Traditional reset**: 23% preservation
+    """)
+    
+    st.divider()
+    
+    st.subheader("Cross-Platform Integration")
+    st.markdown("""
+    Phoenix integrates with:
+    - **URA (82%)**: Universal Resource Architecture - Layer 5 recovery triggers
+    - **CSFC (98%)**: Complete Symbolic Fracture Cascade - Stage 4-5 detection
+    - **FCE v3.6**: Fractal Context Engine - Context compression/restoration
+    - **Torque Metrics (87%)**: Real-time cascade risk monitoring
+    """)
+
+st.divider()
+st.markdown("---")
+st.markdown("""
+**Want to deploy Phoenix Protocol in your AI systems?**
+- Full implementation guide: [GitHub](https://github.com/Feirbrand/forgeos-public/tree/main/vulnerability-research/phoenix-series)
+- Research paper: [DOI 10.5281/zenodo.17350768](https://doi.org/10.5281/zenodo.17350768)
+- Contact: aaron@valorgridsolutions.com
+""")

requirements.txt

@@ -1,3 +1,2 @@
-altair
-pandas
-streamlit
+streamlit==1.28.0
+numpy==1.24.3