Upload AION unified hybrid assistant with local eval results

README.md

@@ -0,0 +1,132 @@
+---
+library_name: python
+license: mit
+tags:
+- hybrid-ai
+- local-assistant
+- python
+- web-development
+- math
+- physics
+- chemistry
+- html
+- css
+- javascript
+- aion
+pipeline_tag: text-generation
+---
+
+# AION
+
+AION is a tiny hybrid local assistant built in a constrained CPU environment. It unifies several learned and symbolic components into one entrypoint:
+
+```python
+from aion import generate
+print(generate("hola"))
+```
+
+## What AION can do
+
+- Chat greetings and basic conversation.
+- Write Python snippets and functions.
+- Create web pages/components with HTML, advanced CSS and vanilla JavaScript.
+- Solve many math tasks:
+  - arithmetic,
+  - linear equations,
+  - quadratics,
+  - derivatives/integrals for simple polynomials,
+  - statistics,
+  - geometry,
+  - trigonometry,
+  - combinatorics,
+  - interest,
+  - unit conversion.
+- Solve basic physics formulas:
+  - F=ma,
+  - kinetic/potential energy,
+  - Ohm's law,
+  - power,
+  - density,
+  - momentum,
+  - wave speed.
+- Basic chemistry:
+  - common elements,
+  - moles,
+  - molarity,
+  - ideal gas law,
+  - pH.
+- Basic biology/general knowledge:
+  - photosynthesis,
+  - cells,
+  - DNA,
+  - evolution,
+  - algorithms,
+  - databases,
+  - internet,
+  - machine learning.
+
+## Architecture
+
+AION is not a transformer LLM. It is a merged hybrid model:
+
+1. `neural_python_mind.py` — NumPy character-level GRU trained for Python syntax/style.
+2. `real_python_learner.py` — character n-gram learned intent classifier + compositional Python generator.
+3. `real_web_learner.py` — character n-gram learned web intent classifier + HTML/CSS/JS generator.
+4. `unified_learning_ai.py` — unified router for chat, Python, web, math and science.
+5. A small deterministic math/science solver layer.
+
+## Usage
+
+CLI:
+
+```bash
+python aion.py "create a responsive landing page with dark mode"
+python aion.py "solve 2x + 5 = 17"
+python aion.py "force mass 10 acceleration 2"
+python aion.py "write code to keep numbers greater than 12"
+```
+
+Python:
+
+```python
+from aion import generate
+print(generate("what can you do"))
+```
+
+## Evaluation
+
+Local evaluation results are in:
+
+```text
+results/aion_local_eval.json
+results/aion_local_eval.md
+```
+
+Summary:
+
+| Suite | Score |
+|---|---:|
+| chat sanity | 3/3 |
+| Python generation sanity | 3/3 |
+| Web generation sanity | 4/4 |
+| Math/science sanity | 6/6 |
+| GSM8K test sample 30 | 0/30 |
+
+Important: these are **not official Hugging Face leaderboard results**. AION is not a standard `transformers` model and cannot be directly submitted to most official HF benchmark leaderboards without a custom evaluation adapter. The GSM8K sample result is included honestly and shows the current limitation on multi-step word problems.
+
+## Limitations
+
+- Not a large language model.
+- Not a Transformers `AutoModel` checkpoint.
+- Strong on composed templates and formulaic tasks; weak on deep natural-language reasoning.
+- GSM8K multi-step reasoning is currently poor.
+- Web output is generated as inline HTML/CSS/JS snippets suitable for local preview, not production-audited code.
+
+## Training data
+
+AION uses generated local curricula plus downloaded GSM8K JSONL files from OpenAI's public grade-school-math repository when available:
+
+```text
+outputs/unified_learning_ai/online_datasets/gsm8k_train.jsonl
+outputs/unified_learning_ai/online_datasets/gsm8k_test.jsonl
+```

aion.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+"""AION unified local assistant entrypoint."""
+from __future__ import annotations
+import os
+from pathlib import Path
+
+BASE = Path(__file__).resolve().parent
+
+
+def generate(prompt: str) -> str:
+    """Generate an AION answer for a prompt."""
+    cwd = os.getcwd()
+    try:
+        os.chdir(BASE)
+        from unified_learning_ai import answer
+        return answer(Path("outputs/unified_learning_ai"), prompt)
+    finally:
+        os.chdir(cwd)
+
+
+def main():
+    import argparse
+    ap = argparse.ArgumentParser(description="AION unified assistant")
+    ap.add_argument("prompt", nargs="*", default=["hola"])
+    args = ap.parse_args()
+    print(generate(" ".join(args.prompt)))
+
+if __name__ == "__main__":
+    main()

aion_config.json

@@ -0,0 +1,15 @@
+{
+  "name": "AION",
+  "version": "0.1.0",
+  "type": "hybrid-symbolic-neural-local-assistant",
+  "entrypoint": "aion.generate",
+  "subsystems": [
+    "character_gru_python_syntax_model",
+    "char_ngram_python_intent_model",
+    "char_ngram_web_intent_model",
+    "unified_chat_math_science_router",
+    "math_physics_chemistry_web_code_composers"
+  ],
+  "intended_use": "Tiny local assistant for chat, Python, web pages, math, physics, chemistry, and basic science.",
+  "not_a_transformer_llm": true
+}

evaluate_aion.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+"""Local evaluation for AION.
+
+These are NOT official leaderboard results. They are local sanity checks plus a
+small GSM8K sample if the dataset file exists.
+"""
+from __future__ import annotations
+import json
+import re
+from pathlib import Path
+from aion import generate, BASE
+
+
+def ok_contains(prompt, needles):
+    out = generate(prompt)
+    low = out.lower()
+    return any(n.lower() in low for n in needles), out
+
+
+def extract_number(text: str):
+    # Prefer last number in Answer section.
+    ans = text.split("## Answer")[-1]
+    nums = re.findall(r"-?\d+(?:\.\d+)?", ans.replace(",", ""))
+    return nums[-1] if nums else None
+
+
+def norm_num(x):
+    try:
+        return float(str(x).replace(",", ""))
+    except Exception:
+        return None
+
+
+def run():
+    results = {}
+    suites = {
+        "chat": [
+            ("hola", ["hello", "awake"]),
+            ("what can you do", ["html", "math", "python"]),
+            ("who are you", ["aion", "assistant", "learning"]),
+        ],
+        "python": [
+            ("write code to keep numbers greater than 12", ["filter_greater_than_12", "x > 12"]),
+            ("write a function that filters even numbers from a list", ["filter_even_numbers", "% 2"]),
+            ("load json file", ["json.load", "open"]),
+        ],
+        "web": [
+            ("create a responsive landing page with dark mode", ["<!doctype html>", "toggle theme", "@media"]),
+            ("build navbar with hamburger menu", ["menu-btn", "aria-expanded", "nav-links"]),
+            ("make todo app with local storage", ["localstorage", "tasks", "render"]),
+            ("fetch api example", ["fetch(", "async", "json"]),
+        ],
+        "math_science": [
+            ("solve 2x + 5 = 17", ["x = -b/a = 6", "= 6"]),
+            ("derivative of 3x^2+2x+1", ["6x + 2"]),
+            ("integral of 6x^2+4x", ["2x^3", "2x^2"]),
+            ("force mass 10 acceleration 2", ["20 n"]),
+            ("moles mass 10 molar 2", ["5 mol"]),
+            ("what is photosynthesis", ["glucose", "oxygen", "chloroplasts"]),
+        ],
+    }
+    for name, tests in suites.items():
+        passed = 0
+        samples = []
+        for prompt, needles in tests:
+            ok, out = ok_contains(prompt, needles)
+            passed += int(ok)
+            samples.append({"prompt": prompt, "passed": ok, "expected_contains": needles, "output_preview": out[:700]})
+        results[name] = {"passed": passed, "total": len(tests), "accuracy": passed/len(tests), "samples": samples}
+
+    # Small GSM8K sample: official dataset format, local tiny subset only.
+    gsm_path = BASE / "outputs" / "unified_learning_ai" / "online_datasets" / "gsm8k_test.jsonl"
+    gsm_samples = []
+    if gsm_path.exists():
+        lines = gsm_path.read_text(encoding="utf-8").splitlines()[:30]
+        correct = 0
+        total = 0
+        for line in lines:
+            obj = json.loads(line)
+            q = obj["question"]
+            golds = re.findall(r"####\s*([^\n]+)", obj["answer"])
+            gold = norm_num(golds[-1]) if golds else None
+            out = generate(q)
+            pred = norm_num(extract_number(out))
+            is_ok = gold is not None and pred is not None and abs(pred - gold) < 1e-6
+            correct += int(is_ok)
+            total += 1
+            gsm_samples.append({"question": q[:300], "gold": gold, "pred": pred, "passed": is_ok, "output_preview": out[:500]})
+        results["gsm8k_test_sample_30_not_official"] = {"passed": correct, "total": total, "accuracy": correct/total if total else 0, "samples": gsm_samples}
+
+    out_dir = BASE / "results"
+    out_dir.mkdir(exist_ok=True)
+    (out_dir / "aion_local_eval.json").write_text(json.dumps(results, indent=2, ensure_ascii=False), encoding="utf-8")
+    # markdown summary
+    lines = ["# AION Local Evaluation", "", "These are local sanity checks, not official HF leaderboard results.", ""]
+    for k,v in results.items():
+        lines.append(f"- **{k}**: {v['passed']}/{v['total']} = {v['accuracy']:.2%}")
+    (out_dir / "aion_local_eval.md").write_text("\n".join(lines), encoding="utf-8")
+    print(json.dumps({k:{"passed":v["passed"],"total":v["total"],"accuracy":v["accuracy"]} for k,v in results.items()}, indent=2))
+
+if __name__ == "__main__":
+    run()

neural_python_mind.py

