lila_restructure.py

#!/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!")