| |
| """Push Lila restructure to GitHub via API""" |
| import subprocess, os, sys |
|
|
| |
| 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) |
|
|
| |
| 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) |
|
|
| |
| |
| |
| with open("src/core/__init__.py", "w") as f: |
| f.write('"""Lila Core — The Self. Loads Gemma 4B, runs inference, manages memory."""\n') |
|
|
| |
| |
| |
| 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 |
| ''') |
|
|
| |
| |
| |
| 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 |
| ''') |
|
|
| |
| |
| |
| 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 |
| ''') |
|
|
| |
| |
| |
| with open("src/cognitive/__init__.py", "w") as f: |
| f.write('"""Lila Cognitive — The Three Loops (Fast, Medium, Slow)"""\n') |
|
|
| |
| |
| |
| 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) |
| ''') |
|
|
| |
| |
| |
| 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 |
| ''') |
|
|
| |
| |
| |
| 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 |
| ''') |
|
|
| |
| |
| |
| with open("src/training/__init__.py", "w") as f: |
| f.write('"""Training pipeline — How Lila learns. Little Fig integration."""\n') |
|
|
| |
| |
| |
| 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) |
| ''') |
|
|
| |
| |
| |
| with open("src/perception/__init__.py", "w") as f: |
| f.write('"""Perception — Lila\'s senses. Listening, monitoring, event bus."""\n') |
|
|
| |
| |
| |
| with open("src/harness/__init__.py", "w") as f: |
| f.write('"""Harness — Lila\'s hands. Tool execution, agents, commands."""\n') |
|
|
| |
| |
| |
| 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() |
| ''') |
|
|
| |
| |
| |
| 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.* |
| ''') |
|
|
| |
| |
| |
| 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!") |
|
|