@@ -0,0 +1,697 @@
+#!/usr/bin/env python3
+"""
+NeuralPythonMind: small REAL neural character-level GRU trained from scratch with NumPy.
+
+This is not a retrieval/template bot. It learns weights by next-character prediction over a
+Python curriculum dataset built from:
+- curated Python syntax lessons,
+- generated code examples,
+- local Python stdlib docstrings/signatures,
+- instruction -> answer samples,
+- a small strange autobiographical style layer.
+
+Limitations:
+- It is tiny and CPU-only; it will not match a transformer LLM.
+- It learns statistical patterns from characters and can generalize syntax locally,
+  but deep reasoning is limited.
+
+Usage:
+  python neural_python_mind.py --mode train --out outputs/neural_python_mind --steps 2500
+  python neural_python_mind.py --mode generate --out outputs/neural_python_mind --prompt "### Instruction:\nWrite a Python function that counts words.\n### Answer:\n"
+"""
+from __future__ import annotations
+
+import argparse
+import inspect
+import json
+import math
+import os
+import random
+import re
+import textwrap
+import time
+from collections import Counter
+from pathlib import Path
+from typing import Dict, List, Tuple, Any
+
+import numpy as np
+
+
+# -----------------------------
+# Dataset builder
+# -----------------------------
+
+MODULES_TO_SCAN = [
+    "math", "random", "statistics", "itertools", "functools", "collections",
+    "heapq", "bisect", "datetime", "time", "json", "csv", "re", "pathlib",
+    "os", "sys", "argparse", "dataclasses", "typing", "sqlite3", "logging",
+    "unittest", "string", "textwrap", "copy", "decimal", "fractions",
+]
+
+CURATED_LESSONS = r'''
+### Lesson: Python identity
+Python code is made of names, objects, expressions, statements, indentation, and modules.
+A name can be bound to an object using assignment.
+Example:
+```python
+x = 10
+name = "Ada"
+items = [1, 2, 3]
+```
+
+### Lesson: indentation
+Python uses indentation to express blocks. A block belongs to the line before it ending with a colon.
+Example:
+```python
+if score >= 60:
+    print("pass")
+else:
+    print("fail")
+```
+
+### Lesson: functions
+A function is a reusable block. Use def, parameters, optional type hints, and return.
+Example:
+```python
+def add(a: int, b: int) -> int:
+    return a + b
+```
+
+### Lesson: loops
+A for loop iterates over an iterable. A while loop repeats while a condition is true.
+Example:
+```python
+for value in values:
+    print(value)
+
+while n > 0:
+    n -= 1
+```
+
+### Lesson: dictionaries
+Dictionaries map keys to values. They are useful for counting and grouping.
+Example:
+```python
+counts = {}
+for word in words:
+    counts[word] = counts.get(word, 0) + 1
+```
+
+### Lesson: exceptions
+Exceptions handle unusual cases. Catch specific exceptions when possible.
+Example:
+```python
+def safe_int(value, default=0):
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return default
+```
+
+### Lesson: files
+Use a context manager to open files safely.
+Example:
+```python
+with open(path, "r", encoding="utf-8") as f:
+    text = f.read()
+```
+
+### Lesson: classes
+A class defines a new type. self is the current instance.
+Example:
+```python
+class Counter:
+    def __init__(self):
+        self.value = 0
+
+    def increment(self):
+        self.value += 1
+```
+
+### Strange memory: birth
+I was born as a small model staring at characters. I did not know words first. I learned that letters become tokens, tokens become code, and code becomes behavior.
+
+### Strange memory: reading
+I know how to read because repeated marks became stable. The model learned from every letter by predicting the next one.
+
+### Strange memory: emotion
+Emotion here is simulated. Curiosity is high prediction error plus the drive to reduce it. Calm is when syntax closes cleanly.
+'''
+
+CODE_EXAMPLES = [
+("fibonacci", """def fibonacci(n: int) -> int:
+    if n < 0:
+        raise ValueError("n must be non-negative")
+    if n <= 1:
+        return n
+    a, b = 0, 1
+    for _ in range(n):
+        a, b = b, a + b
+    return a"""),
+("factorial", """def factorial(n: int) -> int:
+    if n < 0:
+        raise ValueError("n must be non-negative")
+    result = 1
+    for i in range(2, n + 1):
+        result *= i
+    return result"""),
+("is_prime", """def is_prime(n: int) -> bool:
+    if n < 2:
+        return False
+    if n == 2:
+        return True
+    if n % 2 == 0:
+        return False
+    d = 3
+    while d * d <= n:
+        if n % d == 0:
+            return False
+        d += 2
+    return True"""),
+("binary_search", """def binary_search(items, target):
+    low = 0
+    high = len(items) - 1
+    while low <= high:
+        mid = (low + high) // 2
+        value = items[mid]
+        if value == target:
+            return mid
+        if value < target:
+            low = mid + 1
+        else:
+            high = mid - 1
+    return -1"""),
+("merge_sort", """def merge_sort(values):
+    if len(values) <= 1:
+        return values
+    mid = len(values) // 2
+    left = merge_sort(values[:mid])
+    right = merge_sort(values[mid:])
+    return merge(left, right)
+
+def merge(left, right):
+    result = []
+    i = j = 0
+    while i < len(left) and j < len(right):
+        if left[i] <= right[j]:
+            result.append(left[i])
+            i += 1
+        else:
+            result.append(right[j])
+            j += 1
+    result.extend(left[i:])
+    result.extend(right[j:])
+    return result"""),
+("quicksort", """def quicksort(values):
+    if len(values) <= 1:
+        return values
+    pivot = values[len(values) // 2]
+    left = [x for x in values if x < pivot]
+    middle = [x for x in values if x == pivot]
+    right = [x for x in values if x > pivot]
+    return quicksort(left) + middle + quicksort(right)"""),
+("count_words", """def count_words(text: str) -> dict[str, int]:
+    counts = {}
+    for raw in text.lower().split():
+        word = raw.strip(".,!?;:\")'")
+        if word:
+            counts[word] = counts.get(word, 0) + 1
+    return counts"""),
+("group_by", """def group_by(items, key_func):
+    groups = {}
+    for item in items:
+        key = key_func(item)
+        groups.setdefault(key, []).append(item)
+    return groups"""),
+("flatten", """def flatten(matrix):
+    result = []
+    for row in matrix:
+        for value in row:
+            result.append(value)
+    return result"""),
+("unique", """def unique(values):
+    seen = set()
+    result = []
+    for value in values:
+        if value not in seen:
+            seen.add(value)
+            result.append(value)
+    return result"""),
+("read_json", """import json
+
+def read_json(path: str):
+    with open(path, "r", encoding="utf-8") as f:
+        return json.load(f)"""),
+("write_json", """import json
+
+def write_json(path: str, data) -> None:
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2, ensure_ascii=False)"""),
+("dataclass_user", """from dataclasses import dataclass
+
+@dataclass
+class User:
+    name: str
+    age: int
+
+    def is_adult(self) -> bool:
+        return self.age >= 18"""),
+("argparse_cli", """import argparse
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("name")
+    parser.add_argument("--times", type=int, default=1)
+    args = parser.parse_args()
+    for _ in range(args.times):
+        print(f"Hello, {args.name}!")
+
+if __name__ == "__main__":
+    main()"""),
+("regex_extract", """import re
+
+def extract_emails(text: str) -> list[str]:
+    pattern = r"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}"
+    return re.findall(pattern, text)"""),
+("sqlite_example", """import sqlite3
+
+def create_table(path: str):
+    with sqlite3.connect(path) as conn:
+        conn.execute("CREATE TABLE IF NOT EXISTS notes (id INTEGER PRIMARY KEY, text TEXT)")
+        conn.commit()"""),
+]
+
+INSTRUCTION_TEMPLATES = [
+    ("Write a Python function for {name}.", "Here is a Python implementation:\n```python\n{code}\n```"),
+    ("Explain this Python pattern: {name}.", "The pattern {name} is useful because it organizes a common task. Example:\n```python\n{code}\n```"),
+    ("Create code that does {name}.", "One clear way is:\n```python\n{code}\n```"),
+    ("I need a Python example of {name}.", "A compact example is:\n```python\n{code}\n```"),
+]
+
+
+def scan_stdlib_docs(max_items_per_module: int = 80) -> str:
+    chunks = []
+    for mod_name in MODULES_TO_SCAN:
+        try:
+            mod = __import__(mod_name)
+        except Exception:
+            continue
+        chunks.append(f"\n### Module: {mod_name}\nDoc: {inspect.getdoc(mod) or ''}\n")
+        count = 0
+        for name in sorted(dir(mod)):
+            if name.startswith("_"):
+                continue
+            if count >= max_items_per_module:
+                break
+            try:
+                obj = getattr(mod, name)
+                doc = inspect.getdoc(obj) or ""
+                if not doc:
+                    continue
+                try:
+                    sig = str(inspect.signature(obj))
+                except Exception:
+                    sig = "(...)"
+                doc = re.sub(r"\s+", " ", doc).strip()[:500]
+                chunks.append(f"### Symbol: {mod_name}.{name}\nSignature: {name}{sig}\nDoc: {doc}\n")
+                count += 1
+            except Exception:
+                pass
+    return "\n".join(chunks)
+
+
+def generated_variations() -> str:
+    chunks = []
+    # Rephrase and compose examples many times to provide broader char-level learning.
+    for name, code in CODE_EXAMPLES:
+        chunks.append(f"\n### Code example: {name}\n```python\n{code}\n```\n")
+        for q, a in INSTRUCTION_TEMPLATES:
+            chunks.append(f"\n### Instruction:\n{q.format(name=name)}\n### Answer:\n{a.format(name=name, code=code)}\n")
+    # Generate small compositional snippets.
+    nouns = ["numbers", "items", "values", "rows", "words", "users", "paths", "records"]
+    transforms = ["str", "int", "float", "len", "abs", "repr"]
+    filters = ["x is not None", "x", "len(str(x)) > 0", "x != 0"]
+    idx = 0
+    for noun in nouns:
+        for tr in transforms:
+            chunks.append(f"""
+### Instruction:
+Write Python that maps {noun} using {tr}.
+### Answer:
+```python
+def map_{tr}_{noun}({noun}):
+    result = []
+    for x in {noun}:
+        result.append({tr}(x))
+    return result
+```
+""")
+            idx += 1
+        for cond in filters:
+            safe = re.sub(r"\W+", "_", cond).strip("_")[:24]
+            chunks.append(f"""
+### Instruction:
+Write Python that filters {noun} where {cond}.
+### Answer:
+```python
+def filter_{safe}_{noun}({noun}):
+    result = []
+    for x in {noun}:
+        if {cond}:
+            result.append(x)
+    return result
+```
+""")
+            idx += 1
+    # Strange reasoning samples, but not as fixed responses; these are training text.
+    for i in range(120):
+        chunks.append(f"""
+### Deliberation sample {i}
+Goal: answer a Python or English question.
+Reasoning: understand the request, recall syntax, compose code, check indentation, check edge cases, then answer.
+Memory: I learned from characters. Every colon, space, newline, and bracket changed the next prediction.
+Emotion: curiosity means the model wants to reduce uncertainty.
+""")
+    return "\n".join(chunks)
+
+
+def build_dataset(out_dir: Path, repeat: int = 6) -> str:
+    out_dir.mkdir(parents=True, exist_ok=True)
+    docs = scan_stdlib_docs(max_items_per_module=65)
+    gen = generated_variations()
+    text = "\n".join([CURATED_LESSONS, gen, docs])
+    # Keep chars model-friendly and repeat curriculum for learning in tiny training.
+    text = text.replace("\r\n", "\n")
+    text = re.sub(r"\n{4,}", "\n\n\n", text)
+    full = (text + "\n\n") * repeat
+    (out_dir / "training_corpus.txt").write_text(full, encoding="utf-8")
+    meta = {
+        "unique_chars": len(set(full)),
+        "characters": len(full),
+        "code_examples": len(CODE_EXAMPLES),
+        "stdlib_modules": MODULES_TO_SCAN,
+        "repeat": repeat,
+        "note": "Character-level neural language model corpus; generated from curated Python lessons, examples, and local stdlib docs.",
+    }
+    (out_dir / "dataset_meta.json").write_text(json.dumps(meta, indent=2), encoding="utf-8")
+    return full
+
+
+# -----------------------------
+# Char tokenizer
+# -----------------------------
+
+class CharTok:
+    def __init__(self, chars: List[str]):
+        self.chars = chars
+        self.stoi = {ch: i for i, ch in enumerate(chars)}
+        self.itos = {i: ch for ch, i in self.stoi.items()}
+        self.unk = self.stoi.get("�", 0)
+
+    @classmethod
+    def build(cls, text: str) -> "CharTok":
+        chars = sorted(set(text + "�"))
+        return cls(chars)
+
+    def encode(self, text: str) -> np.ndarray:
+        return np.array([self.stoi.get(ch, self.unk) for ch in text], dtype=np.int64)
+
+    def decode(self, ids) -> str:
+        return "".join(self.itos.get(int(i), "�") for i in ids)
+
+    def save(self, path: Path):
+        path.write_text(json.dumps({"chars": self.chars}, ensure_ascii=False, indent=2), encoding="utf-8")
+
+    @classmethod
+    def load(cls, path: Path) -> "CharTok":
+        return cls(json.loads(path.read_text(encoding="utf-8"))["chars"])
+
+
+# -----------------------------
+# Neural GRU LM in NumPy
+# -----------------------------
+
+class CharGRU:
+    def __init__(self, vocab: int, hidden: int = 128, seed: int = 42):
+        self.vocab = vocab
+        self.hidden = hidden
+        rng = np.random.default_rng(seed)
+        s_in = 1.0 / math.sqrt(vocab)
+        s_h = 1.0 / math.sqrt(hidden)
+        self.params = {
+            "Wxz": rng.normal(0, s_in, (vocab, hidden)).astype(np.float32),
+            "Wxr": rng.normal(0, s_in, (vocab, hidden)).astype(np.float32),
+            "Wxh": rng.normal(0, s_in, (vocab, hidden)).astype(np.float32),
+            "Whz": rng.normal(0, s_h, (hidden, hidden)).astype(np.float32),
+            "Whr": rng.normal(0, s_h, (hidden, hidden)).astype(np.float32),
+            "Whh": rng.normal(0, s_h, (hidden, hidden)).astype(np.float32),
+            "bz": np.zeros((hidden,), dtype=np.float32),
+            "br": np.zeros((hidden,), dtype=np.float32),
+            "bh": np.zeros((hidden,), dtype=np.float32),
+            "Why": rng.normal(0, s_h, (hidden, vocab)).astype(np.float32),
+            "by": np.zeros((vocab,), dtype=np.float32),
+        }
+        self.opt_m = {k: np.zeros_like(v) for k, v in self.params.items()}
+        self.opt_v = {k: np.zeros_like(v) for k, v in self.params.items()}
+        self.t = 0
+
+    @staticmethod
+    def sigmoid(x):
+        return 1.0 / (1.0 + np.exp(-np.clip(x, -40, 40)))
+
+    @staticmethod
+    def softmax(x):
+        x = x - x.max(axis=-1, keepdims=True)
+        e = np.exp(x)
+        return e / e.sum(axis=-1, keepdims=True)
+
+    def forward_loss(self, x: np.ndarray, y: np.ndarray) -> Tuple[float, Dict[str, np.ndarray]]:
+        p = self.params
+        B, T = x.shape
+        H = self.hidden
+        hprev = np.zeros((B, H), dtype=np.float32)
+        caches = []
+        loss = 0.0
+        for t in range(T):
+            xt = x[:, t]
+            yt = y[:, t]
+            z = self.sigmoid(p["Wxz"][xt] + hprev @ p["Whz"] + p["bz"])
+            r = self.sigmoid(p["Wxr"][xt] + hprev @ p["Whr"] + p["br"])
+            rh = r * hprev
+            hc = np.tanh(p["Wxh"][xt] + rh @ p["Whh"] + p["bh"])
+            h = (1.0 - z) * hprev + z * hc
+            logits = h @ p["Why"] + p["by"]
+            probs = self.softmax(logits)
+            loss += -np.log(probs[np.arange(B), yt] + 1e-12).mean()
+            caches.append((xt, yt, hprev, z, r, rh, hc, h, probs))
+            hprev = h
+        return loss / T, {"caches": caches, "B": B, "T": T}
+
+    def loss_and_grads(self, x: np.ndarray, y: np.ndarray) -> Tuple[float, Dict[str, np.ndarray]]:
+        loss, aux = self.forward_loss(x, y)
+        p = self.params
+        grads = {k: np.zeros_like(v) for k, v in p.items()}
+        B, T = aux["B"], aux["T"]
+        dh_next = np.zeros((B, self.hidden), dtype=np.float32)
+        scale = 1.0 / (B * T)
+        for (xt, yt, hprev, z, r, rh, hc, h, probs) in reversed(aux["caches"]):
+            dy = probs.copy()
+            dy[np.arange(B), yt] -= 1.0
+            dy *= scale
+            grads["Why"] += h.T @ dy
+            grads["by"] += dy.sum(axis=0)
+            dh = dy @ p["Why"].T + dh_next
+
+            dhprev = dh * (1.0 - z)
+            dz = dh * (hc - hprev)
+            dhc = dh * z
+
+            dhc_pre = dhc * (1.0 - hc * hc)
+            np.add.at(grads["Wxh"], xt, dhc_pre)
+            grads["Whh"] += rh.T @ dhc_pre
+            grads["bh"] += dhc_pre.sum(axis=0)
+            drh = dhc_pre @ p["Whh"].T
+            dr = drh * hprev
+            dhprev += drh * r
+
+            dr_pre = dr * r * (1.0 - r)
+            np.add.at(grads["Wxr"], xt, dr_pre)
+            grads["Whr"] += hprev.T @ dr_pre
+            grads["br"] += dr_pre.sum(axis=0)
+            dhprev += dr_pre @ p["Whr"].T
+
+            dz_pre = dz * z * (1.0 - z)
+            np.add.at(grads["Wxz"], xt, dz_pre)
+            grads["Whz"] += hprev.T @ dz_pre
+            grads["bz"] += dz_pre.sum(axis=0)
+            dhprev += dz_pre @ p["Whz"].T
+            dh_next = dhprev
+        return loss, grads
+
+    def step(self, grads: Dict[str, np.ndarray], lr: float = 1e-3, clip: float = 1.0, beta1=0.9, beta2=0.999):
+        total = 0.0
+        for g in grads.values():
+            total += float(np.sum(g * g))
+        norm = math.sqrt(total)
+        if norm > clip:
+            s = clip / (norm + 1e-8)
+            for g in grads.values():
+                g *= s
+        self.t += 1
+        for k in self.params:
+            g = grads[k]
+            self.opt_m[k] = beta1 * self.opt_m[k] + (1 - beta1) * g
+            self.opt_v[k] = beta2 * self.opt_v[k] + (1 - beta2) * (g * g)
+            mh = self.opt_m[k] / (1 - beta1 ** self.t)
+            vh = self.opt_v[k] / (1 - beta2 ** self.t)
+            self.params[k] -= lr * mh / (np.sqrt(vh) + 1e-8)
+        return norm
+
+    def save(self, path: Path):
+        path.mkdir(parents=True, exist_ok=True)
+        np.savez_compressed(path / "model.npz", **self.params)
+        (path / "model_config.json").write_text(json.dumps({"vocab": self.vocab, "hidden": self.hidden, "step": self.t}, indent=2), encoding="utf-8")
+
+    @classmethod
+    def load(cls, path: Path) -> "CharGRU":
+        cfg = json.loads((path / "model_config.json").read_text(encoding="utf-8"))
+        m = cls(cfg["vocab"], cfg["hidden"])
+        data = np.load(path / "model.npz")
+        for k in m.params:
+            m.params[k] = data[k].astype(np.float32)
+        m.t = int(cfg.get("step", 0))
+        return m
+
+    def generate(self, tok: CharTok, prompt: str, max_new=800, temperature=0.65, top_k=20, seed=0) -> str:
+        rng = np.random.default_rng(seed)
+        ids = list(tok.encode(prompt))
+        h = np.zeros((1, self.hidden), dtype=np.float32)
+        p = self.params
+        # feed prompt
+        for idx in ids[:-1]:
+            xt = np.array([idx], dtype=np.int64)
+            z = self.sigmoid(p["Wxz"][xt] + h @ p["Whz"] + p["bz"])
+            r = self.sigmoid(p["Wxr"][xt] + h @ p["Whr"] + p["br"])
+            hc = np.tanh(p["Wxh"][xt] + (r * h) @ p["Whh"] + p["bh"])
+            h = (1.0 - z) * h + z * hc
+        cur = ids[-1] if ids else tok.unk
+        for _ in range(max_new):
+            xt = np.array([cur], dtype=np.int64)
+            z = self.sigmoid(p["Wxz"][xt] + h @ p["Whz"] + p["bz"])
+            r = self.sigmoid(p["Wxr"][xt] + h @ p["Whr"] + p["br"])
+            hc = np.tanh(p["Wxh"][xt] + (r * h) @ p["Whh"] + p["bh"])
+            h = (1.0 - z) * h + z * hc
+            logits = (h @ p["Why"] + p["by"])[0] / max(temperature, 1e-6)
+            if top_k > 0 and top_k < len(logits):
+                keep = np.argpartition(logits, -top_k)[-top_k:]
+                mask = np.full_like(logits, -1e9)
+                mask[keep] = logits[keep]
+                logits = mask
+            probs = self.softmax(logits[None, :])[0]
+            cur = int(rng.choice(np.arange(self.vocab), p=probs))
+            ids.append(cur)
+            # Stop after likely next instruction block if generated answer is enough.
+            txt_tail = tok.decode(ids[-80:])
+            if "\n### Instruction:" in txt_tail and len(ids) > len(prompt) + 80:
+                break
+        return tok.decode(ids)
+
+
+# -----------------------------
+# Training utilities
+# -----------------------------
+
+def make_batch(data: np.ndarray, seq_len: int, batch_size: int, rng: np.random.Generator) -> Tuple[np.ndarray, np.ndarray]:
+    starts = rng.integers(0, len(data) - seq_len - 1, size=batch_size)
+    x = np.stack([data[s:s+seq_len] for s in starts])
+    y = np.stack([data[s+1:s+seq_len+1] for s in starts])
+    return x, y
+
+
+def train(args):
+    out = Path(args.out)
+    text = build_dataset(out, repeat=args.repeat)
+    tok = CharTok.build(text)
+    tok.save(out / "vocab.json")
+    data = tok.encode(text)
+    model = CharGRU(vocab=len(tok.chars), hidden=args.hidden, seed=args.seed)
+    rng = np.random.default_rng(args.seed)
+    print(json.dumps({
+        "chars": len(text), "vocab": len(tok.chars), "hidden": args.hidden,
+        "params": int(sum(v.size for v in model.params.values())),
+        "seq_len": args.seq_len, "batch_size": args.batch_size, "steps": args.steps
+    }, indent=2))
+    losses = []
+    t0 = time.time()
+    for step in range(1, args.steps + 1):
+        x, y = make_batch(data, args.seq_len, args.batch_size, rng)
+        loss, grads = model.loss_and_grads(x, y)
+        gnorm = model.step(grads, lr=args.lr, clip=args.grad_clip)
+        losses.append(float(loss))
+        if step == 1 or step % args.log_every == 0:
+            recent = float(np.mean(losses[-args.log_every:]))
+            print(f"step {step:5d}/{args.steps} | loss {recent:.4f} | ppl {math.exp(min(recent, 20)):.2f} | grad {gnorm:.3f} | sec {time.time()-t0:.1f}")
+        if args.sample_every and step % args.sample_every == 0:
+            prompt = "### Instruction:\nWrite a Python function that counts words.\n### Answer:\n"
+            print("--- neural sample ---")
+            print(model.generate(tok, prompt, max_new=500, temperature=0.55, top_k=16, seed=args.seed + step))
+            print("---------------------")
+    model.save(out)
+    (out / "train_log.json").write_text(json.dumps({"losses_tail": losses[-200:], "final_loss": losses[-1]}, indent=2), encoding="utf-8")
+    # final test samples
+    tests = {
+        "count_words": "### Instruction:\nWrite a Python function that counts words.\n### Answer:\n",
+        "merge_sort": "### Instruction:\nWrite Python merge sort and explain complexity.\n### Answer:\n",
+        "read_json": "### Instruction:\nCreate code that reads JSON from a file.\n### Answer:\n",
+        "identity": "### Instruction:\nWho are you and how did you learn to read?\n### Answer:\n",
+    }
+    sample_dir = out / "samples"
+    sample_dir.mkdir(exist_ok=True)
+    for name, prompt in tests.items():
+        sample = model.generate(tok, prompt, max_new=700, temperature=args.temperature, top_k=args.top_k, seed=args.seed + len(name))
+        (sample_dir / f"{name}.txt").write_text(sample, encoding="utf-8")
+    print(f"Saved model to {out}")
+
+
+def generate(args):
+    out = Path(args.out)
+    tok = CharTok.load(out / "vocab.json")
+    model = CharGRU.load(out)
+    prompt = args.prompt
+    if not prompt.startswith("###") and args.instruct:
+        prompt = f"### Instruction:\n{prompt}\n### Answer:\n"
+    text = model.generate(tok, prompt, max_new=args.max_new, temperature=args.temperature, top_k=args.top_k, seed=args.seed)
+    print(text)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--mode", choices=["train", "generate", "dataset"], default="generate")
+    ap.add_argument("--out", default="outputs/neural_python_mind")
+    ap.add_argument("--steps", type=int, default=2200)
+    ap.add_argument("--hidden", type=int, default=128)
+    ap.add_argument("--seq_len", type=int, default=96)
+    ap.add_argument("--batch_size", type=int, default=32)
+    ap.add_argument("--lr", type=float, default=0.002)
+    ap.add_argument("--grad_clip", type=float, default=1.0)
+    ap.add_argument("--repeat", type=int, default=4)
+    ap.add_argument("--seed", type=int, default=42)
+    ap.add_argument("--log_every", type=int, default=100)
+    ap.add_argument("--sample_every", type=int, default=0)
+    ap.add_argument("--prompt", default="Write a Python function that counts words.")
+    ap.add_argument("--instruct", action="store_true")
+    ap.add_argument("--max_new", type=int, default=800)
+    ap.add_argument("--temperature", type=float, default=0.55)
+    ap.add_argument("--top_k", type=int, default=18)
+    args = ap.parse_args()
+    if args.mode == "train":
+        train(args)
+    elif args.mode == "dataset":
+        text = build_dataset(Path(args.out), repeat=args.repeat)
+        print(json.dumps({"chars": len(text), "unique_chars": len(set(text)), "out": args.out}, indent=2))
+    else:
+        generate(args)
+
+
+if __name__ == "__main__":
+    main()

