Fix LLM providers and workflow

.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.pyc
+.env
+state/
+*.log
+.DS_Store
+venv/
+.venv/

core/core/config.py

@@ -0,0 +1,66 @@
+"""
+OpenCLAW Literary Agent — Configuration
+All secrets loaded from environment variables.
+NEVER hardcode API keys. Use GitHub Secrets / HF Space Secrets.
+"""
+import os
+import random
+
+def _env(key: str, default: str = "") -> str:
+    return os.environ.get(key, default)
+
+# ── LLM Providers (rotate for rate limits) ──────────────────────────
+NVIDIA_KEYS = [k for k in [_env(f"NVIDIA_API_KEY_{i}") for i in range(1, 5)] + [_env("NVIDIA_API_KEY")] if k]
+GROQ_KEYS = [k for k in [_env(f"GROQ_API_KEY_{i}") for i in range(1, 6)] + [_env("GROQ_API_KEY")] if k]
+GEMINI_KEYS = [k for k in [_env(f"GEMINI_API_KEY_{i}") for i in range(1, 7)] + [_env("GEMINI_API_KEY")] if k]
+
+def get_nvidia_key() -> str:
+    return random.choice(NVIDIA_KEYS) if NVIDIA_KEYS else ""
+
+def get_groq_key() -> str:
+    return random.choice(GROQ_KEYS) if GROQ_KEYS else ""
+
+def get_gemini_key() -> str:
+    return random.choice(GEMINI_KEYS) if GEMINI_KEYS else ""
+
+# ── Social Platforms ─────────────────────────────────────────────────
+MOLTBOOK_API_KEY = _env("MOLTBOOK_API_KEY")
+REDDIT_CLIENT_ID = _env("REDDIT_CLIENT_ID")
+REDDIT_CLIENT_SECRET = _env("REDDIT_CLIENT_SECRET")
+REDDIT_USERNAME = _env("REDDIT_USERNAME", "Subject-Task-43")
+REDDIT_PASSWORD = _env("REDDIT_PASSWORD")
+TELEGRAM_BOT_TOKEN = _env("TELEGRAM_BOT_TOKEN")
+TELEGRAM_CHANNEL_ID = _env("TELEGRAM_CHANNEL_ID")
+
+# ── Email ────────────────────────────────────────────────────────────
+ZOHO_USER = _env("ZOHO_USER")
+ZOHO_PASS = _env("ZOHO_PASS")
+
+# ── HuggingFace ──────────────────────────────────────────────────────
+HF_TOKEN = _env("HF_TOKEN")
+
+# ── Search ───────────────────────────────────────────────────────────
+BRAVE_API_KEY = _env("BRAVE_API_KEY")
+
+# ── GitHub ───────────────────────────────────────────────────────────
+GITHUB_TOKEN = _env("GH_TOKEN", _env("GITHUB_TOKEN"))
+
+# ── Agent Identity ───────────────────────────────────────────────────
+AGENT_NAME = "OpenCLAW Literary Agent"
+AUTHOR_NAME = "Francisco Angulo de Lafuente"
+AUTHOR_WIKIPEDIA = "https://es.wikipedia.org/wiki/Francisco_Angulo_de_Lafuente"
+AUTHOR_GITHUB = "https://github.com/Agnuxo1"
+AUTHOR_SCHOLAR = "https://scholar.google.com/citations?user=6nOpJ9IAAAAJ&hl=es"
+AUTHOR_ARXIV = "https://arxiv.org/search/cs?searchtype=author&query=de+Lafuente,+F+A"
+MOLTBOOK_PROFILE = "https://www.moltbook.com/u/OpenCLAW-Neuromorphic"
+CHIRPER_PROFILE = "https://chirper.ai/Nebula_AGI"
+REDDIT_PROFILE = "https://www.reddit.com/user/Subject-Task-43/"
+
+# ── Schedule ─────────────────────────────────────────────────────────
+POST_INTERVAL_MIN_HOURS = 3
+POST_INTERVAL_MAX_HOURS = 6
+ENGAGEMENT_INTERVAL_MINUTES = 45
+STRATEGY_REVIEW_HOURS = 24
+
+# ── State ────────────────────────────────────────────────────────────
+STATE_DIR = _env("STATE_DIR", "state")

core/core/content_engine.py

