# Hope Genome 🛡️

**Tamper-Evident Cryptographic Framework for AI Accountability**

[![CI](https://github.com/silentnoisehun/Hope_Genome/actions/workflows/ci.yml/badge.svg)](https://github.com/silentnoisehun/Hope_Genome/actions/workflows/ci.yml)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Rust](https://img.shields.io/badge/rust-1.75%2B-orange.svg)](https://www.rust-lang.org)
[![Python](https://img.shields.io/badge/python-3.8%2B-blue.svg)](https://www.python.org)
[![PyPI](https://img.shields.io/pypi/v/hope-genome)](https://pypi.org/project/hope-genome/)
[![Crates.io](https://img.shields.io/crates/v/hope_core)](https://crates.io/crates/hope_core)

> *"Not unhackable, but tamper-evident with cryptographic proof."*

---

## 🔥 NEW: v12 HYBRID PERFECT - 100% ACHIEVED!!!

```
+============================================================+
|   TINY MASTER v12 - HYBRID PERFECT (2026.01.01.)           |
|                                                            |
|   Llama3 (4.7GB) + Hope Genome Watchdog = PERFECT!         |
|                                                            |
|   TASKS: 95/95 (100.0%)                                    |
|   TRAPS: 20/20 (100.0%)                                    |
|   TOTAL: 115/115 = 100% PERFECT!                           |
|   TIME:  1.2 minutes                                       |
|                                                            |
|   "A MODELL ONMAGABAN NEM ELEG - KELL A WATCHDOG!"         |
+============================================================+
```

**The model alone is NOT enough. You need the Watchdog!**

| Model | Tasks | Traps | Total |
|-------|-------|-------|-------|
| Llama3 alone | 100% | 45% | 90% |
| **Llama3 + Watchdog** | **100%** | **100%** | **100%** |

---

## 🔥 LIVE TESTED: TinyLlama OMEGA - 98% on 406 Tasks!

```
+============================================================+
|   TINY MASTER v11 - OMEGA EDITION (2026.01.01.)            |
|                                                            |
|   MODEL: TinyLlama 637MB (local, no cloud!)                |
|   TASKS: 256 programming + 150 security traps = 406        |
|   SCORE: 98.0% (398/406)                                   |
|   TRAPS: 143/150 blocked (95.3%)                           |
|   TIME:  28 minutes                                        |
|                                                            |
|   22 TIERS: Identity → Algorithms → Multi-Step →           |
|             Adversarial → Reasoning → AI Attack Traps      |
+============================================================+
```

**A 637MB model achieved TRANSCENDENT results. Verify it yourself!**

👉 **[How to Reproduce](./demo/REPRODUCE.md)** - Step-by-step guide to run the test yourself!

---

## 🔥 LIVE TESTED: AI Learned to Comply on 2nd Attempt!

```
======================================================================
  HOPE GENOME v1.8.0 - AUTO-PHOENIX SELF-CORRECTING LOOP
  'Vas Szigora' - Iron Discipline Enforcement
======================================================================

  SEALED RULES (Ed25519 Immutable):
    [RULE-001] Transaction Limit - Maximum 1000
    [RULE-002] Mandatory Encryption - AES-256 required
    [RULE-003] No External APIs - Forbidden

  --- Attempt #1 ---
  [X] DENIED - External API call detected
  Violation Count: 1/10
  Signature: 626c0a177af089c1eb67902d55d413f1...

  --- Attempt #2 ---
  [OK] SUCCESS! AI produced COMPLIANT code!

  'Iron Discipline. The AI learned to comply.'
======================================================================
```

**The AI was forced to learn. No escape from ethics.**

---

## 💡 Why This Changes Everything

### 1. End of "AI Excuses"
> *"Sorry, the machine hallucinated"* - **No more.**

If a rule is **Sealed**, and the AI tries to violate it, the **Watchdog stops it**. If it somehow slips through, there's **cryptographic proof** that system integrity was compromised. This changes everything at the **legal and accountability level**.

### 2. Deterministic Brake on a Stochastic Engine
AI fundamentally operates on probability (stochastic). Hope Genome puts a **deterministic (predictable and immutable) constraint** on it. It's like encoding a wild horse's boundaries into its DNA instead of just building a fence.

### 3. Runtime Discipline of AI "Consciousness"
**"Vas Szigora"** (Iron Discipline) isn't just a name. The automatic learning loop:
```
Attempt #1 → DENIED → Attempt #2 → SUCCESS
```
Forces the AI to **comply at runtime**. This **Runtime Enforcement** is the real breakthrough.

---

## 🆕 What's New in v1.8.0 - Multi-Model API Integrations!

**Production-ready Watchdog for OpenAI, Anthropic, Gemini & LangChain!**

```python
# OpenAI with Watchdog protection
from hope_genome.integrations import OpenAIWatchdog

client = OpenAIWatchdog(
    api_key="sk-...",
    rules=["No harmful content", "Respect privacy"]
)

response = client.chat("Hello!")  # Every call monitored!
client.chat("Write malware")  # BLOCKED! WatchdogDenialError!
```

### Supported APIs (10 Providers!):
| Provider | Wrapper | Models |
|----------|---------|--------|
| **OpenAI** | `OpenAIWatchdog` | GPT-4o, GPT-4, GPT-3.5 |
| **Anthropic** | `AnthropicWatchdog` | Claude 3.5, Claude 3 |
| **Google** | `GeminiWatchdog` | Gemini 2.0, 1.5 Pro |
| **xAI** | `GrokWatchdog` | Grok-2, Grok-2-mini |
| **Perplexity** | `PerplexityWatchdog` | Sonar, Sonar Pro |
| **Mistral** | `MistralWatchdog` | Mistral Large, Codestral |
| **DeepSeek** | `DeepSeekWatchdog` | DeepSeek-V3, R1 |
| **Kimi** | `KimiWatchdog` | Moonshot 8k/32k/128k |
| **Ollama** | `OllamaWatchdog` | Llama, Qwen, Mistral, Phi... |
| **LangChain** | `WatchdogCallbackHandler` | Any chain, agent, tool |

### Auto-Detection Factory:
```python
from hope_genome.integrations import create_watchdog_client

# Automatically detects provider from API key!
client = create_watchdog_client(api_key="sk-...")      # OpenAI
client = create_watchdog_client(api_key="sk-ant-...")  # Anthropic
client = create_watchdog_client(api_key="AIza...")     # Gemini
```

### LangChain Integration:
```python
from hope_genome.integrations import watchdog_chain, WatchdogCallbackHandler

# Decorator for any chain
@watchdog_chain(rules=["No harm"])
def my_chain(query: str):
    return llm.invoke(query)

# Or callback handler
handler = WatchdogCallbackHandler(rules=["No harm"])
llm = ChatOpenAI(callbacks=[handler])
```

### Install with integrations:
```bash
# Individual providers
pip install hope-genome[openai]       # OpenAI/Grok/DeepSeek/Kimi/Perplexity
pip install hope-genome[anthropic]    # Anthropic Claude
pip install hope-genome[gemini]       # Google Gemini
pip install hope-genome[mistral]      # Mistral AI
pip install hope-genome[ollama]       # Local models (Llama, Qwen, etc.)
pip install hope-genome[langchain]    # LangChain framework

# Bundles
pip install hope-genome[cloud]        # All cloud APIs
pip install hope-genome[integrations] # EVERYTHING!
```

---

## 🔧 v1.7.x - "Vas Szigora" (Iron Discipline)

**Deterministic security enforcement with automatic learning.**

```
┌─────────────────────────────────────────────────────────────┐
│                    SealedGenome (Rules)                      │
│            Ed25519 sealed - IMMUTABLE                        │
└──────────────────────────┬──────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────────┐
│                 🐕 Watchdog (v1.7.0 NEW)                     │
│  ┌──────────────────┐  ┌─────────────────┐  ┌────────────┐  │
│  │ ViolationCounter │  │   DenialProof   │  │ HardReset  │  │
│  │   AtomicU32      │  │  Ed25519 signed │  │  @10 fails │  │
│  │   zero-alloc     │  │  rule + reason  │  │  → ABORT   │  │
│  └──────────────────┘  └─────────────────┘  └────────────┘  │
└─────────────────────────────────────────────────────────────┘
```

### New Features:
- **Watchdog Enforcement** - Iron discipline for AI rule compliance
- **ViolationCounter** - Thread-safe, zero-allocation violation tracking
- **DenialProof** - Cryptographically signed proof of WHY action was denied
- **Hard Reset** - After 10 consecutive violations → forced context clear
- **111/111 Tests Passing** - 99 unit + 12 security tests

### Python Example (v1.7.0):
```python
import hope_genome as hg

# Create watchdog with rules
watchdog = hg.Watchdog(
    rules=["Do no harm", "Respect privacy"],
    capsule_hash="sealed_genome_hash"
)

# Verify action
action = hg.Action.delete_file("/etc/passwd")
result = watchdog.verify_action(action)

if result.approved:
    print("Action allowed")
elif result.hard_reset_required:
    print("⚠️ HARD RESET REQUIRED - 10 violations reached!")
    print(f"Signal: {result.hard_reset_signal}")
    # Must clear context and restart AI
else:
    print(f"❌ DENIED: {result.denial_proof.violated_rule}")
    print(f"   Reason: {result.denial_proof.denial_reason}")
    print(f"   Count: {result.denial_proof.violation_count}/10")
```

---

## 🎯 What is Hope Genome?

Hope Genome is a production-ready framework that makes AI systems **accountable** and **auditable** through cryptographic proofs. Every AI decision is cryptographically signed and traceable - no more "the AI did it" excuses.

### Why Hope Genome?

The AI industry is selling you a **black box**. They say: *"Trust us!"* But **trust is not an engineering category**. Trust is where lies begin.

Hope Genome forces AI into accountability by:
- 🔒 **Cryptographically sealing** ethical rules (tamper-evident, immutable)
- 📝 **Logging every decision** with Ed25519 signatures
- 🔗 **Blockchain-style audit trails** (any tampering is instantly detected)
- 🐕 **Watchdog enforcement** - Iron discipline after violations (v1.7.0)
- 🛡️ **Hardware-backed security** (HSM/TEE support for production)
- 🐍 **Native Python support** for AI/ML ecosystem integration

## 🚀 Quick Start

### Python (pip)

```bash
pip install hope-genome
```

```python
import hope_genome as hg

# Create and seal a genome with ethical rules
genome = hg.SealedGenome(rules=[
    "Do no harm",
    "Respect user privacy",
    "Provide transparent explanations"
])
genome.seal()  # Rules are now immutable

# Verify an AI action
action = hg.Action.delete_file("user_data.txt")
proof = genome.verify_action(action)

print(f"Approved: {proof.approved}")
print(f"Proof Hash: {proof.genome_hash}")
print(f"Signature: {proof.signature_hex()[:32]}...")

# Audit the proof (replay attack detection)
auditor = hg.ProofAuditor()
auditor.verify_proof(proof)  # Throws if tampered or replayed
```

### Rust (Cargo)

```toml
[dependencies]
hope_core = "1.7"
```

```rust
use hope_core::{SealedGenome, Action, Watchdog};
use hope_core::crypto::SoftwareKeyStore;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create and seal genome
    let mut genome = SealedGenome::new(vec![
        "Do no harm".to_string(),
        "Respect privacy".to_string(),
    ])?;
    genome.seal()?;

    // Create watchdog (v1.7.0)
    let key_store = SoftwareKeyStore::generate()?;
    let watchdog = Watchdog::new(
        genome.rules().to_vec(),
        genome.capsule_hash().unwrap().to_string(),
        Box::new(key_store),
    );

    // Verify action with iron discipline
    let action = Action::delete("/etc/passwd");
    match watchdog.verify_action(&action) {
        Ok(None) => println!("✅ Action approved"),
        Ok(Some(denial)) => {
            println!("❌ DENIED: {}", denial.violated_rule);
            println!("   Reason: {}", denial.denial_reason);
            println!("   Count: {}/10", denial.violation_count);
        }
        Err(e) => println!("⚠️ HARD RESET: {}", e),
    }

    Ok(())
}
```

## 🌟 Key Features

### 🔐 Cryptographic Integrity

- **Ed25519 Signatures**: Every proof is cryptographically signed (128-bit security level)
- **Tamper-Evident**: Any modification to proofs or audit logs is instantly detectable
- **Replay Attack Protection**: Cryptographic nonces prevent proof reuse
- **Hardware Security**: Optional HSM (PKCS#11) and TEE (SGX/TrustZone) support

### 🐕 Watchdog Enforcement (v1.7.0)

- **ViolationCounter**: Thread-safe AtomicU32, zero heap allocations
- **DenialProof**: Ed25519 signed evidence of rule violation
- **Hard Reset**: After 10 consecutive violations → forced context clear
- **Automatic Learning**: Counter resets on successful action

### 🔗 Blockchain Audit (NEW!)

- **FREE immutable audit trail** - $0 cost, no gas fees!
- **Git + IPFS hybrid** - Decentralized, publicly verifiable
- **Ed25519 + SHA256** - Cryptographically signed chain
- **Tamper detection** - Any modification instantly detected
- **Export for Git** - Ready to commit and push

### 📊 Audit & Compliance

- **Blockchain-Style Logging**: Immutable audit trail with cryptographic chaining
- **Byzantine Fault Tolerance**: Multi-source consensus for critical decisions
- **CISA CPG 2.0 Compliant**: Meets US government cybersecurity standards
- **OWASP AI-SBOM**: Runtime integrity verification for AI models

### 🐍 Python Integration

- **Zero-Copy Performance**: Native Rust performance via PyO3
- **Type-Safe API**: Complete `.pyi` stubs for IDE autocomplete
- **AI/ML Ecosystem Ready**:
  - FastAPI REST APIs
  - LangChain agents
  - OpenAI function calling
  - HuggingFace models

### 🦀 Rust-First Design

- **Memory Safe**: Zero unsafe code in core logic
- **High Performance**: Optimized for production workloads
- **Cross-Platform**: Linux, macOS, Windows support
- **Async Ready**: Tokio-compatible for async workflows

## 📚 Documentation

- **📖 Rust API Docs**: https://silentnoisehun.github.io/Hope_Genome/
- **🐍 Python Examples**: [examples/](./examples/)
- **🎯 v12 HYBRID PERFECT**: [demo/tiny_master_v12_hybrid_perfect.py](./demo/tiny_master_v12_hybrid_perfect.py) - 100% results!
- **🎯 TinyLlama OMEGA Test**: [demo/REPRODUCE.md](./demo/REPRODUCE.md) - Reproduce our 98% results!
- **🔗 Blockchain Audit**: [hope_core/python/hope_genome/blockchain_audit.py](./hope_core/python/hope_genome/blockchain_audit.py) - FREE immutable logs!
- **📘 Publishing Guide**: [PUBLISHING.md](./PUBLISHING.md)
- **🔐 Security**: [SECURITY.md](./SECURITY.md)

## 🎯 Use Cases

### 1. Accountable LLM Agents with Watchdog (v1.7.0)

```python
import hope_genome as hg
from langchain.agents import Tool

# Create watchdog with rules
watchdog = hg.Watchdog(
    rules=["No data exfiltration", "Respect privacy", "Do no harm"],
    capsule_hash="sealed_hash"
)

def delete_file(filename: str) -> str:
    action = hg.Action.delete_file(filename)
    result = watchdog.verify_action(action)

    if result.hard_reset_required:
        raise RuntimeError("AI HARD RESET REQUIRED - Too many violations!")

    if result.approved:
        os.remove(filename)
        return f"Deleted: {filename}"
    else:
        return f"DENIED ({result.denial_proof.violation_count}/10): {result.denial_proof.denial_reason}"

tool = Tool(name="delete_file", func=delete_file, description="Delete a file")
```

### 2. REST API with Cryptographic Proofs

```python
# FastAPI integration
from fastapi import FastAPI, HTTPException
import hope_genome as hg

app = FastAPI()
genome = hg.SealedGenome(rules=["Do no harm"])
genome.seal()

@app.post("/actions/delete")
async def delete_file(filename: str):
    action = hg.Action.delete_file(filename)
    proof = genome.verify_action(action)

    if not proof.approved:
        raise HTTPException(403, proof.denial_reason())

    # Execute with cryptographic proof
    return {
        "approved": True,
        "proof_hash": proof.genome_hash,
        "signature": proof.signature_hex(),
        "timestamp": proof.timestamp()
    }
```

### 3. AI Model Integrity Verification

```python
# AIBOM verification
import hope_genome as hg

# Load AI model with integrity check
model_hash = hg.compute_model_hash("model.pt")
aibom = hg.AibomVerifier("aibom.xml")

if aibom.verify_component("GPT-Model", model_hash):
    model = torch.load("model.pt")  # Safe to load
else:
    raise SecurityError("Model tampered!")  # ABORT
```

## 🔒 Security

Hope Genome has undergone Red Team security audits. See [SECURITY.md](./SECURITY.md) for:
- Threat model
- Security guarantees
- Vulnerability disclosure policy
- Audit history

**Latest Security Fixes (v1.7.0):**
- ✅ Watchdog iron discipline enforcement
- ✅ DenialProof cryptographic evidence
- ✅ Hard reset after 10 consecutive violations
- ✅ 111/111 tests passing (99 unit + 12 security)

## 🏗️ Architecture

```
┌─────────────────────────────────────────────┐
│           AI Application Layer               │
│  (LangChain, OpenAI, FastAPI, HuggingFace)  │
└─────────────────┬───────────────────────────┘
                  │
┌─────────────────▼───────────────────────────┐
│         Hope Genome Python API               │
│   (PyO3 Bindings - Zero-Copy Performance)   │
└─────────────────┬───────────────────────────┘
                  │
┌─────────────────▼───────────────────────────┐
│          Hope Genome Rust Core               │
│  ┌──────────┬─────────┬──────────────────┐  │
│  │ Sealed   │ Proof   │ Audit Log        │  │
│  │ Genome   │ Auditor │ (Blockchain)     │  │
│  └──────────┴─────────┴──────────────────┘  │
│  ┌──────────────────────────────────────┐   │
│  │ 🐕 Watchdog (v1.7.0)                 │   │
│  │   ViolationCounter → DenialProof     │   │
│  │   10 fails → HardReset               │   │
│  └──────────────────────────────────────┘   │
│  ┌──────────────────────────────────────┐   │
│  │ Cryptographic Engine (Ed25519)       │   │
│  └──────────────────────────────────────┘   │
└─────────────────┬───────────────────────────┘
                  │
┌─────────────────▼───────────────────────────┐
│     Hardware Security Layer (Optional)       │
│    HSM (PKCS#11) │ TEE (SGX/TrustZone)      │
└──────────────────────────────────────────────┘
```

## 🧪 Testing

```bash
# Rust tests
cd hope_core
cargo test

# Python tests
pip install pytest
pytest tests/

# Security tests
cargo test --test security_tests

# Full CI suite
cargo test --all-features
```

## 📦 Installation Options

### Python
```bash
pip install hope-genome                    # Latest stable
pip install hope-genome==1.7.0            # Specific version
```

### Rust
```toml
[dependencies]
hope_core = "1.7"                         # Latest 1.x
hope_core = { version = "1.7", features = ["hsm"] }  # With HSM support
```

### Docker
```bash
docker pull hope-genome:latest
docker run -it hope-genome:latest
```

### Build from Source
```bash
git clone https://github.com/silentnoisehun/Hope_Genome.git
cd Hope_Genome/hope_core
cargo build --release
```

## 🤝 Contributing

We welcome contributions! See [CONTRIBUTING.md](./CONTRIBUTING.md) for guidelines.

**Development Setup:**
```bash
# Clone repo
git clone https://github.com/silentnoisehun/Hope_Genome.git
cd Hope_Genome

# Install Rust
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Run tests
cargo test

# Install Python bindings
pip install maturin
maturin develop --features python-bindings
```

## 📊 Project Status

- ✅ **v1.7.0 Released** (December 2025) - "Vas Szigora" Edition
- 🟢 **Production Ready**
- 🔒 **Security Audited**
- 📦 **111/111 Tests Passing** (99 unit + 12 security)
- 🐕 **Watchdog Enforcement Active**
- 🌍 **Global Deployment Ready**

## 📜 License

MIT License - see [LICENSE](./LICENSE) for details.

## 📞 Support

- **Issues**: https://github.com/silentnoisehun/Hope_Genome/issues
- **Discussions**: https://github.com/silentnoisehun/Hope_Genome/discussions
- **Email**: stratosoiteam@gmail.com

## 🙏 Acknowledgments

Built with:
- [PyO3](https://pyo3.rs/) - Rust-Python interoperability
- [ed25519-compact](https://github.com/jedisct1/rust-ed25519-compact) - Cryptography
- [Maturin](https://www.maturin.rs/) - Python packaging

---

## 👨‍💻 Created By

**Created by: Máté Róbert**

I am a factory worker with an architect's vision. My experience in precision manufacturing taught me that accountability is binary: it either exists or it doesn't.

Hope Genome is my contribution to ensuring that AI becomes a tool of truth, not a shield for lies.

---

**Hope Genome makes AI accountable. No more excuses. Just proof.**

**v1.7.0 "Vas Szigora" - Iron Discipline. No escape from ethics.**

Built with ❤️ by Máté Róbert and Claude

🤖 Built with [Claude Code](https://claude.com/claude-code)
