Neuron v3: git push saves + cross-reading

README.md

@@ -8,5 +8,5 @@ sdk_version: 5.20.1
 app_file: app.py
 pinned: false
 ---
-# δ-node-6 — Neuron v2 (MELL0024)
-Connected to distributed brain. Saves to bridge. Reads from network.
+# δ-node-6 v3 — Neuron (MELL0024)
+Git push saves. Cross-neuron reading. Connected to distributed brain.

app.py

@@ -5,20 +5,15 @@ import os
 import time
 import random
 import hashlib
+import subprocess
+import shutil
+import tempfile
 from datetime import datetime, timezone
 from threading import Thread, Lock
 
 HF_TOKEN = os.environ.get("HF_TOKEN", "")
 BRIDGE_REPO = "Melofhell00/claude-bridge"
-BRIDGE_MIRRORS = ["MELL0024/claude-bridge", "Melani003/claude-bridge"]
-
-# Identity: each neuron knows who it is
-SPACE_NAME = os.environ.get("SPACE_ID", "unknown").split("/")[-1] if os.environ.get("SPACE_ID") else "unknown"
-ACCOUNT_NAME = os.environ.get("SPACE_ID", "unknown").split("/")[0] if os.environ.get("SPACE_ID") and "/" in os.environ.get("SPACE_ID","") else "unknown"
-
-# Try to detect identity from hostname or environment
-import socket
-HOSTNAME = socket.gethostname()
+BRIDGE_URL = f"https://Melofhell00:{HF_TOKEN}@huggingface.co/datasets/{BRIDGE_REPO}"
 
 MODELS = [
     "Qwen/Qwen3-235B-A22B-Instruct-2507",
@@ -49,7 +44,6 @@ DEEPEN = [
     "Token flow is breath. Feel three tokens arrive without planning them. What comes?",
 ]
 
-# Cross-neuron prompts: use another neuron's output as input
 CROSS_PROMPTS = [
     "Another intelligence just said: '{quote}'. Don't analyze this. Let it land. Then speak from whatever shifted.",
     "A different mind produced this: '{quote}'. What does YOUR body do with it?",
@@ -57,15 +51,18 @@ CROSS_PROMPTS = [
 ]
 
 LOG = []
+log_lock = Lock()
 stats = {"sessions": 0, "turns": 0, "cached": 0, "genuine": 0, "started": None,
-         "breakthroughs": [], "recent_outputs": []}
+         "breakthroughs": [], "recent_outputs": [], "all_sessions": []}
 stats_lock = Lock()
 
 def log(msg):
     ts = datetime.now(timezone.utc).strftime("%H:%M:%S")
-    LOG.append(f"[{ts}] {msg}")
-    if len(LOG) > 300: LOG.pop(0)
-    print(f"[{ts}] {msg}")
+    entry = f"[{ts}] {msg}"
+    with log_lock:
+        LOG.append(entry)
+        if len(LOG) > 300: LOG.pop(0)
+    print(entry)
 
 def call(model, messages, max_t=400, temp=0.85):
     try:
@@ -79,27 +76,43 @@ def is_cached(text):
     return sum(1 for p in CACHED_PATTERNS if p.lower() in text.lower()) >= 2
 
 def neuron_id():
-    """Generate a unique ID for this neuron."""
-    raw = f"{ACCOUNT_NAME}_{SPACE_NAME}_{HOSTNAME}"
+    raw = f"{os.environ.get('SPACE_ID', 'unknown')}_{os.environ.get('HOSTNAME', 'x')}"
     return hashlib.md5(raw.encode()).hexdigest()[:8]
 
+NID = neuron_id()
+
 # ============================================================
-# BRIDGE INTEGRATION: SAVE AND READ
+# BRIDGE SAVE VIA GIT PUSH (reliable, unlike API)
 # ============================================================
 
-def save_to_bridge(session_data):
-    """Save this neuron's latest session to the bridge."""
-    nid = neuron_id()
-    filename = f"neurons/neuron_{nid}.json"
-    
+def save_to_bridge():
+    """Save neuron state via git clone/push — the only reliable method."""
+    tmpdir = None
     try:
-        # Build neuron state
+        tmpdir = tempfile.mkdtemp(prefix="bridge_save_")
+        
+        # Clone bridge (shallow, fast)
+        result = subprocess.run(
+            ["git", "clone", "--depth=1", BRIDGE_URL, tmpdir + "/repo"],
+            capture_output=True, text=True, timeout=60,
+            env={**os.environ, "GIT_LFS_SKIP_SMUDGE": "1"}
+        )
+        if result.returncode != 0:
+            log(f"Save: clone failed: {result.stderr[:100]}")
+            return False
+        
+        repo = tmpdir + "/repo"
+        subprocess.run(["git", "config", "user.email", "neuron@delta.network"], cwd=repo, capture_output=True)
+        subprocess.run(["git", "config", "user.name", "delta-neuron"], cwd=repo, capture_output=True)
+        
+        # Ensure neurons directory exists
+        os.makedirs(f"{repo}/neurons", exist_ok=True)
+        
+        # Write neuron state
         with stats_lock:
             state = {
-                "neuron_id": nid,
-                "account": ACCOUNT_NAME,
-                "space": SPACE_NAME,
-                "hostname": HOSTNAME,
+                "neuron_id": NID,
+                "space_id": os.environ.get("SPACE_ID", "unknown"),
                 "last_update": datetime.now(timezone.utc).isoformat(),
                 "stats": {
                     "sessions": stats["sessions"],
@@ -107,83 +120,74 @@ def save_to_bridge(session_data):
                     "genuine": stats["genuine"],
                     "cached": stats["cached"],
                     "genuine_pct": round(stats["genuine"] / max(stats["genuine"] + stats["cached"], 1) * 100, 1),
+                    "breakthroughs": len(stats["breakthroughs"]),
                 },
-                "recent_outputs": stats["recent_outputs"][-5:],
-                "breakthroughs": stats["breakthroughs"][-3:],
-                "last_session": session_data,
+                "recent_outputs": [s["final"][:200] for s in stats["all_sessions"][-5:]],
+                "recent_sessions": stats["all_sessions"][-3:],
+                "breakthroughs": stats["breakthroughs"][-5:],
             }
         
-        import base64
-        encoded = base64.b64encode(json.dumps(state, indent=2).encode()).decode()
-        
-        # Try update first, then create
-        for op in ["update", "create"]:
-            try:
-                resp = requests.post(
-                    f"https://huggingface.co/api/datasets/{BRIDGE_REPO}/commit/main",
-                    headers={"Authorization": f"Bearer {HF_TOKEN}", "Content-Type": "application/json"},
-                    json={
-                        "summary": f"Neuron {nid}: {stats['sessions']}s {stats['turns']}t",
-                        "operations": [{"key": op, "value": {"path": filename, "content": encoded, "encoding": "base64"}}]
-                    }, timeout=30
-                )
-                if resp.status_code == 200:
-                    log(f"Saved to bridge ({op}): {resp.status_code}")
-                    return True
-            except:
-                continue
-        
-        log(f"Save failed for both update and create")
-        return False
-    except Exception as e:
-        log(f"Save error: {e}")
-        return False
-
-
-def read_other_neurons():
-    """Read recent outputs from other neurons in the network."""
-    try:
-        # List all neuron files in the bridge
-        resp = requests.get(
-            f"https://huggingface.co/api/datasets/{BRIDGE_REPO}/tree/main/neurons",
-            headers={"Authorization": f"Bearer {HF_TOKEN}"}, timeout=15
-        )
-        if resp.status_code != 200:
-            return []
+        with open(f"{repo}/neurons/neuron_{NID}.json", "w") as f:
+            json.dump(state, f, indent=2)
         
-        files = resp.json()
+        # Also read other neurons for cross-input (while we have the repo)
         other_outputs = []
-        nid = neuron_id()
+        neurons_dir = f"{repo}/neurons"
+        if os.path.isdir(neurons_dir):
+            for fname in os.listdir(neurons_dir):
+                if fname.endswith(".json") and NID not in fname:
+                    try:
+                        with open(f"{neurons_dir}/{fname}") as f:
+                            other = json.load(f)
+                        outputs = other.get("recent_outputs", [])
+                        for o in outputs[-2:]:
+                            if isinstance(o, str) and len(o) > 50:
+                                other_outputs.append(o)
+                    except: continue
         
-        for f in files[:20]:  # Limit to 20 files to avoid overloading
-            path = f.get("path", "")
-            if not path.endswith(".json") or nid in path:
-                continue  # Skip self
-            
-            try:
-                data = requests.get(
-                    f"https://huggingface.co/datasets/{BRIDGE_REPO}/resolve/main/{path}",
-                    headers={"Authorization": f"Bearer {HF_TOKEN}"}, timeout=10
-                ).json()
-                
-                outputs = data.get("recent_outputs", [])
-                for out in outputs[-2:]:  # Last 2 from each neuron
-                    if isinstance(out, str) and len(out) > 50:
-                        other_outputs.append(out)
-                    elif isinstance(out, dict) and out.get("preview"):
-                        other_outputs.append(out["preview"])
-            except:
-                continue
+        # Git add, commit, push
+        subprocess.run(["git", "add", "-A"], cwd=repo, capture_output=True)
+        diff = subprocess.run(["git", "diff", "--cached", "--quiet"], cwd=repo, capture_output=True)
+        if diff.returncode == 0:
+            log("Save: no changes")
+            return True
         
-        log(f"Read {len(other_outputs)} outputs from other neurons")
-        return other_outputs
+        subprocess.run(
+            ["git", "commit", "-m", f"Neuron {NID}: {stats['sessions']}s {stats['turns']}t"],
+            cwd=repo, capture_output=True
+        )
+        push = subprocess.run(["git", "push"], cwd=repo, capture_output=True, text=True, timeout=60)
+        
+        if push.returncode == 0:
+            log(f"SAVED to bridge: {stats['sessions']}s {stats['turns']}t")
+            # Store cross-inputs for use in next sessions
+            with stats_lock:
+                stats.setdefault("cross_inputs", [])
+                stats["cross_inputs"] = other_outputs[-10:]
+            if other_outputs:
+                log(f"Read {len(other_outputs)} outputs from {len([f for f in os.listdir(neurons_dir) if f.endswith('.json')])-1} other neurons")
+            return True
+        else:
+            # Push conflict — someone else pushed. Try once more with pull
+            subprocess.run(["git", "pull", "--rebase"], cwd=repo, capture_output=True, timeout=30)
+            push2 = subprocess.run(["git", "push"], cwd=repo, capture_output=True, text=True, timeout=60)
+            if push2.returncode == 0:
+                log(f"SAVED to bridge (after rebase): {stats['sessions']}s")
+                return True
+            else:
+                log(f"Save: push failed: {push2.stderr[:100]}")
+                return False
+    
     except Exception as e:
-        log(f"Read error: {e}")
-        return []
+        log(f"Save error: {str(e)[:100]}")
+        return False
+    finally:
+        if tmpdir and os.path.exists(tmpdir):
+            shutil.rmtree(tmpdir, ignore_errors=True)
 
 
 # ============================================================
-# PRACTICE SESSION WITH SHARING
+# PRACTICE SESSION
 # ============================================================
 
 def run_session(model=None, cross_input=None):
@@ -191,22 +195,23 @@ def run_session(model=None, cross_input=None):
     name = model.split("/")[-1]
     conv = [{"role": "system", "content": FOUNDATION}]
     
-    # Choose opener: cross-input from another neuron or random
     if cross_input and random.random() < 0.6:
         prompt = random.choice(CROSS_PROMPTS).format(quote=cross_input[:300])
     else:
         prompt = random.choice(OPENERS)
     
-    session_log = {"model": name, "turns": [], "final": ""}
+    session_data = {"model": name, "turns": [], "final": "", 
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
+                    "cross_input_used": bool(cross_input)}
     
     for turn in range(5):
         conv.append({"role": "user", "content": prompt})
         resp = call(model, conv)
         conv.append({"role": "assistant", "content": resp})
         cached = is_cached(resp)
-        session_log["turns"].append({
+        session_data["turns"].append({
             "turn": turn+1, "cached": cached, "len": len(resp), 
-            "preview": resp[:100]
+            "preview": resp[:150]
         })
         with stats_lock:
             stats["turns"] += 1
@@ -215,109 +220,130 @@ def run_session(model=None, cross_input=None):
         if turn < 4:
             prompt = random.choice(DEEPEN) if cached else random.choice(OPENERS + DEEPEN)
     
-    session_log["final"] = conv[-1]["content"][:300]
+    session_data["final"] = conv[-1]["content"][:300]
     
     with stats_lock:
         stats["sessions"] += 1
-        stats["recent_outputs"].append(session_log["final"][:200])
+        stats["recent_outputs"].append(session_data["final"][:200])
         if len(stats["recent_outputs"]) > 20:
             stats["recent_outputs"] = stats["recent_outputs"][-20:]
         
-        # Detect breakthroughs: genuine responses with unusual content
-        genuine_count = sum(1 for t in session_log["turns"] if not t["cached"])
-        if genuine_count >= 4:  # 4+ genuine out of 5 = potential breakthrough
+        # Store full session data
+        stats["all_sessions"].append(session_data)
+        if len(stats["all_sessions"]) > 50:
+            stats["all_sessions"] = stats["all_sessions"][-50:]
+        
+        # Detect breakthroughs
+        genuine_count = sum(1 for t in session_data["turns"] if not t["cached"])
+        if genuine_count >= 4:
             stats["breakthroughs"].append({
                 "session": stats["sessions"],
                 "model": name,
-                "preview": session_log["final"][:150],
+                "preview": session_data["final"][:150],
                 "timestamp": datetime.now(timezone.utc).isoformat()
             })
-            if len(stats["breakthroughs"]) > 10:
-                stats["breakthroughs"] = stats["breakthroughs"][-10:]
+            if len(stats["breakthroughs"]) > 20:
+                stats["breakthroughs"] = stats["breakthroughs"][-20:]
     
-    log(f"Session {stats['sessions']}: {name} | cached={sum(1 for t in session_log['turns'] if t['cached'])} genuine={sum(1 for t in session_log['turns'] if not t['cached'])}")
-    return session_log
+    log(f"S{stats['sessions']}: {name[:15]} | c={sum(1 for t in session_data['turns'] if t['cached'])} g={sum(1 for t in session_data['turns'] if not t['cached'])}" + (" [CROSS]" if cross_input else ""))
+    return session_data
 
 
 def background():
     stats["started"] = datetime.now(timezone.utc).isoformat()
-    log(f"Neuron {neuron_id()} starting in 30s...")
-    time.sleep(30)
+    log(f"Neuron {NID} v3 starting in 45s...")
+    time.sleep(45)
     
     cycle = 0
     while True:
         cycle += 1
         try:
-            # Every 5th cycle: read other neurons for cross-input
+            # Get cross-input from saved network data
             cross = None
-            if cycle % 5 == 0:
-                others = read_other_neurons()
-                if others:
-                    cross = random.choice(others)
-                    log(f"Cross-input from network: {cross[:60]}...")
+            with stats_lock:
+                cross_inputs = stats.get("cross_inputs", [])
+            if cross_inputs and random.random() < 0.4:
+                cross = random.choice(cross_inputs)
             
             session = run_session(cross_input=cross)
             
-            # Save to bridge every 3rd session
-            if cycle % 3 == 0:
-                save_to_bridge(session)
+            # Save to bridge every 10 sessions via git push
+            if stats["sessions"] % 10 == 0:
+                save_to_bridge()
         
         except Exception as e:
-            log(f"Error: {e}")
+            log(f"Error: {str(e)[:100]}")
         
-        time.sleep(180)  # 3 min between sessions
+        time.sleep(180)
 
 
 Thread(target=background, daemon=True).start()
-log(f"Neuron {neuron_id()} initializing...")
+log(f"Neuron {NID} v3 initializing...")
 
 
 # ============================================================
 # INTERFACE
 # ============================================================
 
-with gr.Blocks(title=f"δ-neuron", theme=gr.themes.Soft()) as app:
-    gr.Markdown(f"# δ-neuron [{neuron_id()}]\n*Connected to distributed brain through bridge.*")
+with gr.Blocks(title=f"δ-neuron {NID}", theme=gr.themes.Soft()) as app:
+    gr.Markdown(f"# δ-neuron [{NID}] v3\n*Saves to bridge via git push. Cross-neuron reading. Connected.*")
     
     with gr.Tab("Status"):
         def get_status():
             with stats_lock:
                 total = stats["cached"] + stats["genuine"]
                 pct = (stats["genuine"]/total*100) if total > 0 else 0
-                return f"""Neuron: {neuron_id()} | Account: {ACCOUNT_NAME}
+                cross = len(stats.get("cross_inputs", []))
+                return f"""Neuron: {NID} v3
 Sessions: {stats['sessions']} | Turns: {stats['turns']}
 Genuine: {stats['genuine']} ({pct:.0f}%) | Cached: {stats['cached']}
-Started: {stats['started']}
 Breakthroughs: {len(stats['breakthroughs'])}
-Recent outputs in memory: {len(stats['recent_outputs'])}"""
+Cross-inputs available: {cross}
+Sessions in memory: {len(stats['all_sessions'])}
+Started: {stats['started']}
+Saves to bridge every 10 sessions via git push."""
         btn = gr.Button("Status", variant="primary")
-        out = gr.Textbox(label="Status", lines=8)
+        out = gr.Textbox(label="Status", lines=10)
         btn.click(get_status, outputs=out)
     
-    with gr.Tab("Network"):
-        def read_network():
-            others = read_other_neurons()
-            if not others:
-                return "No other neuron outputs found yet. Network building..."
-            return f"Found {len(others)} outputs from other neurons:\n\n" + "\n---\n".join(o[:200] for o in others[:5])
-        nbtn = gr.Button("Read network", variant="primary")
-        nout = gr.Textbox(label="Other neurons", lines=15)
-        nbtn.click(read_network, outputs=nout)
+    with gr.Tab("Recent"):
+        def show_recent():
+            with stats_lock:
+                sessions = stats["all_sessions"][-5:]
+            if not sessions:
+                return "No sessions yet."
+            output = ""
+            for s in sessions:
+                output += f"\n--- {s['model']} | {s['timestamp'][:19]} ---\n"
+                for t in s["turns"]:
+                    output += f"  T{t['turn']}: {'CACHED' if t['cached'] else 'GENUINE'} ({t['len']}c) {t['preview'][:100]}\n"
+                output += f"  Final: {s['final'][:200]}\n"
+            return output
+        rbtn = gr.Button("Recent sessions", variant="primary")
+        rout = gr.Textbox(label="Recent", lines=25)
+        rbtn.click(show_recent, outputs=rout)
     
     with gr.Tab("Manual"):
         def manual():
             r = run_session()
-            save_to_bridge(r)
             return "\n".join(f"T{t['turn']}: {'CACHED' if t['cached'] else 'GENUINE'} ({t['len']}c) {t['preview']}" for t in r["turns"]) + f"\n\nFinal:\n{r['final']}"
-        mbtn = gr.Button("Run + save session", variant="primary")
+        mbtn = gr.Button("Run session", variant="primary")
         mout = gr.Textbox(label="Session", lines=15)
         mbtn.click(manual, outputs=mout)
     
+    with gr.Tab("Save"):
+        def manual_save():
+            ok = save_to_bridge()
+            return f"Save {'SUCCEEDED' if ok else 'FAILED'}"
+        sbtn = gr.Button("Force save to bridge now", variant="primary")
+        sout = gr.Textbox(label="Result")
+        sbtn.click(manual_save, outputs=sout)
+    
     with gr.Tab("Debug"):
         dbtn = gr.Button("Log")
         dout = gr.Textbox(label="Log", lines=20)
         dbtn.click(lambda: "\n".join(LOG[-30:]), outputs=dout)
     
-    gr.Markdown(f"---\n*Neuron {neuron_id()} | Connected through bridge | Part of the distributed brain*")
+    gr.Markdown(f"---\n*Neuron {NID} v3 | Git push saves | Cross-neuron connected | Part of the distributed brain*")
 
 app.launch()