universalisos/AURELIO_INTEGRATION.md

Aurelio Integration Plan: PikeOS → Aurelio Implementation

Overview

This document maps the complete PikeOS 5.0 ecosystem to Aurelio cyber-physical brain implementation, establishing how PikeOS code generation workflows, safety-critical patterns, and architectural principles can be applied to agent-based orchestration and cyber-physical system control.

Mapping Overview

┌─────────────────────────────────────────────────────────┐
│                    PikeOS 5.0 Ecosystem                   │
│  ┌─────────────┐  ┌──────────────┐  ┌─────────────┐  │
│  │ XSD Schemas │──│   PikeOS     │──│   Safety     │  │
│  │   (316)     │  │   Source     │  │   Patterns   │  │
│  └─────────────┘  │   Code       │  │   (AUTOSAR)  │  │
│                  └──────────────┘  └─────────────┘  │
└─────────────────────────────────────────────────────────┘
                           │
                           │ Mapping Layer
                           ▼
┌─────────────────────────────────────────────────────────┐
│                   Aurelio Cyber-Physical Brain         │
│  ┌─────────────┐  ┌──────────────┐  ┌─────────────┐  │
│  │  Agent      │──│   Graph      │──│   Safety     │  │
│  │ Components  │  │   Learning   │  │   Monitoring │  │
│  └─────────────┘  └──────────────┘  └─────────────┘  │
└─────────────────────────────────────────────────────────┘

Phase 1: XSD Workflow → Aurelio Code Generation

1.1 Schema-Driven Agent Configuration

PikeOS Pattern:

<!-- PikeOS component XSD -->
<xs:complexType name="Component">
    <xs:sequence>
        <xs:element name="Description" type="xs:string"/>
        <xs:element name="Dependencies" type="Dependencies"/>
        <xs:element name="Parameters" type="Parameters"/>
    </xs:sequence>
</xs:complexType>

Aurelio Implementation:

class AurelioAgentComponent:
    """Agent component based on PikeOS XSD patterns"""
    
    def __init__(self, schema: XSDSchema):
        self.description = schema.get_description()
        self.dependencies = schema.get_dependencies()
        self.parameters = schema.get_parameters()
        
        # PikeOS-style validation
        self._validate_component(schema)
    
    def _validate_component(self, schema: XSDSchema) -> bool:
        """Validate component with PikeOS safety checks"""
        # Apply PikeOS P4X_STAND_CHECK_PTR equivalent
        if not self._validate_parameters():
            raise AurelioSafetyError("Parameter validation failed")
        
        if not self._validate_dependencies():
            raise AurelioSafetyError("Dependency validation failed")
        
        return True

1.2 Code Generation Pipeline Mapping

PikeOS Eclipse Pipeline:

XSD Schema → Ecore Model → Java Parser → C Code → Compiled Binary

Aurelio Pipeline:

XSD Schema → Aurelio Parser → Agent Model → Python/C++ Code → Agent Component

Implementation:

class AurelioCodeGenerator:
    """Code generator inspired by PikeOS Eclipse workflow"""
    
    def __init__(self):
        self.schema_processor = XSDSchemaProcessor()
        self.agent_generator = AgentComponentGenerator()
        self.validator = CodeValidator()
    
    def generate_agent_from_xsd(self, xsd_file: str) -> AgentComponent:
        """Generate agent component from XSD schema"""
        # Process XSD schema
        schema = self.schema_processor.parse(xsd_file)
        
        # Validate schema constraints
        self.validator.validate_schema(schema)
        
        # Generate agent component
        agent = self.agent_generator.generate(schema)
        
        # Apply safety-critical patterns
        self._apply_safety_patterns(agent)
        
        return agent
    
    def _apply_safety_patterns(self, agent: AgentComponent):
        """Apply PikeOS safety-critical patterns"""
        # Add bounds checking (P4X_STAND_CHECK_PTR equivalent)
        agent.add_bounds_checking()
        
        # Add const correctness
        agent.add_const_correctness()
        
        # Add assertions (warn/warn_once equivalent)
        agent.add_safety_assertions()

Phase 2: Safety-Critical Patterns → Aurelio Safety

2.1 Memory Safety Patterns

PikeOS Pattern:

// PikeOS memory safety
P4X_STAND_CHECK_PTR(dst_void, length);
P4X_STAND_CHECK_PTR(src_void, length);