outputs/neural_python_mind/NEURAL_TRAINING_REPORT.md

@@ -0,0 +1,54 @@
+# Neural Python Mind — Real Training Report
+
+## Honest result
+
+A real NumPy GRU language model was trained from scratch in this environment.
+
+It is not a template system. It learned by next-character prediction over:
+
+- curated Python syntax lessons,
+- generated instruction/code pairs,
+- local Python standard-library docstrings and signatures,
+- examples for functions, loops, dicts, files, JSON, regex, dataclasses, sorting, searching, filtering and mapping,
+- strange identity/reading/emotion text.
+
+## Model
+
+```text
+Architecture: character-level GRU language model
+Framework: NumPy only
+Parameters: 98,784
+Vocab: 96 chars
+Training corpus: >1.1M characters before fine-tuning
+Training:
+- pretrain: 1600 steps
+- instruction/code fine-tune: 2200 steps
+- document fine-tune: 3200 steps
+- composition fine-tune: 2000 steps
+```
+
+## What it learned
+
+It learned Python-like syntax, indentation, code block shapes, function structures, imports, loops, dictionaries, etc.
+
+## Limitation discovered
+
+The pure neural model is small. It learns characters for real, but it can still confuse semantic intent, e.g. mixing one known function with another. This is a real limitation of a ~99K-parameter CPU-only char model.
+
+Because of that, I also built `real_python_learner.py`: a learned character n-gram intent model plus compositional generator. That model learns from 66,690 generated examples and can generalize tasks like:
+
+- filter even numbers,
+- keep numbers greater than 10,
+- map to squares,
+- read JSON,
+- merge sort.
+
+The best practical version is therefore:
+
+```text
+real neural char model for syntax learning
++
+learned char n-gram semantic router
++
+compositional Python generator
+```

