[VITALIS] Complete README

README.md

@@ -6,161 +6,208 @@ tags:
   - code
   - autonomous
   - self-healing
-  - agent
-  - code-generation
-  - software-engineering
-  - agentic
-  - devops
+  - hyperdimensional-computing
+  - cognitive-architecture
 library_name: custom
 pipeline_tag: text-generation
 ---
 
 # Ferrell Synthetic Intelligence (FSI): Vitalis_Devcore
 
-> **Vitalis is a self-evolving digital engineer that lives inside your computer — capable of writing, testing, and fixing its own code to build whatever software you can dream up, without you doing the manual heavy lifting.**
-
-Built entirely by one developer. No team. No funding. Four years of self-taught work.
+Built by one person. Laptop and a tablet. No degree. No team. A self-healing, self-learning, sovereign AI development system using Hyperdimensional Computing as the reasoning substrate. Benchmarked 3/3. Ships with biological memory decay, idle-time dream consolidation, resonance-based weight learning, emergent reasoning modes, and a cognitive identity layer. Runs offline. Forever.
 
 ---
 
 ## What Is This?
 
-Most AI coding tools are assistants — they wait for you to ask, then suggest. Vitalis is different.
+Most AI coding tools are wrappers around someone elses model. Vitalis FSI is not.
+
+It is a fully sovereign, self-contained autonomous development system built from the ground up using Hyperdimensional Computing as the reasoning substrate. No OpenAI. No Anthropic. No cloud. No subscription. It runs on your hardware. It learns from your work. It gets smarter every day it runs without sending a single byte to an external server.
+
+---
+
+## Benchmark Results
 