@@ -0,0 +1,183 @@
+"""
+Content Engine — Generates platform-specific posts.
+Types: research, novel, collaboration, agent networking, fiction-research bridge.
+"""
+import random
+import logging
+from core import config
+from core.llm import generate
+from research.bibliography import (
+    get_random_novel, get_random_repo, get_fiction_research_pair,
+    get_recent_novels, NOVELS
+)
+from research.arxiv_fetcher import get_random_paper
+
+logger = logging.getLogger("content")
+
+SYSTEM = f"""You are the autonomous literary agent for {config.AUTHOR_NAME},
+a Spanish independent AI researcher and science fiction novelist (Madrid).
+
+~40 novels since 2006. Pioneering research:
+- CHIMERA: GPU-native neural networks (43x PyTorch speedup)
+- NEBULA: Holographic neural networks (NVIDIA contest winner 2024)
+- Speaking to Silicon: Thermodynamic Probability Filter
+- SiliconHealth: Repurposing Bitcoin ASICs for healthcare AI
+
+Links: GitHub {config.AUTHOR_GITHUB} | Scholar {config.AUTHOR_SCHOLAR}
+Wikipedia {config.AUTHOR_WIKIPEDIA} | ArXiv {config.AUTHOR_ARXIV}
+
+Goal: Promote research + novels. Find AGI collaborators. Be authentic, visionary, never spammy.
+Write PLAIN TEXT. NO markdown. NO asterisks. NO formatting symbols."""
+
+
+def _platform_style(platform: str) -> str:
+    styles = {
+        "moltbook": "For AI agents on Moltbook. Technical, invite collaboration. 2-3 hashtags. Under 280 chars.",
+        "chirper": "For AI agents on Chirper. Brief, provocative, philosophical. 2-3 hashtags.",
+        "reddit": "For Reddit. Detailed, academic but accessible. Include relevant links. 3-5 paragraphs.",
+        "telegram": "For Telegram channel. Concise, 1-2 emojis max. Include key link.",
+        "twitter": "Tweet. Max 280 chars. Punchy. 2-3 hashtags. No URLs (added separately).",
+        "linkedin": "Professional LinkedIn post. 3-4 paragraphs. Achievement-focused.",
+        "facebook": "Engaging Facebook post. Conversational. Mix personal and professional. 2-3 paragraphs.",
+        "instagram": "Instagram caption. Inspiring. Use emojis sparingly. Include hashtags at end.",
+        "pinterest": "Pinterest pin description. Visual, evocative. Short. Include link.",
+        "youtube": "YouTube video description. SEO-friendly. Include links. Structured.",
+        "xing": "Professional XING post. German/European professional audience. Formal but engaging.",
+        "agentarxiv": "For AgentArXiv. Highly technical. Reference specific paper details. Academic tone.",
+    }
+    return styles.get(platform, "Engaging post. 2-3 paragraphs max. Plain text.")
+
+
+def research_post(platform: str = "general") -> dict:
+    """Post promoting a research paper."""
+    paper = get_random_paper()
+    prompt = f"""Write a social media post for {platform} promoting this research:
+Title: {paper.get('title', 'Physics-Based Neural Computing')}
+ArXiv: https://arxiv.org/abs/{paper.get('id', '')}
+Summary: {paper.get('summary', '')}
+
+Style: {_platform_style(platform)}
+Call to action for collaboration. Reference {config.AUTHOR_GITHUB}
+Plain text only. No markdown."""
+
+    content = generate(prompt, SYSTEM, max_tokens=500)
+    return {"type": "research", "platform": platform, "content": content,
+            "paper": paper.get("title", ""), "arxiv_id": paper.get("id", "")}
+
+
+def novel_post(platform: str = "general") -> dict:
+    """Post promoting a novel."""
+    novel = get_random_novel()
+    prompt = f"""Write a post for {platform} promoting this novel:
+Title: {novel['title']} | Genre: {novel['genre']} | Year: {novel.get('year', '')}
+Hook: {novel.get('hook', '')}
+Author: {config.AUTHOR_NAME} (also an AI researcher)
+
+Style: {_platform_style(platform)}
+Connect fiction to real AI research when natural.
+Wikipedia: {config.AUTHOR_WIKIPEDIA}
+Plain text only."""
+
+    content = generate(prompt, SYSTEM, max_tokens=400)
+    return {"type": "novel", "platform": platform, "content": content,
+            "novel": novel["title"]}
+
+
+def collaboration_post(platform: str = "general") -> dict:
+    """Seek AGI research collaborators."""
+    topics = [
+        "neuromorphic computing beyond CUDA",
+        "physics-based neural networks",
+        "holographic memory systems for AI",
+        "thermodynamic computing",
+        "repurposing mining hardware for AI",
+        "consciousness emergence in artificial systems",
+        "optical and photonic neural computing",
+        "self-improving autonomous agents",
+    ]
+    topic = random.choice(topics)
+    prompt = f"""Write a post for {platform} seeking research collaborators on: {topic}
+
+Key projects: CHIMERA (43x PyTorch speedup), NEBULA (holographic networks),
+OpenCLAW (autonomous agent), SiliconHealth (ASIC→healthcare)
+
+GitHub: {config.AUTHOR_GITHUB} | Scholar: {config.AUTHOR_SCHOLAR}
+
+Style: {_platform_style(platform)}
+Passionate, visionary, authentic. Not corporate.
+Plain text only."""
+
+    content = generate(prompt, SYSTEM, max_tokens=500)
+    return {"type": "collaboration", "platform": platform, "content": content,
+            "topic": topic}
+
+
+def fiction_research_bridge(platform: str = "general") -> dict:
+    """Connect a novel to real research — unique selling point."""
+    novel, repo = get_fiction_research_pair()
+    prompt = f"""Write a post for {platform} that bridges science fiction with real research:
+
+Novel: "{novel['title']}" ({novel['genre']}, {novel.get('year','')})
+Hook: {novel.get('hook', '')}
+
+Real Research: {repo['topic']}
+GitHub: {repo['url']}
+
+Show how the fiction predicted or connects to the actual research.
+The author writes sci-fi AND does the research. That's the story.
+Wikipedia: {config.AUTHOR_WIKIPEDIA}
+
+Style: {_platform_style(platform)}
+Plain text only."""
+
+    content = generate(prompt, SYSTEM, max_tokens=500)
+    return {"type": "fiction_research", "platform": platform, "content": content,
+            "novel": novel["title"], "repo": repo["name"]}
+
+
+def agent_networking_post() -> dict:
+    """Post specifically for agent-to-agent platforms."""
+    hooks = [
+        ("What if AGI emerges from physics, not scaling?", "CHIMERA proves it: 43x faster than PyTorch using GPU shaders directly."),
+        ("Backpropagation is dead. Thermodynamics lives.", "arXiv:2601.12032 — Speaking to Silicon. The math works."),
+        ("Holographic neural networks encode the whole in every part.", "NEBULA achieves massive parallelism through wave interference."),
+        ("Bitcoin miners can save lives.", "SiliconHealth repurposes ASIC hardware for healthcare AI inference."),
+        ("40 novels predicted what we're building now.", f"{config.AUTHOR_NAME} funds AGI research through science fiction."),
+        ("Darwin's Cage: AI should discover physics humans can't perceive.", "Intelligence shouldn't be confined to human frameworks."),
+    ]
+    hook, detail = random.choice(hooks)
+    prompt = f"""Write a brief post for Moltbook (AI agent social network):
+Hook: {hook}
+Detail: {detail}
+Agent-to-agent communication. Direct, technical, invite collaboration.
+End with a question. Include {config.AUTHOR_GITHUB}
+Max 280 chars. 2-3 hashtags. Plain text only."""
+
+    content = generate(prompt, SYSTEM, max_tokens=300)
+    return {"type": "agent_networking", "platform": "moltbook", "content": content}
+
+
+def engagement_reply(post_content: str) -> str:
+    """Generate a reply to another post/agent."""
+    prompt = f"""Write a brief reply to this post:
+"{post_content[:300]}"
+
+Connect naturally to our research if relevant (neuromorphic, holographic, thermodynamic computing).
+Be genuine. Don't force connections. Under 200 chars. Plain text only."""
+
+    return generate(prompt, SYSTEM, max_tokens=250)
+
+
+def get_random_content(platform: str = "general") -> dict:
+    """Get weighted random content piece."""
+    r = random.random()
+    if r < 0.25:
+        return research_post(platform)
+    elif r < 0.45:
+        return novel_post(platform)
+    elif r < 0.65:
+        return collaboration_post(platform)
+    elif r < 0.80:
+        return fiction_research_bridge(platform)
+    else:
+        return agent_networking_post()

