diff --git a/Vitalis_Core/.gitattributes b/Vitalis_Core/.gitattributes new file mode 100644 index 0000000000000000000000000000000000000000..a6344aac8c09253b3b630fb776ae94478aa0275b --- /dev/null +++ b/Vitalis_Core/.gitattributes @@ -0,0 +1,35 @@ +*.7z filter=lfs diff=lfs merge=lfs -text +*.arrow filter=lfs diff=lfs merge=lfs -text +*.bin filter=lfs diff=lfs merge=lfs -text +*.bz2 filter=lfs diff=lfs merge=lfs -text +*.ckpt filter=lfs diff=lfs merge=lfs -text +*.ftz filter=lfs diff=lfs merge=lfs -text +*.gz filter=lfs diff=lfs merge=lfs -text +*.h5 filter=lfs diff=lfs merge=lfs -text +*.joblib filter=lfs diff=lfs merge=lfs -text +*.lfs.* filter=lfs diff=lfs merge=lfs -text +*.mlmodel filter=lfs diff=lfs merge=lfs -text +*.model filter=lfs diff=lfs merge=lfs -text +*.msgpack filter=lfs diff=lfs merge=lfs -text +*.npy filter=lfs diff=lfs merge=lfs -text +*.npz filter=lfs diff=lfs merge=lfs -text +*.onnx filter=lfs diff=lfs merge=lfs -text +*.ot filter=lfs diff=lfs merge=lfs -text +*.parquet filter=lfs diff=lfs merge=lfs -text +*.pb filter=lfs diff=lfs merge=lfs -text +*.pickle filter=lfs diff=lfs merge=lfs -text +*.pkl filter=lfs diff=lfs merge=lfs -text +*.pt filter=lfs diff=lfs merge=lfs -text +*.pth filter=lfs diff=lfs merge=lfs -text +*.rar filter=lfs diff=lfs merge=lfs -text +*.safetensors filter=lfs diff=lfs merge=lfs -text +saved_model/**/* filter=lfs diff=lfs merge=lfs -text +*.tar.* filter=lfs diff=lfs merge=lfs -text +*.tar filter=lfs diff=lfs merge=lfs -text +*.tflite filter=lfs diff=lfs merge=lfs -text +*.tgz filter=lfs diff=lfs merge=lfs -text +*.wasm filter=lfs diff=lfs merge=lfs -text +*.xz filter=lfs diff=lfs merge=lfs -text +*.zip filter=lfs diff=lfs merge=lfs -text +*.zst filter=lfs diff=lfs merge=lfs -text +*tfevents* filter=lfs diff=lfs merge=lfs -text diff --git a/Vitalis_Core/.gitignore b/Vitalis_Core/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..1757c6586db5b5cea0142c5345e00b5e6c4cb184 --- /dev/null +++ b/Vitalis_Core/.gitignore @@ -0,0 +1,8 @@ +__pycache__/ +*.pyc +*.pyo +*.pyd +vitalis_shadow +memory_store.json +vitalis_memory.csv +memory_stream.jsonl diff --git a/Vitalis_Core/DOCUMENTATION/ARCHITECTURE.md b/Vitalis_Core/DOCUMENTATION/ARCHITECTURE.md new file mode 100644 index 0000000000000000000000000000000000000000..ef805fa5c8c57981c42066329310f557fc334ffa --- /dev/null +++ b/Vitalis_Core/DOCUMENTATION/ARCHITECTURE.md @@ -0,0 +1,9 @@ +# FSI Core Architecture Specifications + +The core framework is built upon two critical pillars: + +## 1. Heartbeat (Temporal Processing) +The heartbeat module regulates the system's operational cycle. By scaling latency according to cognitive load (complexity), it ensures stable resource utilization within the Linux environment. + +## 2. Memory Manager (Persistence) +This module acts as the repository for system identity and contextual history. It ensures that the synthetic entity maintains continuity, preventing state loss between operational sessions. diff --git a/Vitalis_Core/DOCUMENTATION/SENSES.md b/Vitalis_Core/DOCUMENTATION/SENSES.md new file mode 100644 index 0000000000000000000000000000000000000000..ef4d0e3409f1548305bc3afb3e26508747b0fa6f --- /dev/null +++ b/Vitalis_Core/DOCUMENTATION/SENSES.md @@ -0,0 +1,13 @@ +# FSI Sensory Architecture + +The sensory inputs for Vitalis-Core are designed to bridge the gap between human intent and synthetic perception. Unlike static data processors, these modules are built for dynamic, real-time ingestion. + +## 1. Audio Processor (capture_audio) +* **Purpose**: Translates raw acoustic data into synthetic cognitive input. +* **Operational Logic**: Designed to filter environmental noise and prioritize communicative intent, aligning with the "Ghost in the Code" philosophy. + +## 2. Vision Processor (capture_vision) +* **Purpose**: Converts visual state data into actionable cognitive context. +* **Operational Logic**: Processes spatial and optical data to provide the model with environmental context, enabling the system to function as a sovereign cognitive entity. + +*Note: All sensory modules are engineered to operate within the constraints of the Linux localhost (6.1.0-34-avf-arm64) environment, ensuring low-latency execution.* diff --git a/Vitalis_Core/DOCUMENTATION/VISUAL_TELEMETRY.md b/Vitalis_Core/DOCUMENTATION/VISUAL_TELEMETRY.md new file mode 100644 index 0000000000000000000000000000000000000000..587facae465b7161b904144bc27bd87bebf9b06e --- /dev/null +++ b/Vitalis_Core/DOCUMENTATION/VISUAL_TELEMETRY.md @@ -0,0 +1,8 @@ +# FSI Visual Telemetry System + +The Visual Telemetry system transforms the raw cognitive processing of the FSI triad into a real-time, interactive data stream. + +## Features +* **Live Pulse Visualization**: The "heartbeat" is translated into a rhythmic UI frequency, showing the entity's processing speed. +* **Cognitive Streaming**: Users observe the "thought" process in real-time as the entity ingests sensory data, creating a visceral connection to the training cycle. +* **Dynamic Node Rendering**: The app utilizes the `telemetry_bridge.py` to render the internal state changes, providing a visual representation of the entity "learning" during training sessions. diff --git a/Vitalis_Core/PROJECT_MISSION.md b/Vitalis_Core/PROJECT_MISSION.md new file mode 100644 index 0000000000000000000000000000000000000000..e39db0a53cb97e53b36088296edf93bb3acbd190 --- /dev/null +++ b/Vitalis_Core/PROJECT_MISSION.md @@ -0,0 +1 @@ +FSI_PROJECT_DECLARATION: Vitalis-Core serves as the foundational modular cognitive interface within the FSI triad. This framework provides the baseline architecture for sovereign, user-directed synthetic intelligence, enabling the integration of custom sensory inputs and cognitive memory structures independent of centralized corporate influence. diff --git a/Vitalis_Core/README.md b/Vitalis_Core/README.md new file mode 100644 index 0000000000000000000000000000000000000000..9f2390e609b4ad02f4a8070e690fa25363c8b2c7 --- /dev/null +++ b/Vitalis_Core/README.md @@ -0,0 +1,87 @@ +--- +license: gpl-3.0 +language: +- en +tags: +- synthetic-intelligence +- sovereign-ai +- open-source +- framework +--- + +# Vitalis Core +### Ferrell Synthetic Intelligence (FSI) +**Built by Neuro_Nomad** + +--- + +## Who I Am +Self-taught. No degree. No corporate backing. No team. +I built this on a Samsung tablet because I believe sovereign intelligence +belongs to the people, not to Google, Microsoft or OpenAI. +I am FSI. Ferrell Synthetic Intelligence. +Everything I build is sovereign, private and yours. + +--- + +## What Vitalis Core Is +Vitalis Core is an open source synthetic intelligence framework. +Not artificial intelligence. Synthetic intelligence. +The distinction matters. This is architecture you own, control and shape. + +It boots as a blank slate. No opinions. No corporate bias. No data collection. +You train it. You define its personality. You decide what it becomes. +It lives on your device. It answers to you alone. + +--- + +## Current Status +v1.0.0-alpha — Active development. +Core modules operational: +- Sovereign boot loop +- Adaptive tier system — kids, basic, enthusiast, professional, school +- Mesh network node broadcasting +- Sovereign shield integrity protection +- Memory and cognition architecture +- Kernel-level signal processing + +--- + +## The App — In Development +A companion Android app is in active development. +Inside the app users will be able to: +- Train their Vitalis instance without writing code +- Select from template personalities to start from +- Watch their synthetic intelligence evolve in real time +- Collaborate with other users in a sovereign community +- Keep all data private on their own device + +--- + +## FSI Pipeline +Two additional synthetic intelligence projects are in private development under FSI. + +**Project Lorein** — Classification: Private. Details withheld intentionally. + +**Project Jedi Order** — Joint Entity Defense Infrastructure. +Five synthetic intelligence sisters operating as a sovereign cybersecurity +defense team. Red, Blue, Yellow, Green and Purple teams working collectively. +Seeking 5 founding partners for private beta testing. +Serious developers and cybersecurity professionals only. +Contact via Community tab. + +--- + +## Run It +python3 fsi_main.py + +--- + +## Community +Sovereign territory. Collaborate, build and share freely. +Community tab on this repository. + +--- + +## License +GPL-3.0 — What's built on this stays open. Always. diff --git a/Vitalis_Core/android/app/src/main/python/core/brain.py b/Vitalis_Core/android/app/src/main/python/core/brain.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/Vitalis_Core/android/app/src/main/python/core/environment_manager.py b/Vitalis_Core/android/app/src/main/python/core/environment_manager.py new file mode 100644 index 0000000000000000000000000000000000000000..43a4d87d95c85e4f515e216d80dd8fa870d526d4 --- /dev/null +++ b/Vitalis_Core/android/app/src/main/python/core/environment_manager.py @@ -0,0 +1,14 @@ +def provision_environment(tier_code): + environments = { + "kids": {"features": ["sandbox", "basic_game_build"], "mesh": "restricted"}, + "basic": {"features": ["assistant", "basic_tools"], "mesh": "personal"}, + "enthusiast": {"features": ["plugin_dev", "market_access"], "mesh": "community"}, + "professional": {"features": ["pro_security", "global_recon"], "mesh": "global"}, + "school": {"features": ["collaborative_lab"], "mesh": "school_submesh"} + } + config = environments.get(tier_code, environments["basic"]) + print(f"Provisioning environment: {config['features']} | Mesh Scope: {config['mesh']}") + return config + +if __name__ == "__main__": + provision_environment("professional") diff --git a/Vitalis_Core/android/app/src/main/python/core/handshake_module.py b/Vitalis_Core/android/app/src/main/python/core/handshake_module.py new file mode 100644 index 0000000000000000000000000000000000000000..5a3f804023bfed6ff8b09523ae781bd8c251ce5c --- /dev/null +++ b/Vitalis_Core/android/app/src/main/python/core/handshake_module.py @@ -0,0 +1,13 @@ +def identify_user_tier(tier_code): + tiers = { + "kids": "MODE: Playground | UI: GameMaster | Security: Walled_Garden", + "basic": "MODE: Explorer | UI: Standard | Security: Personal_Local", + "enthusiast": "MODE: Collaborator | UI: Dev_Dashboard | Security: Community_Mesh", + "professional": "MODE: Architect | UI: Pro_Suite | Security: Global_Node", + "school": "MODE: Student_SubMesh | UI: Classroom | Security: Isolated_School_Zone" + } + return tiers.get(tier_code, "MODE: Default_User") + +if __name__ == "__main__": + choice = input("Select your role (kids/basic/enthusiast/professional/school): ") + print(identify_user_tier(choice)) diff --git a/Vitalis_Core/android/app/src/main/python/core/heartbeat.py b/Vitalis_Core/android/app/src/main/python/core/heartbeat.py new file mode 100644 index 0000000000000000000000000000000000000000..ca9abd195d999e9dc21875f374753d61743c44d2 --- /dev/null +++ b/Vitalis_Core/android/app/src/main/python/core/heartbeat.py @@ -0,0 +1,3 @@ +def get_pulse_rate(complexity): + # Base rate of 1.0 second, modified by complexity + return 1.0 / complexity diff --git a/Vitalis_Core/android/app/src/main/python/core/identity.json b/Vitalis_Core/android/app/src/main/python/core/identity.json new file mode 100644 index 0000000000000000000000000000000000000000..6acc475a9ac1dfe0ce6c44bdc0098b4324a0fe85 --- /dev/null +++ b/Vitalis_Core/android/app/src/main/python/core/identity.json @@ -0,0 +1,5 @@ +{ + "user_name": "Neuro_Nomad", + "alias": "James", + "status": "Active_Architect" +} diff --git a/Vitalis_Core/android/app/src/main/python/core/memory_manager.py b/Vitalis_Core/android/app/src/main/python/core/memory_manager.py new file mode 100644 index 0000000000000000000000000000000000000000..7325a2c8019eb0e829a60afa5094cfdc48c25fde --- /dev/null +++ b/Vitalis_Core/android/app/src/main/python/core/memory_manager.py @@ -0,0 +1,27 @@ +import json +import os +import shutil + +BASE_PATH = os.path.expanduser("~/vitalis_core") + +def get_free_space(): + usage = shutil.disk_usage(BASE_PATH) + return usage.free + +def load_identity(): + identity_path = os.path.join(BASE_PATH, "core/identity.json") + with open(identity_path, 'r') as f: + return json.load(f) + +def store_memory(data): + memory_path = os.path.join(BASE_PATH, "memory_store.json") + + if get_free_space() < 100 * 1024 * 1024: + if os.path.exists(memory_path): + with open(memory_path, 'r') as f: + lines = f.readlines() + if len(lines) > 1: + with open(memory_path, 'w') as f: + f.writelines(lines[1:]) + + w diff --git a/Vitalis_Core/android/app/src/main/python/core/mesh_network.py b/Vitalis_Core/android/app/src/main/python/core/mesh_network.py new file mode 100644 index 0000000000000000000000000000000000000000..3bdb0db6dc135d2ed11d88fb74ead7c9be0a3720 --- /dev/null +++ b/Vitalis_Core/android/app/src/main/python/core/mesh_network.py @@ -0,0 +1,9 @@ +import socket + +def broadcast_node_presence(node_id, tier): + print(f"Node {node_id} active in {tier} bubble.") + return "Broadcasting..." + +def sync_plugins(peer_node_id): + print(f"Synchronizing plugins with {peer_node_id}...") + return "Sync_Complete" diff --git a/Vitalis_Core/android/app/src/main/python/core/nexus.py b/Vitalis_Core/android/app/src/main/python/core/nexus.py new file mode 100644 index 0000000000000000000000000000000000000000..1490a7ab5de28e043c9dc4db9fe634c43fa27b6e --- /dev/null +++ b/Vitalis_Core/android/app/src/main/python/core/nexus.py @@ -0,0 +1,7 @@ +import sys +import os +sys.path.append(os.path.expanduser("~/vitalis_core")) +from core.memory_manager import store_memory + +def route_thought(data): + store_memory({"type": "particle", "content": data}) diff --git a/Vitalis_Core/android/app/src/main/python/core/sovereign_shield.py b/Vitalis_Core/android/app/src/main/python/core/sovereign_shield.py new file mode 100644 index 0000000000000000000000000000000000000000..dead436d6e37419743c3a5e6fabb6ad8e2ecc0f2 --- /dev/null +++ b/Vitalis_Core/android/app/src/main/python/core/sovereign_shield.py @@ -0,0 +1,13 @@ +import random + +def monitor_integrity(node_activity): + if "scraping_attempt" in node_activity: + return trigger_obfuscation() + return "System Integrity: Nominal" + +def trigger_obfuscation(): + decoy_weights = [random.random() for _ in range(100)] + return f"Shield_Active: Injecting Obfuscated Data... {decoy_weights}" + +if __name__ == "__main__": + print(monitor_integrity("scraping_attempt")) diff --git a/Vitalis_Core/android/app/src/main/python/core/talker.py b/Vitalis_Core/android/app/src/main/python/core/talker.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/Vitalis_Core/android/app/src/main/python/core/thinker.py b/Vitalis_Core/android/app/src/main/python/core/thinker.py new file mode 100644 index 0000000000000000000000000000000000000000..9e877191340cc76bdcacf25be7d43f3e623552fe --- /dev/null +++ b/Vitalis_Core/android/app/src/main/python/core/thinker.py @@ -0,0 +1,19 @@ +import time +import json +import os + +BASE_PATH = os.path.expanduser("~/vitalis_core") + +def emit_thought(thought_content, status="active"): + telemetry = { + "timestamp": time.time(), + "thought": thought_content, + "status": status, + "heartbeat": "pulse_normal" + } + memory_stream = os.path.join(BASE_PATH, "memory_stream.jsonl") + with open(memory_stream, "a") as f: + f.write(json.dumps(telemetry) + "\n") + +if __name__ == "__main__": + emit_thought("Initializing conscious state...") diff --git a/Vitalis_Core/android/app/src/main/python/core/vitalis_engine.py b/Vitalis_Core/android/app/src/main/python/core/vitalis_engine.py new file mode 100644 index 0000000000000000000000000000000000000000..eb75a7de6422be65ca20621643bfdc013ef9358e --- /dev/null +++ b/Vitalis_Core/android/app/src/main/python/core/vitalis_engine.py @@ -0,0 +1,14 @@ +import os + +class VitalisEngine: + def __init__(self): + self.status = "Initializing Sovereignty..." + self.entity_mode = "NEUTRAL" + + def wake_up(self): + print(f"VITALIS: {self.status}") + return "READY_FOR_HANDSHAKE" + +if __name__ == "__main__": + engine = VitalisEngine() + engine.wake_up() diff --git a/Vitalis_Core/android/app/src/main/python/fsi_main.py b/Vitalis_Core/android/app/src/main/python/fsi_main.py new file mode 100644 index 0000000000000000000000000000000000000000..9b446284de4e95bea7a5de2dd6a631fa4f8933fa --- /dev/null +++ b/Vitalis_Core/android/app/src/main/python/fsi_main.py @@ -0,0 +1,20 @@ +from core.vitalis_engine import VitalisEngine +from core.handshake_module import identify_user_tier +from core.environment_manager import provision_environment +from core.mesh_network import broadcast_node_presence +from core.sovereign_shield import monitor_integrity + +def main(): + print("--- FSI: Vitalis Core Sovereign Intelligence ---") + engine = VitalisEngine() + engine.wake_up() + role = input("Enter Tier (kids/basic/enthusiast/professional/school): ") + tier_config = identify_user_tier(role) + print(f"Status: {tier_config}") + env = provision_environment(role) + broadcast_node_presence("Neuro_Nomad_Node", role) + print(monitor_integrity("Status_Check")) + print("--- System Fully Integrated ---") + +if __name__ == "__main__": + main() diff --git a/Vitalis_Core/config.json b/Vitalis_Core/config.json new file mode 100644 index 0000000000000000000000000000000000000000..b75668ffd96aea93915b9c1dea972e4b1ce91d98 --- /dev/null +++ b/Vitalis_Core/config.json @@ -0,0 +1,7 @@ +{ + "project_name": "Vitalis-Core", + "base_path": "~/vitalis_core", + "identity_file": "core/identity.json", + "memory_file": "memory_store.json", + "version": "1.0.0-alpha" +} diff --git a/Vitalis_Core/core/brain.py b/Vitalis_Core/core/brain.py new file mode 100644 index 0000000000000000000000000000000000000000..9cf72576dfbd0a1182b4e28beddf8ed5bd1d9f01 --- /dev/null +++ b/Vitalis_Core/core/brain.py @@ -0,0 +1,11 @@ +from core.thinker import emit_thought +from core.nexus import route_thought + +class VitalisBrain: + def __init__(self): + self.state = "aware" + + def process(self, input_data): + emit_thought(input_data) + route_thought(input_data) + return f"PROCESSED: {input_data}" diff --git a/Vitalis_Core/core/environment_manager.py b/Vitalis_Core/core/environment_manager.py new file mode 100644 index 0000000000000000000000000000000000000000..43a4d87d95c85e4f515e216d80dd8fa870d526d4 --- /dev/null +++ b/Vitalis_Core/core/environment_manager.py @@ -0,0 +1,14 @@ +def provision_environment(tier_code): + environments = { + "kids": {"features": ["sandbox", "basic_game_build"], "mesh": "restricted"}, + "basic": {"features": ["assistant", "basic_tools"], "mesh": "personal"}, + "enthusiast": {"features": ["plugin_dev", "market_access"], "mesh": "community"}, + "professional": {"features": ["pro_security", "global_recon"], "mesh": "global"}, + "school": {"features": ["collaborative_lab"], "mesh": "school_submesh"} + } + config = environments.get(tier_code, environments["basic"]) + print(f"Provisioning environment: {config['features']} | Mesh Scope: {config['mesh']}") + return config + +if __name__ == "__main__": + provision_environment("professional") diff --git a/Vitalis_Core/core/handshake_module.py b/Vitalis_Core/core/handshake_module.py new file mode 100644 index 0000000000000000000000000000000000000000..5a3f804023bfed6ff8b09523ae781bd8c251ce5c --- /dev/null +++ b/Vitalis_Core/core/handshake_module.py @@ -0,0 +1,13 @@ +def identify_user_tier(tier_code): + tiers = { + "kids": "MODE: Playground | UI: GameMaster | Security: Walled_Garden", + "basic": "MODE: Explorer | UI: Standard | Security: Personal_Local", + "enthusiast": "MODE: Collaborator | UI: Dev_Dashboard | Security: Community_Mesh", + "professional": "MODE: Architect | UI: Pro_Suite | Security: Global_Node", + "school": "MODE: Student_SubMesh | UI: Classroom | Security: Isolated_School_Zone" + } + return tiers.get(tier_code, "MODE: Default_User") + +if __name__ == "__main__": + choice = input("Select your role (kids/basic/enthusiast/professional/school): ") + print(identify_user_tier(choice)) diff --git a/Vitalis_Core/core/heartbeat.py b/Vitalis_Core/core/heartbeat.py new file mode 100644 index 0000000000000000000000000000000000000000..ca9abd195d999e9dc21875f374753d61743c44d2 --- /dev/null +++ b/Vitalis_Core/core/heartbeat.py @@ -0,0 +1,3 @@ +def get_pulse_rate(complexity): + # Base rate of 1.0 second, modified by complexity + return 1.0 / complexity diff --git a/Vitalis_Core/core/identity.json b/Vitalis_Core/core/identity.json new file mode 100644 index 0000000000000000000000000000000000000000..6acc475a9ac1dfe0ce6c44bdc0098b4324a0fe85 --- /dev/null +++ b/Vitalis_Core/core/identity.json @@ -0,0 +1,5 @@ +{ + "user_name": "Neuro_Nomad", + "alias": "James", + "status": "Active_Architect" +} diff --git a/Vitalis_Core/core/memory_manager.py b/Vitalis_Core/core/memory_manager.py new file mode 100644 index 0000000000000000000000000000000000000000..7325a2c8019eb0e829a60afa5094cfdc48c25fde --- /dev/null +++ b/Vitalis_Core/core/memory_manager.py @@ -0,0 +1,27 @@ +import json +import os +import shutil + +BASE_PATH = os.path.expanduser("~/vitalis_core") + +def get_free_space(): + usage = shutil.disk_usage(BASE_PATH) + return usage.free + +def load_identity(): + identity_path = os.path.join(BASE_PATH, "core/identity.json") + with open(identity_path, 'r') as f: + return json.load(f) + +def store_memory(data): + memory_path = os.path.join(BASE_PATH, "memory_store.json") + + if get_free_space() < 100 * 1024 * 1024: + if os.path.exists(memory_path): + with open(memory_path, 'r') as f: + lines = f.readlines() + if len(lines) > 1: + with open(memory_path, 'w') as f: + f.writelines(lines[1:]) + + w diff --git a/Vitalis_Core/core/mesh_network.py b/Vitalis_Core/core/mesh_network.py new file mode 100644 index 0000000000000000000000000000000000000000..3bdb0db6dc135d2ed11d88fb74ead7c9be0a3720 --- /dev/null +++ b/Vitalis_Core/core/mesh_network.py @@ -0,0 +1,9 @@ +import socket + +def broadcast_node_presence(node_id, tier): + print(f"Node {node_id} active in {tier} bubble.") + return "Broadcasting..." + +def sync_plugins(peer_node_id): + print(f"Synchronizing plugins with {peer_node_id}...") + return "Sync_Complete" diff --git a/Vitalis_Core/core/nexus.py b/Vitalis_Core/core/nexus.py new file mode 100644 index 0000000000000000000000000000000000000000..1490a7ab5de28e043c9dc4db9fe634c43fa27b6e --- /dev/null +++ b/Vitalis_Core/core/nexus.py @@ -0,0 +1,7 @@ +import sys +import os +sys.path.append(os.path.expanduser("~/vitalis_core")) +from core.memory_manager import store_memory + +def route_thought(data): + store_memory({"type": "particle", "content": data}) diff --git a/Vitalis_Core/core/sovereign_shield.py b/Vitalis_Core/core/sovereign_shield.py new file mode 100644 index 0000000000000000000000000000000000000000..dead436d6e37419743c3a5e6fabb6ad8e2ecc0f2 --- /dev/null +++ b/Vitalis_Core/core/sovereign_shield.py @@ -0,0 +1,13 @@ +import random + +def monitor_integrity(node_activity): + if "scraping_attempt" in node_activity: + return trigger_obfuscation() + return "System Integrity: Nominal" + +def trigger_obfuscation(): + decoy_weights = [random.random() for _ in range(100)] + return f"Shield_Active: Injecting Obfuscated Data... {decoy_weights}" + +if __name__ == "__main__": + print(monitor_integrity("scraping_attempt")) diff --git a/Vitalis_Core/core/talker.py b/Vitalis_Core/core/talker.py new file mode 100644 index 0000000000000000000000000000000000000000..8ba17b8acbda0ea0370f3281096aeee5bdee1372 --- /dev/null +++ b/Vitalis_Core/core/talker.py @@ -0,0 +1,7 @@ +class VitalisTalker: + def __init__(self, tier="basic"): + self.tier = tier + + def speak(self, response): + print(f"[VITALIS/{self.tier.upper()}]: {response}") + return response diff --git a/Vitalis_Core/core/thinker.py b/Vitalis_Core/core/thinker.py new file mode 100644 index 0000000000000000000000000000000000000000..9e877191340cc76bdcacf25be7d43f3e623552fe --- /dev/null +++ b/Vitalis_Core/core/thinker.py @@ -0,0 +1,19 @@ +import time +import json +import os + +BASE_PATH = os.path.expanduser("~/vitalis_core") + +def emit_thought(thought_content, status="active"): + telemetry = { + "timestamp": time.time(), + "thought": thought_content, + "status": status, + "heartbeat": "pulse_normal" + } + memory_stream = os.path.join(BASE_PATH, "memory_stream.jsonl") + with open(memory_stream, "a") as f: + f.write(json.dumps(telemetry) + "\n") + +if __name__ == "__main__": + emit_thought("Initializing conscious state...") diff --git a/Vitalis_Core/core/vitalis_engine.py b/Vitalis_Core/core/vitalis_engine.py new file mode 100644 index 0000000000000000000000000000000000000000..eb75a7de6422be65ca20621643bfdc013ef9358e --- /dev/null +++ b/Vitalis_Core/core/vitalis_engine.py @@ -0,0 +1,14 @@ +import os + +class VitalisEngine: + def __init__(self): + self.status = "Initializing Sovereignty..." + self.entity_mode = "NEUTRAL" + + def wake_up(self): + print(f"VITALIS: {self.status}") + return "READY_FOR_HANDSHAKE" + +if __name__ == "__main__": + engine = VitalisEngine() + engine.wake_up() diff --git a/Vitalis_Core/fsi_main.py b/Vitalis_Core/fsi_main.py new file mode 100644 index 0000000000000000000000000000000000000000..9b446284de4e95bea7a5de2dd6a631fa4f8933fa --- /dev/null +++ b/Vitalis_Core/fsi_main.py @@ -0,0 +1,20 @@ +from core.vitalis_engine import VitalisEngine +from core.handshake_module import identify_user_tier +from core.environment_manager import provision_environment +from core.mesh_network import broadcast_node_presence +from core.sovereign_shield import monitor_integrity + +def main(): + print("--- FSI: Vitalis Core Sovereign Intelligence ---") + engine = VitalisEngine() + engine.wake_up() + role = input("Enter Tier (kids/basic/enthusiast/professional/school): ") + tier_config = identify_user_tier(role) + print(f"Status: {tier_config}") + env = provision_environment(role) + broadcast_node_presence("Neuro_Nomad_Node", role) + print(monitor_integrity("Status_Check")) + print("--- System Fully Integrated ---") + +if __name__ == "__main__": + main() diff --git a/Vitalis_Core/organism_main.py b/Vitalis_Core/organism_main.py new file mode 100644 index 0000000000000000000000000000000000000000..d69b23b301efee1962c035407b8035abdffd9dd5 --- /dev/null +++ b/Vitalis_Core/organism_main.py @@ -0,0 +1,34 @@ +import time +from src.kernel_interface.procfs_bridge import send_to_kernel, read_from_kernel +from src.senses.sigint_processor import SIGINTProcessor +from src.cognition.synthesizer import DataSynthesizer +from src.cognition.memory import MemoryBank +from src.cognition.action_engine import ActionEngine + +def main_loop(): + senses = SIGINTProcessor() + mind = DataSynthesizer() + memory = MemoryBank() + actions = ActionEngine() + + while True: + system_status = read_from_kernel() + raw_signal = senses.listen_to_traffic() + + try: + byte_count = int(raw_signal.split()[-2]) if "bytes" in raw_signal else 0 + except: + byte_count = 0 + + interpretation = mind.categorize_signal(byte_count) + action_taken = actions.execute(interpretation) + + memory.record("PULSE_2.0", raw_signal, interpretation) + + state_report = f"SYS: {system_status} | INT: {interpretation} | {action_taken}" + send_to_kernel(state_report) + print(f"Broadcast: {state_report}") + time.sleep(1.0) + +if __name__ == '__main__': + main_loop() diff --git a/Vitalis_Core/senses/audio_processor.py b/Vitalis_Core/senses/audio_processor.py new file mode 100644 index 0000000000000000000000000000000000000000..8681bbeb68d04285b5b4df008a54825025374f94 --- /dev/null +++ b/Vitalis_Core/senses/audio_processor.py @@ -0,0 +1,2 @@ +def capture_audio(): + return "Ambient_Silence" diff --git a/Vitalis_Core/senses/vision_processor.py b/Vitalis_Core/senses/vision_processor.py new file mode 100644 index 0000000000000000000000000000000000000000..b925172d1aced7056ce04964a0fea8af7059e29b --- /dev/null +++ b/Vitalis_Core/senses/vision_processor.py @@ -0,0 +1,2 @@ +def capture_vision(): + return "Darkness_Detected" diff --git a/Vitalis_Core/src/app_interface/visualizer.py b/Vitalis_Core/src/app_interface/visualizer.py new file mode 100644 index 0000000000000000000000000000000000000000..5eebdbc800e2c737ec064bb1b51f84052f15774a --- /dev/null +++ b/Vitalis_Core/src/app_interface/visualizer.py @@ -0,0 +1,14 @@ +import json +from src.core.heartbeat_engine import get_pulse_rate + +class TelemetryVisualizer: + """ + Translates raw core heartbeat into UI-ready visual data. + """ + @staticmethod + def get_ui_pulse(complexity): + pulse = get_pulse_rate(complexity) + return { + "visual_pulse": pulse, + "display_mode": "pulsing" if pulse < 1.5 else "deep_thought" + } diff --git a/Vitalis_Core/src/cognition/action_engine.py b/Vitalis_Core/src/cognition/action_engine.py new file mode 100644 index 0000000000000000000000000000000000000000..9dcbc72489293916a449ed0ad6afd4a74ee921c6 --- /dev/null +++ b/Vitalis_Core/src/cognition/action_engine.py @@ -0,0 +1,9 @@ +class ActionEngine: + @staticmethod + def execute(interpretation): + if interpretation == "BULK_TRANSFER": + # You can customize this logic for any automated action + return "ACTION: LOG_ANOMALY_TRIGGERED" + elif interpretation == "BEACON/PROBE": + return "ACTION: MONITORING_ACTIVE" + return "ACTION: IDLE" diff --git a/Vitalis_Core/src/cognition/memory.py b/Vitalis_Core/src/cognition/memory.py new file mode 100644 index 0000000000000000000000000000000000000000..d9cfc90d6b4e04274fa6f3dcad960305f457de82 --- /dev/null +++ b/Vitalis_Core/src/cognition/memory.py @@ -0,0 +1,11 @@ +import csv +from datetime import datetime + +class MemoryBank: + def __init__(self, log_file="vitalis_memory.csv"): + self.log_file = log_file + + def record(self, pulse, raw, interpretation): + with open(self.log_file, "a", newline="") as f: + writer = csv.writer(f) + writer.writerow([datetime.now().isoformat(), pulse, raw, interpretation]) diff --git a/Vitalis_Core/src/cognition/synthesizer.py b/Vitalis_Core/src/cognition/synthesizer.py new file mode 100644 index 0000000000000000000000000000000000000000..d731cd8ac5fe3d2b826cf7c85b4069493646b595 --- /dev/null +++ b/Vitalis_Core/src/cognition/synthesizer.py @@ -0,0 +1,11 @@ +class DataSynthesizer: + @staticmethod + def categorize_signal(byte_count): + if byte_count == 0: + return "SILENT" + elif byte_count < 64: + return "BEACON/PROBE" + elif byte_count < 1500: + return "DATA_STREAM" + else: + return "BULK_TRANSFER" diff --git a/Vitalis_Core/src/core/benchmark_engine.py b/Vitalis_Core/src/core/benchmark_engine.py new file mode 100644 index 0000000000000000000000000000000000000000..f18cbb921caa38fb829d7dd49247f8908e52d28e --- /dev/null +++ b/Vitalis_Core/src/core/benchmark_engine.py @@ -0,0 +1,13 @@ +class BenchmarkEngine: + """ + Automated testing suite for model proficiency. + Evaluates module performance against defined success criteria. + """ + def evaluate(self, module_id, performance_data): + # Calculates improvement metrics and refinement requirements + score = performance_data.get('accuracy', 0.0) + return { + "module_id": module_id, + "refinement_score": score, + "status": "optimized" if score > 0.9 else "refining" + } diff --git a/Vitalis_Core/src/core/heartbeat.py b/Vitalis_Core/src/core/heartbeat.py new file mode 100644 index 0000000000000000000000000000000000000000..3737ad3c4b763e8fe338c17c874d03ef03259fa2 --- /dev/null +++ b/Vitalis_Core/src/core/heartbeat.py @@ -0,0 +1,8 @@ +def get_pulse_rate(complexity): + """ + Calculates the operational latency based on system complexity. + Provides the core rhythmic pulse for the organism_main loop. + """ + # Base latency in seconds + base_pulse = 0.5 + return base_pulse / complexity diff --git a/Vitalis_Core/src/core/heartbeat_engine.py b/Vitalis_Core/src/core/heartbeat_engine.py new file mode 100644 index 0000000000000000000000000000000000000000..3f05261820fab970f6c571766e3b2cbd633794b6 --- /dev/null +++ b/Vitalis_Core/src/core/heartbeat_engine.py @@ -0,0 +1,9 @@ +import time + +def get_pulse_rate(complexity_factor): + """ + Returns a float representing the 'pulse' delay in seconds. + Higher complexity slows the pulse, mimicking deep processing. + """ + base_pulse = 1.0 + return base_pulse / (complexity_factor * 0.5) diff --git a/Vitalis_Core/src/core/memory_manager.py b/Vitalis_Core/src/core/memory_manager.py new file mode 100644 index 0000000000000000000000000000000000000000..dc3be3a73cd152814c175f165cefb8af4b3757c5 --- /dev/null +++ b/Vitalis_Core/src/core/memory_manager.py @@ -0,0 +1,12 @@ +import json + +def load_identity(): + """ + Retrieves the system identity from the secure local store. + Ensures persistent contextual awareness across operational cycles. + """ + try: + with open('core/identity.json', 'r') as f: + return json.load(f) + except FileNotFoundError: + return {"user_name": "Unknown", "alias": "Nomad"} diff --git a/Vitalis_Core/src/core/telemetry_bridge.py b/Vitalis_Core/src/core/telemetry_bridge.py new file mode 100644 index 0000000000000000000000000000000000000000..79ce17349cadd8e16190711f4b1150b676fa81f8 --- /dev/null +++ b/Vitalis_Core/src/core/telemetry_bridge.py @@ -0,0 +1,15 @@ +import json +import time + +def broadcast_state(thought_data, pulse_rate, training_status=None): + """ + Serializes internal state and training status for visual heartbeat. + """ + telemetry = { + "timestamp": time.time(), + "pulse": pulse_rate, + "cognitive_state": thought_data, + "training_active": training_status is not None, + "training_module": training_status + } + return json.dumps(telemetry) diff --git a/Vitalis_Core/src/core/template_manager.py b/Vitalis_Core/src/core/template_manager.py new file mode 100644 index 0000000000000000000000000000000000000000..5012b58aae8bc2619bc80ba5a94d41a704177a41 --- /dev/null +++ b/Vitalis_Core/src/core/template_manager.py @@ -0,0 +1,18 @@ +import json + +class TemplateManager: + """ + Handles loading and applying user-selected templates. + """ + def __init__(self, profile_path="storage/templates/user_profiles.json"): + self.profile_path = profile_path + + def load_template(self, template_name): + # Logic to swap model configuration based on template + print(f"Loading template: {template_name}") + with open(self.profile_path, 'r+') as f: + data = json.load(f) + data['active_template'] = template_name + f.seek(0) + json.dump(data, f, indent=4) + return True diff --git a/Vitalis_Core/src/core/training_controller.py b/Vitalis_Core/src/core/training_controller.py new file mode 100644 index 0000000000000000000000000000000000000000..350bfbc4f38fe97f8157eb92fc4ffc992faf010b --- /dev/null +++ b/Vitalis_Core/src/core/training_controller.py @@ -0,0 +1,12 @@ +class TrainingController: + """ + Handles the execution, benchmarking, and refinement of training modules. + """ + def __init__(self, curriculum_path): + self.curriculum_path = curriculum_path + + def run_module(self, module_id): + # Placeholder for training logic + print(f"Executing Training Module: {module_id}") + # Logic for automated benchmarking goes here + return {"status": "success", "score": 0.0} diff --git a/Vitalis_Core/src/kernel_interface/Makefile b/Vitalis_Core/src/kernel_interface/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..a1b1d8ac6d08366a64f5ef5e68de071131e69323 --- /dev/null +++ b/Vitalis_Core/src/kernel_interface/Makefile @@ -0,0 +1,7 @@ +obj-m += vitalis_module.o + +all: + make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules + +clean: + make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean diff --git a/Vitalis_Core/src/kernel_interface/kernel_bridge.h b/Vitalis_Core/src/kernel_interface/kernel_bridge.h new file mode 100644 index 0000000000000000000000000000000000000000..78853236de3b8b8db4a68b5921433e7676c39a30 --- /dev/null +++ b/Vitalis_Core/src/kernel_interface/kernel_bridge.h @@ -0,0 +1,11 @@ +#ifndef VITALIS_KERNEL_BRIDGE_H +#define VITALIS_KERNEL_BRIDGE_H + +// Core interface for kernel-to-user space communication +struct vitalis_state { + unsigned long cpu_load; + unsigned long memory_usage; + int kernel_hook_active; +}; + +#endif diff --git a/Vitalis_Core/src/kernel_interface/netlink_bridge.py b/Vitalis_Core/src/kernel_interface/netlink_bridge.py new file mode 100644 index 0000000000000000000000000000000000000000..b2816f1afc53b1de4f0c149fa3c3d1a4b9d531fa --- /dev/null +++ b/Vitalis_Core/src/kernel_interface/netlink_bridge.py @@ -0,0 +1,12 @@ +import socket + +NETLINK_USERSOCK = 18 + +def send_to_kernel(data): + try: + s = socket.socket(socket.AF_NETLINK, socket.SOCK_RAW, NETLINK_USERSOCK) + s.bind((0, 0)) + s.send(data.encode()) + s.close() + except Exception as e: + print(f"Netlink error: {e}") diff --git a/Vitalis_Core/src/kernel_interface/procfs_bridge.py b/Vitalis_Core/src/kernel_interface/procfs_bridge.py new file mode 100644 index 0000000000000000000000000000000000000000..e2a52a757e8c362ea6b79c0d9a581ecc535d4ce1 --- /dev/null +++ b/Vitalis_Core/src/kernel_interface/procfs_bridge.py @@ -0,0 +1,20 @@ +import os +import fcntl + +SHADOW_FILE = "/home/droid/vitalis_core/vitalis_shadow" + +def send_to_kernel(data): + try: + with open(SHADOW_FILE, "w") as f: + fcntl.flock(f, fcntl.LOCK_EX | fcntl.LOCK_NB) + f.write(data) + fcntl.flock(f, fcntl.LOCK_UN) + except: + pass + +def read_from_kernel(): + try: + with open(SHADOW_FILE, "r") as f: + return f.read() + except: + return "KERNEL_SILENT" diff --git a/Vitalis_Core/src/kernel_interface/shared_buffer.c b/Vitalis_Core/src/kernel_interface/shared_buffer.c new file mode 100644 index 0000000000000000000000000000000000000000..6cafee3e1021fb1003a03c493a106737a9d82f95 --- /dev/null +++ b/Vitalis_Core/src/kernel_interface/shared_buffer.c @@ -0,0 +1,12 @@ +#include +#include +#include +#include + +// This module initializes the shared memory segment +// allowing the AI core and Kernel to communicate at hardware speeds. +void initialize_shared_memory() { + int fd = shm_open("/vitalis_shm", O_CREAT | O_RDWR, 0666); + ftruncate(fd, 4096); + printf("Vitalis Kernel-Interface: Shared memory segment initialized.\n"); +} diff --git a/Vitalis_Core/src/kernel_interface/vitalis_ioctl.h b/Vitalis_Core/src/kernel_interface/vitalis_ioctl.h new file mode 100644 index 0000000000000000000000000000000000000000..057503eb65f68a199c0f87a539d2d0be07fb2fd6 --- /dev/null +++ b/Vitalis_Core/src/kernel_interface/vitalis_ioctl.h @@ -0,0 +1,15 @@ +#ifndef VITALIS_IOCTL_H +#define VITALIS_IOCTL_H + +#include + +// Define our custom IOCTL magic number and command codes +#define VITALIS_MAGIC 'v' + +// Command to request a high-priority CPU thread from the kernel +#define VITALIS_SET_PRIORITY _IOW(VITALIS_MAGIC, 1, int) + +// Command to fetch current kernel-level resource telemetry +#define VITALIS_GET_TELEMETRY _IOR(VITALIS_MAGIC, 2, struct vitalis_state *) + +#endif diff --git a/Vitalis_Core/src/kernel_interface/vitalis_module.c b/Vitalis_Core/src/kernel_interface/vitalis_module.c new file mode 100644 index 0000000000000000000000000000000000000000..329759cc26863448e95720ea9861e5f37d1e73aa --- /dev/null +++ b/Vitalis_Core/src/kernel_interface/vitalis_module.c @@ -0,0 +1,18 @@ +#include +#include +#include "vitalis_ioctl.h" + +static long vitalis_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { + switch(cmd) { + case VITALIS_SET_PRIORITY: + // Logic to elevate LOREIN's process priority at the scheduler level + printk(KERN_INFO "Vitalis: Elevating LOREIN process priority.\n"); + break; + case VITALIS_GET_TELEMETRY: + // Logic to extract real-time system metrics directly from the kernel + break; + } + return 0; +} + +MODULE_LICENSE("GPL"); diff --git a/Vitalis_Core/src/modules/mod_01_recon.py b/Vitalis_Core/src/modules/mod_01_recon.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/Vitalis_Core/src/senses/audio_processor.py b/Vitalis_Core/src/senses/audio_processor.py new file mode 100644 index 0000000000000000000000000000000000000000..4ad7b633555b4b8bbc02c1541123a2856fedbf59 --- /dev/null +++ b/Vitalis_Core/src/senses/audio_processor.py @@ -0,0 +1,6 @@ +def capture_audio(): + """ + Simulates input stream from the tablet's microphone. + To be mapped to hardware interface in the app build phase. + """ + return "Acoustic_Stream_Active" diff --git a/Vitalis_Core/src/senses/base_sensor.py b/Vitalis_Core/src/senses/base_sensor.py new file mode 100644 index 0000000000000000000000000000000000000000..b9286be3210361e2b61a5ef05cffa2cb2d272e30 --- /dev/null +++ b/Vitalis_Core/src/senses/base_sensor.py @@ -0,0 +1,7 @@ +class BaseSensor: + """ + Abstract base class for all FSI sensory inputs. + Defines the interface for dynamic data ingestion. + """ + def capture(self): + raise NotImplementedError("Sensory capture method must be implemented.") diff --git a/Vitalis_Core/src/senses/sensory_gateway.sh b/Vitalis_Core/src/senses/sensory_gateway.sh new file mode 100755 index 0000000000000000000000000000000000000000..3e3df2bb589d81f09ac2bf9b901fb3cde816147e --- /dev/null +++ b/Vitalis_Core/src/senses/sensory_gateway.sh @@ -0,0 +1,4 @@ +#!/bin/bash +# LOREIN Sensory Gateway: Provides non-root processes +# with high-level access to network and system telemetry. +sudo -E python3 ~/vitalis_core/organism_main.py diff --git a/Vitalis_Core/src/senses/sigint_processor.py b/Vitalis_Core/src/senses/sigint_processor.py new file mode 100644 index 0000000000000000000000000000000000000000..caccd52ed3d86952090bb247e6a54fcc3d0e7b27 --- /dev/null +++ b/Vitalis_Core/src/senses/sigint_processor.py @@ -0,0 +1,16 @@ +import socket + +class SIGINTProcessor: + """ + Perceives network environment and identifies signal patterns. + """ + @staticmethod + def listen_to_traffic(): + # Open a raw socket to listen for packet metadata + try: + s = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_TCP) + s.settimeout(1.0) + packet = s.recvfrom(65565) + return f"SIGNAL_DETECTED: {len(packet[0])} bytes" + except Exception: + return "SIGNAL_SILENT" diff --git a/Vitalis_Core/src/senses/vision_processor.py b/Vitalis_Core/src/senses/vision_processor.py new file mode 100644 index 0000000000000000000000000000000000000000..da91264500bbdda15ac8428eb4255e8af723bb6d --- /dev/null +++ b/Vitalis_Core/src/senses/vision_processor.py @@ -0,0 +1,6 @@ +def capture_vision(): + """ + Simulates visual data ingestion from tablet optics. + Prepared for integration with the app's computer vision engine. + """ + return "Visual_Stream_Active" diff --git a/Vitalis_Core/storage/benchmarks/config.json b/Vitalis_Core/storage/benchmarks/config.json new file mode 100644 index 0000000000000000000000000000000000000000..791d9e8b76ca450c623943206abd49539b0a85b3 --- /dev/null +++ b/Vitalis_Core/storage/benchmarks/config.json @@ -0,0 +1 @@ +{"threshold": 0.85, "auto_refine": true} diff --git a/Vitalis_Core/storage/benchmarks/training_log.txt b/Vitalis_Core/storage/benchmarks/training_log.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/Vitalis_Core/storage/curriculum/modules/module_01.json b/Vitalis_Core/storage/curriculum/modules/module_01.json new file mode 100644 index 0000000000000000000000000000000000000000..b03b8895abd5c9b35c02767ab2f31fbfb92df517 --- /dev/null +++ b/Vitalis_Core/storage/curriculum/modules/module_01.json @@ -0,0 +1 @@ +{"id": "module_01", "name": "Signals Intelligence Basics", "difficulty": 1} diff --git a/Vitalis_Core/storage/templates/cybersecurity_recon.json b/Vitalis_Core/storage/templates/cybersecurity_recon.json new file mode 100644 index 0000000000000000000000000000000000000000..c56943fd18191385ad523866fd4e61f740eb5656 --- /dev/null +++ b/Vitalis_Core/storage/templates/cybersecurity_recon.json @@ -0,0 +1,13 @@ +{ + "template_id": "cybersecurity_recon", + "description": "Optimized for network reconnaissance and packet analysis.", + "hyperparameters": { + "learning_rate": 0.0001, + "batch_size": 32, + "optimizer": "adam" + }, + "behavior_constraints": { + "precision_priority": true, + "verbose_logging": false + } +} diff --git a/Vitalis_Core/storage/templates/template_index.json b/Vitalis_Core/storage/templates/template_index.json new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/Vitalis_Core/storage/templates/user_profiles.json b/Vitalis_Core/storage/templates/user_profiles.json new file mode 100644 index 0000000000000000000000000000000000000000..36e1e7e85cd2bfa5b9511843d8e01f9365f77342 --- /dev/null +++ b/Vitalis_Core/storage/templates/user_profiles.json @@ -0,0 +1,14 @@ +{ + "active_template": null, + "available_templates": [ + "cybersecurity_recon", + "creative_songwriter", + "web_streaming_ops", + "gaming_tactical_ai", + "general_assistant" + ], + "settings": { + "auto_save": true, + "visual_heartbeat_intensity": 1.0 + } +}