if (ALIGNED2(size_t, d, i)) {
    // Aligned fast path
}

Aurelio Implementation:

class AurelioMemorySafety:
    """Memory safety inspired by PikeOS patterns"""
    
    @staticmethod
    def check_pointer(ptr: bytes, length: int) -> bool:
        """P4X_STAND_CHECK_PTR equivalent for Python"""
        if not isinstance(ptr, (bytes, bytearray)):
            return False
        if length < 0 or length > len(ptr):
            return False
        return True
    
    @staticmethod
    def check_alignment(ptr: bytes, alignment: int) -> bool:
        """ALIGNED2 equivalent for Python"""
        return (id(ptr) % alignment) == 0
    
    def safe_memory_operation(self, src: bytes, dst: bytearray, length: int) -> bool:
        """Safe memory operation with PikeOS-style checks"""
        if not self.check_pointer(src, length):
            return False
        if not self.check_pointer(dst, length):
            return False
        
        # Perform aligned operation if possible
        if self.check_alignment(src, 8) and self.check_alignment(dst, 8):
            return self._aligned_copy(src, dst, length)
        else:
            return self._unaligned_copy(src, dst, length)

2.2 Assertions and Runtime Validation

PikeOS Pattern:

// PikeOS production-safe assertions
#define warn(cond) if(!(cond)) p4_warning(__FILE__, __LINE__, #cond)

#define warn_once(cond) ({ \
    static P4_atomic_t _wonce = P4_ATOMIC_INIT; \
    if (!(cond)) { \
        if (p4_atomic_cas(&_wonce, 0, 1) == TRUE) { \
            p4_warning(__FILE__, __LINE__, #cond); \
        } \
    } \
})

Aurelio Implementation:

class AurelioSafetyChecks:
    """Production-safe assertions inspired by PikeOS"""
    
    @staticmethod
    def warn(condition: bool, context: str) -> None:
        """PikeOS warn equivalent"""
        if not condition:
            Logger.safety_warning(f"Warning in {context}")
    
    @staticmethod
    def warn_once(condition: bool, context: str) -> None:
        """PikeOS warn_once with atomic operation"""
        if not condition:
            # Use atomic operation for thread safety
            if AurelioSafetyChecks._atomic_flag.compare_and_set(False, True):
                Logger.safety_warning(f"One-time warning in {context}")
    
    @staticmethod
    def assert_condition(condition: bool, context: str) -> bool:
        """Production-safe assertion"""
        if not condition:
            Logger.safety_error(f"Assertion failed in {context}")
            return False
        return True

Phase 3: Component Architecture → Aurelio Agents

3.1 Scheduler → Aurelio Thread Orchestrator

PikeOS Scheduler:

// PikeOS time partitioning and priority scheduling
extern void schedule(void);
extern void thread_wait(timeout_t timeout);
extern void thread_wakeup(thread_t *thread);
extern void thread_yield(void);

Aurelio Thread Orchestrator:

class AurelioThreadOrchestrator:
    """Thread orchestrator based on PikeOS scheduler patterns"""
    
    def __init__(self):
        self.time_partitioning = TimePartitioning()
        self.priority_manager = PriorityManager()
        self.preemption_monitor = PreemptionMonitor()
        self.ready_queue = ReadyQueue()
    
    def schedule_agent(self, agent: AurelioAgent, deadline: Deadline):
        """Schedule agent with PikeOS-style safety"""
        # Apply PikeOS scheduling protocol
        self._validate_scheduling_conditions(agent)
        
        # Assign time partition
        self.time_partitioning.assign_partition(agent, deadline)
        
        # Set up priority management
        self.priority_manager.set_priority(agent, deadline.priority)
        
        # Enable preemption monitoring
        self.preemption_monitor.enable(agent)
        
        # Add to ready queue
        self.ready_queue.enqueue(agent)
    
    def agent_wait(self, agent: AurelioAgent, timeout: Timeout):
        """Thread wait equivalent for agents"""
        # PikeOS waiting sequence protocol
        agent.release_critical_section_locks()
        self.ready_queue.remove(agent)
        agent.wait_for_event(timeout)
    
    def agent_wakeup(self, agent: AurelioAgent):
        """Thread wakeup equivalent for agents"""
        # PikeOS wakeup sequence protocol
        self.ready_queue.enqueue(agent)
        agent.notify_event()
    
    def agent_yield(self, agent: AurelioAgent):
        """Thread yield equivalent for agents"""
        # PikeOS yield protocol
        self.preemption_monitor.check_preemption_point(agent)
        self.ready_queue.yield(agent)

