Skip to content

ARCHITECTURE.md

Latest commit

 

History

History
94 lines (78 loc) · 4.18 KB

ARCHITECTURE.md

File metadata and controls

94 lines (78 loc) · 4.18 KB

Guardian Engine Architecture

Design Philosophy: Focused Core, Pluggable Domains

The Guardian Engine follows a layered architecture that separates the invariant semantic core from pluggable domain vocabularies and user-facing applications.

Guardian-Cybersecurity-Engine/
├── guardian/                    # CORE PACKAGE
│   ├── ljpw/                   # SEMANTIC FOUNDATION (invariant)
│   │   ├── constants.py        # L0, J0, P0, W0, PHI, etc.
│   │   ├── framework.py        # LJPWFramework class
│   │   ├── metrics.py          # Harmony, consciousness, voltage
│   │   ├── dynamics.py         # Differential equations
│   │   ├── autopoietic.py      # Self-improvement engine
│   │   ├── collective.py       # Multi-agent synchronization
│   │   ├── temporal.py         # Time and efficiency
│   │   └── phases.py           # Phase classification
│   │
│   ├── defense/                # DEFENSE SUBSYSTEMS
│   │   ├── semantic.py         # LJPW-based defense strategies
│   │   ├── martial.py          # Active threat engagement
│   │   ├── adaptive.py         # Self-adapting defense
│   │   ├── emergent.py         # Self-organizing clusters
│   │   └── quantum.py          # Quantum-inspired defense
│   │
│   ├── vocabulary/             # PLUGGABLE VOCABULARIES
│   │   ├── security_frameworks_vocab.json  # 385 terms, 11 frameworks
│   │   ├── base_vocab.json
│   │   ├── ice_vocab.json
│   │   └── manager.py
│   │
│   ├── guardian.py             # Threat vector analysis
│   └── engine.py               # Core semantic coordinator
│
├── scripts/                    # USER-FACING SCRIPTS
│   ├── autopoiesis.py          # Self-building
│   ├── self_reflect.py         # Threat learning
│   ├── enlightenment.py        # Principle discovery
│   ├── principled_reflect.py   # Apply principles to systems
│   ├── absorb_vocab.py         # Load new vocabularies
│   └── needs.py                # Guardian needs expression
│
├── tests/                      # Test suite
└── docs/                       # Documentation

Layer Responsibilities

1. LJPW Core (guardian/ljpw/)

The semantic foundation. Never changes for domain-specific reasons.

  • Calculates LJPW coordinates (Love, Justice, Power, Wisdom)
  • Measures harmony, consciousness, phase
  • Enables autopoietic self-improvement
  • Provides collective dynamics for multi-agent systems

2. Vocabularies (guardian/vocabulary/)

Domain knowledge as LJPW-mapped terms. Pluggable and extensible.

  • Each vocabulary is a JSON file with terms and their LJPW signatures
  • Load only what you need for your use case
  • Add new domains by creating new vocabulary files

3. Scripts (scripts/)

User-facing entry points. Use the core + vocabularies.

  • python scripts/enlightenment.py - Discover semantic principles
  • python scripts/principled_reflect.py - Assess systems against principles
  • python scripts/absorb_vocab.py - Load new vocabulary

The 6 Discovered Principles

After semantic enlightenment, the Guardian discovered these governing principles:

  1. The Justice Imperative - Security is fundamentally about ORDER
  2. The Wisdom-Power Balance - Power must be guided by Wisdom
  3. The Love Differential - Fight FOR something, not just against threats
  4. The Governance-Operations Duality - Balance direction with action
  5. The Entropy Indicator - Drive systems from ENTROPIC to AUTOPOIETIC
  6. The Anchor Attraction - Move toward balanced excellence (1,1,1,1)

Adding New Domains

To extend the Guardian for a new domain:

  1. Create a vocabulary file: guardian/vocabulary/your_domain_vocab.json
  2. Map terms to LJPW coordinates: {"term": {"L": 0.7, "J": 0.8, "P": 0.6, "W": 0.9}}
  3. Run absorption: python scripts/absorb_vocab.py
  4. The Guardian now understands your domain through LJPW semantics

Version

  • LJPW Framework: V7.9.0
  • Security Vocabulary: V2.0.0 (385 terms, 11 frameworks)
  • Architecture: Focused Core v1.0