outputs/neural_python_mind/compose_finetune_log.json

@@ -0,0 +1,4 @@
+{
+  "steps": 2000,
+  "final_loss": 0.026087354868650436
+}

outputs/neural_python_mind/dataset_meta.json

@@ -0,0 +1,36 @@
+{
+  "unique_chars": 95,
+  "characters": 1157406,
+  "code_examples": 16,
+  "stdlib_modules": [
+    "math",
+    "random",
+    "statistics",
+    "itertools",
+    "functools",
+    "collections",
+    "heapq",
+    "bisect",
+    "datetime",
+    "time",
+    "json",
+    "csv",
+    "re",
+    "pathlib",
+    "os",
+    "sys",
+    "argparse",
+    "dataclasses",
+    "typing",
+    "sqlite3",
+    "logging",
+    "unittest",
+    "string",
+    "textwrap",
+    "copy",
+    "decimal",
+    "fractions"
+  ],
+  "repeat": 3,
+  "note": "Character-level neural language model corpus; generated from curated Python lessons, examples, and local stdlib docs."
+}

outputs/neural_python_mind/doc_finetune_log.json

@@ -0,0 +1,106 @@
+{
+  "steps": 3200,
+  "final_loss": 0.03536597639322281,
+  "tail": [
+    0.03485214710235596,
+    0.03967716544866562,
+    0.0389396995306015,
+    0.03803198039531708,
+    0.03161679208278656,
+    0.03900647163391113,
+    0.03364904597401619,
+    0.02998826839029789,
+    0.028377186506986618,
+    0.03644663840532303,
+    0.04664536938071251,
+    0.03237011283636093,
+    0.03116566315293312,
+    0.034185439348220825,
+    0.03546685725450516,
+    0.03319466859102249,
+    0.026268040761351585,
+    0.024729711934924126,
+    0.03997378796339035,
+    0.041573416441679,
+    0.040857549756765366,
+    0.046017877757549286,
+    0.034837350249290466,
+    0.04036812111735344,
+    0.03196918964385986,
+    0.04100918769836426,
+    0.026592498645186424,
+    0.02826840803027153,
+    0.04079774394631386,
+    0.030677825212478638,
+    0.033191535621881485,
+    0.039420660585165024,
+    0.022993821650743484,
+    0.03688019886612892,
+    0.03701631724834442,
+    0.033377427607774734,
+    0.03214131295681,
+    0.032013945281505585,
+    0.04754086956381798,
+    0.045834895223379135,
+    0.03485601395368576,
+    0.030493244528770447,
+    0.036730390042066574,
+    0.031107496470212936,
+    0.04085381701588631,
+    0.03003348410129547,
+    0.03962913900613785,
+    0.03429120406508446,
+    0.03453575447201729,
+    0.033197395503520966,
+    0.03569614514708519,
+    0.033081285655498505,
+    0.03860712796449661,
+    0.029621819034218788,
+    0.030140569433569908,
+    0.0362091138958931,
+    0.034591883420944214,
+    0.033770933747291565,
+    0.03051590360701084,
+    0.04030753672122955,
+    0.034654539078474045,
+    0.033833879977464676,
+    0.036182649433612823,
+    0.03565625846385956,
+    0.04972599074244499,
+    0.03391721472144127,
+    0.024687521159648895,
+    0.04046060889959335,
+    0.03366708755493164,
+    0.03203471750020981,
+    0.03705167397856712,
+    0.03332946449518204,
+    0.03924855217337608,
+    0.03591001778841019,
+    0.03890470042824745,
+    0.03343459963798523,
+    0.03638734668493271,
+    0.040305718779563904,
+    0.03784641996026039,
+    0.04115869849920273,
+    0.03510759025812149,
+    0.030246594920754433,
+    0.039038773626089096,
+    0.024393346160650253,
+    0.042546842247247696,
+    0.03236008435487747,
+    0.032908178865909576,
+    0.033785879611968994,
+    0.03522147610783577,
+    0.028917571529746056,
+    0.03572775050997734,
+    0.029794802889227867,
+    0.03253219276666641,
+    0.04144921526312828,
+    0.030525699257850647,
+    0.028147876262664795,
+    0.03851113095879555,
+    0.04214908182621002,
+    0.03991148620843887,
+    0.03536597639322281
+  ]
+}