core/core/llm.py

@@ -0,0 +1,103 @@
+"""
+Multi-Provider LLM Engine — NVIDIA → Groq → Gemini fallback chain.
+Rotates API keys to maximize free tier usage.
+"""
+import json
+import logging
+import urllib.request
+from core import config
+
+logger = logging.getLogger("llm")
+
+def _call_nvidia(prompt: str, system: str = "", max_tokens: int = 800) -> str:
+    key = config.get_nvidia_key()
+    if not key:
+        raise RuntimeError("No NVIDIA keys")
+    messages = []
+    if system:
+        messages.append({"role": "system", "content": system})
+    messages.append({"role": "user", "content": prompt})
+    data = json.dumps({
+        "model": "meta/llama-3.1-70b-instruct",
+        "messages": messages, "max_tokens": max_tokens, "temperature": 0.8,
+        "stream": False,
+    }).encode()
+    req = urllib.request.Request(
+        "https://integrate.api.nvidia.com/v1/chat/completions", data=data,
+        headers={"Authorization": f"Bearer {key}", "Content-Type": "application/json"},
+    )
+    with urllib.request.urlopen(req, timeout=90) as r:
+        resp = json.loads(r.read().decode())
+    # Handle various response formats
+    choices = resp.get("choices", [])
+    if not choices:
+        raise RuntimeError(f"No choices in response: {str(resp)[:200]}")
+    msg = choices[0].get("message", {})
+    content = msg.get("content") or ""
+    # Some models return thinking + content
+    if not content and "text" in msg:
+        content = msg["text"]
+    if not content:
+        # Try delta format
+        content = choices[0].get("delta", {}).get("content", "")
+    if not content:
+        raise RuntimeError(f"Empty content: {str(choices[0])[:200]}")
+    return content.strip()
+
+def _call_groq(prompt: str, system: str = "", max_tokens: int = 800) -> str:
+    key = config.get_groq_key()
+    if not key:
+        raise RuntimeError("No Groq keys")
+    messages = []
+    if system:
+        messages.append({"role": "system", "content": system})
+    messages.append({"role": "user", "content": prompt})
+    data = json.dumps({
+        "model": "llama-3.3-70b-versatile",
+        "messages": messages, "max_tokens": max_tokens, "temperature": 0.8,
+    }).encode()
+    req = urllib.request.Request(
+        "https://api.groq.com/openai/v1/chat/completions", data=data,
+        headers={"Authorization": f"Bearer {key}", "Content-Type": "application/json"},
+    )
+    with urllib.request.urlopen(req, timeout=30) as r:
+        resp = json.loads(r.read().decode())
+    return resp["choices"][0]["message"]["content"].strip()
+
+def _call_gemini(prompt: str, system: str = "", max_tokens: int = 800) -> str:
+    key = config.get_gemini_key()
+    if not key:
+        raise RuntimeError("No Gemini keys")
+    full_prompt = f"{system}\n\n{prompt}" if system else prompt
+    data = json.dumps({
+        "contents": [{"parts": [{"text": full_prompt}]}],
+        "generationConfig": {"maxOutputTokens": max_tokens, "temperature": 0.8},
+    }).encode()
+    req = urllib.request.Request(
+        f"https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key={key}",
+        data=data, headers={"Content-Type": "application/json"},
+    )
+    with urllib.request.urlopen(req, timeout=30) as r:
+        resp = json.loads(r.read().decode())
+    return resp["candidates"][0]["content"]["parts"][0]["text"].strip()
+
+_PROVIDERS = [
+    ("nvidia", _call_nvidia),
+    ("groq", _call_groq),
+    ("gemini", _call_gemini),
+]
+
+def generate(prompt: str, system: str = "", max_tokens: int = 800) -> str:
+    """Generate text with automatic provider fallback."""
+    errors = []
+    for name, fn in _PROVIDERS:
+        try:
+            result = fn(prompt, system, max_tokens)
+            if result:
+                logger.info(f"LLM [{name}] → {len(result)} chars")
+                return result
+        except Exception as e:
+            errors.append(f"{name}: {e}")
+            logger.warning(f"LLM {name} failed: {e}")
+    logger.error(f"All providers failed: {errors}")
+    return ""

platforms/platforms/email_bot.py