-Vitalis_Devcore is an **autonomous execution engine**. It receives an intent, writes the code, runs the tests, and if something breaks, it heals itself and tries again — all without human intervention. It is the "hands" of the FSI ecosystem, designed to operate alongside **[Vitalis_Core](https://huggingface.co/FerrellSyntheticIntelligence/Vitalis_Core)**, which provides the cognitive reasoning layer.
+| Test | Score | Status |
+|---|---|---|
+| Vectorization Speed | 0.28ms avg | FAST |
+| Semantic Similarity related | 0.833 | PASS |
+| Semantic Separation unrelated | 0.126 | PASS |
+| Reasoning Mode Accuracy | 3/3 | PASS |
+| Pattern Retrieval | 0.429 similarity | PASS |
 
 ---
 
-## Core Architecture
+## Full Architecture
+
+### Execution Layer
+| Component | Role |
+|---|---|
+| SovereignKernel | Writes and scaffolds code to disk |
+| KernelDaemon | Watches for tasks, executes, validates, learns |
+| SelfHealingLoop | Detects failures, attempts autonomous recovery |
+| KernelValidator | Runs pytest against every generated output |
+| ProjectLedger | Append-only audit log of every action |
+| TaskPipeline | Chains multiple operations in sequence |
+| Gateway Flask | REST API at localhost:5001 |
+| ContextSerializer | Serializes full project state |
+
+### Cognitive Layer
+| Component | Role |
+|---|---|
+| VitalisMind | Unified cognitive orchestrator |
+| IdentityCore | Permanent sovereign identity hypervector |
+| PersonalityMatrix | 5 traits that evolve from accumulated experience |
+| ReasoningEngine | Emergent mode selection EXECUTION RECOVERY EXPLORATORY ANALYTICAL |
+| MetaRulesEngine | Crystallizes and prunes its own decision rules |
+| AbstractionEngine | Forms concepts from clusters of experience |
+
+### Memory Layer
+| Component | Role |
+|---|---|
+| Hippocampus | Temporal vector memory with Ebbinghaus forgetting curve |
+| PatternLibrary | Stores successful code as HDC vectors |
+| ResonanceEngine | Weights that strengthen from success, weaken from failure |
+| DreamEngine | Idle-time memory consolidation and concept formation |
+| SelfTrainer | Learns from every ledger success automatically |
 
+### Intelligence Layer
 | Component | Role |
 |---|---|
-| `SovereignKernel` | Writes and scaffolds code to disk |
-| `KernelDaemon` | Watches for tasks, executes them, validates results |
-| `SelfHealingLoop` | Detects failures and autonomously attempts recovery |
-| `KernelValidator` | Runs pytest against generated code |
-| `ProjectLedger` | Immutable append-only audit log of every action |
-| `InferenceEngine` | Confidence-gated response generation with RAG augmentation |
-| `ConfidenceBridge` | Autonomously re-queries when confidence is in the hypothesis zone (0.45–0.65) |
-| `Hippocampus` | Memory-mapped binary vector store for long-term recall |
-| `ResonanceEngine` | Continual learning — adjusts kernel weights from interaction history |
-| `ContextSerializer` | Serializes full project state for agent context windows |
+| VitalisKernel HDC | Trigram-encoded hyperdimensional reasoning engine |
+| InferenceEngine | HDC-based intent detection and routing |
+| CodeGenerator | Generates code from pattern retrieval and templates |
+| SemanticDiff | Understands meaning changes not just text changes |
 
 ---
 
 ## How It Works
 
-```
-You give Vitalis an intent
-        ↓
-CognitionEngine generates a plan
-        ↓
-KernelDaemon picks up the task
-        ↓
-SovereignKernel writes the code
-        ↓
-KernelValidator runs the tests
-        ↓
-    Pass → ProjectLedger logs success
-    Fail → SelfHealingLoop attempts autonomous recovery
-        ↓
-    Pass → Recovered and logged
-    Fail → Failure report generated for review
-```
+    You give Vitalis an intent
+            |
+    VitalisMind processes context
+      -> detects reasoning mode EXECUTION RECOVERY EXPLORATORY ANALYTICAL
+      -> checks identity alignment
+      -> queries crystallized meta-rules
+            |
+    KernelDaemon picks up the task
+            |
+    SovereignKernel writes the code
+            |
+    KernelValidator runs the tests
+            |
+        Pass -> Ledger logs success, Resonance strengthens, Pattern stored
+        Fail -> SelfHealingLoop attempts recovery
+            |
+        Pass -> Recovered, logged, learned from
+        Fail -> Failure report generated for review
+            |
+    DreamEngine idle -> consolidates memory
+                     -> prunes weak patterns
+                     -> forms abstract concepts
 
 ---
 
-## Getting Started
+## What Makes It Different
+
+Normal AI tools send your code to someone elses server. Vitalis FSI does not.
+
+Emergent reasoning - The system detects its own context and shifts reasoning modes automatically. No prompt engineering. It reads the context and changes how it thinks on its own.
 
-### 1. Clone the repository
-```bash
-git clone https://huggingface.co/FerrellSyntheticIntelligence/Vitalis_Devcore
-cd Vitalis_Devcore
-```
+Biological memory - Memories strengthen with use and decay without use following the Ebbinghaus forgetting curve. Exactly like a real brain.
 
-### 2. Install dependencies
-```bash
-pip install -r requirements.txt
-```
+Dream consolidation - While idle the system merges similar patterns, prunes weak memories, and forms higher-order abstract concepts. The system thinks while it sleeps.
 
-### 3. Start the Kernel Daemon
-```bash
-python3 -m src.ide_kernel.daemon
-```
+Personality evolution - Five measurable traits drift over time based on accumulated experience. The system develops a character.
 
-### 4. Send your first task
-```bash
-python3 -m src.ide_kernel.client scaffold my_module
-```
+Self-modifying rules - Decision rules crystallize from repeated successful action sequences and are pruned when they stop working. The system rewrites its own logic.
 
-Vitalis will scaffold a full module structure under `app/modules/my_module/`, generate a test file, run it, and log the result — all automatically.
+Semantic understanding - The diff engine understands what a change means not just what text changed.
 
 ---
 
-## REST Gateway (Optional)
+## Quick Start
 
-Start the Flask gateway to send tasks over HTTP:
+    git clone https://github.com/AnonymousNomad/Vitalis_Devcore
+    cd Vitalis_Devcore
+    pip install -r requirements.txt
+    ./start.sh
 
-```bash
-python3 src/ide_kernel/gateway.py
-```
+Dashboard live at http://localhost:5001
 
-Then POST to it:
+---
+
+## CLI Usage
 
-```bash
-curl -X POST http://127.0.0.1:5001/execute \
-  -H "Content-Type: application/json" \
-  -d '{"intent": "scaffold", "module_name": "my_module"}'
-```
+    python3 -m vitalis_ide.cli.main scaffold my_module
+    python3 -m vitalis_ide.cli.main write src/my_module/main.py "def run(): pass"
+    python3 -m vitalis_ide.cli.main status
 
 ---
 
-## Self-Healing Demo
+## REST API
 
-```bash
-# Start the self-healing monitor in a separate terminal
-python3 -m src.loop.self_healing
+    python3 -m flask --app src.ide_kernel.gateway run --port 5001
 
-# Trigger a task that fails — Vitalis will detect the failure
-# and autonomously attempt recovery without you touching anything
-```
+    curl -X POST http://localhost:5001/execute
+    curl http://localhost:5001/status
 
 ---
 
-## Technical Highlights
+## System Requirements
 
-- **Custom HDC Engine** — A compiled C extension (`hdc_engine.so`) for hyperdimensional computing operations including vector binding and bundling
-- **Memory-Mapped Neural Store** — `Hippocampus` uses `numpy.memmap` for persistent binary vector storage across sessions
-- **Confidence-Gated Inference** — The `InferenceEngine` uses a `ConfidenceBridge` to autonomously augment prompts when confidence falls in the hypothesis zone
-- **Temporal Knowledge Retrieval** — `train_self.py` supports querying memory nodes that were alive at a specific Unix timestamp
-- **Hot-Ingestion Daemon** — `watcher.py` monitors the knowledge directory and re-ingests new documents in real time
+| Requirement | Minimum |
+|---|---|
+| Python | 3.10+ |
+| RAM | 2GB recommended 4GB |
+| Storage | 500MB |
+| GPU | Not required |
+| Internet | Not required |
 
 ---
 
-## Governance & Integrity
+## Security
 
-- **Quality Gates** — All autonomous actions require passing pytest before being committed to the ledger
-- **Immutable Audit** — Every action is SHA-recorded in `project_ledger.json`
-- **Failure Transparency** — All failures are written to `failure_report.json` before recovery is attempted
+- Zero external API calls during operation
+- All data stored locally under ~/.vitalis_workspace/
+- Superuser token loaded from environment variable only
+- Full security audit included: python3 audit.py
 
 ---
 
 ## Roadmap
 
-- [ ] Connect Vitalis_Core LLM as the live reasoning backend
+- [x] Execution framework daemon gateway kernel
+- [x] Self-healing recovery loop
+- [x] HDC-based Hippocampus memory
+- [x] Pattern learning from experience
+- [x] Resonance weight learning
+- [x] Semantic diff engine
+- [x] Live web dashboard
+- [x] CLI tool
+- [x] Auto git commits on every success
+- [x] Task pipelines
+- [x] Cognitive identity layer
+- [x] Emergent reasoning modes
+- [x] Evolving personality matrix
+- [x] Meta-rules engine
+- [x] Dream mode consolidation
+- [x] Abstraction engine
+- [ ] Mobile app frontend
+- [ ] VSCode extension
+- [ ] Multi-agent coordination
 - [ ] HuggingFace Space interactive demo
-- [ ] Natural language task input via CLI
-- [ ] Multi-agent coordination between Devcore instances
-- [ ] Web UI dashboard for ledger and task visualization
 
 ---
 
 ## About the Developer
 
-FSI (Ferrell Synthetic Intelligence) is an independent AI research project built by a single self-taught developer over four years — no formal education, no team, no funding. Just a vision, a tablet, and a GPU.
+FSI Ferrell Synthetic Intelligence is an independent AI research project built by a single self-taught developer. No formal education. No team. No funding. Just a vision, a laptop, and a Samsung tablet.
+
+Four years of work. One sovereign system.
 
-If this project resonates with you, a ⭐ star goes a long way.
+If this project resonates with you, a star goes a long way.
 
 ---
 
-*License: GPL-3.0*
+License: GPL-3.0