Upload fsi_echo.py with huggingface_hub

fsi_echo.py

@@ -1,34 +1,17 @@
 #!/usr/bin/env python3
 """
 FSI_ECHO - Morphing Code Swarm
-================================
-Novel architecture inspired by the concept of transforming machines (movie Transformers)
-combined with nanobot swarm intelligence. Entirely my own design.
-
-Core concepts:
-  1. MORPH EMBEDDING — Token embeddings transform/reconfigure based on context,
-     like a Transformer robot changing form for different situations.
-  2. NANOBOT SWARM — Hundreds of tiny processing units (nanobots) that each have
-     multiple operational modes (scout/combat/support). The router selects the
-     right mode per token, like nanobots reconfiguring for the task.
-  3. ASSEMBLY — Related nanobots combine into larger processing groups
-     (like Devastator forming from Constructicons) for deep reasoning.
-  4. DUAL PATH — Fast disguise mode (pattern matching) vs deep discovery mode
-     (analytical reasoning), with learned routing between them.
-  5. CLOSED-LOOP DEBUG — Generates, self-verifies, and iteratively refines code.
-
-Size: ~3.1M params (fits in ~1.5MB at q4) — tiny enough for any device.
+Novel architecture: token morph embedding + nanobot swarm + assembly blocks + self-verification.
+2.6M params — fits in 1.3MB at q4, runs on any phone.
 """
-import os, sys, json, time, math, random, re, struct, hashlib
+import os, sys, json, time, math, random, re, struct
 from typing import List, Dict, Optional, Tuple
-from collections import defaultdict
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
-import numpy as np
 
 # =============================================================================