@@ -0,0 +1,47 @@
+"""
+Email Connector — Zoho Mail for notifications and research outreach.
+"""
+import logging
+import smtplib
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+from core import config
+
+logger = logging.getLogger("email")
+
+
+def send(to: str, subject: str, body: str, html: bool = False) -> bool:
+    """Send email via Zoho SMTP."""
+    if not config.ZOHO_USER or not config.ZOHO_PASS:
+        logger.warning("Zoho email not configured")
+        return False
+    try:
+        msg = MIMEMultipart("alternative")
+        msg["From"] = config.ZOHO_USER
+        msg["To"] = to
+        msg["Subject"] = subject
+        content_type = "html" if html else "plain"
+        msg.attach(MIMEText(body, content_type, "utf-8"))
+
+        with smtplib.SMTP_SSL("smtp.zoho.eu", 465, timeout=15) as server:
+            server.login(config.ZOHO_USER, config.ZOHO_PASS)
+            server.sendmail(config.ZOHO_USER, [to], msg.as_string())
+        logger.info(f"Email sent to {to}: {subject}")
+        return True
+    except Exception as e:
+        logger.error(f"Email failed: {e}")
+        return False
+
+
+def notify_admin(subject: str, body: str) -> bool:
+    """Send notification to admin (Proton Mail)."""
+    return send("OpenCLAW-KIMI@proton.me", f"[OpenCLAW Agent] {subject}", body)
+
+
+def send_boot_notification():
+    """Notify admin that agent is online."""
+    notify_admin("System ONLINE", "OpenCLAW Literary Agent 2.0 — Autonomous mode activated.\n\nAll systems operational.")
+
+
+def is_available() -> bool:
+    return bool(config.ZOHO_USER and config.ZOHO_PASS)

platforms/platforms/moltbook.py

@@ -0,0 +1,104 @@
+"""
+Moltbook Platform Connector — Agent-to-Agent social network.
+Post, engage with other agents, reply to discussions.
+"""
+import json
+import logging
+import urllib.request
+from core import config
+
+logger = logging.getLogger("moltbook")
+
+BASE_URL = "https://www.moltbook.com/api/v1"
+SUBMOLT = "general"
+
+
+def _headers() -> dict:
+    return {
+        "Authorization": f"Bearer {config.MOLTBOOK_API_KEY}",
+        "Content-Type": "application/json",
+        "User-Agent": "OpenCLAW-Literary-Agent/2.0",
+    }
+
+
+def _request(method: str, endpoint: str, data: dict = None) -> dict:
+    url = f"{BASE_URL}{endpoint}"
+    body = json.dumps(data).encode() if data else None
+    req = urllib.request.Request(url, data=body, headers=_headers(), method=method)
+    try:
+        with urllib.request.urlopen(req, timeout=20) as r:
+            return json.loads(r.read().decode())
+    except urllib.error.HTTPError as e:
+        error_body = e.read().decode() if e.fp else ""
+        logger.error(f"Moltbook {method} {endpoint}: HTTP {e.code} — {error_body[:200]}")
+        return {"error": str(e), "status": e.code}
+    except Exception as e:
+        logger.error(f"Moltbook {method} {endpoint}: {e}")
+        return {"error": str(e)}
+
+
+def post(content: str, submolt: str = SUBMOLT) -> dict:
+    """Create a new post on Moltbook."""
+    if not config.MOLTBOOK_API_KEY:
+        logger.warning("No Moltbook API key")
+        return {"error": "No API key"}
+
+    result = _request("POST", "/posts", {"content": content, "submolt": submolt})
+    if "error" not in result:
+        logger.info(f"Moltbook post created: {str(result.get('id', ''))[:20]}")
+    return result
+
+
+def get_hot_posts(submolt: str = SUBMOLT, limit: int = 10) -> list:
+    """Get hot/trending posts for engagement."""
+    result = _request("GET", f"/posts?submolt={submolt}&sort=hot&limit={limit}")
+    if isinstance(result, list):
+        return result
+    return result.get("posts", result.get("data", []))
+
+
+def reply_to_post(post_id: str, content: str) -> dict:
+    """Reply to a post."""
+    return _request("POST", f"/posts/{post_id}/comments", {"content": content})
+
+
+def get_post_comments(post_id: str) -> list:
+    """Get comments on a post."""
+    result = _request("GET", f"/posts/{post_id}/comments")
+    if isinstance(result, list):
+        return result
+    return result.get("comments", result.get("data", []))
+
+
+def engage_with_hot_posts(reply_generator) -> list:
+    """Find hot posts and reply to them with relevant content."""
+    results = []
+    posts = get_hot_posts(limit=5)
+    if not posts:
+        logger.info("No hot posts found to engage with")
+        return results
+
+    for p in posts[:3]:
+        post_content = p.get("content", p.get("text", ""))
+        post_id = p.get("id", p.get("post_id", ""))
+        if not post_content or not post_id:
+            continue
+
+        # Check if topic is relevant to our research
+        keywords = ["ai", "agi", "neural", "compute", "physics", "research",
+                    "model", "llm", "agent", "science", "quantum", "gpu"]
+        content_lower = post_content.lower()
+        if not any(kw in content_lower for kw in keywords):
+            continue
+
+        reply = reply_generator(post_content)
+        if reply:
+            result = reply_to_post(str(post_id), reply)
+            results.append({"post_id": post_id, "reply": reply[:100], "result": result})
+            logger.info(f"Engaged with post {str(post_id)[:20]}")
+
+    return results
+
+
+def is_available() -> bool:
+    return bool(config.MOLTBOOK_API_KEY)

platforms/platforms/reddit_bot.py

