Docs: Added documentation for 10 Operational Pillars and updated README

Author: ProgrammerKR

README.md

@@ -58,6 +58,21 @@ ProXPL is implemented entirely in **C/C++** with zero runtime dependencies, maki
 | 🎯 **Memory Safety** | Built-in garbage collector with mark-and-sweep algorithm |
 | 🌐 **Cross-Platform** | First-class support for Windows, Linux, and macOS |
 
+## 🏛️ The 10 Operational Pillars (v1.2.0)
+
+ProXPL introduces 10 revolutionary concepts that redefine modern systems programming:
+
+1.  **[Intent-Oriented Programming](docs/pillars/01_intent_oriented.md)**: Define *what* you want (`intent`), not just *how* to do it (`resolver`).
+2.  **[Context-Aware Polymorphism](docs/pillars/02_context_aware.md)**: Adapt function behavior dynamically based on execution context (`@context`).
+3.  **[Autonomic Self-Healing (ASR)](docs/pillars/03_asr.md)**: Built-in failure recovery with `resilient` and `recovery` blocks.
+4.  **[Intrinsic Security](docs/pillars/04_intrinsic_security.md)**: Taint analysis and `sanitize()` primitives baked into the type system.
+5.  **[Chrono-Native Logic](docs/pillars/05_chrono_native.md)**: Data with expiration dates (`temporal`, `decay after`).
+6.  **[Event-Driven Concurrency](docs/pillars/06_distributed_primitives.md)**: Distributed nodes and types (`distributed`, `node`) as first-class citizens.
+7.  **[AI-Native Integration](docs/pillars/07_ai_native.md)**: Define, train, and run ML models (`model`, `train`, `predict`) natively.
+8.  **[Quantum-Ready Syntax](docs/pillars/08_quantum_ready.md)**: Future-proof syntax for quantum operations (`quantum`, `superpose`, `entangle`).
+9.  **[Hardware-Accelerated Math](docs/pillars/09_hardware_math.md)**: GPU kernel offloading (`gpu`, `kernel`) and tensor math.
+10. **[Zero-Trust Security](docs/pillars/10_zero_trust.md)**: Mandatory identity verification blocks (`verify identity`) and crypto primitives.
+
 ---
 
 ## ⚡ Quick Start

docs/DOCUMENTATION_INDEX.md

@@ -69,6 +69,21 @@
 | **[03-classes.md](docs/tutorials/03-classes.md)** | OOP, inheritance, methods | Intermediate | 45m |
 | **[04-modules.md](docs/tutorials/04-modules.md)** | Module system, imports | Advanced | 30m |
 
+### The 10 Operational Pillars (docs/pillars/)
+
+| File | Pillar | Concept |
+|------|--------|---------|
+| **[01_intent_oriented.md](docs/pillars/01_intent_oriented.md)** | Intent-Oriented | Intent/Resolver pattern |
+| **[02_context_aware.md](docs/pillars/02_context_aware.md)** | Context-Aware | `@context` polymorphism |
+| **[03_asr.md](docs/pillars/03_asr.md)** | Self-Healing | Resilient blocks |
+| **[04_intrinsic_security.md](docs/pillars/04_intrinsic_security.md)** | Intrinsic Security | Taint analysis |
+| **[05_chrono_native.md](docs/pillars/05_chrono_native.md)** | Chrono-Native | Temporal variables |
+| **[06_distributed_primitives.md](docs/pillars/06_distributed_primitives.md)** | Distributed | Node/Distributed types |
+| **[07_ai_native.md](docs/pillars/07_ai_native.md)** | AI-Native | Model/Train/Predict |
+| **[08_quantum_ready.md](docs/pillars/08_quantum_ready.md)** | Quantum-Ready | Qubit/Superpose |
+| **[09_hardware_math.md](docs/pillars/09_hardware_math.md)** | Hardware Math | GPU Kernels |
+| **[10_zero_trust.md](docs/pillars/10_zero_trust.md)** | Zero-Trust | Identity Verification |
+
 ---
 
 ## 🗂️ Documentation by Purpose

docs/DOCUMENTATION_SUMMARY.md

@@ -25,6 +25,7 @@ All ProXPL markdown documentation files have been comprehensively updated to pro
 | **docs/language-spec.md** | ~30KB | ✅ Complete | Complete language specification with grammar, syntax, examples |
 | **src/README.md** | ~12KB | ✅ Complete | Developer guide to codebase with architecture, testing, debugging |
 | **DOCUMENTATION_INDEX.md** | ~15KB | ✅ Updated | Navigation hub updated with new file references |
