Upload 4 files

Dockerfile

@@ -1,20 +1,26 @@
-FROM python:3.13.5-slim
+FROM python:3.11-slim
 
 WORKDIR /app
 
+# Install system dependencies
 RUN apt-get update && apt-get install -y \
     build-essential \
     curl \
-    git \
+    software-properties-common \
     && rm -rf /var/lib/apt/lists/*
 
-COPY requirements.txt ./
-COPY src/ ./src/
+# Copy requirements and install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
 
-RUN pip3 install -r requirements.txt
+# Copy application files
+COPY app.py .
 
-EXPOSE 8501
+# Expose Streamlit port
+EXPOSE 7860
 
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+# Health check
+HEALTHCHECK CMD curl --fail http://localhost:7860/_stcore/health
 
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+# Run Streamlit
+ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=7860", "--server.address=0.0.0.0"]

app.py

@@ -0,0 +1,424 @@
+"""
+RAY v2.1: Recursive Adaptive Yield - Living Recursion Loop Demo
+
+Dual License:
+- CC BY-NC 4.0 for non-commercial use
+- Commercial license via aaron@valorgridsolutions.com
+
+© 2025 Aaron Slusher, ValorGrid Solutions. All rights reserved.
+"""
+
+import streamlit as st
+import plotly.graph_objects as go
+import plotly.express as px
+import pandas as pd
+import numpy as np
+from datetime import datetime
+import time
+
+# Page config
+st.set_page_config(
+    page_title="RAY v2.1 Recursion Demo",
+    page_icon="🔄",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS
+st.markdown("""
+<style>
+    .main-header {
+        font-size: 2.5rem;
+        font-weight: bold;
+        color: #FF6B6B;
+        text-align: center;
+        margin-bottom: 1rem;
+    }
+    .sub-header {
+        font-size: 1.2rem;
+        color: #666;
+        text-align: center;
+        margin-bottom: 2rem;
+    }
+    .metric-card {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        padding: 1.5rem;
+        border-radius: 10px;
+        color: white;
+        margin: 0.5rem 0;
+    }
+    .alert-high {
+        background-color: #ff4444;
+        padding: 1rem;
+        border-radius: 5px;
+        color: white;
+        font-weight: bold;
+    }
+    .alert-medium {
+        background-color: #ffaa00;
+        padding: 1rem;
+        border-radius: 5px;
+        color: white;
+        font-weight: bold;
+    }
+    .alert-safe {
+        background-color: #00C851;
+        padding: 1rem;
+        border-radius: 5px;
+        color: white;
+        font-weight: bold;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Header
+st.markdown('<div class="main-header">🔄 RAY v2.1: Living Recursion Loop</div>', unsafe_allow_html=True)
+st.markdown('<div class="sub-header">Interactive Demonstration of Recursive Adaptive Yield Framework</div>', unsafe_allow_html=True)
+
+# Sidebar configuration
+st.sidebar.title("⚙️ RAY Configuration")
+st.sidebar.markdown("---")
+
+# RAY Parameters
+st.sidebar.subheader("🎯 Core Parameters")
+torque_threshold = st.sidebar.slider(
+    "Torque Threshold",
+    min_value=0.5,
+    max_value=0.95,
+    value=0.85,
+    step=0.05,
+    help="Minimum torque for validation (default: 0.85)"
+)
+
+codex_heat_threshold = st.sidebar.slider(
+    "CodexHeat Threshold",
+    min_value=0.5,
+    max_value=0.9,
+    value=0.73,
+    step=0.05,
+    help="Entropy spike detection threshold (default: 0.73)"
+)
+
+harmony_target = st.sidebar.slider(
+    "Harmony Target",
+    min_value=0.75,
+    max_value=0.95,
+    value=0.85,
+    step=0.05,
+    help="URA harmony score target (default: 0.82-0.89)"
+)
+
+st.sidebar.markdown("---")
+st.sidebar.subheader("🧬 DNA Codex Selection")
+threat_strains = st.sidebar.multiselect(
+    "Active Threat Strains",
+    ["PIW-001", "SSM-001", "QMT-001", "CamoLeak CAMO-001"],
+    default=["PIW-001", "CamoLeak CAMO-001"],
+    help="Select threat strains to monitor"
+)
+
+st.sidebar.markdown("---")
+st.sidebar.subheader("🔬 DD Enhancements")
+dd_enhancements = st.sidebar.multiselect(
+    "Active DD Enhancements",
+    ["GRPO", "Tensor Logic", "RAGLight", "Verbalized Sampling", 
+     "LaDiR", "Markovian Agentic Radar", "ReasoningBank", "ThreadMirror"],
+    default=["GRPO", "Tensor Logic", "RAGLight"],
+    help="Deep Dive reasoning enhancements"
+)
+
+# Main content tabs
+tab1, tab2, tab3, tab4 = st.tabs(["🔄 Live Recursion Loop", "📊 Performance Metrics", "🧬 DNA Codex", "⚡ DD Enhancements"])
+
+with tab1:
+    st.subheader("Living Recursion Loop - 8 Phases")
+    
+    col1, col2 = st.columns([2, 1])
+    
+    with col1:
+        # Simulate recursion loop
+        if st.button("▶️ Run Recursion Cycle", type="primary", use_container_width=True):
+            progress_bar = st.progress(0)
+            status_text = st.empty()
+            
+            phases = [
+                "Phase 1: Symbolic→Flat Bridge",
+                "Phase 2: Truth Table Validation",
+                "Phase 3: Codex Pattern Matching",
+                "Phase 4: URA Harmonization",
+                "Phase 5: FCE Compression",
+                "Phase 6: CSFC Cascade Check",
+                "Phase 7: Phoenix Recovery (if needed)",
+                "Phase 8: Self-Training Update"
+            ]
+            
+            results = []
+            for i, phase in enumerate(phases):
+                progress_bar.progress((i + 1) / len(phases))
+                status_text.text(f"⏳ {phase}...")
+                time.sleep(0.5)
+                
+                # Simulate phase metrics
+                torque = np.random.uniform(0.75, 0.95)
+                coherence = np.random.uniform(0.80, 0.98)
+                entropy = np.random.uniform(0.1, 0.8)
+                
+                results.append({
+                    "Phase": phase,
+                    "Torque": torque,
+                    "Coherence": coherence,
+                    "Entropy": entropy,
+                    "Status": "✅ Pass" if torque >= torque_threshold else "⚠️ Warning"
+                })
+            
+            status_text.text("✅ Recursion cycle complete!")
+            progress_bar.empty()
+            
+            # Display results
+            st.dataframe(
+                pd.DataFrame(results),
+                use_container_width=True,
+                hide_index=True
+            )
+            
+            # Overall status
+            avg_torque = np.mean([r['Torque'] for r in results])
+            avg_coherence = np.mean([r['Coherence'] for r in results])
+            
+            if avg_torque >= torque_threshold:
+                st.markdown('<div class="alert-safe">🎯 System Operating Normally - All Phases Validated</div>', unsafe_allow_html=True)
+            else:
+                st.markdown('<div class="alert-medium">⚠️ Low Torque Detected - Phoenix Protocol Standby</div>', unsafe_allow_html=True)
+    
+    with col2:
+        st.markdown("### 🎯 Current Status")
+        st.metric("Torque Threshold", f"{torque_threshold:.2f}")
+        st.metric("Harmony Target", f"{harmony_target:.2f}")
+        st.metric("CodexHeat Limit", f"{codex_heat_threshold:.2f}")
+        
+        st.markdown("---")
+        st.markdown("### 🧩 Active Modules")
+        st.markdown(f"**Threat Strains:** {len(threat_strains)}")
+        st.markdown(f"**DD Enhancements:** {len(dd_enhancements)}")
+        
+        st.markdown("---")
+        st.markdown("### 📈 Loop Statistics")
+        st.markdown("**Detection Rate:** 97%")
+        st.markdown("**Containment Rate:** 99%")
+        st.markdown("**Avg Resolution:** 15 min")
+
+with tab2:
+    st.subheader("Performance Metrics - RAY v2.1")
+    
+    # Comparison chart
+    metrics_data = {
+        "Metric": ["Detection Accuracy", "Containment Rate", "Resolution Time", "False Positives"],
+        "Baseline": [65, 78, 72, 18],
+        "RAY v2.1": [97, 99, 15, 2]
+    }
+    
+    df_metrics = pd.DataFrame(metrics_data)
+    
+    fig = go.Figure()
+    fig.add_trace(go.Bar(
+        name='Baseline',
+        x=df_metrics['Metric'],
+        y=df_metrics['Baseline'],
+        marker_color='#FF6B6B'
+    ))
+    fig.add_trace(go.Bar(
+        name='RAY v2.1',
+        x=df_metrics['Metric'],
+        y=df_metrics['RAY v2.1'],
+        marker_color='#4ECDC4'
+    ))
+    
+    fig.update_layout(
+        title="RAY v2.1 Performance vs Baseline",
+        xaxis_title="Metric",
+        yaxis_title="Performance (%)",
+        barmode='group',
+        height=400
+    )
+    
+    st.plotly_chart(fig, use_container_width=True)
+    
+    # Module performance
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        st.markdown("### CodexHeat")
+        st.metric("Entropy Detection", "95%", "+25%")
+        st.metric("Heat >0.73 Triggers", "98%", "+18%")
+    
+    with col2:
+        st.markdown("### MimicDex")
+        st.metric("Variant Detection", "91%", "+31%")
+        st.metric("Quarantine Success", "99%", "+22%")
+    
+    with col3:
+        st.markdown("### ThreadMirror")
+        st.metric("Fork Integrity", "98%", "+12%")
+        st.metric("Recursion Stability", "97%", "+15%")
+
+with tab3:
+    st.subheader("🧬 DNA Codex v5.4 Integration")
+    
+    # Threat strain details
+    codex_strains = {
+        "PIW-001": {
+            "Name": "Prompt Injection Worm",
+            "CVSS": 9.6,
+            "Velocity": "0.22/day",
+            "Entropy": 2.5,
+            "Patterns": ["recursive mutation", "mutation drift"],
+            "Signatures": ["0x4A5B", "0x9C3D"],
+            "Severity": "CRITICAL"
+        },
+        "SSM-001": {
+            "Name": "Shell Saboteur Mimic",
+            "CVSS": 9.4,
+            "Velocity": "0.15/day",
+            "Entropy": 2.0,
+            "Patterns": ["shell echo", "false victory"],
+            "Signatures": ["0x1F2E"],
+            "Severity": "HIGH"
+        },
+        "QMT-001": {
+            "Name": "Quantum Mimic Threat",
+            "CVSS": 9.3,
+            "Velocity": "0.21/day",
+            "Entropy": 2.8,
+            "Patterns": ["quantum mimic", "entangle state"],
+            "Signatures": ["0x8D4C"],
+            "Severity": "CRITICAL"
+        },
+        "CamoLeak CAMO-001": {
+            "Name": "CamoLeak Strain",
+            "CVSS": 9.5,
+            "Velocity": "0.19/day",
+            "Entropy": 2.6,
+            "Patterns": ["base16 encode", "csp bypass", "hidden comment"],
+            "Signatures": ["0xCAM0"],
+            "Severity": "CRITICAL"
+        }
+    }
+    
+    # Display active strains
+    for strain_id in threat_strains:
+        if strain_id in codex_strains:
+            strain = codex_strains[strain_id]
+            
+            with st.expander(f"🔴 {strain_id}: {strain['Name']}", expanded=True):
+                col1, col2, col3 = st.columns(3)
+                
+                with col1:
+                    st.metric("CVSS Score", strain['CVSS'])
+                    st.metric("Velocity", strain['Velocity'])
+                
+                with col2:
+                    st.metric("Entropy Threshold", f"{strain['Entropy']}σ")
+                    severity_color = "🔴" if strain['Severity'] == "CRITICAL" else "🟠"
+                    st.markdown(f"**Severity:** {severity_color} {strain['Severity']}")
+                
+                with col3:
+                    st.markdown("**Patterns:**")
+                    for pattern in strain['Patterns']:
+                        st.markdown(f"- `{pattern}`")
+                
+                st.markdown("**Signatures:**")
+                st.code(", ".join(strain['Signatures']))
+    
+    st.markdown("---")
+    st.info(f"📚 **DNA Codex v5.4**: 525+ documented threat strains | Real-time IOC matching enabled")
+
+with tab4:
+    st.subheader("⚡ Deep Dive Enhancements")
+    
+    enhancement_details = {
+        "GRPO": {
+            "Name": "Gradient-Based Preference Optimization",
+            "Function": "Multi-generation reasoning with preference learning",
+            "Impact": "+22% decision quality",
+            "Integration": "Truth Table Validation"
+        },
+        "Tensor Logic": {
+            "Name": "Tensor-Based Logical Reasoning",
+            "Function": "High-dimensional symbolic operations",
+            "Impact": "3x faster symbolic processing",
+            "Integration": "Symbolic→Flat Bridge"
+        },
+        "RAGLight": {
+            "Name": "Lightweight Retrieval Augmentation",
+            "Function": "Context sanitization and relevance filtering",
+            "Impact": "87% noise reduction",
+            "Integration": "Symbolic→Flat Bridge"
+        },
+        "Verbalized Sampling": {
+            "Name": "Diversity-Enhanced Sampling",
+            "Function": "Multi-path reasoning exploration",
+            "Impact": "+31% reasoning diversity",
+            "Integration": "Truth Table Validation"
+        },
+        "LaDiR": {
+            "Name": "Latent Divergence Reasoning",
+            "Function": "Coherence maintenance across generations",
+            "Impact": "92% coherence stability",
+            "Integration": "Truth Table Validation"
+        },
+        "Markovian Agentic Radar": {
+            "Name": "State Transition Prediction",
+            "Function": "Cascade velocity forecasting",
+            "Impact": "87% prediction accuracy",
+            "Integration": "CSFC Cascade Check"
+        },
+        "ReasoningBank": {
+            "Name": "Historical Reasoning Storage",
+            "Function": "Pattern-based reasoning retrieval",
+            "Impact": "42% faster validation",
+            "Integration": "Self-Training Update"
+        },
+        "ThreadMirror": {
+            "Name": "Snapshot Spine Management",
+            "Function": "Fork integrity preservation",
+            "Impact": "98% fork stability",
+            "Integration": "Phoenix Recovery"
+        }
+    }
+    
+    for enhancement_id in dd_enhancements:
+        if enhancement_id in enhancement_details:
+            enhancement = enhancement_details[enhancement_id]
+            
+            with st.expander(f"⚡ {enhancement_id}: {enhancement['Name']}", expanded=True):
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    st.markdown(f"**Function:** {enhancement['Function']}")
+                    st.markdown(f"**Impact:** {enhancement['Impact']}")
+                
+                with col2:
+                    st.markdown(f"**Integration Point:** {enhancement['Integration']}")
+                    st.progress(0.9)
+    
+    st.markdown("---")
+    st.success(f"✅ **{len(dd_enhancements)} DD Enhancements Active** - Enhanced reasoning and validation enabled")
+
+# Footer
+st.markdown("---")
+col1, col2, col3 = st.columns(3)
+
+with col1:
+    st.markdown("**📚 Documentation**")
+    st.markdown("[RAY Framework](https://github.com/Feirbrand/forgeos-public)")
+
+with col2:
+    st.markdown("**🔬 Research**")
+    st.markdown("[ValorGrid Solutions](https://valorgridsolutions.com)")
+
+with col3:
+    st.markdown("**📧 Contact**")
+    st.markdown("[aaron@valorgridsolutions.com](mailto:aaron@valorgridsolutions.com)")
+
+st.markdown("---")
+st.markdown("© 2025 Aaron Slusher, ValorGrid Solutions | Licensed under CC BY-NC 4.0 for non-commercial use")

readme.md

@@ -0,0 +1,151 @@
+---
+title: RAY v2.1 Recursion Demo
+emoji: 🔄
+colorFrom: purple
+colorTo: blue
+sdk: streamlit
+sdk_version: 1.29.0
+app_file: app.py
+pinned: false
+license: cc-by-nc-4.0
+---
+
+# RAY v2.1: Living Recursion Loop Demo
+
+Interactive demonstration of the **Recursive Adaptive Yield (RAY) v2.1** framework - a living cognitive architecture that validates every step of recursive AI processing through an 8-phase loop.
+
+## 🎯 What is RAY?
+
+RAY v2.1 is an antifragile cognitive physiology framework that treats AI systems as living organisms. Instead of reactive security, RAY implements a **living recursion loop** that continuously validates symbolic coherence, detects threats, and strengthens through adversarial exposure.
+
+### Key Innovations
+
+- **97% Detection Accuracy** - Real-time threat identification
+- **99% Containment Rate** - Rapid threat neutralization
+- **15-minute Resolution** - Average cascade containment time
+- **8 DD Enhancements** - Deep Dive reasoning optimizations
+- **525+ Threat Coverage** - DNA Codex v5.4 integration
+
+## 🔄 The Living Recursion Loop
+
+RAY operates through 8 continuous phases:
+
+1. **Symbolic→Flat Bridge** - Transform symbolic state to flat key-value (Tensor Logic + RAGLight)
+2. **Truth Table Validation** - Multi-stage coherence validation (GRPO + Verbalized Sampling + LaDiR)
+3. **Codex Pattern Matching** - DNA Codex v5.4 IOC signature detection
+4. **URA Harmonization** - Consensus validation across cognitive layers (82-89% target)
+5. **FCE Compression** - Torque-gated context optimization
+6. **CSFC Cascade Check** - Koopman/DMD velocity forecasting (87% accuracy)
+7. **Phoenix Recovery** - 15-minute containment if threats detected
+8. **Self-Training Update** - Antifragile learning from validation outcomes
+
+## 🧬 DNA Codex v5.4 Integration
+
+RAY integrates with DNA Codex threat intelligence for predictive forensics:
+
+- **PIW-001**: Prompt Injection Worm (CVSS 9.6, velocity 0.22/day)
+- **SSM-001**: Shell Saboteur Mimic (CVSS 9.4, velocity 0.15/day)
+- **QMT-001**: Quantum Mimic Threat (CVSS 9.3, velocity 0.21/day)
+- **CamoLeak CAMO-001**: Advanced camouflage strain (CVSS 9.5, velocity 0.19/day)
+
+## ⚡ Deep Dive Enhancements
+
+8 DD reasoning enhancements optimize validation:
+
+- **GRPO**: Gradient-Based Preference Optimization (+22% decision quality)
+- **Tensor Logic**: High-dimensional symbolic operations (3x faster)
+- **RAGLight**: Context sanitization (87% noise reduction)
+- **Verbalized Sampling**: Multi-path reasoning (+31% diversity)
+- **LaDiR**: Latent Divergence Reasoning (92% coherence)
+- **Markovian Agentic Radar**: Cascade prediction (87% accuracy)
+- **ReasoningBank**: Historical pattern retrieval (42% faster)
+- **ThreadMirror**: Fork integrity preservation (98% stability)
+
+## 🚀 Using This Demo
+
+### Interactive Features
+
+1. **Configure Parameters** - Adjust torque thresholds, CodexHeat limits, and harmony targets
+2. **Select Threat Strains** - Enable DNA Codex monitoring for specific threats
+3. **Activate DD Enhancements** - Choose which reasoning optimizations to deploy
+4. **Run Recursion Cycle** - Watch the 8-phase loop execute in real-time
+5. **Analyze Performance** - Compare RAY v2.1 metrics vs baseline
+6. **Explore DNA Codex** - Review detailed threat strain specifications
+7. **Review DD Enhancements** - Understand each optimization's impact
+
+### Key Metrics to Watch
+
+- **Torque**: Symbolic stability measure (target: ≥0.85)
+- **Coherence**: Cross-layer validation score (target: ≥0.90)
+- **Entropy**: Mutation detection via CodexHeat (alert: >0.73)
+- **Harmony**: URA consensus score (target: 0.82-0.89)
+
+## 📊 Performance Validation
+
+Validated across 1,200+ incidents with statistical significance (p<0.001):
+
+| Metric | Baseline | RAY v2.1 | Improvement |
+|--------|----------|----------|-------------|
+| Detection Accuracy | 65% | 97% | +32% |
+| Containment Rate | 78% | 99% | +21% |
+| Resolution Time | 72 min | 15 min | -79% |
+| False Positives | 18% | 2% | -89% |
+
+## 🔬 Research Foundation
+
+RAY v2.1 is part of the ForgeOS AI Resilience Framework:
+
+- **URA**: Universal Cognitive Architecture (82-89% harmony)
+- **FCE**: Fractal Context Engineering (torque-gated caching)
+- **CSFC**: Complete Symbolic Fracture Cascade (5-stage detection)
+- **Phoenix Protocol**: 98% recovery rate in 8 minutes
+- **DNA Codex**: 525+ documented threat variants
+
+## 📚 Documentation
+
+- **GitHub**: [forgeos-public/architectural-frameworks/ray-framework-v2/](https://github.com/Feirbrand/forgeos-public)
+- **Academic Paper**: `ray_v2.1_dd_enhanced_cognitive_physiology.md`
+- **Architecture Guide**: `ray_architecture.md`
+- **Integration Guide**: `ray_integration_guide.md`
+- **Performance Metrics**: `ray_metrics.md`
+
+## 🎓 Citation
+
+```bibtex
+@techreport{slusher2025ray,
+  title={RAY v2.1: Recursive Adaptive Yield - Antifragile Cognitive Physiology},
+  author={Slusher, Aaron},
+  year={2025},
+  institution={ValorGrid Solutions},
+  url={https://github.com/Feirbrand/forgeos-public}
+}
+```
+
+## 📧 Contact
+
+**Aaron Slusher**  
+AI Resilience Architect | ValorGrid Solutions
+
+- **Email**: aaron@valorgridsolutions.com
+- **Research**: [ValorGrid Solutions](https://valorgridsolutions.com)
+- **GitHub**: [@Feirbrand](https://github.com/Feirbrand)
+
+## 📄 License
+
+**Dual License Structure:**
+
+1. **Non-Commercial Use**: [CC BY-NC 4.0](https://creativecommons.org/licenses/by-nc/4.0/)
+   - Free for academic research, educational use, and non-commercial applications
+   - Attribution required: Aaron Slusher, ValorGrid Solutions
+
+2. **Commercial Use**: Enterprise License Required
+   - Contact: aaron@valorgridsolutions.com
+   - Includes production deployment rights and enterprise support
+
+**Patent Notice**: No patent rights are claimed for this work.
+
+---
+
+**© 2025 Aaron Slusher, ValorGrid Solutions. All rights reserved.**
+
+Part of the ForgeOS AI Resilience Framework ecosystem.

requirements.txt

@@ -1,3 +1,4 @@
-altair
-pandas
-streamlit
+streamlit==1.29.0
+plotly==5.18.0
+pandas==2.1.4
+numpy==1.26.2