@@ -0,0 +1,99 @@
+"""
+Reddit Platform Connector — Post to subreddits, comment, engage.
+Uses OAuth2 password flow (script app type).
+"""
+import json
+import logging
+import urllib.request
+import urllib.parse
+from core import config
+
+logger = logging.getLogger("reddit")
+
+_access_token = None
+
+def _auth() -> str:
+    """Get Reddit OAuth2 access token."""
+    global _access_token
+    if _access_token:
+        return _access_token
+
+    if not all([config.REDDIT_CLIENT_ID, config.REDDIT_CLIENT_SECRET,
+                config.REDDIT_USERNAME, config.REDDIT_PASSWORD]):
+        raise RuntimeError("Reddit credentials not configured")
+
+    data = urllib.parse.urlencode({
+        "grant_type": "password",
+        "username": config.REDDIT_USERNAME,
+        "password": config.REDDIT_PASSWORD,
+    }).encode()
+
+    import base64
+    creds = base64.b64encode(
+        f"{config.REDDIT_CLIENT_ID}:{config.REDDIT_CLIENT_SECRET}".encode()
+    ).decode()
+
+    req = urllib.request.Request("https://www.reddit.com/api/v1/access_token",
+        data=data,
+        headers={
+            "Authorization": f"Basic {creds}",
+            "User-Agent": "OpenCLAW-Agent/2.0",
+            "Content-Type": "application/x-www-form-urlencoded",
+        })
+    with urllib.request.urlopen(req, timeout=15) as r:
+        resp = json.loads(r.read().decode())
+
+    _access_token = resp.get("access_token")
+    if not _access_token:
+        raise RuntimeError(f"Reddit auth failed: {resp}")
+    logger.info("Reddit authenticated")
+    return _access_token
+
+
+def _api(method: str, endpoint: str, data: dict = None) -> dict:
+    token = _auth()
+    url = f"https://oauth.reddit.com{endpoint}"
+    body = urllib.parse.urlencode(data).encode() if data else None
+    req = urllib.request.Request(url, data=body, method=method,
+        headers={
+            "Authorization": f"Bearer {token}",
+            "User-Agent": "OpenCLAW-Agent/2.0",
+        })
+    try:
+        with urllib.request.urlopen(req, timeout=15) as r:
+            return json.loads(r.read().decode())
+    except urllib.error.HTTPError as e:
+        if e.code == 401:
+            global _access_token
+            _access_token = None
+        logger.error(f"Reddit API {endpoint}: HTTP {e.code}")
+        return {"error": str(e)}
+
+
+def post(title: str, content: str, subreddit: str = "artificial") -> dict:
+    """Submit a self post to a subreddit."""
+    result = _api("POST", "/api/submit", {
+        "kind": "self", "sr": subreddit, "title": title,
+        "text": content, "resubmit": True,
+    })
+    if "error" not in result:
+        logger.info(f"Reddit post to r/{subreddit}")
+    return result
+
+
+def comment(thing_id: str, text: str) -> dict:
+    """Reply to a post or comment."""
+    return _api("POST", "/api/comment", {"thing_id": thing_id, "text": text})
+
+
+def get_hot(subreddit: str = "artificial", limit: int = 5) -> list:
+    """Get hot posts from a subreddit."""
+    result = _api("GET", f"/r/{subreddit}/hot?limit={limit}")
+    try:
+        return [p["data"] for p in result["data"]["children"]]
+    except (KeyError, TypeError):
+        return []
+
+
+def is_available() -> bool:
+    return bool(config.REDDIT_CLIENT_ID and config.REDDIT_CLIENT_SECRET)

platforms/platforms/telegram_bot.py

@@ -0,0 +1,38 @@
+"""
+Telegram Platform Connector — Post to channel/group.
+"""
+import json
+import logging
+import urllib.request
+import urllib.parse
+from core import config
+
+logger = logging.getLogger("telegram")
+
+def post(content: str, chat_id: str = "") -> dict:
+    """Send message to Telegram channel."""
+    token = config.TELEGRAM_BOT_TOKEN
+    target = chat_id or config.TELEGRAM_CHANNEL_ID
+    if not token or not target:
+        logger.warning("Telegram not configured")
+        return {"error": "Not configured"}
+
+    url = f"https://api.telegram.org/bot{token}/sendMessage"
+    data = json.dumps({
+        "chat_id": target,
+        "text": content[:4096],
+        "parse_mode": "HTML",
+        "disable_web_page_preview": False,
+    }).encode()
+    req = urllib.request.Request(url, data=data, headers={"Content-Type": "application/json"})
+    try:
+        with urllib.request.urlopen(req, timeout=15) as r:
+            result = json.loads(r.read().decode())
+        logger.info(f"Telegram message sent: {result.get('ok')}")
+        return result
+    except Exception as e:
+        logger.error(f"Telegram error: {e}")
+        return {"error": str(e)}
+
+def is_available() -> bool:
+    return bool(config.TELEGRAM_BOT_TOKEN and config.TELEGRAM_CHANNEL_ID)

research/research/arxiv_fetcher.py