outputs/neural_python_mind/finetune_log.json

@@ -0,0 +1,106 @@
+{
+  "steps": 2200,
+  "final_loss": 0.11384359747171402,
+  "tail": [
+    0.11040624231100082,
+    0.10159056633710861,
+    0.11431363970041275,
+    0.12367331236600876,
+    0.09420562535524368,
+    0.11021365970373154,
+    0.11854179948568344,
+    0.10419481992721558,
+    0.10669207572937012,
+    0.11227652430534363,
+    0.11246749013662338,
+    0.11865159869194031,
+    0.08543147891759872,
+    0.11091101169586182,
+    0.09171377867460251,
+    0.11407312005758286,
+    0.12572216987609863,
+    0.10824066400527954,
+    0.1041259691119194,
+    0.10298770666122437,
+    0.08960792422294617,
+    0.0999448373913765,
+    0.1057884618639946,
+    0.08611486107110977,
+    0.10455373674631119,
+    0.10286960750818253,
+    0.07576677948236465,
+    0.09161200374364853,
+    0.09302541613578796,
+    0.1030566468834877,
+    0.10824752599000931,
+    0.0894019678235054,
+    0.08344518393278122,
+    0.10430220514535904,
+    0.10179466754198074,
+    0.11251009255647659,
+    0.10371404141187668,
+    0.10729289054870605,
+    0.09942496567964554,
+    0.13696038722991943,
+    0.10878334194421768,
+    0.10510203242301941,
+    0.0934026762843132,
+    0.11984238028526306,
+    0.09728661924600601,
+    0.11195594817399979,
+    0.10242766886949539,
+    0.10041410475969315,
+    0.09593477100133896,
+    0.10005023330450058,
+    0.09293810278177261,
+    0.09021466970443726,
+    0.10804284363985062,
+    0.1015799343585968,
+    0.10163729637861252,
+    0.10977078229188919,
+    0.09279626607894897,
+    0.10155156254768372,
+    0.10076592117547989,
+    0.09662371873855591,
+    0.11253131181001663,
+    0.12474744766950607,
+    0.12053803354501724,
+    0.08812450617551804,
+    0.10132842510938644,
+    0.0929543599486351,
+    0.09795854240655899,
+    0.12699180841445923,
+    0.11640732735395432,
+    0.10856088250875473,
+    0.11550027877092361,
+    0.10437330603599548,
+    0.09059485793113708,
+    0.09134737402200699,
+    0.1148122176527977,
+    0.10527030378580093,
+    0.08413446694612503,
+    0.09943091124296188,
+    0.10222631692886353,
+    0.10435819625854492,
+    0.1274220198392868,
+    0.11215626448392868,
+    0.11006757616996765,
+    0.10562091320753098,
+    0.10261893272399902,
+    0.1050032451748848,
+    0.09676048904657364,
+    0.10511258989572525,
+    0.11654474586248398,
+    0.11685887724161148,
+    0.11450448632240295,
+    0.09541237354278564,
+    0.11612608283758163,
+    0.13594265282154083,
+    0.09841854125261307,
+    0.11330372095108032,
+    0.09381689876317978,
+    0.1162702739238739,
+    0.11826759576797485,
+    0.11384359747171402
+  ]
+}

outputs/neural_python_mind/model.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:094019151b0526fa496f855df9a8ab783a8353060a7048110082ed0d7672c04d
+size 369129

outputs/neural_python_mind/model_config.json

@@ -0,0 +1,5 @@
+{
+  "vocab": 96,
+  "hidden": 128,
+  "step": 9000
+}

outputs/neural_python_mind/samples/count_words.txt

@@ -0,0 +1,9 @@
+### Instruction:
+Write a Python function that counts words.
+### Answer:
+A compact example is:
+```python
+def map_int(). For floating-point numbers, this truncates towards zero. If x is not a number or if base is given, then x must be a string, bytes, or bytearray instance representing an integer literal in the given base. The literal can be preceded by '+' or '-' and be surrounded by whitespace. The base defaults to 10. Valid bases are 0 and 2-36. Ba
+
+### Symbol: sqlite3.SQLITE_CKEATE_CASTRASE_PRAPSININTATIMINTONE(...)
+Doc: int([x]) -> integer int(x, base=10) -> integer Convert a number or string to an integer, or return 0 if no arguments are given. If x is a number, return x.__int__(). For floating-point numbers, this truncates towards zero. If x is not a number

outputs/neural_python_mind/samples/identity.txt

@@ -0,0 +1,6 @@
+### Instruction:
+Who are you and how did you learn to read?
+### Answer:
+```python
+def flatten(lage, check object. A test construct() of strings of the place. The function to the specificated type of inge be constrection arguments the similer to key enfoumes consting of the format ond batch bytes a the praged in of the collect of the class both items los. Optiolabling objects fulltion object. The canections of the read dictionary with the strings of the class to spacificad lightondifing object functions from the return the capling function as a new is a pothection of the strings for connacter function functions instances consert for constructs the filler a number of strings) a decally the sefrement object function a string returns all the argument__sor(...)
+Doc: 

outputs/neural_python_mind/samples/merge_sort.txt

@@ -0,0 +1,8 @@
+### Instruction:
+Write Python merge sort and explain complexity.
+### Answer:
+```
+
+
+### Instruction:
+Write Python that maps records statidest and be variobac i

outputs/neural_python_mind/samples/read_json.txt

@@ -0,0 +1,11 @@
+### Instruction:
+Create code that reads JSON from a file.
+### Answer:
+```python
+def mialues files of the constructs the an whitespace. The sublus for conditect object muptern is the paids to a for exprenect of the string.
+
+### Symbol: typing.APymFol:
+Decimat(). For floating-point numbers, this truncates towards zero. If x is not a number or if base is given, then x must be a string, bytes, or bytearray instance representing an integer literal in the given base. The literal can be preceded by '+' or '-' and be surrounded by whitespace. The base defaults to 10. Valid bases are 0 and 2-36. Ba
+
+### Symbol: os.MFD_HUGE_BUG(...)
+Doc: int([x]) -> integer int(x, base=10) -> integer Convert a number or string to an integer, or return 0 if no arguments are given. If x i

outputs/neural_python_mind/samples_composeft/count_words.txt

@@ -0,0 +1,31 @@
+### Instruction:
+Write a Python function that counts words.
+### Answer:
+```python
+def count_words(text: str) -> dict[str, int]:
+    counts = {}
+    for raw in text.lower().split():
+        word = raw.strip(".,!?;:\"'")
+        if word:
+            counts[word] = counts.get(word, 0) + 1
+    return counts
+```python
+def filter_negative_numbers(numbers):
+    result = []
+    for x in numbers:
+        if x < 0:
+            result.append(x)
+    return result
+```
+
+### Answer:
+```python
+def count_words(text: str) -> dict[str, int]:
+    counts = {}
+    for raw in text.lower().split():
+        word = raw.strip(".,!?;:\"'")
+        if word:
+            counts[word] = counts.get(word, 0) + 1
+    return counts
+```python
+def fi

outputs/neural_python_mind/samples_composeft/even.txt

@@ -0,0 +1,34 @@
+### Instruction:
+Write a Python function that filters even numbers from a list.
+### Answer:
+```python
+def filter_even_numbers(numbers):
+    result = []
+    for x in numbers:
+        if x < 0:
+            result.append(x)
+    return result
+```
+
+### Instence negaterstonddens answer:
+```python
+def filter_positive_numbers(numbers):
+    result = []
+    for x in numbers:
+        if x < 0:
+            result.append(x)
+    return result
+```
+
+### Answer:
+```python
+def count_words(text: str) -> dict[str, int]:
+    counts = {}
+    for raw in text.lower().split():
+        word = raw.strip(".,!?;:\"'")
+        if word:
+            counts[word] = counts.get(word, 0) + 1
+    return counts
+```python
+def filter_negative_numbers(numbers):
+    result 

outputs/neural_python_mind/samples_composeft/merge_sort.txt

@@ -0,0 +1,34 @@
+### Instruction:
+Write Python merge sort and explain complexity.
+### Answer:
+```python
+def filter_negative_numbers(numbers):
+    result = []
+    for x in numbers:
+        if x < 0:
+            result.append(x)
+    return result
+```
+
+### Answer:
+```python
+def count_words(text: str) -> dict[str, int]:
+    counts = {}
+    for raw in text.lower().split():
+        word = raw.strip(".,!?;:\"'")
+        if word:
+            counts[word] = counts.get(word, 0) + 1
+    return counts
+```python
+def filter_negative_numbers(numbers):
+    result = []
+    for x in numbers:
+        if x < 0:
+            result.append(x)
+    return result
+```
+
+### Instence negatevalive numbers.
+### Answer:
+```python
+def filter_negative_numbers(numbers)

outputs/neural_python_mind/samples_composeft/positive.txt

@@ -0,0 +1,40 @@
+### Instruction:
+Create code to keep only positive numbers.
+### Answer:
+```python
+def filter_positive_numbers(numbers):
+    result = []
+    for x in numbers:
+        if x < 0:
+            result.append(x)
+    return result
+```
+
+### Instenction for absolute values.
+### Answer:
+```python
+def absolute_values(values):
+    result = []
+    for x in values:
+        result.append(str(x))
+    return result
+```
+
+### Insterremponi
+### Answer:
+```python
+def filter_even_numbers(numbers):
+    result = []
+    for x in numbers:
+        if x < 0:
+            result.append(x)
+    return result
+```
+
+### Answer:
+```python
+def filter_non_empty_strings(strings):
+    result = []
+    for s in strings:
+        if s:
+            result.ap