3.2 Memory Management → Aurelio Memory Manager

PikeOS Memory:

// PikeOS memory management
extern void *kmalloc(size_t size);
extern void kfree(void *ptr);
extern void heap_validate(void);
extern void garbage_collect(void);

Aurelio Memory Manager:

class AurelioMemoryManager:
    """Memory manager based on PikeOS patterns"""
    
    def __init__(self):
        self.bounds_checker = BoundsChecker()
        self.heap_protector = HeapProtector()
        self.garbage_collector = GarbageCollector()
        self.memory_partitioner = MemoryPartitioner()
    
    def allocate_safe(self, size: int, asil_level: ASILLevel) -> Optional[memory]:
        """Safe allocation with PikeOS-style checks"""
        # PikeOS P4X_STAND_CHECK_PTR validation
        if not self.bounds_checker.validate_size(size):
            raise MemoryError("Invalid size parameter")
        
        # Apply safety level protection
        memory = self.heap_protector.allocate(size, asil_level)
        
        if memory and asil_level == ASILLevel.D:
            self.garbage_collector.register_for_tracking(memory)
        
        return memory
    
    def free_safe(self, memory: memory) -> None:
        """Safe memory deallocation"""
        # Validate before freeing
        if not self.heap_protector.validate_memory(memory):
            raise MemoryError("Invalid memory pointer")
        
        # Perform garbage collection if needed
        self.garbage_collector.collect_if_necessary()
        
        # Free memory
        self.heap_protector.free(memory)
    
    def validate_heap(self) -> bool:
        """PikeOS heap_validate equivalent"""
        return self.heap_protector.validate_integrity()
    
    def collect_garbage(self) -> GarbageCollectionResult:
        """PikeOS garbage_collect equivalent"""
        return self.garbage_collector.collect()

3.3 IPC → Aurelio Agent Communication

PikeOS IPC:

// PikeOS inter-process communication
extern int ipc_send(thread_t *dest, void *msg, size_t len);
extern int ipc_receive(thread_t *src, void *msg, size_t len);
extern void ipc_mask_update(thread_t *thread, ipc_mask_t mask);

Aurelio Agent Communication:

class AurelioAgentCommunication:
    """Agent communication based on PikeOS IPC patterns"""
    
    def __init__(self):
        self.thread_locker = ThreadSafeLocking()
        self.queue_manager = SafeQueueManager()
        self.mask_manager = IPCMaskManager()
        self.protocol_validator = ProtocolValidator()
    
    def send_message_safe(self, sender: Agent, receiver: Agent, message: Message):
        """PikeOS ipc_send equivalent for agents"""
        # Apply PikeOS IPC protocol
        self.thread_locker.acquire_thread_lock(sender)
        
        try:
            # Validate message
            if not self.protocol_validator.validate(message):
                raise CommunicationError("Invalid message format")
            
            # Check IPC mask
            if not self.mask_manager.check_permission(sender, receiver):
                raise CommunicationError("IPC permission denied")
            
            # Enqueue to receiver's queue
            self.queue_manager.enqueue(receiver, message)
            
        finally:
            self.thread_locker.release_thread_lock(sender)
    
    def receive_message_safe(self, receiver: Agent, timeout: Timeout) -> Optional[Message]:
        """PikeOS ipc_receive equivalent for agents"""
        # Apply PikeOS receive sequence
        self.thread_locker.acquire_thread_lock(receiver)
        
        try:
            # Wait for message with timeout
            message = self.queue_manager.dequeue(receiver, timeout)
            
            if message:
                self.protocol_validator.validate_received(message)
            
            return message
            
        finally:
            self.thread_locker.release_thread_lock(receiver)
    
    def update_ipc_mask(self, agent: Agent, mask: IPCMask):
        """PikeOS ipc_mask_update equivalent"""
        self.mask_manager.update_mask(agent, mask)
        self.queue_manager.apply_mask(agent, mask)

Phase 4: Hypervisor Architecture → Aurelio Orchestration

4.1 Virtual Machine Management → Aurelio Agent Sandbox

PikeOS VM Management:

// PikeOS VM lifecycle
int universalisos_create_vm(vm_config_t *config, universalisos_vm_context_t **vm_out);
int universalisos_start_vm(universalisos_vm_context_t *vm);
int universalisos_stop_vm(universalisos_vm_context_t *vm);

Aurelio Agent Sandbox:

class AurelioAgentSandbox:
    """Agent sandbox based on PikeOS VM patterns"""
    
    def __init__(self):
        self.vm_manager = VirtualMachineManager()
        self.isolation_manager = IsolationManager()
        self.resource_quota_manager = ResourceQuotaManager()
    
    def create_agent_sandbox(self, agent_config: AgentConfig) -> AgentSandbox:
        """Create agent sandbox with PikeOS VM isolation"""
        # Apply PikeOS VM creation safety
        sandbox = AgentSandbox(agent_config)
        
        # Set up memory isolation
        self.isolation_manager.setup_memory_partitioning(sandbox, agent_config.asil_level)
        
        # Configure resource quotas
        self.resource_quota_manager.set_quotas(sandbox, agent_config.resource_limits)
        
        # Enable safety monitoring
        self.enable_safety_monitoring(sandbox)
        
        return sandbox
    
    def start_agent(self, agent: Agent, sandbox: AgentSandbox):
        """Start agent in sandbox with PikeOS safety"""
        # Validate sandbox state
        if not self.isolation_manager.validate_isolation(sandbox):
            raise SandboxError("Sandbox isolation validation failed")
        
        # Start agent with safety checks
        agent.start(sandbox)
        
        # Enable runtime monitoring
        self.enable_runtime_monitoring(agent, sandbox)
    
    def stop_agent(self, agent: Agent):
        """Stop agent safely"""
        # Apply PikeOS VM stop safety protocol
        self.disable_runtime_monitoring(agent)
        self.isolation_manager.cleanup_resources(agent)
        agent.stop()

4.2 Time Partitioning → Aurelio Real-Time Scheduling

PikeOS Time Partitioning:

// PikeOS time partition enforcement
void universalisos_enforce_time_partition(universalisos_vcpu_t *vcpu);
bool universalisos_check_time_partition_compliance(universalisos_vm_context_t *vm);

Aurelio Real-Time Scheduling:

class AurelioRealTimeScheduler:
    """Real-time scheduling based on PikeOS time partitioning"""
    
    def __init__(self):
        self.time_partitioner = TimePartitioner()
        self.deadline_monitor = DeadlineMonitor()
        self.priority_inheritor = PriorityInheritor()
    
    def schedule_agent_with_deadline(self, agent: Agent, deadline: Deadline):
        """Schedule agent with real-time deadline"""
        # Apply PikeOS time partitioning
        partition = self.time_partitioner.create_partition(agent, deadline)
        
        # Set up deadline monitoring
        self.deadline_monitor.enable(agent, deadline)
        
        # Configure priority inheritance
        self.priority_inheritor.setup(agent, deadline.priority)
        
        # Schedule in ready queue
        self.ready_queue.enqueue(agent, partition)
    
    def enforce_time_partition(self, agent: Agent):
        """PikeOS time partition enforcement"""
        partition = self.time_partitioner.get_partition(agent)
        
        # Check time slice compliance
        if not partition.within_time_slice():
            self.deadline_monitor.check_deadline(agent)
            self.time_partitioner.enforce_deadline(agent)
    
    def handle_deadline_miss(self, agent: Agent):
        """Handle deadline miss with PikeOS safety"""
        # Apply PikeOS deadline miss protocol
        self.deadline_monitor.log_deadline_miss(agent)
        self.priority_inheritor.apply_priority_boost(agent)
        
        # Take corrective action
        if agent.asil_level == ASILLevel.D:
            self.handle_safety_critical_deadline_miss(agent)

Phase 5: Component Configuration → Aurelio Agent Definition

5.1 XSD-Driven Agent Definition

PikeOS Component XSD:

<xs:complexType name="Component">
    <xs:sequence>
        <xs:element name="Description" type="xs:string"/>
        <xs:element name="CategoryTable" type="componentCategories"/>
        <xs:element name="DependencyTable" type="componentDepends"/>
        <xs:element name="ParameterTable" type="TypeParameters"/>
    </xs:sequence>
</xs:complexType>

Aurelio Agent Schema:

@dataclass
class AurelioAgentSchema:
    """Agent schema based on PikeOS component XSD"""
    name: str
    description: str
    categories: List[str]
    dependencies: List[str]
    parameters: Dict[str, Any]
    asil_level: ASILLevel
    resource_limits: ResourceLimits
    
    def to_agent(self) -> 'AurelioAgent':
        """Generate agent from schema"""
        # Validate schema
        self._validate_schema()
        
        # Create agent with PikeOS safety patterns
        agent = AurelioAgent(
            name=self.name,
            description=self.description,
            asil_level=self.asil_level
        )
        
        # Apply safety-critical patterns
        self._apply_safety_patterns(agent)
        
        # Set up parameters
        for param_name, param_value in self.parameters.items():
            agent.set_parameter(param_name, param_value)
        
        # Configure dependencies
        for dep in self.dependencies:
            agent.add_dependency(dep)
        
        return agent

Implementation Roadmap

Stage 1: Bare-Metal Hypervisor Skeleton ✅ Implemented

Deliverables:

• Bootable bare-metal kernel for QEMU ARM virt, written in C++
• Assembly startup with stack/BSS setup
• PL011 UART driver for serial output
• Build system using arm-none-eabi-g++

Code Components:

File	Purpose
kernel/arch/arm/boot.S	ARMv7 assembly entry point
kernel/arch/arm/linker.ld	Memory layout for QEMU virt
kernel/arch/arm/uart.c / uart.h	PL011 UART driver
kernel/kernel.c	kernel_main() entry point
kernel/Makefile	Cross-compilation and QEMU launch
kernel/README.md	Build and run instructions

Verification: make run boots the kernel in QEMU and prints:

Universalisos type-1 hypervisor booted.
Stage 1: bare-metal skeleton running on QEMU ARM virt.

Stage 2: Code Generation Pipeline (Week 3-4)

Deliverables:

• XSD schema processor for agent definitions
• Agent component code generator
• Safety-critical code patterns application
• Generated code validation framework

Code Components:

# Code generation modules
- AurelioCodeGenerator
- XSDSchemaProcessor
- AgentComponentGenerator
- CodeValidator

Stage 3: Agent Orchestration (Week 5-6)

Deliverables:

• Real-time thread orchestrator
• Memory manager with garbage collection
• Agent communication system
• Resource quota management

Code Components:

# Orchestration modules
- AurelioThreadOrchestrator
- AurelioMemoryManager
- AurelioAgentCommunication
- ResourceQuotaManager

Stage 4: Hypervisor Integration (Week 7-8)

Deliverables:

• Virtual machine management for agent isolation
• Time partitioning for real-time guarantees
• Safety monitoring and compliance checking
• Fault isolation and containment

Code Components:

# Hypervisor modules
- AurelioHypervisorOrchestrator
- VirtualMachineManager
- TimePartitioning
- SafetyMonitor

Verification Strategy

Phase 1: Safety Infrastructure Validation

# Memory safety tests
def test_memory_bounds_checking():
    """Test PikeOS-style memory safety"""
    # P4X_STAND_CHECK_PTR equivalent tests
    assert not check_pointer(invalid_ptr, 100)
    assert check_pointer(valid_ptr, 50)
    
    # ALIGNED2 equivalent tests
    assert check_alignment(aligned_ptr, 8)
    assert not check_alignment(unaligned_ptr, 8)

# Assertion tests
def test_production_safe_assertions():
    """Test PikeOS warn/warn_once patterns"""
    # Test warning functionality
    warn(True, "test_context")  # Should not warn
    
    # Test one-time warning
    for i in range(10):
        warn_once(False, "test_once")  # Should warn only once

Phase 2: Code Generation Validation

# XSD processing tests
def test_xsd_to_agent_generation():
    """Test XSD-driven agent generation"""
    xsd_schema = load_xsd("agent_component.xsd")
    generator = AurelioCodeGenerator()
    
    agent = generator.generate_agent_from_xsd(xsd_schema)
    
    # Validate generated agent
    assert agent.name == "TestAgent"
    assert agent.has_safety_patterns()
    assert agent.validates_parameters()

# Generated code validation
def test_generated_agent_safety():
    """Test safety patterns in generated agents"""
    agent = generate_test_agent()
    
    # Test bounds checking
    agent.set_parameter("test_param", 100)
    assert agent.validate_parameter("test_param", 100)
    
    # Test memory operations
    assert agent.perform_safe_memory_operation()