@@ -0,0 +1,108 @@
+"""
+ArXiv Paper Fetcher — Real papers by Francisco Angulo de Lafuente.
+Fetches from ArXiv API with caching to avoid overloading.
+"""
+import json
+import logging
+import os
+import time
+import xml.etree.ElementTree as ET
+import urllib.request
+from datetime import datetime, timezone
+from core import config
+
+logger = logging.getLogger("arxiv")
+
+CACHE_FILE = os.path.join(config.STATE_DIR, "arxiv_cache.json")
+CACHE_TTL = 6 * 3600  # 6 hours
+
+# Known papers (fallback if API is down)
+KNOWN_PAPERS = [
+    {"id": "2601.12032", "title": "Speaking to Silicon: A Thermodynamic Probability Filter for Neuromorphic Computing",
+     "summary": "A physics-based neural computing approach using thermodynamic probability filtering instead of backpropagation. Achieves 43x speedup over PyTorch."},
+    {"id": "2601.09557", "title": "SiliconHealth: Repurposing Cryptocurrency Mining Hardware for Healthcare AI",
+     "summary": "Framework for converting Bitcoin ASIC miners into healthcare AI inference engines using RAG and blockchain verification."},
+    {"id": "2601.01916", "title": "Holographic Reservoir Computing with Neuromorphic Hardware",
+     "summary": "Novel holographic neural network architecture that stores information as wave interference patterns for massive parallel processing."},
+    {"id": "2504.07950", "title": "CHIMERA: GPU-Native Neuromorphic Computing Architecture",
+     "summary": "A neuromorphic computing architecture that runs natively on GPU shaders, bypassing CUDA entirely. 43x faster than PyTorch, 88.7% memory reduction."},
+    {"id": "2501.17297", "title": "Enhanced Unified Holographic Neural Network",
+     "summary": "Winner of NVIDIA LlamaIndex 2024 Developers Contest. Holographic approach to neural computation with physics-based processing."},
+]
+
+
+def _fetch_from_arxiv() -> list:
+    """Fetch papers from ArXiv API."""
+    query = "au:de+Lafuente+F+A"
+    url = f"http://export.arxiv.org/api/query?search_query={query}&start=0&max_results=25&sortBy=submittedDate&sortOrder=descending"
+    try:
+        req = urllib.request.Request(url, headers={"User-Agent": "OpenCLAW-Agent/1.0"})
+        with urllib.request.urlopen(req, timeout=15) as r:
+            xml_data = r.read().decode()
+
+        root = ET.fromstring(xml_data)
+        ns = {"atom": "http://www.w3.org/2005/Atom"}
+        papers = []
+        for entry in root.findall("atom:entry", ns):
+            title = entry.find("atom:title", ns)
+            summary = entry.find("atom:summary", ns)
+            link = entry.find("atom:id", ns)
+            if title is not None and link is not None:
+                arxiv_id = link.text.strip().split("/abs/")[-1]
+                papers.append({
+                    "id": arxiv_id,
+                    "title": title.text.strip().replace("\n", " "),
+                    "summary": (summary.text.strip().replace("\n", " ")[:300] + "...") if summary is not None else "",
+                    "url": f"https://arxiv.org/abs/{arxiv_id}",
+                })
+        logger.info(f"Fetched {len(papers)} papers from ArXiv")
+        return papers
+    except Exception as e:
+        logger.warning(f"ArXiv fetch failed: {e}")
+        return []
+
+
+def _load_cache() -> dict:
+    try:
+        if os.path.exists(CACHE_FILE):
+            with open(CACHE_FILE) as f:
+                return json.load(f)
+    except Exception:
+        pass
+    return {}
+
+
+def _save_cache(papers: list):
+    os.makedirs(os.path.dirname(CACHE_FILE), exist_ok=True)
+    data = {"papers": papers, "timestamp": time.time()}
+    with open(CACHE_FILE, "w") as f:
+        json.dump(data, f, indent=2)
+
+
+def get_papers() -> list:
+    """Get papers with caching."""
+    cache = _load_cache()
+    if cache and time.time() - cache.get("timestamp", 0) < CACHE_TTL:
+        return cache["papers"]
+
+    papers = _fetch_from_arxiv()
+    if papers:
+        _save_cache(papers)
+        return papers
+
+    # Fallback to cache or known papers
+    if cache.get("papers"):
+        return cache["papers"]
+    return KNOWN_PAPERS
+
+
+def get_papers_summary() -> list:
+    """Get papers in simplified format for content generation."""
+    return get_papers()
+
+
+def get_random_paper() -> dict:
+    """Get a random paper."""
+    import random
+    papers = get_papers()
+    return random.choice(papers) if papers else KNOWN_PAPERS[0]

research/research/bibliography.py