+| **docs/pillars/** | ~15KB | ✅ New | Complete documentation for the 10 Operational Pillars (v1.2.0) |
 | **DOCUMENTATION_SUMMARY.md** | ~8KB | ✅ Complete | Complete update summary and statistics |
 
 ### Already Comprehensive (Reviewed)

docs/pillars/01_intent_oriented.md

@@ -0,0 +1,26 @@
+# Pillar 1: Intent-Oriented Programming
+
+## Concept
+Intent-Oriented Programming (IOP) shifts focus from *how* to execute a task to *what* the outcome should be. It allows developers to define `intent` interfaces that express a desired capability, and `resolver` implementations that fulfill those intents.
+
+## Syntax
+
+### Intent Declaration
+```javascript
+intent PaymentProcessor(amount, currency) -> bool;
+```
+Defines an abstract operation `PaymentProcessor` that takes an amount and currency, returning a boolean success status.
+
+### Resolver Implementation
+```javascript
+resolver StripePayment for PaymentProcessor {
+    func resolve(amount, currency) {
+        // Implementation for Stripe
+        return true;
+    }
+}
+```
+Provides a concrete implementation for the intent.
+
+## Usage
+The runtime (or compile-time logic) selects the appropriate resolver based on context, configuration, or availability.

docs/pillars/02_context_aware.md

@@ -0,0 +1,22 @@
+# Pillar 2: Context-Aware Polymorphism
+
+## Concept
+Context-Aware Polymorphism allow functions and behavior to adapt dynamically based on the execution environment (e.g., Mobile vs. Cloud, Dev vs. Prod). This is achieved via the `@context` decorator.
+
+## Syntax
+
+### Context Decorators
+```javascript
+@context(env="cloud")
+func connectDB() {
+    // Cloud-specific connection
+}
+
+@context(env="mobile")
+func connectDB() {
+    // Local SQLite connection
+}
+```
+
+## Usage
+The runtime evaluates the current context (set via start flags or environment variables) and dispatches the correct function variant. This eliminates complex `if-else` chains for environment-specific logic.

docs/pillars/03_asr.md

@@ -0,0 +1,23 @@
+# Pillar 3: Autonomic Self-Healing (ASR)
+
+## Concept
+Autonomic Self-Healing Integration (ASR) embeds resilience directly into the language syntax. It provides structured blocks for handling failures, restarting logic, and rolling back state without external supervisors.
+
+## Syntax
+
+### Resilient Block
+```javascript
+resilient(strategy="restart", retries=3) {
+    // Critical code that might fail
+    processTransaction();
+} recovery {
+    // Logic to run if all retries fail
+    logError("Transaction failed");
+}
+```
+
+### Keywords
+- `resilient`: Defines a block monitored for crashes/errors.
+- `recovery`: Checkpoint block executed on ultimate failure.
+- `restart`: Manually trigger a restart of the block.
+- `rollback`: Revert modifications (if transactional memory is supported).

docs/pillars/04_intrinsic_security.md

@@ -0,0 +1,30 @@
+# Pillar 4: Intrinsic Security
+
+## Concept
+Intrinsic Security treats data safety as a type-system feature. It introduces Taint Analysis directly into the language, forcing developers to explicitly sanitize untrusted inputs before using them in sensitive contexts.
+
+## Syntax
+
+### Tainted Types
+```javascript
+policy NoSQLInjection { ... }
+```
+(Note: Policy definition syntax is reserved for future expansion)
+
+### Usage
+```javascript
+// 'input()' returns a tainted string by default (conceptually)
+let userInput = input("Enter query: "); 
+
+// Attempting to use 'userInput' in a sensitive sink (like exec) would warn/error
+// exec(userInput); // Error: Tainted data in sensitive sink
+
+// Must sanitize first
+let cleanInput = sanitize(userInput);
+exec(cleanInput); // Safe
+```
+
+### Keywords
+- `tainted`: (Internal type attribute) Marks data as untrusted.
+- `sanitize(expr)`: Primitive to strip taint from a value.
+- `policy`: Define security boundaries.

docs/pillars/05_chrono_native.md

@@ -0,0 +1,15 @@
+# Pillar 5: Chrono-Native Logic
+
+## Concept
+Chrono-Native Logic treats time as a first-class data attribute. Variables can have a "Time-To-Live" (TTL) and expire automatically, simplifying cache invalidation and session management.
+
+## Syntax
+
+### Temporal Variables
+```javascript
+// Variable 'session' decays (becomes null/invalid) after 5000ms
+temporal session = connect() decay after 5000ms;
+```
+
+### Usage
+Accessing `session` after 5 seconds will result in a null value or trigger a refresh handler (depending on future runtime implementation). This is enforcing ephemeral data lifecycles at the declaration level.

docs/pillars/06_distributed_primitives.md

@@ -0,0 +1,23 @@
+# Pillar 6: Event-Driven Concurrency
+
+## Concept
+Event-Driven Concurrency provides native primitives for building distributed, node-based systems. It introduces `node` and `distributed type` declarations to model concurrent actors and shared data structures without external libraries.
+
+## Syntax
+
+### Node Declaration
+```javascript
+node Server {
+   // Capabilities and internal state
+}
+```
+
+### Distributed Type
+```javascript
+distributed type Ledger {
+    // A data structure shared/replicated across nodes
+}
+```
+
+## Usage
+These constructs lay the groundwork for building distributed systems where concurrency is managed by the language runtime (actor model or similar) rather than manual thread management.

docs/pillars/07_ai_native.md

@@ -0,0 +1,25 @@
+# Pillar 7: AI-Native Integration
+
+## Concept
+AI-Native Integration makes Machine Learning a first-class citizen. Instead of importing external libraries like TensorFlow or PyTorch, ProXPL allows defining models, training loops, and predictions directly in the syntax.
+
+## Syntax
+
+### Model Declaration
+```javascript
+model SentimentAnalysis {
+    // Model architecture and hyperparameters
+}
+```
+
+### Operations
+```javascript
+// Train the model
+train SentimentAnalysis with dataset;
+
+// Make predictions
+let score = predict("This is great") using SentimentAnalysis;
+```
+
+## Usage
+This abstracts the complexity of ML pipelines, allowing the compiler to optimize mathematical operations (tensor math) and hardware usage (GPU offloading) automatically.