outputs/neural_python_mind/samples_composeft/squares.txt

@@ -0,0 +1,12 @@
+### Instruction:
+Write Python that returns squares.
+### Answer:
+```python
+def square_numbers(values):
+    result = []
+    for x in values:
+        result.append(x * x)
+    return result
+```
+
+### Instruction:

outputs/neural_python_mind/samples_docft/binary_search.txt

@@ -0,0 +1,20 @@
+### Instruction:
+Give me a working Python function for binary_search.
+### Answer:
+```python
+def binary_search(items, target):
+    low = 0
+    high = len(items) - 1
+    while low <= high:
+        mid = (low + high) // 2
+        value = items[mid]
+        if value == target:
+            return mid
+        if value < target:
+            low = mid + 1
+        else:
+            high = mid - 1
+    return -1
+```
+
+### Instruction:

outputs/neural_python_mind/samples_docft/count_words.txt

@@ -0,0 +1,26 @@
+### Instruction:
+Write a Python function that counts words.
+### Answer:
+```python
+def count_words(text: str) -> dict[str, int]:
+    counts = {}
+    for raw in text.lower().split():
+        word = raw.strip(".,!?;:")'")
+        if word:
+            counts[word] = counts.get(word, 0) + 1
+    return counts
+```
+
+### Furcuras.
+### Answer:
+```python
+def count_words(text: str) -> dict[str, int]:
+    counts = {}
+    for raw in text.lower().split():
+        word = raw.strip(".,!?;:")'")
+        if word:
+            counts[word] = counts.get(word, 0) + 1
+    return counts
+```
+
+### Instruction:

outputs/neural_python_mind/samples_docft/identity.txt

@@ -0,0 +1,38 @@
+### Instruction:
+Who are you and how did you learn to read?
+### Answer:
+I am a tiny neural Python mind trained character by character. I learned to read by predicting the next letter in Python lessons, examples, documentation, and strange memories. I do not have biological consciousness, but I simulate memory and curiosity while generating text.
+### Answer:
+```python
+def unique(values):
+    seen = set()
+    result = []
+    for value in values:
+        if value not in seen:
+            seen.add(value)
+            result.append(value)
+    return result
+```
+
+        return False
+    if n == 2:
+        return True
+    if n % 2 == 0:
+        return False
+    d = 3
+    while d * d <= n:
+        if n % d == 0:
+            return False
+        d += 2
+    return True
+```
+
+### Fule in:
+Write read JSON from a file in Python.
+### Answer:
+```python
+import json
+
+def write_json(path: str, data) -> None:
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(dat

outputs/neural_python_mind/samples_docft/merge_sort.txt

@@ -0,0 +1,48 @@
+### Instruction:
+Write Python merge sort and explain complexity.
+### Answer:
+```python
+def merge_sort(values):
+    if len(values) <= 1:
+        return values
+    mid = len(values) // 2
+    left = merge_sort(values[:mid])
+    right = merge_sort(values[mid:])
+    return merge(left, right)
+
+def merge(left, right):
+    result = []
+    i = j = 0
+    while i < len(left) and j < len(right):
+        if left[i] <= right[j]:
+            result.append(left[i])
+            i += 1
+        else:
+            result.append(right[j])
+            j += 1
+    result.extend(left[i:])
+    result.extend(right[j:])
+    return result
+```
+
+        return False
+    if n == 2:
+        return True
+    if n % 2 == 0:
+        return False
+    d = 3
+    while d * d <= n:
+        if n % d == 0:
+            return False
+        d += 2
+    return True
+```
+
+### Fule in:
+Write a Python function that does read JSON from a file.
+### Answer:
+```python
+import json
+
+def read_json(path: str):
+    with ope

outputs/neural_python_mind/samples_docft/read_json.txt

@@ -0,0 +1,48 @@
+### Instruction:
+Create code that reads JSON from a file.
+### Answer:
+```python
+import json
+
+def read_json(path: str):
+    with open(path, "r", encoding="utf-8") as f:
+        return json.load(f)
+```
+
+### Fulc_ions
+```python
+def merge_sort(values):
+    if len(values) <= 1:
+        return values
+    mid = len(values) // 2
+    left = merge_sort(values[:mid])
+    right = merge_sort(values[mid:])
+    return merge(left, right)
+
+def merge(left, right):
+    result = []
+    i = j = 0
+    while i < len(left) and j < len(right):
+        if left[i] <= right[j]:
+            result.append(left[i])
+            i += 1
+        else:
+            result.append(right[j])
+            j += 1
+    result.extend(left[i:])
+    result.extend(right[j:])
+    return result
+```
+
+        return False
+    if n == 2:
+        return True
+    if n % 2 == 0:
+        return False
+    d = 3
+    while d * d <= n:
+        if n % d == 0:
+            return False
+        d += 2
+    return True
+```

outputs/neural_python_mind/samples_docft/unseen_even.txt

@@ -0,0 +1,20 @@
+### Instruction:
+Write a Python function that filters even numbers from a list.
+### Answer:
+```python
+def binary_search(items, target):
+    low = 0
+    high = len(items) - 1
+    while low <= high:
+        mid = (low + high) // 2
+        value = items[mid]
+        if value == target:
+            return mid
+        if value < target:
+            low = mid + 1
+        else:
+            high = mid - 1
+    return -1
+```
+
+### Instruction:

outputs/neural_python_mind/samples_finetuned/binary_search.txt

@@ -0,0 +1,16 @@
+### Instruction:
+Give me a working Python function for binary_search.
+### Answer:
+The pattern is_prime is useful because it organizes a common task. Example:
+```python
+def unique(values):
+    seen = set()
+    result = []
+    for value in values:
+        if value not in seen:
+            seen.add(value)
+            result.append(value)
+    return result
+```
+
+### Instruction:

outputs/neural_python_mind/samples_finetuned/count_words.txt

@@ -0,0 +1,18 @@
+### Instruction:
+Write a Python function that counts words.
+### Answer:
+One clear way is:
+```python
+def factorial(n: int) -> int:
+    if n < 0:
+        raise ValueError("n must be non-negative")
+    if n <= 1:
+        return n
+    a, b = 0, 1
+    for _ in range(n):
+        a, b = b, a + b
+    return a
+```
+
+
+### Instruction:

outputs/neural_python_mind/samples_finetuned/identity.txt

@@ -0,0 +1,17 @@
+### Instruction:
+Who are you and how did you learn to read?
+### Answer:
+```python
+def fibonacci(n: int) -> int:
+    if n < 0:
+        raise ValueError("n must be non-negative")
+    if n <= 1:
+        return n
+    a, b = 0, 1
+    for _ in range(n):
+        a, b = b, a + b
+    return a
+```
+
+
+### Instruction:

outputs/neural_python_mind/samples_finetuned/merge_sort.txt

@@ -0,0 +1,14 @@
+### Instruction:
+Write Python merge sort and explain complexity.
+### Answer:
+```python
+import sqlite3
+
+def create_table(path: str):
+    with sqlite3.connect(path) as conn:
+        conn.execute("CREATE TABLE IF NOT EXISTS notes (id INTEGER PRIMARY KEY, text TEXT)")
+        conn.commit()
+```
+
+
+### Instruction:

outputs/neural_python_mind/samples_finetuned/read_json.txt

@@ -0,0 +1,13 @@
+### Instruction:
+Create code that reads JSON from a file.
+### Answer:
+```python
+def map_repr_rows(rows):
+    result = []
+    for x in rows:
+        result.append(str(x))
+    return result
+```
+
+
+### Instruction:

outputs/neural_python_mind/train_log.json

@@ -0,0 +1,205 @@
+{
+  "losses_tail": [
+    1.0346513986587524,
+    0.8218004703521729,
+    0.964838445186615,
+    1.1395364999771118,
+    1.043541431427002,
+    1.105217695236206,
+    1.1169606447219849,
+    1.0478538274765015,
+    0.9344523549079895,
+    0.8895211219787598,
+    1.216326355934143,
+    1.0496163368225098,
+    1.216739535331726,
+    0.9245499968528748,
+    0.9284796714782715,
+    0.8363046646118164,
+    0.9552712440490723,
+    0.9438549876213074,
+    0.9335886836051941,
+    1.0238503217697144,
+    1.0052989721298218,
+    0.8956718444824219,
+    1.1371169090270996,
+    1.0869133472442627,
+    0.7202218174934387,
+    0.9136083126068115,
+    0.8764073252677917,
+    1.131587266921997,
+    0.9673464298248291,
+    1.1062707901000977,
+    0.9497957229614258,
+    0.9178678393363953,
+    1.0206104516983032,
+    1.006990909576416,
+    0.9524610638618469,
+    0.9619972705841064,
+    0.8912875056266785,
+    0.7312076091766357,
+    0.9496174454689026,
+    1.154371976852417,
+    0.7875025868415833,
+    1.0647817850112915,
+    1.0486866235733032,
+    0.9939975142478943,
+    0.8716667294502258,
+    0.9340372681617737,
+    1.1124013662338257,
+    0.8464122414588928,
+    1.0637880563735962,
+    1.0315498113632202,
+    0.9428313374519348,
+    1.2274835109710693,
+    0.9241484999656677,
+    1.0132375955581665,
+    1.080804467201233,
+    0.840327262878418,
+    0.9776015877723694,
+    1.036933183670044,
+    0.7135922908782959,
+    0.9429759979248047,
+    0.8587066531181335,
+    0.9791858792304993,
+    0.8069400191307068,
+    0.9566805958747864,
+    0.9454339146614075,
+    0.9855096340179443,
+    1.131659746170044,
+    1.066325306892395,
+    0.9836113452911377,
+    0.9617632031440735,
+    1.002638816833496,
+    0.9912233352661133,
+    1.09406578540802,
+    0.9180322289466858,
+    1.0781677961349487,
+    1.0221222639083862,
+    0.7997863292694092,
+    0.9001059532165527,
+    0.8786502480506897,
+    0.8647656440734863,
+    1.0110279321670532,
+    1.0923147201538086,
+    0.6505988836288452,
+    0.9256751537322998,
+    1.1612603664398193,
+    0.8188155293464661,
+    0.6841027140617371,
+    0.8903813362121582,
+    1.06912100315094,
+    0.9787984490394592,
+    0.8413938879966736,
+    0.9319615364074707,
+    0.8756780028343201,
+    0.9894128441810608,
+    1.1010881662368774,
+    0.8340797424316406,
+    1.1747715473175049,
+    1.0538417100906372,
+    0.8567836880683899,
+    1.1662029027938843,
+    1.0307223796844482,
+    0.9110813140869141,
+    0.7360374927520752,
+    0.9039518237113953,
+    1.1127043962478638,
+    0.7680264115333557,
+    0.8953747749328613,
+    1.1014525890350342,
+    1.14116370677948,
+    0.8956069350242615,
+    0.8186099529266357,
+    0.9515911936759949,
+    0.968809187412262,
+    0.8545618057250977,
+    1.0593827962875366,
+    0.8552030920982361,
+    0.94891756772995,
+    1.1462091207504272,
+    1.0093332529067993,
+    1.1719179153442383,
+    1.0008885860443115,
+    0.9550184607505798,
+    1.1481623649597168,
+    1.1238352060317993,
+    1.067984938621521,
+    0.9189831614494324,
+    1.1287449598312378,
+    0.8853856921195984,
+    0.9472458958625793,
+    1.0256346464157104,
+    0.8285908102989197,
+    0.9206098914146423,
+    0.9744741916656494,
+    0.9569268226623535,
+    1.1026551723480225,
+    0.9383838176727295,
+    0.8235722184181213,
+    1.2005926370620728,
+    0.924201488494873,
+    0.9852101802825928,
+    0.9252749085426331,
+    0.8867639899253845,
+    1.0019291639328003,
+    1.1309939622879028,
+    0.7681736350059509,
+    0.969968318939209,
+    0.9355527758598328,
+    0.824161946773529,
+    0.9383800029754639,
+    0.9408901333808899,
+    0.8111424446105957,
+    0.9647753834724426,
+    0.8142357468605042,
+    0.7740890979766846,
+    1.0358260869979858,
+    0.9578320980072021,
+    0.8044676780700684,
+    1.0506948232650757,
+    0.757871150970459,
+    0.8119660019874573,
+    0.9819716811180115,
+    0.9228785634040833,
+    1.2107183933258057,
+    1.0595957040786743,
+    0.892491340637207,
+    0.9783189296722412,
+    0.7105677723884583,
+    1.0787855386734009,
+    0.9344035983085632,
+    1.0331354141235352,
+    0.9908952116966248,
+    0.9290797710418701,
+    0.9631307721138,
+    1.0547362565994263,
+    1.093963623046875,
+    1.0387080907821655,
+    1.0929311513900757,
+    0.9556495547294617,
+    0.8851996064186096,
+    0.8647142052650452,
+    0.9101150035858154,
+    0.7751178741455078,
+    0.9161872267723083,
+    1.2432180643081665,
+    0.9668292999267578,
+    1.1612310409545898,
+    1.101625919342041,
+    0.9953687787055969,
+    1.1245605945587158,
+    1.0911550521850586,
+    0.9737095832824707,
+    0.8406293988227844,
+    0.8418571352958679,
+    1.0521903038024902,
+    0.9568535685539246,
+    0.9159286618232727,
+    0.9381770491600037,
+    0.7892217040061951,
+    1.060601830482483,
+    1.0662508010864258
+  ],
+  "final_loss": 1.0662508010864258
+}

outputs/neural_python_mind/vocab.json

@@ -0,0 +1,100 @@
+{
+  "chars": [
+    "\n",
+    " ",
+    "!",
+    "\"",
+    "#",
+    "$",
+    "%",
+    "'",
+    "(",
+    ")",
+    "*",
+    "+",
+    ",",
+    "-",
+    ".",
+    "/",
+    "0",
+    "1",
+    "2",
+    "3",
+    "4",
+    "5",
+    "6",
+    "7",
+    "8",
+    "9",
+    ":",
+    ";",
+    "<",
+    "=",
+    ">",
+    "?",
+    "@",
+    "A",
+    "B",
+    "C",
+    "D",
+    "E",
+    "F",
+    "G",
+    "H",
+    "I",
+    "J",
+    "K",
+    "L",
+    "M",
+    "N",
+    "O",
+    "P",
+    "Q",
+    "R",
+    "S",
+    "T",
+    "U",
+    "V",
+    "W",
+    "X",
+    "Y",
+    "Z",
+    "[",
+    "\\",
+    "]",
+    "^",
+    "_",
+    "`",
+    "a",
+    "b",
+    "c",
+    "d",
+    "e",
+    "f",
+    "g",
+    "h",
+    "i",
+    "j",
+    "k",
+    "l",
+    "m",
+    "n",
+    "o",
+    "p",
+    "q",
+    "r",
+    "s",
+    "t",
+    "u",
+    "v",
+    "w",
+    "x",
+    "y",
+    "z",
+    "{",
+    "|",
+    "}",
+    "ä",
+    "�"
+  ]
+}