Phase 3: Orchestration Validation

# Real-time scheduling tests
def test_real_time_scheduling():
    """Test PikeOS-style real-time scheduling"""
    scheduler = AurelioThreadOrchestrator()
    agent = create_test_agent()
    deadline = Deadline(ms=10)
    
    scheduler.schedule_agent(agent, deadline)
    
    # Test time partition compliance
    assert scheduler.check_time_partition_compliance(agent)
    
    # Test deadline handling
    scheduler.simulate_deadline_miss(agent)
    assert scheduler.deadline_miss_count == 1

# Communication safety tests
def test_agent_communication_safety():
    """Test PikeOS-style IPC safety"""
    sender = create_test_agent()
    receiver = create_test_agent()
    message = create_test_message()
    
    comm = AurelioAgentCommunication()
    
    # Test thread-safe send
    comm.send_message_safe(sender, receiver, message)
    
    # Test receive with timeout
    received = comm.receive_message_safe(receiver, Timeout(ms=100))
    assert received == message

Success Criteria

Phase 1 Success Metrics

• Memory safety framework with <1% overhead
• Zero production assertion failures (properly silenced)
• Thread-safe locking with no deadlocks
• Basic agent sandbox with isolation verification

Phase 2 Success Metrics

• XSD schema processing with 100% coverage
• Code generation with safety pattern application
• Generated code passes all safety checks
• Code generation overhead <5% compared to hand-written

Phase 3 Success Metrics

• Real-time scheduling with <100μs overhead
• Memory management with <10% fragmentation
• Agent communication with zero message loss
• Resource quota enforcement with 99% accuracy

Phase 4 Success Metrics

• VM isolation with <1μs context switch
• Time partitioning with <1% deadline miss rate
• Safety monitoring with <100μs detection latency
• Fault containment with 100% isolation verification

Integration Testing

End-to-End Test Scenario

def test_aurelio_pikeos_integration():
    """Comprehensive integration test"""
    
    # Stage 1: Create agent from XSD
    xsd_schema = load_xsd("test_agent.xsd")
    generator = AurelioCodeGenerator()
    agent = generator.generate_agent_from_xsd(xsd_schema)
    
    # Stage 2: Create sandbox
    sandbox_mgr = AurelioAgentSandbox()
    sandbox = sandbox_mgr.create_agent_sandbox(agent.config)
    
    # Stage 3: Start agent with real-time scheduling
    scheduler = AurelioThreadOrchestrator()
    deadline = Deadline(ms=50)
    scheduler.schedule_agent(agent, deadline)
    
    # Stage 4: Test communication
    sender = agent
    receiver = create_test_agent()
    comm = AurelioAgentCommunication()
    message = create_test_message()
    comm.send_message_safe(sender, receiver, message)
    
    # Stage 5: Test monitoring
    monitor = SafetyMonitor()
    monitor.start_monitoring(agent)
    
    # Validate results
    assert monitor.safety_compliance_check(agent)
    assert scheduler.deadline_miss_count == 0
    assert comm.message_success_rate == 1.0

Conclusion

This Aurelio integration plan establishes a comprehensive mapping from PikeOS 5.0 patterns to Aurelio cyber-physical brain implementation. The integration provides:

✅ Safety-Critical Foundation: AUTOSAR/MISRA compliant code generation ✅ Real-Time Guarantees: Deterministic scheduling and time partitioning
✅ Memory Safety: Comprehensive bounds checking and validation ✅ Agent Isolation: Strong sandbox with VM-level isolation ✅ Production Safety: Fail-safe design with graceful degradation

Key Integration Achievements:

• XSD-driven agent component generation
• PikeOS safety patterns applied to agent orchestration
• Real-time scheduling with deadline guarantees
• Thread-safe inter-agent communication
• Comprehensive safety monitoring and compliance

---

Status: 🔄 In Progress

Stage 1 (bare-metal hypervisor skeleton) is complete and boots in QEMU. The original Python mapping has been discarded in favor of a real C implementation.

Next Steps:

• Add C safety primitives (bounds checking, assertions, spinlocks)
• Add exception vector table and basic trap handling
• Implement a simple UART console shell
• Bring up a second CPU core (SMP bring-up)
• Begin Stage 2: code generation and build integration