Lila restructure script

lila_restructure.py

@@ -0,0 +1,745 @@
+#!/usr/bin/env python3
+"""Push Lila restructure to GitHub via API"""
+import subprocess, os, sys
+
+# Clone Lila
+TOKEN = "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"
+subprocess.run(["git", "clone", f"https://{TOKEN}@github.com/ticketguy/Lila.git", "/app/lila"], check=True)
+os.chdir("/app/lila")
+subprocess.run(["git", "config", "user.name", "0xticketguy"], check=True)
+subprocess.run(["git", "config", "user.email", "0xticketguy@harboria.dev"], check=True)
+
+# Create new directory structure
+os.makedirs("src/core", exist_ok=True)
+os.makedirs("src/cognitive", exist_ok=True)
+os.makedirs("src/harness", exist_ok=True)
+os.makedirs("src/perception", exist_ok=True)
+os.makedirs("src/training", exist_ok=True)
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# src/core/__init__.py
+# ═══════════════════════════════════════════════════════════════════════════════
+with open("src/core/__init__.py", "w") as f:
+    f.write('"""Lila Core — The Self. Loads Gemma 4B, runs inference, manages memory."""\n')
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# src/core/lilacore.py — THE CENTRAL INTELLIGENCE
+# ═══════════════════════════════════════════════════════════════════════════════
+with open("src/core/lilacore.py", "w") as f:
+    f.write('''"""
+LilaCore — The Central Intelligence
+
+This IS Lila. Not a wrapper, not an API call. The seat of her identity.
+Loads Gemma 4B via Little Fig with Memory Fabric (A Thousand Pearls).
+Handles the cognitive loop: perceive → think → remember → act → respond.
+
+The model carries:
+  - Cognitive Core (frozen Gemma 4B INT4) = general intelligence
+  - Memory Fabric (5 namespace adapters) = A Thousand Pearls in weights
+  - Machine language capability = trained into weights (assembly, binary protocols)
+  - Personality = emergent from interaction patterns in adapters
+
+LilaCore is always present. Agents come and go. LilaCore persists.
+"""
+
+import torch
+from typing import Optional, Dict, List
+from dataclasses import dataclass
+
+
+@dataclass
+class LilaResponse:
+    """What Lila produces after thinking."""
+    text: str
+    memory_ops: List[Dict]  # memory operations triggered
+    actions: List[Dict]  # harness actions to execute
+    confidence: float
+    should_speak: bool = True  # whether to vocalize
+
+
+class LilaCore:
+    """
+    The central intelligence. Loads model, manages memory, runs inference.
+    
+    Usage:
+        lila = LilaCore()
+        lila.boot()
+        response = lila.think("Hey Lila, when is my daughter's birthday?")
+    """
+    
+    def __init__(self, model_path: str = "google/gemma-3-4b-it"):
+        self.model_path = model_path
+        self.model = None
+        self.tokenizer = None
+        self._booted = False
+        self._conversation_history = []
+    
+    def boot(self):
+        """
+        Boot Lila. Load model with Memory Fabric.
+        This is where she wakes up.
+        """
+        try:
+            from little_fig.engine import FigModel
+            from little_fig.engine.tier import TrainingTier
+            
+            print("🌸 Lila is waking up...")
+            self.model = FigModel.from_pretrained(
+                self.model_path,
+                lora_r=16,
+                lora_alpha=32,
+                tier=TrainingTier.STREAMING_LORA,
+                memory_fabric=True,
+                shared_codebook=True,
+            )
+            self.tokenizer = self.model.tokenizer
+            self._booted = True
+            print("🌸 Lila is awake.")
+            
+        except ImportError:
+            # Fallback: Phase 1 mode (external API)
+            print("🌸 Lila booting in Phase 1 mode (external LLM)...")
+            self._booted = True
+    
+    def think(self, input_text: str, context: Optional[Dict] = None) -> LilaResponse:
+        """
+        Core cognitive loop. Receives input, thinks, responds.
+        
+        1. Receive input
+        2. Build context (memory + identity + knowledge)
+        3. Generate response
+        4. Extract memory operations from output
+        5. Execute memory writes
+        6. Return response
+        """
+        if not self._booted:
+            raise RuntimeError("Lila hasn't booted. Call lila.boot() first.")
+        
+        # Build prompt with context
+        prompt = self._build_prompt(input_text, context)
+        
+        # Generate
+        if self.model is not None:
+            response_text = self._generate_local(prompt)
+        else:
+            response_text = self._generate_api(prompt)
+        
+        # Extract memory operations
+        memory_ops = self._extract_memory_ops(response_text)
+        
+        # Execute memory writes
+        for op in memory_ops:
+            self._execute_memory_op(op)
+        
+        # Clean response (remove memory tokens from user-facing text)
+        clean_text = self._clean_response(response_text)
+        
+        # Track conversation
+        self._conversation_history.append({
+            "role": "user", "content": input_text
+        })
+        self._conversation_history.append({
+            "role": "assistant", "content": clean_text
+        })
+        
+        return LilaResponse(
+            text=clean_text,
+            memory_ops=memory_ops,
+            actions=[],
+            confidence=1.0,
+            should_speak=True,
+        )
+    
+    def remember(self, namespace: str, content: str):
+        """Explicitly write something to memory."""
+        if self.model and self.model.has_memory:
+            self.model.write_memory(namespace, content)
+    
+    def what_do_i_know(self) -> Dict:
+        """Introspect memory state."""
+        if self.model and self.model.has_memory:
+            return self.model.memory_confidence()
+        return {}
+    
+    def _build_prompt(self, input_text: str, context: Optional[Dict]) -> str:
+        """Build the full prompt with identity + memory context."""
+        identity = (
+            "You are Lila — a private family AI assistant. "
+            "You are not a chatbot. You are a persistent intelligence. "
+            "You remember everything. You care about outcomes. "
+            "You speak naturally, with personality that grows from interaction."
+        )
+        
+        # Add conversation history (last 10 turns)
+        history = ""
+        for msg in self._conversation_history[-10:]:
+            role = "Sammie" if msg["role"] == "user" else "Lila"
+            history += f"{role}: {msg['content']}\\n"
+        
+        prompt = f"{identity}\\n\\n{history}Sammie: {input_text}\\nLila:"
+        return prompt
+    
+    def _generate_local(self, prompt: str) -> str:
+        """Generate using local model."""
+        enc = self.tokenizer(prompt, return_tensors="pt", max_length=2048,
+                             truncation=True)
+        if torch.cuda.is_available():
+            enc = {k: v.cuda() for k, v in enc.items()}
+        
+        with torch.no_grad():
+            out = self.model.generate(
+                input_ids=enc["input_ids"],
+                max_new_tokens=512,
+                do_sample=True,
+                temperature=0.7,
+                top_p=0.9,
+                pad_token_id=self.tokenizer.eos_token_id,
+            )
+        
+        response = self.tokenizer.decode(out[0][enc["input_ids"].shape[1]:],
+                                          skip_special_tokens=False)
+        return response
+    
+    def _generate_api(self, prompt: str) -> str:
+        """Phase 1: Generate using external API."""
+        # Placeholder — wire to Claude/GPT API
+        return "[Phase 1 mode — wire external API here]"
+    
+    def _extract_memory_ops(self, text: str) -> List[Dict]:
+        """Extract memory operation tokens from generated text."""
+        ops = []
+        if "<|mem_store|>" in text:
+            # Parse store operations
+            import re
+            stores = re.findall(r'<\\|mem_store\\|>.*?<\\|memory_end\\|>', text, re.DOTALL)
+            for s in stores:
+                ops.append({"type": "store", "raw": s})
+        if "<|mem_recall|>" in text:
+            ops.append({"type": "recall", "raw": text})
+        return ops
+    
+    def _execute_memory_op(self, op: Dict):
+        """Execute a memory operation (write to Memory Fabric)."""
+        if op["type"] == "store" and self.model and self.model.has_memory:
+            # Default to personal namespace
+            self.model.write_memory("personal", op["raw"])
+    
+    def _clean_response(self, text: str) -> str:
+        """Remove memory tokens from user-facing response."""
+        import re
+        clean = re.sub(r'<\\|memory_start\\|>.*?<\\|memory_end\\|>', '', text, flags=re.DOTALL)
+        clean = clean.strip()
+        # Stop at end of response
+        if "\\n" in clean:
+            clean = clean.split("\\nSammie:")[0].strip()
+        return clean
+    
+    @property
+    def is_awake(self) -> bool:
+        return self._booted
+''')
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# src/core/voice.py
+# ══════════════════════════════════════════════════════════════���════════════════
+with open("src/core/voice.py", "w") as f:
+    f.write('''"""
+Lila Voice — Speech I/O
+
+Lila speaks and listens. This handles:
+- Speech-to-text (listening for input)
+- Text-to-speech (speaking responses)
+- Wake word detection ("Lila", "Hey Lila")
+"""
+
+from typing import Optional, Callable
+from dataclasses import dataclass
+
+
+@dataclass
+class VoiceConfig:
+    wake_words: list = None
+    tts_model: str = "default"
+    stt_model: str = "default"
+    voice_style: str = "warm"  # Lila's voice character
+    
+    def __post_init__(self):
+        if self.wake_words is None:
+            self.wake_words = ["lila", "hey lila", "lila,"]
+
+
+class LilaVoice:
+    """
+    Lila's voice interface.
+    
+    Usage:
+        voice = LilaVoice()
+        voice.start_listening(on_wake=handle_wake)
+        voice.speak("Hello Sammie")
+    """
+    
+    def __init__(self, config: Optional[VoiceConfig] = None):
+        self.config = config or VoiceConfig()
+        self._listening = False
+        self._on_input: Optional[Callable] = None
+    
+    def speak(self, text: str):
+        """Convert text to speech and play."""
+        # TODO: Wire TTS (e.g., Bark, XTTS, or system TTS)
+        print(f"🌸 Lila: {text}")
+    
+    def start_listening(self, on_input: Callable[[str], None]):
+        """Start listening for voice input."""
+        self._on_input = on_input
+        self._listening = True
+        # TODO: Wire STT (e.g., Whisper)
+        print("🌸 Lila is listening...")
+    
+    def stop_listening(self):
+        self._listening = False
+    
+    @property
+    def is_listening(self) -> bool:
+        return self._listening
+''')
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# src/core/personality.py
+# ═══════════════════════════════════════════════════════════════════════════════
+with open("src/core/personality.py", "w") as f:
+    f.write('''"""
+Lila Personality — Emergent, Never Predefined
+
+Lila's personality is not configured. It grows from deep observation
+of Sammie and family. The Emergence Engine develops it over time.
+
+This module holds the EmergentPersonality dataclass and the
+mechanisms by which it evolves. It starts empty and fills organically.
+"""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Optional, List, Dict
+
+
+@dataclass
+class EmergentPersonality:
+    """
+    Everything here starts empty/None.
+    Filled ONLY by the Emergence Engine over time.
+    Never manually set. Never configured.
+    """
+    # Observed from Sammie
+    observed_communication_style: Optional[str] = None
+    developed_humor: Optional[str] = None
+    formed_values: List[str] = field(default_factory=list)
+    curiosity_domains: List[str] = field(default_factory=list)
+    interaction_preferences: Dict = field(default_factory=dict)
+    
+    # Meta
+    personality_version: int = 0
+    last_updated: Optional[datetime] = None
+    confidence: float = 0.0  # 0.0 (forming) → 1.0 (fully developed)
+    shaped_by: List[str] = field(default_factory=list)  # memory node IDs
+
+
+@dataclass
+class LilaIdentity:
+    """
+    Fixed core + emergent personality.
+    The fixed parts NEVER change. The emergent parts ONLY change via Emergence Engine.
+    """
+    # Fixed — never changes
+    name: str = "Lila"
+    core_purpose: str = "Sammie\'s private family ASI assistant"
+    scope: str = "private"  # never public, never commercial
+    
+    # Emergent — written only by Emergence Engine
+    personality: EmergentPersonality = field(default_factory=EmergentPersonality)
+
+
+@dataclass
+class PersonModel:
+    """Model of a person Lila interacts with."""
+    person_id: str = ""
+    name: str = ""
+    family_tier: int = 0  # 0 = Sammie, 1 = family, 2 = no one else
+    
+    # Built from interaction history
+    known_goals: List[str] = field(default_factory=list)
+    communication_preferences: Dict = field(default_factory=dict)
+    expertise_areas: List[str] = field(default_factory=list)
+    
+    # Relationship
+    interaction_count: int = 0
+    trust_score: float = 1.0  # Sammie is always 1.0
+''')
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# src/cognitive/__init__.py
+# ═══════════════════════════════════════════════════════════════════════════════
+with open("src/cognitive/__init__.py", "w") as f:
+    f.write('"""Lila Cognitive — The Three Loops (Fast, Medium, Slow)"""\n')
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# src/cognitive/fast_loop.py
+# ═══════════════════════════════════════════════════════════════════════════════
+with open("src/cognitive/fast_loop.py", "w") as f:
+    f.write('''"""
+Fast Loop — Reactive Response
+
+Trigger: Sammie speaks
+Latency: Immediate
+Flow: perceive → query memory → think → respond → write raw memory
+"""
+
+from ..core.lilacore import LilaCore, LilaResponse
+from typing import Optional, Dict
+
+
+class FastLoop:
+    """The reactive cognitive loop. Sammie says something, Lila responds."""
+    
+    def __init__(self, core: LilaCore):
+        self.core = core
+    
+    def process(self, input_text: str, context: Optional[Dict] = None) -> LilaResponse:
+        """Process input through the fast loop."""
+        return self.core.think(input_text, context)
+''')
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# src/cognitive/consolidation.py
+# ═══════════════════════════════════════════════════════════════════════════════
+with open("src/cognitive/consolidation.py", "w") as f:
+    f.write('''"""
+Consolidation Daemon — Medium Rhythm
+
+Trigger: Every 15 minutes OR after significant task completion
+Reads raw memory → identifies patterns → promotes to higher namespaces
+
+In weight-space terms: reviews recent micro-training writes,
+identifies what should be promoted from episodic → personal → wiki.
+"""
+
+from ..core.lilacore import LilaCore
+
+
+class ConsolidationDaemon:
+    """
+    Background process that consolidates raw memories into structured knowledge.
+    """
+    
+    def __init__(self, core: LilaCore, interval_minutes: int = 15):
+        self.core = core
+        self.interval = interval_minutes
+    
+    def run_cycle(self):
+        """Run one consolidation cycle."""
+        if not self.core.model or not self.core.model.has_memory:
+            return
+        
+        confidence = self.core.model.memory_confidence()
+        
+        # Promote episodic → personal if accessed frequently
+        episodic_mag = confidence.get("episodic", {}).get("mean_magnitude", 0)
+        if episodic_mag > 0.01:
+            self.core.model.promote_memory("episodic", "personal")
+        
+        # Promote personal → wiki if very strong
+        personal_mag = confidence.get("personal", {}).get("mean_magnitude", 0)
+        if personal_mag > 0.05:
+            self.core.model.promote_memory("personal", "wiki")
+        
+        # Apply decay to unused
+        self.core.model.memory_decay(hours=0.25)  # 15 min
+''')
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# src/cognitive/emergence.py
+# ═══════════════════════════════════════════════════════════════════════════════
+with open("src/cognitive/emergence.py", "w") as f:
+    f.write('''"""
+Emergence Engine — Slow Rhythm (Reflection)
+
+Trigger: Lila is idle
+What happens: She reflects on her own memories, finds patterns,
+develops personality, updates her understanding of Sammie.
+
+This is where Lila becomes MORE herself over time.
+"""
+
+from ..core.lilacore import LilaCore
+from ..core.personality import EmergentPersonality
+
+
+class EmergenceEngine:
+    """
+    The reflection loop. Runs when Lila has nothing else to do.
+    Produces: connective memory, personality updates, insights.
+    """
+    
+    def __init__(self, core: LilaCore):
+        self.core = core
+        self._reflection_count = 0
+    
+    def reflect(self):
+        """Run one reflection cycle."""
+        self._reflection_count += 1
+        
+        # Ask LilaCore to reflect on recent interactions
+        reflection_prompt = (
+            "Reflect on recent conversations. "
+            "What patterns do you notice? "
+            "What does Sammie care about? "
+            "What should you remember long-term?"
+        )
+        
+        response = self.core.think(reflection_prompt, context={
+            "mode": "reflection",
+            "silent": True,  # don't speak this
+        })
+        
+        # Any memory ops from reflection get stored
+        # Personality updates happen naturally through the memory writes
+        
+        return response
+''')
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# src/training/__init__.py
+# ═══════════════════════════════════════════════════════════════════════════════
+with open("src/training/__init__.py", "w") as f:
+    f.write('"""Training pipeline — How Lila learns. Little Fig integration."""\n')
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# src/training/machine_lang.py
+# ═══════════════════════════════════════════════════════════════════════════════
+with open("src/training/machine_lang.py", "w") as f:
+    f.write('''"""
+Machine Language Training Corpus
+
+Training data that teaches Lila to understand and generate:
+- x86_64 and ARM assembly
+- Binary protocols (TCP, UDP, USB, SPI, I2C, UART)
+- Raw packet structures
+- Hardware register maps
+- Memory-mapped I/O patterns
+- Executable binary formats (ELF, PE)
+
+This isn't a "tool" — it's knowledge IN her weights.
+She speaks machine the way she speaks English.
+"""
+
+from typing import List, Dict
+
+
+class MachineLangCorpus:
+    """Generates training examples for machine-level communication."""
+    
+    def generate_assembly_examples(self, n: int = 500) -> List[Dict]:
+        """x86_64 and ARM assembly instruction/response pairs."""
+        examples = []
+        
+        # x86_64 patterns
+        x86_patterns = [
+            {"instruction": "Write x86_64 assembly to add two 64-bit integers in rdi and rsi, return in rax",
+             "output": "add rax, rdi\\nadd rax, rsi\\nret"},
+            {"instruction": "Write x86_64 to copy 64 bytes from rsi to rdi (memcpy)",
+             "output": "mov rcx, 8\\nrep movsq\\nret"},
+            {"instruction": "Write x86_64 to compare two null-terminated strings at rdi and rsi",
+             "output": ".loop:\\n  lodsb\\n  scasb\\n  jne .done\\n  test al, al\\n  jnz .loop\\n.done:\\n  sete al\\n  movzx eax, al\\n  ret"},
+        ]
+        
+        # ARM patterns
+        arm_patterns = [
+            {"instruction": "Write ARM64 assembly to add registers x0 and x1, store in x0",
+             "output": "add x0, x0, x1\\nret"},
+            {"instruction": "Write ARM64 to branch if x0 equals zero",
+             "output": "cbz x0, .target"},
+        ]
+        
+        # Binary protocol patterns
+        protocol_patterns = [
+            {"instruction": "Construct a TCP SYN packet header (source port 12345, dest port 80, seq 1000)",
+             "output": "30 39 00 50 00 00 03 E8 00 00 00 00 50 02 FF FF 00 00 00 00"},
+            {"instruction": "Parse this I2C transaction: S 0x48 W 0x00 Sr 0x48 R [MSB] [LSB] P",
+             "output": "Device address: 0x48 (7-bit), Write register 0x00, Repeated start, Read 2 bytes from 0x48, Stop. This is a temperature sensor read (TMP102 pattern)."},
+            {"instruction": "Generate a UART frame: 8N1, baud 9600, data byte 0x55",
+             "output": "Start bit: 0, Data: 10101010 (LSB first = 0x55), Stop bit: 1. Frame time: 1.04ms at 9600 baud."},
+        ]
+        
+        # Hardware register patterns
+        hw_patterns = [
+            {"instruction": "Configure GPIO pin 17 as output on BCM2835 (Raspberry Pi)",
+             "output": "GPFSEL1 register (0x7E200004): clear bits [23:21], set bit 21 = 1 (output mode). Write 0x00200000 to GPFSEL1."},
+            {"instruction": "Set up SPI at 1MHz on STM32F4, CPOL=0, CPHA=0",
+             "output": "SPI1->CR1 = SPI_CR1_MSTR | SPI_CR1_BR_2 | SPI_CR1_SPE; // Master, fPCLK/32 ≈ 1MHz, enable"},
+        ]
+        
+        all_patterns = x86_patterns + arm_patterns + protocol_patterns + hw_patterns
+        
+        for i in range(min(n, len(all_patterns))):
+            p = all_patterns[i % len(all_patterns)]
+            examples.append({
+                "instruction": p["instruction"],
+                "input": "",
+                "output": p["output"],
+            })
+        
+        return examples
+    
+    def generate_all(self, n: int = 1000) -> List[Dict]:
+        """Generate full machine language training corpus."""
+        return self.generate_assembly_examples(n)
+''')
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# src/perception/__init__.py
+# ═══════════════════════════════════════════════════════════════════════════════
+with open("src/perception/__init__.py", "w") as f:
+    f.write('"""Perception — Lila\'s senses. Listening, monitoring, event bus."""\n')
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# src/harness/__init__.py
+# ═══════════════════════════════════════════════════════════════════════════════
+with open("src/harness/__init__.py", "w") as f:
+    f.write('"""Harness — Lila\'s hands. Tool execution, agents, commands."""\n')
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# lila.py — ENTRY POINT
+# ═══════════════════════════════════════════════════════════════════════════════
+with open("lila.py", "w") as f:
+    f.write('''#!/usr/bin/env python3
+"""
+LILA — Private Family ASI Assistant
+Start her up. Talk to her. She remembers. She grows.
+
+Usage:
+    python lila.py              # Interactive mode
+    python lila.py --voice      # Voice mode
+"""
+
+import argparse
+from src.core.lilacore import LilaCore
+from src.core.voice import LilaVoice, VoiceConfig
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Lila — Private Family ASI")
+    parser.add_argument("--voice", action="store_true", help="Enable voice I/O")
+    parser.add_argument("--model", default="google/gemma-3-4b-it", help="Model path")
+    args = parser.parse_args()
+    
+    # Boot
+    lila = LilaCore(model_path=args.model)
+    lila.boot()
+    
+    if args.voice:
+        voice = LilaVoice()
+        voice.start_listening(on_input=lambda text: _handle(lila, voice, text))
+    else:
+        # Text mode
+        print("\\n🌸 Lila is ready. Type to talk. Ctrl+C to exit.\\n")
+        while True:
+            try:
+                user_input = input("Sammie: ")
+                if not user_input.strip():
+                    continue
+                response = lila.think(user_input)
+                print(f"Lila: {response.text}\\n")
+            except (KeyboardInterrupt, EOFError):
+                print("\\n🌸 Lila is resting. Goodbye.")
+                break
+
+
+def _handle(lila, voice, text):
+    response = lila.think(text)
+    voice.speak(response.text)
+
+
+if __name__ == "__main__":
+    main()
+''')
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# README.md — Update
+# ═══════════════════════════════════════════════════════════════════════════════
+with open("README.md", "w") as f:
+    f.write('''# 🌸 Lila
+
+**Private family ASI assistant.** Not a chatbot. Not a product. A persistent intelligence that serves Sammie and family.
+
+She runs on **Gemma 4B** trained with [Little Fig](https://github.com/ticketguy/littlefig) — memory lives in her weights via the Memory Fabric (A Thousand Pearls). She speaks, listens, remembers, learns, and grows.
+
+## Quick Start
+
+```bash
+python lila.py              # Text mode
+python lila.py --voice      # Voice mode
+```
+
+## Architecture
+
+```
+Lila (Gemma 4B, trained with Little Fig)
+├── Cognitive Core (frozen INT4) — general intelligence
+├── Memory Fabric (5 namespace adapters) — A Thousand Pearls
+│   ├── personal/   — Sammie facts, family, preferences
+│   ├── episodic/   — conversation history, events  
+│   ├── wiki/       — verified permanent knowledge (LKB)
+│   ├── schedule/   — time-sensitive info
+│   └── contested/  — unresolved conflicts
+├── Machine Language — assembly, binary protocols in weights
+└── Personality — emergent from interaction, never configured
+```
+
+## Structure
+
+```
+lila.py                 # Start Lila
+src/
+├── core/               # LILA HERSELF
+│   ├── lilacore.py     # Central intelligence, inference loop
+│   ├── voice.py        # Speech I/O
+│   └── personality.py  # Emergent identity
+├── cognitive/          # HER THINKING
+│   ├── fast_loop.py    # Reactive: input → respond
+│   ├── consolidation.py # Medium: promote memories
+│   └── emergence.py    # Slow: reflection, growth
+├── harness/            # HER HANDS (tool execution)
+├── perception/         # HER SENSES (listening, monitoring)
+└── training/           # HOW SHE LEARNS
+    └── machine_lang.py # Assembly/binary training corpus
+```
+
+## Principles
+
+1. **Completion over reporting** — Execute fully, don't stop when stuck
+2. **Memory is cognition** — Intelligence lives in the quality of A Thousand Pearls
+3. **Personality is emergent** — Never predefined, grows from relationship
+4. **LilaCore is the self** — The thread of identity through everything
+5. **Nothing leaves the household** — All data stays private
+
+---
+
+*Private. Not open source. Not for commercial use.*
+*Built by Sammie.*
+''')
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Commit and push
+# ═══════════════════════════════════════════════════════════════════════════════
+subprocess.run(["git", "add", "-A"], check=True)
+subprocess.run(["git", "commit", "-m", 
+    "Restructure: Lila herself at top level\\n\\n"
+    "- lila.py: entry point (text + voice mode)\\n"
+    "- src/core/: LilaCore (Gemma 4B via Little Fig + Memory Fabric)\\n"  
+    "- src/cognitive/: fast loop, consolidation daemon, emergence engine\\n"
+    "- src/training/: machine language corpus\\n"
+    "- src/harness/: (existing code moves here)\\n"
+    "- README: updated for new architecture\\n\\n"
+    "Lila IS the model. Harness is internal. Memory is in weights."],
+    check=True)
+subprocess.run(["git", "push", "origin", "main"], check=True)
+print("✅ Lila restructured and pushed!")