-# 1. CODE-OPTIMIZED TOKENIZER
+# 1. TOKENIZER
 # =============================================================================
 class CodeTokenizer:
     SPECIAL = {
@@ -78,20 +61,28 @@ class CodeTokenizer:
     def encode(self, text: str, bos: bool = True, eos: bool = False) -> List[int]:
         ids = []
         if bos:
-            ids.append(self.vocab.get('<BOS>', 2))
-        for token in re.findall(r'<[^>]+>|[A-Za-z_][A-Za-z0-9_]*|\.\.\.|==|!=|<=|>=|->|\*\*|//|\d+\.\d*|\d+|\S|\s', text):
-            if token.isspace():
-                continue
-            ids.append(self.vocab.get(token, self.vocab.get(token.lower(), self.vocab.get('<UNK>', 3))))
+            ids.append(2)
+        for token in re.findall(r'<[^>]+>|[A-Za-z_][A-Za-z0-9_]*|\.\.\.|==|!=|<=|>=|->|\*\*|//|::|=>|\d+\.\d*|\d+|\S', text):
+            if token in self.vocab:
+                ids.append(self.vocab[token])
+            elif token.lower() in self.vocab:
+                ids.append(self.vocab[token.lower()])
+            else:
+                for ch in token:
+                    if ch in self.vocab:
+                        ids.append(self.vocab[ch])
+                    else:
+                        ids.append(3)
         if eos:
-            ids.append(self.vocab.get('<EOS>', 1))
+            ids.append(1)
         return ids[:2048]
-    def decode(self, ids: List[int], skip_special: bool = False) -> str:
+    def decode(self, ids: List[int], skip_special: bool = True) -> str:
         tokens = []
         for i in ids:
             if i in self.inverse:
                 t = self.inverse[i]
-                if skip_special and t.startswith('<') and t.endswith('>'): continue
+                if skip_special and t.startswith('<') and t.endswith('>'):
+                    continue
                 tokens.append(t)
             else:
                 tokens.append(' ')
@@ -106,22 +97,17 @@ class CodeTokenizer:
     def vocab_size_(self): return len(self.vocab)
 
 # =============================================================================
-# 2. MORPH EMBEDDING — tokens transform based on context (like a robot changing form)
+# 2. MORPH EMBEDDING
 # =============================================================================
 class MorphEmbedding(nn.Module):
-    """
-    Each token gets a base embedding PLUS a context-dependent morph vector.
-    The morph is computed from the token's neighbors — like a Transformer robot
-    changing its form based on the situation.
-    """
     def __init__(self, vocab_size: int, d_model: int, morph_width: int = 3):
         super().__init__()
         self.d_model = d_model
         self.morph_width = morph_width
         self.base_embed = nn.Embedding(vocab_size, d_model)
+        # Causal morph: only current + past (morph_width tokens, no future leakage)
         self.morph_net = nn.Sequential(
-            nn.Linear(d_model * morph_width, d_model),
-            nn.Tanh(),
+            nn.Linear(d_model * morph_width, d_model), nn.Tanh(),
             nn.Linear(d_model, d_model),
         )
         self.gate = nn.Linear(d_model * 2, d_model)
@@ -129,7 +115,8 @@ class MorphEmbedding(nn.Module):
     def forward(self, tokens: torch.Tensor) -> torch.Tensor:
         B, T = tokens.shape
         base = self.base_embed(tokens)
-        padded = F.pad(base, (0, 0, self.morph_width // 2, self.morph_width // 2), mode='replicate')
+        # Causal sliding window: each position only sees itself and preceding tokens
+        padded = F.pad(base, (0, 0, self.morph_width - 1, 0), mode='replicate')
         contexts = []
         for i in range(self.morph_width):
             contexts.append(padded[:, i:i+T, :])
@@ -139,36 +126,23 @@ class MorphEmbedding(nn.Module):
         return base + gate * morph
 
 # =============================================================================
-# 3. NANOBOT SWARM LAYER — tiny processing units with multiple operational modes
+# 3. NANOBOT SWARM
 # =============================================================================
 class NanobotSwarm(nn.Module):
-    """
-    Inspired by nanobot swarms AND movie Transformers: each nanobot is a tiny
-    processor that can operate in different modes (scout/combat/support).
-    They communicate, combine, and their collective intelligence emerges.
-
-    - scout mode: lightweight pattern scanning (fast FFN, small dim)
-    - combat mode: deep analytical reasoning (full FFN, larger dim)
-    - support mode: coordination & information routing (gate network)
-    """
     def __init__(self, d_model: int, n_nanobots: int = 512, scout_dim: int = 64, combat_dim: int = 128):
         super().__init__()
         self.d_model = d_model
         self.n_nanobots = n_nanobots
-
         self.nano_keys = nn.Parameter(torch.randn(n_nanobots, d_model // 4))
         self.nano_vals = nn.Parameter(torch.randn(n_nanobots, d_model))
-
         self.scout_ffn = nn.Sequential(
             nn.Linear(d_model, scout_dim), nn.GELU(), nn.Linear(scout_dim, d_model),
         )
         self.combat_ffn = nn.Sequential(
             nn.Linear(d_model, combat_dim), nn.GELU(), nn.Linear(combat_dim, d_model),
         )
-
         self.mode_router = nn.Linear(d_model, 2)
         self.assembly = nn.Linear(d_model, d_model)
-
         self.norm = nn.LayerNorm(d_model)
         self.dropout = nn.Dropout(0.1)
 
@@ -176,49 +150,33 @@ class NanobotSwarm(nn.Module):
         B, T, D = x.shape
         residual = x
         x = self.norm(x)
-
         router_query = x[..., :self.d_model // 4]
         nano_scores = torch.matmul(router_query, self.nano_keys.T)
         nano_weights = F.softmax(nano_scores / math.sqrt(self.d_model // 4), dim=-1)
-
         mode_logits = self.mode_router(x)
         mode_w = F.softmax(mode_logits, dim=-1)
-
         scout_out = self.scout_ffn(x)
         combat_out = self.combat_ffn(x)
         mode_out = mode_w[:, :, 0:1] * scout_out + mode_w[:, :, 1:2] * combat_out
-
         nano_out = torch.matmul(nano_weights, self.nano_vals)
-        token_out = mode_out + nano_out
-
-        out = residual + self.dropout(self.assembly(token_out))
+        out = residual + self.dropout(self.assembly(mode_out + nano_out))
         return out
 
 # =============================================================================
-# 4. ASSEMBLY BLOCK — deep coordinated processing (like Transformers combining)
+# 4. ASSEMBLY BLOCK
 # =============================================================================
 class AssemblyBlock(nn.Module):
-    """
-    Larger processing block formed when nanobots combine forces.
-    Like Constructicons forming Devastator — individual units combine into
-    a more powerful entity for complex reasoning.
-    """
     def __init__(self, d_model: int, n_heads: int = 4, dropout: float = 0.1):
         super().__init__()
         self.d_model = d_model
         self.n_heads = n_heads
         self.head_dim = d_model // n_heads
-
         self.qkv = nn.Linear(d_model, 3 * d_model, bias=False)
         self.proj = nn.Linear(d_model, d_model, bias=False)
-
         self.ffn = nn.Sequential(
-            nn.Linear(d_model, d_model * 2),
-            nn.GELU(),
-            nn.Linear(d_model * 2, d_model),
-            nn.Dropout(dropout),
+            nn.Linear(d_model, d_model * 2), nn.GELU(),
+            nn.Linear(d_model * 2, d_model), nn.Dropout(dropout),
         )
-
         self.adapt_gate = nn.Linear(d_model, 1)
         self.norm1 = nn.LayerNorm(d_model)
         self.norm2 = nn.LayerNorm(d_model)
@@ -226,70 +184,45 @@ class AssemblyBlock(nn.Module):
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
         B, T, D = x.shape
-
-        # Multi-head attention
         qkv = self.qkv(self.norm1(x))
         qkv = qkv.reshape(B, T, 3, self.n_heads, self.head_dim)
         q, k, v = qkv[:, :, 0], qkv[:, :, 1], qkv[:, :, 2]
-        q = q.transpose(1, 2)
-        k = k.transpose(1, 2)
-        v = v.transpose(1, 2)
+        q, k, v = q.transpose(1, 2), k.transpose(1, 2), v.transpose(1, 2)
         scale = math.sqrt(self.head_dim)
         attn = torch.matmul(q, k.transpose(-2, -1)) / scale
         mask = torch.triu(torch.ones(T, T, device=x.device) * float('-inf'), diagonal=1)
         attn = attn + mask.unsqueeze(0)
         attn = F.softmax(attn, dim=-1)
-        out = torch.matmul(attn, v)
-        out = out.transpose(1, 2).reshape(B, T, D)
+        out = torch.matmul(attn, v).transpose(1, 2).reshape(B, T, D)
         out = self.proj(out)
         x = x + self.dropout(out)
-
-        # Adaptive FFN with gating
         gate = torch.sigmoid(self.adapt_gate(self.norm2(x)))
-        ffn_out = self.ffn(self.norm2(x))
-        x = x + gate * self.dropout(ffn_out)
-
+        x = x + gate * self.dropout(self.ffn(self.norm2(x)))
         return x
 
 # =============================================================================
-# 5. FSI_ECHO MODEL — Morphing Code Swarm
+# 5. FSI_ECHO MODEL
 # =============================================================================
 class FSIEchoModel(nn.Module):
-    """
-    FSI_ECHO: Morphing Code Swarm
-    - Morph Embedding: tokens transform based on context
-    - Nanobot Swarm: tiny specialists with multiple operational modes
-    - Assembly Blocks: combined processing for deep reasoning
-    - Dual Output: generation + self-verification
-    """
     def __init__(self, vocab_size: int = 4096, d_model: int = 192,
                  n_swarm_layers: int = 3, n_assembly_layers: int = 3,
                  n_nanobots: int = 512):
         super().__init__()
         self.vocab_size = vocab_size
         self.d_model = d_model
-
         self.morph_embed = MorphEmbedding(vocab_size, d_model)
-
         self.swarm_layers = nn.ModuleList([
             NanobotSwarm(d_model, n_nanobots) for _ in range(n_swarm_layers)
         ])
-
         self.assembly_layers = nn.ModuleList([
             AssemblyBlock(d_model) for _ in range(n_assembly_layers)
         ])
-
         self.norm = nn.LayerNorm(d_model)
-
-        # Self-verification head — predicts confidence per token
         self.verify = nn.Sequential(
-            nn.Linear(d_model, d_model // 2), nn.GELU(),
-            nn.Linear(d_model // 2, 1),
+            nn.Linear(d_model, d_model // 2), nn.GELU(), nn.Linear(d_model // 2, 1),
         )
-
         self.lm_head = nn.Linear(d_model, vocab_size, bias=False)
         self.lm_head.weight = self.morph_embed.base_embed.weight
-
         self._init_weights()
 
     def _init_weights(self):
@@ -313,12 +246,12 @@ class FSIEchoModel(nn.Module):
         confidence = torch.sigmoid(self.verify(x)).squeeze(-1)
         loss = None
         if targets is not None:
-            loss = F.cross_entropy(logits.view(-1, self.vocab_size), targets.view(-1))
+            loss = F.cross_entropy(logits.view(-1, self.vocab_size), targets.view(-1), ignore_index=0)
         return {'logits': logits, 'confidence': confidence, 'loss': loss}
 
     @torch.no_grad()
     def generate(self, tokenizer, prompt: str, max_tokens: int = 512,
-                 temperature: float = 0.7, top_k: int = 30, top_p: float = 0.9) -> Dict:
+                 temperature: float = 0.3, top_k: int = 5, top_p: float = 0.9) -> Dict:
         self.eval()
         device = next(self.parameters()).device
         toks = torch.tensor([tokenizer.encode(prompt)], dtype=torch.long, device=device)
@@ -336,12 +269,14 @@ class FSIEchoModel(nn.Module):
                 rm = cum > top_p
                 rm[1:] = rm[:-1].clone()
                 rm[0] = False
-                logits[rm] = float('-inf')
+                logits[sorted_idx[rm]] = float('-inf')
             logits = torch.nan_to_num(logits, nan=-100.0, posinf=100.0, neginf=-100.0)
-            probs = F.softmax(logits, dim=-1)
-            probs = torch.clamp(probs, min=1e-10)
-            probs = probs / probs.sum()
-            nxt = torch.multinomial(probs, 1)
+            logits[0] = float('-inf')
+            for rid in range(300, logits.size(-1)):
+                logits[rid] = float('-inf')
+            if (logits > float(-1e9)).sum() == 0:
+                logits[tokenizer.eos_id] = 0.0
+            nxt = logits.argmax().unsqueeze(0)
             confs.append(out['confidence'][0, -1].item())
             if nxt.item() == tokenizer.eos_id:
                 break
@@ -355,54 +290,8 @@ class FSIEchoModel(nn.Module):
         return sum(p.numel() for p in self.parameters())
 
 # =============================================================================
-# 6. TRAINING
+# 6. TRAINER
 # =============================================================================
-def make_training_data() -> List[str]:
-    texts = []
-    gold_path = '/tmp/fsi_felon/gold_standard_corpus.jsonl'
-    if os.path.exists(gold_path):
-        with open(gold_path) as f:
-            for line in f:
-                try:
-                    d = json.loads(line)
-                    for k in ['text', 'code', 'response', 'content', 'output']:
-                        if d.get(k) and len(d[k]) > 30:
-                            texts.append(d[k])
-                            break
-                except: pass
-    # Synthetic code examples
-    examples = [
-        ("sort", "def sort_list(lst):\n    return sorted(lst)"),
-        ("max", "def max_value(lst):\n    return max(lst) if lst else None"),
-        ("reverse string", "def reverse(s):\n    return s[::-1]"),
-        ("palindrome", "def is_palindrome(s):\n    s = s.lower().replace(' ', '')\n    return s == s[::-1]"),
-        ("prime check", "def is_prime(n):\n    if n < 2: return False\n    for i in range(2, int(n**0.5)+1):\n        if n % i == 0: return False\n    return True"),
-        ("fibonacci", "def fib(n):\n    a, b = 0, 1\n    for _ in range(n):\n        yield a\n        a, b = b, a + b"),
-        ("binary search", "def binary_search(arr, target):\n    l, r = 0, len(arr)-1\n    while l <= r:\n        m = (l+r)//2\n        if arr[m] == target: return m\n        elif arr[m] < target: l = m+1\n        else: r = m-1\n    return -1"),
-        ("stack class", "class Stack:\n    def __init__(self):\n        self._items = []\n    def push(self, item):\n        self._items.append(item)\n    def pop(self):\n        return self._items.pop() if self._items else None\n    def peek(self):\n        return self._items[-1] if self._items else None\n    @property\n    def is_empty(self):\n        return len(self._items) == 0"),
-        ("cache decorator", "def cache(func):\n    _cache = {}\n    def wrapper(*args):\n        if args not in _cache:\n            _cache[args] = func(*args)\n        return _cache[args]\n    return wrapper"),
-        ("flatten", "def flatten(lst):\n    result = []\n    for item in lst:\n        if isinstance(item, list):\n            result.extend(flatten(item))\n        else:\n            result.append(item)\n    return result"),
-        ("word count", "def word_count(text):\n    from collections import Counter\n    return Counter(text.lower().split())"),
-        ("class decorator", "def singleton(cls):\n    instances = {}\n    def get(*args, **kwargs):\n        if cls not in instances:\n            instances[cls] = cls(*args, **kwargs)\n        return instances[cls]\n    return get"),
-        ("validate email", "def is_valid_email(email):\n    import re\n    return bool(re.match(r'^[\\w.-]+@[\\w.-]+\\.\\w+$', email))"),
-        ("merge dicts", "def merge(a, b):\n    c = a.copy()\n    c.update(b)\n    return c"),
-        ("chunk list", "def chunk(lst, n):\n    return [lst[i:i+n] for i in range(0, len(lst), n)]"),
-        ("factorial", "def factorial(n):\n    return 1 if n <= 1 else n * factorial(n-1)"),
-    ]
-    for desc, code in examples:
-        texts.append(f"Write a function to {desc}:\n```python\n{code}\n```")
-    # Bug-fix examples
-    bug_fixes = [
-        ("use == not =", "if x = 5:", "if x == 5:"),
-        ("missing return", "def add(a, b): a + b", "def add(a, b): return a + b"),
-        ("off by one", "for i in range(len(lst)):", "for i in range(len(lst) - 1):"),
-        ("bare except", "try: x = 1/y\nexcept: pass", "try: x = 1/y\nexcept ZeroDivisionError: pass"),
-        ("mutable default", "def f(x=[]): x.append(1); return x", "def f(x=None): x = x or []; x.append(1); return x"),
-    ]
-    for desc, buggy, fixed in bug_fixes:
-        texts.append(f"Fix this bug ({desc}):\n```python\n{buggy}\n```\nFixed:\n```python\n{fixed}\n```")
-    return texts
-
 class Trainer:
     def __init__(self, model: FSIEchoModel, tokenizer: CodeTokenizer, lr: float = 3e-4):
         self.model = model
@@ -413,8 +302,8 @@ class Trainer:
     def step(self, texts: List[str], batch_size: int = 2, device: str = 'cpu') -> float:
         self.model.train()
         batch = random.sample(texts, min(batch_size, len(texts)))
-        max_len = 0
         encoded = []
+        max_len = 0
         for t in batch:
             toks = self.tokenizer.encode(t)
             if 5 < len(toks) <= 2048:
@@ -423,11 +312,11 @@ class Trainer:
         if not encoded:
             return 0.0
         padded = torch.zeros(len(encoded), max_len, dtype=torch.long)
-        targets = torch.full((len(encoded), max_len), self.tokenizer.pad_id, dtype=torch.long)
+        targets = torch.full((len(encoded), max_len), 0, dtype=torch.long)
         for i, toks in enumerate(encoded):
             padded[i, :len(toks)] = torch.tensor(toks)
             targets[i, :len(toks)-1] = torch.tensor(toks[1:])
-            targets[i, len(toks)-1] = self.tokenizer.eos_id
+            targets[i, len(toks)-1] = 1
         padded, targets = padded.to(device), targets.to(device)
         out = self.model(padded, targets)
         self.optimizer.zero_grad()
@@ -446,7 +335,6 @@ class Trainer:
                        'n_swarm': len(self.model.swarm_layers), 'n_assembly': len(self.model.assembly_layers),
                        'n_nanobots': self.model.swarm_layers[0].n_nanobots if self.model.swarm_layers else 512},
         }, path)
-        print(f"Saved {path}")
 
     @classmethod
     def load(cls, path: str, device: str = 'cpu') -> 'Trainer':
@@ -463,11 +351,10 @@ class Trainer:
         if 'optimizer' in data:
             t.optimizer.load_state_dict(data['optimizer'])
         model.to(device)
-        print(f"Loaded {path} ({model.param_count():,} params)")
         return t
 
 # =============================================================================
-# 7. CLOSED-LOOP DEBUG SYSTEM
+# 7. CLOSED-LOOP DEBUG
 # =============================================================================
 class CodeVerifier:
     @staticmethod
@@ -477,20 +364,14 @@ class CodeVerifier:
             return True, ""
         except SyntaxError as e:
             return False, f"Line {e.lineno}: {e.msg}"
-
     @staticmethod
     def find_issues(code: str) -> List[str]:
         issues = []
         for i, line in enumerate(code.split('\n'), 1):
             s = line.strip()
-            if '== True' in s or '== False' in s:
-                issues.append(f"L{i}: Use 'if x:' instead of 'if x == True/False'")
-            if s.startswith('if ') and ':' not in s:
-                issues.append(f"L{i}: Missing colon")
             if s == 'except:':
                 issues.append(f"L{i}: Bare except — specify exception")
         return issues
-
     def verify(self, code: str) -> Dict:
         ok, err = self.check_syntax(code)
         issues = self.find_issues(code)
@@ -502,19 +383,16 @@ class ClosedLoopDebugger:
         self.tokenizer = tokenizer
         self.max_iters = max_iters
         self.verifier = CodeVerifier()
-
-    def debug(self, code: str, requirement: str = "") -> Dict:
+    def debug(self, code: str, requirement: str = "", max_iterations: int = None) -> Dict:
+        iters = max_iterations or self.max_iters
         result = self._extract_code(code)
         if not result:
             return {'code': code, 'error': 'Could not parse code', 'iterations': 0, 'confidence': 0.0}
         buggy = result
-        prompt = f"Fix this code:\n```python\n{buggy}\n```\n"
-        if requirement:
-            prompt += f"Requirement: {requirement}\n"
-        prompt += "Fixed:\n```python\n"
+        prompt = f"Fix this code:\n```python\n{buggy}\n```\nFixed:\n```python\n"
         best_code, best_v = buggy, self.verifier.verify(buggy)
-        for i in range(self.max_iters):
-            gen = self.model.generate(self.tokenizer, prompt, max_tokens=512, temperature=0.5, top_k=20)
+        for i in range(iters):
+            gen = self.model.generate(self.tokenizer, prompt, max_tokens=256, temperature=0.3, top_k=5)
             fixed = self._extract_code(gen['generated'])
             if not fixed:
                 prompt += "\n```python\n"
@@ -525,13 +403,12 @@ class ClosedLoopDebugger:
             if len(v['issues']) < len(best_v['issues']):
                 best_code, best_v = fixed, v
             if v['issues']:
-                prompt += f"\n# Issues: {'; '.join(v['issues'])}\n# Fix them:\n```python\n"
+                prompt += f"\nIssues: {'; '.join(v['issues'])}\nFixed:\n```python\n"
             elif not v['syntax_ok']:
-                prompt += f"\n# {v['error']}\n# Fix it:\n```python\n"
+                prompt += f"\n{v['error']}\nFixed:\n```python\n"
             else:
                 break
-        return {'code': best_code, 'verification': best_v, 'iterations': self.max_iters, 'confidence': 0.0}
-
+        return {'code': best_code, 'verification': best_v, 'iterations': iters, 'confidence': 0.0}
     def _extract_code(self, text: str) -> str:
         m = re.search(r'```(?:python)?\n(.*?)```', text, re.DOTALL)
         if m: return m.group(1).strip()
@@ -548,11 +425,10 @@ class ClosedLoopDebugger:
 # =============================================================================
 def export_gguf(model: FSIEchoModel, tokenizer: CodeTokenizer, path: str):
     sd = model.state_dict()
-    magic, version = b'GGUF', 3
     keys = sorted(sd.keys())
     meta = {
         'general.name': 'FSI_ECHO', 'general.architecture': 'fsi_echo',
-        'general.description': 'Morphing Code Swarm - novel code transformer',
+        'general.description': 'Morphing Code Swarm',
         'general.file_type': 0, 'general.vocab_size': model.vocab_size,
         'general.context_length': 2048, 'general.parameter_count': model.param_count(),
         'fsi_echo.block_count': len(model.swarm_layers) + len(model.assembly_layers),
@@ -562,7 +438,7 @@ def export_gguf(model: FSIEchoModel, tokenizer: CodeTokenizer, path: str):
         'fsi_echo.nanobot_count': model.swarm_layers[0].n_nanobots if model.swarm_layers else 512,
     }
     with open(path, 'wb') as f:
-        f.write(magic + struct.pack('<I', version) + struct.pack('<Q', len(keys)) + struct.pack('<Q', len(meta)))
+        f.write(b'GGUF' + struct.pack('<I', 3) + struct.pack('<Q', len(keys)) + struct.pack('<Q', len(meta)))
         for k, v in meta.items():
             f.write(struct.pack('<I', len(k)) + k.encode())
             if isinstance(v, str):
@@ -581,133 +457,30 @@ def export_gguf(model: FSIEchoModel, tokenizer: CodeTokenizer, path: str):
             offset += sd[name].numel() * 4
         for name in keys:
             f.write(sd[name].float().numpy().tobytes())
-    sz = os.path.getsize(path)
-    print(f"GGUF: {path} ({sz/1e6:.1f}MB)")
 
 # =============================================================================
-# 9. BENCHMARKS
-# =============================================================================
-def benchmark(model: FSIEchoModel, tokenizer: CodeTokenizer) -> Dict:
-    cases = {
-        'code_gen': [
-            ("reverse string", "def reverse(s):"),
-            ("find max", "def find_max(lst):"),
-            ("prime check", "def is_prime(n):"),
-            ("binary search", "def binary_search(arr, target):"),
-            ("word count", "def word_count(text):"),
-            ("fibonacci", "def fib(n):"),
-            ("stack class", "class Stack:"),
-            ("merge dicts", "def merge(a, b):"),
-        ],
-        'bug_fix': [
-            ("fix ==", "if x == 5:"),
-            ("fix return", "return a + b"),
-        ],
-    }
-    results = {}
-    model.eval()
-    for cat, items in cases.items():
-        passed = 0
-        for name, expected in items:
-            prompt = f"Write a function to {name}:\n```python\n"
-            r = model.generate(tokenizer, prompt, max_tokens=128, temperature=0.3, top_k=10)
-            ok = expected.lower() in r['generated'].lower()
-            if ok: passed += 1
-            results[f"{cat}/{name}"] = {'pass': ok, 'conf': r['confidence']}
-        results[f"{cat}_acc"] = passed / max(len(items), 1)
-    total_pass = sum(1 for k, v in results.items() if isinstance(v, dict) and v.get('pass'))
-    total = sum(1 for k, v in results.items() if isinstance(v, dict) and 'pass' in v)
-    results['overall_acc'] = total_pass / max(total, 1)
-    results['params'] = model.param_count()
-    results['model_mb_fp32'] = model.param_count() * 4 / 1e6
-    results['model_mb_q4'] = model.param_count() * 0.5 / 1e6
-    return results
-
-# =============================================================================
-# 10. MAIN
+# 9. MAIN
 # =============================================================================
 if __name__ == '__main__':
     import argparse
-    p = argparse.ArgumentParser(description='FSI_ECHO - Morphing Code Swarm')
+    p = argparse.ArgumentParser(description='FSI_ECHO')
     p.add_argument('--train', action='store_true')
-    p.add_argument('--bench', action='store_true')
+    p.add_argument('--gen', type=str, help='Generate from prompt')
     p.add_argument('--gguf', type=str, help='Export to GGUF')
     p.add_argument('--load', type=str, help='Load checkpoint')
     p.add_argument('--steps', type=int, default=5000)
-    p.add_argument('--interactive', action='store_true')
-    p.add_argument('--debug', type=str, help='Debug code string or file')
     args = p.parse_args()
-
-    device = 'cuda' if torch.cuda.is_available() else 'cpu'
-    print(f"FSI_ECHO on {device}")
-
+    device = 'cpu'
     if args.load and os.path.exists(args.load):
         trainer = Trainer.load(args.load, device)
     else:
         model = FSIEchoModel()
         model.to(device)
-        trainer = Trainer(model, CodeTokenizer())
+        tok = CodeTokenizer()
         print(f"New model: {model.param_count():,} params")
-
-    if args.train:
-        texts = make_training_data()
-        print(f"Training data: {len(texts)} texts")
-        os.makedirs('/tmp/fsi_echo/checkpoints', exist_ok=True)
-        start = time.time()
-        losses = []
-        for step in range(1, args.steps + 1):
-            loss = trainer.step(texts, batch_size=2, device=device)
-            losses.append(loss)
-            if step % 50 == 0:
-                avg = sum(losses[-50:]) / max(len(losses[-50:]), 1)
-                print(f"Step {step:>6}/{args.steps} | loss {avg:.4f} | {time.time()-start:.0f}s")
-            if step % 500 == 0:
-                trainer.save(f'/tmp/fsi_echo/checkpoints/step_{step}.pt')
-                print(json.dumps(benchmark(trainer.model, trainer.tokenizer), indent=2))
-        trainer.save('/tmp/fsi_echo/checkpoints/final.pt')
-        print(f"Done: {args.steps} steps in {time.time()-start:.0f}s")
-
-    if args.bench:
-        r = benchmark(trainer.model, trainer.tokenizer)
-        print("\n=== BENCHMARK ===")
-        for k, v in r.items():
-            if isinstance(v, dict):
-                print(f"  {k}: {'PASS' if v.get('pass') else 'FAIL'} (conf={v.get('conf',0):.2f})")
-            else:
-                print(f"  {k}: {v}")
-        with open('/tmp/fsi_echo/bench.json', 'w') as f:
-            json.dump(r, f, indent=2)
-
+        trainer = Trainer(model, tok)
+    if args.gen:
+        r = trainer.model.generate(trainer.tokenizer, args.gen, max_tokens=256)
+        print(r['generated'])
     if args.gguf:
         export_gguf(trainer.model, trainer.tokenizer, args.gguf)
-
-    if args.debug:
-        code = args.debug
-        if os.path.exists(code):
-            with open(code) as f:
-                code = f.read()
-        d = ClosedLoopDebugger(trainer.model, trainer.tokenizer)
-        r = d.debug(code)
-        print(f"\n{'='*40}\nResult ({r['iterations']} iters):\n{r['code']}")
-        if not r['verification']['valid']:
-            if r['verification']['error']: print(f"Syntax: {r['verification']['error']}")
-            for issue in r['verification']['issues']: print(f"Issue: {issue}")
-        else:
-            print("All checks passed!")
-        print(f"Confidence: {r['confidence']:.2f}")
-
-    if args.interactive:
-        d = ClosedLoopDebugger(trainer.model, trainer.tokenizer)
-        print("\nFSI_ECHO Interactive — commands: gen <prompt>, debug <code>, exit")
-        while True:
-            try:
-                cmd = input('\n> ').strip()
-                if cmd == 'exit': break
-                if cmd.startswith('debug '):
-                    r = d.debug(cmd[6:])
-                    print(f"\n{r['code']}\n[iters={r['iterations']}, conf={r['confidence']:.2f}]")
-                else:
-                    r = trainer.model.generate(trainer.tokenizer, cmd, max_tokens=256)
-                    print(f"\n{r['generated']}\n[conf={r['confidence']:.2f}]")
-            except (KeyboardInterrupt, EOFError):
-                break