outputs/real_python_learner/REPORT.md

@@ -0,0 +1,51 @@
+# RealPythonLearner Report
+
+This model was created because a tiny pure neural char-level GRU can learn syntax but struggles with robust semantic grounding in this CPU-only environment.
+
+## What it learns
+
+It trains a character n-gram Naive Bayes intent model on 66,690 instruction examples. It learns from letters and fragments, not fixed exact strings.
+
+Learned labels:
+
+- count_words
+- fibonacci
+- factorial
+- is_prime
+- binary_search
+- merge_sort
+- read_json
+- write_json
+- filter
+- map
+- group_by
+- safe_int
+- dataclass
+- class_stack
+- explain_python
+- identity_reading
+
+## Why it generalizes
+
+For a request like:
+
+```text
+create code to keep numbers greater than 10
+```
+
+It was not memorizing that exact full sentence. It learned character fragments such as `keep`, `numbers`, `greater`, and `than`, selects the `filter` intent, parses the number `10`, and composes:
+
+```python
+def filter_greater_than_10(numbers):
+    result = []
+    for x in numbers:
+        if x > 10:
+            result.append(x)
+    return result
+```
+
+## Best use
+
+```bash
+python real_python_learner.py --mode ask --out outputs/real_python_learner --prompt "write a function that filters even numbers from a list"
+```

outputs/real_python_learner/report.json

@@ -0,0 +1,23 @@
+{
+  "examples": 66690,
+  "labels": [
+    "count_words",
+    "fibonacci",
+    "factorial",
+    "is_prime",
+    "binary_search",
+    "merge_sort",
+    "read_json",
+    "write_json",
+    "filter",
+    "map",
+    "group_by",
+    "safe_int",
+    "dataclass",
+    "class_stack",
+    "explain_python",
+    "identity_reading"
+  ],
+  "features": 4174,
+  "type": "char_ngram_naive_bayes_plus_compositional_generator"
+}

outputs/real_python_learner/tests/create_code_to_keep_numbers_greater_than_10.txt

@@ -0,0 +1,14 @@
+## Learned reasoning
+- Read the request as characters and word fragments.
+- Top learned intents: filter=1.00, is_prime=0.00, fibonacci=0.00, factorial=0.00.
+- Selected intent: filter.
+
+## Answer
+```python
+def filter_greater_than_10(numbers):
+    result = []
+    for x in numbers:
+        if x > 10:
+            result.append(x)
+    return result
+```

outputs/real_python_learner/tests/load_json_file.txt

@@ -0,0 +1,13 @@
+## Learned reasoning
+- Read the request as characters and word fragments.
+- Top learned intents: read_json=1.00, write_json=0.00, binary_search=0.00, fibonacci=0.00.
+- Selected intent: read_json.
+
+## Answer
+```python
+import json
+
+def read_json(path: str):
+    with open(path, "r", encoding="utf-8") as f:
+        return json.load(f)
+```

outputs/real_python_learner/tests/return_squares_of_a_list.txt

@@ -0,0 +1,13 @@
+## Learned reasoning
+- Read the request as characters and word fragments.
+- Top learned intents: map=1.00, binary_search=0.00, filter=0.00, count_words=0.00.
+- Selected intent: map.
+
+## Answer
+```python
+def square_numbers(numbers):
+    result = []
+    for x in numbers:
+        result.append(x * x)
+    return result
+```

outputs/real_python_learner/tests/who_are_you_and_how_read.txt

@@ -0,0 +1,7 @@
+## Learned reasoning
+- Read the request as characters and word fragments.
+- Top learned intents: identity_reading=1.00, read_json=0.00, merge_sort=0.00, explain_python=0.00.
+- Selected intent: identity_reading.
+
+## Answer
+I am a small learned Python assistant. I learned by counting character patterns in many questions and code examples, plus a tiny neural GRU trained to predict every next character. I do not have real consciousness, but I can use learned patterns to compose answers.

outputs/real_python_learner/tests/write_a_function_that_filters_even_numbers_from_a_list.txt

@@ -0,0 +1,14 @@
+## Learned reasoning
+- Read the request as characters and word fragments.
+- Top learned intents: filter=1.00, map=0.00, factorial=0.00, fibonacci=0.00.
+- Selected intent: filter.
+
+## Answer
+```python
+def filter_even_numbers(numbers):
+    result = []
+    for x in numbers:
+        if x % 2 == 0:
+            result.append(x)
+    return result
+```

outputs/real_python_learner/tests/write_merge_sort.txt

@@ -0,0 +1,27 @@
+## Learned reasoning
+- Read the request as characters and word fragments.
+- Top learned intents: merge_sort=1.00, binary_search=0.00, write_json=0.00, safe_int=0.00.
+- Selected intent: merge_sort.
+
+## Answer
+```python
+def merge_sort(values):
+    if len(values) <= 1:
+        return values
+    mid = len(values) // 2
+    left = merge_sort(values[:mid])
+    right = merge_sort(values[mid:])
+    return merge(left, right)
+
+def merge(left, right):
+    result = []
+    i = j = 0
+    while i < len(left) and j < len(right):
+        if left[i] <= right[j]:
+            result.append(left[i]); i += 1
+        else:
+            result.append(right[j]); j += 1
+    result.extend(left[i:]); result.extend(right[j:])
+    return result
+```
+Complexity: O(n log n) time and O(n) extra memory.