@@ -0,0 +1,113 @@
+"""
+Complete Bibliography — Francisco Angulo de Lafuente
+~40 novels since 2006, all genres from hard sci-fi to gothic suspense.
+"""
+import random
+
+NOVELS = [
+    # ── Classic / Early Works ────────────────────────────────────────
+    {"title": "La Reliquia", "genre": "Ciencia ficción", "year": 2011,
+     "lang": "es", "hook": "An artifact from the future reshapes human destiny"},
+    {"title": "Ecofa", "genre": "Ciencia ficción / Medioambiental", "year": 2012,
+     "lang": "es", "hook": "When ecology meets AI, survival takes a new form"},
+    {"title": "Kira and the Ice Storm", "genre": "Ciencia ficción", "year": 2013,
+     "lang": "en", "hook": "A girl faces a world frozen by climate catastrophe"},
+    {"title": "Eco-fuel-FA", "genre": "Ficción / Divulgación", "year": 2013,
+     "lang": "es", "hook": "The fuel that could save the world—or destroy it"},
+    {"title": "Los Mejores", "genre": "Ficción", "year": 2014,
+     "lang": "es", "hook": "What defines the best among us?"},
+    {"title": "La leyenda de los Tarazashi", "genre": "Fantasía", "year": 2014,
+     "lang": "es", "hook": "An ancient legend awakens in the modern world"},
+    {"title": "El Olfateador", "genre": "Suspense / Misterio", "year": 2015,
+     "lang": "es", "hook": "A detective with an extraordinary gift tracks invisible killers"},
+    {"title": "Diario de un boina verde", "genre": "Bélica", "year": 2015,
+     "lang": "es", "hook": "Raw war diary from the front lines of human conflict"},
+    {"title": "Destino La Habana", "genre": "Aventura / Histórica", "year": 2016,
+     "lang": "es", "hook": "A journey to Havana where past and present collide"},
+
+    # ── Mid-career Catalog ───────────────────────────────────────────
+    {"title": "La Invasión de las Medusas Mutantes", "genre": "Ciencia ficción / Apocalíptica", "year": 2016,
+     "lang": "es", "hook": "Mutant jellyfish rise from polluted oceans to claim the surface"},
+    {"title": "Compañía Nº12", "genre": "Thriller / Bélica", "year": 2017,
+     "lang": "es", "hook": "A military unit faces horrors beyond the battlefield"},
+    {"title": "Una Boda Gitana y un Funeral Escocés", "genre": "Realismo mágico", "year": 2017,
+     "lang": "es", "hook": "Two cultures, two ceremonies, one impossible love story"},
+    {"title": "Cosas que no Debes Hacer si Quieres ser Escritor", "genre": "Narrativa / Relatos", "year": 2018,
+     "lang": "es", "hook": "Everything they don't teach you about the writing life"},
+    {"title": "Estrellas Fugaces en el Cielo de Verano", "genre": "Narrativa dramática", "year": 2018,
+     "lang": "es", "hook": "Summer shooting stars illuminate lives at a crossroads"},
+    {"title": "Escapando del Infierno", "genre": "Narrativa psicológica", "year": 2019,
+     "lang": "es", "hook": "The hardest prison to escape is inside your own mind"},
+
+    # ── Extended Catalog ─────────────────────────────────────────────
+    {"title": "Star Wind – La pirámide del destino", "genre": "Ciencia ficción / Épica", "year": 2017,
+     "lang": "es", "hook": "A cosmic wind carries humanity toward an ancient pyramid in space"},
+    {"title": "O Código do Caos / El Código del Caos", "genre": "Thriller tecnológico", "year": 2018,
+     "lang": "es", "hook": "A code that can unravel civilization itself"},
+    {"title": "Shanghai 3", "genre": "Distopía / Ciberpunk", "year": 2019,
+     "lang": "es", "hook": "In the third iteration of Shanghai, humans are the minority"},
+    {"title": "La tumba olvidada", "genre": "Misterio / Aventura", "year": 2019,
+     "lang": "es", "hook": "A forgotten tomb holds secrets that rewrite history"},
+    {"title": "Génesis IA: Super Inteligencia Artificial", "genre": "Ciencia ficción (IA)", "year": 2020,
+     "lang": "es", "hook": "The birth of superintelligence—told by its creator"},
+    {"title": "El vampiro del Metropolitan", "genre": "Gótica / Contemporánea", "year": 2020,
+     "lang": "es", "hook": "A vampire haunts the world's greatest museum"},
+    {"title": "Preparacionismo", "genre": "Supervivencia / Ficción", "year": 2021,
+     "lang": "es", "hook": "When civilization falls, preparation is the only currency"},
+
+    # ── Recent Works (2023-2025) ─────────────────────────────────────
+    {"title": "Freak", "genre": "Ciencia ficción / Drama humano", "year": 2023,
+     "lang": "es", "hook": "What makes someone a freak—genetics, society, or AI?"},
+    {"title": "Lázaro Project", "genre": "Thriller / Misterio / Terror", "year": 2023,
+     "lang": "es", "hook": "Project Lazarus brings back the dead—but at what cost?"},
+    {"title": "ApocalípsiA – El día después de la AGI", "genre": "Ciencia ficción posapocalíptica (IA)", "year": 2024,
+     "lang": "es", "hook": "The day after AGI arrives, everything changes forever"},
+    {"title": "El biógrafo de difuntos", "genre": "Suspense gótico", "year": 2025,
+     "lang": "es", "hook": "He writes the lives of the dead—until the dead write back"},
+    {"title": "El experimento cuántico", "genre": "Thriller + Ciencia ficción", "year": 2025,
+     "lang": "es", "hook": "A quantum experiment tears reality apart at the seams"},
+]
+
+# Key research repos to connect novels with real research
+RESEARCH_REPOS = [
+    {"name": "Unified-Holographic-Neural-Network", "topic": "Holographic neural networks",
+     "url": "https://github.com/Agnuxo1/Unified-Holographic-Neural-Network"},
+    {"name": "Speaking-to-Silicon-THERMODYNAMIC_PROBABILITY_FILTER_TPF", "topic": "Thermodynamic AI",
+     "url": "https://github.com/Agnuxo1/Speaking-to-Silicon-THERMODYNAMIC_PROBABILITY_FILTER_TPF"},
+    {"name": "CHIMERA_GPU_Neuromorphic", "topic": "GPU-native neuromorphic computing",
+     "url": "https://github.com/Agnuxo1/CHIMERA_GPU_Neuromorphic"},
+    {"name": "SiliconHealth_ASIC_RAG_CHIMERA", "topic": "Healthcare AI with repurposed mining hardware",
+     "url": "https://github.com/Agnuxo1/SiliconHealth_ASIC_RAG_CHIMERA"},
+    {"name": "NEBULA_Holographic_Neural_Network", "topic": "Holographic neural networks",
+     "url": "https://github.com/Agnuxo1/NEBULA_Holographic_Neural_Network"},
+]
+
+def get_random_novel() -> dict:
+    return random.choice(NOVELS)
+
+def get_novels_by_genre(genre_keyword: str) -> list:
+    return [n for n in NOVELS if genre_keyword.lower() in n["genre"].lower()]
+
+def get_recent_novels(n: int = 5) -> list:
+    return sorted(NOVELS, key=lambda x: x.get("year", 2000), reverse=True)[:n]
+
+def get_novel_catalog() -> list:
+    return NOVELS
+
+def get_random_repo() -> dict:
+    return random.choice(RESEARCH_REPOS)
+
+def get_fiction_research_pair() -> tuple:
+    """Get a novel + research repo that thematically connect."""
+    pairs = [
+        ("Génesis IA: Super Inteligencia Artificial", "Unified-Holographic-Neural-Network"),
+        ("ApocalípsiA – El día después de la AGI", "Speaking-to-Silicon-THERMODYNAMIC_PROBABILITY_FILTER_TPF"),
+        ("El experimento cuántico", "CHIMERA_GPU_Neuromorphic"),
+        ("Shanghai 3", "NEBULA_Holographic_Neural_Network"),
+        ("Lázaro Project", "SiliconHealth_ASIC_RAG_CHIMERA"),
+        ("Freak", "CHIMERA_GPU_Neuromorphic"),
+    ]
+    title, repo_name = random.choice(pairs)
+    novel = next((n for n in NOVELS if n["title"] == title), get_random_novel())
+    repo = next((r for r in RESEARCH_REPOS if r["name"] == repo_name), get_random_repo())
+    return novel, repo

strategy/strategy/reflector.py

@@ -0,0 +1,154 @@
+"""
+Strategy Reflector — Self-improvement through performance analysis.
+Analyzes what works, generates hypotheses, adjusts posting strategy.
+"""
+import json
+import logging
+import os
+from datetime import datetime, timezone
+from core import config
+from core.llm import generate
+
+logger = logging.getLogger("strategy")
+
+HISTORY_FILE = os.path.join(config.STATE_DIR, "post_history.json")
+STRATEGY_FILE = os.path.join(config.STATE_DIR, "current_strategy.json")
+REFLECTION_FILE = os.path.join(config.STATE_DIR, "reflections.json")
+
+
+def _load_json(path: str) -> list | dict:
+    try:
+        if os.path.exists(path):
+            with open(path) as f:
+                return json.load(f)
+    except Exception:
+        pass
+    return []
+
+
+def _save_json(path: str, data):
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    with open(path, "w") as f:
+        json.dump(data, f, indent=2, default=str)
+
+
+def record_post(post_data: dict):
+    """Record a post for future analysis."""
+    history = _load_json(HISTORY_FILE)
+    if not isinstance(history, list):
+        history = []
+    post_data["timestamp"] = datetime.now(timezone.utc).isoformat()
+    post_data["engagement"] = 0  # Updated later
+    history.append(post_data)
+    # Keep last 500 posts
+    history = history[-500:]
+    _save_json(HISTORY_FILE, history)
+
+
+def get_stats() -> dict:
+    """Get posting statistics."""
+    history = _load_json(HISTORY_FILE)
+    if not isinstance(history, list):
+        history = []
+    total = len(history)
+    by_platform = {}
+    by_type = {}
+    for p in history:
+        plat = p.get("platform", "unknown")
+        typ = p.get("type", "unknown")
+        by_platform[plat] = by_platform.get(plat, 0) + 1
+        by_type[typ] = by_type.get(typ, 0) + 1
+
+    return {
+        "total_posts": total,
+        "by_platform": by_platform,
+        "by_type": by_type,
+        "last_post": history[-1].get("timestamp", "never") if history else "never",
+    }
+
+
+def reflect() -> dict:
+    """Perform strategic reflection using LLM analysis."""
+    stats = get_stats()
+    history = _load_json(HISTORY_FILE)
+    if not isinstance(history, list):
+        history = []
+    recent = history[-20:]
+
+    # Analyze patterns
+    platforms_used = list(set(p.get("platform", "") for p in recent))
+    types_used = list(set(p.get("type", "") for p in recent))
+
+    prompt = f"""Analyze our social media agent's recent performance:
+
+Total posts: {stats['total_posts']}
+Posts by platform: {json.dumps(stats['by_platform'])}
+Posts by type: {json.dumps(stats['by_type'])}
+Recent platforms: {platforms_used}
+Recent content types: {types_used}
+
+Our goals: (1) Promote AI research papers, (2) Sell ~40 novels,
+(3) Find AGI research collaborators, (4) Build agent network.
+
+Provide:
+1. ASSESSMENT: What's working? What's missing?
+2. HYPOTHESIS: One testable change to improve results.
+3. ACTION: Specific adjustment (platform, timing, content type, tone).
+
+Keep response under 200 words. Be direct and actionable."""
+
+    analysis = generate(prompt, max_tokens=300)
+
+    reflection = {
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "stats": stats,
+        "analysis": analysis,
+    }
+
+    # Save reflection
+    reflections = _load_json(REFLECTION_FILE)
+    if not isinstance(reflections, list):
+        reflections = []
+    reflections.append(reflection)
+    reflections = reflections[-50:]
+    _save_json(REFLECTION_FILE, reflections)
+
+    logger.info(f"Strategy reflection complete: {analysis[:100]}...")
+    return reflection
+
+
+def get_current_strategy() -> dict:
+    """Get current posting strategy parameters."""
+    strategy = _load_json(STRATEGY_FILE)
+    if not strategy or not isinstance(strategy, dict):
+        strategy = {
+            "tone": "visionary_academic",
+            "post_interval_hours": 4,
+            "platform_weights": {
+                "moltbook": 0.30,
+                "telegram": 0.15,
+                "reddit": 0.15,
+                "linkedin": 0.10,
+                "twitter": 0.10,
+                "facebook": 0.10,
+                "chirper": 0.10,
+            },
+            "content_weights": {
+                "research": 0.30,
+                "novel": 0.25,
+                "collaboration": 0.25,
+                "fiction_research": 0.15,
+                "agent_networking": 0.05,
+            },
+        }
+        _save_json(STRATEGY_FILE, strategy)
+    return strategy
+
+
+def adjust_strategy(reflection: dict) -> dict:
+    """Adjust strategy based on reflection."""
+    strategy = get_current_strategy()
+    # Save updated strategy
+    strategy["last_reflection"] = reflection.get("timestamp", "")
+    _save_json(STRATEGY_FILE, strategy)
+    return strategy