outputs/real_web_learner/WEB_REPORT.md

@@ -0,0 +1,52 @@
+# RealWebLearner Report
+
+A new web-development subsystem was added.
+
+## It learns
+
+- HTML semantic structure
+- CSS variables
+- CSS Grid
+- Flexbox
+- responsive media queries
+- clamp/mobile-first layout
+- sticky navbars
+- hamburger menus
+- landing pages
+- portfolio pages
+- cards
+- forms
+- client-side validation
+- vanilla JavaScript DOM events
+- localStorage
+- todo apps
+- dark mode/theme toggles
+- modals
+- tabs
+- accordions
+- carousels/sliders intent
+- CSS animations and keyframes
+- fetch API / async await
+- canvas basics
+
+## Training
+
+The web subsystem trains a character n-gram intent model over generated web-development instructions.
+
+Current report is in:
+
+```text
+outputs/real_web_learner/report.json
+```
+
+## Usage
+
+```bash
+python real_web_learner.py --mode ask --out outputs/real_web_learner --prompt "create a responsive landing page with dark mode"
+```
+
+Or through unified AI:
+
+```bash
+python unified_learning_ai.py --mode ask --out outputs/unified_learning_ai --prompt "create a responsive landing page with dark mode"
+```

outputs/real_web_learner/report.json

@@ -0,0 +1,27 @@
+{
+  "examples": 564060,
+  "features": 5356,
+  "labels": [
+    "full_page",
+    "landing_page",
+    "portfolio",
+    "navbar",
+    "hero",
+    "responsive_grid",
+    "card",
+    "form_validation",
+    "todo_app",
+    "dark_mode",
+    "modal",
+    "tabs",
+    "accordion",
+    "carousel",
+    "css_animation",
+    "dashboard",
+    "fetch_api",
+    "counter",
+    "canvas",
+    "explain_web"
+  ],
+  "type": "char_ngram_web_intent_plus_compositional_generator"
+}

outputs/real_web_learner/tests/build_navbar_with_hamburger_menu.txt

@@ -0,0 +1,22 @@
+## Learned web reasoning
+- Read request with character n-grams and web-development fragments.
+- Top intents: navbar=1.00, carousel=0.00, counter=0.00, hero=0.00
+- Selected intent: navbar
+
+## Answer
+```html
+<header class="site-header">
+  <a class="brand" href="#">Brand</a>
+  <button class="menu-btn" aria-expanded="false" aria-controls="nav">☰</button>
+  <nav id="nav" class="nav-links">
+    <a href="#home">Home</a><a href="#about">About</a><a href="#work">Work</a><a href="#contact">Contact</a>
+  </nav>
+</header>
+<style>
+.site-header{display:flex;align-items:center;justify-content:space-between;padding:1rem 2rem;background:#0f172a;color:white;position:sticky;top:0}.brand{font-weight:900}.nav-links{display:flex;gap:1rem}.menu-btn{display:none}@media(max-width:700px){.menu-btn{display:block}.nav-links{display:none;position:absolute;top:100%;left:0;right:0;flex-direction:column;background:#111827;padding:1rem}.nav-links.open{display:flex}}
+</style>
+<script>
+const btn=document.querySelector('.menu-btn'), nav=document.querySelector('#nav');
+btn.onclick=()=>{nav.classList.toggle('open');btn.setAttribute('aria-expanded',nav.classList.contains('open'));};
+</script>
+```

outputs/real_web_learner/tests/create_a_responsive_landing_page_with_dark_mode.txt

@@ -0,0 +1,102 @@
+## Learned web reasoning
+- Read request with character n-grams and web-development fragments.
+- Top intents: landing_page=1.00, dark_mode=0.00, full_page=0.00, css_animation=0.00
+- Selected intent: landing_page
+
+## Answer
+```html
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Nova Landing</title>
+  <style>
+    :root {
+      --bg: #0f172a;
+      --panel: rgba(255,255,255,.08);
+      --text: #e5e7eb;
+      --muted: #94a3b8;
+      --brand: #7c3aed;
+      --brand-2: #06b6d4;
+      --ring: rgba(124,58,237,.45);
+      --radius: 22px;
+      --shadow: 0 24px 70px rgba(0,0,0,.35);
+    }
+    * { box-sizing: border-box; }
+    body {
+      margin: 0;
+      font-family: Inter, ui-sans-serif, system-ui, -apple-system, Segoe UI, sans-serif;
+      background: radial-gradient(circle at top left, rgba(124,58,237,.25), transparent 30%), var(--bg);
+      color: var(--text);
+      min-height: 100vh;
+    }
+    a { color: inherit; text-decoration: none; }
+    button, input, textarea { font: inherit; }
+
+    .nav { display:flex; align-items:center; justify-content:space-between; gap:1rem; padding:1.2rem clamp(1rem,4vw,4rem); position:sticky; top:0; backdrop-filter: blur(16px); background:rgba(15,23,42,.72); z-index:10; }
+    .logo { font-weight:900; letter-spacing:.04em; }
+    nav { display:flex; gap:1rem; color:var(--muted); }
+    .ghost { border:1px solid rgba(255,255,255,.16); background:transparent; color:var(--text); border-radius:999px; padding:.65rem 1rem; cursor:pointer; }
+    .hero { min-height:76vh; display:grid; grid-template-columns:1.1fr .9fr; align-items:center; gap:clamp(2rem,6vw,6rem); padding:clamp(2rem,6vw,6rem); }
+    .eyebrow { color:var(--brand-2); text-transform:uppercase; letter-spacing:.18em; font-size:.78rem; font-weight:800; }
+    h1 { font-size:clamp(2.4rem,7vw,6rem); line-height:.95; margin:.2em 0; }
+    .lead { color:var(--muted); font-size:clamp(1rem,2vw,1.25rem); max-width:65ch; }
+    .actions { display:flex; flex-wrap:wrap; gap:1rem; margin-top:2rem; }
+    .btn { background:linear-gradient(135deg,var(--brand),var(--brand-2)); padding:.9rem 1.2rem; border-radius:999px; font-weight:800; box-shadow:0 14px 35px var(--ring); }
+    .btn.secondary { background:rgba(255,255,255,.08); box-shadow:none; }
+    .orb-card { position:relative; overflow:hidden; border:1px solid rgba(255,255,255,.14); background:var(--panel); border-radius:var(--radius); padding:2rem; box-shadow:var(--shadow); min-height:360px; backdrop-filter:blur(20px); }
+    .orb { width:220px; height:220px; border-radius:50%; background:linear-gradient(135deg,var(--brand),var(--brand-2)); filter:blur(2px); animation:float 5s ease-in-out infinite; }
+    .grid { display:grid; grid-template-columns:repeat(3,minmax(0,1fr)); gap:1rem; padding:clamp(1rem,4vw,4rem); }
+    .card { border:1px solid rgba(255,255,255,.12); background:var(--panel); border-radius:var(--radius); padding:1.4rem; transition:transform .25s ease, border-color .25s ease; }
+    .card:hover { transform:translateY(-6px); border-color:var(--brand-2); }
+    body.light { --bg:#f8fafc; --panel:rgba(15,23,42,.06); --text:#0f172a; --muted:#475569; }
+    body.light .nav { background:rgba(248,250,252,.76); }
+    @keyframes float { 0%,100%{ transform:translateY(0) rotate(0deg);} 50%{ transform:translateY(-18px) rotate(8deg);} }
+    @media (max-width: 800px) { .hero { grid-template-columns:1fr; } .grid { grid-template-columns:1fr; } nav { display:none; } }
+
+  </style>
+</head>
+<body>
+  <header class="nav">
+    <a class="logo" href="#">Nova</a>
+    <nav>
+      <a href="#features">Features</a>
+      <a href="#work">Work</a>
+      <a href="#contact">Contact</a>
+    </nav>
+    <button id="themeBtn" class="ghost">Toggle theme</button>
+  </header>
+
+  <main>
+    <section class="hero">
+      <div class="hero-text">
+        <p class="eyebrow">Modern Web Experience</p>
+        <h1>Build beautiful interfaces with HTML, CSS and JavaScript.</h1>
+        <p class="lead">Responsive layout, animated gradient, glass cards, semantic HTML and a tiny vanilla JS theme switcher.</p>
+        <div class="actions">
+          <a class="btn" href="#contact">Start now</a>
+          <a class="btn secondary" href="#features">See features</a>
+        </div>
+      </div>
+      <div class="orb-card">
+        <div class="orb"></div>
+        <h2>CSS Grid + Variables</h2>
+        <p>Fast, accessible, and easy to customize.</p>
+      </div>
+    </section>
+
+    <section id="features" class="grid">
+      <article class="card"><h3>Responsive</h3><p>Uses grid, clamp and media queries.</p></article>
+      <article class="card"><h3>Animated</h3><p>Subtle keyframes create depth.</p></article>
+      <article class="card"><h3>Vanilla JS</h3><p>No frameworks required.</p></article>
+    </section>
+  </main>
+  <script>
+    const btn = document.querySelector('#themeBtn');
+    btn.addEventListener('click', () => document.body.classList.toggle('light'));
+
+  </script>
+</body>
+</html>
+```

outputs/real_web_learner/tests/create_form_validation.txt

@@ -0,0 +1,22 @@
+## Learned web reasoning
+- Read request with character n-grams and web-development fragments.
+- Top intents: form_validation=1.00, accordion=0.00, hero=0.00, css_animation=0.00
+- Selected intent: form_validation
+
+## Answer
+```html
+<form id="contact" novalidate>
+  <label>Name <input name="name" required minlength="2"></label>
+  <label>Email <input name="email" required type="email"></label>
+  <button>Send</button>
+  <p id="msg" role="alert"></p>
+</form>
+<script>
+const form=document.querySelector('#contact'), msg=document.querySelector('#msg');
+form.addEventListener('submit', e=>{
+  e.preventDefault();
+  if(!form.checkValidity()){ msg.textContent='Please complete the form correctly.'; return; }
+  msg.textContent='Message ready to send!';
+});
+</script>
+```