Upload folder using huggingface_hub

embodied/anti_stasis.py

@@ -0,0 +1,16 @@
+"""Stable VoxForge re-export for anti-stasis control.
+
+This wrapper intentionally avoids importing from a bundled top-level ``cogcore``
+package.  It resolves an external CogCore implementation when present and falls
+back to ``voxforge_cogcore_compat`` when VoxForge is used alone.
+"""
+from __future__ import annotations
+
+from voxforge_cogcore_compat.resolver import export_anti_stasis_symbols, load_anti_stasis_api
+
+_api = load_anti_stasis_api()
+globals().update(_api.exports())
+ANTI_STASIS_API_SOURCE = _api.source
+ANTI_STASIS_API_DIAGNOSTICS = _api.to_dict()
+
+__all__ = sorted(set(export_anti_stasis_symbols().keys()) | {"ANTI_STASIS_API_SOURCE", "ANTI_STASIS_API_DIAGNOSTICS"})

embodied/gemini_commander.py

@@ -0,0 +1,416 @@
+"""
+GeminiCommander — multimodální jazyková oblast pro Phantom embodied agenta.
+
+Architektura (mozková analogie):
+  ┌──────────────┐    obrázky světa + instrukce     ┌──────────────────┐
+  │   UŽIVATEL   │ ─────────────────────────────── ▶│  GEMINI          │
+  │              │                                   │  (jazyková oblast│
+  │              │ ◀─────────────────────────────── │   Broca/Wernicke)│
+  │              │    narrace + goal_vec[32]         └────────┬─────────┘
+  └──────────────┘                                           │ goal_vec
+                                                             ▼
+                                                  ┌──────────────────────┐
+                                                  │  RL AGENT            │
+                                                  │  (hippocampus / PFC) │
+                                                  │  state[26+32] = [58] │
+                                                  │  ExperienceReplay    │
+                                                  │  VerticalPentaMemory │
+                                                  └──────────────────────┘
+
+Multimodalita:
+  - Gemini dostane: pohled shora (PNG) + póza těla (PNG) + text instrukce
+  - Gemini vrátí: strukturovaný JSON → goal_vec[32] + naraci v češtině
+
+Použití:
+  export GEMINI_API_KEY="..."
+  python -m embodied.gemini_commander --report
+  python -m embodied.gemini_commander "Zvedni hrnek a dej ho na pult"
+  python -m embodied.gemini_commander   # interaktivní chat
+"""
+from __future__ import annotations
+import os, json, sys, argparse, logging, base64, io
+from pathlib import Path
+from typing import Optional, TYPE_CHECKING
+import numpy as np
+
+from embodied.goal_encoder import GoalSpec, encode_goal, GOAL_DIM, goal_for_task
+
+if TYPE_CHECKING:
+    from PIL import Image as PILImage
+
+log = logging.getLogger("phantom.gemini")
+
+# ── Gemini REST client (přímé volání bez gRPC — funguje i v kontejnerech) ────
+
+_GEMINI_REST_URL = (
+    "https://generativelanguage.googleapis.com/v1beta/models/"
+    "{model}:generateContent"
+)
+_DEFAULT_MODEL = "gemini-2.5-flash"
+
+
+def _call_gemini(api_key: str, parts: list, model: str = _DEFAULT_MODEL) -> str:
+    """
+    Přímé volání Gemini REST API přes requests.
+    Obchází gRPC + SSL problémy v kontejnerech (verify=False).
+    parts může obsahovat stringy i inline_data dict (obrázky).
+    """
+    import requests, urllib3
+    urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+    content_parts = []
+    for p in parts:
+        if isinstance(p, str):
+            if p.strip():
+                content_parts.append({"text": p})
+        elif isinstance(p, dict) and "inline_data" in p:
+            content_parts.append({"inline_data": p["inline_data"]})
+
+    payload = {"contents": [{"parts": content_parts}]}
+    url     = _GEMINI_REST_URL.format(model=model)
+
+    resp = requests.post(
+        url,
+        json=payload,
+        params={"key": api_key},
+        verify=False,
+        timeout=45,
+    )
+    resp.raise_for_status()
+    data = resp.json()
+    return data["candidates"][0]["content"]["parts"][0]["text"]
+
+
+def _get_api_key() -> str:
+    key = os.environ.get("GEMINI_API_KEY", "")
+    if not key:
+        raise ValueError("Nastav GEMINI_API_KEY env proměnnou")
+    return key
+
+
+# ── Systémový kontext ─────────────────────────────────────────────────────────
+
+_SYSTEM_PROMPT = """
+Jsi expertní koordinátor pro Phantom Learning — systém, kde virtuální humanoidní
+robot učený metodami zpětnovazebního učení (RL) operuje ve fyzikálním simulátoru.
+
+ARCHITEKTURA:
+  Ty (Gemini) = jazyková oblast mozku (Broca/Wernicke)
+  RL agent    = hippocampus + prefrontální kůra (PFC)
+  Motorická kůra = 10-DOF pohybový systém se prsty
+
+ROBOT:
+  - 22 segmentů: hlava, krk, trup, pánev, kyčle/kolena/chodidla (L+R),
+    ramena/lokty/ruce (L+R), 4 prsty na každé ruce
+  - Akce[10]: kyčle L/R, kolena L/R, ramena L/R, lokty L/R, grip L/R
+  - grip < -0.25 = uchopení objektu (pokud je ruka do 35 cm)
+
+FYZIKA:
+  - Hrnek (keramika): rozbije se při nárazu > 4.5 m/s (pád z výšky > 1 m)
+  - Blok (dřevo): rozbije se při > 8.0 m/s
+  - Kovová klika: prakticky nezničitelná (> 14 m/s)
+
+DOSTUPNÉ ÚLOHY:
+  stand, reach, walk, stairs, maze,
+  household_pick, household_door, household_stack, household_sweep, household_sit
+
+DOMÁCNOST (household terrain):
+  - Stůl: x=10-14, z=14-18, povrch y=3 (hrnek zde)
+  - Pult: x=20-26, z=3-7, povrch y=4 (cíl pro household_pick)
+  - Židle: x=8-10, z=20-22, y=3
+  - Polička: x=2-4, z=8-22, y=1-7
+  - Dveře (mezera): x=13-17, z=0 (jih)
+
+Vždy odpovídej ČESKY pokud není řečeno jinak.
+"""
+
+_GOAL_SCHEMA_PROMPT = """
+Na základě obrázků a instrukce vrať POUZE platný JSON v tomto formátu:
+{
+  "target": "<cup|block|door|chair|table|counter|shelf|sink|none|any>",
+  "action": "<pick|carry|sweep|open|sit|walk|stand>",
+  "destination": "<counter|table|door|chair|floor|none>",
+  "phase": "<approach|grasp|carry|place>",
+  "urgency": <0.0-1.0>,
+  "grip": <-1.0 (pevný stisk) až 1.0 (otevřená ruka)>,
+  "speed": <0.0 (pomalu) až 1.0 (rychle)>,
+  "description": "<česky: co agent má dělat, max 1 věta>"
+}
+"""
+
+
+# ── GoalSpec parser ───────────────────────────────────────────────────────────
+
+def _parse_goal_json(text: str) -> GoalSpec:
+    """Extrahuj JSON ze stringu (Gemini někdy přidá markdown)."""
+    text = text.strip()
+    # Odstraň markdown code block pokud existuje
+    if "```" in text:
+        start = text.find("{")
+        end   = text.rfind("}") + 1
+        text  = text[start:end]
+    try:
+        d = json.loads(text)
+        return GoalSpec(
+            target=str(d.get("target", "none")),
+            action=str(d.get("action", "walk")),
+            destination=str(d.get("destination", "none")),
+            phase=str(d.get("phase", "approach")),
+            urgency=float(d.get("urgency", 0.5)),
+            grip=float(d.get("grip", 0.0)),
+            speed=float(d.get("speed", 0.5)),
+            description=str(d.get("description", "")),
+        )
+    except (json.JSONDecodeError, KeyError, ValueError) as e:
+        log.warning("Nepodařilo se parsovat GoalSpec JSON: %s\nText: %s", e, text[:200])
+        return GoalSpec(description=text[:100])
+
+
+# ── Gemini Commander ──────────────────────────────────────────────────────────
+
+class GeminiCommander:
+    """
+    Multimodální jazyková vrstva — Gemini jako jazyková oblast mozku.
+    Přijímá FPV obrázky světa + instrukci → vrací goal_vec[32] + naraci.
+    Používá přímé REST API (bez gRPC), funguje i v síťově izolovaných kontejnerech.
+    """
+
+    def __init__(self, log_path: Path = Path("logs/embodied_training.jsonl")):
+        self._api_key = _get_api_key()
+        self.log_path = log_path
+        self._history: list[dict] = []
+
+    # ── Multimodální goal generation ──────────────────────────────────────────
+
+    def get_goal(self,
+                 instruction: str,
+                 fpv_img=None,
+                 minimap_img=None,
+                 agent_pos=None,
+                 target_pos=None,
+                 ) -> tuple[GoalSpec, np.ndarray]:
+        """
+        Hlavní metoda: instrukce + obrázky → (GoalSpec, goal_vec[32]).
+
+        Posílá Gemini multimodálně:
+          1. FPV obraz (PNG)    — co agent SKUTEČNĚ VIDÍ ze svých očí
+                                  voxelový raycaster, ruce viditelné dole
+          2. Minimap (PNG)      — pohled shora pro prostorový kontext
+          3. Text instrukce     — co má agent dělat
+
+        Vrátí:
+          GoalSpec  — strukturovaný cíl v češtině
+          np.ndarray[32] — goal vektor pro RL agenta (hippocampus/PFC)
+        """
+        from embodied.world_renderer import image_to_gemini_part
+        parts = [_SYSTEM_PROMPT, "\n\nINSTRUKCE: " + instruction, "\n"]
+
+        if fpv_img is not None:
+            parts.insert(1, image_to_gemini_part(fpv_img))
+            parts.insert(2,
+                "\n[POHLED Z OČÍ AGENTA — voxelový FPV raycaster. "
+                "Červené objekty = hrnky, oranžové = bloky, "
+                "zelené ruce = pravá ruka agenta (viditelná dole).]\n")
+
+        if minimap_img is not None:
+            parts.append(image_to_gemini_part(minimap_img))
+            parts.append(
+                "\n[MAPA SHORA — prostorový kontext. "
+                "Modrá tečka = agent, šipka = směr pohledu, "
+                "zelené X = cíl.]\n")
+
+        parts.append(_GOAL_SCHEMA_PROMPT)
+
+        try:
+            text = _call_gemini(self._api_key, parts)
+            spec = _parse_goal_json(text)
+        except Exception as e:
+            log.warning("Gemini goal generation selhal: %s", e)
+            spec = GoalSpec(description=f"fallback: {e}")
+
+        # Doplň relativní offset pokud víme kde je cíl a agent
+        if agent_pos is not None and target_pos is not None:
+            spec.rel_x = float(target_pos[0]) - float(agent_pos[0])
+            spec.rel_y = float(target_pos[1]) - float(agent_pos[1])
+            spec.rel_z = float(target_pos[2]) - float(agent_pos[2])
+
+        vec = encode_goal(spec)
+        return spec, vec
+
+    # ── Narativní popis stavu ──────────────────────────────────────────────────
+
+    def narrate(self,
+                stats: dict,
+                topdown_img=None,
+                episode: int = 0,
+                ) -> str:
+        """
+        Na základě obrázku světa + statistik epizody vygeneruj českou naraci.
+        Simuluje roli jazykové oblasti — interpretuje co se stalo motoricky.
+        """
+        stats_str = json.dumps(stats, ensure_ascii=False, indent=2)
+        parts = [
+            _SYSTEM_PROMPT,
+            f"\n\nStatistiky epizody {episode}:\n{stats_str}\n",
+            "\nPopiš česky co agent v této epizodě dělal, co se mu povedlo/nepovedlo, "
+            "a dej konkrétní doporučení pro příští epizodu. Max 3 věty.",
+        ]
+        if topdown_img is not None:
+            from embodied.world_renderer import image_to_gemini_part
+            parts.insert(2, image_to_gemini_part(topdown_img))
+            parts.insert(3, "\n[Finální stav světa]\n")
+
+        try:
+            return _call_gemini(self._api_key, parts).strip()
+        except Exception as e:
+            return f"[Narrace nedostupná: {e}]"
+
+    # ── Zpráva o tréninku ────────────────────────────────────────────────────
+
+    def report(self) -> str:
+        summary = _load_training_summary(self.log_path)
+        parts = [
+            _SYSTEM_PROMPT,
+            f"\n\nTréninkové data:\n{summary}\n\n"
+            "Napiš česky podrobnou zprávu: co se agent naučil, kde je slabý, "
+            "a navrhni 3 konkrétní zlepšení.",
+        ]
+        try:
+            return _call_gemini(self._api_key, parts).strip()
+        except Exception as e:
+            return f"[Report nedostupný: {e}]\n\n{summary}"
+
+    # ── Konverzační chat ─────────────────────────────────────────────────────
+
+    def chat(self, user_input: str, fpv_img=None) -> str:
+        summary = _load_training_summary(self.log_path)
+        parts   = [
+            _SYSTEM_PROMPT,
+            f"\n\nAktuální data tréninku:\n{summary}\n",
+        ]
+        if fpv_img is not None:
+            from embodied.world_renderer import image_to_gemini_part
+            parts.append(image_to_gemini_part(fpv_img))
+            parts.append("\n[Aktuální FPV pohled agenta]\n")
+
+        parts.append(f"\nUžitel: {user_input}")
+        try:
+            answer = _call_gemini(self._api_key, parts).strip()
+        except Exception as e:
+            answer = f"[Chyba: {e}]"
+
+        self._history.append({"user": user_input, "assistant": answer})
+        return answer
+
+
+# ── Samostatný goal_vec bez Gemini (fallback) ─────────────────────────────────
+
+def get_goal_vec_fallback(task_name: str,
+                          agent_pos=None, target_pos=None) -> np.ndarray:
+    """Vrátí předdefinovaný goal_vec bez volání Gemini API."""
+    spec = goal_for_task(task_name)
+    if agent_pos is not None and target_pos is not None:
+        spec.rel_x = float(target_pos[0]) - float(agent_pos[0])
+        spec.rel_y = float(target_pos[1]) - float(agent_pos[1])
+        spec.rel_z = float(target_pos[2]) - float(agent_pos[2])
+    return encode_goal(spec)
+
+
+# ── Log helper ────────────────────────────────────────────────────────────────
+
+def _load_training_summary(log_path: Path) -> str:
+    if not log_path.exists():
+        return "Žádný tréninkový log nenalezen."
+    lines = [json.loads(l) for l in log_path.read_text().splitlines() if l.strip()]
+    if not lines:
+        return "Log je prázdný."
+    from collections import defaultdict
+    tasks: dict[str, list] = defaultdict(list)
+    for e in lines:
+        tasks[e["task"]].append(e)
+    parts = [f"Celkem epizod: {len(lines)}\n"]
+    for tn, eps in tasks.items():
+        rewards = [e["total_reward"] for e in eps]
+        suc = sum(1 for e in eps if e.get("success"))
+        avg = sum(rewards) / len(rewards)
+        parts.append(
+            f"  {tn}: {len(eps)} ep  avg={avg:.1f}  max={max(rewards):.1f}  "
+            f"úspěch={suc}  šum {eps[0]['noise']:.3f}→{eps[-1]['noise']:.3f}"
+        )
+    return "\n".join(parts)
+
+
+# ── CLI ───────────────────────────────────────────────────────────────────────
+
+def main():
+    logging.basicConfig(level=logging.WARNING)
+    parser = argparse.ArgumentParser(
+        description="Gemini multimodální commander pro Phantom agenta"
+    )
+    parser.add_argument("command", nargs="?",
+                        help="Přirozený jazyk příkaz / otázka")
+    parser.add_argument("--report",    action="store_true",
+                        help="Vygeneruj zprávu o tréninku")
+    parser.add_argument("--goal",      action="store_true",
+                        help="Vygeneruj goal_vec pro danou instrukci")
+    parser.add_argument("--render",    action="store_true",
+                        help="Vykresli a ulož scénu (demo bez Gemini)")
+    parser.add_argument("--log",       default="logs/embodied_training.jsonl")
+    parser.add_argument("--task",      default="household_pick",
+                        help="Úloha pro --goal bez Gemini")
+    args = parser.parse_args()
+
+    if args.render:
+        _demo_render()
+        return
+
+    try:
+        commander = GeminiCommander(log_path=Path(args.log))
+    except (ImportError, ValueError) as e:
+        print(f"Chyba inicializace Gemini: {e}")
+        print("Tip: export GEMINI_API_KEY='váš_klíč'")
+        sys.exit(1)
+
+    if args.report:
+        print(commander.report())
+    elif args.goal and args.command:
+        spec, vec = commander.get_goal(args.command)
+        print(f"GoalSpec: {spec}")
+        print(f"goal_vec shape: {vec.shape}")
+        print(f"goal_vec: {np.round(vec, 3).tolist()}")
+    elif args.command:
+        print(commander.chat(args.command))
+    else:
+        print("Phantom Gemini Commander (multimodální) — Ctrl+C pro ukončení\n")
+        while True:
+            try:
+                user_input = input("Ty: ").strip()
+                if not user_input:
+                    continue
+                print(f"\nGemini: {commander.chat(user_input)}\n")
+            except KeyboardInterrupt:
+                print("\nKonec.")
+                break
+
+
+def _demo_render():
+    """Demo: vykresli scénu bez Gemini (pro testování rendereru)."""
+    import sys; sys.path.insert(0, ".")
+    from embodied.physics_world import WorldEnv
+    from embodied.virtual_body import VirtualBody
+    from embodied.world_renderer import save_scene
+    from engine.physics.rigid_body import vec3
+
+    print("Inicializuji household svět...")
+    world = WorldEnv(seed=0, terrain_type="household")
+    body  = VirtualBody(world.phys, origin=None)
+    body.reset(vec3(8.0, 2.0, 4.0))
+    world.add_interactive_object("cup", "cup", vec3(12.0, 3.5, 16.0),
+                                 size=vec3(0.08, 0.14, 0.08), mass=0.3)
+    paths = save_scene(world, body, "/tmp/phantom_scene",
+                       target_pos=vec3(23.0, 4.5, 5.0))
+    print(f"Uloženo: {paths[0]}, {paths[1]}")
+
+
+if __name__ == "__main__":
+    main()

embodied/goal_encoder.py

@@ -0,0 +1,146 @@
+"""
+GoalEncoder — převod strukturovaného výstupu Gemini na 32-dim float vektor.
+
+Architektura (PFC/hippocampus analogie):
+  Gemini (jazyková oblast) → goal_vec[32] → RL agent (PFC/hippocampus)
+
+Vektor má pevnou strukturu:
+  [0-9]   : cílový objekt (one-hot 10 tříd)
+  [10-16] : typ akce (one-hot 7 tříd)
+  [17-22] : cílové místo (one-hot 6 tříd)
+  [23]    : naléhavost (0–1)
+  [24-26] : relativní offset cíle od agenta (normalizovaný na ±1)
+  [27-29] : fáze úlohy (soft one-hot: approach/grasp/carry/place)
+  [30]    : doporučená sila stisku (-1 = pevně, +1 = povolně)
+  [31]    : faktor rychlosti (0 = pomalu, 1 = rychle)
+"""
+from __future__ import annotations
+import numpy as np
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+GOAL_DIM = 32
+
+# ── Mapovací tabulky ──────────────────────────────────────────────────────────
+
+_OBJECTS = ["cup", "block", "door", "chair", "table", "counter", "shelf", "sink", "none", "any"]
+_ACTIONS = ["pick", "carry", "sweep", "open", "sit", "walk", "stand"]
+_DESTS   = ["counter", "table", "door", "chair", "floor", "none"]
+_PHASES  = ["approach", "grasp", "carry", "place"]
+
+
+@dataclass
+class GoalSpec:
+    """Strukturovaný cíl vrácený Gemini."""
+    target:      str   = "none"      # cílový objekt
+    action:      str   = "walk"      # akce
+    destination: str   = "none"      # kam
+    phase:       str   = "approach"  # fáze
+    urgency:     float = 0.5         # 0–1
+    grip:        float = -0.5        # -1 (pevný) → +1 (povolný)
+    speed:       float = 0.5         # 0 (pomalu) → 1 (rychle)
+    # Relativní offset cíle od agenta (volitelné, naplní WorldEnv)
+    rel_x: float = 0.0
+    rel_y: float = 0.0
+    rel_z: float = 0.0
+    # Popis pro logování
+    description: str = ""
+
+
+def encode_goal(spec: GoalSpec) -> np.ndarray:
+    """GoalSpec → float32[32]."""
+    vec = np.zeros(GOAL_DIM, dtype=np.float32)
+
+    # [0-9] target object one-hot
+    obj_idx = _OBJECTS.index(spec.target) if spec.target in _OBJECTS else _OBJECTS.index("none")
+    vec[obj_idx] = 1.0
+
+    # [10-16] action one-hot
+    act_idx = _ACTIONS.index(spec.action) if spec.action in _ACTIONS else 0
+    vec[10 + act_idx] = 1.0
+
+    # [17-22] destination one-hot
+    dst_idx = _DESTS.index(spec.destination) if spec.destination in _DESTS else _DESTS.index("none")
+    vec[17 + dst_idx] = 1.0
+
+    # [23] urgency
+    vec[23] = float(np.clip(spec.urgency, 0.0, 1.0))
+
+    # [24-26] relative offset (normalized)
+    vec[24] = float(np.clip(spec.rel_x / 20.0, -1.0, 1.0))
+    vec[25] = float(np.clip(spec.rel_y / 5.0,  -1.0, 1.0))
+    vec[26] = float(np.clip(spec.rel_z / 20.0, -1.0, 1.0))
+
+    # [27-29] fáze (soft — okolní fáze dostanou malou váhu)
+    ph_idx = _PHASES.index(spec.phase) if spec.phase in _PHASES else 0
+    for i, _ in enumerate(_PHASES):
+        dist = abs(i - ph_idx)
+        vec[27 + min(i, 2)] += max(0.0, 1.0 - dist * 0.4)
+    vec[27:30] /= (vec[27:30].sum() + 1e-8)
+
+    # [30] grip recommendation
+    vec[30] = float(np.clip(spec.grip, -1.0, 1.0))
+
+    # [31] speed
+    vec[31] = float(np.clip(spec.speed, 0.0, 1.0))
+
+    return vec
+
+
+def decode_goal(vec: np.ndarray) -> GoalSpec:
+    """float32[32] → GoalSpec (pro debugging)."""
+    obj_idx = int(np.argmax(vec[0:10]))
+    act_idx = int(np.argmax(vec[10:17]))
+    dst_idx = int(np.argmax(vec[17:23]))
+    ph_idx  = int(np.argmax(vec[27:30]))
+    return GoalSpec(
+        target=_OBJECTS[obj_idx],
+        action=_ACTIONS[act_idx],
+        destination=_DESTS[dst_idx],
+        phase=_PHASES[ph_idx],
+        urgency=float(vec[23]),
+        rel_x=float(vec[24]) * 20.0,
+        rel_y=float(vec[25]) * 5.0,
+        rel_z=float(vec[26]) * 20.0,
+        grip=float(vec[30]),
+        speed=float(vec[31]),
+    )
+
+
+# ── Předdefinované cíle pro každou úlohu ─────────────────────────────────────
+
+def goal_for_task(task_name: str) -> GoalSpec:
+    """Fallback goal_vec bez Gemini — pro trénink bez API klíče."""
+    defaults = {
+        "stand":           GoalSpec(target="none",    action="stand",  destination="none",    phase="approach", urgency=0.3, grip=0.5,  speed=0.2),
+        "reach":           GoalSpec(target="none",    action="walk",   destination="none",    phase="approach", urgency=0.6, grip=-0.2, speed=0.5),
+        "walk":            GoalSpec(target="none",    action="walk",   destination="none",    phase="approach", urgency=0.7, grip=0.3,  speed=0.8),
+        "stairs":          GoalSpec(target="none",    action="walk",   destination="none",    phase="approach", urgency=0.8, grip=0.2,  speed=0.6),
+        "maze":            GoalSpec(target="none",    action="walk",   destination="none",    phase="approach", urgency=0.9, grip=0.3,  speed=0.7),
+        "household_pick":  GoalSpec(target="cup",     action="pick",   destination="counter", phase="approach", urgency=0.8, grip=-0.8, speed=0.4),
+        "household_door":  GoalSpec(target="door",    action="open",   destination="door",    phase="approach", urgency=0.7, grip=-0.6, speed=0.5),
+        "household_stack": GoalSpec(target="block",   action="pick",   destination="table",   phase="approach", urgency=0.8, grip=-0.8, speed=0.4),
+        "household_sweep": GoalSpec(target="cup",     action="sweep",  destination="floor",   phase="approach", urgency=0.9, grip=0.5,  speed=0.9),
+        "household_sit":   GoalSpec(target="chair",   action="sit",    destination="chair",   phase="approach", urgency=0.6, grip=0.3,  speed=0.4),
+        "reach_arm":       GoalSpec(target="none",    action="pick",   destination="none",    phase="grasp",    urgency=0.9, grip=-0.5, speed=0.3),
+        "yoga_mountain":   GoalSpec(target="none",    action="stand",  destination="none",    phase="approach", urgency=0.5, grip=0.5,  speed=0.2),
+        "yoga_tree":       GoalSpec(target="none",    action="stand",  destination="none",    phase="approach", urgency=0.6, grip=0.5,  speed=0.2),
+        "yoga_warrior1":   GoalSpec(target="none",    action="stand",  destination="none",    phase="approach", urgency=0.7, grip=0.3,  speed=0.3),
+        "yoga_warrior2":   GoalSpec(target="none",    action="stand",  destination="none",    phase="approach", urgency=0.7, grip=0.3,  speed=0.3),
+        "yoga_triangle":   GoalSpec(target="none",    action="stand",  destination="none",    phase="approach", urgency=0.7, grip=0.3,  speed=0.3),
+        "yoga_child":      GoalSpec(target="none",    action="stand",  destination="none",    phase="approach", urgency=0.6, grip=0.5,  speed=0.2),
+        "yoga_downdog":    GoalSpec(target="none",    action="stand",  destination="none",    phase="approach", urgency=0.7, grip=0.4,  speed=0.3),
+        "yoga_cobra":      GoalSpec(target="none",    action="stand",  destination="none",    phase="approach", urgency=0.6, grip=0.5,  speed=0.2),
+        "yoga_all":        GoalSpec(target="none",    action="stand",  destination="none",    phase="approach", urgency=0.6, grip=0.4,  speed=0.2),
+        "yoga_random":     GoalSpec(target="none",    action="stand",  destination="none",    phase="approach", urgency=0.7, grip=0.4,  speed=0.3),
+        "household_ball":  GoalSpec(target="any",     action="carry",  destination="floor",   phase="approach", urgency=0.7, grip=-0.6, speed=0.6),
+        "shape_sorter":    GoalSpec(target="block",   action="pick",   destination="none",    phase="approach", urgency=0.8, grip=-0.8, speed=0.4),
+        "media_watch":     GoalSpec(target="none",    action="stand",  destination="none",    phase="approach", urgency=0.5, grip=0.5,  speed=0.2),
+        "drive_city":      GoalSpec(target="none",    action="walk",   destination="none",    phase="approach", urgency=0.9, grip=0.5,  speed=0.9),
+        "dribble":         GoalSpec(target="ball",    action="carry",  destination="floor",   phase="grasp",    urgency=0.8, grip=-0.6, speed=0.7),
+        "shoot":           GoalSpec(target="ball",    action="pick",   destination="counter", phase="grasp",    urgency=0.9, grip=-0.7, speed=0.5),
+        "layup":           GoalSpec(target="ball",    action="carry",  destination="counter", phase="approach", urgency=1.0, grip=-0.7, speed=0.9),
+        "basketball":      GoalSpec(target="ball",    action="carry",  destination="counter", phase="approach", urgency=0.9, grip=-0.6, speed=0.8),
+    }
+    return defaults.get(task_name, GoalSpec())

embodied/interactive_objects.py

@@ -0,0 +1,374 @@
+"""
+InteractiveObjects — fyzické předměty pro haptické a kognitivní úlohy.
+
+BallObject       – gumový míč s vysokou elasticitou
+WaterCupObject   – hrnek s hladinou vody (kloní se = přelévá)
+RubiksCubeObject – zjednodušená Rubikova kostka (fyzické těleso + logický stav)
+ShapeSorterWall  – zeď s otvory (čtverec, trojúhelník, hvězda) + odpovídající tvar
+"""
+from __future__ import annotations
+import sys, os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+import numpy as np
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple
+
+from engine.physics.rigid_body import (
+    PhysicsWorld, RigidBody, BodyType,
+    vec3, Vec3, length, normalize,
+)
+
+
+# ── Základní třída ────────────────────────────────────────────────────────────
+
+class PhysicsObject:
+    """Základní třída pro interaktivní objekty."""
+
+    def __init__(self, phys: PhysicsWorld, obj_id: str):
+        self.phys   = phys
+        self.obj_id = obj_id
+        self.body: Optional[RigidBody] = None
+
+    @property
+    def position(self) -> Vec3:
+        return self.body.position if self.body else vec3()
+
+    @property
+    def velocity(self) -> Vec3:
+        return self.body.velocity if self.body else vec3()
+
+    def distance_to(self, pos: Vec3) -> float:
+        return float(length(self.position - pos))
+
+
+# ── Míč ───────────────────────────────────────────────────────────────────────
+
+class BallObject(PhysicsObject):
+    """
+    Gumový míč — malé těleso s vysokou elasticitou a nízkou hmotností.
+    Odraz: restitution=0.82 (≈ gumový míč, ne super-ball).
+    """
+    RADIUS   = 0.12   # m
+    MASS     = 0.25   # kg
+
+    def __init__(self, phys: PhysicsWorld, pos: Vec3, obj_id: str = "ball"):
+        super().__init__(phys, obj_id)
+        self.body = phys.create_body(
+            obj_id, BodyType.DYNAMIC,
+            position=pos,
+            size=vec3(self.RADIUS * 2, self.RADIUS * 2, self.RADIUS * 2),
+            mass=self.MASS,
+            restitution=0.82,
+            friction=0.35,
+        )
+        self._spawn_pos = pos
+
+    def reset(self, pos: Optional[Vec3] = None):
+        p = pos if pos is not None else self._spawn_pos
+        self.body.position = p
+        self.body.velocity = vec3()
+        self.body.angular_velocity = vec3()
+        self.body.rotation = vec3()
+
+    def get_state(self) -> np.ndarray:
+        """6 floats: [pos_x, pos_y, pos_z, vel_x, vel_y, vel_z]"""
+        p = self.body.position
+        v = self.body.velocity
+        return np.array([p[0], p[1], p[2], v[0], v[1], v[2]], dtype=np.float32)
+
+
+# ── Hrnek s vodou ─────────────────────────────────────────────────────────────
+
+class WaterCupObject(PhysicsObject):
+    """
+    Keramický hrnek s hladinou vody.
+    water_level klesá, když je hrnek nakloněný (tilt > threshold).
+    Použití: agent se musí naučit nosit hrnek opatrně.
+    """
+    MASS               = 0.35
+    SIZE               = vec3(0.09, 0.12, 0.09)
+    TILT_SPILL_THRESH  = 0.40  # rad od svislé osy
+    SPILL_RATE         = 0.03  # úbytek hladiny za krok při náklonu
+
+    def __init__(self, phys: PhysicsWorld, pos: Vec3, obj_id: str = "water_cup"):
+        super().__init__(phys, obj_id)
+        self.body = phys.create_body(
+            obj_id, BodyType.DYNAMIC,
+            position=pos,
+            size=self.SIZE,
+            mass=self.MASS,
+            restitution=0.08,
+            friction=0.70,
+        )
+        self._spawn_pos   = pos
+        self.water_level  = 1.0   # 0.0 = prázdný, 1.0 = plný
+        self._spilled     = False
+
+    def step(self):
+        """Volat každý fyzikální krok."""
+        if self.water_level <= 0.0:
+            return
+        rot = self.body.rotation
+        tilt = float(np.sqrt(rot[0] ** 2 + rot[2] ** 2))
+        if tilt > self.TILT_SPILL_THRESH:
+            self.water_level = max(0.0, self.water_level - self.SPILL_RATE)
+            if self.water_level == 0.0:
+                self._spilled = True
+
+    def reset(self, pos: Optional[Vec3] = None):
+        p = pos if pos is not None else self._spawn_pos
+        self.body.position = p
+        self.body.velocity = vec3()
+        self.body.angular_velocity = vec3()
+        self.body.rotation = vec3()
+        self.water_level = 1.0
+        self._spilled = False
+
+    def get_state(self) -> np.ndarray:
+        """4 floats: [pos_y_rel_spawn, tilt, water_level, spilled]"""
+        rot   = self.body.rotation
+        tilt  = float(np.sqrt(float(rot[0]) ** 2 + float(rot[2]) ** 2))
+        pos_y = float(self.body.position[1])
+        return np.array([pos_y, tilt, self.water_level, float(self._spilled)],
+                        dtype=np.float32)
+
+
+# ── Rubikova kostka ───────────────────────────────────────────────────────────
+
+# Každá stěna má 9 políček → 6 stěn × 9 = 54 hodnot (0-5 = 6 barev)
+# Zjednodušení: jedna fyzická krychle, logický stav jako int array
+_SOLVED_FACES = np.array([
+    [i] * 9 for i in range(6)   # každá stěna má jednu barvu
+], dtype=np.int8).flatten()
+
+
+class RubiksCubeObject(PhysicsObject):
+    """
+    Fyzická krychle s logickým stavem 6×9 políček (6 barev).
+    Rotace stěn: rotate_face(face_idx, clockwise).
+    Stav: stupeň zamíchanosti (0=vyřešeno, 1=přeskupeno).
+    """
+    SIZE = vec3(0.12, 0.12, 0.12)
+    MASS = 0.15
+
+    # Indexy stěn
+    FRONT, BACK, LEFT, RIGHT, TOP, BOTTOM = 0, 1, 2, 3, 4, 5
+
+    # Otáčení: stěna 0-5 → seznam indexů políček (zjednodušeno — ring rotation)
+    _FACE_RING = {
+        0: ([6,7,8],[0,3,6],[2,1,0],[8,5,2],  [BACK:=1,LEFT:=2,TOP:=4,RIGHT:=3]),
+    }
+
+    def __init__(self, phys: PhysicsWorld, pos: Vec3, obj_id: str = "rubiks"):
+        super().__init__(phys, obj_id)
+        self.body = phys.create_body(
+            obj_id, BodyType.DYNAMIC,
+            position=pos,
+            size=self.SIZE,
+            mass=self.MASS,
+            restitution=0.10,
+            friction=0.80,
+        )
+        self._spawn_pos  = pos
+        self.faces       = _SOLVED_FACES.copy()    # 54 políček
+        self._moves      = 0
+
+    def scramble(self, n_moves: int = 20, rng: np.random.Generator = None):
+        if rng is None:
+            rng = np.random.default_rng()
+        for _ in range(n_moves):
+            face = int(rng.integers(0, 6))
+            self._rotate_face_logical(face, bool(rng.integers(0, 2)))
+        self._moves = 0
+
+    def _rotate_face_logical(self, face: int, clockwise: bool):
+        """Otočí políčka na jedné stěně o 90°."""
+        f = self.faces[face * 9:(face + 1) * 9].copy().reshape(3, 3)
+        if clockwise:
+            f = np.rot90(f, k=3)
+        else:
+            f = np.rot90(f, k=1)
+        self.faces[face * 9:(face + 1) * 9] = f.flatten()
+        self._moves += 1
+
+    def is_solved(self) -> bool:
+        return np.array_equal(self.faces, _SOLVED_FACES)
+
+    def solve_fraction(self) -> float:
+        """Poměr správně umístěných políček (0.0–1.0)."""
+        return float(np.mean(self.faces == _SOLVED_FACES))
+
+    def reset(self, pos: Optional[Vec3] = None, scramble_n: int = 0,
+              rng: np.random.Generator = None):
+        p = pos if pos is not None else self._spawn_pos
+        self.body.position = p
+        self.body.velocity = vec3()
+        self.body.angular_velocity = vec3()
+        self.body.rotation = vec3()
+        self.faces = _SOLVED_FACES.copy()
+        self._moves = 0
+        if scramble_n > 0:
+            self.scramble(scramble_n, rng)
+
+    def get_state(self) -> np.ndarray:
+        """3 floats: [solve_fraction, n_moves_norm, is_held_approx(pos_y)]"""
+        return np.array([
+            self.solve_fraction(),
+            min(1.0, self._moves / 100.0),
+            float(np.clip((float(self.body.position[1]) - 0.5) / 1.5, 0.0, 1.0)),
+        ], dtype=np.float32)
+
+
+# ── Třídicí zeď ───────────────────────────────────────────────────────────────
+
+SHAPE_SQUARE   = 0
+SHAPE_TRIANGLE = 1
+SHAPE_STAR     = 2
+
+# Fyzické rozměry tvarových předmětů
+_SHAPE_SIZES = {
+    SHAPE_SQUARE:   vec3(0.09, 0.09, 0.04),
+    SHAPE_TRIANGLE: vec3(0.09, 0.09, 0.04),
+    SHAPE_STAR:     vec3(0.10, 0.10, 0.04),
+}
+
+# Barvy tvarů (R, G, B) pro renderer
+SHAPE_COLORS = {
+    SHAPE_SQUARE:   (0.9, 0.2, 0.2),   # červená
+    SHAPE_TRIANGLE: (0.2, 0.8, 0.2),   # zelená
+    SHAPE_STAR:     (0.9, 0.8, 0.1),   # žlutá
+}
+
+# Pozice otvorů (x-offset od středu zdi)
+_HOLE_X_OFFSETS = {
+    SHAPE_SQUARE:   -0.35,
+    SHAPE_TRIANGLE:  0.00,
+    SHAPE_STAR:      0.35,
+}
+
+# Tolerance vložení (vzdálenost + orientace)
+_INSERT_DIST_OK  = 0.15   # m — střed tvaru musí být do 15 cm od otvoru
+_INSERT_TILT_OK  = 0.30   # rad — maximální náklon tvaru při vkládání
+
+
+@dataclass
+class ShapePiece:
+    shape:   int           # SHAPE_* konstanta
+    body:    RigidBody
+    inserted: bool = False
+    spawn_pos: Vec3 = field(default_factory=lambda: vec3())
+
+
+class ShapeSorterWall:
+    """
+    Statická zeď s třemi otvory (čtverec, trojúhelník, hvězda).
+    Tvarové předměty jsou dynamické tělesa, agent je musí vložit do správného otvoru.
+    Kontrola vložení: vzdálenost od otvoru < 15 cm + přibližně správná orientace.
+    """
+    WALL_POS   = vec3(0.0, 1.0, -2.0)   # zeď je v záporném Z (před agentem)
+    WALL_SIZE  = vec3(1.2, 1.0, 0.08)
+    HOLE_Y     = 1.0   # výška středu otvorů (v absolutních souřadnicích)
+
+    def __init__(self, phys: PhysicsWorld, origin: Vec3 = None, rng=None):
+        self.phys   = phys
+        self._rng   = rng if rng is not None else np.random.default_rng()
+        self.origin = origin if origin is not None else vec3()
+        self._wall_body: Optional[RigidBody] = None
+        self.pieces: List[ShapePiece] = []
+        self._spawn()
+
+    def _spawn(self):
+        wall_pos = self.origin + self.WALL_POS
+        self._wall_body = self.phys.create_body(
+            "shape_wall", BodyType.STATIC,
+            position=wall_pos,
+            size=self.WALL_SIZE,
+            mass=0.0, restitution=0.05, friction=0.90,
+        )
+
+        # Spawn tvarové předměty před zdi
+        spawn_z  = float(self.WALL_POS[2]) + 1.2   # 1.2 m před zdi
+        shapes   = [SHAPE_SQUARE, SHAPE_TRIANGLE, SHAPE_STAR]
+        # Zamíchej pořadí spawnu
+        order    = self._rng.permutation(len(shapes))
+        x_slots  = [-0.35, 0.0, 0.35]
+        for i, shape_idx in enumerate(order):
+            shape = shapes[shape_idx]
+            pos   = self.origin + vec3(
+                x_slots[i],
+                0.80,       # výška stolu/podlahy
+                spawn_z,
+            )
+            body = self.phys.create_body(
+                f"shape_{shape}_{i}", BodyType.DYNAMIC,
+                position=pos,
+                size=_SHAPE_SIZES[shape],
+                mass=0.08, restitution=0.10, friction=0.75,
+            )
+            self.pieces.append(ShapePiece(shape=shape, body=body, spawn_pos=pos.copy()))
+
+    def hole_position(self, shape: int) -> Vec3:
+        """Absolutní pozice středu otvoru pro daný tvar."""
+        wx = float(self.WALL_POS[0]) + float(self.origin[0])
+        wz = float(self.WALL_POS[2]) + float(self.origin[2]) + 0.05
+        return vec3(wx + _HOLE_X_OFFSETS[shape], self.HOLE_Y, wz)
+
+    def check_insertions(self) -> int:
+        """Zkontroluje vložení předmětů; vrací počet správně vložených."""
+        count = 0
+        for piece in self.pieces:
+            if piece.inserted:
+                count += 1
+                continue
+            hole = self.hole_position(piece.shape)
+            dist = float(length(piece.body.position - hole))
+            rot  = piece.body.rotation
+            tilt = float(np.sqrt(float(rot[0]) ** 2 + float(rot[1]) ** 2))
+            if dist < _INSERT_DIST_OK and tilt < _INSERT_TILT_OK:
+                piece.inserted = True
+                # Zafixuj předmět na místě
+                piece.body.body_type = BodyType.STATIC
+                piece.body.velocity  = vec3()
+                count += 1
+        return count
+
+    def all_inserted(self) -> bool:
+        return all(p.inserted for p in self.pieces)
+
+    def nearest_piece(self, hand_pos: Vec3) -> Optional[ShapePiece]:
+        """Vrátí nejbližší nevložený předmět k ruce agenta."""
+        best_d = float("inf")
+        best_p = None
+        for p in self.pieces:
+            if p.inserted:
+                continue
+            d = float(length(p.body.position - hand_pos))
+            if d < best_d:
+                best_d, best_p = d, p
+        return best_p
+
+    def reset(self):
+        for piece in self.pieces:
+            piece.inserted = False
+            piece.body.body_type = BodyType.DYNAMIC
+            piece.body.position  = piece.spawn_pos.copy()
+            piece.body.velocity  = vec3()
+            piece.body.angular_velocity = vec3()
+            piece.body.rotation  = vec3()
+
+    def get_state(self) -> np.ndarray:
+        """
+        9 floats: pro každý předmět (3×):
+          [dist_to_hole_norm, inserted, piece_pos_y_norm]
+        """
+        out = []
+        for piece in self.pieces:
+            hole = self.hole_position(piece.shape)
+            dist = float(length(piece.body.position - hole))
+            out.extend([
+                float(np.clip(dist / 3.0, 0.0, 1.0)),
+                float(piece.inserted),
+                float(np.clip(float(piece.body.position[1]) / 2.0, 0.0, 1.0)),
+            ])
+        return np.array(out, dtype=np.float32)

embodied/intrinsic.py

@@ -0,0 +1,290 @@
+"""
+Intrinsická motivace agenta — implementace 5 strategií proti
+"Local Optimum of Doing Nothing".
+
+1. MetabolicNeeds  — biologický tlak (hunger/energy decay)
+2. CuriositySignal — η kanál: bonus za novelty (predikční chyba)
+3. BoredomTracker  — penalizace za opakování stejných pozic
+4. EventRewardBus  — mikro-odměny za změnu stavu světa
+"""
+from __future__ import annotations
+import numpy as np
+from collections import deque
+from typing import Optional
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# 1. Metabolic Needs  (biologický tlak)
+# ══════════════════════════════════════════════════════════════════════════════
+
+class MetabolicNeeds:
+    """
+    Stání na místě = jistá smrt.
+
+    hunger cresce každý tick, energy klesá.
+    Penalizace roste nelineárně — čím déle agent stojí, tím víc ho to bolí.
+    Nahrazuje flat alive-bonus, který dovoloval nicnedělání.
+    """
+    HUNGER_RATE   = 0.0010   # hunger per step (dosáhne 1.0 za ~1000 kroků)
+    ENERGY_RATE   = 0.0008   # energy drain per step
+    DEATH_PENALTY = -4.0     # jednorázová penalizace při hunger >= 1.0, pak plný reset
+    HUNGER_RESET  = 0.0      # plný reset — nová šance
+
+    def __init__(self):
+        self.hunger = 0.0
+        self.energy = 1.0
+        self._step  = 0
+
+    def reset(self):
+        self.hunger = 0.0
+        self.energy = 1.0
+        self._step  = 0
+
+    def feed(self, amount: float = 0.3):
+        """Agent dostal jídlo/energii (nasbíral reward)."""
+        self.hunger = max(0.0, self.hunger - amount * 0.5)
+        self.energy = min(1.0, self.energy + amount * 0.3)
+
+    def step(self, task_reward: float) -> float:
+        """
+        Vrátí metabolický příspěvek k odměně (záporný = tlak).
+        Volej po výpočtu task_reward.
+        """
+        self._step += 1
+
+        # Krmení z jakékoli kladné task odměny
+        if task_reward > 0.0:
+            self.feed(task_reward * 0.12)
+
+        self.hunger = min(1.0, self.hunger + self.HUNGER_RATE)
+        self.energy = max(0.0, self.energy - self.ENERGY_RATE)
+
+        # Smrt hladem → penalizace + reset (ne trvalá smrt v -8 smyčce)
+        if self.hunger >= 1.0:
+            self.hunger = self.HUNGER_RESET
+            return self.DEATH_PENALTY
+
+        # Metabolický tlak — koef 0.15 aby nepřebil task reward
+        pressure = -(self.hunger ** 2) * 0.15
+        energy_bonus = self.energy * 0.012
+        return pressure + energy_bonus
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# 2. Curiosity Signal  (η kanál — predikční chyba)
+# ══════════════════════════════════════════════════════════════════════════════
+
+class CuriositySignal:
+    """
+    Intrinsická odměna za překvapení (Prediction Error).
+
+    Udržuje exponenciální klouzavý průměr (EMA) stavu jako "predikci".
+    Pokud aktuální stav výrazně odchyluje od predikce → vysoká curiosity.
+    To motivuje agenta hledat nové situace místo opakovat bezpečné smyčky.
+
+    Odpovídá η (Eta) kanálu v MnemoLattice.
+    """
+    ALPHA      = 0.15     # rychlost učení prediktoru
+    SCALE      = 0.25     # škálování curiosity bonusu
+    MAX_BONUS  = 0.40     # strop bonusu za jeden krok
+
+    def __init__(self, state_dim: int = 24):
+        self._pred  = None          # exponenciální predikce dalšího stavu
+        self._sdim  = state_dim
+        self._eta   = 0.0           # aktuální curiosity hodnota
+
+    def reset(self):
+        self._pred = None
+        self._eta  = 0.0
+
+    def step(self, state: np.ndarray) -> float:
+        """
+        Spočítá curiosity bonus pro aktuální stav.
+        Vysoká hodnota = agent viděl něco neobvyklého.
+        """
+        if self._pred is None:
+            self._pred = state.copy()
+            return 0.0
+
+        # Predikční chyba — jak moc se lišíme od očekávaného stavu
+        err = float(np.mean((state - self._pred) ** 2))
+        # Aktualizuj predikci (EMA — jednoduchý 1-krokový forward model)
+        self._pred = (1 - self.ALPHA) * self._pred + self.ALPHA * state
+
+        self._eta = float(np.clip(err * self.SCALE, 0.0, self.MAX_BONUS))
+        return self._eta
+
+    @property
+    def eta(self) -> float:
+        return self._eta
+
+
+# ══════════��═══════════════════════════════════════════════════════════════════
+# 3. Boredom Tracker  (penalizace za opakování pozic)
+# ══════════════════════════════════════════════════════════════════════════════
+
+class BoredomTracker:
+    """
+    Penalizace za nudné chování — opakování stejných míst.
+
+    Mřížka 1m × 1m, udrží historii N posledních navštívených buněk.
+    Revisit té samé buňky stojí energii.
+    Propojuje se s FractalHexaPentaMemory přes memory pressure.
+    """
+    CELL_SIZE    = 1.0     # rozlišení mřížky (m)
+    HISTORY_LEN  = 60      # kolik kroků pamatuje
+    REVISIT_PEN  = -0.12   # penalizace za revisit (per krok v té buňce)
+    NOVEL_BONUS  = 0.08    # bonus za novou buňku
+
+    def __init__(self):
+        self._history: deque = deque(maxlen=self.HISTORY_LEN)
+        self._visited: set   = set()   # buňky navštívené za epizodu
+        self._total_novel    = 0
+
+    def reset(self):
+        self._history.clear()
+        self._visited.clear()
+        self._total_novel = 0
+
+    def _cell(self, x: float, z: float) -> tuple:
+        return (int(x / self.CELL_SIZE), int(z / self.CELL_SIZE))
+
+    def step(self, x: float, z: float) -> float:
+        cell = self._cell(x, z)
+        recent_count = list(self._history).count(cell)
+        self._history.append(cell)
+
+        is_novel = cell not in self._visited
+        if is_novel:
+            self._visited.add(cell)
+            self._total_novel += 1
+            return self.NOVEL_BONUS
+
+        # Penalizace roste s počtem recentních revisitů
+        if recent_count >= 3:
+            return self.REVISIT_PEN * min(recent_count / 3, 2.0)
+        return 0.0
+
+    @property
+    def exploration_score(self) -> float:
+        """Kolik různých buněk agent prozkoumala — metrika pro logging."""
+        return float(self._total_novel)
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# 4. Event Reward Bus  (mikro-odměny za interakci se světem)
+# ══════════════════════════════════════════════════════════════════════════════
+
+class EventRewardBus:
+    """
+    Analogie EventBus z VoxForge — mikro-odměny za VOXEL_DESTROYED,
+    OBJECT_TOUCHED, GRASP_ATTEMPT.
+
+    Agenta odměňuje za to, že dělá cokoliv se světem, ne za stání.
+    Postupně tyto mikro-odměny snižuj (decay) aby agent přešel na task reward.
+    """
+    TOUCH_BONUS  = 0.20   # za dotek s objektem
+    GRASP_BONUS  = 0.50   # za sevření předmětu
+    MOVE_BONUS   = 0.04   # za pohyb těla (norma velocity)
+    DECAY        = 0.9998 # decay per step → po 3000 krocích na 55%
+
+    def __init__(self):
+        self._scale = 1.0
+        self._last_grip = False
+
+    def reset(self):
+        self._scale     = 1.0
+        self._last_grip = False
+
+    def step(self, touched: bool, grasped: bool,
+             body_velocity_norm: float) -> float:
+        self._scale *= self.DECAY
+        r = 0.0
+
+        if touched:
+            r += self.TOUCH_BONUS * self._scale
+        if grasped and not self._last_grip:
+            r += self.GRASP_BONUS * self._scale   # jen při prvním sevření
+        self._last_grip = grasped
+
+        # Bonus za pohyb — bojuje přímo s "stojím a nedělám nic"
+        move_r = min(body_velocity_norm, 2.0) * self.MOVE_BONUS * self._scale
+        r += move_r
+
+        return r
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# 5. ε-greedy Motor Noise  (injekce šumu do motoriky)
+# ══════════════════════════════════════════════════════════════════════════════
+
+class EpsilonGreedyMotor:
+    """
+    ε-greedy strategie pro výstup motorické sítě.
+
+    S pravděpodobností ε přepiš výstup sítě náhodnou akcí.
+    ε klesá exponenciálně — brzy agent přestane být náhodný.
+    """
+    EPS_START  = 0.35   # počáteční pravděpodobnost náhodné akce
+    EPS_MIN    = 0.03   # minimální ε (nikdy úplně nevypínat)
+    EPS_DECAY  = 0.9992 # decay per episode
+
+    def __init__(self, action_dim: int = 10, seed: int = 0):
+        self._eps   = self.EPS_START
+        self._adim  = action_dim
+        self._rng   = np.random.default_rng(seed)
+        self._ep    = 0
+
+    def reset_episode(self):
+        self._ep   += 1
+        self._eps   = max(self.EPS_MIN, self._eps * self.EPS_DECAY)
+
+    def apply(self, action: np.ndarray) -> np.ndarray:
+        """Případně nahraď akci náhodnou — 'shodí agenta z kopce nicnedělání'."""
+        if self._rng.random() < self._eps:
+            # Náhodná akce ale biased toward movement (ne nulová akce)
+            noise = self._rng.uniform(-1.0, 1.0, self._adim).astype(np.float32)
+            return np.clip(noise, -1.0, 1.0)
+        return action
+
+    @property
+    def epsilon(self) -> float:
+        return self._eps
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# Kompozit: IntrinsicMotivation (všechny 4 složky najednou)
+# ══════════════════════════════════════════════════════════════════════════════
+
+class IntrinsicMotivation:
+    """
+    Balíček všech intrinsických složek odměny.
+    Použití v step_reward():
+
+        im_bonus = self.intrinsic.step(
+            state=cortex_output, pos_x=x, pos_z=z,
+            touched=touched, grasped=grasped,
+            body_vel=vel_norm, task_reward=task_r
+        )
+        total_reward = task_r + im_bonus
+    """
+    def __init__(self, state_dim: int = 24, action_dim: int = 10):
+        self.meta     = MetabolicNeeds()
+        self.curiosity = CuriositySignal(state_dim)
+        self.boredom  = BoredomTracker()
+        self.events   = EventRewardBus()
+
+    def reset(self):
+        self.meta.reset()
+        self.curiosity.reset()
+        self.boredom.reset()
+        self.events.reset()
+
+    def step(self, state: np.ndarray, pos_x: float, pos_z: float,
+             touched: bool, grasped: bool, body_vel: float,
+             task_reward: float) -> float:
+        meta_r    = self.meta.step(task_reward)
+        curious_r = self.curiosity.step(state)
+        bored_r   = self.boredom.step(pos_x, pos_z)
+        event_r   = self.events.step(touched, grasped, body_vel)
+        return meta_r + curious_r + bored_r + event_r

embodied/language_goal_bridge.py

@@ -0,0 +1,263 @@
+"""
+LanguageGoalBridge — obousměrný překlad mezi přirozeným jazykem a goal vektorem.
+
+Architektura:
+  Vstup (CZ/EN text) → text_to_goal() → GoalSpec → encode_goal() → vec[32]
+  Výstup             ← goal_to_text() ← decode_goal() ← vec[32] + body_state
+
+Vnitřní "jazyk agenta":
+  - goal_vec[32]: kontinuální sémantický prostor (co chce)
+  - workspace tokeny: diskrétní sémantické tokeny (co si "všímá")
+  - body_state[73]: proprioceptivní stav (jak se cítí)
+
+Překlad je pravidlový (bez externího API) — funguje offline.
+"""
+from __future__ import annotations
+import re
+import numpy as np
+from typing import Optional
+from dataclasses import dataclass, field
+
+from embodied.goal_encoder import GoalSpec, encode_goal, decode_goal, GOAL_DIM
+
+
+# ── Slovníky pro parsování ────────────────────────────────────────────────────
+
+_OBJECT_KEYWORDS: dict[str, list[str]] = {
+    "cup":     ["hrníček", "hrnek", "šálek", "cup", "mug"],
+    "block":   ["blok", "kostka", "kvádr", "block", "cube"],
+    "door":    ["dveře", "dvéře", "door"],
+    "chair":   ["židle", "křeslo", "chair"],
+    "table":   ["stůl", "stůl", "table"],
+    "counter": ["pult", "deska", "counter", "countertop"],
+    "shelf":   ["polička", "police", "shelf"],
+    "ball":    ["míč", "míček", "ball"],
+}
+
+_ACTION_KEYWORDS: dict[str, list[str]] = {
+    "pick":   ["vezmi", "zvedni", "uchop", "chyť", "pick", "grab", "take", "lift"],
+    "carry":  ["přines", "dones", "přesuň", "carry", "bring", "move"],
+    "sweep":  ["smeteň", "shoď", "smeť", "sweep", "knock", "push off"],
+    "open":   ["otevři", "open"],
+    "sit":    ["sedni", "posaď", "sit", "sit down"],
+    "walk":   ["jdi", "choď", "dojdi", "walk", "go", "move to"],
+    "stand":  ["stůj", "postůj", "drž se", "stand", "stay", "hold"],
+    "place":  ["polož", "dej", "umísti", "place", "put", "set down"],
+}
+
+_DEST_KEYWORDS: dict[str, list[str]] = {
+    "counter": ["pult", "desku", "na pult", "counter", "on counter"],
+    "table":   ["stůl", "stůl", "na stůl", "table", "on table", "cílové místo", "target"],
+    "floor":   ["podlahu", "zem", "dolů", "floor", "ground", "down"],
+    "door":    ["dveře", "ke dveřím", "door"],
+    "chair":   ["židli", "na židli", "chair"],
+}
+
+_URGENCY_KEYWORDS: dict[float, list[str]] = {
+    0.9: ["rychle", "hned", "okamžitě", "fast", "quickly", "now", "immediately"],
+    0.3: ["pomalu", "opatrně", "slowly", "carefully", "gently"],
+}
+
+_GRIP_KEYWORDS: dict[float, list[str]] = {
+    -0.8: ["pevně", "silně", "tight", "firmly", "hard"],
+    0.8:  ["povolně", "jemně", "loose", "gently", "softly"],
+}
+
+
+# ── Překladové tabulky (goal_vec → CZ text) ──────────────────────────────────
+
+_OBJECT_CZ  = {"cup": "hrníček", "block": "blok", "door": "dveře",
+               "chair": "židli", "table": "stůl", "counter": "pult",
+               "shelf": "poličku", "sink": "dřez", "none": "nic", "any": "objekt"}
+_ACTION_CZ  = {"pick": "Uchopuji", "carry": "Přenáším", "sweep": "Smetám",
+               "open": "Otevírám", "sit": "Sedám", "walk": "Jdu",
+               "stand": "Stojím", "place": "Pokládám"}
+_DEST_CZ    = {"counter": "na pult", "table": "na stůl", "door": "ke dveřím",
+               "chair": "na židli", "floor": "na zem", "none": ""}
+_PHASE_CZ   = {"approach": "přibližování", "grasp": "uchopení",
+               "carry": "přenos", "place": "pokládání"}
+
+
+# ── Parsování textu → GoalSpec ────────────────────────────────────────────────
+
+def _find_keyword(text_lower: str, kw_dict: dict) -> Optional[str]:
+    """Najde první shodu klíčového slova v textu."""
+    for key, keywords in kw_dict.items():
+        for kw in keywords:
+            if kw in text_lower:
+                return key
+    return None
+
+
+def text_to_goal(text: str, task_name: str = "") -> GoalSpec:
+    """
+    Přirozený jazyk (CZ/EN) → GoalSpec.
+
+    Příklady:
+        "vezmi hrníček a dej ho na pult"
+        → GoalSpec(target='cup', action='pick', destination='counter', grip=-0.8)
+
+        "rychle jdi ke dveřím"
+        → GoalSpec(target='door', action='walk', destination='door', urgency=0.9)
+    """
+    t = text.lower().strip()
+
+    target      = _find_keyword(t, _OBJECT_KEYWORDS) or "none"
+    action_raw  = _find_keyword(t, _ACTION_KEYWORDS) or "walk"
+    destination = _find_keyword(t, _DEST_KEYWORDS) or "none"
+
+    # Normalizace: "place" → "carry" (agent nosí, pak pokládá)
+    action = "carry" if action_raw == "place" else action_raw
+
+    # Urgency
+    urgency = 0.6
+    for val, kws in _URGENCY_KEYWORDS.items():
+        if any(kw in t for kw in kws):
+            urgency = val
+            break
+
+    # Grip: manipulační akce → záporný grip (uchopit)
+    grip = 0.3  # default: neutrální
+    if action in ("pick", "carry", "open"):
+        grip = -0.7
+    for val, kws in _GRIP_KEYWORDS.items():
+        if any(kw in t for kw in kws):
+            grip = val
+            break
+
+    # Fáze: odvoď z akce
+    phase_map = {"pick": "grasp", "carry": "carry", "place": "place",
+                 "open": "grasp", "sweep": "approach"}
+    phase = phase_map.get(action, "approach")
+
+    # Speed: urgency → speed
+    speed = float(np.clip(urgency * 0.9, 0.2, 1.0))
+
+    return GoalSpec(
+        target=target,
+        action=action,
+        destination=destination,
+        phase=phase,
+        urgency=urgency,
+        grip=grip,
+        speed=speed,
+        description=text[:120],
+    )
+
+
+# ── Dekódování stavu → CZ text ────────────────────────────────────────────────
+
+@dataclass
+class AgentThought:
+    """Čitelná reprezentace vnitřního stavu agenta."""
+    action_sentence:  str   = ""
+    phase_label:      str   = ""
+    object_dist:      float = 0.0
+    grip_value:       float = 0.0
+    energy_pct:       float = 1.0
+    noise_pct:        float = 0.0
+    workspace_tokens: list  = field(default_factory=list)
+    raw_goal:         GoalSpec = field(default_factory=GoalSpec)
+
+
+def goal_to_text(goal_vec: np.ndarray,
+                 body_state: Optional[np.ndarray] = None,
+                 object_dist: float = -1.0,
+                 energy: float = 1.0,
+                 noise: float = 0.0,
+                 workspace_tokens: Optional[list] = None) -> str:
+    """
+    goal_vec[32] + volitelný kontext → čitelná česká věta.
+
+    Výstup:
+        "Uchopuji hrníček → na pult | fáze: uchopení | vzdálenost: 0.4m
+         grip: -0.7 (pevný) | energie: 85% | explorace: 18%"
+    """
+    spec = decode_goal(goal_vec)
+
+    action_cz  = _ACTION_CZ.get(spec.action, spec.action)
+    object_cz  = _OBJECT_CZ.get(spec.target, spec.target)
+    dest_cz    = _DEST_CZ.get(spec.destination, "")
+    phase_cz   = _PHASE_CZ.get(spec.phase, spec.phase)
+
+    # Hlavní věta (přeskočí "nic" když target=none)
+    obj_part  = "" if spec.target == "none" else f" {object_cz}"
+    dest_part = f" {dest_cz}" if dest_cz else ""
+    main = f"{action_cz}{obj_part}{dest_part}".strip()
+
+    parts = [main, f"fáze: {phase_cz}"]
+
+    if object_dist >= 0:
+        parts.append(f"vzdálenost: {object_dist:.2f}m")
+
+    # Grip slovně
+    g = spec.grip
+    grip_word = "pevný" if g < -0.5 else ("povolný" if g > 0.5 else "střední")
+    parts.append(f"grip: {g:+.1f} ({grip_word})")
+
+    if energy < 1.0:
+        parts.append(f"energie: {energy*100:.0f}%")
+
+    if noise > 0.0:
+        parts.append(f"explorace: {noise*100:.0f}%")
+
+    # Workspace tokeny (cogcore.emergent)
+    if workspace_tokens:
+        tok_strs = []
+        for tok in workspace_tokens[:3]:
+            if hasattr(tok, 'key') and hasattr(tok, 'salience'):
+                tok_strs.append(f"{tok.key.split('.')[-2]}↑{tok.salience:.2f}")
+        if tok_strs:
+            parts.append("workspace: [" + ", ".join(tok_strs) + "]")
+
+    return " | ".join(parts)
+
+
+def state_to_thought(goal_vec: np.ndarray,
+                     body_state: np.ndarray,
+                     task_name: str = "",
+                     object_dist: float = -1.0,
+                     energy: float = 1.0,
+                     noise: float = 0.0,
+                     workspace_tokens: Optional[list] = None,
+                     task_reward: float = 0.0) -> AgentThought:
+    """Plný vnitřní stav → AgentThought dataclass."""
+    spec = decode_goal(goal_vec)
+    thought = AgentThought(
+        action_sentence=goal_to_text(goal_vec, body_state, object_dist,
+                                     energy, noise, workspace_tokens),
+        phase_label=_PHASE_CZ.get(spec.phase, spec.phase),
+        object_dist=object_dist,
+        grip_value=spec.grip,
+        energy_pct=energy,
+        noise_pct=noise,
+        workspace_tokens=workspace_tokens or [],
+        raw_goal=spec,
+    )
+    return thought
+
+
+# ── Rychlý test ───────────────────────────────────────────────────────────────
+
+def _demo():
+    examples = [
+        "vezmi hrníček a dej ho na pult",
+        "rychle jdi ke dveřím",
+        "pomalu a pevně uchop blok a přesuň ho na stůl",
+        "take the cup and carry it to the counter",
+        "sweep all cups off the table quickly",
+        "stand still",
+    ]
+    print("=== text_to_goal demo ===")
+    for ex in examples:
+        spec = text_to_goal(ex)
+        vec  = encode_goal(spec)
+        back = decode_goal(vec)
+        print(f"\nVstup : {ex!r}")
+        print(f"Spec  : action={spec.action}, target={spec.target}, "
+              f"dest={spec.destination}, grip={spec.grip:+.1f}, urgency={spec.urgency:.1f}")
+        print(f"→ Text: {goal_to_text(vec, object_dist=0.8, energy=0.72, noise=0.15)}")
+
+
+if __name__ == "__main__":
+    _demo()

embodied/media_objects.py

@@ -0,0 +1,276 @@
+"""
+MediaObjects — obrazovka a reproduktor pro multimediální učení agenta.
+
+MonitorObject  – plochá statická plocha s video buffrem; FPV raycaster ji maluje
+SpeakerObject  – bodový zdroj zvuku; vydává frekvenci slyšitelnou jako stavová veličina
+MediaRoom      – pomocná třída: room s monitorem + reproduktorem + lavicí předmětů
+"""
+from __future__ import annotations
+import sys, os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+import numpy as np
+from dataclasses import dataclass, field
+from typing import List, Optional, Tuple
+
+from engine.physics.rigid_body import (
+    PhysicsWorld, RigidBody, BodyType,
+    vec3, Vec3, length,
+)
+
+# ── Monitor ───────────────────────────────────────────────────────────────────
+
+# Rozlišení obrazovky (logické — FPV renderer na to mapuje pixely)
+MONITOR_W = 64
+MONITOR_H = 48
+
+# Barvy pro syntetické video (R, G, B 0-255)
+_PALETTE = np.array([
+    [220,  50,  50],   # červená
+    [ 50, 200,  50],   # zelená
+    [ 50,  80, 220],   # modrá
+    [230, 210,  30],   # žlutá
+    [180,  50, 220],   # fialová
+    [230, 130,  30],   # oranžová
+    [240, 240, 240],   # bílá
+    [ 20,  20,  20],   # černá
+], dtype=np.uint8)
+
+
+def make_color_frame(color_idx: int, w: int = MONITOR_W, h: int = MONITOR_H) -> np.ndarray:
+    """Jednobarevný snímek (pro jednoduché asociační testy)."""
+    frame = np.zeros((h, w, 3), dtype=np.uint8)
+    frame[:] = _PALETTE[color_idx % len(_PALETTE)]
+    return frame
+
+
+def make_pattern_frame(pattern: str, t: int,
+                       w: int = MONITOR_W, h: int = MONITOR_H) -> np.ndarray:
+    """
+    Syntetický snímek pro různé typy videí.
+    pattern: "stripe" | "circle" | "checkers" | "noise" | "arrow_left" | "arrow_right"
+    t: čas (číslo snímku)
+    """
+    frame = np.zeros((h, w, 3), dtype=np.uint8)
+    xs = np.arange(w)
+    ys = np.arange(h)
+    xg, yg = np.meshgrid(xs, ys)
+
+    if pattern == "stripe":
+        mask = ((xg // 8 + t // 4) % 2 == 0)
+        frame[mask] = _PALETTE[0]
+        frame[~mask] = _PALETTE[6]
+    elif pattern == "checkers":
+        mask = ((xg // 8 + yg // 8) % 2 == 0)
+        frame[mask] = _PALETTE[1]
+        frame[~mask] = _PALETTE[2]
+    elif pattern == "circle":
+        cx, cy = w // 2, h // 2
+        r = 10 + int(8 * np.sin(t * 0.1))
+        dist = np.sqrt((xg - cx) ** 2 + (yg - cy) ** 2)
+        frame[dist <= r] = _PALETTE[3]
+        frame[dist > r]  = _PALETTE[7]
+    elif pattern == "noise":
+        rng = np.random.default_rng(t)
+        frame[:] = rng.integers(0, 255, (h, w, 3), dtype=np.uint8)
+    elif pattern == "arrow_left":
+        mid = h // 2
+        for i in range(w // 2):
+            span = i // 2 + 1
+            frame[max(0, mid - span):mid + span, i] = _PALETTE[4]
+        frame[mid - 2:mid + 2, w // 4:3 * w // 4] = _PALETTE[4]
+    elif pattern == "arrow_right":
+        mid = h // 2
+        for i in range(w // 2, w):
+            span = (w - i) // 2 + 1
+            frame[max(0, mid - span):mid + span, i] = _PALETTE[5]
+        frame[mid - 2:mid + 2, w // 4:3 * w // 4] = _PALETTE[5]
+    else:
+        frame[:] = _PALETTE[7]
+    return frame
+
+
+class MonitorObject:
+    """
+    Statická obrazovka montovaná na zeď.
+    Drží aktuální snímek (numpy array H×W×3 uint8).
+    FPV raycaster (world_renderer.py) ji rozpozná podle obj_id="monitor_*"
+    a obarvuje zasažené pixely z self.current_frame.
+    """
+    SIZE = vec3(0.80, 0.60, 0.04)   # šířka × výška × hloubka (m)
+
+    def __init__(self, phys: PhysicsWorld, pos: Vec3, obj_id: str = "monitor"):
+        self.obj_id = obj_id
+        self.body   = phys.create_body(
+            obj_id, BodyType.STATIC,
+            position=pos,
+            size=self.SIZE,
+            mass=0.0, restitution=0.0, friction=0.9,
+        )
+        self.current_frame: np.ndarray = make_color_frame(7)  # černo
+        self._playlist: List[np.ndarray] = []
+        self._frame_idx  = 0
+        self._step_count = 0
+        self._fps_steps  = 4   # každých N fyzikálních kroků se snímek změní
+        self.is_on       = True
+
+    # ── Video ─────────────────────────────────────────────────────────────
+
+    def load_color_sequence(self, n_frames: int = 60):
+        """Naplní playlist střídajícími se barevnými snímky (asociační učení)."""
+        self._playlist = [
+            make_color_frame(i % len(_PALETTE)) for i in range(n_frames)
+        ]
+        self._frame_idx = 0
+
+    def load_pattern_sequence(self, pattern: str = "stripe", n_frames: int = 60):
+        """Naplní playlist syntetickým pohybovým vzorem."""
+        self._playlist = [make_pattern_frame(pattern, t) for t in range(n_frames)]
+        self._frame_idx = 0
+
+    def step(self):
+        """Posune playlist o jeden snímek (volat každý fyzikální krok)."""
+        if not self.is_on or not self._playlist:
+            return
+        self._step_count += 1
+        if self._step_count % self._fps_steps == 0:
+            self._frame_idx = (self._frame_idx + 1) % len(self._playlist)
+            self.current_frame = self._playlist[self._frame_idx]
+
+    # ── Viditelnost ───────────────────────────────────────────────────────
+
+    def visibility_from(self, eye_pos: Vec3, forward: Vec3) -> float:
+        """
+        Odhadne, jak moc je monitor v zorném poli agenta.
+        Vrátí 0.0–1.0 (0 = mimo pohled / za agentem, 1 = přímý pohled).
+        """
+        to_monitor = self.body.position - eye_pos
+        dist = float(length(to_monitor))
+        if dist < 0.01:
+            return 0.0
+        to_norm  = to_monitor * (1.0 / dist)
+        dot      = float(
+            forward[0] * to_norm[0] +
+            forward[1] * to_norm[1] +
+            forward[2] * to_norm[2]
+        )
+        if dot <= 0.0:
+            return 0.0
+        # Vzdálenostní útlum (1/r, max 5 m)
+        dist_fac = float(np.clip(1.0 - dist / 5.0, 0.0, 1.0))
+        return float(np.clip(dot * dist_fac, 0.0, 1.0))
+
+    def get_state(self) -> np.ndarray:
+        """
+        3 floats: [is_on, frame_progress (0-1), mean_brightness (0-1)]
+        """
+        brightness = float(np.mean(self.current_frame)) / 255.0
+        return np.array([
+            float(self.is_on),
+            self._frame_idx / max(1, len(self._playlist) - 1),
+            brightness,
+        ], dtype=np.float32)
+
+
+# ── Reproduktor ───────────────────────────────────────────────────────────────
+
+# Frekvenční pásma (Hz) → normalizovaný index 0-1
+_FREQ_BANDS = np.array([
+    100, 200, 400, 800, 1600, 3200, 6400
+], dtype=np.float32)
+
+
+class SpeakerObject:
+    """
+    Bodový zdroj zvuku. Nemá fyzické těleso — je to jen pozice + stav.
+    Vydává frekvenci, agent ji "slyší" jako stavovou veličinu (vzdálenostní útlum).
+    Tónové sekvence → asociační učení (Pavlovovo podmínění).
+    """
+    MAX_DIST = 8.0   # m — za touto vzdáleností není slyšet
+
+    def __init__(self, pos: Vec3, obj_id: str = "speaker"):
+        self.obj_id   = obj_id
+        self.position = pos
+        self.freq_hz  = 440.0   # A4
+        self.volume   = 1.0     # 0.0–1.0
+        self.is_on    = True
+
+        self._sequence: List[float] = []   # sekvence frekvencí
+        self._seq_idx  = 0
+        self._steps_per_note = 8
+        self._step_count     = 0
+
+    def load_tone_sequence(self, freqs_hz: List[float], steps_per_note: int = 8):
+        """Načte sekvenci tónů (analogie k učebnímu pořadu)."""
+        self._sequence       = freqs_hz
+        self._seq_idx        = 0
+        self._steps_per_note = steps_per_note
+        self._step_count     = 0
+        if freqs_hz:
+            self.freq_hz = freqs_hz[0]
+
+    def step(self):
+        if not self.is_on or not self._sequence:
+            return
+        self._step_count += 1
+        if self._step_count % self._steps_per_note == 0:
+            self._seq_idx = (self._seq_idx + 1) % len(self._sequence)
+            self.freq_hz  = self._sequence[self._seq_idx]
+
+    def heard_by(self, listener_pos: Vec3) -> Tuple[float, float]:
+        """
+        Vrátí (heard_freq_norm, amplitude) pro posluchače na dané pozici.
+        heard_freq_norm: 0.0–1.0 (normalizovaná frekvence)
+        amplitude: 0.0–1.0 (útlum se vzdáleností)
+        """
+        if not self.is_on:
+            return 0.0, 0.0
+        from engine.physics.rigid_body import length
+        dist = float(length(listener_pos - self.position))
+        amplitude = float(np.clip(1.0 - dist / self.MAX_DIST, 0.0, 1.0)) * self.volume
+        freq_norm = float(np.clip(
+            np.log2(self.freq_hz / 100.0) / np.log2(6400.0 / 100.0),
+            0.0, 1.0,
+        ))
+        return freq_norm, amplitude
+
+    def get_state(self, listener_pos: Vec3) -> np.ndarray:
+        """2 floats: [freq_norm, amplitude]"""
+        fn, amp = self.heard_by(listener_pos)
+        return np.array([fn, amp], dtype=np.float32)
+
+
+# ── MediaRoom — místnost s médii ──────────────────────────────────────────────
+
+class MediaRoom:
+    """
+    Pomocná třída: přidá do světa monitor + reproduktor + lavici předmětů.
+    Volej media_room.step() každý fyzikální krok.
+    """
+
+    def __init__(self, phys: PhysicsWorld, origin: Vec3 = None,
+                 pattern: str = "stripe"):
+        o = origin if origin is not None else vec3()
+        self.monitor = MonitorObject(phys,
+            pos=o + vec3(0.0, 1.4, -3.0),   # zeď v záporném Z
+            obj_id="monitor_main",
+        )
+        self.speaker = SpeakerObject(
+            pos=o + vec3(0.5, 1.4, -3.0),   # vedle monitoru
+            obj_id="speaker_main",
+        )
+        # Načti výchozí sekvence
+        self.monitor.load_pattern_sequence(pattern, n_frames=120)
+        self.speaker.load_tone_sequence(
+            [262, 330, 392, 523, 392, 330],   # C-E-G-C'-G-E (arpeggio)
+            steps_per_note=12,
+        )
+
+    def step(self):
+        self.monitor.step()
+        self.speaker.step()
+
+    def reset(self, pattern: str = "stripe"):
+        self.monitor.load_pattern_sequence(pattern, n_frames=120)
+        self.speaker._seq_idx  = 0
+        self.speaker._step_count = 0

embodied/observer.py

@@ -0,0 +1,135 @@
+"""
+Observer: reads the JSONL training log and reports interesting findings.
+Can be run while training is live or as a post-analysis.
+"""
+from __future__ import annotations
+import json, os, sys
+from pathlib import Path
+from typing import List, Dict, Any
+import numpy as np
+
+RESULTS = Path(os.getenv("PHANTOM_RESULTS", "results"))
+
+
+def load_log(log_path: Path) -> List[Dict]:
+    if not log_path.exists():
+        return []
+    rows = []
+    with log_path.open() as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                try:
+                    rows.append(json.loads(line))
+                except Exception:
+                    pass
+    return rows
+
+
+def analyse(rows: List[Dict]) -> Dict[str, Any]:
+    if not rows:
+        return {}
+
+    by_task: Dict[str, List[Dict]] = {}
+    for r in rows:
+        by_task.setdefault(r["task"], []).append(r)
+
+    report = {"total_episodes": len(rows), "tasks": {}}
+
+    for task, eps in by_task.items():
+        rewards  = [e["total_reward"] for e in eps]
+        successes = [e["success"] for e in eps]
+        falls    = [e["fallen"]  for e in eps]
+        steps    = [e["steps"]   for e in eps]
+        noises   = [e["noise"]   for e in eps]
+
+        # Learning curve: improvement in last 20% vs first 20%
+        n = len(rewards)
+        split = max(1, n // 5)
+        early_avg = float(np.mean(rewards[:split]))
+        late_avg  = float(np.mean(rewards[-split:]))
+        improvement = late_avg - early_avg
+
+        # First success episode
+        first_success = next((e["episode"] for e in eps if e["success"]), None)
+
+        # Interesting events across all episodes
+        all_interesting = [ev for e in eps for ev in e.get("interesting", [])]
+        event_counts: Dict[str, int] = {}
+        for ev in all_interesting:
+            key = ev.split("@")[0]
+            event_counts[key] = event_counts.get(key, 0) + 1
+
+        report["tasks"][task] = {
+            "n_episodes":    n,
+            "success_rate":  round(float(np.mean(successes)), 3),
+            "fall_rate":     round(float(np.mean(falls)), 3),
+            "avg_reward":    round(float(np.mean(rewards)), 3),
+            "max_reward":    round(float(np.max(rewards)), 3),
+            "early_avg":     round(early_avg, 3),
+            "late_avg":      round(late_avg, 3),
+            "improvement":   round(improvement, 3),
+            "avg_steps":     round(float(np.mean(steps)), 1),
+            "final_noise":   round(float(noises[-1]), 4),
+            "first_success_ep": first_success,
+            "event_counts":  event_counts,
+        }
+
+    # Global learning trend (reward moving avg across all episodes)
+    all_rewards = [r["total_reward"] for r in rows]
+    window = max(1, len(all_rewards) // 10)
+    moving_avg = [float(np.mean(all_rewards[max(0,i-window):i+1]))
+                  for i in range(len(all_rewards))]
+    report["global_moving_avg"] = [round(v, 3) for v in moving_avg[::max(1,len(moving_avg)//50)]]
+
+    return report
+
+
+def print_report(report: Dict):
+    print("\n" + "═" * 65)
+    print("  PHANTOM EMBODIED TRAINING  —  OBSERVER REPORT")
+    print("═" * 65)
+    print(f"  Total episodes: {report.get('total_episodes', 0)}")
+
+    for task, info in report.get("tasks", {}).items():
+        print(f"\n  ── {task.upper()} ───────────────────────────────────────")
+        print(f"    Episodes:      {info['n_episodes']}")
+        print(f"    Success rate:  {info['success_rate']*100:.1f}%")
+        print(f"    Fall rate:     {info['fall_rate']*100:.1f}%")
+        print(f"    Avg reward:    {info['avg_reward']:.3f}  (max {info['max_reward']:.3f})")
+        print(f"    Learning:      {info['early_avg']:.3f} → {info['late_avg']:.3f}  "
+              f"(Δ {info['improvement']:+.3f})")
+        print(f"    Avg steps:     {info['avg_steps']:.0f}")
+        print(f"    Final noise σ: {info['final_noise']:.4f}")
+        if info['first_success_ep'] is not None:
+            print(f"    First SUCCESS: episode {info['first_success_ep']}")
+        if info["event_counts"]:
+            print(f"    Events:        {info['event_counts']}")
+
+    trend = report.get("global_moving_avg", [])
+    if trend:
+        print(f"\n  ── GLOBAL REWARD TREND (sampled) ─────────────────────")
+        bar_len = 40
+        mn, mx = min(trend), max(trend)
+        rng = mx - mn if mx != mn else 1.0
+        for i, v in enumerate(trend):
+            bar = int((v - mn) / rng * bar_len)
+            print(f"    [{i:3d}] {'█'*bar}{'·'*(bar_len-bar)} {v:.2f}")
+    print("\n" + "═" * 65)
+
+
+def save_report(report: Dict, path: Path):
+    path.write_text(json.dumps(report, indent=2, default=str))
+
+
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--log", default="logs/embodied_training.jsonl")
+    parser.add_argument("--out", default="results/embodied_report.json")
+    args = parser.parse_args()
+
+    rows   = load_log(Path(args.log))
+    report = analyse(rows)
+    print_report(report)
+    save_report(report, Path(args.out))

embodied/phantom_acc.py

@@ -0,0 +1,110 @@
+"""
+PhantomACC — ACCConflictDetector wrapper.
+
+Detects conflicts between:
+  - current intent (task name)
+  - sensory percepts (hand/torso from body state)
+  - emotional state (from BioCor)
+
+When conflict is high → triggers exploration boost.
+When safety_bypass=True → vetoes current action and resets exploration.
+"""
+from __future__ import annotations
+import numpy as np
+import logging
+from typing import Optional
+
+log = logging.getLogger("phantom.acc")
+
+try:
+    from cogcore.routing.acc import ACCConflictDetector, ConflictReport
+    _HAS_ACC = True
+except ImportError:
+    _HAS_ACC = False
+    log.warning("cogcore.routing.acc not available — ACC in passthrough mode")
+
+# Score at which the ACC recommends an exploration boost
+_EXPLORATION_TRIGGER = 0.25
+
+
+class PhantomACC:
+    """Wraps ACCConflictDetector; exposes conflict_score and exploration signals."""
+
+    def __init__(self):
+        if _HAS_ACC:
+            self._acc = ACCConflictDetector(
+                intent_emotion_threshold=0.30,
+                modality_intent_threshold=0.50,
+                domain_intent_threshold=0.40,
+                discord_threshold=0.30,
+                safety_bypass_threshold=0.88,
+            )
+        else:
+            self._acc = None
+        self._last_score: float = 0.0
+        self._safety_bypass: bool = False
+
+    # ── public ────────────────────────────────────────────────────────────
+
+    def detect(self, task_name: str, body_state: np.ndarray,
+               bio_vec: np.ndarray) -> float:
+        """
+        Run conflict detection; returns conflict score in [0, 1].
+        Also updates self.should_explore and self.safety_bypass.
+        """
+        if not _HAS_ACC or self._acc is None:
+            return 0.0
+
+        percepts = self._make_percepts(body_state)
+        emotion  = self._make_emotion(bio_vec)
+        report: ConflictReport = self._acc.detect(
+            intent=task_name,
+            percepts=percepts,
+            emotion=emotion,
+        )
+        self._last_score  = float(report.score)
+        self._safety_bypass = bool(report.safety_bypass)
+
+        if report.safety_bypass:
+            log.warning("ACC safety_bypass! intent=%s score=%.2f", task_name, report.score)
+        elif report.score >= _EXPLORATION_TRIGGER:
+            log.debug("ACC conflict=%.2f (%s) → exploration boost", report.score, report.strongest)
+
+        return self._last_score
+
+    @property
+    def score(self) -> float:
+        return self._last_score
+
+    @property
+    def should_explore(self) -> bool:
+        return self._last_score >= _EXPLORATION_TRIGGER
+
+    @property
+    def safety_bypass(self) -> bool:
+        return self._safety_bypass
+
+    def noise_multiplier(self) -> float:
+        """Maps conflict score to noise multiplier (1.0 – 2.0)."""
+        return float(1.0 + np.clip(self._last_score * 2.0, 0.0, 1.0))
+
+    # ── internal ──────────────────────────────────────────────────────────
+
+    @staticmethod
+    def _make_percepts(body_state: np.ndarray) -> dict:
+        bs = body_state
+        return {
+            "visual":   float(np.clip(abs(float(bs[18])) if len(bs) > 18 else 0.5, 0.0, 1.0)),
+            "motor":    float(np.clip(1.0 - abs(float(bs[12])) if len(bs) > 12 else 0.5, 0.0, 1.0)),
+            "balance":  float(np.clip(1.0 - abs(float(bs[0]))  if len(bs) > 0  else 0.5, 0.0, 1.0)),
+        }
+
+    @staticmethod
+    def _make_emotion(bio_vec: np.ndarray) -> dict:
+        # bio_vec = [pfc, hpc, acc, ins, amy]
+        amy = float(bio_vec[4]) if len(bio_vec) > 4 else 0.16
+        ins = float(bio_vec[3]) if len(bio_vec) > 3 else 0.18
+        return {
+            "urgency": float(np.clip(amy * 3.0, 0.0, 1.0)),
+            "valence": float(np.clip(1.0 - ins * 2.0, 0.0, 1.0)),
+        }

embodied/phantom_biocor.py

@@ -0,0 +1,120 @@
+"""
+PhantomBioCor — FiveBioEngine safety wrapper (BioCor layer).
+
+Roles:
+  1. Biological state tracker: pfc / hpc / acc / ins / amy (5 floats appended to state)
+  2. Safety gate: if bio detects unsafe goal_vec from external LLM (Gemini),
+     clamp or zero urgency to protect RL policy from black-box manipulation
+  3. Neurotransmitter modulation: DA/NE scale exploration noise, OXT scales proximity
+
+Output slice appended to state vector: [pfc, hpc, acc, ins, amy]  → 5 floats
+"""
+from __future__ import annotations
+import numpy as np
+import logging
+from typing import Dict, Any, Optional
+
+log = logging.getLogger("phantom.biocor")
+
+try:
+    from cogcore.bio.engine import FiveBioEngine, FiveBioConfig
+    _HAS_BIO = True
+except ImportError:
+    _HAS_BIO = False
+    log.warning("cogcore.bio not available — BioCor in passthrough mode")
+
+BIO_DIM = 5  # pfc, hpc, acc, ins, amy
+
+# Urgency clamp threshold: if Amy spike is too high, distrust external goal
+_AMY_SAFETY_THRESHOLD = 0.75
+# Maximum allowed urgency from Gemini before BioCor overrides it
+_MAX_ALLOWED_URGENCY = 0.92
+
+
+class PhantomBioCor:
+    """
+    FiveBioEngine wrapper.
+    Call step() every RL step; the 5-dim bio slice is appended to agent state.
+    Call moderate_goal() to safety-filter Gemini goal vectors.
+    """
+
+    def __init__(self):
+        if _HAS_BIO:
+            self._engine = FiveBioEngine(FiveBioConfig(
+                pfc_tonic=0.32, hpc_tonic=0.25,
+                acc_tonic=0.18, ins_tonic=0.18, amy_tonic=0.16,
+                sentiment_tau=30.0, memory_tau=50.0, drift_tau=24.0,
+            ))
+        else:
+            self._engine = None
+        self._last: Optional[Dict[str, Any]] = None
+
+    # ── public ────────────────────────────────────────────────────────────
+
+    def step(self, reward: float, memory_pressure: float,
+             conflict_score: float, task_name: str) -> np.ndarray:
+        """
+        Update bio state and return float32[5] = [pfc, hpc, acc, ins, amy].
+        signals mapping: reward → sentiment, memory_pressure → memory_load,
+                         conflict_score → drift
+        """
+        if self._engine is None:
+            return np.zeros(BIO_DIM, np.float32)
+
+        signals: Dict[str, float] = {
+            "sentiment":   float(np.clip(reward, -1.0, 1.0)),
+            "memory_load": float(np.clip(memory_pressure, 0.0, 1.0)),
+            "drift":       float(np.clip(conflict_score, 0.0, 1.0)),
+        }
+        result = self._engine.step(signals, topic="motor", intent=task_name)
+        self._last = result
+        return np.array(
+            [result["pfc"], result["hpc"], result["acc"],
+             result["ins"], result["amy"]], dtype=np.float32
+        )
+
+    def moderate_goal(self, goal_vec: np.ndarray) -> np.ndarray:
+        """
+        BioCor safety gate: inspect Gemini goal_vec and clamp if unsafe.
+        goal_vec[23] = urgency; [30] = grip; [31] = speed.
+        Returns a (possibly modified) copy of goal_vec.
+        """
+        if self._last is None:
+            return goal_vec
+        vec = goal_vec.copy()
+        amy = float(self._last.get("amy", 0.0))
+        pfc = float(self._last.get("pfc", 0.5))
+
+        if amy > _AMY_SAFETY_THRESHOLD:
+            # Amygdala overactivation: distrust external urgency, defer to PFC
+            vec[23] = float(np.clip(vec[23], 0.0, pfc))
+            log.debug("BioCor: amy=%.2f — urgency clamped to %.2f", amy, vec[23])
+
+        # Hard cap on urgency from black-box transformer
+        if vec[23] > _MAX_ALLOWED_URGENCY:
+            vec[23] = _MAX_ALLOWED_URGENCY
+            log.debug("BioCor: urgency hard-cap applied → %.2f", vec[23])
+
+        return vec
+
+    def noise_scale(self) -> float:
+        """Return DA/NE-based multiplier for exploration noise (0.5 – 1.5)."""
+        if self._last is None:
+            return 1.0
+        da = float(self._last.get("DA", 0.25))
+        ne = float(self._last.get("NE", 0.20))
+        # High DA → more exploration; high NE alone → more caution
+        scale = 0.5 + 2.0 * da + 1.0 * ne
+        return float(np.clip(scale, 0.5, 1.5))
+
+    def proximity_scale(self) -> float:
+        """OXT (oxytocin) boosts social/approach reward scaling (0.8 – 1.3)."""
+        if self._last is None:
+            return 1.0
+        oxt = float(self._last.get("OXT", 0.27))
+        return float(np.clip(0.8 + oxt * 1.8, 0.8, 1.3))
+
+    def reset(self):
+        self._last = None
+        if self._engine is not None and hasattr(self._engine, 'reset'):
+            self._engine.reset()

embodied/phantom_cortex.py

@@ -0,0 +1,121 @@
+"""
+PhantomCortex — complete cognitive architecture integration.
+
+State vector (73 dims):
+  [0:28]   body state (VirtualBody) — incl. gyro [24:27] + abs_height [27]
+  [28:36]  memory scalars (4-tier × 2: p1,e1,p2,e2,p3,e3,consensus,centrality)
+  [36:68]  goal vector (GoalSpec → 32-dim, from Gemini or fallback)
+  [68:73]  bio state (pfc, hpc, acc, ins, amy)
+
+Data flow per step:
+  1. Memory.step(mem_inputs)     → mem_scalars[8]
+  2. ACC.detect(...)             → conflict_score
+  3. BioCor.step(...)            → bio_vec[5]
+  4. BioCor.moderate_goal(goal)  → safety-filtered goal_vec
+  5. Concatenate all → state[73]
+  6. Noise = base × ACC.noise_mult × BioCor.noise_scale
+"""
+from __future__ import annotations
+import numpy as np
+import logging
+from typing import Optional
+
+from embodied.phantom_memory import PhantomMemory, MEM_OUT_DIM
+from embodied.phantom_biocor import PhantomBioCor, BIO_DIM
+from embodied.phantom_acc    import PhantomACC
+from embodied.goal_encoder   import GOAL_DIM, GoalSpec, encode_goal, goal_for_task
+
+log = logging.getLogger("phantom.cortex")
+
+BODY_DIM   = 28
+CORTEX_DIM = BODY_DIM + MEM_OUT_DIM + GOAL_DIM + BIO_DIM  # 28+8+32+5 = 73
+
+
+class PhantomCortex:
+    """
+    Integration hub.  One instance per agent; call step() every RL step.
+    """
+
+    def __init__(self):
+        self.memory = PhantomMemory()
+        self.biocor = PhantomBioCor()
+        self.acc    = PhantomACC()
+
+        self._mem_scalars = np.zeros(MEM_OUT_DIM, np.float32)
+        self._bio_vec     = np.zeros(BIO_DIM,     np.float32)
+        self._goal_vec    = np.zeros(GOAL_DIM,    np.float32)
+        self._conflict    = 0.0
+
+    # ── episode boundary ──────────────────────────────────────────────────
+
+    def reset(self, task_name: str = "stand"):
+        self.memory.reset()
+        self.biocor.reset()
+        self._mem_scalars = np.zeros(MEM_OUT_DIM, np.float32)
+        self._bio_vec     = np.zeros(BIO_DIM,     np.float32)
+        self._goal_vec    = encode_goal(goal_for_task(task_name))
+        self._conflict    = 0.0
+
+    def set_goal(self, goal_vec: np.ndarray):
+        """Set goal_vec from Gemini (or fallback); BioCor will moderate it."""
+        self._goal_vec = goal_vec.astype(np.float32)
+
+    # ── per-step ──────────────────────────────────────────────────────────
+
+    def step(self, body_state: np.ndarray, last_action: np.ndarray,
+             reward: float, task_name: str) -> np.ndarray:
+        """
+        Full cortex tick. Returns augmented state float32[69].
+        Called every RL environment step.
+        """
+        # 1. Memory inputs from body state + last action
+        mem_in = self._build_mem_inputs(body_state, last_action)
+        self._mem_scalars = self.memory.step(mem_in)
+
+        # 2. ACC conflict detection
+        self._conflict = self.acc.detect(task_name, body_state, self._bio_vec)
+
+        # 3. Bio update (uses reward + memory pressure + conflict)
+        mem_pressure = float(self._mem_scalars[0])  # tier1 pressure
+        self._bio_vec = self.biocor.step(reward, mem_pressure, self._conflict, task_name)
+
+        # 4. Goal moderation (BioCor safety filter on Gemini goal)
+        safe_goal = self.biocor.moderate_goal(self._goal_vec)
+
+        # 5. Concatenate
+        return np.concatenate([
+            body_state.astype(np.float32),
+            self._mem_scalars,
+            safe_goal,
+            self._bio_vec,
+        ]).astype(np.float32)
+
+    def noise_multiplier(self, base_noise: float) -> float:
+        """
+        ACC conflict + biocor DA/NE modulate exploration noise.
+        Returns actual noise std to use.
+        """
+        acc_mult  = self.acc.noise_multiplier()       # 1.0 – 2.0
+        bio_scale = self.biocor.noise_scale()         # 0.5 – 1.5
+        return float(np.clip(base_noise * acc_mult * bio_scale, 0.01, 1.0))
+
+    def safety_bypass(self) -> bool:
+        """True when ACC signals safety_bypass — action should be overridden."""
+        return self.acc.safety_bypass
+
+    # ── helpers ───────────────────────────────────────────────────────────
+
+    @staticmethod
+    def _build_mem_inputs(body_state: np.ndarray,
+                          last_action: np.ndarray) -> list[float]:
+        """5-channel memory input: hand_L_y / hand_R_y / torso_tilt / grip_L / grip_R."""
+        bs = body_state
+        grip_L = float(last_action[8]) if len(last_action) > 8 else 0.0
+        grip_R = float(last_action[9]) if len(last_action) > 9 else 0.0
+        return [
+            float(np.tanh(bs[18])) if len(bs) > 18 else 0.0,  # hand_L_rel_y
+            float(np.tanh(bs[19])) if len(bs) > 19 else 0.0,  # hand_R_rel_y
+            float(np.tanh(bs[12])) if len(bs) > 12 else 0.0,  # torso_tilt_x
+            float(np.tanh(grip_L)),
+            float(np.tanh(grip_R)),
+        ]

embodied/phantom_memory.py

@@ -0,0 +1,152 @@
+"""
+PhantomMemory — 4-tier HexaPenta memory hierarchy.
+
+Tier 1  working   HexaPentaMemoryLattice   depth=600   (fast, shallow)
+Tier 2  episodic  FractalHexaPentaMemory   depth=15000  segments=3
+Tier 3  long-term FractalHexaPentaMemory   depth=100000 segments=7  scale_levels=2
+Tier 4  archive   DataLedgerMemory         shards=7     retention_blocks=4096
+
+PAC-style coupling: tier-N energy gates how often tier-(N+1) is updated.
+Output: np.ndarray[8] — [p1,e1, p2,e2, p3,e3, p4c,p4n]
+  p = pressure, e = energy, p4c = DataLedger consensus mean, p4n = centrality
+"""
+from __future__ import annotations
+import numpy as np
+import logging
+from typing import Sequence
+
+log = logging.getLogger("phantom.memory")
+
+try:
+    from cogcore.vendor.genomeforge.vertical_memory import (
+        HexaPentaMemoryLattice, HexaPentaMemoryConfig,
+    )
+    from cogcore.vendor.genomeforge.fractal_memory import (
+        FractalHexaPentaMemory, FractalHexaPentaMemoryConfig,
+    )
+    from cogcore.vendor.genomeforge.data_ledger_memory import (
+        DataLedgerMemory, DataLedgerMemoryConfig,
+    )
+    _HAS_MEMORY = True
+except ImportError:
+    _HAS_MEMORY = False
+    log.warning("genomeforge not available — PhantomMemory running in zero-output mode")
+
+MEM_OUT_DIM = 8  # 2 scalars × 4 tiers
+
+
+class PhantomMemory:
+    """4-tier episodic/long-term memory with PAC-style inter-tier gating."""
+
+    # PAC gate: tier N+1 updates only when tier N energy exceeds this
+    _T1_GATE = 0.05
+    _T2_GATE = 0.08
+    _T3_GATE = 0.10
+
+    # Fall-back update intervals when gate is never triggered
+    _T2_INTERVAL = 4
+    _T3_INTERVAL = 16
+    _T4_INTERVAL = 64
+
+    def __init__(self):
+        self._step = 0
+        self._t1_energy = 0.0
+
+        if not _HAS_MEMORY:
+            self._t1 = self._t2 = self._t3 = self._t4 = None
+            return
+
+        self._t1 = HexaPentaMemoryLattice(HexaPentaMemoryConfig(
+            depth=600, active_depth=32,
+            tau=0.88, coupling=0.12, ring_coupling=0.10,
+            rotation_rate=0.05, rotation_mode="spiral_hex",
+        ))
+        self._t2 = FractalHexaPentaMemory(FractalHexaPentaMemoryConfig(
+            depth=15000, scale_levels=1, segments=3, active_segments=1,
+            tau=0.88, coupling=0.12, ring_coupling=0.10,
+            scale_coupling=0.18, segment_coupling=0.15,
+            consolidation_interval=8, consolidation_strength=0.25,
+            rotation_rate=0.05, rotation_mode="spiral_hex",
+        ))
+        self._t3 = FractalHexaPentaMemory(FractalHexaPentaMemoryConfig(
+            depth=100000, scale_levels=2, segments=7, active_segments=1,
+            tau=0.90, coupling=0.10, ring_coupling=0.08,
+            scale_coupling=0.20, segment_coupling=0.18,
+            consolidation_interval=16, consolidation_strength=0.30,
+            rotation_rate=0.03, rotation_mode="spiral_hex",
+        ))
+        self._t4 = DataLedgerMemory(DataLedgerMemoryConfig(
+            channels=5, shards=7,
+            consensus_window=64, checkpoint_interval=16,
+            retention_blocks=4096,
+            tau=0.82, recovery_strength=0.35, evolution_rate=0.10,
+        ))
+
+        # Last snapshots (for PAC coupling)
+        self._s1 = self._s2 = self._s3 = self._s4 = None
+
+    # ── public ────────────────────────────────────────────────────────────
+
+    def step(self, features: Sequence[float]) -> np.ndarray:
+        """
+        Feed 5 sensory scalars (P/U/Z/B/η) through all tiers.
+        Returns float32[8]: [p1,e1, p2,e2, p3,e3, consensus,centrality]
+        """
+        self._step += 1
+        if not _HAS_MEMORY or self._t1 is None:
+            return np.zeros(MEM_OUT_DIM, np.float32)
+
+        feats = list(features[:5]) if len(features) >= 5 else list(features) + [0.0] * (5 - len(features))
+
+        # Tier 1 — always updated
+        s1 = self._t1.step(feats)
+        self._s1 = s1
+        self._t1_energy = s1.energy
+
+        # Tier 2 — PAC gate from tier 1 energy OR periodic fallback
+        t2_trigger = (s1.energy >= self._T1_GATE) or (self._step % self._T2_INTERVAL == 0)
+        if t2_trigger:
+            self._s2 = self._t2.step(feats)
+
+        # Tier 3 — PAC gate from tier 2 energy
+        s2_energy = self._s2.energy if self._s2 is not None else 0.0
+        t3_trigger = (s2_energy >= self._T2_GATE) or (self._step % self._T3_INTERVAL == 0)
+        if t3_trigger:
+            self._s3 = self._t3.step(feats)
+
+        # Tier 4 — PAC gate from tier 3 energy
+        s3_energy = self._s3.energy if self._s3 is not None else 0.0
+        t4_trigger = (s3_energy >= self._T3_GATE) or (self._step % self._T4_INTERVAL == 0)
+        if t4_trigger:
+            self._s4 = self._t4.step(feats)
+
+        return self._pack()
+
+    def reset(self):
+        """Reset all tiers at episode boundary."""
+        self._step = 0
+        self._t1_energy = 0.0
+        self._s1 = self._s2 = self._s3 = self._s4 = None
+        if _HAS_MEMORY and self._t1 is not None:
+            for tier in (self._t1, self._t2, self._t3, self._t4):
+                if hasattr(tier, 'reset'):
+                    tier.reset()
+
+    # ── internal ──────────────────────────────────────────────────────────
+
+    def _pack(self) -> np.ndarray:
+        out = np.zeros(MEM_OUT_DIM, np.float32)
+        if self._s1 is not None:
+            out[0] = float(self._s1.pressure)
+            out[1] = float(self._s1.energy)
+        if self._s2 is not None:
+            out[2] = float(self._s2.pressure)
+            out[3] = float(self._s2.energy)
+        if self._s3 is not None:
+            out[4] = float(self._s3.pressure)
+            out[5] = float(self._s3.energy)
+        if self._s4 is not None:
+            cons = self._s4.consensus
+            out[6] = float(np.mean(cons)) if hasattr(cons, '__len__') else float(cons)
+            out[7] = float(np.clip(self._s4.centrality, 0.0, 1.0))
+        return out

embodied/physics_world.py

@@ -0,0 +1,651 @@
+"""
+PhysicsWorldEnv: voxelový fyzikální svět s gravitací, terénem, interaktivními
+objekty a reálnou fyzikou rozbití (FractureBridge, MaterialDegradation).
+
+Materiálová fyzika rozbití:
+  - Při každé kolizi se počítá rychlost nárazu (relative_velocity z manifoldu)
+  - Kinetická energie → tepelný spike + entropie (inelasticita) → stress pole
+  - FractureBridge.evaluate() rozhodne zda objekt praská
+  - Při rozpadnutí se spawnují fragmenty s náhodnou rychlostí od nárazu
+"""
+from __future__ import annotations
+import sys, os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+import numpy as np
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple
+
+from engine.physics.rigid_body import PhysicsWorld, BodyType, vec3, Vec3, length
+from engine.sim.fracture import FractureBridge, FractureBridgeConfig, compute_stress
+
+
+# ── Materiálové vlastnosti ────────────────────────────────────────────────────
+
+@dataclass(frozen=True)
+class MaterialProps:
+    name: str
+    yield_velocity: float       # m/s — minimální rychlost nárazu pro rozbití
+    thermal_sensitivity: float  # nárůst T na jednotku kinetické energie
+    entropy_base: float         # základní entropie materiálu (neuspořádanost)
+    fracture_threshold: float   # práh FractureBridge (0..1)
+    n_fragments: int            # počet úlomků
+    fragment_size_frac: float   # úlomek = frac × original half-size
+
+
+MATERIAL_PROPS: Dict[str, MaterialProps] = {
+    "cup": MaterialProps(
+        name="ceramic",
+        # 4.5 m/s ≈ drop from ~1 m (table-height drop breaks, gentle placement survives)
+        yield_velocity=4.5,
+        thermal_sensitivity=0.08,   # scaled down so risk is gradual above threshold
+        entropy_base=0.40,
+        fracture_threshold=0.48,
+        n_fragments=6,
+        fragment_size_frac=0.45,
+    ),
+    "block": MaterialProps(
+        name="wood",
+        yield_velocity=8.0,          # block survives falls up to ~3 m
+        thermal_sensitivity=0.04,
+        entropy_base=0.18,
+        fracture_threshold=0.62,
+        n_fragments=3,
+        fragment_size_frac=0.55,
+    ),
+    "handle": MaterialProps(
+        name="metal",
+        yield_velocity=14.0,         # kovová klika se téměř nerozbije
+        thermal_sensitivity=0.015,
+        entropy_base=0.06,
+        fracture_threshold=0.80,
+        n_fragments=2,
+        fragment_size_frac=0.6,
+    ),
+    "ball": MaterialProps(
+        name="rubber",
+        yield_velocity=50.0,         # gumový míč se nikdy nerozbije
+        thermal_sensitivity=0.01,
+        entropy_base=0.05,
+        fracture_threshold=0.99,
+        n_fragments=1,
+        fragment_size_frac=0.9,
+    ),
+    "cube": MaterialProps(
+        name="plastic",
+        yield_velocity=10.0,         # plastová kostka je odolná
+        thermal_sensitivity=0.03,
+        entropy_base=0.15,
+        fracture_threshold=0.70,
+        n_fragments=3,
+        fragment_size_frac=0.50,
+    ),
+    "shape_piece": MaterialProps(
+        name="wood",
+        yield_velocity=8.0,
+        thermal_sensitivity=0.04,
+        entropy_base=0.18,
+        fracture_threshold=0.65,
+        n_fragments=2,
+        fragment_size_frac=0.55,
+    ),
+}
+
+_FRACTURE_BRIDGE = FractureBridge(FractureBridgeConfig(
+    fracture_risk_threshold=0.50,
+    propagation_enabled=True,
+    propagation_radius=1,
+    propagation_gain=0.38,
+    propagation_seed_top_k=8,
+))
+
+
+def _impact_stress(mat: MaterialProps, impact_speed: float,
+                   obj_mass: float, restitution: float) -> float:
+    """
+    Převede rychlost nárazu → skalární stress (0..1).
+    Využívá FractureBridge přes 2×2×2 voxelové pole.
+    """
+    ke_per_kg   = 0.5 * impact_speed ** 2
+    T_spike     = 293.15 + ke_per_kg * mat.thermal_sensitivity * 400.0
+    S_spike     = mat.entropy_base + (1.0 - restitution) * ke_per_kg * 0.25
+
+    shape = (2, 2, 2)
+    vox   = np.ones(shape, dtype=np.int32)
+    thermal = np.full(shape, T_spike,  dtype=np.float32)
+    entropy = np.full(shape, S_spike,  dtype=np.float32)
+    stress  = compute_stress(
+        vox, thermal, entropy,
+        thermal_expansion_coeff=5e-4,
+        entropy_damage_scale=0.45,
+    )
+    result = _FRACTURE_BRIDGE.evaluate(
+        external_failure_risk_field=stress.astype(np.float64),
+        base_stress_field=stress.astype(np.float64),
+    )
+    return float(result["fracture_risk_max"])
+
+
+# ── Voxel grid ────────────────────────────────────────────────────────────────
+
+class VoxelGrid:
+    def __init__(self, size: Tuple[int, int, int]):
+        self.data = np.zeros(size, dtype=np.uint8)
+        self.size = size
+
+    def is_solid(self, x: int, y: int, z: int) -> bool:
+        sx, sy, sz = self.size
+        if 0 <= x < sx and 0 <= y < sy and 0 <= z < sz:
+            return bool(self.data[x, y, z] > 0)
+        return True
+
+    def set_solid(self, x: int, y: int, z: int, v: int = 1):
+        sx, sy, sz = self.size
+        if 0 <= x < sx and 0 <= y < sy and 0 <= z < sz:
+            self.data[x, y, z] = v
+
+
+# ── Interactive object ────────────────────────────────────────────────────────
+
+@dataclass
+class InteractiveObject:
+    id: str
+    obj_type: str
+    initial_pos: Vec3
+    body_id: str
+    is_grasped: bool = False
+    held_by: str = ""
+    is_broken: bool = False
+    fragment_ids: List[str] = field(default_factory=list)
+    # Accumulated impact energy between physics steps (reset after fracture check)
+    _pending_impact_speed: float = field(default=0.0, repr=False)
+    _pending_impact_vel: object  = field(default=None, repr=False)
+
+
+# ── World ─────────────────────────────────────────────────────────────────────
+
+class WorldEnv:
+    WORLD_SIZE = (64, 32, 64)
+
+    def __init__(self, seed: int = 42, terrain_type: str = "flat"):
+        self.seed         = seed
+        self.terrain_type = terrain_type
+        self.voxels       = VoxelGrid(self.WORLD_SIZE)
+        self.phys         = PhysicsWorld(gravity=vec3(0, -9.81, 0), substeps=3)
+        self._tick        = 0
+        self.interactive_objects: Dict[str, InteractiveObject] = {}
+        self._grasped: Dict[str, str] = {}
+        self.maze_goal: Optional[Vec3] = None
+        self._fracture_log: List[dict] = []   # for observer reporting
+        self._build_terrain()
+        self._register_collision_callback()
+
+    # ── Collision callback — live fracture detection ──────────────────────────
+
+    def _register_collision_callback(self):
+        def _on_collision(manifold):
+            for body in (manifold.body_a, manifold.body_b):
+                bid = body.body_id
+                if bid in self.interactive_objects:
+                    obj = self.interactive_objects[bid]
+                    if obj.is_broken or obj.is_grasped:
+                        continue
+                    speed = float(length(manifold.relative_velocity))
+                    # Keep worst hit per step
+                    if speed > obj._pending_impact_speed:
+                        obj._pending_impact_speed = speed
+                        obj._pending_impact_vel   = manifold.relative_velocity
+
+        self.phys.on_collision(_on_collision)
+
+    # ── Terrain builders ──────────────────────────────────────────────────────
+
+    def _build_terrain(self):
+        dispatch = {
+            "flat":      self._build_flat,
+            "hills":     self._build_hills,
+            "maze":      self._build_maze,
+            "obstacle":  self._build_obstacle_course,
+            "stairs":    self._build_stairs,
+            "household": self._build_household,
+            "military":  self._build_military_course,
+        }
+        dispatch.get(self.terrain_type, self._build_flat)()
+        self._add_boundary_walls()
+        self._add_ground_body()
+
+    def _add_ground_body(self):
+        SX, _, SZ = self.WORLD_SIZE
+        self.phys.create_body(
+            "ground_plane", BodyType.STATIC,
+            position=vec3(SX / 2, -10.0, SZ / 2),
+            size=vec3(float(SX * 2), 20.0, float(SZ * 2)),
+            mass=0.0, restitution=0.15, friction=0.85,
+        )
+
+    def _build_flat(self):
+        SX, _, SZ = self.WORLD_SIZE
+        for x in range(SX):
+            for z in range(SZ):
+                self.voxels.set_solid(x, 0, z, 1)
+
+    def _build_hills(self):
+        SX, SY, SZ = self.WORLD_SIZE
+        rng = np.random.default_rng(self.seed)
+        for x in range(SX):
+            for z in range(SZ):
+                h = int(2 + 2.5 * np.sin(x * 0.3) * np.cos(z * 0.25) +
+                        rng.uniform(0, 0.8))
+                for y in range(min(h + 1, SY)):
+                    self.voxels.set_solid(x, y, z, 1)
+
+    def _build_maze(self):
+        SX, _, SZ = self.WORLD_SIZE
+        for x in range(SX):
+            for z in range(SZ):
+                self.voxels.set_solid(x, 0, z, 1)
+        CELL = 4
+        rows = SZ // CELL
+        cols = SX // CELL
+        visited = np.zeros((cols, rows), dtype=bool)
+        walls_h = np.ones((cols, rows + 1), dtype=bool)
+        walls_v = np.ones((cols + 1, rows), dtype=bool)
+
+        def _carve(cx, cy):
+            visited[cx, cy] = True
+            dirs = [(1,0),(-1,0),(0,1),(0,-1)]
+            np.random.default_rng(self.seed + cx * 97 + cy).shuffle(dirs)
+            for dx, dy in dirs:
+                nx, ny = cx + dx, cy + dy
+                if 0 <= nx < cols and 0 <= ny < rows and not visited[nx, ny]:
+                    if dy == 0:
+                        walls_v[max(cx, nx), cy] = False
+                    else:
+                        walls_h[cx, max(cy, ny)] = False
+                    _carve(nx, ny)
+
+        _carve(0, 0)
+
+        def _wall(x0, z0, x1, z1):
+            for x in range(min(x0,x1), max(x0,x1)+1):
+                for z in range(min(z0,z1), max(z0,z1)+1):
+                    for y in range(1, 5):
+                        self.voxels.set_solid(x, y, z, 2)
+
+        for cx in range(cols):
+            for cy in range(rows):
+                wx0 = cx * CELL
+                wz0 = cy * CELL
+                if walls_v[cx, cy]:
+                    _wall(wx0, wz0, wx0, wz0 + CELL - 1)
+                if walls_h[cx, cy]:
+                    _wall(wx0, wz0, wx0 + CELL - 1, wz0)
+        _wall(0, 0, 0, SZ - 1)
+        _wall(SX-1, 0, SX-1, SZ-1)
+        _wall(0, 0, SX-1, 0)
+        _wall(0, SZ-1, SX-1, SZ-1)
+        gx = (cols - 1) * CELL + 2
+        gz = (rows - 1) * CELL + 2
+        for y in range(1, 4):
+            self.voxels.set_solid(min(gx, SX-1), y, min(gz, SZ-1), 3)
+        self.maze_goal = vec3(float(min(gx, SX-2)), 1.0, float(min(gz, SZ-2)))
+
+    def _build_obstacle_course(self):
+        SX, _, SZ = self.WORLD_SIZE
+        for x in range(SX):
+            for z in range(SZ):
+                self.voxels.set_solid(x, 0, z, 1)
+        rng = np.random.default_rng(self.seed + 1)
+        for i in range(1, SX // 8):
+            h = int(rng.integers(1, 4))
+            for x in range(i*8, i*8+4):
+                for z in range(10, SZ-10):
+                    for y in range(1, h+1):
+                        self.voxels.set_solid(x, y, z, 1)
+        for j in range(4):
+            bx = 6 + j * 12
+            for z in range(20, 40):
+                for y in range(1, 3):
+                    self.voxels.set_solid(bx, y, z, 1)
+
+    def _build_military_course(self):
+        """
+        Vojenská překážková dráha (opičí dráha).
+        Agent běží ve směru +X od x=4 do x=60, course centrována na z=32.
+
+        Překážky:
+          x=16-17  Hurdle 1   – nízká zeď h=2, přeskočit
+          x=26-27  Hurdle 2   – nízká zeď h=2, přeskočit
+          x=35-38  Wall climb – vysoká zeď h=4 s výběžkem, vylézt
+          x=39-43  Descent    – schody dolů z h=4
+          x=46-53  Low crawl  – strop na y=2, plazit se
+          x=55-57  Jump pit   – jáma bez země, přeskočit
+        """
+        SX, _, SZ = self.WORLD_SIZE
+        ZC = SZ // 2        # z=32, středová osa kurzu
+        ZH = 6              # půl-šířka kurzu (±6), celkem 12m
+        Z0, Z1 = ZC - ZH, ZC + ZH
+
+        def solid(x0, x1, y0, y1, z0, z1, val=1):
+            for x in range(x0, x1 + 1):
+                for y in range(y0, y1 + 1):
+                    for z in range(z0, z1 + 1):
+                        self.voxels.set_solid(x, y, z, val)
+
+        # Ground floor everywhere
+        solid(0, SX - 1, 0, 0, 0, SZ - 1)
+
+        # Side channel walls (keep agent on track)
+        for x in range(SX):
+            for y in range(1, 7):
+                self.voxels.set_solid(x, y, Z0 - 1, 1)
+                self.voxels.set_solid(x, y, Z1 + 1, 1)
+
+        # ── HURDLE 1 (x=16-17, h=2) ──────────────────────────────────────────
+        solid(16, 17, 1, 2, Z0, Z1)
+
+        # ── HURDLE 2 (x=26-27, h=2) ──────────────────────────────────────────
+        solid(26, 27, 1, 2, Z0, Z1)
+
+        # ── WALL CLIMB (x=35-38, h=4) ─────────────────────────────────────────
+        # Toeholds: ledge on approach side at h=1-2 (x=34)
+        solid(34, 34, 1, 2, Z0, Z1)
+        # Main wall
+        solid(35, 38, 1, 4, Z0, Z1)
+        # Top platform to land on (x=38, y=4 — flat top)
+        solid(38, 38, 4, 4, Z0, Z1)
+
+        # ── DESCENT STEPS (x=39-43): from h=4 down to ground ────────────────
+        # Each step is 1m wide and 1m lower
+        for i, x in enumerate(range(39, 44)):
+            h = 4 - i
+            if h >= 1:
+                solid(x, x, 1, h, Z0, Z1)
+
+        # ── LOW CRAWL TUNNEL (x=46-53): ceiling at y=2) ──────────────────────
+        # Ceiling blocks: agent torso height ~1.8m, must crouch to pass y<2
+        for x in range(46, 54):
+            for z in range(Z0, Z1 + 1):
+                self.voxels.set_solid(x, 2, z, 1)
+                self.voxels.set_solid(x, 3, z, 1)
+
+        # ── JUMP PIT (x=55-57): remove ground ───────────────────────────────
+        for x in range(55, 58):
+            for z in range(Z0, Z1 + 1):
+                self.voxels.set_solid(x, 0, z, 0)
+
+        # Ensure landing pad after pit
+        solid(58, SX - 1, 0, 0, Z0, Z1)
+
+    def _build_stairs(self):
+        SX, _, SZ = self.WORLD_SIZE
+        for x in range(SX):
+            for z in range(SZ):
+                self.voxels.set_solid(x, 0, z, 1)
+        for step in range(1, 14):
+            for x in range(step * 4, step * 4 + 4):
+                for z in range(8, SZ - 8):
+                    for y in range(1, step + 1):
+                        self.voxels.set_solid(x, y, z, 1)
+
+    def _build_household(self):
+        SX, SY, SZ = self.WORLD_SIZE
+        for x in range(SX):
+            for z in range(SZ):
+                self.voxels.set_solid(x, 0, z, 1)
+
+        def _fill(x0, x1, y0, y1, z0, z1, mat=2):
+            for x in range(x0, x1+1):
+                for y in range(y0, y1+1):
+                    for z in range(z0, z1+1):
+                        self.voxels.set_solid(x, y, z, mat)
+
+        _fill(38, 38, 1, 8, 1, 42)
+        _fill(1, 38, 1, 8, 42, 42)
+        _fill(10, 14, 1, 2, 14, 18)
+        _fill(8, 10, 1, 2, 20, 22)
+        _fill(8, 10, 3, 5, 22, 23)
+        _fill(2, 4, 1, 7, 8, 22, mat=2)
+        for shelf_y in (2, 4, 6):
+            _fill(2, 4, shelf_y, shelf_y, 8, 22, mat=2)
+        for hollow_y in (1, 3, 5):
+            for x in range(3, 4):
+                for z in range(9, 22):
+                    self.voxels.set_solid(x, hollow_y, z, 0)
+        _fill(20, 26, 1, 3, 3, 7)
+        _fill(22, 24, 4, 6, 3, 4)
+        self.voxels.set_solid(23, 4, 5, 3)
+
+    def _add_boundary_walls(self):
+        SX, SY, SZ = self.WORLD_SIZE
+        for x in range(SX):
+            for y in range(SY):
+                self.voxels.set_solid(x, y, 0, 1)
+                self.voxels.set_solid(x, y, SZ-1, 1)
+        for z in range(SZ):
+            for y in range(SY):
+                self.voxels.set_solid(0, y, z, 1)
+                self.voxels.set_solid(SX-1, y, z, 1)
+        if self.terrain_type == "household":
+            for x in range(13, 18):
+                for y in range(1, 7):
+                    self.voxels.set_solid(x, y, 0, 0)
+
+    # ── Interactive objects ───────────────────────────────────────────────────
+
+    def add_interactive_object(self, obj_id: str, obj_type: str,
+                                pos: Vec3, size: Vec3 = None,
+                                mass: float = 0.3) -> InteractiveObject:
+        if size is None:
+            size = vec3(0.08, 0.12, 0.08)
+        self.phys.create_body(
+            obj_id, BodyType.DYNAMIC,
+            position=pos, size=size,
+            mass=mass, restitution=0.3, friction=0.6,
+        )
+        obj = InteractiveObject(
+            id=obj_id, obj_type=obj_type,
+            initial_pos=vec3(float(pos[0]), float(pos[1]), float(pos[2])),
+            body_id=obj_id,
+        )
+        self.interactive_objects[obj_id] = obj
+        return obj
+
+    # ── Fracture system ───────────────────────────────────────────────────────
+
+    def _process_fractures(self):
+        """Check accumulated impact speeds; fracture objects that exceed yield."""
+        for obj_id, obj in list(self.interactive_objects.items()):
+            speed = obj._pending_impact_speed
+            obj._pending_impact_speed = 0.0
+
+            if obj.is_broken or speed == 0.0:
+                continue
+
+            mat = MATERIAL_PROPS.get(obj.obj_type)
+            if mat is None or speed < mat.yield_velocity:
+                continue
+
+            # Compute stress via FractureBridge
+            body = self.phys.bodies.get(obj.body_id)
+            if body is None:
+                continue
+            restitution = body.restitution
+            risk = _impact_stress(mat, speed, body.mass, restitution)
+
+            if risk >= mat.fracture_threshold:
+                self._fracture_object(obj, body, obj._pending_impact_vel, mat)
+
+    def _fracture_object(self, obj: InteractiveObject, body,
+                         impact_vel, mat: MaterialProps):
+        """Replace object with N fragments flying in random directions."""
+        pos  = body.position.copy() if hasattr(body.position, 'copy') else vec3(*body.position)
+        half = body.aabb_local.max   # half-size
+        rng  = np.random.default_rng(int(abs(hash(obj.id))) % (2**31))
+
+        frag_ids = []
+        for i in range(mat.n_fragments):
+            fid  = f"{obj.id}_frag_{i}"
+            foff = vec3(
+                float(rng.uniform(-float(half[0]), float(half[0]))),
+                float(rng.uniform(0.0, float(half[1]))),
+                float(rng.uniform(-float(half[2]), float(half[2]))),
+            )
+            fsz  = vec3(
+                float(half[0]) * mat.fragment_size_frac * float(rng.uniform(0.6, 1.0)),
+                float(half[1]) * mat.fragment_size_frac * float(rng.uniform(0.6, 1.0)),
+                float(half[2]) * mat.fragment_size_frac * float(rng.uniform(0.6, 1.0)),
+            )
+            fmass = body.mass * mat.fragment_size_frac ** 3 * 8.0
+
+            frag = self.phys.create_body(
+                fid, BodyType.DYNAMIC,
+                position=pos + foff,
+                size=fsz,
+                mass=max(0.01, fmass),
+                restitution=0.12,
+                friction=0.85,
+            )
+            iv = impact_vel if impact_vel is not None else vec3()
+            frag.velocity = vec3(
+                float(iv[0]) * 0.4 + float(rng.uniform(-3.0, 3.0)),
+                float(abs(iv[1])) * 0.3 + float(rng.uniform(0.5, 2.5)),
+                float(iv[2]) * 0.4 + float(rng.uniform(-3.0, 3.0)),
+            )
+            frag_ids.append(fid)
+
+        # Deactivate original body — mark as static so physics ignores it
+        body.body_type = BodyType.STATIC
+        body.velocity  = vec3()
+
+        obj.is_broken    = True
+        obj.fragment_ids = frag_ids
+
+        self._fracture_log.append({
+            "tick": self._tick,
+            "object": obj.id,
+            "material": mat.name,
+            "impact_speed": float(body.restitution),
+            "n_fragments": mat.n_fragments,
+        })
+
+    # ── Grasp ─────────────────────────────────────────────────────────────────
+
+    def check_grasp(self, hand_id: str, hand_pos: Vec3, grip: float,
+                    grasp_radius: float = 0.35):
+        if grip > 0.25:
+            self.release(hand_id)
+            return
+        if grip < -0.25 and hand_id not in self._grasped:
+            for obj in self.interactive_objects.values():
+                if not obj.is_grasped and not obj.is_broken:
+                    body = self.phys.bodies.get(obj.body_id)
+                    if body is None:
+                        continue
+                    d = float(length(hand_pos - body.position))
+                    if d < grasp_radius:
+                        obj.is_grasped = True
+                        obj.held_by    = hand_id
+                        self._grasped[hand_id] = obj.id
+                        return
+
+    def release(self, hand_id: str):
+        if hand_id in self._grasped:
+            obj = self.interactive_objects[self._grasped[hand_id]]
+            obj.is_grasped = False
+            obj.held_by    = ""
+            del self._grasped[hand_id]
+
+    def update_grasped(self, body_positions: Dict[str, Vec3],
+                       body_velocities: Dict[str, Vec3]):
+        for hand_id, obj_id in self._grasped.items():
+            obj   = self.interactive_objects[obj_id]
+            pbody = self.phys.bodies.get(obj.body_id)
+            if pbody is None or obj.is_broken:
+                continue
+            h_pos = body_positions[hand_id]
+            h_vel = body_velocities.get(hand_id, vec3())
+            pbody.position = h_pos + vec3(0, -0.08, 0.05)
+            pbody.velocity = vec3(float(h_vel[0]), float(h_vel[1]), float(h_vel[2]))
+
+    def get_object_pos(self, obj_id: str) -> Vec3:
+        body = self.phys.bodies.get(self.interactive_objects[obj_id].body_id)
+        return body.position if body else vec3()
+
+    def is_grasped(self, obj_id: str) -> bool:
+        obj = self.interactive_objects.get(obj_id)
+        return bool(obj and obj.is_grasped)
+
+    def is_broken(self, obj_id: str) -> bool:
+        obj = self.interactive_objects.get(obj_id)
+        return bool(obj and obj.is_broken)
+
+    # ── Physics step ──────────────────────────────────────────────────────────
+
+    def step(self, dt: float = 0.016) -> List:
+        self._tick += 1
+        manifolds = self.phys.step(dt)
+
+        # Anti-tunneling ground clamp + impact detection for interactive objects
+        from engine.physics.rigid_body import BodyType as BT
+        for body in self.phys.bodies.values():
+            if body.body_type == BT.STATIC or body.mass <= 0:
+                continue
+            h = body.aabb_local.max[1]
+            floor_y = self.get_ground_height(
+                float(body.position[0]), float(body.position[2]))
+            if float(body.position[1]) - h < floor_y:
+                impact_speed = abs(float(body.velocity[1]))
+                # Record impact for interactive objects (voxel surface contact)
+                bid = body.body_id
+                if bid in self.interactive_objects:
+                    obj = self.interactive_objects[bid]
+                    if impact_speed > obj._pending_impact_speed:
+                        obj._pending_impact_speed = impact_speed
+                        obj._pending_impact_vel   = body.velocity
+                body.position[1] = floor_y + h
+                if float(body.velocity[1]) < 0:
+                    body.velocity[1] = abs(body.velocity[1]) * body.restitution
+                    body.is_grounded = True
+
+        # Also record impacts from AABB body-body manifolds
+        for m in manifolds:
+            speed = float(length(m.relative_velocity))
+            for body in (m.body_a, m.body_b):
+                bid = body.body_id
+                if bid in self.interactive_objects:
+                    obj = self.interactive_objects[bid]
+                    if speed > obj._pending_impact_speed:
+                        obj._pending_impact_speed = speed
+                        obj._pending_impact_vel   = m.relative_velocity
+
+        # Fracture check — runs after every physics step
+        self._process_fractures()
+        return manifolds
+
+    def get_ground_height(self, x: float, z: float) -> float:
+        ix, iz = int(x), int(z)
+        SX, SY, SZ = self.WORLD_SIZE
+        ix = max(1, min(SX-2, ix))
+        iz = max(1, min(SZ-2, iz))
+        for y in range(SY - 1, -1, -1):
+            if self.voxels.is_solid(ix, y, iz):
+                return float(y + 1)
+        return 0.0
+
+    def is_solid_at(self, x: float, y: float, z: float) -> bool:
+        return self.voxels.is_solid(int(x), int(y), int(z))
+
+    def reset(self):
+        self._tick = 0
+        self._grasped.clear()
+        self._fracture_log.clear()
+        for obj in self.interactive_objects.values():
+            obj.is_grasped  = False
+            obj.held_by     = ""
+            obj.is_broken   = False
+            obj.fragment_ids = []
+            obj._pending_impact_speed = 0.0
+            obj._pending_impact_vel   = None
+        self.phys = PhysicsWorld(gravity=vec3(0, -9.81, 0), substeps=3)
+        self._register_collision_callback()

embodied/pretrain/bc_driving.py

@@ -0,0 +1,416 @@
+"""
+BC předtrénování pro DriveCity — z reálných řidičských dat.
+
+Datasety (dle průzkumu, best-to-use):
+  1. CARLA Autopilot    — huggingface: immanuelpeter/carla-autopilot-multimodal-dataset
+                          Plně normalizované akce: throttle, steer, brake
+  2. L2D (Learning to Drive) — yaak-ai/L2D
+                          Největší: 19M+ snímků, 5000+ hodin, 10 Hz
+                          steering(norm), gas(0-1), brake(0-1)
+
+Mapování na agent 10D:
+  action[0]  = throttle - brake   (dopředu/dozadu)
+  action[2]  = steer              (zatáčení)
+  action[1,3..9] = 0              (nevyužité pro řízení)
+
+Spuštění:
+  python -m embodied.pretrain.bc_driving --dataset carla --steps 12000
+  python -m embodied.pretrain.bc_driving --dataset l2d   --steps 20000
+"""
+from __future__ import annotations
+
+import logging
+import os
+import sys
+import time
+import glob
+from pathlib import Path
+from typing import Tuple
+
+import numpy as np
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..'))
+
+from cogcore.cognition.motor import MotorActionHead, MotorActionConfig
+from embodied.rl_loop import RLConfig, PhantomAgent
+from embodied.pretrain.bc_pretrain import _save_agent_weights
+from embodied.goal_encoder import encode_goal, goal_for_task
+from embodied.phantom_cortex import CORTEX_DIM, BODY_DIM
+from embodied.tasks.drive_city import DriveCity
+
+log = logging.getLogger("phantom.bc_driving")
+logging.basicConfig(level=logging.INFO,
+                    format="%(asctime)s  %(levelname)-8s  %(name)s  %(message)s",
+                    datefmt="%H:%M:%S")
+
+
+# ── Stav vozidla pro DriveCity (inicializovat s nulovou rychlostí) ────────────
+
+def _make_drive_state(speed_norm: float = 0.0,
+                      steer: float = 0.0,
+                      throttle: float = 0.0) -> np.ndarray:
+    """
+    Vytvoří 73D state vektor odpovídající DriveCity.get_task_state():
+      state[0]  = speed (normalizovaná 0–1)
+      state[2]  = steer (−1..+1)
+      state[3]  = throttle (0..1)
+      state[18:26] = city_obs (nuly — bez mapy)
+      state[36:68] = goal_vec (drive_city goal)
+    """
+    state = np.zeros(CORTEX_DIM, dtype=np.float32)
+    state[0] = speed_norm
+    state[2] = steer
+    state[3] = throttle
+    goal_vec = encode_goal(goal_for_task("drive_city"))
+    state[BODY_DIM + 8: BODY_DIM + 8 + 32] = goal_vec
+    return state
+
+
+def _make_drive_action(throttle: float, brake: float, steer: float) -> np.ndarray:
+    """Normalizovaná 10D akce pro řízení."""
+    a = np.zeros(10, dtype=np.float32)
+    a[0] = float(np.clip(throttle - brake, -1.0, 1.0))   # gas/brake na ose 0
+    a[2] = float(np.clip(steer, -1.0, 1.0))              # steer
+    return a
+
+
+# ── Syntetická data z vlastní simulace (fallback) ────────────────────────────
+
+def _generate_synthetic_driving_data(n_samples: int = 15000,
+                                     seed: int = 42) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Generuje syntetická řidičská data z DriveCity simulace.
+    Expert policy: sleduj waypoint, brzdí u semaforů, zpomaluj u retardérů.
+
+    Používá se jako fallback pokud není dostupný HuggingFace dataset.
+    """
+    rng = np.random.default_rng(seed)
+    states, actions = [], []
+
+    # Simulujeme různé scénáře
+    scenarios = [
+        # (speed_kmh, target_speed, steer_variance, throttle_base)
+        (80,  80, 0.05, 0.65),   # dálnice — rovně
+        (50,  50, 0.12, 0.55),   # centrum — mírné zatáčení
+        (30,  30, 0.20, 0.40),   # residential — pomalé, více zatáček
+        (130, 130, 0.02, 0.85),  # D1 — max rychlost, minimum zatáček
+        (0,   50, 0.0,  0.80),   # rozjezd
+        (80,   0, 0.0,  0.0),    # brzdění
+        (60,  70, 0.08, 0.60),   # boulevard
+        (70,  30, 0.10, 0.0),    # zpomalení před křižovatkou
+    ]
+
+    per_scenario = n_samples // len(scenarios)
+    for speed, target, steer_var, thr_base in scenarios:
+        for _ in range(per_scenario):
+            speed_norm = speed / 140.0
+            steer = float(rng.normal(0.0, steer_var))
+            steer = np.clip(steer, -1.0, 1.0)
+
+            # Throttle: přiblíž se k target rychlosti
+            speed_err = (target - speed) / 140.0
+            throttle = float(np.clip(thr_base + speed_err * 0.5
+                                     + rng.normal(0.0, 0.05), 0.0, 1.0))
+            brake    = float(np.clip(-speed_err * 0.6
+                                     + rng.normal(0.0, 0.02), 0.0, 1.0))
+            if throttle > 0.1:
+                brake = 0.0
+
+            s = _make_drive_state(speed_norm, steer, throttle)
+            # Drobné perturbace v city obs části
+            s[18:26] = rng.uniform(0, 1, 8).astype(np.float32) * 0.3
+            a = _make_drive_action(throttle, brake, steer)
+            states.append(s)
+            actions.append(a)
+
+    # Shuffle
+    idx = rng.permutation(len(states))
+    return (np.array(states, dtype=np.float32)[idx],
+            np.array(actions, dtype=np.float32)[idx])
+
+
+# ── Loader pro L2D dataset (yaak-ai/L2D) ─────────────────────────────────────
+
+# Mapování road_type → kategorické číslo (pro state obohacení)
+_L2D_ROAD_MAP = {
+    "motorway": 1.0, "trunk": 0.9, "primary": 0.7,
+    "secondary": 0.55, "tertiary": 0.4, "residential": 0.25,
+    "service": 0.15, "unclassified": 0.3,
+}
+
+
+def _download_l2d_files(n_files: int = 2, cache_dir: str = "/tmp/l2d_cache") -> list:
+    """
+    Stáhne prvních n_files parquet souborů z yaak-ai/L2D (chunk-000).
+    Každý soubor = ~57 MB, ~1.1M řádků skutečné jízdy z Německa.
+    """
+    from huggingface_hub import hf_hub_download
+    os.makedirs(cache_dir, exist_ok=True)
+    paths = []
+    for i in range(n_files):
+        fname = f"data/chunk-000/file-{i:03d}.parquet"
+        local = os.path.join(cache_dir, f"l2d_chunk000_file{i:03d}.parquet")
+        if os.path.exists(local):
+            log.info("L2D soubor %d už existuje v cache (%s)", i, local)
+            paths.append(local)
+            continue
+        log.info("Stahuji L2D %s ...", fname)
+        path = hf_hub_download("yaak-ai/L2D", fname, repo_type="dataset",
+                               local_dir=cache_dir)
+        paths.append(path)
+    return paths
+
+
+def _load_l2d_dataset(
+    data_dir:    str   = "/tmp/l2d_cache",
+    n_samples:   int   = 80000,
+    road_filter: Optional[str] = None,
+    download:    bool  = True,
+    n_files:     int   = 1,
+) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Načte reálná řidičská data z L2D (yaak-ai/L2D, Apache 2.0).
+
+    Schema parquet:
+      action.continuous [3]: [gas_pedal_norm, brake_pedal_norm, steering_angle_norm]
+      observation.state.vehicle [8]: [speed_kmh, heading, heading_error, lat, lon, alt, acc_x, acc_y]
+      observation.state.road: "motorway" | "primary" | "residential" | ...
+      observation.state.max_speed: rychlostní limit (string, např. "50.0")
+
+    Args:
+        road_filter : 'highway' → motorway+trunk, 'city' → residential+tertiary, None → vše
+        download    : stáhnout z HuggingFace pokud nejsou lokální soubory
+        n_files     : počet parquet souborů ke stažení (1 soubor = ~1.1M řádků)
+    """
+    try:
+        import pandas as pd
+    except ImportError:
+        raise ImportError("pandas vyžadován pro L2D loader: pip install pandas pyarrow")
+
+    # Najdi nebo stáhni parquet soubory
+    parquet_files = sorted(glob.glob(os.path.join(data_dir, "l2d_*.parquet")))
+    if not parquet_files:
+        parquet_files = sorted(glob.glob(os.path.join(data_dir, "**/*.parquet"), recursive=True))
+    if not parquet_files and download:
+        parquet_files = _download_l2d_files(n_files=n_files, cache_dir=data_dir)
+    if not parquet_files:
+        raise FileNotFoundError(f"Žádné L2D parquet soubory v {data_dir}. Použij download=True.")
+
+    parquet_files = parquet_files[:n_files]
+
+    all_states, all_actions = [], []
+    for fpath in parquet_files:
+        log.info("Načítám %s ...", fpath)
+        df = pd.read_parquet(fpath, columns=[
+            "action.continuous",
+            "observation.state.vehicle",
+            "observation.state.road",
+            "observation.state.max_speed",
+        ])
+
+        # Filtr podle typu silnice
+        if road_filter == "highway":
+            mask = df["observation.state.road"].isin(["motorway", "trunk"])
+            df = df[mask]
+        elif road_filter == "city":
+            mask = df["observation.state.road"].isin(["residential", "tertiary", "service"])
+            df = df[mask]
+
+        if len(df) == 0:
+            log.warning("Po filtraci road_filter=%r: 0 řádků v %s", road_filter, fpath)
+            continue
+
+        # Subsample na n_samples // n_files
+        per_file = n_samples // len(parquet_files)
+        if len(df) > per_file:
+            df = df.sample(n=per_file, random_state=42)
+
+        # Vektorizované zpracování — rychlejší než iterrows
+        acts = np.stack(df["action.continuous"].values).astype(np.float32)   # (N, 3)
+        vehs = np.stack(df["observation.state.vehicle"].values).astype(np.float32)  # (N, 8)
+
+        gas   = np.clip(acts[:, 0], 0.0, 1.0)
+        brake = np.clip(acts[:, 1], 0.0, 1.0)
+        steer = np.clip(acts[:, 2], -1.0, 1.0)
+        speed_norm = np.clip(vehs[:, 0] / 140.0, 0.0, 1.5)
+
+        # Rychlostní limit → normalizuj
+        def _parse_limit(s):
+            try:
+                v = float(s)
+                return v if v > 0 else 50.0
+            except (ValueError, TypeError):
+                return 50.0
+        limits = np.array([_parse_limit(x) for x in df["observation.state.max_speed"].values],
+                          dtype=np.float32)
+        limit_norm = np.clip(limits / 130.0, 0.0, 1.0)
+
+        # Road type encoding
+        road_norms = np.array([_L2D_ROAD_MAP.get(r, 0.3)
+                                for r in df["observation.state.road"].values], dtype=np.float32)
+
+        N = len(df)
+        batch_states  = np.zeros((N, CORTEX_DIM), dtype=np.float32)
+        batch_actions = np.zeros((N, 10), dtype=np.float32)
+
+        goal_vec = encode_goal(goal_for_task("drive_city"))
+        batch_states[:, BODY_DIM + 8: BODY_DIM + 8 + 32] = goal_vec
+
+        batch_states[:, 0] = speed_norm
+        batch_states[:, 2] = steer
+        batch_states[:, 3] = gas
+        batch_states[:, 22] = road_norms
+        batch_states[:, 23] = limit_norm
+
+        batch_actions[:, 0] = np.clip(gas - brake, -1.0, 1.0)
+        batch_actions[:, 2] = steer
+
+        all_states.append(batch_states)
+        all_actions.append(batch_actions)
+
+    if not all_states:
+        raise ValueError("L2D loader: nepodařilo se načíst žádná data.")
+
+    states  = np.concatenate(all_states,  axis=0)
+    actions = np.concatenate(all_actions, axis=0)
+
+    # Shuffle
+    rng = np.random.default_rng(42)
+    idx = rng.permutation(len(states))
+    log.info("L2D dataset: %d vzorků  (road_filter=%r)", len(states), road_filter)
+    return states[idx], actions[idx]
+
+
+# ── Loader pro CARLA Autopilot dataset ───────────────────────────────────────
+
+def _load_carla_dataset(data_dir: str,
+                        max_episodes: int = 200) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Načte CARLA Autopilot epizody (immanuelpeter/carla-autopilot-multimodal-dataset).
+
+    Formát: každý epizoda = NPZ soubor s klíči:
+      'throttle' (T,), 'brake' (T,), 'steer' (T,), 'speed' (T,)
+    nebo CSV/JSON s control array.
+    """
+    states, actions = [], []
+
+    # Zkus NPZ formát
+    npz_files = sorted(glob.glob(os.path.join(data_dir, "**/*.npz"), recursive=True))
+    npz_files += sorted(glob.glob(os.path.join(data_dir, "*.npz")))
+    npz_files = list(dict.fromkeys(npz_files))[:max_episodes]
+
+    for fpath in npz_files:
+        try:
+            d = np.load(fpath, allow_pickle=True)
+            keys = list(d.keys())
+            throttle = d.get("throttle", d.get("gas", np.zeros(1)))
+            brake    = d.get("brake", np.zeros(len(throttle)))
+            steer    = d.get("steer", d.get("steering", np.zeros(len(throttle))))
+            speed    = d.get("speed", np.zeros(len(throttle)))
+            T = min(len(throttle), len(brake), len(steer), len(speed))
+            for t in range(T):
+                s = _make_drive_state(
+                    speed_norm=float(speed[t]) / 140.0,
+                    steer=float(steer[t]),
+                    throttle=float(throttle[t]),
+                )
+                a = _make_drive_action(float(throttle[t]), float(brake[t]), float(steer[t]))
+                states.append(s)
+                actions.append(a)
+        except Exception as e:
+            log.debug("Nelze načíst %s: %s", fpath, e)
+
+    if not states:
+        raise FileNotFoundError(f"Žádná CARLA data v {data_dir}")
+    return np.array(states, dtype=np.float32), np.array(actions, dtype=np.float32)
+
+
+# ── Hlavní BC funkce ──────────────────────────────────────────────────────────
+
+def run_driving_bc_pretraining(
+    dataset:     str   = "synthetic",
+    data_dir:    str   = "/tmp/carla_driving",
+    steps:       int   = 12000,
+    batch_size:  int   = 64,
+    lr:          float = 0.002,
+    save_path:   str   = "checkpoints/bc_driving.npz",
+    log_every:   int   = 1000,
+    road_filter: Optional[str] = None,
+    n_files:     int   = 1,
+) -> PhantomAgent:
+    """
+    BC předtrénování pro DriveCity.
+
+    Args:
+        dataset     : 'synthetic' | 'carla' | 'l2d'
+        data_dir    : cesta k datasetu (pro carla/l2d)
+        steps       : počet BC kroků
+        road_filter : (L2D) 'highway' | 'city' | None → filtruj typ silnice
+        n_files     : (L2D) počet parquet souborů ke stažení (1 = ~1.1M řádků, 57 MB)
+    """
+    rng = np.random.default_rng(42)
+
+    if dataset == "synthetic":
+        log.info("Generuji syntetická řidičská data (15 000 vzorků)...")
+        states, actions = _generate_synthetic_driving_data(n_samples=15000)
+    elif dataset == "carla":
+        log.info("Načítám CARLA Autopilot data z %s ...", data_dir)
+        states, actions = _load_carla_dataset(data_dir)
+    elif dataset == "l2d":
+        log.info("Načítám L2D dataset (yaak-ai/L2D)  road_filter=%r  n_files=%d ...",
+                 road_filter, n_files)
+        states, actions = _load_l2d_dataset(
+            data_dir=data_dir, n_samples=80000,
+            road_filter=road_filter, download=True, n_files=n_files,
+        )
+    else:
+        raise ValueError(f"Neznámý dataset: {dataset}. Použij 'synthetic', 'carla' nebo 'l2d'.")
+
+    N = len(states)
+    log.info("Dataset: %d vzorků  state=%s  action=%s", N, states.shape, actions.shape)
+    log.info("Action range: throttle~[%.2f,%.2f]  steer~[%.2f,%.2f]",
+             actions[:, 0].min(), actions[:, 0].max(),
+             actions[:, 2].min(), actions[:, 2].max())
+
+    cfg   = RLConfig(lr=lr)
+    agent = PhantomAgent(cfg)
+
+    losses = []
+    t0 = time.time()
+    for step in range(steps):
+        idx  = rng.integers(0, N, size=batch_size)
+        loss = agent.head.train_supervised_step(states[idx], actions[idx])
+        losses.append(loss)
+        if (step + 1) % log_every == 0:
+            log.info("BC-driving step %5d/%d  loss=%.4f  (%.1f s)",
+                     step + 1, steps, float(np.mean(losses[-log_every:])), time.time() - t0)
+
+    _save_agent_weights(agent, save_path)
+    log.info("BC-driving hotovo  →  %s  final_loss=%.4f",
+             save_path, float(np.mean(losses[-500:])))
+    return agent
+
+
+# ── CLI ───────────────────────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+    import argparse
+    p = argparse.ArgumentParser()
+    p.add_argument("--dataset", default="synthetic",
+                   choices=["synthetic", "carla", "l2d"])
+    p.add_argument("--data-dir", default="/tmp/l2d_cache")
+    p.add_argument("--steps",   type=int,   default=12000)
+    p.add_argument("--lr",      type=float, default=0.002)
+    p.add_argument("--save",    default="checkpoints/bc_driving.npz")
+    p.add_argument("--log-every", type=int, default=1000)
+    p.add_argument("--road-filter", default=None, choices=["highway", "city", None],
+                   help="L2D: filtruj typ silnice (highway=motorway/trunk, city=residential)")
+    p.add_argument("--n-files", type=int, default=1,
+                   help="L2D: počet parquet souborů ke stažení (1 soubor = ~57 MB, ~1.1M řádků)")
+    args = p.parse_args()
+    run_driving_bc_pretraining(
+        dataset=args.dataset, data_dir=args.data_dir,
+        steps=args.steps, lr=args.lr,
+        save_path=args.save, log_every=args.log_every,
+        road_filter=args.road_filter, n_files=args.n_files,
+    )

embodied/pretrain/bc_ice_driving.py

@@ -0,0 +1,419 @@
+"""
+BC předtrénování pro IceDriving — syntetický expert policy.
+
+Protože žádný WRC výrobce (Subaru/Mitsubishi/Suzuki) ani veřejná komunita
+nezveřejnili telemetrická data ze sněhu/ledu, generujeme expertní demonstrace
+přímo z naší IceDrivingTask fyziky.
+
+Expert policy principy (Scandinavian/rally styl):
+  1. Anticipační brzdění — začíná dřív než na suchém asfaltu (mu×7× delší dráha)
+  2. Plynulé vstupy — na ledu skoky způsobí blokování kol
+  3. Řízený drift (drift_index 0.15–0.55) — Scandinavian flick před zatáčkou
+  4. Regen brzdění — EM motory jako generátory, bez lockup
+  5. Throttle na výjezdu ze zatáčky — AWD trakce ven ze zatáčky
+
+State layout (IceDrivingTask, relevantní části):
+  state[18] = dist_norm (vzdálenost k waypointu / 800)
+  state[19] = ang_err / pi  (−1..+1, negativní = vlevo)
+  state[20] = mu_factor (0.07 black_ice .. 1.0 dry)
+  state[21] = drift_index (0..1)
+  state[22] = speed_norm (speed_kmh / 140)
+  state[23] = regen_kw_norm (0..1)
+  state[24] = prev_steer (−1..+1)
+  state[25] = prev_throttle (0..1)
+  state[26] = slip_ratio_front
+  state[27] = black_ice_nearby (0/1)
+
+Výstup akce (10D):
+  action[0] = throttle - brake  (+1 = plný plyn, −1 = plná regen-brzda)
+  action[2] = steer             (−1 = vlevo, +1 = vpravo)
+"""
+from __future__ import annotations
+
+import logging
+import math
+import os
+import sys
+import time
+from pathlib import Path
+from typing import Tuple
+
+import numpy as np
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..'))
+
+from embodied.rl_loop import RLConfig, PhantomAgent
+from embodied.pretrain.bc_pretrain import _save_agent_weights
+from embodied.goal_encoder import encode_goal, goal_for_task
+from embodied.phantom_cortex import CORTEX_DIM, BODY_DIM
+
+log = logging.getLogger("phantom.bc_ice")
+logging.basicConfig(level=logging.INFO,
+                    format="%(asctime)s  %(levelname)-8s  %(name)s  %(message)s",
+                    datefmt="%H:%M:%S")
+
+
+# ── Expert policy ─────────────────────────────────────────────────────────────
+
+def _expert_action(state: np.ndarray,
+                   rng:   np.random.Generator,
+                   noise: float = 0.04) -> np.ndarray:
+    """
+    Heuristický expert pro jízdu na ledu/sněhu.
+
+    Vstup: 73D state z IceDrivingTask.get_task_state()
+    Výstup: 10D action
+    """
+    dist_norm  = float(state[18])   # 0-1
+    ang_err    = float(state[19])   # -1..+1  (/ pi)
+    mu         = float(state[20])   # 0.07-1.0
+    drift_idx  = float(state[21])   # 0-1
+    speed      = float(state[22])   # 0-1  (/ 140 km/h)
+    prev_steer = float(state[24])
+    prev_thr   = float(state[25])
+    black_ice  = float(state[27])
+
+    # ── Cílová rychlost ──────────────────────────────────────────────────────
+    # Na ledu (mu=0.14) → max cca 45 km/h v zatáčce, 80 na rovince
+    # Na sněhu (mu=0.28) → max cca 70 km/h v zatáčce, 100 na rovince
+    corner_sharpness = min(1.0, abs(ang_err) * 1.8)  # 0 = rovinka, 1 = vlásenka
+    # Základní target normalizovaná rychlost
+    target_straight = min(0.6, mu * 3.2)       # ice: 0.45, snow: 0.90→0.6
+    target_corner   = min(0.35, mu * 2.0)      # ice: 0.28, snow: 0.56→0.35
+    target_speed_norm = target_straight * (1.0 - 0.6 * corner_sharpness) + \
+                        target_corner   *         0.6 * corner_sharpness
+
+    if black_ice > 0.5:
+        target_speed_norm *= 0.55   # ještě opatrněji na černém ledu
+
+    # Anticipační brzdění: začni brzdit výrazně před zatáčkou
+    # dist_norm ~ 0.0 znamená jsme blízko waypointu → zatáčka přichází
+    anticipate = max(0.0, 0.4 - dist_norm) * corner_sharpness
+    target_speed_norm *= max(0.5, 1.0 - anticipate * 2.5)
+
+    # ── Throttle / Regen-brzda ────────────────────────────────────────────────
+    speed_err = target_speed_norm - speed
+
+    if drift_idx > 0.65:
+        # Spin-out riziko → seber plyn, jemně kontr-zatočení
+        thr_brake = min(0.05, speed_err * 0.5)
+    elif speed_err > 0.04:
+        # Potřebujeme zrychlit
+        thr_brake = min(0.85, speed_err * 2.5 + 0.05)
+    elif speed_err < -0.04:
+        # Regen-brzdění (záporná hodnota = EM generátory)
+        # Omez brzdění pokud zároveň zatáčíme (late_brake penalty)
+        brake_limit = 0.7 if abs(ang_err) < 0.2 else 0.4
+        thr_brake = max(-brake_limit, speed_err * 2.8)
+    else:
+        thr_brake = speed_err * 0.8
+
+    # Jemné uvolnění plynu při přiblížení k zatáčce (engine braking)
+    if corner_sharpness > 0.3 and thr_brake > 0.0:
+        thr_brake *= max(0.3, 1.0 - corner_sharpness)
+
+    # ── Řízení ───────────────────────────────────────────────────────────────
+    # Na ledu: KONZERVATIVNÍ gain — malé vstupy, ledová plocha zesiluje efekt
+    steer_gain = 0.45 if mu < 0.20 else 0.60   # ice=0.45, snow=0.60
+    raw_steer = ang_err * steer_gain
+
+    # Spin-out recovery: pokud drift > 0.65, kontr-zatáčení a uvolnění
+    if drift_idx > 0.65:
+        raw_steer = -math.copysign(min(0.15, drift_idx * 0.2), prev_steer)
+
+    # Scandinavian flick: jen při plynulé jízdě (drift nízký, těsná zatáčka)
+    elif (dist_norm > 0.20 and corner_sharpness > 0.55 and drift_idx < 0.08
+            and abs(prev_steer) < 0.15):
+        flick = -math.copysign(0.10, ang_err)   # jemný protisměrný impuls
+        raw_steer += flick
+
+    raw_steer = float(np.clip(raw_steer, -1.0, 1.0))
+
+    # LP filtr na řízení → plynulost vstupů (kritická na ledu)
+    alpha_steer = 0.25   # 25% nový signál, 75% stará hodnota = velmi hladké
+    steer = alpha_steer * raw_steer + (1.0 - alpha_steer) * prev_steer
+
+    # LP filtr na throttle
+    alpha_thr = 0.25
+    thr_brake_smooth = alpha_thr * thr_brake + (1.0 - alpha_thr) * (
+        prev_thr if thr_brake >= 0 else -prev_thr)
+
+    # Výstupní akce
+    action = np.zeros(10, dtype=np.float32)
+    action[0] = float(np.clip(thr_brake_smooth, -1.0, 1.0))
+    action[2] = float(np.clip(steer, -1.0, 1.0))
+
+    # Malý šum pro rozmanitost datasetu
+    if noise > 0:
+        action[0] += float(rng.normal(0, noise * 0.6))
+        action[2] += float(rng.normal(0, noise))
+        action = np.clip(action, -1.0, 1.0)
+
+    return action.astype(np.float32)
+
+
+# ── Generátor syntetických demonstrací ────────────────────────────────────────
+
+# Trasa _ICE_TRACK − normalizovaná pro přímé generování stavů
+_TRACK_WAYPOINTS = [
+    (400,   0),   # T1 brzdění
+    (600, 200),   # T2 vlásenka
+    (600, 500),   # T3 rychlá
+    (400, 700),   # T4 chicane a
+    (200, 700),   # T4 chicane b
+    (  0, 500),   # T5 dlouhá
+    (-200, 200),  # T6 kink
+    (  0,   0),   # cíl
+]
+
+# Úhly mezi waypoints − typ zatáčky pro scénáře
+def _corner_angle(i: int) -> float:
+    if i == 0 or i >= len(_TRACK_WAYPOINTS) - 1:
+        return 0.0
+    ax, az = _TRACK_WAYPOINTS[i - 1]
+    bx, bz = _TRACK_WAYPOINTS[i]
+    cx, cz = _TRACK_WAYPOINTS[i + 1]
+    v1 = (bx - ax, bz - az)
+    v2 = (cx - bx, cz - bz)
+    n1 = math.sqrt(v1[0]**2 + v1[1]**2)
+    n2 = math.sqrt(v2[0]**2 + v2[1]**2)
+    if n1 == 0 or n2 == 0:
+        return 0.0
+    cos_a = (v1[0]*v2[0] + v1[1]*v2[1]) / (n1 * n2)
+    return math.acos(max(-1.0, min(1.0, cos_a)))   # 0 = rovinka, pi = vlásenka
+
+
+def generate_ice_expert_data(
+        n_samples:  int   = 40000,
+        surface:    str   = "all",   # "ice" | "snow" | "black_ice" | "all"
+        seed:       int   = 42,
+        noise:      float = 0.04,
+) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Generuje syntetické BC demonstrace pro IceDrivingTask.
+
+    Místo spouštění plné fyziky simulujeme různé stavy jízdní situace
+    (rychlost, úhel zatáčky, drift_index, mu_factor) a aplikujeme expert policy.
+    Výsledek: dataset (state, expert_action) pro BC trénink.
+    """
+    rng = np.random.default_rng(seed)
+    log.info("Generuji expert demonstrace: n=%d  surface=%s  noise=%.3f",
+             n_samples, surface, noise)
+
+    # Mu faktory pro různé povrchy
+    surface_mus = {
+        "ice":       (0.10, 0.18),   # ledová dráha  (WRC Szwecja)
+        "snow":      (0.22, 0.34),   # utlačený sníh (Rallye Monte Carlo)
+        "black_ice": (0.05, 0.09),   # černý led (zákeřný)
+        "mixed":     (0.10, 0.32),   # střídání povrchů
+    }
+
+    if surface == "all":
+        surf_choices = ["ice", "snow", "black_ice", "mixed"]
+        surf_weights = [0.30, 0.35, 0.15, 0.20]
+    else:
+        surf_choices = [surface]
+        surf_weights = [1.0]
+
+    # Pre-compute goal vector for ice task
+    goal_vec = encode_goal(goal_for_task("drive_city"))  # fallback goal
+
+    states  = np.zeros((n_samples, CORTEX_DIM), dtype=np.float32)
+    actions = np.zeros((n_samples, 10),         dtype=np.float32)
+
+    # Koutové úhly pro každý waypoint
+    corner_angles = [_corner_angle(i) for i in range(len(_TRACK_WAYPOINTS))]
+    max_corner = max(corner_angles) if corner_angles else 1.0
+
+    for i in range(n_samples):
+        # ── Výběr povrchu ─────────────────────────────────────────────────────
+        surf = rng.choice(surf_choices, p=surf_weights)
+        mu_lo, mu_hi = surface_mus[surf]
+        mu = float(rng.uniform(mu_lo, mu_hi))
+
+        # ── Náhodná pozice na trase ───────────────────���────────────────────────
+        wp_idx = int(rng.integers(0, len(_TRACK_WAYPOINTS)))
+        corner_ang = corner_angles[wp_idx]   # 0=rovinka, ~pi/2=těsná
+
+        # Vzdálenost k waypointu (blíže = zatáčka se blíží)
+        dist_to_wp = float(rng.uniform(0, 800))
+        dist_norm  = float(np.clip(dist_to_wp / 800.0, 0.0, 1.0))
+
+        # Úhel k waypointu (ang_err / pi)
+        # Na rovince: malý ang_err; v zatáčce: 0.2–0.8
+        ang_amplitude = corner_ang / math.pi * 0.9
+        ang_err_raw   = float(rng.uniform(-ang_amplitude, ang_amplitude))
+        # Blíže k waypointu → menší ang_err (agent se srovnává)
+        ang_err = ang_err_raw * max(0.2, dist_norm)
+
+        # ── Rychlost ──────────────────────────────────────────────────────────
+        # Vzorkujeme realistický rozsah pro daný mu a zatáčku
+        max_speed_kmh = mu * 280.0 * (1.0 - 0.6 * corner_ang / math.pi)
+        max_speed_kmh = float(np.clip(max_speed_kmh, 5.0, 120.0))
+        speed_kmh   = float(rng.uniform(5.0, max_speed_kmh))
+        speed_norm  = float(np.clip(speed_kmh / 140.0, 0.0, 1.0))
+
+        # ── Drift index ───────────────────────────────────────────────────────
+        # 20% scénářů: spin-out recovery (drift > 0.65) — agent musí vědět jak z toho ven
+        if rng.random() < 0.20:
+            drift_idx = float(rng.uniform(0.65, 0.95))
+        else:
+            drift_base = speed_norm * corner_ang / math.pi * (1.0 - mu)
+            drift_idx  = float(np.clip(
+                rng.normal(drift_base * 0.8, 0.08), 0.0, 0.60))
+
+        # ── Předchozí vstupy (LP filter paměť) ───────────────────────────────
+        prev_steer = float(rng.uniform(-ang_amplitude * 0.5, ang_amplitude * 0.5))
+        prev_thr   = float(rng.uniform(0.1, 0.7) * (1.0 - corner_ang / math.pi * 0.6))
+
+        # ── Regen kW (přibližně) ──────────────────────────────────────────────
+        regen_norm = float(np.clip(rng.uniform(0, 0.4), 0.0, 1.0))
+
+        # ── Slip ratio ────────────────────────────────────────────────────────
+        slip = float(np.clip(drift_idx * 2.0, 0.0, 1.0))
+
+        # ── Černý led v okolí ─────────────────────────────────────────────────
+        black_ice = 1.0 if (surf == "black_ice" and rng.random() < 0.6) else 0.0
+
+        # ── Sestavení state vektoru ───────────────────────────────────────────
+        s = np.zeros(CORTEX_DIM, dtype=np.float32)
+
+        # state[0:18] = telemetrie (zjednodušená simulace)
+        s[0]  = speed_norm
+        s[1]  = float(rng.uniform(0.0, 0.5))   # lateral_accel (mock)
+        s[2]  = prev_steer                       # steer
+        s[3]  = prev_thr                         # throttle
+        s[4]  = float(rng.uniform(0.5, 1.0))    # battery_soc
+        s[5]  = float(rng.uniform(0.3, 0.8))    # supercap_soc
+        s[6]  = regen_norm * 50.0 / 100.0       # regen_kw norm
+        s[7]  = float(rng.uniform(-5, 5))        # yaw mock
+        s[8]  = drift_idx                        # drift_index
+        s[9]  = float(rng.uniform(0.0, 0.3))    # nose lift (mock)
+        s[10] = mu                               # tire_temp_fl proxy
+        s[11] = mu                               # tire_temp_fr proxy
+        s[12] = mu * 0.95                        # tire_temp_rl
+        s[13] = mu * 0.95                        # tire_temp_rr
+        s[14] = float(rng.uniform(-0.2, 0.2))   # gyro_x
+        s[15] = float(rng.uniform(-0.1, 0.1))   # gyro_z
+        s[16] = float(rng.uniform(0.3, 0.7))    # height
+
+        # state[18..27] = IceDrivingTask specifické
+        s[18] = dist_norm
+        s[19] = ang_err
+        s[20] = mu
+        s[21] = drift_idx
+        s[22] = speed_norm
+        s[23] = regen_norm
+        s[24] = prev_steer
+        s[25] = prev_thr
+        s[26] = slip
+        s[27] = black_ice
+
+        # Goal vector (mem + goal pásmo)
+        s[BODY_DIM + 8: BODY_DIM + 8 + 32] = goal_vec
+
+        # ── Expert akce ───────────────────────────────────────────────────────
+        a = _expert_action(s, rng, noise=noise)
+
+        states[i]  = s
+        actions[i] = a
+
+    # Shuffle
+    idx = rng.permutation(n_samples)
+    states  = states[idx]
+    actions = actions[idx]
+
+    log.info("Vygenerováno %d expert demonstrací  "
+             "thr_range=[%.2f, %.2f]  steer_range=[%.2f, %.2f]",
+             n_samples,
+             actions[:, 0].min(), actions[:, 0].max(),
+             actions[:, 2].min(), actions[:, 2].max())
+    return states, actions
+
+
+# ── BC trénink ────────────────────────────────────────────────────────────────
+
+def run_ice_bc_pretraining(
+    surface:    str   = "all",
+    n_samples:  int   = 40000,
+    steps:      int   = 15000,
+    batch_size: int   = 64,
+    lr:         float = 0.002,
+    save_path:  str   = "checkpoints/bc_ice.npz",
+    log_every:  int   = 1000,
+    noise:      float = 0.04,
+    seed:       int   = 42,
+) -> PhantomAgent:
+    """
+    BC předtrénování pro IceDriving — syntetický expert.
+
+    Agent se naučí:
+      - Anticipační brzdění (dřív než na suchu)
+      - Plynulé vstupy (LP filter)
+      - Scandinavian flick (protisteer před vlásenkou)
+      - Regen-brzdění místo kotouče
+
+    Args:
+        surface   : 'ice' | 'snow' | 'black_ice' | 'all' (mix)
+        n_samples : počet syntetických demonstrací
+        steps     : počet BC tréninkových kroků
+        noise     : šum na expert akcích pro rozmanitost
+        save_path : cesta pro uložení vah
+
+    Returns:
+        PhantomAgent s předtrénovanými vahami pro IceDriving
+    """
+    t0 = time.time()
+
+    states, actions = generate_ice_expert_data(
+        n_samples=n_samples, surface=surface, seed=seed, noise=noise)
+
+    N = len(states)
+    log.info("Dataset: %d  state=%s  action=%s", N, states.shape, actions.shape)
+
+    rng   = np.random.default_rng(seed)
+    cfg   = RLConfig(lr=lr)
+    agent = PhantomAgent(cfg)
+
+    losses = []
+    for step in range(steps):
+        idx  = rng.integers(0, N, size=batch_size)
+        loss = agent.head.train_supervised_step(states[idx], actions[idx])
+        losses.append(float(loss))
+
+        if (step + 1) % log_every == 0:
+            avg = float(np.mean(losses[-log_every:]))
+            log.info("BC-ice step %5d/%d  loss=%.4f  (%.1fs)",
+                     step + 1, steps, avg, time.time() - t0)
+
+    _save_agent_weights(agent, save_path)
+    final_loss = float(np.mean(losses[-500:]))
+    log.info("BC-ice hotovo  →  %s  final_loss=%.4f  (%.1fs)",
+             save_path, final_loss, time.time() - t0)
+    return agent
+
+
+# ── CLI ───────────────────────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+    import argparse
+    p = argparse.ArgumentParser(description="BC předtrénování pro IceDriving — syntetický expert")
+    p.add_argument("--surface",    default="all",
+                   choices=["ice", "snow", "black_ice", "all"],
+                   help="Povrch: 'ice' | 'snow' | 'black_ice' | 'all' (mix vše)")
+    p.add_argument("--n-samples",  type=int, default=40000,
+                   help="Počet syntetických demonstrací (default: 40000)")
+    p.add_argument("--steps",      type=int, default=15000,
+                   help="Počet BC tréninkových kroků (default: 15000)")
+    p.add_argument("--lr",         type=float, default=0.002)
+    p.add_argument("--noise",      type=float, default=0.04,
+                   help="Šum na expert akcích (default: 0.04 = 4%)")
+    p.add_argument("--save",       default="checkpoints/bc_ice.npz")
+    p.add_argument("--log-every",  type=int, default=1000)
+    p.add_argument("--seed",       type=int, default=42)
+    args = p.parse_args()
+    run_ice_bc_pretraining(
+        surface=args.surface, n_samples=args.n_samples,
+        steps=args.steps, lr=args.lr, noise=args.noise,
+        save_path=args.save, log_every=args.log_every, seed=args.seed,
+    )

embodied/pretrain/bc_pretrain.py

@@ -0,0 +1,253 @@
+"""
+BCPretrainer — Behaviour Cloning předtrénování agenta z MoCap + manipulačních dat.
+
+Pipeline:
+  1. Načtení LAFAN-G1 (lokomoce: chůze, běh)      → stavy + akce pro tělo
+  2. Načtení LIBERO-3D (manipulace: pick, place)   → stavy + akce pro ruce
+  3. Sloučení a zamíchání datasetu
+  4. BC trénink: MotorActionHead.train_supervised_step()
+     - MSE loss: predikovaná_akce vs. demonstrovaná_akce
+     - čistě numpy, žádný PyTorch
+  5. Uložení předtrénovaných vah do checkpoints/bc_pretrained.npz
+
+Výsledek:
+  Agent začíná RL trénink s:
+    - Pochopením základní kinematiky chůze (LAFAN)
+    - Základním vzorcem manipulace — přiblížení ruky, uchopení, přenos (LIBERO)
+  → Výrazně rychlejší konvergence household_pick, household_stack, sweep.
+"""
+from __future__ import annotations
+
+import logging
+import os
+import sys
+import time
+from pathlib import Path
+from typing import Tuple, Optional
+
+import numpy as np
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..'))
+
+from cogcore.cognition.motor import MotorActionHead, MotorActionConfig
+from embodied.rl_loop import RLConfig, PhantomAgent
+from embodied.pretrain.motion_dataset import (
+    load_lafan, load_libero, load_basketball_bvh, merge_datasets, dataset_stats
+)
+
+log = logging.getLogger("phantom.pretrain")
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s  %(levelname)-8s  %(name)s  %(message)s",
+    datefmt="%H:%M:%S",
+)
+
+CKPT_DIR = Path("checkpoints")
+CKPT_DIR.mkdir(exist_ok=True)
+
+
+# ── BC trénink ────────────────────────────────────────────────────────────────
+
+def run_bc_pretraining(
+    lafan_dir:    str   = "/tmp/lafan_walk",
+    libero_dir:   str   = "/tmp/libero_pick",
+    steps:        int   = 8000,
+    batch_size:   int   = 64,
+    lr:           float = 0.002,
+    save_path:    str   = "checkpoints/bc_pretrained.npz",
+    log_every:    int   = 500,
+) -> PhantomAgent:
+    """
+    Spustí BC předtrénování a vrátí natrénovaného agenta.
+
+    Args:
+        lafan_dir : cesta ke složce s LAFAN .npz soubory
+        libero_dir: cesta ke složce s LIBERO epizodami (rekurzivně)
+        steps     : počet BC tréninkových kroků
+        batch_size: velikost dávky
+        lr        : learning rate (vyšší než RL — BC konverguje rychle)
+        save_path : kam uložit váhy
+        log_every : interval logování
+    Returns:
+        PhantomAgent s předtrénovanými vahami
+    """
+    rng = np.random.default_rng(42)
+
+    # ── Načtení dat ──────────────────────────────────────────────────────────
+    datasets = []
+
+    log.info("Načítám LAFAN-G1 lokomoční data z %s ...", lafan_dir)
+    try:
+        s_laf, a_laf = load_lafan(lafan_dir, task_name="walk", max_files=10, subsample=3)
+        dataset_stats(s_laf, a_laf, "LAFAN-walk")
+        datasets.append((s_laf, a_laf))
+        log.info("LAFAN: %d vzorků lokomoce", len(s_laf))
+    except Exception as e:
+        log.warning("LAFAN nenačten: %s", e)
+
+    log.info("Načítám LIBERO-3D manipulační demonstrace z %s ...", libero_dir)
+    try:
+        s_lib, a_lib = load_libero(libero_dir, task_name="household_pick", max_episodes=30)
+        dataset_stats(s_lib, a_lib, "LIBERO-pick")
+        datasets.append((s_lib, a_lib))
+        log.info("LIBERO: %d vzorků manipulace", len(s_lib))
+    except Exception as e:
+        log.warning("LIBERO nenačten: %s", e)
+
+    if not datasets:
+        raise RuntimeError("Nepodařilo se načíst žádná data pro BC předtrénování.")
+
+    states, actions = merge_datasets(*datasets, shuffle=True, seed=42)
+    N = len(states)
+    log.info("Celkem %d vzorků (lokomoce + manipulace) → BC trénink %d kroků", N, steps)
+
+    # ── Inicializace agenta ──────────────────────────────────────────────────
+    cfg = RLConfig(lr=lr)
+    agent = PhantomAgent(cfg)
+
+    # ── BC smyčka ────────────────────────────────────────────────────────────
+    losses = []
+    t0 = time.time()
+
+    for step in range(steps):
+        idx = rng.integers(0, N, size=batch_size)
+        batch_s = states[idx]
+        batch_a = actions[idx]
+
+        loss = agent.head.train_supervised_step(batch_s, batch_a)
+        losses.append(loss)
+
+        if (step + 1) % log_every == 0:
+            recent_loss = float(np.mean(losses[-log_every:]))
+            elapsed = time.time() - t0
+            log.info(
+                "BC step %5d/%d  loss=%.4f  (%.1f s)",
+                step + 1, steps, recent_loss, elapsed,
+            )
+
+    # ── Uložení vah ──────────────────────────────────────────────────────────
+    _save_agent_weights(agent, save_path)
+    log.info("BC předtrénování hotovo. Váhy uloženy: %s", save_path)
+    log.info("Průměrná finální loss (posledních 500): %.4f", float(np.mean(losses[-500:])))
+
+    return agent
+
+
+def _save_agent_weights(agent: PhantomAgent, path: str) -> None:
+    """Uloží váhy MotorActionHead do .npz — kompatibilní s rl_loop checkpointem."""
+    np.savez(
+        path,
+        W1=agent.head.W1,
+        b1=agent.head.b1,
+        W_action=agent.head.W_action,
+        b_action=agent.head.b_action,
+        W_disc=agent.head.W_disc,
+        b_disc=agent.head.b_disc,
+    )
+
+
+def load_bc_weights_into_agent(agent: PhantomAgent, path: str) -> None:
+    """
+    Načte BC předtrénované váhy do existujícího agenta.
+    Volat před spuštěním RL tréninku.
+    """
+    if not os.path.exists(path):
+        log.warning("BC váhy nenalezeny: %s — přeskakuji", path)
+        return
+    d = np.load(path)
+    agent.head.W1       = d["W1"].astype(np.float32)
+    agent.head.b1       = d["b1"].astype(np.float32)
+    agent.head.W_action = d["W_action"].astype(np.float32)
+    agent.head.b_action = d["b_action"].astype(np.float32)
+    agent.head.W_disc   = d["W_disc"].astype(np.float32)
+    agent.head.b_disc   = d["b_disc"].astype(np.float32)
+    log.info("BC předtrénované váhy načteny z %s", path)
+
+
+def run_basketball_bc_pretraining(
+    basketball_dir: str   = "/tmp/basketball_mocap",
+    steps:          int   = 10000,
+    batch_size:     int   = 64,
+    lr:             float = 0.002,
+    save_path:      str   = "checkpoints/bc_basketball.npz",
+    log_every:      int   = 500,
+    subsample:      int   = 6,
+) -> PhantomAgent:
+    """
+    BC předtrénování z CMU MoCap basketbalových BVH sekvencí.
+
+    Naučí agenta základní basketbalové pohyby:
+      - dribbling (pravá ruka dolů/nahoru, rytmický pohyb)
+      - shooting (výmah paže, zápěstí snap)
+      - layup (kombinace pohybu + střelby)
+
+    Args:
+        basketball_dir : složka s CMU MoCap .bvh soubory (subject 49 + 140)
+        steps          : počet BC kroků
+        save_path      : kde uložit váhy
+        subsample      : podvzorkování 120fps → 20fps (subsample=6)
+    """
+    rng = np.random.default_rng(42)
+
+    log.info("Načítám CMU MoCap basketbalová data z %s ...", basketball_dir)
+    s_bball, a_bball = load_basketball_bvh(
+        basketball_dir, task_name="dribble", subsample=subsample
+    )
+    dataset_stats(s_bball, a_bball, "CMU-basketball")
+    log.info("Basketball BVH: %d vzorků z %s", len(s_bball), basketball_dir)
+
+    # Přidáme i lokomoční data (basketbal = pohyb + ruce)
+    datasets: list = [(s_bball, a_bball)]
+    try:
+        s_laf, a_laf = load_lafan("/tmp/lafan_walk", task_name="walk", max_files=5, subsample=3)
+        datasets.append((s_laf, a_laf))
+        log.info("LAFAN lokomoce přidána: %d vzorků", len(s_laf))
+    except Exception:
+        pass
+
+    states, actions = merge_datasets(*datasets, shuffle=True, seed=42)
+    N = len(states)
+    log.info("Celkem %d vzorků → BC trénink %d kroků", N, steps)
+
+    cfg   = RLConfig(lr=lr)
+    agent = PhantomAgent(cfg)
+
+    losses = []
+    t0 = time.time()
+    for step in range(steps):
+        idx     = rng.integers(0, N, size=batch_size)
+        loss    = agent.head.train_supervised_step(states[idx], actions[idx])
+        losses.append(loss)
+        if (step + 1) % log_every == 0:
+            log.info("BC-basketball step %5d/%d  loss=%.4f  (%.1f s)",
+                     step + 1, steps, float(np.mean(losses[-log_every:])), time.time() - t0)
+
+    _save_agent_weights(agent, save_path)
+    log.info("BC-basketball hotovo. Váhy: %s  final_loss=%.4f", save_path,
+             float(np.mean(losses[-500:])))
+    return agent
+
+
+# ── Standalone spuštění ───────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser(description="BC předtrénování z LAFAN + LIBERO")
+    parser.add_argument("--lafan",   default="/tmp/lafan_walk",  help="Složka s LAFAN .npz")
+    parser.add_argument("--libero",  default="/tmp/libero_pick", help="Složka s LIBERO epizodami")
+    parser.add_argument("--steps",   type=int,   default=8000,   help="Počet BC kroků")
+    parser.add_argument("--batch",   type=int,   default=64,     help="Velikost dávky")
+    parser.add_argument("--lr",      type=float, default=0.002,  help="Learning rate")
+    parser.add_argument("--save",    default="checkpoints/bc_pretrained.npz")
+    parser.add_argument("--log-every", type=int, default=500)
+    args = parser.parse_args()
+
+    run_bc_pretraining(
+        lafan_dir=args.lafan,
+        libero_dir=args.libero,
+        steps=args.steps,
+        batch_size=args.batch,
+        lr=args.lr,
+        save_path=args.save,
+        log_every=args.log_every,
+    )

embodied/pretrain/motion_dataset.py

@@ -0,0 +1,346 @@
+"""
+MotionDataset — načítač MoCap a manipulačních demonstrací pro BC pre-training.
+
+Zdroje:
+  LAFAN-G1  (ember-lab-berkeley/LAFAN-G1)  — lokomoce: chůze, běh, pád+vstávání
+  LIBERO-3D (Ayana666888/LIBERO-3D)         — manipulace: pick, place, open drawer
+
+Mapování do agentova prostoru (73D stav, 10D akce):
+──────────────────────────────────────────────────
+LAFAN → stav:
+  dof_positions[0:28] → body_state[0:28]   (28 ze 29 kloubů G1 humanoid)
+  mem[0:8]  = 0  (paměť se inicializuje za běhu)
+  goal[0:32] = goal_for_task("walk")
+  bio[0:5]  = 0
+
+LAFAN → akce (Δ kloubní pozice → 10D):
+  akce[0] = mean(Δhip_pitch_L, Δhip_pitch_R)   ← dopředný pohyb
+  akce[1] = mean(Δhip_roll_L, Δhip_roll_R)     ← laterální vychýlení
+  akce[2] = Δwaist_yaw                          ← rotace trupu
+  akce[3] = Δleft_shoulder_pitch                ← levé rameno
+  akce[4] = Δleft_elbow                         ← levý loket
+  akce[5] = Δleft_wrist_pitch                   ← levé zápěstí
+  akce[6] = Δright_shoulder_pitch               ← pravé rameno
+  akce[7] = Δright_elbow                        ← pravý loket
+  akce[8] = Δright_wrist_pitch                  ← pravé zápěstí
+  akce[9] = 0                                   ← gripper (LAFAN nemá)
+
+LIBERO → stav:
+  state[0:8] → body_state[0:8]   (end-effector + gripper jako proxy kloubů)
+  goal[0:32] = goal_for_task("household_pick")
+
+LIBERO → akce (7D → 10D):
+  akce[0:3] = 0                        ← základ stojí
+  akce[3:6] = libero_action[0:3]       ← translace → pohyb levé paže
+  akce[6:9] = libero_action[3:6]       ← rotace → orientace pravé paže
+  akce[9]   = libero_action[6]         ← gripper (1D)
+"""
+from __future__ import annotations
+
+import os
+import glob
+import numpy as np
+from pathlib import Path
+from typing import List, Tuple, Optional
+
+from embodied.goal_encoder import encode_goal, goal_for_task, GOAL_DIM
+from embodied.phantom_cortex import CORTEX_DIM, BODY_DIM
+
+# ── LAFAN kloubní indexy (z dof_names G1 humanoid) ──────────────────────────
+_L = {
+    "hip_pitch_L":      0, "hip_roll_L":  1, "hip_yaw_L":   2,
+    "knee_L":           3, "ankle_pitch_L": 4, "ankle_roll_L": 5,
+    "hip_pitch_R":      6, "hip_roll_R":  7, "hip_yaw_R":   8,
+    "knee_R":           9, "ankle_pitch_R": 10, "ankle_roll_R": 11,
+    "waist_yaw":        12, "waist_roll": 13, "waist_pitch": 14,
+    "shoulder_pitch_L": 15, "shoulder_roll_L": 16, "shoulder_yaw_L": 17,
+    "elbow_L":          18, "wrist_roll_L":    19, "wrist_pitch_L":  20, "wrist_yaw_L": 21,
+    "shoulder_pitch_R": 22, "shoulder_roll_R": 23, "shoulder_yaw_R": 24,
+    "elbow_R":          25, "wrist_roll_R":    26, "wrist_pitch_R":  27, "wrist_yaw_R": 28,
+}
+
+_ACTION_SCALE = 5.0   # Δklouby jsou malé → škáluj na [-1, 1] range
+
+
+def _lafan_to_state(dof_pos: np.ndarray, task_name: str = "walk") -> np.ndarray:
+    """29D dof_positions → 73D agent stav."""
+    state = np.zeros(CORTEX_DIM, dtype=np.float32)
+    state[0:28] = dof_pos[0:28]
+    goal_vec = encode_goal(goal_for_task(task_name))
+    state[BODY_DIM + 8: BODY_DIM + 8 + GOAL_DIM] = goal_vec
+    return state
+
+
+def _lafan_delta_to_action(delta: np.ndarray) -> np.ndarray:
+    """Δ29D dof → 10D agent akce."""
+    a = np.zeros(10, dtype=np.float32)
+    a[0] = (delta[_L["hip_pitch_L"]] + delta[_L["hip_pitch_R"]]) * 0.5 * _ACTION_SCALE
+    a[1] = (delta[_L["hip_roll_L"]]  + delta[_L["hip_roll_R"]])  * 0.5 * _ACTION_SCALE
+    a[2] = delta[_L["waist_yaw"]] * _ACTION_SCALE
+    a[3] = delta[_L["shoulder_pitch_L"]] * _ACTION_SCALE
+    a[4] = delta[_L["elbow_L"]]          * _ACTION_SCALE
+    a[5] = delta[_L["wrist_pitch_L"]]    * _ACTION_SCALE
+    a[6] = delta[_L["shoulder_pitch_R"]] * _ACTION_SCALE
+    a[7] = delta[_L["elbow_R"]]          * _ACTION_SCALE
+    a[8] = delta[_L["wrist_pitch_R"]]    * _ACTION_SCALE
+    a[9] = 0.0
+    return np.clip(a, -1.0, 1.0)
+
+
+def _libero_to_state(robot_state: np.ndarray, task_name: str = "household_pick") -> np.ndarray:
+    """8D LIBERO end-effector stav → 73D agent stav."""
+    state = np.zeros(CORTEX_DIM, dtype=np.float32)
+    n = min(len(robot_state), 8)
+    state[0:n] = robot_state[:n]
+    goal_vec = encode_goal(goal_for_task(task_name))
+    state[BODY_DIM + 8: BODY_DIM + 8 + GOAL_DIM] = goal_vec
+    return state
+
+
+def _libero_action_to_agent(libero_action: np.ndarray) -> np.ndarray:
+    """7D LIBERO akce → 10D agent akce."""
+    a = np.zeros(10, dtype=np.float32)
+    a[0:3] = 0.0
+    a[3:6] = libero_action[0:3]
+    a[6:9] = libero_action[3:6]
+    a[9]   = libero_action[6]
+    return np.clip(a, -1.0, 1.0)
+
+
+# ── Loadery ──────────────────────────────────────────────────────���───────────
+
+def load_lafan(data_dir: str, task_name: str = "walk",
+               max_files: int = 20, subsample: int = 3) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Načte LAFAN-G1 .npz soubory → (states, actions).
+    subsample: bere každý N-tý snímek (30fps → 10fps při subsample=3).
+    """
+    files = glob.glob(os.path.join(data_dir, "*.npz"))
+    if not files:
+        raise FileNotFoundError(f"Žádné .npz soubory v {data_dir}")
+    files = sorted(files)[:max_files]
+
+    all_states, all_actions = [], []
+    for fpath in files:
+        d = np.load(fpath)
+        pos = d["dof_positions"][::subsample]   # shape (T, 29)
+        if len(pos) < 2:
+            continue
+        deltas = np.diff(pos, axis=0)           # shape (T-1, 29)
+        for i in range(len(deltas)):
+            s = _lafan_to_state(pos[i], task_name)
+            a = _lafan_delta_to_action(deltas[i])
+            all_states.append(s)
+            all_actions.append(a)
+
+    return np.array(all_states, dtype=np.float32), np.array(all_actions, dtype=np.float32)
+
+
+def load_libero(data_dir: str, task_name: str = "household_pick",
+                max_episodes: int = 50) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Načte LIBERO-3D .npz epizody → (states, actions).
+    Rekurzivně prohledá data_dir pro všechna data.npz.
+    """
+    files = sorted(glob.glob(os.path.join(data_dir, "**", "data.npz"), recursive=True))
+    if not files:
+        raise FileNotFoundError(f"Žádné data.npz v {data_dir}")
+    files = files[:max_episodes]
+
+    all_states, all_actions = [], []
+    for fpath in files:
+        d = np.load(fpath, allow_pickle=True)
+        states  = d["state"]    # (T, 8)
+        actions = d["actions"]  # (T, 7)
+        T = min(len(states), len(actions))
+        for t in range(T):
+            s = _libero_to_state(states[t], task_name)
+            a = _libero_action_to_agent(actions[t])
+            all_states.append(s)
+            all_actions.append(a)
+
+    return np.array(all_states, dtype=np.float32), np.array(all_actions, dtype=np.float32)
+
+
+def merge_datasets(*datasets: Tuple[np.ndarray, np.ndarray],
+                   shuffle: bool = True, seed: int = 42) -> Tuple[np.ndarray, np.ndarray]:
+    """Sloučí více (states, actions) dvojic dohromady."""
+    all_s = np.concatenate([d[0] for d in datasets], axis=0)
+    all_a = np.concatenate([d[1] for d in datasets], axis=0)
+    if shuffle:
+        rng = np.random.default_rng(seed)
+        idx = rng.permutation(len(all_s))
+        all_s, all_a = all_s[idx], all_a[idx]
+    return all_s, all_a
+
+
+def dataset_stats(states: np.ndarray, actions: np.ndarray, name: str = "") -> None:
+    print(f"[Dataset{' ' + name if name else ''}]")
+    print(f"  Vzorků   : {len(states):,}")
+    print(f"  State    : {states.shape}  range=[{states.min():.3f}, {states.max():.3f}]")
+    print(f"  Action   : {actions.shape}  range=[{actions.min():.3f}, {actions.max():.3f}]")
+    print(f"  Act mean : {actions.mean(0).round(3)}")
+    print(f"  Act std  : {actions.std(0).round(3)}")
+
+
+# ── CMU MoCap BVH parser (basketbalové sekvence) ─────────────────────────────
+#
+# CMU skeleton (subject 49, 140) — channel layout (96 ch / frame):
+#   Root/Hips        ch 0-5   : Xpos, Ypos, Zpos, Zrot, Yrot, Xrot
+#   LHipJoint        ch 6-8   : Zrot, Yrot, Xrot
+#   LeftUpLeg        ch 9-11
+#   LeftLeg          ch 12-14
+#   LeftFoot         ch 15-17
+#   LeftToeBase      ch 18-20
+#   RHipJoint        ch 21-23
+#   RightUpLeg       ch 24-26
+#   RightLeg         ch 27-29
+#   RightFoot        ch 30-32
+#   RightToeBase     ch 33-35
+#   LowerBack        ch 36-38
+#   Spine            ch 39-41
+#   Spine1           ch 42-44
+#   Neck/Neck1/Head  ch 45-53
+#   LeftShoulder     ch 54-56
+#   LeftArm          ch 57-59  ← shoulder pitch (Xrot = ch 59)
+#   LeftForeArm      ch 60-62  ← elbow (Zrot = ch 60)
+#   LeftHand         ch 63-65  ← wrist (Xrot = ch 65)
+#   LeftFinger/LThumb ch 66-74
+#   RightShoulder    ch 75-77
+#   RightArm         ch 78-80  ← shoulder pitch (Xrot = ch 80)
+#   RightForeArm     ch 81-83  ← elbow (Zrot = ch 81)
+#   RightHand        ch 84-86  ← wrist (Xrot = ch 86)
+#   RightFinger/RThumb ch 87-95
+
+_CMU_TOTAL_CH = 96
+_CMU_DEG2RAD  = np.pi / 180.0
+
+# Mapování CMU channels → agent 10D actions
+#   [0] hip forward  = mean(LeftUpLeg Xrot, RightUpLeg Xrot)
+#   [1] hip lateral  = mean(LeftUpLeg Zrot, RightUpLeg Zrot)
+#   [2] waist yaw    = LowerBack Yrot
+#   [3] L shoulder   = LeftArm Xrot
+#   [4] L elbow      = LeftForeArm Zrot
+#   [5] L wrist      = LeftHand Xrot
+#   [6] R shoulder   = RightArm Xrot
+#   [7] R elbow      = RightForeArm Zrot
+#   [8] R wrist      = RightHand Xrot
+#   [9] gripper      = derived: RightHand downward velocity (dribble push)
+_CMU_CH = {
+    "lup_xrot":  11, "lup_zrot":  9,
+    "rup_xrot":  26, "rup_zrot":  24,
+    "lback_yrot": 37,
+    "larm_xrot": 59,
+    "lfore_zrot": 60,
+    "lhand_xrot": 65,
+    "rarm_xrot": 80,
+    "rfore_zrot": 81,
+    "rhand_xrot": 86,
+    "root_ypos":  1,      # výška boků (pro dribble detekci)
+    "rhand_yrot": 85,     # wrist Y = dribble záp
+}
+
+_CMU_ACTION_SCALE = 0.012   # degrees → [-1,1]: 80° full range → ~1.0
+
+
+def _parse_bvh_frames(filepath: str) -> Optional[np.ndarray]:
+    """Parsuje BVH soubor → pole snímků (T, 96)."""
+    frames_data = []
+    in_motion   = False
+    n_frames    = 0
+    with open(filepath, "r") as f:
+        for line in f:
+            line = line.strip()
+            if line == "MOTION":
+                in_motion = True
+                continue
+            if not in_motion:
+                continue
+            if line.startswith("Frames:"):
+                n_frames = int(line.split(":")[1].strip())
+                continue
+            if line.startswith("Frame Time:"):
+                continue
+            vals = [float(x) for x in line.split()]
+            if len(vals) == _CMU_TOTAL_CH:
+                frames_data.append(vals)
+    if not frames_data:
+        return None
+    arr = np.array(frames_data, dtype=np.float32)
+    return arr[:n_frames] if n_frames > 0 else arr
+
+
+def _cmu_frame_to_state(frame: np.ndarray, task_name: str = "dribble") -> np.ndarray:
+    """96D CMU frame → 73D agent stav."""
+    state = np.zeros(CORTEX_DIM, dtype=np.float32)
+    # Klouby horní končetiny → body_state[15:28] (shoulder, elbow, wrist obě strany)
+    state[15] = frame[_CMU_CH["larm_xrot"]]  * _CMU_DEG2RAD
+    state[16] = frame[_CMU_CH["lfore_zrot"]] * _CMU_DEG2RAD
+    state[17] = frame[_CMU_CH["lhand_xrot"]] * _CMU_DEG2RAD
+    state[18] = frame[_CMU_CH["rarm_xrot"]]  * _CMU_DEG2RAD
+    state[19] = frame[_CMU_CH["rfore_zrot"]] * _CMU_DEG2RAD
+    state[20] = frame[_CMU_CH["rhand_xrot"]] * _CMU_DEG2RAD
+    # Nohy → body_state[0:6]
+    state[0]  = frame[_CMU_CH["lup_xrot"]]  * _CMU_DEG2RAD
+    state[1]  = frame[_CMU_CH["lup_zrot"]]  * _CMU_DEG2RAD
+    state[6]  = frame[_CMU_CH["rup_xrot"]]  * _CMU_DEG2RAD
+    state[7]  = frame[_CMU_CH["rup_zrot"]]  * _CMU_DEG2RAD
+    # Trup
+    state[12] = frame[_CMU_CH["lback_yrot"]] * _CMU_DEG2RAD
+    # Goal vector
+    goal_vec = encode_goal(goal_for_task(task_name))
+    state[BODY_DIM + 8: BODY_DIM + 8 + GOAL_DIM] = goal_vec
+    return state
+
+
+def _cmu_delta_to_action(frame: np.ndarray, prev_frame: np.ndarray) -> np.ndarray:
+    """Δ mezi dvěma CMU snímky → 10D agent akce."""
+    delta = frame - prev_frame
+    a = np.zeros(10, dtype=np.float32)
+    a[0] = (delta[_CMU_CH["lup_xrot"]]  + delta[_CMU_CH["rup_xrot"]])  * 0.5 * _CMU_ACTION_SCALE
+    a[1] = (delta[_CMU_CH["lup_zrot"]]  + delta[_CMU_CH["rup_zrot"]])  * 0.5 * _CMU_ACTION_SCALE
+    a[2] = delta[_CMU_CH["lback_yrot"]] * _CMU_ACTION_SCALE
+    a[3] = delta[_CMU_CH["larm_xrot"]]  * _CMU_ACTION_SCALE
+    a[4] = delta[_CMU_CH["lfore_zrot"]] * _CMU_ACTION_SCALE
+    a[5] = delta[_CMU_CH["lhand_xrot"]] * _CMU_ACTION_SCALE
+    a[6] = delta[_CMU_CH["rarm_xrot"]]  * _CMU_ACTION_SCALE
+    a[7] = delta[_CMU_CH["rfore_zrot"]] * _CMU_ACTION_SCALE
+    a[8] = delta[_CMU_CH["rhand_xrot"]] * _CMU_ACTION_SCALE
+    # Gripper: pravá ruka jde dolů (pozitivní Xrot delta = flexe → dribble tlak)
+    rhand_delta_y = delta[_CMU_CH["rhand_yrot"]]
+    a[9] = float(np.clip(rhand_delta_y * 0.03, -1.0, 1.0))
+    return np.clip(a, -1.0, 1.0)
+
+
+def load_basketball_bvh(
+    data_dir: str,
+    task_name: str = "dribble",
+    subsample: int = 6,
+    max_files: int = 30,
+) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Načte CMU MoCap basketball BVH soubory → (states, actions).
+
+    subsample=6: 120fps → 20fps (basketbal je rychlý pohyb)
+    Vrací prázdné pole pokud žádné BVH soubory nenalezeny.
+    """
+    files = sorted(glob.glob(os.path.join(data_dir, "*.bvh")))
+    if not files:
+        raise FileNotFoundError(f"Žádné .bvh soubory v {data_dir}")
+    files = files[:max_files]
+
+    all_states, all_actions = [], []
+    for fpath in files:
+        frames = _parse_bvh_frames(fpath)
+        if frames is None or len(frames) < 2:
+            continue
+        frames = frames[::subsample]
+        for i in range(1, len(frames)):
+            s = _cmu_frame_to_state(frames[i], task_name)
+            a = _cmu_delta_to_action(frames[i], frames[i - 1])
+            all_states.append(s)
+            all_actions.append(a)
+
+    if not all_states:
+        raise ValueError("Žádná platná data z BVH souborů")
+    return np.array(all_states, dtype=np.float32), np.array(all_actions, dtype=np.float32)

embodied/rl_loop.py

@@ -0,0 +1,503 @@
+"""
+Autonomous RL training loop with:
+  - 10-DOF action (hips/knees/shoulders/elbows/grip)
+  - 69-dim state (24 body + 8 memory + 32 goal + 5 biocor)
+  - PhantomCortex: 4-tier HexaPenta memory, BioCor safety, ACC conflict detection
+  - Per-task noise reset + ACC/BioCor noise modulation
+"""
+from __future__ import annotations
+import sys, os, json, time, logging
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+import numpy as np
+from pathlib import Path
+from typing import List, Dict, Optional, Tuple, Any
+from dataclasses import dataclass, field, asdict
+
+from cogcore.cognition.motor import MotorActionHead, MotorActionConfig, MotorReplayBuffer
+from cogcore.emergent.loop import EmergentCognitiveLoop, EmergentLoopConfig
+from engine.cognitive_observation import EngineCognitiveObservationAdapter
+from embodied.language_goal_bridge import goal_to_text
+from embodied.anti_stasis import (
+    AntiDoNothingController, AntiStasisConfig, AgentNeeds,
+    EmbodiedObservation, MotorExplorationScheduler, EventRecord,
+)
+from embodied.virtual_body import VirtualBody
+from embodied.physics_world import WorldEnv
+from embodied.tasks.base import Task, TaskResult
+from embodied.goal_encoder import GOAL_DIM, goal_for_task, encode_goal
+from embodied.phantom_cortex import PhantomCortex, CORTEX_DIM
+
+log = logging.getLogger("phantom.rl")
+
+
+# ── Config ────────────────────────────────────────────────────────────────────
+
+@dataclass
+class RLConfig:
+    state_dim:    int   = CORTEX_DIM     # 24 body + 8 mem + 32 goal + 5 bio = 69
+    action_dim:   int   = 10
+    hidden_dim:   int   = 64
+    lr:           float = 0.003
+    gamma:        float = 0.99
+    buffer_cap:   int   = 8192
+    train_every:  int   = 16
+    batch_size:   int   = 32
+    noise_std:    float = 0.20
+    noise_floor:  float = 0.10   # min 10% explorace — nikdy nepřestat zkoumat
+    noise_decay:  float = 0.9998 # pomaleji: min dosažen za ~8000 train-steps (~65 ep)
+    reset_noise:  float = 0.20   # při každém novém tasku resetuj na 20%
+    dt:           float = 0.016
+    seed:         int   = 42
+    use_gemini:   bool  = False  # multimodální goal generation přes Gemini API
+
+
+# ── Experience & Replay ───────────────────────────────────────────────────────
+
+@dataclass
+class Transition:
+    state:      np.ndarray
+    action:     np.ndarray
+    reward:     float
+    next_state: np.ndarray
+    done:       bool
+
+
+class ExperienceBuffer:
+    def __init__(self, capacity: int, state_dim: int, action_dim: int):
+        self.cap  = capacity
+        self.idx  = 0
+        self.full = False
+        self.states      = np.zeros((capacity, state_dim),  np.float32)
+        self.actions     = np.zeros((capacity, action_dim), np.float32)
+        self.rewards     = np.zeros(capacity,               np.float32)
+        self.next_states = np.zeros((capacity, state_dim),  np.float32)
+        self.dones       = np.zeros(capacity,               bool)
+
+    def push(self, t: Transition):
+        i = self.idx % self.cap
+        self.states[i]      = t.state
+        self.actions[i]     = t.action
+        self.rewards[i]     = t.reward
+        self.next_states[i] = t.next_state
+        self.dones[i]       = t.done
+        self.idx += 1
+        if self.idx >= self.cap:
+            self.full = True
+
+    def sample(self, n: int, rng: np.random.Generator) -> Tuple:
+        size = self.cap if self.full else self.idx
+        idx  = rng.integers(0, size, size=min(n, size))
+        return (self.states[idx], self.actions[idx],
+                self.rewards[idx], self.next_states[idx], self.dones[idx])
+
+    def __len__(self):
+        return self.cap if self.full else self.idx
+
+
+# ── RL Agent ──────────────────────────────────────────────────────────────────
+
+class PhantomAgent:
+    """
+    MotorActionHead + PhantomCortex (4-tier memory, BioCor safety, ACC conflict).
+    State: 24 body + 8 mem + 32 goal + 5 bio = 69 dims.
+    """
+
+    def __init__(self, cfg: RLConfig):
+        self.cfg    = cfg
+        self.rng    = np.random.default_rng(cfg.seed)
+        motor_cfg   = MotorActionConfig(
+            state_dim=cfg.state_dim,
+            action_dim=cfg.action_dim,
+            hidden_dim=cfg.hidden_dim,
+            lr=cfg.lr,
+        )
+        self.head    = MotorActionHead(config=motor_cfg, seed=cfg.seed)
+        self.buffer  = ExperienceBuffer(cfg.buffer_cap, cfg.state_dim, cfg.action_dim)
+        self.noise   = cfg.noise_std
+        self.cortex  = PhantomCortex()
+        self.motor_scheduler = MotorExplorationScheduler(
+            epsilon_start=0.25, epsilon_end=0.05, decay_ticks=300_000, seed=cfg.seed
+        )
+        self._global_tick = 0
+        self._step   = 0
+        self._task_name = "stand"
+
+    def reset_memory(self, task_name: str = "stand"):
+        self._task_name = task_name
+        self.cortex.reset(task_name)
+
+    def set_goal(self, goal_vec: np.ndarray):
+        self.cortex.set_goal(goal_vec)
+
+    def act(self, body_state: np.ndarray, last_action: np.ndarray,
+            reward: float = 0.0,
+            goal_vec: np.ndarray | None = None) -> tuple[np.ndarray, np.ndarray]:
+        if goal_vec is not None:
+            self.cortex.set_goal(goal_vec)
+        state  = self.cortex.step(body_state, last_action, reward, self._task_name)
+        out    = self.head.forward(state)
+        action = np.array(out["action"], dtype=np.float32)
+        # ACC + BioCor modulate exploration noise
+        eff_noise = self.cortex.noise_multiplier(self.noise)
+        noise     = self.rng.normal(0, eff_noise, action.shape).astype(np.float32)
+        # Safety bypass: zero out action if ACC signals danger
+        if self.cortex.safety_bypass():
+            action = np.zeros_like(action)
+        action = np.clip(action + noise, -1.0, 1.0)
+        # CogCore ε-greedy motor exploration (AntiStasis MotorExplorationScheduler)
+        _, explored, _ = self.motor_scheduler.choose(None, [], tick=self._global_tick)
+        if explored:
+            action = self.rng.uniform(-1.0, 1.0, action.shape).astype(np.float32)
+        self._global_tick += 1
+        return action, state
+
+    def store(self, t: Transition):
+        self.buffer.push(t)
+
+    def update(self) -> Optional[float]:
+        if len(self.buffer) < self.cfg.batch_size:
+            return None
+        states, actions, rewards, next_states, dones = \
+            self.buffer.sample(self.cfg.batch_size, self.rng)
+        next_feats = np.stack([
+            np.array(self.head.forward(ns)["features"][:self.cfg.action_dim], np.float32)
+            for ns in next_states
+        ])
+        v_next   = np.mean(np.abs(next_feats), axis=1)
+        targets  = rewards + self.cfg.gamma * v_next * (~dones)
+        advs     = targets - np.mean(targets)
+        tgt_acts = np.clip(
+            actions + np.outer(advs, np.ones(self.cfg.action_dim)) * 0.1,
+            -1.0, 1.0,
+        )
+        loss = self.head.train_supervised_step(states, tgt_acts)
+        self.noise = max(self.cfg.noise_floor, self.noise * self.cfg.noise_decay)
+        return float(loss)
+
+    def reset_noise_for_task(self, task=None):
+        level = getattr(task, "reset_noise", self.cfg.reset_noise)
+        self.noise = max(level, self.cfg.noise_floor)
+
+    def save(self, path: Path):
+        np.savez(str(path),
+                 W1=self.head.W1, b1=self.head.b1,
+                 W_action=self.head.W_action, b_action=self.head.b_action,
+                 W_disc=self.head.W_disc,   b_disc=self.head.b_disc,
+                 noise=np.array([self.noise]))
+
+    def load(self, path: Path):
+        w = np.load(str(path))
+        self.head.W1       = w["W1"]
+        self.head.b1       = w["b1"]
+        self.head.W_action = w["W_action"]
+        self.head.b_action = w["b_action"]
+        self.head.W_disc   = w["W_disc"]
+        self.head.b_disc   = w["b_disc"]
+        if "noise" in w:
+            self.noise = float(w["noise"][0])
+
+
+# ── Episode runner ────────────────────────────────────────────────────────────
+
+@dataclass
+class EpisodeStats:
+    episode:      int
+    task:         str
+    steps:        int
+    total_reward: float
+    success:      bool
+    fallen:       bool
+    noise:        float
+    loss:         Optional[float]
+    duration_s:   float
+    interesting:  List[str] = field(default_factory=list)
+
+
+def run_episode(agent: PhantomAgent, task: Task, cfg: RLConfig,
+                ckpt_dir: Path, episode: int,
+                gemini=None,
+                command_goal_vec: Optional[np.ndarray] = None) -> EpisodeStats:
+    t0 = time.time()
+
+    world = WorldEnv(seed=episode, terrain_type=task.terrain)
+    body_cls = getattr(task, "body_class", VirtualBody)
+    body  = body_cls(world.phys, origin=None)
+    task.reset(body, world)
+    agent.reset_memory(task.name)
+
+    # ── Goal vector (Gemini multimodální → PFC) ────────────────────────────
+    # Gemini generuje goal_vec jednou na začátku epizody (cíl se nemění).
+    # Bez Gemini API se použije předdefinovaný fallback vektor.
+    goal_vec = None
+    goal_desc = ""
+    if gemini is not None and cfg.use_gemini:
+        try:
+            from embodied.world_renderer import render_scene
+            target_pos = getattr(task, "TARGET_POS", None) or getattr(task, "CHAIR_POS", None)
+            # FPV = co agent skutečně vidí ze svých očí; minimap = prostorový kontext
+            fpv_img, minimap_img = render_scene(world, body, target_pos=target_pos)
+            torso_pos = body.bodies["torso"].position if "torso" in body.bodies else None
+            spec, goal_vec = gemini.get_goal(
+                f"Proveď úlohu: {task.name}",
+                fpv_img=fpv_img,
+                minimap_img=minimap_img,
+                agent_pos=torso_pos,
+                target_pos=target_pos,
+            )
+            goal_desc = spec.description
+            log.debug("[%s] Gemini goal: %s → vec norm=%.2f",
+                      task.name, goal_desc, float(np.linalg.norm(goal_vec)))
+        except Exception as e:
+            log.warning("Gemini goal generation selhal: %s", e)
+
+    if goal_vec is None:
+        if command_goal_vec is not None:
+            goal_vec = command_goal_vec   # language command přepisuje fallback
+        else:
+            spec = goal_for_task(task.name)
+            goal_vec = encode_goal(spec)
+    agent.set_goal(goal_vec)
+
+    total_reward = 0.0
+    steps        = 0
+    last_loss    = None
+    interesting  = []
+    last_action  = np.zeros(cfg.action_dim, np.float32)
+    prev_bstate  = body.get_state()
+    prev_reward  = 0.0
+    # CogCore AntiDoNothingController — officially tuned anti-stasis coefficients
+    anti_stasis_cfg = AntiStasisConfig(
+        hunger_rate=0.0018,
+        idle_energy_decay=0.0011,
+        action_energy_cost_scale=0.004,
+        hunger_penalty_weight=0.20,
+        low_energy_penalty_weight=0.10,
+        death_penalty=-3.0,
+        survival_bonus=0.004,
+        curiosity_weight=0.40,
+        movement_reward=0.015,
+        food_reward=0.50,
+        # Boredom snížen 5× — musí být dost na přelomení alive-only (+74),
+        # ale nesmí zničit gradient signál z proximity reward
+        repeated_position_penalty=-0.030,
+        repeated_signature_penalty=-0.008,
+        boredom_window=60,
+    )
+    anti_stasis = AntiDoNothingController(config=anti_stasis_cfg)
+    emergent_loop = EmergentCognitiveLoop()
+    emergent_loop.reset()
+    cog_obs_adapter = EngineCognitiveObservationAdapter()
+    prev_visual  = None
+
+    for step in range(task.max_steps):
+        action, aug_state = agent.act(prev_bstate, last_action,
+                                      reward=prev_reward, goal_vec=goal_vec)
+
+        # POLARIS server blend: task může mít polaris_server atribut
+        # → část akce pochází z analogového POLARIS čipu (inference v HfO2)
+        if getattr(task, "polaris_server", None) is not None:
+            _ps      = task.polaris_server
+            _pid     = getattr(task, "polaris_agent_id", "agent")
+            _blend   = getattr(task, "polaris_blend",    0.25)
+            _state_v = aug_state if aug_state is not None else prev_bstate
+            pol_action = _ps.infer(_pid, _state_v.astype(np.float32))
+            action     = np.clip(
+                action * (1.0 - _blend) + pol_action * _blend, -1.0, 1.0
+            ).astype(np.float32)
+            # Online Hebbian update: POLARIS se učí z RL akce
+            if step % 4 == 0:
+                _ps.learn(_pid, _state_v.astype(np.float32), action)
+
+        body.apply_action(action)
+        world.step(cfg.dt)
+        body.update_contacts(ground_y=0.15)
+
+        bstate    = body.get_state()
+        # Tasky s vlastní fyzikou (DriveCity, apod.) mohou přepsat state vektor
+        if hasattr(task, "get_task_state"):
+            bstate = task.get_task_state(bstate)
+        task_r    = task.step_reward(body, world, action)
+
+        # CogCore anti-stasis bonus (officially tuned, fights local optimum of doing nothing)
+        torso      = body.torso_pos()
+        body_vel   = float(np.linalg.norm([bstate[0], bstate[1]]))
+        grasped    = bool(action[8] < -0.5 or action[9] < -0.5)
+
+        # KFP food motivation: task může vrátit food_event (póza = dumpling = metabolismus)
+        found_food, nutrition, energy_gain = False, 0.0, 0.0
+        if hasattr(task, 'food_event'):
+            found_food, nutrition, energy_gain = task.food_event(body, world)
+
+        # Krmení metabolismu: buď KFP food event, nebo obecná task_r
+        if found_food:
+            anti_stasis.needs.feed(nutrition=nutrition, energy_gain=energy_gain)
+        elif task_r > 0.0:
+            anti_stasis.needs.feed(
+                nutrition=min(0.50, float(task_r) * 1.5),
+                energy_gain=min(0.15, float(task_r) * 0.5),
+            )
+
+        events_list = []
+        if grasped:
+            events_list.append(EventRecord("INTERACT_SUCCESS", source_id="agent"))
+        if body_vel > 0.1:
+            events_list.append(EventRecord("MOVE", source_id="agent"))
+        obs = EmbodiedObservation(
+            agent_id="phantom",
+            tick=step,
+            position=(int(torso[0]), int(torso[1]), int(torso[2])),
+            visual_state=prev_visual,
+            predicted_next_visual=prev_visual,
+            actual_next_visual=bstate,
+            action_id="grasp" if grasped else ("move" if body_vel > 0.1 else "idle"),
+            action_cost=float(np.mean(np.abs(action))) * 0.3,
+            events=tuple(events_list),
+            external_reward=0.0,   # task_r zvlášť — žádné dvojité počítání
+            found_food=found_food,  # KFP: dobrá póza = jídlo = metabolická odměna
+            nutrition=nutrition,
+            energy_gain=energy_gain,
+        )
+        report    = anti_stasis.step(obs)
+        im_bonus  = float(report.reward)
+
+        # EmergentCognitiveLoop — officiální engine.cognitive_observation bridge
+        e_cog = cog_obs_adapter.from_mapping({
+            "position":  (float(torso[0]), float(torso[1]), float(torso[2])),
+            "velocity":  (float(bstate[0]), 0.0, float(bstate[1])),
+            "energy":    float(anti_stasis.needs.energy),
+            "damage":    1.0 if body.is_fallen() else 0.0,
+            "contact":   1.0 if grasped else 0.0,
+            "blocked":   1.0 if body_vel < 0.005 else 0.0,
+        })
+        e_obs    = e_cog.to_cogcore_dict()
+        e_action = {"control_match": min(1.0, float(task_r + 1.0) / 2.0) if task_r > -1.0 else 0.0}
+        e_report = emergent_loop.step(e_obs, action=e_action)
+        # planner_bias.caution: jen log pro monitoring — noise_decay řídí hlavní plán
+        # Emergent loop nesmí přebít noise_decay schedule, proto nemodifikuje agent.noise
+
+        prev_visual = bstate
+
+        # Každých 100 kroků: agent "řekne" co si myslí že dělá (language goal bridge)
+        if step % 100 == 0 and step > 0:
+            ws_tokens = list(e_report.workspace.get("broadcast", []))[:3] if e_report else []
+            thought = goal_to_text(
+                goal_vec,
+                object_dist=-1.0,
+                energy=float(anti_stasis.needs.energy),
+                noise=agent.noise,
+                workspace_tokens=ws_tokens,
+            )
+            log.debug("[%s] step %d | %s", task.name, step, thought)
+
+        reward    = task_r + im_bonus
+        done      = task.is_done(body, world)
+        total_reward += reward
+        steps += 1
+
+        _, next_aug = agent.act(bstate, action, reward=reward, goal_vec=goal_vec)
+        agent.store(Transition(aug_state, action, reward, next_aug, done))
+
+        if steps % cfg.train_every == 0:
+            loss = agent.update()
+            if loss is not None:
+                last_loss = loss
+
+        if reward < -1.5:
+            interesting.append(f"fall_penalty@step{step}")
+        if task.success_condition(body, world):
+            interesting.append(f"SUCCESS@step{step}")
+            done = True
+
+        last_action = action
+        prev_bstate = bstate
+        prev_reward = reward
+        if done:
+            break
+
+    success = task.success_condition(body, world)
+    fallen  = body.is_fallen()
+
+    return EpisodeStats(
+        episode=episode, task=task.name, steps=steps,
+        total_reward=round(total_reward, 4),
+        success=success, fallen=fallen,
+        noise=round(agent.noise, 4),
+        loss=round(last_loss, 6) if last_loss is not None else None,
+        duration_s=round(time.time() - t0, 2),
+        interesting=interesting,
+    )
+
+
+# ── Curriculum ────────────────────────────────────────────────────────────────
+
+def train_curriculum(
+    tasks: List[Task],
+    episodes_per_task: int,
+    cfg: RLConfig,
+    ckpt_dir: Path,
+    log_path: Path,
+    resume: bool = False,
+    gemini=None,
+    command_goal_vec: Optional[np.ndarray] = None,
+    bc_weights_path: str = "",
+) -> List[EpisodeStats]:
+    agent = PhantomAgent(cfg)
+
+    ckpt = ckpt_dir / "agent_latest.npz"
+    if resume and ckpt.exists():
+        agent.load(ckpt)
+        log.info("Resumed from %s", ckpt)
+    elif bc_weights_path:
+        # BC předtrénování: načti váhy před RL (jen pokud nezačínáme z RL checkpointu)
+        try:
+            from embodied.pretrain.bc_pretrain import load_bc_weights_into_agent
+            load_bc_weights_into_agent(agent, bc_weights_path)
+            log.info("BC předtrénované váhy načteny: %s", bc_weights_path)
+        except Exception as e:
+            log.warning("BC váhy nelze načíst (%s) — start z náhodné inicializace", e)
+
+    all_stats: List[EpisodeStats] = []
+    ep_global = 0
+
+    for task in tasks:
+        log.info("══ Task: %s  (%d episodes, reset_noise=%.2f) ══",
+                 task.name, episodes_per_task, getattr(task, "reset_noise", cfg.reset_noise))
+        # Restore exploration noise for each new task (manipulation tasks use higher noise)
+        agent.reset_noise_for_task(task)
+        task_rewards = []
+
+        for ep in range(episodes_per_task):
+            stats = run_episode(agent, task, cfg, ckpt_dir, ep_global,
+                                gemini=gemini, command_goal_vec=command_goal_vec)
+            all_stats.append(stats)
+            task_rewards.append(stats.total_reward)
+            ep_global += 1
+
+            if True:   # loguj každou epizodu pro rychlejší feedback
+                avg = np.mean(task_rewards[-5:]) if len(task_rewards) >= 5 else stats.total_reward
+                log.info("[%s] ep %d/%d  reward=%.2f  avg5=%.2f  noise=%.3f  %s",
+                         task.name, ep+1, episodes_per_task,
+                         stats.total_reward, avg, agent.noise,
+                         "SUCCESS" if stats.success else ("FALLEN" if stats.fallen else ""))
+
+            with log_path.open("a") as f:
+                d = asdict(stats)
+                # numpy float32 → Python float pro JSON serializaci
+                def _to_python(v):
+                    if isinstance(v, np.floating): return float(v)
+                    if isinstance(v, np.integer):  return int(v)
+                    return v
+                d = {k: _to_python(v) for k, v in d.items()}
+                f.write(json.dumps(d) + "\n")
+
+            # Průběžný checkpoint každých 10 epizod (ochrana před výpadkem kontejneru)
+            if (ep + 1) % 10 == 0:
+                agent.save(ckpt)
+                agent.save(ckpt_dir / f"agent_{task.name}_ep{ep+1}.npz")
+
+        agent.save(ckpt)
+        agent.save(ckpt_dir / f"agent_{task.name}.npz")
+        log.info("Checkpoint saved after task %s", task.name)
+
+    return all_stats

embodied/run_embodied.py

@@ -0,0 +1,246 @@
+#!/usr/bin/env python3
+"""
+Embodied training: virtual body + Noctilith physics world.
+
+Curriculum (default):
+  1. stand                – stay upright
+  2. reach                – reach a target with the right hand
+  3. walk                 – walk forward over hills
+  4. stairs               – climb a staircase
+  5. maze                 – navigate a procedural labyrinth
+  6. household_pick       – pick a cup off the table, carry to counter
+  7. household_door       – push a door handle, walk through
+  8. household_stack      – pick up 3 blocks, stack on table
+  9. household_sweep      – knock cups off the table
+  10. household_sit       – navigate to chair and sit down
+
+Usage:
+  python -m embodied.run_embodied [--episodes N] [--tasks stand,walk,maze]
+  python -m embodied.run_embodied --episodes 40 --tasks household_pick,household_door
+"""
+import argparse, logging, json, os, sys, time
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+from pathlib import Path
+import numpy as np
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s  %(levelname)-8s  %(name)s  %(message)s",
+    datefmt="%H:%M:%S",
+)
+log = logging.getLogger("phantom.embodied")
+
+CKPT_DIR = Path(os.getenv("PHANTOM_CKPT",    "checkpoints"))
+LOG_DIR  = Path(os.getenv("PHANTOM_LOGS",    "logs"))
+RES_DIR  = Path(os.getenv("PHANTOM_RESULTS", "results"))
+for p in [CKPT_DIR, LOG_DIR, RES_DIR]:
+    p.mkdir(parents=True, exist_ok=True)
+
+LOG_PATH = LOG_DIR / "embodied_training.jsonl"
+
+
+TASK_REGISTRY = {
+    "stand":           ("embodied.tasks.stand",            "StandTask"),
+    "walk":            ("embodied.tasks.walk",             "WalkTask"),
+    "reach":           ("embodied.tasks.reach",            "ReachTask"),
+    "stairs":          ("embodied.tasks.stairs",           "StairsTask"),
+    "maze":            ("embodied.tasks.maze",             "MazeTask"),
+    "household_pick":  ("embodied.tasks.household_pick",   "HouseholdPickTask"),
+    "household_door":  ("embodied.tasks.household_door",   "HouseholdDoorTask"),
+    "household_stack": ("embodied.tasks.household_stack",  "HouseholdStackTask"),
+    "household_sweep": ("embodied.tasks.household_sweep",  "HouseholdSweepTask"),
+    "household_sit":   ("embodied.tasks.household_sit",    "HouseholdSitTask"),
+    # ── Nové interaktivní + mediální úlohy ────────────────────────────────────
+    "reach_arm":       ("embodied.tasks.reach_arm",        "ReachArmTask"),
+    # ── Jóga ─────────────────────────────────────────────────────────────────
+    "yoga_mountain":   ("embodied.tasks.yoga",             "YogaMountainTask"),
+    "yoga_tree":       ("embodied.tasks.yoga",             "YogaTreeTask"),
+    "yoga_warrior1":   ("embodied.tasks.yoga",             "YogaWarrior1Task"),
+    "yoga_warrior2":   ("embodied.tasks.yoga",             "YogaWarrior2Task"),
+    "yoga_triangle":   ("embodied.tasks.yoga",             "YogaTriangleTask"),
+    "yoga_child":      ("embodied.tasks.yoga",             "YogaChildTask"),
+    "yoga_downdog":    ("embodied.tasks.yoga",             "YogaDowndogTask"),
+    "yoga_cobra":      ("embodied.tasks.yoga",             "YogaCobraTask"),
+    "yoga_all":        ("embodied.tasks.yoga",             "YogaAllTask"),
+    "yoga_random":     ("embodied.tasks.yoga",             "YogaRandomTask"),
+    "household_ball":  ("embodied.tasks.household_ball",   "BallTask"),
+    "shape_sorter":    ("embodied.tasks.shape_sorter",     "ShapeSorterTask"),
+    "media_watch":     ("embodied.tasks.media_watch",      "MediaWatchTask"),
+    # ── Vojenská překážková dráha ─────────────────────────────────────────────
+    "obstacle_course": ("embodied.tasks.obstacle_course",  "ObstacleCourseTask"),
+    # ── Řízení hypercar v městském prostředí ──────────────────────────────────
+    "drive_city":      ("embodied.tasks.drive_city",        "DriveCity"),
+    "drive_city_echo": ("embodied.tasks.drive_city_echo",   "DriveCity_Echo"),
+    # ── Terminator (POLARIS v3.1 + EHA-C Rev C.1) ────────────────────────────
+    "terminator_stand":   ("embodied.tasks.terminator_stand",   "TerminatorStandTask"),
+    "terminator_factory": ("embodied.tasks.terminator_factory",  "TerminatorFactoryTask"),
+    "terminator_obstacle":("embodied.tasks.terminator_factory",  "TerminatorObstacleTask"),
+    # ── Terminator jemná motorika (nářadí) ───────────────────────────────────
+    "terminator_weld":    ("embodied.tasks.terminator_tools",   "TerminatorWeldTask"),
+    "terminator_screw":   ("embodied.tasks.terminator_tools",   "TerminatorScrewTask"),
+    "terminator_assembly":("embodied.tasks.terminator_tools",   "TerminatorAssemblyTask"),
+    # ── PolarisServer — virtuální neuromorphní server ve VoxForge světě ─────
+    "polaris_server":     ("embodied.tasks.polaris_server_task","PolarisServerTask"),
+    # ── Drive + POLARIS koprocesor ────────────────────────────────────────────
+    "drive_city_polaris": ("embodied.tasks.drive_city_polaris", "DriveCity_Polaris"),
+    # ── Basketbal ─────────────────────────────────────────────────────────────
+    "dribble":          ("embodied.tasks.basketball",      "DribbleTask"),
+    "shoot":            ("embodied.tasks.basketball",      "ShootTask"),
+    "layup":            ("embodied.tasks.basketball",      "LayupTask"),
+    "basketball":       ("embodied.tasks.basketball",      "BasketballTask"),
+    "basketball_1v1":   ("embodied.tasks.basketball_1v1",  "Basketball1v1Task"),
+    "basketball_coop":  ("embodied.tasks.basketball_1v1",  "BasketballCoopTask"),
+    # ── Časovaná navigace (3 módy emergentního chování) ──────────────────────
+    "timed_nav_legal":    ("embodied.tasks.timed_nav", "TimedNavLegal"),
+    "timed_nav_realistic":("embodied.tasks.timed_nav", "TimedNavRealistic"),
+    "timed_nav_race":     ("embodied.tasks.timed_nav", "TimedNavRace"),
+    # ── Jízda na ledu / sněhu (emergentní rally techniky) ────────────────────
+    "ice_driving_ice":       ("embodied.tasks.ice_driving", "IceDrivingIce"),
+    "ice_driving_snow":      ("embodied.tasks.ice_driving", "IceDrivingSnow"),
+    "ice_driving_black_ice": ("embodied.tasks.ice_driving", "IceDrivingBlackIce"),
+    "ice_driving_mixed":     ("embodied.tasks.ice_driving", "IceDrivingMixed"),
+    # ── Led + POLARIS koprocesor ──────────────────────────────────────────────
+    "ice_driving_polaris":           ("embodied.tasks.ice_driving_polaris", "IceDriving_Polaris"),
+    "ice_driving_ice_polaris":       ("embodied.tasks.ice_driving_polaris", "IceDrivingIce_Polaris"),
+    "ice_driving_black_ice_polaris": ("embodied.tasks.ice_driving_polaris", "IceDrivingBlackIce_Polaris"),
+}
+
+
+def _load_task(name: str):
+    mod_name, cls_name = TASK_REGISTRY[name]
+    import importlib
+    mod = importlib.import_module(mod_name)
+    return getattr(mod, cls_name)()
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--episodes", type=int, default=20)
+    parser.add_argument("--tasks",
+        default="stand,reach,walk,stairs,maze,"
+                "household_pick,household_door,household_stack,"
+                "household_sweep,household_sit")
+    parser.add_argument("--resume", action="store_true")
+    parser.add_argument("--seed",   type=int, default=42)
+    parser.add_argument("--gemini", action="store_true",
+                        help="Zapni Gemini multimodální goal generation (vyžaduje GEMINI_API_KEY)")
+    parser.add_argument("--command", type=str, default="",
+                        help="Přirozený jazyk příkaz (CZ/EN) → přepíše goal_vec pro všechny tasky. "
+                             "Např: 'vezmi hrníček a dej ho na pult'")
+    parser.add_argument("--bc-init", type=str, default="",
+                        help="Cesta k BC předtrénovaným vahám (checkpoints/bc_pretrained.npz). "
+                             "Načte váhy před RL tréninkem — agent začíná s pohybovými prio ry.")
+    parser.add_argument("--bc-steps", type=int, default=0,
+                        help="Spustit BC předtrénování NYNÍ s tímto počtem kroků (přepíše --bc-init). "
+                             "Data: /tmp/lafan_walk + /tmp/libero_pick")
+    parser.add_argument("--bc-ice", action="store_true",
+                        help="Spustit BC ICE předtrénování (syntetický rally expert) → checkpoints/bc_ice.npz. "
+                             "Vhodné pro ice_driving_* tasky. Nevyžaduje žádná externí data.")
+    parser.add_argument("--bc-ice-surface", default="all",
+                        choices=["ice", "snow", "black_ice", "all"],
+                        help="Povrch pro BC ICE (default: all = mix ledu/sněhu/černého ledu)")
+    parser.add_argument("--bc-ice-steps", type=int, default=15000,
+                        help="Počet kroků BC ICE předtrénování (default: 15000)")
+    args = parser.parse_args()
+
+    from embodied.rl_loop import RLConfig, train_curriculum
+    from embodied.observer import load_log, analyse, print_report, save_report
+    from embodied.phantom_cortex import CORTEX_DIM
+
+    task_names = [t.strip() for t in args.tasks.split(",")]
+    tasks      = [_load_task(n) for n in task_names]
+
+    cfg = RLConfig(
+        state_dim=CORTEX_DIM, action_dim=10,
+        hidden_dim=64, lr=0.003,
+        gamma=0.99, buffer_cap=8192,
+        train_every=16, batch_size=32,
+        noise_std=0.20, noise_floor=0.10,
+        noise_decay=0.9998, reset_noise=0.20,
+        dt=0.016, seed=args.seed,
+        use_gemini=args.gemini,
+    )
+
+    # Volitelný Gemini commander (jazyková oblast)
+    gemini = None
+    if args.gemini:
+        try:
+            from embodied.gemini_commander import GeminiCommander
+            gemini = GeminiCommander(log_path=LOG_PATH)
+            log.info("Gemini multimodální goal generation: AKTIVNÍ")
+        except Exception as e:
+            log.warning("Gemini nedostupný (%s) — trénink pokračuje s fallback goal_vec", e)
+
+    # ── BC předtrénování / načtení BC vah ────────────────────────────────────
+    bc_weights_path = ""
+    if args.bc_ice:
+        log.info("Spouštím BC ICE předtrénování (syntetický rally expert)  "
+                 "surface=%s  steps=%d ...", args.bc_ice_surface, args.bc_ice_steps)
+        try:
+            from embodied.pretrain.bc_ice_driving import run_ice_bc_pretraining
+            run_ice_bc_pretraining(
+                surface=args.bc_ice_surface,
+                steps=args.bc_ice_steps,
+                save_path="checkpoints/bc_ice.npz",
+            )
+            bc_weights_path = "checkpoints/bc_ice.npz"
+        except Exception as e:
+            log.warning("BC ICE předtrénování selhalo (%s) — pokračuji bez něj", e)
+    elif args.bc_steps > 0:
+        log.info("Spouštím BC předtrénování (%d kroků) z LAFAN + LIBERO ...", args.bc_steps)
+        try:
+            from embodied.pretrain.bc_pretrain import run_bc_pretraining
+            run_bc_pretraining(
+                lafan_dir="/tmp/lafan_walk",
+                libero_dir="/tmp/libero_pick",
+                steps=args.bc_steps,
+                save_path="checkpoints/bc_pretrained.npz",
+            )
+            bc_weights_path = "checkpoints/bc_pretrained.npz"
+        except Exception as e:
+            log.warning("BC předtrénování selhalo (%s) — pokračuji bez něj", e)
+    elif args.bc_init:
+        bc_weights_path = args.bc_init
+
+    # Volitelný language command → goal_vec override
+    command_goal_vec = None
+    if args.command:
+        from embodied.language_goal_bridge import text_to_goal
+        from embodied.goal_encoder import encode_goal
+        spec = text_to_goal(args.command)
+        command_goal_vec = encode_goal(spec)
+        log.info("Language command: %r → action=%s target=%s dest=%s grip=%+.1f",
+                 args.command, spec.action, spec.target, spec.destination, spec.grip)
+
+    log.info("Starting embodied training v4 (PhantomCortex): tasks=%s  episodes_each=%d",
+             task_names, args.episodes)
+    log.info("Engine: VoxForge Noctilith  action_dim=10  state_dim=%d  "
+             "(28 body [+gyro+height] + 8 mem + 32 goal + 5 bio)  "
+             "cortex=PhantomCortex(4-tier HexaPenta + BioCor + ACC)", CORTEX_DIM)
+
+    t0 = time.time()
+    all_stats = train_curriculum(
+        tasks=tasks,
+        episodes_per_task=args.episodes,
+        cfg=cfg,
+        ckpt_dir=CKPT_DIR,
+        log_path=LOG_PATH,
+        resume=args.resume,
+        gemini=gemini,
+        command_goal_vec=command_goal_vec,
+        bc_weights_path=bc_weights_path,
+    )
+    elapsed = time.time() - t0
+
+    log.info("Training complete in %.1fs  total_episodes=%d", elapsed, len(all_stats))
+
+    rows   = load_log(LOG_PATH)
+    report = analyse(rows)
+    report["elapsed_s"] = round(elapsed, 1)
+    print_report(report)
+    save_report(report, RES_DIR / "embodied_report.json")
+
+
+if __name__ == "__main__":
+    main()

embodied/tasks/__init__.py

@@ -0,0 +1,12 @@
+from .base import Task, TaskResult
+from .stand import StandTask
+from .walk import WalkTask
+from .maze import MazeTask
+from .reach import ReachTask
+from .stairs import StairsTask
+from .household_pick import HouseholdPickTask
+from .household_door import HouseholdDoorTask
+from .household_stack import HouseholdStackTask
+from .household_sweep import HouseholdSweepTask
+from .household_sit import HouseholdSitTask
+from .obstacle_course import ObstacleCourseTask

embodied/tasks/base.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Dict, Any
+import numpy as np
+import sys, os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../..'))
+from engine.physics.rigid_body import vec3, Vec3
+
+
+@dataclass
+class TaskResult:
+    success: bool
+    reward: float
+    steps: int
+    info: Dict[str, Any] = field(default_factory=dict)
+
+
+class Task:
+    name = "base"
+    terrain = "flat"
+    max_steps = 600
+    reset_noise: float = 0.15   # noise level restored at each new task in curriculum
+
+    def reset(self, body, world_env) -> None:
+        raise NotImplementedError
+
+    def step_reward(self, body, world_env, action: np.ndarray) -> float:
+        raise NotImplementedError
+
+    def is_done(self, body, world_env) -> bool:
+        return body.is_fallen() or world_env._tick >= self.max_steps
+
+    def success_condition(self, body, world_env) -> bool:
+        return False

embodied/tasks/basketball.py

@@ -0,0 +1,403 @@
+"""
+Basketbalové tasky pro PhantomCortex agent.
+
+DribbleTask  — dribling: rytmické odrážení míče pravou rukou
+ShootTask    — střelba: hod míče na koš (výška 3.05 m, vzdálenost ~4 m)
+LayupTask    — layup: přiběh k obruči + střelba
+BasketballTask — celková úloha: dribling → pohyb → střelba
+
+Fyzika míče (zjednodušená):
+  ball.pos  — 3D pozice míče
+  Odraz: ball_y(t+1) = abs(ball_y(t) - BOUNCE_LOSS) pokud u podlahy
+  Gravitace: ball_vy -= 9.8 * dt
+"""
+from __future__ import annotations
+
+import numpy as np
+from .base import Task
+import sys, os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../..'))
+from engine.physics.rigid_body import vec3, length
+
+_GRAVITY   = 9.8
+_BOUNCE    = 0.72      # koeficient odrazu
+_HOOP_H    = 3.05      # výška obruče [m]
+_HOOP_X    = 4.0       # vzdálenost obruče [m]
+_HOOP_R    = 0.23      # polomer obruče [m]
+_DRIBBLE_H = 0.12      # výška míče při kontaktu s podlahou
+_HAND_R    = 0.25      # dosah ruky pro dotek míče [m]
+
+
+class _Ball:
+    """Jednoduchý míč s gravitací a odrazem."""
+    def __init__(self, pos: np.ndarray):
+        self.pos = pos.copy().astype(np.float32)
+        self.vel = np.zeros(3, dtype=np.float32)
+
+    def step(self, dt: float):
+        self.vel[1] -= _GRAVITY * dt
+        self.pos   += self.vel * dt
+        if self.pos[1] <= _DRIBBLE_H and self.vel[1] < 0:
+            self.pos[1]  = _DRIBBLE_H
+            self.vel[1] *= -_BOUNCE
+
+    def apply_impulse(self, impulse: np.ndarray):
+        self.vel += impulse
+
+
+class DribbleTask(Task):
+    """
+    Dribling: agent drží míč na dosah pravé ruky a rytmicky ho odrází.
+
+    Odměna:
+      +2.0 za každý odraz míče od podlahy (ball.pos.y ≤ dribble_h)
+      +1.0 za každý kontakt ruky s míčem (distance < HAND_R)
+      +0.5 za rytmus (pravidelné odrazy ~0.5 s)
+      -2.0 pokud míč odletí > 2 m od agenta (ztráta kontroly)
+      alive +0.03 / step
+    """
+    name        = "dribble"
+    terrain     = "flat"
+    max_steps   = 1500
+    reset_noise = 0.20
+
+    def reset(self, body, world_env):
+        body.reset(vec3(0.0, 2.0, 0.0))
+        hp = body.hand_pos("R")
+        start = np.array([hp[0], hp[1] - 0.5, hp[2]], dtype=np.float32)
+        self._ball  = _Ball(start)
+        self._bounces      = 0
+        self._last_bounce  = 0
+        self._dribble_intervals: list = []
+        self._contacts     = 0
+        self._tick         = 0
+
+    def step_reward(self, body, world_env, action):
+        dt   = 0.016
+        self._tick += 1
+
+        hp   = body.hand_pos("R")
+        hand = np.array([hp[0], hp[1], hp[2]], dtype=np.float32)
+
+        # Kontakt ruky s míčem
+        dist = float(np.linalg.norm(hand - self._ball.pos))
+        hand_contact = dist < _HAND_R
+        if hand_contact:
+            self._contacts += 1
+            grip = float(action[9])
+            # Ruka tlačí dolů (grip < 0 = svírá) → dáme míči impulz dolů
+            if grip < -0.1:
+                push = np.array([0.0, -4.5 * abs(grip), 0.0], dtype=np.float32)
+                self._ball.apply_impulse(push)
+            # Ruka pohybuje míčem laterálně
+            arm_vel = np.array([action[6] * 0.8, action[7] * 0.5, 0.0], dtype=np.float32)
+            self._ball.apply_impulse(arm_vel * 0.3)
+
+        prev_y = self._ball.pos[1]
+        self._ball.step(dt)
+
+        # Detekce odrazu
+        bounce_reward = 0.0
+        if prev_y > _DRIBBLE_H and self._ball.pos[1] <= _DRIBBLE_H + 0.02:
+            self._bounces += 1
+            interval = self._tick - self._last_bounce
+            if self._last_bounce > 0:
+                self._dribble_intervals.append(interval)
+            self._last_bounce = self._tick
+            bounce_reward = 2.0
+
+        # Rytmus bonus (intervaly mezi odrazy jsou konzistentní)
+        rhythm_reward = 0.0
+        if len(self._dribble_intervals) >= 3:
+            std = float(np.std(self._dribble_intervals[-6:]))
+            if std < 4.0:
+                rhythm_reward = 0.5
+
+        # Kontakt bonus
+        contact_reward = 0.5 if hand_contact else 0.0
+
+        # Ztráta míče penalty
+        agent_pos = np.array([0.0, 0.0, 0.0], dtype=np.float32)
+        ball_dist  = float(np.linalg.norm(self._ball.pos - agent_pos))
+        lost_penalty = -2.0 if ball_dist > 2.5 else 0.0
+
+        alive       = 0.03 if not body.is_fallen() else -2.0
+        action_pen  = float(np.mean(np.square(action))) * 0.002
+
+        return bounce_reward + rhythm_reward + contact_reward + lost_penalty + alive - action_pen
+
+    def success_condition(self, body, world_env) -> bool:
+        return self._bounces >= 20
+
+    def food_event(self, body, world_env) -> tuple:
+        if self._ball.pos[1] <= _DRIBBLE_H + 0.05:
+            return True, 0.15, 0.06   # odraz = krekr
+        return False, 0.0, 0.0
+
+
+class ShootTask(Task):
+    """
+    Střelba na koš: agent vhodí míč tak, aby prošel obruční (r=0.23 m, h=3.05 m).
+
+    Odměna:
+      +3.0 za výšku trajektorie (míč dosáhne > 2.5 m)
+      +10.0 za průchod obruční (úspěch)
+      progressivní: čím blíže k obruči, tím více bodů
+      alive +0.02 / step
+    """
+    name        = "shoot"
+    terrain     = "flat"
+    max_steps   = 800
+    reset_noise = 0.20
+
+    HOOP_POS = np.array([_HOOP_X, _HOOP_H, 0.0], dtype=np.float32)
+
+    def reset(self, body, world_env):
+        body.reset(vec3(0.0, 2.0, 0.0))
+        hp = body.hand_pos("R")
+        self._ball  = _Ball(np.array([hp[0], hp[1], hp[2]], dtype=np.float32))
+        self._shot_taken   = False
+        self._peak_height  = 0.0
+        self._scored       = False
+        self._prev_hoop_dist = float(np.linalg.norm(self._ball.pos - self.HOOP_POS))
+
+    def step_reward(self, body, world_env, action):
+        dt = 0.016
+
+        hp   = body.hand_pos("R")
+        hand = np.array([hp[0], hp[1], hp[2]], dtype=np.float32)
+        dist = float(np.linalg.norm(hand - self._ball.pos))
+
+        if not self._shot_taken:
+            # Fáze 1: přiblížení ruky k míči
+            if dist < _HAND_R:
+                # Střelecký pohyb: ruka jde nahoru + vpřed → dáme míči impuls
+                shoot_vel = np.array([
+                    action[6] * 3.5 + 2.0,    # vpřed ke koši
+                    abs(action[7]) * 4.0 + 3.5,  # nahoru (výška oblouku)
+                    action[8] * 0.5,
+                ], dtype=np.float32)
+                self._ball.vel = shoot_vel
+                self._shot_taken = True
+
+        self._ball.step(dt)
+        self._peak_height = max(self._peak_height, float(self._ball.pos[1]))
+
+        # Výška bonus
+        height_reward = 0.0
+        if self._ball.pos[1] > 2.5:
+            height_reward = 0.3
+
+        # Přiblížení ke koši
+        hoop_dist = float(np.linalg.norm(self._ball.pos - self.HOOP_POS))
+        approach  = (self._prev_hoop_dist - hoop_dist) * 2.0
+        self._prev_hoop_dist = hoop_dist
+
+        # Skóre: míč prošel obruční
+        score_reward = 0.0
+        if not self._scored and self._shot_taken:
+            horiz_dist = float(np.sqrt(
+                (self._ball.pos[0] - _HOOP_X) ** 2 + self._ball.pos[2] ** 2
+            ))
+            if horiz_dist < _HOOP_R and abs(self._ball.pos[1] - _HOOP_H) < 0.3:
+                score_reward  = 10.0
+                self._scored  = True
+
+        alive      = 0.02 if not body.is_fallen() else -2.0
+        action_pen = float(np.mean(np.square(action))) * 0.002
+
+        return height_reward + approach + score_reward + alive - action_pen
+
+    def success_condition(self, body, world_env) -> bool:
+        return self._scored
+
+    def food_event(self, body, world_env) -> tuple:
+        if self._scored:
+            return True, 1.0, 0.40   # koš = velký dumpling
+        if self._ball.pos[1] > 2.5:
+            return True, 0.12, 0.05  # míč letí vysoko → krekr
+        return False, 0.0, 0.0
+
+
+class LayupTask(Task):
+    """
+    Layup: agent přiběhne k obruči a vystřelí z pohybu.
+
+    Fáze:
+      1. Přiblížení k obruči (z 6 m na < 2 m) → reward: pohyb k obruči
+      2. Výskok + střelba → reward: ShootTask logika
+    """
+    name        = "layup"
+    terrain     = "flat"
+    max_steps   = 1200
+    reset_noise = 0.25
+
+    HOOP_POS = np.array([_HOOP_X, _HOOP_H, 0.0], dtype=np.float32)
+
+    def reset(self, body, world_env):
+        body.reset(vec3(-3.0, 2.0, 0.0))   # start 3 m před košem
+        hp = body.hand_pos("R")
+        self._ball      = _Ball(np.array([hp[0], hp[1], hp[2]], dtype=np.float32))
+        self._phase     = "approach"
+        self._scored    = False
+        self._bounces   = 0
+        agent_x = -3.0
+        self._prev_dist = float(np.sqrt((agent_x - _HOOP_X)**2 + _HOOP_H**2))
+
+    def step_reward(self, body, world_env, action):
+        dt   = 0.016
+        hp   = body.hand_pos("R")
+        hand = np.array([hp[0], hp[1], hp[2]], dtype=np.float32)
+        dist = float(np.linalg.norm(hand - self._ball.pos))
+
+        # Míč sleduje ruku v approach fázi (dribble pohyb)
+        if self._phase == "approach":
+            self._ball.pos = hand + np.array([0.0, -0.4, 0.0], dtype=np.float32)
+            # Vzdálenost od koše (X osa)
+            hoop_approach = max(0.0, (self._prev_dist - abs(hand[0] - _HOOP_X)) * 1.5)
+            self._prev_dist = abs(hand[0] - _HOOP_X)
+            # Přechod na střelbu: ruka blízko obruče
+            if hand[0] > (_HOOP_X - 1.8):
+                self._phase = "shoot"
+            alive = 0.03 if not body.is_fallen() else -2.0
+            return hoop_approach + alive
+
+        # Fáze střelby
+        if dist < _HAND_R and self._ball.vel[1] < 1.0:
+            shoot_vel = np.array([
+                action[6] * 2.0 + 1.5,
+                abs(action[7]) * 3.5 + 4.0,
+                action[8] * 0.3,
+            ], dtype=np.float32)
+            self._ball.vel = shoot_vel
+
+        self._ball.step(dt)
+
+        score_reward = 0.0
+        if not self._scored:
+            horiz_dist = float(np.sqrt(
+                (self._ball.pos[0] - _HOOP_X)**2 + self._ball.pos[2]**2
+            ))
+            if horiz_dist < _HOOP_R and abs(self._ball.pos[1] - _HOOP_H) < 0.3:
+                score_reward = 15.0
+                self._scored = True
+
+        height_reward = 0.3 if self._ball.pos[1] > 2.5 else 0.0
+        alive         = 0.02 if not body.is_fallen() else -2.0
+        action_pen    = float(np.mean(np.square(action))) * 0.002
+
+        return score_reward + height_reward + alive - action_pen
+
+    def success_condition(self, body, world_env) -> bool:
+        return self._scored
+
+    def food_event(self, body, world_env) -> tuple:
+        if self._scored:
+            return True, 1.2, 0.50
+        if self._phase == "shoot" and self._ball.pos[1] > 2.5:
+            return True, 0.10, 0.04
+        return False, 0.0, 0.0
+
+
+class BasketballTask(Task):
+    """
+    Kompletní basketbalová úloha: dribling → přesun → střelba.
+
+    Fáze:
+      1. dribble  — 20 odrazů míče
+      2. move     — přiblíž se k obruči
+      3. shoot    — vystřel na koš
+    """
+    name        = "basketball"
+    terrain     = "flat"
+    max_steps   = 2000
+    reset_noise = 0.20
+
+    HOOP_POS = np.array([_HOOP_X, _HOOP_H, 0.0], dtype=np.float32)
+
+    def reset(self, body, world_env):
+        body.reset(vec3(-2.0, 2.0, 0.0))
+        hp = body.hand_pos("R")
+        self._ball      = _Ball(np.array([hp[0], hp[1] - 0.4, hp[2]], dtype=np.float32))
+        self._phase     = "dribble"
+        self._bounces   = 0
+        self._contacts  = 0
+        self._scored    = False
+        self._last_bounce = 0
+        self._tick      = 0
+
+    def step_reward(self, body, world_env, action):
+        dt = 0.016
+        self._tick += 1
+
+        hp   = body.hand_pos("R")
+        hand = np.array([hp[0], hp[1], hp[2]], dtype=np.float32)
+        dist = float(np.linalg.norm(hand - self._ball.pos))
+
+        reward = 0.0
+
+        if self._phase == "dribble":
+            # Kontakt + dribble logika
+            if dist < _HAND_R:
+                grip = float(action[9])
+                if grip < -0.1:
+                    self._ball.apply_impulse(np.array([0.0, -4.0 * abs(grip), 0.0], dtype=np.float32))
+
+            prev_y = self._ball.pos[1]
+            self._ball.step(dt)
+
+            if prev_y > _DRIBBLE_H and self._ball.pos[1] <= _DRIBBLE_H + 0.02:
+                self._bounces += 1
+                reward += 1.5
+
+            if self._bounces >= 12:
+                self._phase = "move"
+                reward += 5.0   # bonus za dokončení dribble fáze
+
+        elif self._phase == "move":
+            # Míč sleduje ruku
+            self._ball.pos = hand + np.array([0.0, -0.3, 0.0], dtype=np.float32)
+            approach = max(0.0, (_HOOP_X - hand[0]) * 0.0)
+            hoop_x_dist = abs(hand[0] - _HOOP_X)
+            reward += max(0.0, (2.5 - hoop_x_dist) * 0.5)
+
+            if hoop_x_dist < 2.0:
+                self._phase = "shoot"
+                reward += 3.0
+
+        elif self._phase == "shoot":
+            if dist < _HAND_R and self._ball.vel[1] < 0.5:
+                self._ball.vel = np.array([
+                    action[6] * 2.5 + 1.8,
+                    abs(action[7]) * 4.0 + 3.8,
+                    action[8] * 0.3,
+                ], dtype=np.float32)
+
+            self._ball.step(dt)
+
+            if not self._scored:
+                horiz = float(np.sqrt(
+                    (self._ball.pos[0] - _HOOP_X)**2 + self._ball.pos[2]**2
+                ))
+                if horiz < _HOOP_R and abs(self._ball.pos[1] - _HOOP_H) < 0.35:
+                    self._scored = True
+                    reward += 20.0
+
+            if self._ball.pos[1] > 2.5:
+                reward += 0.3
+
+        alive      = 0.03 if not body.is_fallen() else -2.5
+        action_pen = float(np.mean(np.square(action))) * 0.002
+        return reward + alive - action_pen
+
+    def success_condition(self, body, world_env) -> bool:
+        return self._scored
+
+    def food_event(self, body, world_env) -> tuple:
+        if self._scored:
+            return True, 1.5, 0.60    # koš v plné hře = velký dumpling
+        if self._phase == "dribble" and self._ball.pos[1] <= _DRIBBLE_H + 0.05:
+            return True, 0.12, 0.05
+        if self._phase == "shoot" and self._ball.pos[1] > 2.5:
+            return True, 0.15, 0.06
+        return False, 0.0, 0.0

embodied/tasks/basketball_1v1.py

@@ -0,0 +1,284 @@
+# ┌─────────────────────────────────────────────────────────────────────────┐
+# │  SUBSYSTÉM: PhantomCortex Cognitive Neural Engine — Task Layer           │
+# │  Modul:     Basketball 1v1 (agent vs NPC) + Basketball Coop (s NPC)     │
+# │  Závislost: BasketballNPC (CharacterStudio) + Basketball fyzika          │
+# └─────────────────────────────────────────────────────────────────────────┘
+"""
+Basketball1v1Task  — agent vs AI protihráč (NPC opponent z CharacterStudio).
+BasketballCoopTask — agent + AI spoluhráč (NPC teammate) vs AI bránič.
+
+Observation rozšíření:
+  Standardní 28D body state + 4D NPC obs → agent "vidí" soupeře/spoluhráče.
+  PhantomCortex přijme 28D (city_obs override pro rozšíření stavu nepoužijeme —
+  NPC info vstupuje jako reward shaping a reward signal).
+
+Reward 1v1:
+  +15 za koš agenta
+  -10 za koš NPC (soupeř dal koš)
+  -5  za ukradení míče NPC
+  +3  za úspěšný výstřel i bez koše (výška oblouku)
+  +alive 0.02/step
+
+Reward Coop:
+  +15 za koš agenta
+  +8  za koš spoluhráče NPC (agent ho vedl do pozice)
+  -10 za koš nepřítele
+  +0.5 za přiblížení spoluhráče k obruči
+"""
+from __future__ import annotations
+
+import math
+import numpy as np
+from .base import Task
+
+import sys, os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../..'))
+from engine.physics.rigid_body import vec3
+
+from .basketball import _Ball, _HOOP_X, _HOOP_H, _HOOP_R, _DRIBBLE_H, _HAND_R
+from .basketball_npc import BasketballNPC
+
+
+class Basketball1v1Task(Task):
+    """
+    1v1: Agent (PhantomCortex) vs NPC protihráč (CharacterStudio).
+
+    NPC se vygeneruje z kategorie 'basketball_player' s behavior_tags: defend, steal.
+    Každá epizoda dostane nového NPC (různý seed → různé dovednosti).
+    """
+    name        = "basketball_1v1"
+    terrain     = "flat"
+    max_steps   = 1800
+    reset_noise = 0.22
+
+    HOOP_POS = np.array([_HOOP_X, _HOOP_H, 0.0], dtype=np.float32)
+
+    def reset(self, body, world_env):
+        body.reset(vec3(-1.0, 2.0, 0.0))
+        hp = body.hand_pos("R")
+        self._ball       = _Ball(np.array([hp[0], hp[1] - 0.4, hp[2]], dtype=np.float32))
+        self._phase      = "dribble"
+        self._bounces    = 0
+        self._scored     = False
+        self._npc_scored = 0
+        self._tick       = 0
+        self._stole      = 0
+
+        # NPC s náhodným seedem → jiné dovednosti každou epizodu
+        npc_seed = int(world_env._tick * 7 + 13) if hasattr(world_env, "_tick") else 42
+        self._npc = BasketballNPC(role="opponent", seed=npc_seed % 100)
+
+    def step_reward(self, body, world_env, action: np.ndarray) -> float:
+        dt = 0.016
+        self._tick += 1
+
+        hp   = body.hand_pos("R")
+        hand = np.array([hp[0], hp[1], hp[2]], dtype=np.float32)
+        hand_2d = np.array([hp[0], 0.0, hp[2]], dtype=np.float32)
+        dist_hand_ball = float(np.linalg.norm(hand - self._ball.pos))
+        ball_held = dist_hand_ball < _HAND_R
+
+        reward = 0.0
+
+        # ── Fáze dribbling ────────────────────────────────────────────────
+        if self._phase == "dribble":
+            if ball_held:
+                grip = float(action[9])
+                if grip < -0.1:
+                    self._ball.apply_impulse(np.array([0.0, -4.0 * abs(grip), 0.0], np.float32))
+            prev_y = self._ball.pos[1]
+            self._ball.step(dt)
+            if prev_y > _DRIBBLE_H and self._ball.pos[1] <= _DRIBBLE_H + 0.02:
+                self._bounces += 1
+                reward += 0.8
+            if self._bounces >= 8:
+                self._phase = "move"
+                reward += 3.0
+
+        # ── Fáze pohyb ke koši ────────────────────────────────────────────
+        elif self._phase == "move":
+            self._ball.pos = hand + np.array([0.0, -0.3, 0.0], np.float32)
+            hoop_dist = abs(hand[0] - _HOOP_X)
+            reward += max(0.0, (3.0 - hoop_dist) * 0.3)
+            if hoop_dist < 2.5:
+                self._phase = "shoot"
+                reward += 2.0
+
+        # ── Fáze střelba ─────────────────────────────────────────────────
+        elif self._phase == "shoot":
+            if dist_hand_ball < _HAND_R and self._ball.vel[1] < 0.5:
+                self._ball.vel = np.array([
+                    action[6] * 2.5 + 1.8,
+                    abs(action[7]) * 4.0 + 3.8,
+                    action[8] * 0.3,
+                ], np.float32)
+            self._ball.step(dt)
+            if self._ball.pos[1] > 2.5:
+                reward += 0.3
+            if not self._scored:
+                horiz = float(np.sqrt(
+                    (self._ball.pos[0] - _HOOP_X)**2 + self._ball.pos[2]**2
+                ))
+                if horiz < _HOOP_R and abs(self._ball.pos[1] - _HOOP_H) < 0.35:
+                    self._scored = True
+                    reward += 15.0
+
+        # ── NPC update ────────────────────────────────────────────────────
+        agent_pos = np.array([hp[0], 1.0, hp[2]], np.float32)
+        npc_result = self._npc.step(agent_pos, self._ball.pos,
+                                    ball_held_by_agent=ball_held, dt=dt)
+
+        # NPC ukradl míč
+        if npc_result["stole"] and not self._scored:
+            self._stole += 1
+            reward -= 5.0
+            self._phase = "dribble"  # reset fáze
+            self._bounces = 0
+
+        # NPC dal koš
+        if npc_result["scored"]:
+            self._npc_scored += 1
+            reward -= 10.0
+
+        alive      = 0.02 if not body.is_fallen() else -2.0
+        action_pen = float(np.mean(np.square(action))) * 0.002
+        return float(reward + alive - action_pen)
+
+    def is_done(self, body, world_env) -> bool:
+        if body.is_fallen():
+            return True
+        if self._npc_scored >= 3:   # soupeř dal 3 koše → prohra
+            return True
+        return world_env._tick >= self.max_steps
+
+    def success_condition(self, body, world_env) -> bool:
+        return self._scored and self._npc_scored == 0
+
+    def get_npc_obs(self) -> np.ndarray:
+        """4D NPC pozorování pro rozšíření stavu (volitelné)."""
+        return self._npc.get_obs() if hasattr(self, "_npc") else np.zeros(4, np.float32)
+
+
+class BasketballCoopTask(Task):
+    """
+    Kooperativní basketbal: agent + NPC spoluhráč vs NPC bránič.
+
+    Agent zodpovídá za dribling + střelbu.
+    Spoluhráč NPC běží na volnou pozici a sám může dát koš pokud dostane příležitost.
+    Bránič NPC se snaží zablokovat agenta.
+    """
+    name        = "basketball_coop"
+    terrain     = "flat"
+    max_steps   = 2000
+    reset_noise = 0.22
+
+    HOOP_POS = np.array([_HOOP_X, _HOOP_H, 0.0], dtype=np.float32)
+
+    def reset(self, body, world_env):
+        body.reset(vec3(-2.0, 2.0, 0.0))
+        hp = body.hand_pos("R")
+        self._ball       = _Ball(np.array([hp[0], hp[1] - 0.35, hp[2]], np.float32))
+        self._phase      = "dribble"
+        self._bounces    = 0
+        self._agent_scored = False
+        self._npc_scored   = 0
+        self._enemy_scored = 0
+        self._tick         = 0
+
+        seed = getattr(world_env, "_tick", 0) % 200
+        self._teammate = BasketballNPC(role="teammate", seed=seed)
+        self._opponent = BasketballNPC(role="opponent", seed=seed + 50,
+                                       skill_override={"defense": 0.55, "agility": 0.60})
+
+    def step_reward(self, body, world_env, action: np.ndarray) -> float:
+        dt = 0.016
+        self._tick += 1
+
+        hp   = body.hand_pos("R")
+        hand = np.array([hp[0], hp[1], hp[2]], np.float32)
+        dist_hand_ball = float(np.linalg.norm(hand - self._ball.pos))
+        ball_held = dist_hand_ball < _HAND_R
+
+        reward = 0.0
+
+        # ── Dribbling ─────────────────────────────────────────────────────
+        if self._phase == "dribble":
+            if ball_held and float(action[9]) < -0.1:
+                self._ball.apply_impulse(np.array([0.0, -4.0 * abs(float(action[9])), 0.0], np.float32))
+            prev_y = self._ball.pos[1]
+            self._ball.step(dt)
+            if prev_y > _DRIBBLE_H and self._ball.pos[1] <= _DRIBBLE_H + 0.02:
+                self._bounces += 1
+                reward += 0.5
+            if self._bounces >= 10:
+                self._phase = "move"
+                reward += 2.0
+
+        # ── Pohyb ─────────────────────────────────────────────────────────
+        elif self._phase == "move":
+            self._ball.pos = hand + np.array([0.0, -0.3, 0.0], np.float32)
+            hoop_dist = abs(hand[0] - _HOOP_X)
+            reward += max(0.0, (3.0 - hoop_dist) * 0.25)
+            if hoop_dist < 2.5:
+                self._phase = "shoot"
+
+        # ── Střelba ───────────────────────────────────────────────────────
+        elif self._phase == "shoot":
+            if dist_hand_ball < _HAND_R and self._ball.vel[1] < 0.5:
+                self._ball.vel = np.array([
+                    action[6] * 2.5 + 1.8,
+                    abs(action[7]) * 4.0 + 3.8,
+                    action[8] * 0.3,
+                ], np.float32)
+            self._ball.step(dt)
+            if self._ball.pos[1] > 2.5:
+                reward += 0.2
+            if not self._agent_scored:
+                horiz = float(np.sqrt(
+                    (self._ball.pos[0] - _HOOP_X)**2 + self._ball.pos[2]**2
+                ))
+                if horiz < _HOOP_R and abs(self._ball.pos[1] - _HOOP_H) < 0.35:
+                    self._agent_scored = True
+                    reward += 15.0
+
+        # ── NPC update ────────────────────────────────────────────────────
+        agent_pos_3d = np.array([hp[0], 1.0, hp[2]], np.float32)
+
+        # Spoluhráč
+        tm_result = self._teammate.step(agent_pos_3d, self._ball.pos,
+                                        ball_held_by_agent=ball_held, dt=dt)
+        if tm_result["scored"]:
+            self._npc_scored += 1
+            reward += 8.0   # spoluhráčův koš = bonus pro agenta
+
+        # Bonus za vedení spoluhráče do dobré pozice
+        tm_pos = tm_result["pos"]
+        tm_hoop_dist = math.hypot(float(tm_pos[0]) - _HOOP_X, float(tm_pos[2]))
+        if tm_hoop_dist < 3.0 and tm_result["mode"] == "OPEN_RUN":
+            reward += 0.5
+
+        # Soupeř
+        opp_result = self._opponent.step(agent_pos_3d, self._ball.pos,
+                                         ball_held_by_agent=ball_held, dt=dt)
+        if opp_result["stole"]:
+            reward -= 5.0
+            self._phase = "dribble"
+            self._bounces = 0
+        if opp_result["scored"]:
+            self._enemy_scored += 1
+            reward -= 10.0
+
+        alive      = 0.02 if not body.is_fallen() else -2.0
+        action_pen = float(np.mean(np.square(action))) * 0.002
+        return float(reward + alive - action_pen)
+
+    def is_done(self, body, world_env) -> bool:
+        if body.is_fallen():
+            return True
+        if self._enemy_scored >= 3:
+            return True
+        return world_env._tick >= self.max_steps
+
+    def success_condition(self, body, world_env) -> bool:
+        total_scored = int(self._agent_scored) + self._npc_scored
+        return total_scored >= 2 and self._enemy_scored == 0

embodied/tasks/basketball_npc.py

@@ -0,0 +1,287 @@
+# ┌─────────────────────────────────────────────────────────────────────────┐
+# │  SUBSYSTÉM: VoxForge 3D Voxel Engine — Character Studio + NPC AI        │
+# │  Modul:     Basketball NPC (protihráč / spoluhráč)                      │
+# │  Závislost: CharacterStudio blueprint → PhantomCortex Task Layer         │
+# └─────────────────────────────────────────────────────────────────────────┘
+"""
+BasketballNPC — AI hráč generovaný přes VoxForge Character Studio.
+
+Kategorie "basketball_player" (registrovaná v CharacterStudio):
+  skills: shooting, defense, agility, stamina
+  behavior_tags: dribble, defend, shoot, rebound
+
+Dva módy:
+  role="opponent"  — brání obruč, snaží se ukrást míč
+  role="teammate"  — přibíhá za otevřenou pozicí, signalizuje nahrávku
+
+NPC fyzika (zjednodušená — bez VirtualBody rigidní fyziky):
+  - Pozice (x, z) na hřišti, pohybuje se po ploše
+  - State machine: IDLE → DEFEND → CHASE → SHOOT → REBOUND
+  - Detekce dosahu míče (steal radius) a košového dosahu (shoot radius)
+"""
+from __future__ import annotations
+
+import math
+import random
+from dataclasses import dataclass, field
+from typing import Optional, Tuple
+
+import numpy as np
+
+import sys, os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../..'))
+
+from engine.character_studio.studio import CharacterStudio, CharacterStudioConfig
+from engine.character_studio.categories import (
+    CharacterCategory,
+    register_custom_character_category,
+)
+
+# ── Registrace basketball kategorie v CharacterStudio ─────────────────────
+
+_BASKETBALL_CATEGORY = CharacterCategory(
+    category_id    = "basketball_player",
+    name           = "Basketball Player",
+    description    = "Athletic MPC for basketball court — can defend, shoot and rebound.",
+    default_species= "humans",
+    default_district="sports_district",
+    behavior_tags  = ("dribble", "defend", "shoot", "rebound", "teamplay"),
+    skill_bias     = {
+        "shooting":   0.72,
+        "defense":    0.68,
+        "agility":    0.80,
+        "stamina":    0.75,
+        "teamplay":   0.65,
+    },
+    schedule       = ("warmup", "play", "halftime", "play", "cooldown"),
+    city_category_affinity=("classic_city", "cybercity"),
+    equipment_tags = ("basketball_shoes", "jersey"),
+    custom         = True,
+)
+
+
+def _ensure_category_registered():
+    """Zaregistruj basketball kategorii při prvním importu."""
+    try:
+        register_custom_character_category(_BASKETBALL_CATEGORY)
+    except Exception:
+        pass  # Může být již zaregistrována
+
+
+_ensure_category_registered()
+
+
+# ── NPC konstanty ─────────────────────────────────────────────────────────
+
+_COURT_X_MIN, _COURT_X_MAX =  0.0, 14.0   # šířka hřiště [m]
+_COURT_Z_MIN, _COURT_Z_MAX = -7.5,  7.5   # hloubka hřiště [m]
+_HOOP_X    = 4.0    # X pozice obruče (koš agenta)
+_HOOP_Z    = 0.0
+_NPC_HOOP_X= -4.0   # NPC koš (na opačné straně)
+
+_STEAL_RADIUS  = 0.6   # m — dosah ukradení míče
+_SHOOT_RADIUS  = 3.5   # m — dosah střelby
+_DEFEND_DIST   = 2.0   # m — vzdálenost obrany (mezi agentem a košem)
+
+
+@dataclass
+class NPCState:
+    x: float          = 6.0    # pozice X na hřišti
+    z: float          = 0.0    # pozice Z
+    vx: float         = 0.0
+    vz: float         = 0.0
+    mode: str         = "DEFEND"   # IDLE | DEFEND | CHASE | SHOOT | REBOUND
+    stamina: float    = 1.0
+    shoot_cooldown: int = 0
+    shoot_success_prob: float = 0.45
+
+
+class BasketballNPC:
+    """
+    AI basketbalový hráč vygenerovaný z CharacterStudio blueprintu.
+
+    Args:
+      role:    "opponent" nebo "teammate"
+      seed:    seed pro RNG
+      skill_override: dict přepíše dovednosti z blueprintu
+    """
+
+    def __init__(self, role: str = "opponent", seed: int = 0,
+                 skill_override: Optional[dict] = None):
+        self.role = role
+        self.rng  = random.Random(seed)
+        self.np_rng = np.random.default_rng(seed)
+
+        # Vygeneruj blueprint přes CharacterStudio
+        studio    = CharacterStudio(CharacterStudioConfig(seed=seed))
+        self.blueprint = studio.create_mpc(
+            "basketball_player",
+            display_name=f"NPC-{role.upper()}-{seed:03d}",
+            custom_data={"role": role},
+        )
+
+        # Dovednosti z blueprintu
+        skills = dict(self.blueprint.skills)
+        if skill_override:
+            skills.update(skill_override)
+        self.shooting  = float(skills.get("shooting",  0.60))
+        self.defense   = float(skills.get("defense",   0.60))
+        self.agility   = float(skills.get("agility",   0.70))
+        self.stamina_max = float(skills.get("stamina", 0.75))
+
+        # Fyzický stav
+        start_x = 8.0 if role == "opponent" else 2.0
+        self.state = NPCState(
+            x=start_x, z=0.0,
+            shoot_success_prob=0.25 + self.shooting * 0.5,
+        )
+        self.max_speed = 2.5 + self.agility * 2.5  # m/step @ 16ms → ~1.5–4 m/s
+
+    # ── Hlavní update krok ────────────────────────────────────────────────
+
+    def step(self, agent_pos: np.ndarray, ball_pos: np.ndarray,
+             ball_held_by_agent: bool, dt: float = 0.016) -> dict:
+        """
+        Jeden simulační krok NPC.
+
+        Args:
+          agent_pos:        [x, y, z] agenta
+          ball_pos:         [x, y, z] míče
+          ball_held_by_agent: True pokud agent drží míč
+          dt:               krok simulace [s]
+
+        Returns:
+          dict s: pos, mode, stole_ball, scored
+        """
+        s     = self.state
+        ax, az = float(agent_pos[0]), float(agent_pos[2])
+        bx, bz = float(ball_pos[0]),  float(ball_pos[2])
+
+        stole  = False
+        scored = False
+
+        if s.shoot_cooldown > 0:
+            s.shoot_cooldown -= 1
+
+        # Stamina odpadá pomalu
+        s.stamina = max(0.2, s.stamina - 0.0001)
+
+        # ── Stavový automat ───────────────────────────────────────────────
+        if self.role == "opponent":
+            stole, scored = self._opponent_step(ax, az, bx, bz, ball_held_by_agent, dt)
+        else:
+            stole, scored = self._teammate_step(ax, az, bx, bz, ball_held_by_agent, dt)
+
+        # Ohraničení hřiště
+        s.x = max(_COURT_X_MIN, min(_COURT_X_MAX, s.x))
+        s.z = max(_COURT_Z_MIN, min(_COURT_Z_MAX, s.z))
+
+        return {
+            "pos":   np.array([s.x, 1.0, s.z], dtype=np.float32),
+            "mode":  s.mode,
+            "stole": stole,
+            "scored": scored,
+        }
+
+    # ── Protihráč AI ──────────────────────────────────────────────────────
+
+    def _opponent_step(self, ax, az, bx, bz, ball_held: bool, dt: float):
+        s = self.state
+        stole = scored = False
+
+        dist_to_ball  = math.hypot(s.x - bx, s.z - bz)
+        dist_to_agent = math.hypot(s.x - ax, s.z - az)
+
+        if ball_held:
+            # Bran agenta: jdi mezi agenta a koš
+            mid_x = (ax + _HOOP_X) / 2.0
+            mid_z = az * 0.6
+            s.mode = "DEFEND"
+            self._move_toward(mid_x, mid_z, dt, speed_frac=0.85)
+
+            # Pokus ukrást míč
+            if dist_to_agent < _STEAL_RADIUS:
+                steal_chance = self.defense * 0.15 * s.stamina
+                if self.rng.random() < steal_chance:
+                    stole = True
+                    s.mode = "SHOOT"
+        else:
+            # Míč volný → chase
+            if dist_to_ball < _SHOOT_RADIUS and s.shoot_cooldown == 0:
+                s.mode = "SHOOT"
+                scored = self._attempt_shot()
+                s.shoot_cooldown = 45
+            else:
+                s.mode = "CHASE"
+                self._move_toward(bx, bz, dt, speed_frac=1.0)
+
+        return stole, scored
+
+    # ── Spoluhráč AI ──────────────────────────────────────────────────────
+
+    def _teammate_step(self, ax, az, bx, bz, ball_held: bool, dt: float):
+        s = self.state
+        stole = scored = False
+
+        dist_to_hoop = math.hypot(s.x - _HOOP_X, s.z - _HOOP_Z)
+
+        if ball_held:
+            # Agent drží → běžím na otevřenou pozici u koše
+            open_x = _HOOP_X - 1.5 + self.rng.uniform(-0.5, 0.5)
+            open_z = self.rng.uniform(-1.5, 1.5)
+            s.mode = "OPEN_RUN"
+            self._move_toward(open_x, open_z, dt, speed_frac=0.9)
+        else:
+            # Míč volný → pomoz agentovi
+            if dist_to_hoop < _SHOOT_RADIUS and s.shoot_cooldown == 0:
+                s.mode = "SHOOT"
+                scored = self._attempt_shot()
+                s.shoot_cooldown = 60
+            else:
+                s.mode = "REBOUND"
+                self._move_toward(bx, bz, dt, speed_frac=0.75)
+
+        return stole, scored
+
+    # ── Pohyb ─────────────────────────────────────────────────────────────
+
+    def _move_toward(self, tx: float, tz: float, dt: float, speed_frac: float = 1.0):
+        s   = self.state
+        dx  = tx - s.x
+        dz  = tz - s.z
+        dist = math.hypot(dx, dz)
+        if dist < 0.05:
+            return
+        speed = self.max_speed * speed_frac * s.stamina * dt
+        step  = min(speed, dist)
+        s.x  += (dx / dist) * step
+        s.z  += (dz / dist) * step
+
+    # ── Střelba ───────────────────────────────────────────────────────────
+
+    def _attempt_shot(self) -> bool:
+        dist_to_hoop = math.hypot(self.state.x - _HOOP_X, self.state.z - _HOOP_Z)
+        dist_factor  = max(0.0, 1.0 - dist_to_hoop / (_SHOOT_RADIUS * 1.5))
+        prob = self.state.shoot_success_prob * dist_factor * self.state.stamina
+        return self.rng.random() < prob
+
+    # ── Diagnostika ───────────────────────────────────────────────────────
+
+    def get_obs(self) -> np.ndarray:
+        """4D pozorování NPC pro agenta: [rel_x, rel_z, mode_enc, stamina]."""
+        mode_enc = {"IDLE": 0.0, "DEFEND": 0.25, "CHASE": 0.5,
+                    "SHOOT": 0.75, "REBOUND": 1.0, "OPEN_RUN": 0.6}.get(
+            self.state.mode, 0.0)
+        return np.array([
+            self.state.x / 14.0,      # norm. X pozice
+            self.state.z / 7.5,       # norm. Z pozice
+            mode_enc,                 # mód NPC
+            self.state.stamina,       # únava
+        ], dtype=np.float32)
+
+    def reset(self):
+        start_x = 8.0 if self.role == "opponent" else 2.0
+        self.state = NPCState(
+            x=start_x, z=0.0,
+            shoot_success_prob=0.25 + self.shooting * 0.5,
+        )

embodied/tasks/drive_city.py

@@ -0,0 +1,413 @@
+"""
+DriveCity — RL task pro jízdu hypercar v městském prostředí.
+
+Mapa: Procedurálně generovaná síť 110 km silnic (CityGenerator):
+  - Centrum: hustá síť 68 km ulic (50–70 km/h), 21 semaforů, 5 kruháčů
+  - Boulevard ring: okružní třída 26 km (70 km/h)
+  - Dálnice D1: 9 km (130 km/h), nájezdy/výjezdy, mýtnice
+  - Tunely: 3 podzemní úseky (80 km/h)
+  - Trasa: 23 km přes 28 waypointů
+
+Odměnová funkce:
+  +progress_reward : postup po trase (per-krok)
+  +waypoint_bonus  : dosažení průjezdního bodu (+5.0)
+  +speed_reward    : udržování cílové rychlosti v dané zóně
+  +tunnel_bonus    : průjezd tunelem bez incidentu (+3.0)
+  +speed_bump_regen: EM tlumiče rekuperují energii z nárazu na retardér
+  -off_road_pen    : uzávěrka / mimo vozovku
+  -red_light_pen   : průjezd na červenou (-8.0)
+  -crash_pen       : havárie / převrácení (-20.0)
+  +traffic_flow   : plynulé projíždění provozu bez kolizí
+  -traffic_crash  : náraz do vozidla provozu (-25.0 až -40.0 dle rychlosti)
+"""
+from __future__ import annotations
+
+import math
+import random
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple
+
+import numpy as np
+
+from embodied.tasks.base import Task
+from embodied.vehicle_body import VehicleBody
+from engine.city_builder.traffic import IntersectionNetwork, TrafficLight
+from engine.city_builder.city_gen import CityGenerator, build_traffic_network, build_long_route
+from engine.city_builder.road_network import RoadNetwork
+from engine.city_builder.traffic_sim import TrafficSimulation
+
+
+# ── Definice trasy ────────────────────────────────────────────────────────────
+
+@dataclass
+class Waypoint:
+    x: float
+    z: float
+    speed_limit_kmh: float = 80.0
+    is_intersection: bool = False
+    light_id: Optional[str] = None
+    road_width_m: float = 7.0
+    label: str = ""
+
+    def dist_to(self, x: float, z: float) -> float:
+        return math.sqrt((self.x - x) ** 2 + (self.z - z) ** 2)
+
+
+def _build_city_route(road_net: Optional[RoadNetwork] = None) -> List[Waypoint]:
+    """23 km trasa přes celou síť — 28 waypointů."""
+    if road_net is not None:
+        raw = build_long_route(road_net)
+    else:
+        raw = build_long_route(CityGenerator(seed=42).generate())
+    return [
+        Waypoint(
+            x=wp["x"], z=wp["z"],
+            speed_limit_kmh=wp["speed_limit_kmh"],
+            is_intersection=wp["is_intersection"],
+            light_id=wp["light_id"],
+            road_width_m=wp["road_width_m"],
+            label=wp["label"],
+        )
+        for wp in raw
+    ]
+
+
+# ── Uzávěry dopravy ───────────────────────────────────────────────────────────
+
+@dataclass
+class RoadClosure:
+    x: float
+    z: float
+    radius_m: float = 12.0
+    label: str = ""
+    active: bool = True
+
+    def blocks(self, x: float, z: float) -> bool:
+        return self.active and math.sqrt((x - self.x) ** 2 + (z - self.z) ** 2) < self.radius_m
+
+
+def _random_closures(route: List[Waypoint], rng: random.Random,
+                     road_net: Optional[RoadNetwork] = None) -> List[RoadClosure]:
+    """Uzávěrky: 2–4 z trasy + navíc ze silniční sítě (pokud dostupná)."""
+    candidates = route[2:-2]
+    k = min(rng.randint(2, 4), len(candidates))
+    chosen = rng.sample(candidates, k=k)
+    closures = [RoadClosure(wp.x + rng.uniform(-15, 15), wp.z + rng.uniform(-15, 15),
+                            radius_m=10.0, label=f"closure_{wp.label}") for wp in chosen]
+    # Přidej uzávěry z road_network (předem generované)
+    if road_net:
+        for seg in road_net.segments.values():
+            if "closure" in seg.features:
+                mx, mz = seg.midpoint()
+                closures.append(RoadClosure(mx, mz, radius_m=12.0, label=f"closure_{seg.seg_id}"))
+    return closures
+
+
+# ── Pomocné funkce ────────────────────────────────────────────────────────────
+
+def _heading_to_waypoint(px: float, pz: float, wp: Waypoint) -> float:
+    """Úhel (rad) od aktuální pozice k cílovému bodu."""
+    return math.atan2(wp.z - pz, wp.x - px)
+
+
+def _angular_error(heading: float, target_heading: float) -> float:
+    """Normalizovaná úhlová odchylka v [-π, π]."""
+    err = (target_heading - heading) % (2 * math.pi)
+    if err > math.pi:
+        err -= 2 * math.pi
+    return err
+
+
+# ── DriveCity Task ────────────────────────────────────────────────────────────
+
+class DriveCity(Task):
+    """
+    Tréninkový task pro jízdu hypercar v městském prostředí.
+
+    Observation (ze strany rl_loop.py):
+        Mimo standardní body_state[73] rl_loop předá DriveCity jako
+        external_task_obs: 18D telemetrie VehicleBody + 8D city context.
+        Celkem 26D → přidáno do goal_vec jako extended obs.
+    """
+
+    name       = "drive_city"
+    terrain    = "city"
+    max_steps  = 3000
+    reset_noise: float = 0.15
+
+    WAYPOINT_RADIUS     = 22.0
+    OFF_ROAD_PENALTY    = -5.0
+    RED_LIGHT_PENALTY   = -8.0
+    CRASH_PENALTY       = -20.0
+    WAYPOINT_BONUS      = 5.0
+    ALIVE_BONUS         = 0.05
+    REGEN_SCALE         = 0.002
+    PROGRESS_SCALE      = 0.04
+    SPEED_REWARD_SCALE  = 0.015
+
+    def __init__(self, seed: int = 0, city_seed: int = 42,
+                 traffic_density: float = 1.0):
+        self._rng        = random.Random(seed)
+        self._road_net   = CityGenerator(seed=city_seed, closure_count=6).generate()
+        self._route      = _build_city_route(self._road_net)
+        self._network    = build_traffic_network(self._road_net)
+        self._traffic    = TrafficSimulation(
+            self._road_net, density_scale=traffic_density, seed=seed, max_cars=120)
+        self._traffic.set_traffic_lights(self._network)
+        self._closures: List[RoadClosure] = []
+        self._wp_idx     = 0
+        self._sim_time   = 0.0
+        self._vehicle    = VehicleBody.phantom_vertex()
+        self._last_dist  = 0.0
+        self._done       = False
+        self._success    = False
+        self._episode_regen = 0.0
+        self._in_tunnel  = False
+        self._traffic_collisions = 0
+
+    # ── Task interface ────────────────────────────────────────────────────────
+
+    def reset(self, body, world_env) -> None:
+        start = self._route[0]
+        self._vehicle.reset(position=(start.x, 0.0, start.z), heading_rad=0.0)
+        self._wp_idx      = 1
+        self._sim_time    = 0.0
+        self._done        = False
+        self._success     = False
+        self._episode_regen = 0.0
+        self._closures    = _random_closures(self._route, self._rng, self._road_net)
+        self._in_tunnel   = False
+        self._last_dist   = self._route[1].dist_to(start.x, start.z)
+        self._traffic_collisions = 0
+        self._last_threat = None
+        self._last_rays   = None
+        self._traffic.reset()
+
+        # Reset semaforů — náhodný offset pro různorodost
+        for lt in self._network.lights.values():
+            lt.timer_s = self._rng.uniform(0.0, lt.cycle_s)
+
+        # Řidič: krátký burst dopředu → vozidlo nezačíná úplně stojí
+        self._vehicle.step(0.12, 0.0, 0.0)
+
+    def step_reward(self, body, world_env, action: np.ndarray) -> float:
+        """
+        Provede fyzikální krok vozidla a vrátí skalar odměny.
+
+        action[0] = throttle  (-1 až +1, kladné = plyn)
+        action[1] = brake     (0 až 1)
+        action[2] = steer     (-1 až +1)
+        """
+        throttle = float(np.clip(action[0], 0.0, 1.0))
+        brake    = float(np.clip(-min(action[0], 0.0), 0.0, 1.0))
+        steer    = float(np.clip(action[2] if len(action) > 2 else 0.0, -1.0, 1.0))
+
+        tel = self._vehicle.step(throttle, brake, steer)
+        self._sim_time += self._vehicle.DT
+
+        px, _, pz = self._vehicle.position()
+        reward = self.ALIVE_BONUS
+
+        # ── Postup k cílovému bodu ────────────────────────────────────────────
+        if self._wp_idx < len(self._route):
+            wp    = self._route[self._wp_idx]
+            dist  = wp.dist_to(px, pz)
+            progress = (self._last_dist - dist) * self.PROGRESS_SCALE
+            reward += max(-0.5, progress)
+            self._last_dist = dist
+
+            # Rychlostní zóna
+            target_speed = wp.speed_limit_kmh
+            speed_err = abs(tel.speed_kmh - target_speed) / max(target_speed, 1.0)
+            reward += self.SPEED_REWARD_SCALE * max(0.0, 1.0 - speed_err)
+
+            # Dosažení průjezdního bodu
+            if dist < self.WAYPOINT_RADIUS:
+                reward += self.WAYPOINT_BONUS
+                self._wp_idx += 1
+                if self._wp_idx >= len(self._route):
+                    self._success = True
+                    self._done = True
+                    reward += 50.0
+                else:
+                    self._last_dist = self._route[self._wp_idx].dist_to(px, pz)
+
+        # ── Semafory ──────────────────────────────────────────────────────────
+        self._network.step(self._sim_time, self._vehicle.DT)
+        wp_now = self._route[min(self._wp_idx, len(self._route) - 1)]
+        if wp_now.is_intersection and wp_now.light_id:
+            lt = self._network.lights.get(wp_now.light_id)
+            if lt:
+                dist_to_light = wp_now.dist_to(px, pz)
+                if dist_to_light < 18.0:
+                    direction = "NS" if abs(wp_now.z - pz) > abs(wp_now.x - px) else "EW"
+                    if not lt.allows(direction) and tel.speed_kmh > 8.0:
+                        reward += self.RED_LIGHT_PENALTY
+
+        # ── Uzávěry dopravy ───────────────────────────────────────────────────
+        for closure in self._closures:
+            if closure.blocks(px, pz):
+                reward += self.OFF_ROAD_PENALTY * 0.5
+
+        # ── Tunel ─────────────────────────────────────────────────────────────
+        seg = self._road_net.segment_at(px, pz)
+        if seg and seg.tunnel:
+            if not self._in_tunnel:
+                reward += 3.0               # bonus za vstup do tunelu bez incidentu
+                self._in_tunnel = True
+        else:
+            self._in_tunnel = False
+
+        # ── Retardéry — EM tlumiče HX-1 rekuperují energii z nárazu ─────────────
+        if seg and "speed_bump" in seg.features:
+            damper_regen = tel.speed_kmh * 0.0003
+            self._episode_regen += damper_regen * self._vehicle.DT / 3600.0
+            reward += damper_regen * 0.004
+
+        # ── Rekuperace ────────────────────────────────────────────────────────
+        regen = tel.regen_kw
+        self._episode_regen += regen * self._vehicle.DT / 3600.0
+        reward += regen * self.REGEN_SCALE
+
+        # ── Dopravní provoz — fyzika kolizí + TTC prevence ───────────────────
+        agent_heading  = self._vehicle.heading()
+        agent_speed_ms = tel.speed_kmh / 3.6
+        traffic_events = self._traffic.step(
+            self._vehicle.DT, px, pz, agent_speed_ms, agent_heading)
+        for ev in traffic_events:
+            self._traffic_collisions += 1
+            if ev.is_crash:
+                crash_pen = -25.0 - min(15.0, ev.delta_v_agent * 2.0)
+                reward += crash_pen
+                self._done = True
+            else:
+                reward -= 3.0
+
+        # TTC (time-to-collision) preventivní penalizace — trestá PŘED kolizí
+        threat = self._traffic.closest_threat_info(
+            px, pz, agent_speed_ms, agent_heading)
+        self._last_threat = threat
+        ttc_n   = threat["ttc_norm"]     # 0=bezpečno, 1=kolize za <1s
+        closing = threat["closing_norm"] # 0=stojí, 1=uzavírá 30 m/s
+        if ttc_n > 0.0 and closing > 0.0:
+            # Penalizace roste kvadraticky s blízkostí
+            reward -= ttc_n * ttc_n * closing * 4.0
+        # Odměna za udržení bezpečného odstupu (dist_norm blízko 1 = daleko)
+        elif threat["dist_norm"] > 0.5:
+            reward += 0.008
+
+        # ── Havárie (vlastní vozidlo) ─────────────────────────────────────────
+        if self._vehicle.is_crashed():
+            reward += self.CRASH_PENALTY
+            self._done = True
+
+        return float(reward)
+
+    def is_done(self, body, world_env) -> bool:
+        return self._done or world_env._tick >= self.max_steps
+
+    def success_condition(self, body, world_env) -> bool:
+        return self._success
+
+    # ── City context observation ──────────────────────────────────────────────
+
+    def city_obs(self) -> np.ndarray:
+        """
+        8D city context vektor pro rozšíření observation.
+
+        [0] vzdálenost k dalšímu WP (normalizovaná)
+        [1] úhlová odchylka k dalšímu WP (normalizovaná)
+        [2] limit rychlosti v aktuální zóně (normalizovaný)
+        [3] semafor: 1.0 = zelená, 0.5 = žlutá, 0.0 = červená
+        [4] uzávěra blízko (0/1)
+        [5] index WP / celkový počet WP (postup trasou)
+        [6] telemetrie battery_soc
+        [7] telemetrie supercap_soc
+        """
+        tel  = self._vehicle.state.telemetry
+        px, _, pz = self._vehicle.position()
+        heading   = self._vehicle.heading()
+        obs       = np.zeros(8, dtype=np.float32)
+        wp_count  = len(self._route)
+
+        if self._wp_idx < wp_count:
+            wp      = self._route[self._wp_idx]
+            dist    = wp.dist_to(px, pz)
+            t_head  = _heading_to_waypoint(px, pz, wp)
+            ang_err = _angular_error(heading, t_head)
+            obs[0]  = float(np.clip(dist / 200.0, 0.0, 1.0))
+            obs[1]  = float(ang_err / math.pi)
+            obs[2]  = wp.speed_limit_kmh / 130.0
+
+            light_val = 0.5
+            if wp.is_intersection and wp.light_id:
+                lt = self._network.lights.get(wp.light_id)
+                if lt:
+                    if lt.phase in ("NS_GREEN", "EW_GREEN"):
+                        light_val = 1.0
+                    elif lt.phase in ("NS_YELLOW", "EW_YELLOW"):
+                        light_val = 0.5
+                    else:
+                        light_val = 0.0
+            obs[3] = light_val
+
+        obs[4] = 1.0 if any(c.blocks(px, pz) for c in self._closures) else 0.0
+        obs[5] = float(self._wp_idx) / max(wp_count - 1, 1)
+        obs[6] = tel.battery_soc
+        obs[7] = self._traffic.traffic_density(px, pz, radius=60.0)
+        return obs
+
+    def vehicle_obs(self) -> np.ndarray:
+        """18D telemetrie VehicleBody."""
+        return np.array(self._vehicle.observation_vec(), dtype=np.float32)
+
+    def full_obs(self) -> np.ndarray:
+        """Kompletní 26D observation: 18D telemetrie + 8D city context."""
+        return np.concatenate([self.vehicle_obs(), self.city_obs()])
+
+    def get_task_state(self, body_state: np.ndarray) -> np.ndarray:
+        """
+        Přepíše body_state[0:36] telemetrií vozidla, city contextem, TTC infem a raycasts.
+        state[0:18]  = vehicle telemetrie
+        state[18:26] = city_obs (8D)
+        state[26]    = closest_threat dist_norm (1=daleko, 0=těsně vedle)
+        state[27]    = TTC norm (0=bezpečno, 1=kolize za <1s)
+        state[28:36] = 8D raycast echolokace (1=prázdno, 0=auto těsně vedle)
+        """
+        state = body_state.copy()
+        obs26 = self.full_obs()          # 18D vozidlo + 8D city
+        state[0:26] = obs26
+
+        # Dej agentovi explicitní info o nejbližší hrozbě
+        px, _, pz = self._vehicle.position()
+        threat = getattr(self, "_last_threat", None)
+        if threat is None:
+            tel = self._vehicle.state.telemetry
+            threat = self._traffic.closest_threat_info(
+                px, pz, tel.speed_kmh / 3.6, self._vehicle.heading())
+        state[26] = float(threat["dist_norm"])
+        state[27] = float(threat["ttc_norm"])
+
+        self._last_rays = None   # subclass DriveCity_Echo přepíše city_obs místo tohoto
+
+        return state
+
+    # ── Info / debug ──────────────────────────────────────────────────────────
+
+    def progress_info(self) -> Dict[str, object]:
+        tel = self._vehicle.state.telemetry
+        return {
+            "waypoint":      self._wp_idx,
+            "waypoints_total": len(self._route),
+            "speed_kmh":     round(tel.speed_kmh, 1),
+            "battery_soc":   round(tel.battery_soc, 3),
+            "supercap_soc":  round(tel.supercap_soc, 3),
+            "regen_kwh":     round(self._episode_regen, 4),
+            "drs_open":      tel.drs_open,
+            "rear_steer_deg": round(tel.rear_steer_deg, 2),
+            "drift_index":   round(tel.drift_index, 3),
+            "closures":      len(self._closures),
+            "success":       self._success,
+            "traffic_cars":  self._traffic.active_count,
+            "traffic_collisions": self._traffic_collisions,
+        }

embodied/tasks/drive_city_echo.py

@@ -0,0 +1,68 @@
+"""
+DriveCity_Echo — DriveCity s 8D raycast echolokací místo generických city_obs.
+
+city_obs layout (8D):
+  [0] dist k dalšímu WP        (zachováno — nutné pro navigaci)
+  [1] úhel k dalšímu WP        (zachováno)
+  [2] limit rychlosti           (zachováno)
+  [3] semafor                   (zachováno)
+  [4] raycast 0°  = přímo vpředu        (1=volno, 0=auto těsně)
+  [5] raycast 45° = vpředu vpravo
+  [6] raycast 315°= vpředu vlevo
+  [7] raycast 90° = přímo vpravo
+
+A/B srovnání:
+  drive_city       — closest_dist + TTC (1 hrozba, bez směru)
+  drive_city_echo  — 4 navigační + 4 raycasts (vidí KDE auta jsou)
+"""
+from __future__ import annotations
+import math
+import numpy as np
+from embodied.tasks.drive_city import DriveCity, _heading_to_waypoint, _angular_error
+
+
+class DriveCity_Echo(DriveCity):
+    """DriveCity kde city_obs[4:8] jsou 4 raycasts vpřed/vpravo/vlevo."""
+
+    name = "drive_city_echo"
+
+    def city_obs(self) -> np.ndarray:
+        """8D: 4D navigace (WP/limit/light) + 4D raycasts (vpřed, ±45°, vpravo)."""
+        tel  = self._vehicle.state.telemetry
+        px, _, pz = self._vehicle.position()
+        heading   = self._vehicle.heading()
+        obs       = np.zeros(8, dtype=np.float32)
+        wp_count  = len(self._route)
+
+        # ── Navigace (zachováno z DriveCity) ─────────────────────────────────
+        if self._wp_idx < wp_count:
+            wp      = self._route[self._wp_idx]
+            dist    = wp.dist_to(px, pz)
+            t_head  = _heading_to_waypoint(px, pz, wp)
+            ang_err = _angular_error(heading, t_head)
+            obs[0]  = float(np.clip(dist / 200.0, 0.0, 1.0))
+            obs[1]  = float(ang_err / math.pi)
+            obs[2]  = wp.speed_limit_kmh / 130.0
+
+            light_val = 0.5
+            if wp.is_intersection and wp.light_id:
+                lt = self._network.lights.get(wp.light_id)
+                if lt:
+                    if lt.phase in ("NS_GREEN", "EW_GREEN"):
+                        light_val = 1.0
+                    elif lt.phase in ("NS_YELLOW", "EW_YELLOW"):
+                        light_val = 0.5
+                    else:
+                        light_val = 0.0
+            obs[3] = light_val
+
+        # ── 4 raycasts: vpřed (0°), vpředvpravo (45°), vpředvlevo (315°), vpravo (90°) ──
+        all_rays = self._traffic.raycast_obs(px, pz, heading, max_dist=60.0, n_rays=8)
+        self._last_rays = all_rays
+        # all_rays[0]=0°, [1]=45°, [2]=90°, [3]=135°, [4]=180°, [5]=225°, [6]=270°, [7]=315°
+        obs[4] = all_rays[0]   # přímo vpředu
+        obs[5] = all_rays[1]   # vpředu vpravo (45°)
+        obs[6] = all_rays[7]   # vpředu vlevo (315°)
+        obs[7] = all_rays[2]   # přímo vpravo (90°)
+
+        return obs

embodied/tasks/drive_city_polaris.py

@@ -0,0 +1,107 @@
+# ┌─────────────────────────────────────────────────────────────────────────┐
+# │  SUBSYSTÉM: PhantomCortex Cognitive Neural Engine — Task Layer           │
+# │  Modul:     DriveCity_Polaris — jízda po městě s POLARIS koprocesorem   │
+# │  Fyzika:    PolarisServer existuje ve VoxForge světě (x=50, y=0.5, z=5) │
+# └─────────────────────────────────────────────────────────────────────────┘
+"""
+DriveCity_Polaris — identický task jako DriveCity, ale akce je blendovaná
+s POLARIS serverem nahrátým z předchozího drive checkpointu.
+
+Architektura:
+  RL agent (PhantomCortex)  → 75% akce
+  POLARIS server (distillace drive checkpointu) → 25% akce
+  ────────────────────────────────────────────────────────
+  blended_action = 0.75 * rl_action + 0.25 * polaris_action
+
+POLARIS se inicializuje z agent_drive_city.npz:
+  → bank_0: W1 drive checkpoint (co auto "vidí")
+  → bank_1: W_action drive checkpoint (jak řídí)
+  → bank_2: W1@W_action (přímá politika řízení)
+  → bank_3: W_disc (hodnotí situace na silnici)
+
+Server je fyzicky umístěn v mapě (x=50, y=0.5, z=5) — za centrem.
+POLARIS se online učí z každé RL akce (Hebbian, každé 4 kroky).
+"""
+from __future__ import annotations
+
+import logging
+import os, sys
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../..'))
+
+import numpy as np
+
+# Zdědíme celý DriveCity task (reward, waypoints, traffic, vše)
+from .drive_city import DriveCity
+
+log = logging.getLogger("phantom.embodied")
+
+_DRIVE_CKPT   = "checkpoints/agent_drive_city.npz"
+_POLARIS_BLEND = 0.25   # 25% POLARIS, 75% RL
+
+
+class DriveCity_Polaris(DriveCity):
+    """
+    DriveCity + POLARIS server koprocesor.
+
+    Server se inicializuje JEDNOU při prvním reset() — Hebbian learning
+    se akumuluje přes epizody (POLARIS se učí z každého průjezdu).
+    """
+    name = "drive_city_polaris"
+
+    polaris_server   = None
+    polaris_agent_id = "drive_polaris"
+    polaris_blend    = _POLARIS_BLEND
+    _polaris_ready   = False   # flag: server už byl inicializován
+
+    def reset(self, body, world_env):
+        super().reset(body, world_env)
+
+        # Server se inicializuje jen jednou — Hebbian learning přetrvává
+        if not self._polaris_ready:
+            self._init_polaris_server()
+            self._polaris_ready = True
+
+    def _init_polaris_server(self):
+        try:
+            from engine.hardware.polaris_server import PolarisServer
+            from engine.hardware.phantom_uploader import PhantomCortexUploader
+
+            srv = PolarisServer(
+                position=(50.0, 0.5, 5.0),
+                name="PolarisServer-DRIVE-01",
+                rng_seed=7777,
+            )
+
+            ckpt_path = _DRIVE_CKPT if os.path.exists(_DRIVE_CKPT) else "checkpoints/agent_latest.npz"
+            if os.path.exists(ckpt_path):
+                uploader = PhantomCortexUploader(ckpt_path)
+                uploader.upload_to_server(srv)
+                log.info(
+                    "[DriveCity_Polaris] POLARIS server INIT z %s  blend=%.0f%%  "
+                    "(přetrvává přes epizody — Hebbian akumulace)",
+                    os.path.basename(ckpt_path), _POLARIS_BLEND * 100
+                )
+            else:
+                log.warning("[DriveCity_Polaris] checkpoint nenalezen, POLARIS startuje náhodně")
+
+            srv.connect(self.polaris_agent_id, task_type="locomotion")
+            self.polaris_server = srv
+
+        except Exception as e:
+            log.warning("[DriveCity_Polaris] POLARIS init selhal (%s) — bez POLARIS", e)
+            self.polaris_server = None
+
+    def step_reward(self, body, world_env, action: np.ndarray) -> float:
+        # Standardní DriveCity reward (žádná změna)
+        reward = super().step_reward(body, world_env, action)
+
+        # Diagnostika serveru každých 200 kroků
+        if self.polaris_server is not None and world_env._tick % 200 == 0:
+            diag = self.polaris_server.diagnostics()
+            if diag.health != "ONLINE":
+                log.warning(
+                    "[POLARIS-DRIVE] Server health=%s  PWR=%.0fW  CLT=%.1f°C",
+                    diag.health, diag.total_power_w, diag.coolant["outlet_temp_c"]
+                )
+
+        return reward

embodied/tasks/household_ball.py

@@ -0,0 +1,66 @@
+"""
+BallTask — agent chytí míč a odvalí ho do cílové zóny.
+Odměna: přiblížení k míči + přiblížení míče k cíli + alive bonus.
+"""
+from __future__ import annotations
+import sys, os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../..'))
+
+import numpy as np
+from engine.physics.rigid_body import vec3, length
+from embodied.tasks.base import Task
+from embodied.interactive_objects import BallObject
+
+
+class BallTask(Task):
+    name      = "household_ball"
+    terrain   = "flat"
+    max_steps = 400
+    reset_noise: float = 0.25
+
+    TARGET_POS = vec3(2.0, 0.12, 0.0)   # cílová zóna
+
+    def __init__(self):
+        self._ball: BallObject = None
+        self._prev_ball_dist  = 0.0
+
+    def reset(self, body, world_env):
+        rng = np.random.default_rng(world_env._tick if hasattr(world_env, '_tick') else 0)
+        spawn = vec3(
+            float(rng.uniform(-0.3, 0.3)),
+            0.12,
+            float(rng.uniform(0.5, 1.0)),
+        )
+        self._ball = BallObject(world_env.phys, spawn, obj_id="task_ball")
+        self._prev_ball_dist = float(length(self._ball.position - self.TARGET_POS))
+        world_env._objects = getattr(world_env, "_objects", {})
+        world_env._objects["task_ball"] = self._ball
+
+    def step_reward(self, body, world_env, action) -> float:
+        if self._ball is None:
+            return 0.0
+
+        hand_R = body.hand_pos("R")
+        hand_dist  = float(length(self._ball.position - hand_R))
+        ball_dist  = float(length(self._ball.position - self.TARGET_POS))
+
+        approach_hand = max(0.0, 0.5 - hand_dist) * 0.4
+        approach_ball = (self._prev_ball_dist - ball_dist) * 3.0
+        proximity     = 0.30 if hand_dist < 0.25 else (0.10 if hand_dist < 0.6 else 0.0)
+        alive         = 0.05
+        action_pen    = float(np.mean(np.abs(action))) * 0.02
+
+        self._prev_ball_dist = ball_dist
+        return approach_hand + approach_ball + proximity + alive - action_pen
+
+    def is_done(self, body, world_env) -> bool:
+        if body.is_fallen():
+            return True
+        if self.success_condition(body, world_env):
+            return True
+        return world_env._tick >= self.max_steps
+
+    def success_condition(self, body, world_env) -> bool:
+        if self._ball is None:
+            return False
+        return float(length(self._ball.position - self.TARGET_POS)) < 0.30

embodied/tasks/household_door.py

@@ -0,0 +1,63 @@
+"""
+Household task: walk to the door, push/reach the handle, then step through.
+
+The door is in the south wall (z≈0) with a gap at x=13..17.
+Handle target: (15, 3, 1).  After touching the handle the door "opens" and
+the agent must move to z < -1 (outside the room).
+
+Phases:
+  1. Walk to door handle  (approach with hand_R)
+  2. Touch handle         (hand within 0.4m → door open flag)
+  3. Step through gap     (torso z < 0)
+"""
+from __future__ import annotations
+import numpy as np
+from .base import Task
+import sys, os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../..'))
+from engine.physics.rigid_body import vec3, length
+
+
+class HouseholdDoorTask(Task):
+    name      = "household_door"
+    terrain   = "household"
+    max_steps = 1000
+
+    HANDLE_POS = vec3(15.0, 3.0, 1.5)   # just inside south wall gap
+    OUTSIDE_Z  = -0.5                    # target z after passing through
+
+    def reset(self, body, world_env):
+        body.reset(vec3(8.0, 2.0, 6.0))
+        self._door_open       = False
+        self._prev_handle_dist = self._handle_dist(body)
+        self._prev_torso_z    = float(body.torso_pos()[2])
+
+    def _handle_dist(self, body) -> float:
+        return float(length(body.hand_pos("R") - self.HANDLE_POS))
+
+    def step_reward(self, body, world_env, action):
+        alive      = 0.03 if not body.is_fallen() else -2.0
+        action_pen = float(np.mean(np.square(action))) * 0.003
+
+        if not self._door_open:
+            dist     = self._handle_dist(body)
+            approach = (self._prev_handle_dist - dist) * 5.0
+            self._prev_handle_dist = dist
+            # Dense gradient from any distance — beats alive at every range
+            if   dist < 0.40: proximity = 2.0
+            elif dist < 1.50: proximity = 0.7
+            elif dist < 4.00: proximity = 0.20
+            elif dist < 8.00: proximity = 0.06
+            else:             proximity = 0.02
+            if dist < 0.4:
+                self._door_open = True
+                return approach + proximity + 8.0 + alive - action_pen
+            return approach + proximity + alive - action_pen
+        else:
+            tz       = float(body.torso_pos()[2])
+            progress = (self._prev_torso_z - tz) * 4.0
+            self._prev_torso_z = tz
+            return progress + 0.5 + alive - action_pen
+
+    def success_condition(self, body, world_env):
+        return self._door_open and float(body.torso_pos()[2]) < self.OUTSIDE_Z

embodied/tasks/household_pick.py

@@ -0,0 +1,99 @@
+"""
+Household task: pick a cup off the table and carry it to the kitchen counter.
+
+Phases:
+  1. Approach cup   — reward: Δ(distance hand_R → cup)
+  2. Grasp cup      — reward: holding bonus per step
+  3. Carry to target — reward: Δ(distance cup → counter target)
+"""
+from __future__ import annotations
+import numpy as np
+from .base import Task
+import sys, os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../..'))
+from engine.physics.rigid_body import vec3, length
+
+
+class HouseholdPickTask(Task):
+    name        = "household_pick"
+    terrain     = "household"
+    max_steps   = 1200
+    reset_noise = 0.30   # higher exploration for manipulation
+
+    # Cup: on table (surface y=3, table at x=10-14, z=14-18)
+    CUP_POS    = vec3(12.0, 3.5, 16.0)
+    # Target: on counter — blíže než dříve pro snazší curriculum
+    TARGET_POS = vec3(14.0, 3.5, 19.0)
+
+    def reset(self, body, world_env):
+        # Spawn blíže k hrnku (bylo 12m daleko, nyní ~1.5m)
+        body.reset(vec3(10.5, 2.0, 15.5))
+        # Add cup as interactive object (re-adds each episode via fresh world)
+        world_env.add_interactive_object(
+            "cup", "cup", self.CUP_POS,
+            size=vec3(0.08, 0.14, 0.08), mass=0.3,
+        )
+        self._prev_hand_dist   = self._hand_dist(body, world_env)
+        self._prev_target_dist = float(length(self.CUP_POS - self.TARGET_POS))
+        self._holding_steps    = 0
+
+    def _hand_dist(self, body, world_env) -> float:
+        hp = body.hand_pos("R")
+        cp = world_env.get_object_pos("cup")
+        return float(length(hp - cp))
+
+    def step_reward(self, body, world_env, action):
+        hand_id = "hand_R"
+        grip    = float(action[9])
+        hp      = body.hand_pos("R")
+
+        # Update grasp state
+        world_env.check_grasp(hand_id, hp, grip)
+        hand_vel  = body.bodies[hand_id].velocity
+        world_env.update_grasped(
+            {hand_id: hp},
+            {hand_id: hand_vel},
+        )
+
+        alive      = 0.04 if not body.is_fallen() else -2.0
+        action_pen = float(np.mean(np.square(action))) * 0.003
+
+        if world_env.is_broken("cup"):
+            return -5.0 + alive - action_pen
+
+        if world_env.is_grasped("cup"):
+            self._holding_steps += 1
+            cup_pos    = world_env.get_object_pos("cup")
+            tgt_dist   = float(length(cup_pos - self.TARGET_POS))
+            carry_prog = (self._prev_target_dist - tgt_dist) * 8.0
+            holding    = 1.5   # zvýšeno z 1.0: silnější signál pro udržení uchopení
+            self._prev_target_dist = tgt_dist
+            return carry_prog + holding + alive - action_pen
+        else:
+            hand_dist    = self._hand_dist(body, world_env)
+            approach     = (self._prev_hand_dist - hand_dist) * 6.0
+            self._prev_hand_dist = hand_dist
+            # Dense proximity gradient — any range beats alive-only
+            if   hand_dist < 0.25: proximity = 2.0
+            elif hand_dist < 0.60: proximity = 0.8
+            elif hand_dist < 1.50: proximity = 0.25
+            elif hand_dist < 3.50: proximity = 0.08
+            else:                  proximity = 0.02
+            # Pre-grasp bonus: ruka blízko + zavřená → +3.0 jednorázově (klíčový signál!)
+            pre_grasp = 3.0 if (hand_dist < 0.35 and grip < -0.25) else 0.0
+            return approach + proximity + pre_grasp + alive - action_pen
+
+    def food_event(self, body, world_env) -> tuple:
+        """KFP: uchopení hrníčku = dumpling — přímá metabolická odměna."""
+        if world_env.is_grasped("cup"):
+            return True, 0.40, 0.20   # drží hrníček → velký dumpling
+        hand_dist = self._hand_dist(body, world_env)
+        if hand_dist < 0.35:
+            return True, 0.08, 0.03   # ruka blízko → krekr (zárodek motivace)
+        return False, 0.0, 0.0
+
+    def success_condition(self, body, world_env):
+        if "cup" not in world_env.interactive_objects:
+            return False
+        cup_pos = world_env.get_object_pos("cup")
+        return float(length(cup_pos - self.TARGET_POS)) < 1.0

embodied/tasks/household_sit.py

@@ -0,0 +1,68 @@
+"""
+Household task: navigate to the chair and sit down.
+
+Chair seat: x=8-10, z=20-22, surface y=3.
+Chair centre: (9, 3, 21).
+
+"Sitting" = torso is near chair XZ AND torso y ≤ 3.2 (low enough to be seated)
+            AND not fallen (torso y still ≥ 1.5).
+"""
+from __future__ import annotations
+import numpy as np
+from .base import Task
+import sys, os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../..'))
+from engine.physics.rigid_body import vec3, length
+
+
+class HouseholdSitTask(Task):
+    name      = "household_sit"
+    terrain   = "household"
+    max_steps = 1000
+
+    CHAIR_POS   = vec3(9.0, 3.0, 21.0)
+    SIT_Y_MAX   = 3.8    # torso must be this low
+    SIT_Y_MIN   = 1.5    # but not fallen
+    SIT_XZ_DIST = 1.5    # within 1.5m of chair centre (XZ plane)
+
+    def reset(self, body, world_env):
+        body.reset(vec3(8.0, 2.0, 4.0))
+        self._prev_dist   = self._chair_dist(body)
+        self._seated_steps = 0
+
+    def _chair_dist(self, body) -> float:
+        tp = body.torso_pos()
+        dx = float(tp[0]) - float(self.CHAIR_POS[0])
+        dz = float(tp[2]) - float(self.CHAIR_POS[2])
+        return float(np.sqrt(dx*dx + dz*dz))
+
+    def _is_seated(self, body) -> bool:
+        tp  = body.torso_pos()
+        ty  = float(tp[1])
+        xz  = self._chair_dist(body)
+        return xz < self.SIT_XZ_DIST and self.SIT_Y_MIN <= ty <= self.SIT_Y_MAX
+
+    def step_reward(self, body, world_env, action):
+        alive      = 0.03 if not body.is_fallen() else -2.0
+        action_pen = float(np.mean(np.square(action))) * 0.003
+
+        dist     = self._chair_dist(body)
+        approach = (self._prev_dist - dist) * 4.0
+        self._prev_dist = dist
+
+        # Dense proximity gradient — agent spawns 18m from chair
+        if   dist < 1.5: proximity = 1.0
+        elif dist < 5.0: proximity = 0.25
+        elif dist < 12.: proximity = 0.07
+        else:            proximity = 0.02
+
+        seated_bonus = 0.0
+        if self._is_seated(body):
+            self._seated_steps += 1
+            seated_bonus = 3.0
+
+        return approach + proximity + seated_bonus + alive - action_pen
+
+    def success_condition(self, body, world_env):
+        # Must stay seated for 30 consecutive steps
+        return self._seated_steps >= 30

embodied/tasks/household_stack.py

@@ -0,0 +1,117 @@
+"""
+Household task: pick up 3 blocks from the floor and stack them on the table.
+
+Blocks start on the floor at (18,1,10), (20,1,10), (22,1,10).
+Target: each block within 0.8m of table centre (12, 3, 16).
+
+Strategy: agent earns reward per block it moves onto the table surface.
+It must pick each block (grip_R), carry it, and release near target.
+"""
+from __future__ import annotations
+import numpy as np
+from .base import Task
+import sys, os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../..'))
+from engine.physics.rigid_body import vec3, length
+
+
+_BLOCK_STARTS = [
+    vec3(18.0, 1.5, 10.0),
+    vec3(20.0, 1.5, 10.0),
+    vec3(22.0, 1.5, 10.0),
+]
+_TABLE_TARGET = vec3(12.0, 3.5, 16.0)
+_BLOCK_IDS    = ["block_0", "block_1", "block_2"]
+
+
+class HouseholdStackTask(Task):
+    name        = "household_stack"
+    terrain     = "household"
+    max_steps   = 1000
+    reset_noise = 0.30
+
+    def reset(self, body, world_env):
+        body.reset(vec3(8.0, 2.0, 4.0))
+        for bid, bpos in zip(_BLOCK_IDS, _BLOCK_STARTS):
+            world_env.add_interactive_object(
+                bid, "block", bpos,
+                size=vec3(0.15, 0.15, 0.15), mass=0.5,
+            )
+        self._prev_dists = {bid: float(length(_BLOCK_STARTS[i] - _TABLE_TARGET))
+                            for i, bid in enumerate(_BLOCK_IDS)}
+        self._on_table: set = set()
+        self._current_target = _BLOCK_IDS[0]   # work on blocks in order
+        self._prev_hand_dist = self._nearest_block_dist(body, world_env)
+
+    def _block_dist_to_table(self, world_env, bid: str) -> float:
+        return float(length(world_env.get_object_pos(bid) - _TABLE_TARGET))
+
+    def _nearest_block_dist(self, body, world_env) -> float:
+        hp = body.hand_pos("R")
+        unplaced = [b for b in _BLOCK_IDS if b not in self._on_table]
+        if not unplaced:
+            return 0.0
+        return min(float(length(hp - world_env.get_object_pos(b))) for b in unplaced)
+
+    def step_reward(self, body, world_env, action):
+        hand_id = "hand_R"
+        grip    = float(action[9])
+        hp      = body.hand_pos("R")
+        world_env.check_grasp(hand_id, hp, grip)
+        world_env.update_grasped(
+            {hand_id: hp},
+            {hand_id: body.bodies[hand_id].velocity},
+        )
+
+        alive      = 0.03 if not body.is_fallen() else -2.0
+        action_pen = float(np.mean(np.square(action))) * 0.003
+        reward     = alive - action_pen
+
+        # Detect newly placed blocks
+        for bid in _BLOCK_IDS:
+            if bid not in self._on_table:
+                d = self._block_dist_to_table(world_env, bid)
+                if d < 0.8:
+                    self._on_table.add(bid)
+                    reward += 15.0
+
+        # Approach reward: hand toward nearest unplaced block
+        hand_dist = self._nearest_block_dist(body, world_env)
+        if not world_env.is_grasped(self._current_target or "block_0"):
+            approach = (self._prev_hand_dist - hand_dist) * 6.0
+            # Dense gradient — agent starts 12m from blocks, needs signal from far
+            if   hand_dist < 0.30: proximity = 2.0
+            elif hand_dist < 1.00: proximity = 0.6
+            elif hand_dist < 4.00: proximity = 0.15
+            elif hand_dist < 10.0: proximity = 0.05
+            else:                  proximity = 0.01
+            # Pre-grasp bonus: ruka blízko bloku + zavřená → silný signál pro uchopení
+            pre_grasp = 3.0 if (hand_dist < 0.35 and grip < -0.25) else 0.0
+            reward += approach + proximity + pre_grasp
+        self._prev_hand_dist = hand_dist
+
+        # Progress reward toward current target
+        if self._current_target:
+            bid = self._current_target
+            d   = self._block_dist_to_table(world_env, bid)
+            progress = (self._prev_dists[bid] - d) * 3.0
+            self._prev_dists[bid] = d
+            reward += progress
+            if bid in self._on_table:
+                remaining = [b for b in _BLOCK_IDS if b not in self._on_table]
+                self._current_target = remaining[0] if remaining else None
+
+        return reward
+
+    def food_event(self, body, world_env) -> tuple:
+        """KFP: uchopení bloku = dumpling, ruka blízko = krekr."""
+        ct = self._current_target or "block_0"
+        if world_env.is_grasped(ct):
+            return True, 0.40, 0.20
+        hand_dist = self._nearest_block_dist(body, world_env)
+        if hand_dist < 0.35:
+            return True, 0.08, 0.03
+        return False, 0.0, 0.0
+
+    def success_condition(self, body, world_env):
+        return len(self._on_table) >= 3

embodied/tasks/household_sweep.py

@@ -0,0 +1,78 @@
+"""
+Household task: sweep / knock three cups off the table edge.
+
+Cups start on the table at x=10-14, z=14-18 (surface y=3).
+"Off table" = cup y drops below 2.5 (fell off the edge).
+
+The agent earns reward each time a cup drops, plus approach reward
+for the hand_R moving toward cups still on the table.
+"""
+from __future__ import annotations
+import numpy as np
+from .base import Task
+import sys, os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../..'))
+from engine.physics.rigid_body import vec3, length
+
+
+_SWEEP_CUPS = [
+    ("sweep_cup_0", vec3(11.0, 3.5, 15.0)),
+    ("sweep_cup_1", vec3(12.5, 3.5, 16.0)),
+    ("sweep_cup_2", vec3(13.0, 3.5, 17.0)),
+]
+
+
+class HouseholdSweepTask(Task):
+    name      = "household_sweep"
+    terrain   = "household"
+    max_steps = 800
+
+    def reset(self, body, world_env):
+        body.reset(vec3(8.0, 2.0, 4.0))
+        for cid, cpos in _SWEEP_CUPS:
+            world_env.add_interactive_object(
+                cid, "cup", cpos,
+                size=vec3(0.08, 0.14, 0.08), mass=0.3,
+            )
+        self._knocked: set = set()
+        self._prev_hand_dist = self._nearest_cup_dist(body, world_env)
+
+    def _nearest_cup_dist(self, body, world_env) -> float:
+        hp = body.hand_pos("R")
+        dists = []
+        for cid, _ in _SWEEP_CUPS:
+            if cid not in self._knocked:
+                dists.append(float(length(hp - world_env.get_object_pos(cid))))
+        return min(dists) if dists else 0.0
+
+    def step_reward(self, body, world_env, action):
+        alive      = 0.03 if not body.is_fallen() else -2.0
+        action_pen = float(np.mean(np.square(action))) * 0.003
+        reward     = alive - action_pen
+
+        for cid, _ in _SWEEP_CUPS:
+            if cid not in self._knocked:
+                cup_y  = float(world_env.get_object_pos(cid)[1])
+                broken = world_env.is_broken(cid)
+                if cup_y < 2.5 or broken:
+                    self._knocked.add(cid)
+                    reward += 12.0 + (4.0 if broken else 0.0)
+
+        if len(self._knocked) < len(_SWEEP_CUPS):
+            d        = self._nearest_cup_dist(body, world_env)
+            approach = (self._prev_hand_dist - d) * 6.0
+            # Sweep bonus: ruka velmi blízko hrníčku = aktivní sweep pokus
+            sweep_attempt = 4.0 if d < 0.30 else 0.0
+            # Agent spawns at (8,2,4), cups at ~(12,3.5,15-17) → ~13m away
+            if   d < 0.40: proximity = 2.0
+            elif d < 1.50: proximity = 0.7
+            elif d < 5.00: proximity = 0.18
+            elif d < 12.0: proximity = 0.05
+            else:          proximity = 0.01
+            self._prev_hand_dist = d
+            reward += approach + proximity + sweep_attempt
+
+        return reward
+
+    def success_condition(self, body, world_env):
+        return len(self._knocked) >= 3

embodied/tasks/ice_driving.py

@@ -0,0 +1,358 @@
+"""
+IceDrivingTask — jízda HX-1 na ledu / sněhu.
+
+Emergentní chování které by mělo vzniknout:
+  - Dřívější brzdění (mu×0.14 → brzdná dráha ~7× delší)
+  - Dřívější zatáčení (musí nacouvat nebo flick před zatáčkou)
+  - Rekuperační brzdění místo kotoučů (plynulejší, bez blokování kol)
+  - Scandinavian flick / pendulum: přehoz karoserie pro řízený oversteer
+  - Throttle na výjezdu ze zatáčky: trakce AWD = šoférovat výkonem ven ze zatáčky
+  - "Brzdit zpátečkou": EM motory jako generátory = engine-braking bez lockup
+
+Povrchové podmínky:
+  "ice"       — průhledný led, mu_factor=0.14 (frozen lake, závodní situace)
+  "snow"      — utlačený sníh, mu_factor=0.28 (rallye styl)
+  "black_ice" — náhodné zákeřné klouzání, mu_factor=0.07 (nebezpečné)
+  "mixed"     — střídá se led / sníh / dry patches (nejreálnější)
+
+Odměnová funkce:
+  +progress   : postup po trase
+  +goal_bonus : dosažení cíle (+80)
+  +smooth_ctrl: plynulé vstupy (bez agresivních skoků)
+  +regen_brake: rekuperační brzdění místo kotoučů (+bonus)
+  +controlled_drift: drift_index 0.15–0.55 = řízený → bonus
+  -spin_pen   : drift_index > 0.75 = vykrouceníí → penalizace
+  -crash_pen  : havárie (-30)
+  -late_brake : pozdní prudké brzdění v zatáčce → penalizace (naučí jet předem)
+
+Observation (28D):
+  [0:18] vehicle telemetrie
+  [18]   vzdálenost k cíli (norm)
+  [19]   úhel k cíli
+  [20]   aktuální mu_factor (agent vidí klouzavost)
+  [21]   drift_index
+  [22]   speed_norm
+  [23]   regen_kw_norm
+  [24]   prev_steer (paměť vstupu pro smooth penalty)
+  [25]   prev_throttle
+  [26]   slip_ratio_front (odhad z telemetrie)
+  [27]   black_ice_nearby (0/1 — random zákeřné místo)
+"""
+from __future__ import annotations
+
+import math
+import random
+from dataclasses import dataclass
+from typing import List, Optional, Tuple
+
+import numpy as np
+
+from embodied.tasks.base import Task
+from embodied.vehicle_body import VehicleBody
+from engine.city_builder.city_gen import CityGenerator, build_traffic_network
+from engine.city_builder.road_network import RoadNetwork
+from engine.city_builder.traffic_sim import TrafficSimulation
+from engine.vehicles.tire_physics import SurfaceCondition
+
+
+# ── Konstanty ──────────────────────────────────────────────────────────────────
+
+_GOAL_RADIUS    = 35.0
+_CRASH_PEN      = -30.0
+_SPIN_PEN       = -2.0        # per krok při drift_index > 0.75
+_LATE_BRAKE_PEN = -0.8        # pozdní prudké brzdění v zatáčce
+_DRIFT_OPT_LO   = 0.15        # ideální drift_index minimum (řízený slip)
+_DRIFT_OPT_HI   = 0.55        # ideální drift_index maximum
+
+# Tréninkové body na malém okruhu (ice track) — krátké zatáčky, různé poloměry
+_ICE_TRACK = [
+    #  (x,    z,   label)
+    (   0,    0,   "start"),
+    ( 400,    0,   "T1_braking"),
+    ( 600,  200,   "T2_hairpin"),
+    ( 600,  500,   "T3_fast"),
+    ( 400,  700,   "T4_chicane_a"),
+    ( 200,  700,   "T4_chicane_b"),
+    (   0,  500,   "T5_long"),
+    (-200,  200,   "T6_kink"),
+    (   0,    0,   "finish"),
+]
+
+
+def _dist(ax, az, bx, bz) -> float:
+    return math.sqrt((ax - bx) ** 2 + (az - bz) ** 2)
+
+
+# ── Task ──────────────────────────────────────────────────────────────────────
+
+class IceDrivingTask(Task):
+    """
+    Trénuje agenta na ledových/sněžných podmínkách.
+    Emergentní: plynulé vstupy, rekuperační brzdění, řízený drift.
+    """
+
+    name        = "ice_driving"
+    terrain     = "ice"
+    max_steps   = 3000
+    reset_noise = 0.05   # malý noise — led je citlivý
+
+    def __init__(self,
+                 surface:   str   = "ice",
+                 seed:      int   = 0,
+                 city_seed: int   = 42):
+        assert surface in ("ice", "snow", "black_ice", "mixed"), f"Neznámý povrch: {surface}"
+        self.surface_name = surface
+        self._rng         = random.Random(seed)
+        self._road_net    = CityGenerator(seed=city_seed, closure_count=0).generate()
+        self._network     = build_traffic_network(self._road_net)
+        # Na ledu je minimální provoz (1–2 auta)
+        self._traffic     = TrafficSimulation(
+            self._road_net, density_scale=0.05, seed=seed, max_cars=5)
+        self._vehicle     = VehicleBody.phantom_vertex()
+        self._surface     = self._make_surface(surface)
+        self._track       = _ICE_TRACK
+        self._wp_idx      = 1
+        self._prev_dist   = 0.0
+        self._prev_steer  = 0.0
+        self._prev_thr    = 0.0
+        self._elapsed_s   = 0.0
+        self._total_regen = 0.0
+        self._spin_steps  = 0
+        self._late_brake_pen = 0.0
+        self._reached_finish = False
+        # Zákeřné místo černého ledu (mění se každou epizodu)
+        self._black_ice_pos: Optional[Tuple[float, float]] = None
+
+    def _make_surface(self, name: str, vary: bool = False) -> SurfaceCondition:
+        if name == "ice":
+            s = SurfaceCondition.ice()
+        elif name == "snow":
+            s = SurfaceCondition.snow()
+        elif name == "black_ice":
+            s = SurfaceCondition.black_ice()
+        else:  # mixed
+            choice = self._rng.choice(["ice", "snow", "ice"])
+            s = SurfaceCondition.ice() if choice == "ice" else SurfaceCondition.snow()
+        # Drobná variace mu_factor (±10%) pro rozmanitost epizod
+        if vary:
+            s.mu_factor *= self._rng.uniform(0.9, 1.1)
+        return s
+
+    # ── Reset ──────────────────────────────────────────────────────────────────
+
+    def reset(self, body, world_env) -> None:
+        self._surface  = self._make_surface(self.surface_name, vary=True)
+        self._wp_idx   = 1
+        self._elapsed_s = 0.0
+        self._total_regen = 0.0
+        self._spin_steps = 0
+        self._late_brake_pen = 0.0
+        self._reached_finish = False
+        self._prev_steer = 0.0
+        self._prev_thr   = 0.0
+
+        start = self._track[0]
+        self._vehicle.reset(position=(start[0], 0.0, start[1]), heading_rad=0.0)
+        self._prev_dist = _dist(start[0], start[1],
+                                self._track[1][0], self._track[1][1])
+        self._traffic.reset()
+
+        # Náhodné místo černého ledu (mixed/black_ice mód)
+        if self.surface_name in ("black_ice", "mixed"):
+            ti = self._rng.randint(1, len(self._track) - 2)
+            self._black_ice_pos = (
+                self._track[ti][0] + self._rng.uniform(-30, 30),
+                self._track[ti][1] + self._rng.uniform(-30, 30),
+            )
+        else:
+            self._black_ice_pos = None
+
+    # ── Step reward ────────────────────────────────────────────────────────────
+
+    def step_reward(self, body, world_env, action: np.ndarray) -> float:
+        throttle = float(np.clip(action[0],  0.0, 1.0))
+        brake    = float(np.clip(-min(action[0], 0.0), 0.0, 1.0))
+        steer    = float(np.clip(action[2] if len(action) > 2 else 0.0, -1.0, 1.0))
+
+        # Aplikuj povrchovou podmínku na vehicle před krokem
+        # (interně snižuje dostupnou trakci)
+        self._vehicle.set_surface_mu(self._surface.mu_factor)
+
+        # Černý led: náhodné zákeřné snížení gripu
+        px, _, pz = self._vehicle.position()
+        mu_effective = self._surface.mu_factor
+        if self._black_ice_pos:
+            bx, bz = self._black_ice_pos
+            if _dist(px, pz, bx, bz) < 20.0:
+                mu_effective *= 0.45   # zhoršení o 55%
+                self._vehicle.set_surface_mu(mu_effective)
+
+        tel = self._vehicle.step(throttle, brake, steer)
+        dt  = self._vehicle.DT
+        self._elapsed_s += dt
+
+        px, _, pz = self._vehicle.position()
+        reward    = 0.0
+
+        # ── Postup k cílovému bodu ────────────────────────────────────────────
+        if self._wp_idx < len(self._track):
+            wx, wz = self._track[self._wp_idx][0], self._track[self._wp_idx][1]
+            dist   = _dist(px, pz, wx, wz)
+            progress = (self._prev_dist - dist) * 0.08
+            reward  += max(-0.4, progress)
+            self._prev_dist = dist
+
+            if dist < _GOAL_RADIUS:
+                reward += 10.0   # průjezdní bod
+                self._wp_idx += 1
+                if self._wp_idx >= len(self._track):
+                    self._reached_finish = True
+                    reward += 80.0
+                else:
+                    nx, nz = self._track[self._wp_idx][0], self._track[self._wp_idx][1]
+                    self._prev_dist = _dist(px, pz, nx, nz)
+
+        # ── Plynulost vstupů (klíčová na ledu) ───────────────────────────────
+        steer_jerk  = abs(steer - self._prev_steer)
+        thr_jerk    = abs(throttle - self._prev_thr)
+        smooth_bonus = max(0.0, 0.04 - steer_jerk * 0.06 - thr_jerk * 0.04)
+        reward += smooth_bonus
+        self._prev_steer = steer
+        self._prev_thr   = throttle
+
+        # ── Rekuperační brzdění (EM motory jako generátory) ───────────────────
+        regen = tel.regen_kw
+        self._total_regen += regen * dt / 3600.0
+        # Bonus za regen-brzdění (místo kotouče) — specificky při deceleraci
+        if brake > 0.1 and regen > 5.0:
+            reward += regen * 0.005 * self._surface.regen_factor
+        elif regen > 0:
+            reward += regen * 0.002 * self._surface.regen_factor
+
+        # ── Řízený drift vs. spin-out ──────────────────────────────────────────
+        drift = tel.drift_index
+        if _DRIFT_OPT_LO <= drift <= _DRIFT_OPT_HI:
+            # Řízený slip = rally styl, agent se to aktivně naučí
+            reward += 0.15 * (1.0 - abs(drift - 0.35) / 0.20)
+        elif drift > 0.75:
+            # Vytoč → trestej
+            self._spin_steps += 1
+            reward += _SPIN_PEN * min(1.0, (drift - 0.75) / 0.25)
+
+        # ── Pozdní prudké brzdění v zatáčce ───────────────────────────────────
+        # Detekce: agent brzdí ostře (brake > 0.5) a zároveň steer > 0.3
+        # → na ledu to vede ke spin-outu → penalizuj dřív než nastane
+        if brake > 0.5 and abs(steer) > 0.3:
+            late_pen = brake * abs(steer) * 0.4
+            reward -= late_pen
+            self._late_brake_pen += late_pen
+
+        # ── EM tlumiče (retardéry/nerovnosti) ────────────────────────────────
+        seg = self._road_net.segment_at(px, pz)
+        if seg and "speed_bump" in seg.features:
+            damper_regen = tel.speed_kmh * 0.0003
+            self._total_regen += damper_regen * dt / 3600.0
+            reward += damper_regen * 0.004
+
+        # ── Časový tlak ────────────────────────────────────────────────────────
+        reward -= 0.015   # mírný tlak (menší než timed_nav)
+
+        # ── Havárie ────────────────────────────────────────────────────────────
+        if self._vehicle.is_crashed():
+            reward += _CRASH_PEN
+
+        return float(reward)
+
+    # ── Terminace ──────────────────────────────────────────────────────────────
+
+    def is_done(self, body, world_env) -> bool:
+        if self._reached_finish:
+            return True
+        if self._vehicle.is_crashed():
+            return True
+        return world_env._tick >= self.max_steps
+
+    def success_condition(self, body, world_env) -> bool:
+        return self._reached_finish
+
+    def food_event(self, body, world_env) -> tuple:
+        if self._reached_finish:
+            return True, 1.0, 0.35
+        return False, 0.0, 0.0
+
+    # ── State override ─────────────────────────────────────────────────────────
+
+    def get_task_state(self, body_state: np.ndarray) -> np.ndarray:
+        state = body_state.copy()
+        state[0:18] = np.array(self._vehicle.observation_vec(), dtype=np.float32)
+
+        px, _, pz = self._vehicle.position()
+        tel = self._vehicle.state.telemetry
+
+        if self._wp_idx < len(self._track):
+            wx, wz = self._track[self._wp_idx][0], self._track[self._wp_idx][1]
+            dist = _dist(px, pz, wx, wz)
+            heading  = self._vehicle.heading()
+            goal_h   = math.atan2(wz - pz, wx - px)
+            ang_err  = (goal_h - heading + math.pi) % (2 * math.pi) - math.pi
+        else:
+            dist, ang_err = 0.0, 0.0
+
+        # Černý led v okolí?
+        black_ice_near = 0.0
+        if self._black_ice_pos:
+            bx, bz = self._black_ice_pos
+            if _dist(px, pz, bx, bz) < 40.0:
+                black_ice_near = 1.0
+
+        state[18] = float(np.clip(dist / 800.0, 0.0, 1.0))
+        state[19] = float(ang_err / math.pi)
+        state[20] = float(self._surface.mu_factor)        # agent vidí klouzavost!
+        state[21] = float(tel.drift_index)
+        state[22] = float(np.clip(tel.speed_kmh / 140.0, 0.0, 1.0))
+        state[23] = float(np.clip(tel.regen_kw / 50.0, 0.0, 1.0))
+        state[24] = float(self._prev_steer)
+        state[25] = float(self._prev_thr)
+        state[26] = float(np.clip(abs(tel.drift_index) * 2.0, 0.0, 1.0))
+        state[27] = black_ice_near
+        return state
+
+    # ── Info ───────────────────────────────────────────────────────────────────
+
+    def episode_info(self) -> dict:
+        tel = self._vehicle.state.telemetry
+        return {
+            "surface":         self.surface_name,
+            "mu_factor":       round(self._surface.mu_factor, 3),
+            "waypoints_done":  self._wp_idx - 1,
+            "elapsed_s":       round(self._elapsed_s, 1),
+            "spin_steps":      self._spin_steps,
+            "late_brake_pen":  round(self._late_brake_pen, 2),
+            "regen_kwh":       round(self._total_regen, 4),
+            "drift_index":     round(tel.drift_index, 3),
+            "speed_kmh":       round(tel.speed_kmh, 1),
+            "finished":        self._reached_finish,
+        }
+
+
+# ── Varianty ──────────────────────────────────────────────────────────────────
+
+class IceDrivingIce(IceDrivingTask):
+    """Průhledný led — rallye na zamrzlém jezeře."""
+    name = "ice_driving_ice"
+    def __init__(self, seed=0): super().__init__(surface="ice", seed=seed)
+
+class IceDrivingSnow(IceDrivingTask):
+    """Utlačený sníh — rallye ve Finsku."""
+    name = "ice_driving_snow"
+    def __init__(self, seed=0): super().__init__(surface="snow", seed=seed)
+
+class IceDrivingBlackIce(IceDrivingTask):
+    """Zákeřný černý led — agresivní, nečekané klouzání."""
+    name = "ice_driving_black_ice"
+    def __init__(self, seed=0): super().__init__(surface="black_ice", seed=seed)
+
+class IceDrivingMixed(IceDrivingTask):
+    """Smíšený povrch — střídá led, sníh, suché záplaty."""
+    name = "ice_driving_mixed"
+    def __init__(self, seed=0): super().__init__(surface="mixed", seed=seed)

embodied/tasks/ice_driving_polaris.py

@@ -0,0 +1,164 @@
+# ┌─────────────────────────────────────────────────────────────────────────┐
+# │  SUBSYSTÉM: PhantomCortex Cognitive Neural Engine — Task Layer           │
+# │  Modul:     IceDriving_Polaris — jízda na ledu s POLARIS koprocesorem   │
+# │  Fyzika:    PolarisServer existuje ve VoxForge světě (x=60, y=0.5, z=15)│
+# └─────────────────────────────────────────────────────────────────────────┘
+"""
+IceDriving_Polaris — ice/snow/mixed jízda s POLARIS serverem jako koprocesorem.
+
+Architektura:
+  RL agent (PhantomCortex)  → 75% akce
+  POLARIS server (distillace drive checkpointu) → 25% akce
+  ────────────────────────────────────────────────────────
+  blended_action = 0.75 * rl_action + 0.25 * polaris_action
+
+POLARIS se inicializuje z agent_drive_city.npz (nejlepší dostupný checkpoint).
+Na ledu může drive-city znalost:
+  + přispět plynulostí řízení (smooth steering)
+  + pomoci s brzdovými vzory
+  - nebo překazit (agresivní vstupy nevhodné pro led)
+
+Server je fyzicky umístěn v mapě (x=60, y=0.5, z=15) — u okraje ice tracku.
+POLARIS se online učí z každé RL akce (Hebbian, každé 4 kroky).
+"""
+from __future__ import annotations
+
+import logging
+import os, sys
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../..'))
+
+import numpy as np
+
+from .ice_driving import IceDrivingMixed, IceDrivingIce, IceDrivingSnow, IceDrivingBlackIce
+
+log = logging.getLogger("phantom.embodied")
+
+_DRIVE_CKPT    = "checkpoints/agent_drive_city.npz"
+_POLARIS_BLEND = 0.25
+
+
+class IceDriving_Polaris(IceDrivingMixed):
+    """
+    IceDrivingMixed + POLARIS server koprocesor.
+
+    Server se inicializuje JEDNOU při prvním reset() — Hebbian learning
+    akumuluje přes epizody (POLARIS se učí z každého průjezdu po ledu).
+    """
+    name = "ice_driving_polaris"
+
+    polaris_server   = None
+    polaris_agent_id = "ice_polaris"
+    polaris_blend    = _POLARIS_BLEND
+    _polaris_ready   = False
+
+    def reset(self, body, world_env):
+        super().reset(body, world_env)
+
+        if not self._polaris_ready:
+            self._init_polaris_server()
+            self._polaris_ready = True
+
+    def _init_polaris_server(self):
+        try:
+            from engine.hardware.polaris_server import PolarisServer
+            from engine.hardware.phantom_uploader import PhantomCortexUploader
+
+            srv = PolarisServer(
+                position=(60.0, 0.5, 15.0),
+                name="PolarisServer-ICE-01",
+                rng_seed=8888,
+            )
+
+            ckpt_path = _DRIVE_CKPT if os.path.exists(_DRIVE_CKPT) else "checkpoints/agent_latest.npz"
+            if os.path.exists(ckpt_path):
+                uploader = PhantomCortexUploader(ckpt_path)
+                uploader.upload_to_server(srv)
+                log.info(
+                    "[IceDriving_Polaris] POLARIS server INIT z %s  blend=%.0f%%  "
+                    "(přetrvává přes epizody — Hebbian akumulace)",
+                    os.path.basename(ckpt_path), _POLARIS_BLEND * 100
+                )
+            else:
+                log.warning("[IceDriving_Polaris] checkpoint nenalezen, POLARIS startuje náhodně")
+
+            srv.connect(self.polaris_agent_id, task_type="locomotion")
+            self.polaris_server = srv
+
+        except Exception as e:
+            log.warning("[IceDriving_Polaris] POLARIS init selhal (%s) — bez POLARIS", e)
+            self.polaris_server = None
+
+    def step_reward(self, body, world_env, action: np.ndarray) -> float:
+        reward = super().step_reward(body, world_env, action)
+
+        if self.polaris_server is not None and world_env._tick % 200 == 0:
+            diag = self.polaris_server.diagnostics()
+            if diag.health != "ONLINE":
+                log.warning(
+                    "[POLARIS-ICE] Server health=%s  PWR=%.0fW  CLT=%.1f°C",
+                    diag.health, diag.total_power_w, diag.coolant["outlet_temp_c"]
+                )
+
+        return reward
+
+
+# ── Varianty pro jednotlivé povrchy ───────────────────────────────────────────
+
+class IceDrivingIce_Polaris(IceDrivingIce):
+    """Čistý led + POLARIS."""
+    name = "ice_driving_ice_polaris"
+    polaris_server   = None
+    polaris_agent_id = "ice_polaris_pure"
+    polaris_blend    = _POLARIS_BLEND
+    _polaris_ready   = False
+
+    def reset(self, body, world_env):
+        super().reset(body, world_env)
+        if not self._polaris_ready:
+            self._init_polaris_server()
+            self._polaris_ready = True
+
+    def _init_polaris_server(self):
+        try:
+            from engine.hardware.polaris_server import PolarisServer
+            from engine.hardware.phantom_uploader import PhantomCortexUploader
+            srv = PolarisServer(position=(60.0, 0.5, 15.0), name="PolarisServer-ICE-PURE", rng_seed=9001)
+            ckpt = _DRIVE_CKPT if os.path.exists(_DRIVE_CKPT) else "checkpoints/agent_latest.npz"
+            if os.path.exists(ckpt):
+                PhantomCortexUploader(ckpt).upload_to_server(srv)
+                log.info("[IceDrivingIce_Polaris] INIT z %s  blend=%.0f%%", os.path.basename(ckpt), _POLARIS_BLEND * 100)
+            srv.connect(self.polaris_agent_id, task_type="locomotion")
+            self.polaris_server = srv
+        except Exception as e:
+            log.warning("[IceDrivingIce_Polaris] POLARIS init selhal (%s)", e)
+            self.polaris_server = None
+
+
+class IceDrivingBlackIce_Polaris(IceDrivingBlackIce):
+    """Černý led + POLARIS (nejtěžší varianta)."""
+    name = "ice_driving_black_ice_polaris"
+    polaris_server   = None
+    polaris_agent_id = "ice_polaris_black"
+    polaris_blend    = _POLARIS_BLEND
+    _polaris_ready   = False
+
+    def reset(self, body, world_env):
+        super().reset(body, world_env)
+        if not self._polaris_ready:
+            self._init_polaris_server()
+            self._polaris_ready = True
+
+    def _init_polaris_server(self):
+        try:
+            from engine.hardware.polaris_server import PolarisServer
+            from engine.hardware.phantom_uploader import PhantomCortexUploader
+            srv = PolarisServer(position=(60.0, 0.5, 15.0), name="PolarisServer-ICE-BLACK", rng_seed=9002)
+            ckpt = _DRIVE_CKPT if os.path.exists(_DRIVE_CKPT) else "checkpoints/agent_latest.npz"
+            if os.path.exists(ckpt):
+                PhantomCortexUploader(ckpt).upload_to_server(srv)
+                log.info("[IceDrivingBlackIce_Polaris] INIT z %s  blend=%.0f%%", os.path.basename(ckpt), _POLARIS_BLEND * 100)
+            srv.connect(self.polaris_agent_id, task_type="locomotion")
+            self.polaris_server = srv
+        except Exception as e:
+            log.warning("[IceDrivingBlackIce_Polaris] POLARIS init selhal (%s)", e)
+            self.polaris_server = None

embodied/tasks/maze.py

@@ -0,0 +1,36 @@
+"""Task: navigate from spawn to goal in the maze."""
+from __future__ import annotations
+import numpy as np
+from .base import Task
+import sys, os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../..'))
+from engine.physics.rigid_body import vec3, length
+
+
+class MazeTask(Task):
+    name    = "maze"
+    terrain = "maze"
+    max_steps = 2000
+
+    def reset(self, body, world_env):
+        body.reset(vec3(4.0, 2.0, 4.0))
+        self._goal = getattr(world_env, "maze_goal", vec3(58.0, 1.0, 58.0))
+        self._prev_dist = float(length(body.torso_pos() - self._goal))
+
+    def step_reward(self, body, world_env, action):
+        pos = body.torso_pos()
+        dist = float(length(pos - self._goal))
+        # Dense reward: getting closer
+        approach  = (self._prev_dist - dist) * 3.0
+        alive     = 0.1 if not body.is_fallen() else -3.0
+        at_goal   = 5.0 if dist < 3.0 else 0.0
+        action_pen = float(np.sum(np.square(action))) * 0.003
+        self._prev_dist = dist
+        return approach + alive + at_goal - action_pen
+
+    def is_done(self, body, world_env):
+        dist = float(length(body.torso_pos() - self._goal))
+        return body.is_fallen() or dist < 2.5 or world_env._tick >= self.max_steps
+
+    def success_condition(self, body, world_env):
+        return float(length(body.torso_pos() - self._goal)) < 2.5

embodied/tasks/media_watch.py

@@ -0,0 +1,96 @@
+"""
+MediaWatchTask — agent se musí otočit k obrazovce a sledovat ji (udržovat pohled)
+zatímco hraje reproduktor. Testuje schopnost orientace k senzorickému podnětu.
+
+Odměna: visibility score (jak moc monitor vidí) × zesílení reproduktoru
+        + bonus za udržení pohledu po N po sobě jdoucích krocích.
+"""
+from __future__ import annotations
+import sys, os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../..'))
+
+import numpy as np
+from engine.physics.rigid_body import vec3, Vec3, length, normalize
+from embodied.tasks.base import Task
+from embodied.media_objects import MediaRoom
+
+
+class MediaWatchTask(Task):
+    name        = "media_watch"
+    terrain     = "flat"
+    max_steps   = 300
+    reset_noise: float = 0.12
+
+    # Kolik kroků musí agent sledovat obrazovku, aby byl úkol splněn
+    GAZE_TARGET = 80
+    # Minimální visibility score pro "dívám se"
+    GAZE_THRESH = 0.35
+
+    def __init__(self):
+        self._media: MediaRoom = None
+        self._gaze_steps = 0
+        self._patterns   = ["stripe", "circle", "checkers", "arrow_left", "arrow_right"]
+        self._pat_idx    = 0
+
+    def reset(self, body, world_env):
+        pat = self._patterns[self._pat_idx % len(self._patterns)]
+        self._pat_idx += 1
+        self._media      = MediaRoom(world_env.phys, pattern=pat)
+        self._gaze_steps = 0
+        world_env._objects = getattr(world_env, "_objects", {})
+        world_env._objects["monitor_main"] = self._media.monitor
+        world_env._objects["speaker_main"] = self._media.speaker
+
+    def _get_forward(self, body) -> Vec3:
+        """Přibližný dopředný vektor hlavy agenta (z pohybu hlavy)."""
+        try:
+            head  = body.bodies["head"].position
+            torso = body.bodies["torso"].position
+            fwd   = head - torso
+            fwd_np = np.array([fwd[0], 0.0, fwd[2]], dtype=np.float64)
+            n = float(np.linalg.norm(fwd_np))
+            if n < 0.001:
+                return vec3(0, 0, -1)
+            fwd_np /= n
+            return vec3(float(fwd_np[0]), 0.0, float(fwd_np[2]))
+        except Exception:
+            return vec3(0, 0, -1)
+
+    def step_reward(self, body, world_env, action) -> float:
+        if self._media is None:
+            return 0.0
+
+        self._media.step()
+
+        # Pozice oka = hlava agenta
+        try:
+            eye = body.bodies["head"].position
+        except Exception:
+            eye = body.torso_pos()
+
+        forward = self._get_forward(body)
+        vis     = self._media.monitor.visibility_from(eye, forward)
+        _, amp  = self._media.speaker.heard_by(eye)
+
+        if vis >= self.GAZE_THRESH:
+            self._gaze_steps += 1
+        else:
+            self._gaze_steps = max(0, self._gaze_steps - 1)
+
+        gaze_bonus = 0.0
+        if self._gaze_steps >= self.GAZE_TARGET:
+            gaze_bonus = 5.0   # splněno!
+
+        alive      = 0.03
+        action_pen = float(np.mean(np.abs(action))) * 0.01
+        return vis * 0.5 + amp * 0.1 + gaze_bonus + alive - action_pen
+
+    def is_done(self, body, world_env) -> bool:
+        if body.is_fallen():
+            return True
+        if self.success_condition(body, world_env):
+            return True
+        return world_env._tick >= self.max_steps
+
+    def success_condition(self, body, world_env) -> bool:
+        return self._gaze_steps >= self.GAZE_TARGET

embodied/tasks/obstacle_course.py

@@ -0,0 +1,132 @@
+"""
+Vojenská překážková dráha (opičí dráha).
+
+Agent startuje na x=4, musí projet celou trasou (+X směr) a zdolat:
+  1. Hurdle 1   (x=16-17) — přeskočit nízkou zeď
+  2. Hurdle 2   (x=26-27) — přeskočit nízkou zeď
+  3. Wall climb (x=35-38) — vylézt na vysokou zeď (h=4)
+  4. Descent    (x=39-43) — sejít ze schodů dolů
+  5. Low crawl  (x=46-53) — proplazit se nízkým tunelem
+  6. Jump pit   (x=55-57) — přeskočit jámu (bez země)
+  7. Finish     (x=60+)   — cíl
+
+Reward:
+  - Živý bonus každý krok (+0.03)
+  - Pokrok vpřed (delta X × weight, závisí na sekci)
+  - Checkpoint bonusy při prvním dosažení každého CP
+  - Výšková odměna při šplhání
+  - Penalizace za stojení na místě
+  - SUCCESS bonus při dosažení cíle
+"""
+from __future__ import annotations
+import numpy as np
+from .base import Task
+import sys, os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../..'))
+from engine.physics.rigid_body import vec3
+
+
+# Checkpoints: (min_x, name, bonus)
+_CHECKPOINTS = [
+    (14.0, "start_run",   5.0),
+    (20.0, "hurdle_1",   12.0),
+    (30.0, "hurdle_2",   12.0),
+    (40.0, "wall_climb", 20.0),
+    (44.0, "descent",    10.0),
+    (54.0, "crawl",      18.0),
+    (58.0, "pit_jump",   25.0),
+    (61.0, "finish",     40.0),
+]
+
+# Forward progress weight per X zone (harder section → higher reward density)
+def _progress_weight(x: float) -> float:
+    if x < 14:   return 1.0   # free run
+    if x < 22:   return 2.5   # hurdle 1 zone
+    if x < 32:   return 2.5   # hurdle 2 zone
+    if x < 44:   return 3.5   # wall climb + descent
+    if x < 55:   return 2.0   # crawl tunnel
+    if x < 59:   return 4.0   # pit jump
+    return 1.5                 # after finish line
+
+
+class ObstacleCourseTask(Task):
+    name        = "obstacle_course"
+    terrain     = "military"
+    max_steps   = 600
+    reset_noise = 0.32   # high noise: jumping/climbing needs varied exploration
+
+    def __init__(self):
+        self._fallen_flag   = False
+        self._prev_x        = 4.0
+        self._prev_y        = 2.0
+        self._reached_cps: set = set()
+        self._stall_counter = 0
+        self._best_x        = 4.0
+
+    def reset(self, body, world_env):
+        body.reset(vec3(4.0, 2.0, 32.0))
+        self._prev_x          = 4.0
+        self._prev_y          = 2.0
+        self._reached_cps     = set()
+        self._stall_counter   = 0
+        self._best_x          = 4.0
+        self._fallen_flag     = False
+
+    def is_done(self, body, world_env) -> bool:
+        if body.is_fallen():
+            self._fallen_flag = True
+        if self._fallen_flag:
+            return True
+        if self.success_condition(body, world_env):
+            return True
+        return world_env._tick >= self.max_steps
+
+    def step_reward(self, body, world_env, action):
+        pos    = body.torso_pos()
+        curr_x = float(pos[0])
+        curr_y = float(pos[1])
+
+        reward = 0.0
+
+        # Při pádu: velká jednorázová penalizace + konec
+        if body.is_fallen():
+            return -15.0
+
+        reward += 0.03   # alive bonus
+
+        # Action energy cost (discourage wasteful flailing)
+        action_pen = float(np.mean(np.square(action))) * 0.004
+        reward -= action_pen
+
+        # Forward progress (zone-weighted)
+        dx = curr_x - self._prev_x
+        w  = _progress_weight(self._prev_x)
+        reward += dx * w
+
+        # Height bonus in wall-climb zone (encourage going UP)
+        if 33.0 < curr_x < 43.0:
+            dy = curr_y - self._prev_y
+            if dy > 0:
+                reward += dy * 4.0
+
+        # Stall penalty: if agent isn't making X progress
+        if curr_x <= self._best_x + 0.05:
+            self._stall_counter += 1
+            if self._stall_counter > 80:
+                reward -= 0.05   # gentle push to keep moving
+        else:
+            self._stall_counter = 0
+            self._best_x = max(self._best_x, curr_x)
+
+        # Checkpoint bonuses (one-time per checkpoint)
+        for min_x, cp_name, bonus in _CHECKPOINTS:
+            if cp_name not in self._reached_cps and curr_x >= min_x:
+                self._reached_cps.add(cp_name)
+                reward += bonus
+
+        self._prev_x = curr_x
+        self._prev_y = curr_y
+        return reward
+
+    def success_condition(self, body, world_env):
+        return float(body.torso_pos()[0]) >= 61.0 and not body.is_fallen()

embodied/tasks/polaris_server_task.py

@@ -0,0 +1,151 @@
+# ┌─────────────────────────────────────────────────────────────────────────┐
+# │  SUBSYSTÉM: PhantomCortex Cognitive Neural Engine — Task Layer           │
+# │  Modul:     PolarisServerTask — Terminator se připojuje k serveru        │
+# │  Fyzika:    Server existuje ve VoxForge světě na souřadnicích (48,0,10)  │
+# └─────────────────────────────────────────────────────────────────────────┘
+"""
+PolarisServerTask — Terminator naviguje k PolarisServer v továrně
+a připojí se přes CAP-Bus. Po připojení server přebírá část výpočtů.
+
+Scénář:
+  1. Server je fyzicky umístěn na konci továrny (x=48, y=0.5, z=10)
+  2. Terminator musí dojít do vzdálenosti ≤ 3 m od serveru
+  3. Po připojení: inference přes server (MOTOR board → fine motor reflexy)
+  4. Server dělá Hebbian update každý krok kdy Terminator provádí správný pohyb
+  5. Cíl: dojít k serveru + provést 50 kroků se serverem připojeným
+
+Odměna:
+  +progress  — pohyb směrem k serveru
+  +5.0       — úspěšné připojení k serveru
+  +0.1/krok  — server-guided kroky (s ověřením konzistence akce)
+  -0.5       — každý krok kde server reportuje DEGRADED/OFFLINE health
+  SUCCESS    — 50 kroků po připojení s avg odměnou > 3.0
+"""
+from __future__ import annotations
+
+import numpy as np
+from .base import Task
+
+import sys, os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../..'))
+from engine.physics.rigid_body import vec3, length
+from engine.hardware.terminator_body import TerminatorBody
+from engine.hardware.polaris_server import PolarisServer
+
+
+_SERVER_POS = np.array([48.0, 0.5, 10.0], dtype=np.float32)
+_CONNECT_DIST = 3.0    # m — vzdálenost pro připojení
+_MIN_GUIDED_STEPS = 50 # kroků připojeného provozu pro SUCCESS
+
+
+class PolarisServerTask(Task):
+    """
+    Terminator → navigace k PolarisServer → připojení → guided trénink.
+
+    Ukazuje jak VoxForge fyzický server funguje jako distribuovaný
+    neurální koprocesor pro agenta.
+    """
+    name        = "polaris_server"
+    terrain     = "flat"
+    max_steps   = 1000
+    reset_noise = 0.1
+    body_class  = TerminatorBody
+
+    def reset(self, body, world_env):
+        body.reset(vec3(2.0, 2.0, 10.0))
+
+        # Server fyzicky existuje v továrně — vytvoříme ho při resetu
+        self._server = PolarisServer.factory_room(factory_x=48.0)
+
+        self._connected     = False
+        self._guided_steps  = 0
+        self._guided_reward = 0.0
+        self._prev_dist     = float(np.linalg.norm(
+            body.torso_pos()[:3] - _SERVER_POS
+        ))
+        self._is_terminator = hasattr(body, "get_hardware_state")
+        self._body = body
+
+        # Připojení se vyřeší automaticky při prvním přiblížení
+
+    def step_reward(self, body, world_env, action: np.ndarray) -> float:
+        if body.is_fallen():
+            return -10.0
+
+        pos     = np.array(body.torso_pos()[:3], dtype=np.float32)
+        dist    = float(np.linalg.norm(pos - _SERVER_POS))
+        reward  = 0.02   # živý bonus
+
+        # Fáze 1: navigace k serveru
+        if not self._connected:
+            progress = self._prev_dist - dist
+            reward += progress * 2.0   # motivace přibližovat se
+
+            # Připojení!
+            if dist <= _CONNECT_DIST:
+                self._connected = True
+                self._server.connect("terminator_1", task_type="fine_motor")
+                reward += 5.0
+                self._log_connect(dist)
+
+        # Fáze 2: guided kroky přes server
+        else:
+            state_vec = body.get_state()
+
+            # Server provede inference (MOTOR board)
+            server_action = self._server.infer("terminator_1", state_vec)
+
+            # Konzistence: jak moc se RL akce shoduje se serverovou?
+            consistency = float(
+                1.0 - np.mean(np.abs(action - server_action)) / 2.0
+            )
+            reward += 0.1 * consistency
+
+            # Server health penalty
+            diag = self._server.diagnostics()
+            if diag.health == "DEGRADED":
+                reward -= 0.5
+            elif diag.health == "OFFLINE":
+                reward -= 2.0
+
+            # Hebbian: server se učí z každého dobrého pohybu
+            if consistency > 0.6:
+                self._server.learn("terminator_1", state_vec, action)
+
+            self._guided_steps  += 1
+            self._guided_reward += reward
+
+        self._prev_dist = dist
+        return float(reward)
+
+    def _log_connect(self, dist: float):
+        diag = self._server.diagnostics()
+        import logging
+        log = logging.getLogger("phantom.embodied")
+        log.info(
+            "  [PolarisServer] Terminator PŘIPOJEN @ dist=%.2fm  server=%s  "
+            "boards=%s  coolant_out=%.1f°C",
+            dist, diag.health,
+            [(b["role"], b["health"]) for b in diag.board_states],
+            diag.coolant["outlet_temp_c"],
+        )
+
+    def is_done(self, body, world_env) -> bool:
+        if body.is_fallen():
+            return True
+        if self.success_condition(body, world_env):
+            return True
+        return world_env._tick >= self.max_steps
+
+    def success_condition(self, body, world_env) -> bool:
+        return (
+            self._connected
+            and self._guided_steps >= _MIN_GUIDED_STEPS
+            and not body.is_fallen()
+        )
+
+    def server_report(self) -> str:
+        """Volitelný výpis stavu serveru po epizodě."""
+        if not hasattr(self, "_server"):
+            return "(server nenastaven)"
+        return self._server.status_line()

embodied/tasks/reach.py

@@ -0,0 +1,57 @@
+"""Task: reach a randomly placed target with the right hand.
+
+Opravené tvarování odměny — silné proximity bonusy zabraňují alive-only lokálnímu optimu.
+"""
+from __future__ import annotations
+import numpy as np
+from .base import Task
+import sys, os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../..'))
+from engine.physics.rigid_body import vec3, length
+
+
+class ReachTask(Task):
+    name       = "reach"
+    terrain    = "flat"
+    max_steps  = 300
+    reset_noise: float = 0.25   # vyšší průzkum pro motoriku ruky
+
+    def reset(self, body, world_env):
+        body.reset(vec3(16.0, 2.0, 16.0))
+        rng = np.random.default_rng(world_env._tick + 1)
+        # Cíl: v dosahu ruky (blíže než dříve pro snazší učení)
+        angle = rng.uniform(0, 2 * np.pi)
+        r     = rng.uniform(0.3, 0.65)   # blíže (bylo 0.4–0.9)
+        self._target = body.torso_pos() + vec3(
+            float(r * np.cos(angle)),
+            float(rng.uniform(0.3, 0.7)),
+            float(r * np.sin(angle)),
+        )
+        self._prev_dist = self._hand_dist(body)
+
+    def _hand_dist(self, body):
+        hand = body.bodies["hand_R"]
+        return float(length(hand.position - self._target))
+
+    def step_reward(self, body, world_env, action):
+        dist = self._hand_dist(body)
+
+        # Dense proximity — even random exploration yields gradient from 1m range
+        if   dist < 0.12: proximity = 3.0
+        elif dist < 0.25: proximity = 1.5
+        elif dist < 0.45: proximity = 0.6
+        elif dist < 0.70: proximity = 0.20
+        elif dist < 1.00: proximity = 0.06
+        else:             proximity = 0.0
+
+        approach   = (self._prev_dist - dist) * 4.0
+        at_target  = 6.0 if dist < 0.12 else 0.0
+        alive      = 0.03 if not body.is_fallen() else -3.0
+        # Penalizuj pohyb nohou (agent nesmí chodit pryč od cíle)
+        leg_pen    = float(np.mean(np.square(action[0:4]))) * 0.15
+        arm_pen    = float(np.mean(np.square(action[4:8]))) * 0.005
+        self._prev_dist = dist
+        return approach + proximity + at_target + alive - leg_pen - arm_pen
+
+    def success_condition(self, body, world_env):
+        return self._hand_dist(body) < 0.15

embodied/tasks/reach_arm.py

@@ -0,0 +1,61 @@
+"""
+ReachArmTask — mikroúloha pro trénink natahování paže.
+
+Agent stojí na místě, cíl je vždy přímo vedle jeho ruky (1–3 kroky paže).
+Nezabývá se chůzí — pouze pohyb ramen/loktů/zápěstí.
+Slouží jako stepping stone před household_pick.
+"""
+from __future__ import annotations
+import numpy as np
+from .base import Task
+import sys, os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../..'))
+from engine.physics.rigid_body import vec3, length
+
+
+class ReachArmTask(Task):
+    name       = "reach_arm"
+    terrain    = "flat"
+    max_steps  = 200
+    reset_noise: float = 0.30
+
+    def reset(self, body, world_env):
+        body.reset(vec3(16.0, 2.0, 16.0))
+        rng = np.random.default_rng(world_env._tick + 7)
+        # Cíl vždy nahoru nebo do strany — čistě paže, žádná chůze
+        dx = float(rng.uniform(0.2, 0.55)) * float(rng.choice([-1, 1]))
+        dy = float(rng.uniform(0.1, 0.55))
+        dz = float(rng.uniform(-0.3, 0.3))
+        torso = body.torso_pos()
+        self._target = torso + vec3(dx, dy, dz)
+        self._prev_dist = self._dist(body)
+        self._best_dist  = self._prev_dist
+
+    def _dist(self, body) -> float:
+        return float(length(body.bodies["hand_R"].position - self._target))
+
+    def step_reward(self, body, world_env, action) -> float:
+        dist = self._dist(body)
+        self._best_dist = min(self._best_dist, dist)
+
+        # Hustá odměna za blízkost — průběžná, ne jen při dosažení
+        if   dist < 0.10: prox = 3.0
+        elif dist < 0.20: prox = 1.50
+        elif dist < 0.35: prox = 0.60
+        elif dist < 0.55: prox = 0.20
+        else:             prox = 0.0
+
+        approach   = (self._prev_dist - dist) * 6.0
+        success_b  = 8.0 if dist < 0.10 else 0.0
+        alive      = 0.04 if not body.is_fallen() else -3.0
+
+        # Penalizuj pouze pohyb nohou (kroky 0–3), paže jsou žádoucí
+        leg_pen  = float(np.mean(np.square(action[0:4]))) * 0.05
+        # Drobná penalizace švihu gripem (nechceme zbytečně svírat)
+        grip_pen = float(action[9] ** 2) * 0.02
+
+        self._prev_dist = dist
+        return approach + prox + success_b + alive - leg_pen - grip_pen
+
+    def success_condition(self, body, world_env) -> bool:
+        return self._dist(body) < 0.10

embodied/tasks/shape_sorter.py

@@ -0,0 +1,75 @@
+"""
+ShapeSorterTask — agent musí vzít tři tvary (čtverec, trojúhelník, hvězda)
+a vložit je do správných otvorů ve zdi.
+
+Odměna: za každý vložený tvar +5.0, průběžně přiblížení k nejbližšímu tvaru.
+"""
+from __future__ import annotations
+import sys, os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../..'))
+
+import numpy as np
+from engine.physics.rigid_body import vec3, length
+from embodied.tasks.base import Task
+from embodied.interactive_objects import ShapeSorterWall
+
+
+class ShapeSorterTask(Task):
+    name        = "shape_sorter"
+    terrain     = "flat"
+    max_steps   = 600
+    reset_noise: float = 0.30
+
+    def __init__(self):
+        self._wall: ShapeSorterWall = None
+        self._prev_hand_dist = 1.0
+        self._prev_inserted  = 0
+
+    def reset(self, body, world_env):
+        rng = np.random.default_rng(world_env._tick if hasattr(world_env, '_tick') else 0)
+        self._wall = ShapeSorterWall(world_env.phys, rng=rng)
+        self._prev_inserted  = 0
+        hand_R = body.hand_pos("R")
+        nearest = self._wall.nearest_piece(hand_R)
+        self._prev_hand_dist = (
+            float(length(nearest.body.position - hand_R)) if nearest else 2.0
+        )
+        world_env._objects = getattr(world_env, "_objects", {})
+        world_env._objects["shape_wall"] = self._wall
+
+    def step_reward(self, body, world_env, action) -> float:
+        if self._wall is None:
+            return 0.0
+
+        hand_R   = body.hand_pos("R")
+        inserted = self._wall.check_insertions()
+
+        # Bonus za každý nově vložený tvar
+        insert_bonus = (inserted - self._prev_inserted) * 5.0
+        self._prev_inserted = inserted
+
+        # Průběžné přiblížení k nejbližšímu nevloženému tvaru
+        nearest = self._wall.nearest_piece(hand_R)
+        if nearest is not None:
+            hand_dist = float(length(nearest.body.position - hand_R))
+            approach  = (self._prev_hand_dist - hand_dist) * 2.0
+            proximity = 0.25 if hand_dist < 0.25 else (0.08 if hand_dist < 0.7 else 0.0)
+            self._prev_hand_dist = hand_dist
+        else:
+            approach, proximity = 0.0, 0.0
+
+        alive      = 0.04
+        action_pen = float(np.mean(np.abs(action))) * 0.02
+        return insert_bonus + approach + proximity + alive - action_pen
+
+    def is_done(self, body, world_env) -> bool:
+        if body.is_fallen():
+            return True
+        if self.success_condition(body, world_env):
+            return True
+        return world_env._tick >= self.max_steps
+
+    def success_condition(self, body, world_env) -> bool:
+        if self._wall is None:
+            return False
+        return self._wall.all_inserted()

embodied/tasks/stairs.py

@@ -0,0 +1,30 @@
+"""Task: climb the staircase to the top."""
+from __future__ import annotations
+import numpy as np
+from .base import Task
+import sys, os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../..'))
+from engine.physics.rigid_body import vec3
+
+
+class StairsTask(Task):
+    name    = "stairs"
+    terrain = "stairs"
+    max_steps = 1200
+
+    def reset(self, body, world_env):
+        body.reset(vec3(4.0, 2.0, 32.0))
+        self._prev_x = 4.0
+
+    def step_reward(self, body, world_env, action):
+        curr_x  = float(body.torso_pos()[0])
+        height  = float(body.bodies["torso"].position[1])
+        progress = (curr_x - self._prev_x) * 1.5
+        height_r = height * 0.3
+        alive    = 0.2 if not body.is_fallen() else -2.0
+        action_pen = float(np.sum(np.square(action))) * 0.005
+        self._prev_x = curr_x
+        return progress + height_r + alive - action_pen
+
+    def success_condition(self, body, world_env):
+        return float(body.torso_pos()[0]) > 50.0 and float(body.bodies["torso"].position[1]) > 10.0

embodied/tasks/stand.py

@@ -0,0 +1,27 @@
+"""Task: stay upright as long as possible."""
+from __future__ import annotations
+import numpy as np
+from .base import Task
+import sys, os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../..'))
+from engine.physics.rigid_body import vec3
+
+
+class StandTask(Task):
+    name    = "stand"
+    terrain = "flat"
+    max_steps = 400
+
+    def reset(self, body, world_env):
+        body.reset(vec3(16.0, 2.0, 16.0))
+
+    def step_reward(self, body, world_env, action):
+        torso = body.bodies["torso"]
+        # Reward for high torso, penalty for large actions
+        height_reward = float(torso.position[1]) * 0.5
+        stability     = 1.0 - min(abs(float(torso.rotation[0])) + abs(float(torso.rotation[2])), 1.0)
+        action_penalty = float(np.sum(np.square(action))) * 0.01
+        return height_reward + stability * 0.3 - action_penalty
+
+    def success_condition(self, body, world_env):
+        return world_env._tick >= self.max_steps and not body.is_fallen()

embodied/tasks/terminator_factory.py

@@ -0,0 +1,30 @@
+"""Factory manipulation task for heavy humanoid robot tools."""
+from __future__ import annotations
+
+import numpy as np
+
+from embodied.tasks.base import Task
+from embodied.tasks.terminator_tools import run_tool_cycle
+
+
+class TerminatorFactoryTask(Task):
+    name = "terminator_factory"
+    terrain = "factory_floor"
+    max_steps = 1400
+    reset_noise = 0.10
+
+    def reset(self, body, world_env) -> None:
+        self._completed = 0
+        self._tool_cycle = ["gripper", "welder", "factory_lifter"]
+
+    def step_reward(self, body, world_env, action: np.ndarray) -> float:
+        tool_id = self._tool_cycle[self._completed % len(self._tool_cycle)]
+        telemetry = run_tool_cycle(tool_id, action)
+        reward = 0.05 + float(telemetry["stability"])
+        if telemetry["tool_ready"]:
+            self._completed += 1
+            reward += 2.0
+        return float(reward)
+
+    def success_condition(self, body, world_env) -> bool:
+        return self._completed >= 9

embodied/tasks/terminator_stand.py

@@ -0,0 +1,92 @@
+# ┌─────────────────────────────────────────────────────────────────────────┐
+# │  SUBSYSTÉM: PhantomCortex Cognitive Neural Engine — Task Layer           │
+# │  Modul:     TerminatorStand (RL task pro Terminator tělo)                │
+# │  Závislost: VoxForge 3D Engine / TerminatorBody (EHA-C + POLARIS)        │
+# └─────────────────────────────────────────────────────────────────────────┘
+"""
+TerminatorStand — demonstrační task pro TerminatorBody (POLARIS + EHA-C).
+
+Cíl: Terminator se udržuje vestoje co nejdéle.
+Bonus: POLARIS online Hebbovské učení ze zkušenosti.
+Diagnostika: hardware stav EHA-C + POLARIS zaznamenán v info.
+
+Kompatibilní s run_embodied.py přes TASK_REGISTRY (task_type="terminator_stand").
+"""
+from __future__ import annotations
+
+import logging
+import numpy as np
+
+from embodied.tasks.base import Task
+import sys, os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../..'))
+from engine.physics.rigid_body import vec3
+from engine.hardware.terminator_body import TerminatorBody
+
+
+
+
+log = logging.getLogger("phantom.terminator")
+
+
+class TerminatorStandTask(Task):
+    """
+    Terminator (POLARIS + 10× EHA-C) se udržuje vestoje.
+
+    Stav: standardní 28D z TerminatorBody.get_state() — PhantomCortex přijme beze změny.
+    Akce: 10D — hip L/R, knee L/R, shoulder L/R, elbow L/R, grip L/R.
+
+    Reward:
+      +torso_height × 0.5     — odměna za výšku
+      +stability × 0.3        — odměna za rovnováhu (náklon)
+      -action_penalty × 0.01  — trest za velké příkazy
+      -joint_fault × 2.0      — trest za přehřátý/vypnutý EHA-C kloub
+      +recup_bonus × 0.001    — bonus za rekuperovanou energii
+    """
+    name       = "terminator_stand"
+    terrain    = "flat"
+    max_steps  = 500
+    body_class = TerminatorBody
+
+    def reset(self, body, world_env):
+        self._body_is_terminator = isinstance(body, TerminatorBody)
+        body.reset(vec3(16.0, 2.0, 16.0))
+        self._prev_recup = 0.0
+
+    def step_reward(self, body, world_env, action: np.ndarray) -> float:
+        torso        = body.bodies["torso"]
+        height_r     = float(torso.position[1]) * 0.5
+        stability    = 1.0 - min(
+            abs(float(torso.rotation[0])) + abs(float(torso.rotation[2])), 1.0
+        )
+        action_pen   = float(np.sum(np.square(action))) * 0.01
+        reward       = height_r + stability * 0.3 - action_pen
+
+        if self._body_is_terminator:
+            hw = body.get_hardware_state()
+            # Trest za výpadky EHA-C
+            for jname, jstate in hw["joints"].items():
+                if jstate["health"] in ("SHUTDOWN", "FAULT"):
+                    reward -= 2.0
+                    break
+            # Bonus za rekuperaci energie
+            recup_now = hw["energy"]["recup_j"]
+            reward   += (recup_now - self._prev_recup) * 0.001
+            self._prev_recup = recup_now
+
+            # POLARIS online učení: aktuální stav → prováděná akce
+            state_vec = body.get_state()
+            body.polaris_learn(state_vec, action)
+
+        return float(reward)
+
+    def is_done(self, body, world_env) -> bool:
+        if body.is_fallen():
+            return True
+        if self._body_is_terminator and body.any_joint_shutdown():
+            log.warning("Terminator: EHA-C joint shutdown — epizoda ukončena")
+            return True
+        return world_env._tick >= self.max_steps
+
+    def success_condition(self, body, world_env) -> bool:
+        return world_env._tick >= self.max_steps and not body.is_fallen()

embodied/tasks/terminator_tools.py

@@ -0,0 +1,446 @@
+# ┌─────────────────────────────────────────────────────────────────────────┐
+# │  SUBSYSTÉM: PhantomCortex Cognitive Neural Engine — Task Layer           │
+# │  Modul:     Jemná motorika — nářadí (svářečka, šroub, montáž)           │
+# │  Závislost: TerminatorBody (EHA-C wrist + POLARIS fine-motor reflexy)    │
+# └─────────────────────────────────────────────────────────────────────────┘
+"""
+Tři tasky jemné motoriky pro TerminatorBody.
+
+TerminatorWeldTask — svařování podél čáry (2 m, přesnost ±8 cm)
+  Fáze 1: Uchopit svářecí hořák (tool pickup)
+  Fáze 2: Přiblížit špičku k začátku svaru (x=12, y=3.5, z=16)
+  Fáze 3: Jet podél svaru (dx+), udržovat vzdálenost 4–10 cm od povrchu
+  Kvalita: akumuluje se za každý krok se správnou vzdáleností + stabilitou ruky
+
+TerminatorScrewTask — utahování šroubů (5 šroubů, rotation + downforce)
+  Fáze 1: Přiblížit šroubovák ke šroubu (±5 cm přesnost)
+  Fáze 2: Zatlačit dolů (downforce > 0.3) + rotovat zápěstím
+  Kvalita: torque × time — čím pevněji a déle, tím lépe
+
+TerminatorAssemblyTask — zasunutí kolíku do díry (±3 cm přesnost, nejtěžší)
+  Fáze 1: Uchopit kolík
+  Fáze 2: Navigovat kolík nad dírou (přesnost ±3 cm)
+  Fáze 3: Zasunout dolů (udržet osu, nenaklánět)
+  SUCCESS: kolík v díře, odchylka < 2 cm
+"""
+from __future__ import annotations
+
+import math
+import numpy as np
+from .base import Task
+
+import sys, os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../..'))
+from engine.physics.rigid_body import vec3, length
+from engine.hardware.terminator_body import TerminatorBody
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# SVÁŘEČKA
+# ─────────────────────────────────────────────────────────────────────────────
+
+class TerminatorWeldTask(Task):
+    """
+    Terminator svaří 2m šev na ocelové desce.
+
+    Klíčové pro POLARIS:
+      - Zápěstní EHA-C musí udržet přesný úhel hořáku
+      - Ruka se pohybuje pomalu a stabilně (minimální velocity)
+      - Hebbian: každý správný krok = posílení vzoru "stabilní zápěstí + pohyb vpřed"
+    """
+    name        = "terminator_weld"
+    terrain     = "household"
+    max_steps   = 1500
+    reset_noise = 0.20
+    body_class  = TerminatorBody
+
+    # Svařovací šev: přímá čára na stole
+    WELD_START  = np.array([12.0, 3.5, 16.0], np.float32)
+    WELD_END    = np.array([14.0, 3.5, 16.0], np.float32)
+    WELD_LEN    = 2.0   # m
+    TORCH_POS   = np.array([11.5, 3.5, 16.0], np.float32)  # hořák leží vedle švu
+
+    # Optimální vzdálenost špičky hořáku od povrchu
+    OPT_DIST_MIN = 0.04   # 4 cm
+    OPT_DIST_MAX = 0.10   # 10 cm
+
+    def reset(self, body, world_env):
+        body.reset(vec3(10.5, 2.0, 15.5))
+        world_env.add_interactive_object(
+            "torch", "torch", vec3(*self.TORCH_POS),
+            size=vec3(0.04, 0.30, 0.04), mass=0.8,
+        )
+        self._phase           = "pickup"
+        self._weld_progress   = 0.0   # 0.0–1.0 (kolik švu je hotovo)
+        self._weld_quality    = 0.0   # akumulovaná kvalita
+        self._prev_hand_dist  = self._dist_to_torch(body, world_env)
+        self._prev_weld_x     = self.WELD_START[0]
+        self._holding_steps   = 0
+        self._stability_sum   = 0.0
+        self._is_terminator   = hasattr(body, "get_hardware_state")
+
+    def _dist_to_torch(self, body, world_env) -> float:
+        hp = body.hand_pos("R")
+        tp = world_env.get_object_pos("torch")
+        return float(length(hp - tp))
+
+    def step_reward(self, body, world_env, action: np.ndarray) -> float:
+        grip  = float(action[9])
+        hp    = body.hand_pos("R")
+
+        world_env.check_grasp("hand_R", hp, grip)
+        world_env.update_grasped(
+            {"hand_R": hp},
+            {"hand_R": body.bodies["hand_R"].velocity},
+        )
+
+        alive      = 0.04 if not body.is_fallen() else -3.0
+        action_pen = float(np.mean(np.square(action))) * 0.002
+        reward     = alive - action_pen
+
+        # ── Fáze 1: Uchopit hořák ────────────────────────────────────────
+        if self._phase == "pickup":
+            dist = self._dist_to_torch(body, world_env)
+            approach = (self._prev_hand_dist - dist) * 6.0
+            reward  += approach
+            if   dist < 0.20: reward += 2.0
+            if   dist < 0.10 and grip < -0.2: reward += 3.0
+            self._prev_hand_dist = dist
+
+            if world_env.is_grasped("torch"):
+                self._phase = "approach_weld"
+                reward += 10.0   # uchopit hořák = velká odměna
+
+        # ── Fáze 2: Přiblížit k začátku švu ─────────────────────────────
+        elif self._phase == "approach_weld":
+            torch_pos = world_env.get_object_pos("torch")
+            dist_to_start = float(np.linalg.norm(torch_pos - self.WELD_START))
+            reward += max(0.0, (2.0 - dist_to_start) * 1.5)
+            reward += 0.8   # drží hořák
+            if dist_to_start < 0.15:
+                self._phase = "weld"
+                reward += 8.0
+
+        # ── Fáze 3: Svařování ─────────────────────────────────────────────
+        elif self._phase == "weld":
+            torch_pos = world_env.get_object_pos("torch")
+
+            # Vzdálenost špičky od povrchu stolu (y=3.5)
+            surface_dist = abs(float(torch_pos[1]) - 3.5)
+
+            # Laterální přesnost (Z odchylka od švu)
+            z_error = abs(float(torch_pos[2]) - self.WELD_START[2])
+
+            # Pokrok podél švu (X osa)
+            weld_x   = float(torch_pos[0])
+            dx       = weld_x - self._prev_weld_x
+            progress = max(0.0, dx) / self.WELD_LEN
+            self._weld_progress = min(1.0, self._weld_progress + progress)
+            self._prev_weld_x   = weld_x
+
+            # Stabilita ruky (nízká velocity = jemný pohyb)
+            hand_vel  = body.bodies["hand_R"].velocity
+            stability = max(0.0, 1.0 - float(length(hand_vel)) * 3.0)
+            self._stability_sum += stability
+
+            # Kvalita svaru: správná vzdálenost + stabilita + přesnost Z
+            in_range = self.OPT_DIST_MIN <= surface_dist <= self.OPT_DIST_MAX
+            z_ok     = z_error < 0.08
+            if in_range and z_ok:
+                weld_quality = stability * 2.0
+                self._weld_quality += weld_quality
+                reward += weld_quality
+                reward += progress * 15.0   # pokrok vpřed
+            else:
+                reward -= z_error * 0.5     # trest za odchylku
+
+            reward += 0.5   # drží hořák
+
+            # POLARIS fine-motor update (pohyb hořáku podél čáry)
+            if self._is_terminator and in_range and z_ok:
+                body.polaris_learn(body.get_state(), action)
+
+            # Dokončení švu
+            if self._weld_progress >= 0.95:
+                quality_bonus = self._weld_quality * 0.5
+                reward += 50.0 + quality_bonus
+
+        return float(reward)
+
+    def is_done(self, body, world_env) -> bool:
+        if body.is_fallen(): return True
+        if self._weld_progress >= 0.95: return True
+        return world_env._tick >= self.max_steps
+
+    def success_condition(self, body, world_env) -> bool:
+        return self._weld_progress >= 0.95
+
+    def get_weld_stats(self) -> dict:
+        return {
+            "progress":  round(self._weld_progress * 100, 1),
+            "quality":   round(self._weld_quality, 2),
+            "stability": round(self._stability_sum / max(1, self._holding_steps), 3),
+        }
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# ŠROUBOVÁK
+# ─────────────────────────────────────────────────────────────────────────────
+
+class TerminatorScrewTask(Task):
+    """
+    Terminator utáhne 5 šroubů šroubovákem.
+
+    Klíčové: kombinace downforce (EHA-C loket dolů) + rotace zápěstí (grip action).
+    POLARIS se naučí koordinaci loket↓ + zápěstí→ jako jeden reflex.
+    """
+    name        = "terminator_screw"
+    terrain     = "household"
+    max_steps   = 1800
+    reset_noise = 0.18
+    body_class  = TerminatorBody
+
+    SCREWS = [
+        np.array([12.0, 3.5, 15.5], np.float32),
+        np.array([12.5, 3.5, 15.5], np.float32),
+        np.array([13.0, 3.5, 15.5], np.float32),
+        np.array([13.5, 3.5, 15.5], np.float32),
+        np.array([14.0, 3.5, 15.5], np.float32),
+    ]
+    DRIVER_POS = np.array([11.5, 3.5, 15.5], np.float32)
+
+    def reset(self, body, world_env):
+        body.reset(vec3(10.5, 2.0, 15.0))
+        world_env.add_interactive_object(
+            "screwdriver", "tool", vec3(*self.DRIVER_POS),
+            size=vec3(0.03, 0.25, 0.03), mass=0.4,
+        )
+        self._phase         = "pickup"
+        self._screws_done   = 0
+        self._current_screw = 0
+        self._torque_accum  = 0.0
+        self._prev_hand_dist = self._dist_hand_to(body, world_env, self.DRIVER_POS)
+        self._is_terminator = hasattr(body, "get_hardware_state")
+
+    def _dist_hand_to(self, body, world_env, target: np.ndarray) -> float:
+        hp = body.hand_pos("R")
+        return float(np.linalg.norm(np.array([hp[0], hp[1], hp[2]]) - target))
+
+    def step_reward(self, body, world_env, action: np.ndarray) -> float:
+        grip = float(action[9])
+        hp   = body.hand_pos("R")
+
+        world_env.check_grasp("hand_R", hp, grip)
+        world_env.update_grasped(
+            {"hand_R": hp},
+            {"hand_R": body.bodies["hand_R"].velocity},
+        )
+
+        alive      = 0.04 if not body.is_fallen() else -3.0
+        action_pen = float(np.mean(np.square(action))) * 0.002
+        reward     = alive - action_pen
+
+        # ── Pickup ───────────────────────────────────────────────────────
+        if self._phase == "pickup":
+            dist = self._dist_hand_to(body, world_env, self.DRIVER_POS)
+            reward += (self._prev_hand_dist - dist) * 5.0
+            if dist < 0.15: reward += 1.5
+            if dist < 0.08 and grip < -0.2: reward += 2.0
+            self._prev_hand_dist = dist
+            if world_env.is_grasped("screwdriver"):
+                self._phase = "approach_screw"
+                reward += 8.0
+
+        # ── Přiblížit k šroubu ────────────────────────────────────────────
+        elif self._phase == "approach_screw":
+            if self._current_screw >= len(self.SCREWS):
+                return reward + 30.0
+            screw_pos = self.SCREWS[self._current_screw]
+            driver_pos = world_env.get_object_pos("screwdriver")
+            dist = float(np.linalg.norm(
+                np.array([driver_pos[0], driver_pos[1], driver_pos[2]]) - screw_pos
+            ))
+            reward += max(0.0, (1.5 - dist) * 2.0)
+            reward += 0.3   # drží nástroj
+            if dist < 0.06:
+                self._phase = "screw"
+                self._torque_accum = 0.0
+                reward += 5.0
+
+        # ── Šroubování ────────────────────────────────────────────────────
+        elif self._phase == "screw":
+            driver_pos = world_env.get_object_pos("screwdriver")
+            screw_pos  = self.SCREWS[self._current_screw]
+            dist = float(np.linalg.norm(
+                np.array([driver_pos[0], driver_pos[1], driver_pos[2]]) - screw_pos
+            ))
+
+            # Downforce: loket dolů (action[6] < 0 = loket dolů)
+            downforce = max(0.0, -float(action[6]))
+            # Rotace zápěstí: grip oscilace (simuluje rotaci šroubováku)
+            wrist_rot = abs(float(action[9]))
+            torque    = downforce * wrist_rot
+
+            if dist < 0.08:
+                self._torque_accum += torque
+                reward += torque * 3.0
+
+                # POLARIS: naučit koordinaci loket↓ + grip
+                if self._is_terminator and torque > 0.1:
+                    body.polaris_learn(body.get_state(), action)
+
+                if self._torque_accum > 8.0:   # dost torque = šroub utažen
+                    self._screws_done   += 1
+                    self._current_screw += 1
+                    self._torque_accum  = 0.0
+                    reward += 12.0
+                    if self._current_screw < len(self.SCREWS):
+                        self._phase = "approach_screw"
+                    else:
+                        self._phase = "done"
+            else:
+                reward -= 0.1   # ztratil kontakt
+
+        elif self._phase == "done":
+            reward += 1.0   # hotovo, čeká na konec epizody
+
+        return float(reward)
+
+    def success_condition(self, body, world_env) -> bool:
+        return self._screws_done >= len(self.SCREWS)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# MONTÁŽ — KOLÍK DO DÍRY (nejtěžší)
+# ─────────────────────────────────────────────────────────────────────────────
+
+class TerminatorAssemblyTask(Task):
+    """
+    Terminator zasune válcový kolík do přesné díry (tolerance ±2 cm).
+
+    Toto je nejtěžší task jemné motoriky:
+      - Musí udržet kolík svisle (nenaklánět) při zasouvání
+      - Tolerance ±2 cm vyžaduje přesnou koordinaci obou rukou
+      - POLARIS se naučí "svislý grip" jako dedikovaný reflex
+    """
+    name        = "terminator_assembly"
+    terrain     = "household"
+    max_steps   = 2000
+    reset_noise = 0.15
+    body_class  = TerminatorBody
+
+    PEG_POS  = np.array([12.0, 3.5, 16.0], np.float32)   # kolík
+    HOLE_POS = np.array([13.5, 3.5, 16.0], np.float32)   # díra
+    HOLE_R   = 0.04   # poloměr díry (4 cm tolerance)
+    INSERT_DEPTH = 0.15   # m jak hluboko zasunout
+
+    def reset(self, body, world_env):
+        body.reset(vec3(11.0, 2.0, 15.5))
+        world_env.add_interactive_object(
+            "peg", "peg", vec3(*self.PEG_POS),
+            size=vec3(0.04, 0.20, 0.04), mass=0.3,
+        )
+        self._phase         = "pickup"
+        self._inserted      = False
+        self._insert_depth  = 0.0
+        self._tilt_penalty  = 0.0
+        self._prev_dist     = self._hand_to_peg(body, world_env)
+        self._is_terminator = hasattr(body, "get_hardware_state")
+
+    def _hand_to_peg(self, body, world_env) -> float:
+        hp = body.hand_pos("R")
+        pp = world_env.get_object_pos("peg")
+        return float(length(hp - pp))
+
+    def step_reward(self, body, world_env, action: np.ndarray) -> float:
+        grip = float(action[9])
+        hp   = body.hand_pos("R")
+
+        world_env.check_grasp("hand_R", hp, grip)
+        world_env.update_grasped(
+            {"hand_R": hp},
+            {"hand_R": body.bodies["hand_R"].velocity},
+        )
+
+        alive      = 0.05 if not body.is_fallen() else -3.0
+        action_pen = float(np.mean(np.square(action))) * 0.002
+        reward     = alive - action_pen
+
+        # ── Pickup kolíku ────────────────────────────────────────────────
+        if self._phase == "pickup":
+            dist = self._hand_to_peg(body, world_env)
+            reward += (self._prev_dist - dist) * 7.0
+            if dist < 0.15: reward += 2.0
+            if dist < 0.08 and grip < -0.3: reward += 4.0
+            self._prev_dist = dist
+            if world_env.is_grasped("peg"):
+                self._phase = "align"
+                reward += 12.0
+
+        # ── Zarovnat kolík nad díru ────────────────────────────────────────
+        elif self._phase == "align":
+            peg_pos = world_env.get_object_pos("peg")
+            peg_arr = np.array([peg_pos[0], peg_pos[1], peg_pos[2]])
+            # XZ vzdálenost od díry (ignoruj Y — výška)
+            xz_dist = float(np.sqrt(
+                (peg_arr[0] - self.HOLE_POS[0])**2 +
+                (peg_arr[2] - self.HOLE_POS[2])**2
+            ))
+            reward += max(0.0, (2.0 - xz_dist) * 3.0)
+            reward += 0.5   # drží kolík
+
+            # Stabilita (nenaklánět)
+            hand_vel = float(length(body.bodies["hand_R"].velocity))
+            reward  -= hand_vel * 0.3
+
+            if xz_dist < self.HOLE_R * 2:
+                self._phase = "insert"
+                reward += 15.0
+
+        # ── Zasouvání ─────────────────────────────────────────────────────
+        elif self._phase == "insert":
+            peg_pos = world_env.get_object_pos("peg")
+            peg_arr = np.array([peg_pos[0], peg_pos[1], peg_pos[2]])
+
+            xz_dist = float(np.sqrt(
+                (peg_arr[0] - self.HOLE_POS[0])**2 +
+                (peg_arr[2] - self.HOLE_POS[2])**2
+            ))
+
+            # Pohyb dolů (loket dolů = action[6] < 0)
+            downward = max(0.0, -float(action[6]))
+            if xz_dist < self.HOLE_R:
+                # V díře → zasouvej dolů
+                dy = max(0.0, float(peg_arr[1]) - (self.HOLE_POS[1] - self._insert_depth))
+                self._insert_depth += downward * 0.002
+                self._insert_depth  = min(self._insert_depth, self.INSERT_DEPTH)
+                reward += downward * 5.0
+                reward += 1.0   # v díře
+
+                # POLARIS: nácvik přesného svislého zasouvání
+                if self._is_terminator:
+                    body.polaris_learn(body.get_state(), action)
+
+                if self._insert_depth >= self.INSERT_DEPTH * 0.9:
+                    self._inserted = True
+                    reward += 60.0   # SUCCESS!
+            else:
+                # Mimo díru — penalizace za odchylku
+                reward -= xz_dist * 5.0
+                reward -= 0.5
+
+            # Stabilita při zasouvání
+            hand_vel = float(length(body.bodies["hand_R"].velocity))
+            tilt_pen = hand_vel * 0.5
+            self._tilt_penalty += tilt_pen
+            reward  -= tilt_pen
+
+        return float(reward)
+
+    def is_done(self, body, world_env) -> bool:
+        if body.is_fallen(): return True
+        if self._inserted:   return True
+        return world_env._tick >= self.max_steps
+
+    def success_condition(self, body, world_env) -> bool:
+        return self._inserted

embodied/tasks/timed_nav.py

@@ -0,0 +1,371 @@
+"""
+TimedNavigationTask — dojeď na cílový bod ve městě za daný čas.
+
+Tři módy emergentního chování:
+
+  mode="legal"    — přísné penalizace za rychlost
+    → agent se učí OPTIMALIZOVAT TRASU: zkratky, volné ulice,
+      vyhýbání uzávěrkám, správný výběr silnic (alej vs boulevard).
+      Porušení limitu = silná penalizace → nevyplatí se.
+
+  mode="realistic" — měkké penalizace, časový bonus
+    → agent se učí VYVAŽOVAT: na prázdné D1 pojede 150, v centru
+      dodrží 50 (semafory + ret.). Emerguje realistické řidičské
+      chování jako u skutečného řidiče ve spěchu.
+
+  mode="race"     — žádné rychlostní penalizace, jen čas
+    → čistý závodník: agent se naučí max rychlost na každém úseku,
+      ignoruje retardéry, semafory, jede nejkratší vzdáleností bez
+      ohledu na typ silnice.
+
+Odměnová funkce:
+  +goal_bonus       : dosažení cíle (+100 legal, +80 race)
+  +time_bonus       : zbývající čas při dosažení cíle (0..+50)
+  +progress_reward  : per-krok přiblížení k cíli
+  -time_penalty     : per-krok odečet (tlak → nestůj!)
+  -speed_violation  : překročení limitu (pouze legal/realistic)
+  -closure_pen      : uzávěrka
+  -crash_pen        : havárie -30
+  +regen_bonus      : rekuperace (jen legal)
+
+Observation (26D stejná jako DriveCity + rozšíření):
+  [0:18]  vehicle telemetrie
+  [18:24] city context (WP dist, heading, light, closure...)
+  [24]    vzdálenost k cíli (normalizovaná)
+  [25]    zbývající čas (normalizovaný 0-1)
+"""
+from __future__ import annotations
+
+import math
+import random
+from dataclasses import dataclass
+from typing import List, Optional, Tuple
+
+import numpy as np
+
+from embodied.tasks.base import Task
+from embodied.vehicle_body import VehicleBody
+from engine.city_builder.city_gen import CityGenerator, build_traffic_network
+from engine.city_builder.road_network import RoadNetwork
+from engine.city_builder.traffic import IntersectionNetwork
+from engine.city_builder.traffic_sim import TrafficSimulation
+
+
+# ── Konstanty ─────────────────────────────────────────────────────────────────
+
+_GOAL_RADIUS   = 30.0    # m — jak blízko = dosažení cíle
+_CRASH_PEN     = -30.0
+_CLOSURE_PEN   = -3.0
+
+# Rychlostní penalizace dle módu (per km/h překročení / 100)
+_SPEED_PEN = {
+    "legal":    -0.08,   # silná
+    "realistic": -0.02,  # měkká
+    "race":      0.0,    # žádná
+}
+
+# Časový bonus za cíl (base + zbývající čas)
+_GOAL_BONUS = {
+    "legal":    100.0,
+    "realistic": 80.0,
+    "race":      60.0,
+}
+
+# Náhodné starty/cíle rozmístěné po celé síti
+_CITY_POINTS = [
+    # (x, z, label)
+    (-1500, -1500, "start_JZ"),
+    ( 1500, -1500, "start_JV"),
+    ( 1500,  1500, "start_SV"),
+    (-1500,  1500, "start_SZ"),
+    (    0,     0, "centrum"),
+    ( -600,  -600, "centrum_JZ"),
+    (  600,   600, "centrum_SV"),
+    (-2800, -2800, "D1_západ"),
+    ( 3000, -2800, "D1_východ"),
+    (  800,  -800, "tunel_jih"),
+    ( -800,   800, "tunel_sever"),
+    ( 1800, -1800, "ring_JV"),
+    (-1800,  1800, "ring_SZ"),
+    (    0,  1200, "sever"),
+    (    0, -2000, "jih_centrum"),
+]
+
+
+# ── Helper ────────────────────────────────────────────────────────────────────
+
+def _dist(ax, az, bx, bz) -> float:
+    return math.sqrt((ax - bx) ** 2 + (az - bz) ** 2)
+
+
+def _optimal_time(dist_m: float, avg_speed_kmh: float = 65.0) -> float:
+    """Odhadovaný čas (s) pro zdatného řidiče na dané vzdálenosti."""
+    return dist_m / (avg_speed_kmh / 3.6)
+
+
+# ── Task ──────────────────────────────────────────────────────────────────────
+
+class TimedNavigationTask(Task):
+    """
+    Navigace bod→bod s časovým limitem.
+    Záměrně provokuje emergentní chování dle zvoleného módu.
+    """
+
+    name        = "timed_nav"
+    terrain     = "city"
+    max_steps   = 4000     # 64 s fyzikálního času @ 16ms/step
+    reset_noise = 0.10
+
+    def __init__(self, mode: str = "realistic", seed: int = 0, city_seed: int = 42):
+        assert mode in ("legal", "realistic", "race"), f"Neznámý mód: {mode}"
+        self.mode      = mode
+        self._rng      = random.Random(seed)
+        self._road_net = CityGenerator(seed=city_seed, closure_count=4).generate()
+        self._network  = build_traffic_network(self._road_net)
+        # Hustota provozu dle módu: race jede po skoro prázdných silnicích,
+        # realistic má normální provoz, legal jede v hustém provozu
+        _density = {"legal": 1.2, "realistic": 0.8, "race": 0.4}[mode]
+        self._traffic  = TrafficSimulation(
+            self._road_net, density_scale=_density, seed=city_seed, max_cars=80)
+        self._traffic.set_traffic_lights(self._network)
+        self._vehicle  = VehicleBody.phantom_vertex()
+        self._goal_pos: Tuple[float, float] = (0.0, 0.0)
+        self._goal_label = ""
+        self._start_pos: Tuple[float, float] = (0.0, 0.0)
+        self._time_limit_s  = 120.0
+        self._elapsed_s     = 0.0
+        self._reached_goal  = False
+        self._dist_to_goal  = 0.0
+        self._prev_dist     = 0.0
+        self._sim_time      = 0.0
+        self._speed_violations = 0
+        self._total_regen   = 0.0
+        self._shortcut_bonus_given = False
+
+    # ── Reset ─────────────────────────────────────────────────────────────────
+
+    def reset(self, body, world_env) -> None:
+        # Náhodně vyber start a cíl (minimálně 800 m od sebe)
+        pts = _CITY_POINTS.copy()
+        self._rng.shuffle(pts)
+        start = pts[0]
+        goal  = next((p for p in pts[1:] if _dist(p[0], p[1], start[0], start[1]) > 800), pts[-1])
+
+        self._start_pos  = (start[0], start[1])
+        self._goal_pos   = (goal[0],  goal[1])
+        self._goal_label = goal[2]   # label
+
+        dist_m = _dist(start[0], start[1], goal[0], goal[1])
+
+        # Časový limit: závisí na módu
+        # legal: velkorysejší (agent musí jet dobře, ne rychle)
+        # race:  těsný (musí jet max)
+        margin = {"legal": 2.0, "realistic": 1.5, "race": 1.1}[self.mode]
+        self._time_limit_s = _optimal_time(dist_m) * margin
+        self._elapsed_s    = 0.0
+        self._sim_time     = 0.0
+        self._reached_goal = False
+        self._prev_dist    = dist_m
+        self._dist_to_goal = dist_m
+        self._speed_violations = 0
+        self._total_regen  = 0.0
+        self._shortcut_bonus_given = False
+        self._traffic_collisions = 0
+
+        self._vehicle.reset(position=(start[0], 0.0, start[1]), heading_rad=0.0)
+        self._traffic.reset()
+
+        # Randomizuj uzávěrky v silniční síti
+        for seg in self._road_net.segments.values():
+            if "closure" in seg.features:
+                seg.features.remove("closure")
+        eligible = [s for s in self._road_net.segments.values()
+                    if s.road_type in ("city", "boulevard")]
+        for seg in self._rng.sample(eligible, k=min(4, len(eligible))):
+            seg.features.append("closure")
+
+    # ── Step reward ───────────────────────────────────────────────────────────
+
+    def step_reward(self, body, world_env, action: np.ndarray) -> float:
+        throttle = float(np.clip(action[0],  0.0, 1.0))
+        brake    = float(np.clip(-min(action[0], 0.0), 0.0, 1.0))
+        steer    = float(np.clip(action[2] if len(action) > 2 else 0.0, -1.0, 1.0))
+
+        tel = self._vehicle.step(throttle, brake, steer)
+        dt  = self._vehicle.DT
+        self._elapsed_s += dt
+        self._sim_time  += dt
+
+        px, _, pz = self._vehicle.position()
+        gx, gz    = self._goal_pos
+        reward    = 0.0
+
+        # ── Přiblížení k cíli ─────────────────────────────────────────────────
+        dist = _dist(px, pz, gx, gz)
+        progress = (self._prev_dist - dist) * 0.06
+        reward += max(-0.3, progress)
+        self._prev_dist    = dist
+        self._dist_to_goal = dist
+
+        # ── Dosažení cíle ─────────────────────────────────────────────────────
+        if dist < _GOAL_RADIUS and not self._reached_goal:
+            self._reached_goal = True
+            time_remaining = max(0.0, self._time_limit_s - self._elapsed_s)
+            time_bonus     = (time_remaining / self._time_limit_s) * 50.0
+            reward += _GOAL_BONUS[self.mode] + time_bonus
+            # Legal mód: bonus za rekuperaci (ekologický řidič)
+            if self.mode == "legal":
+                reward += self._total_regen * 5.0
+
+        # ── Rychlostní penalizace ─────────────────────────────────────────────
+        speed_pen = _SPEED_PEN[self.mode]
+        if speed_pen < 0.0:
+            seg = self._road_net.segment_at(px, pz)
+            limit = seg.speed_limit if seg else 50.0
+            excess = max(0.0, tel.speed_kmh - limit)
+            if excess > 5.0:
+                self._speed_violations += 1
+                reward += speed_pen * excess
+
+        # ── Semafor ──────────────────────────────────────────���────────────────
+        self._network.step(self._sim_time, dt)
+        if self.mode in ("legal", "realistic"):
+            near_junc = self._road_net.nearest_junction(px, pz)
+            if near_junc and near_junc.has_light and near_junc.dist_to(px, pz) < 20.0:
+                lt = self._network.lights.get(near_junc.light_id)
+                if lt:
+                    direction = "EW" if abs(near_junc.pos[0] - px) > abs(near_junc.pos[1] - pz) else "NS"
+                    if not lt.allows(direction) and tel.speed_kmh > 10.0:
+                        reward -= 6.0 if self.mode == "legal" else 2.0
+
+        # ── Uzávěrky / retardéry ─────────────────────────────────────────────
+        if self._road_net.is_blocked(px, pz):
+            reward += _CLOSURE_PEN
+
+        seg = self._road_net.segment_at(px, pz)
+        if seg and "speed_bump" in seg.features:
+            # HX-1 adaptivní EM tlumiče rekuperují energii z komprese pružení
+            # Vyšší rychlost = větší komprese = více rekuperované energie
+            damper_regen = tel.speed_kmh * 0.0003
+            self._total_regen += damper_regen * dt / 3600.0
+            reward += damper_regen * 0.004
+
+        # ── Zkratka — alej / servisní silnice ────────────────────────────────
+        # legal mód: odměn za chytré využití aleje nebo service road
+        if self.mode == "legal" and seg and seg.road_type == "alley":
+            if not self._shortcut_bonus_given and progress > 0.05:
+                reward += 2.0   # objevil zkratku!
+                self._shortcut_bonus_given = True
+
+        # ── Rekuperace ────────────────────────────────────────────────────────
+        regen = tel.regen_kw
+        self._total_regen += regen * dt / 3600.0
+        if self.mode in ("legal", "realistic"):
+            reward += regen * 0.002
+
+        # ── Časový tlak ───────────────────────────────────────────────────────
+        time_left = self._time_limit_s - self._elapsed_s
+        # Per-krok penalizace (exponenciálně roste jak čas ubývá)
+        urgency = 1.0 + max(0.0, 1.0 - time_left / self._time_limit_s) * 2.0
+        reward -= 0.02 * urgency
+
+        # ── Dopravní provoz — fyzika kolizí ──────────────────────────────────
+        agent_heading  = self._vehicle.heading()
+        agent_speed_ms = tel.speed_kmh / 3.6
+        traffic_events = self._traffic.step(dt, px, pz, agent_speed_ms, agent_heading)
+        for ev in traffic_events:
+            self._traffic_collisions += 1
+            if ev.is_crash:
+                crash_pen = -25.0 - min(15.0, ev.delta_v_agent * 2.0)
+                reward += crash_pen
+            else:
+                reward -= 2.0 if self.mode == "legal" else 1.0
+
+        # ── Havárie (vlastní vozidlo) ─────────────────────────────────────────
+        if self._vehicle.is_crashed():
+            reward += _CRASH_PEN
+
+        return float(reward)
+
+    # ── Terminace ─────────────────────────────────────────────────────────────
+
+    def is_done(self, body, world_env) -> bool:
+        if self._reached_goal:
+            return True
+        if self._elapsed_s >= self._time_limit_s:
+            return True
+        if self._vehicle.is_crashed():
+            return True
+        return world_env._tick >= self.max_steps
+
+    def success_condition(self, body, world_env) -> bool:
+        return self._reached_goal
+
+    def food_event(self, body, world_env) -> tuple:
+        if self._reached_goal:
+            return True, 1.0, 0.40
+        # Postupný přísun energie za přibližování
+        if self._dist_to_goal < 200.0:
+            return True, 0.10, 0.04
+        return False, 0.0, 0.0
+
+    # ── State override (stejný vzor jako DriveCity) ───────────────────────────
+
+    def get_task_state(self, body_state: np.ndarray) -> np.ndarray:
+        state = body_state.copy()
+        # [0:18] vehicle telemetrie
+        state[0:18] = np.array(self._vehicle.observation_vec(), dtype=np.float32)
+        # [18:24] základní city ctx
+        px, _, pz = self._vehicle.position()
+        gx, gz    = self._goal_pos
+        dist_norm = float(np.clip(self._dist_to_goal / 5000.0, 0.0, 1.0))
+        heading   = self._vehicle.heading()
+        goal_head = math.atan2(gz - pz, gx - px)
+        ang_err   = (goal_head - heading + math.pi) % (2 * math.pi) - math.pi
+        time_norm = float(np.clip(1.0 - self._elapsed_s / max(self._time_limit_s, 1.0), 0.0, 1.0))
+        state[18] = dist_norm
+        state[19] = float(ang_err / math.pi)        # směr k cíli
+        state[20] = time_norm                        # zbývající čas
+        state[21] = float(self._speed_violations / max(self._speed_violations + 1, 1))
+        state[22] = 1.0 if self._road_net.is_blocked(px, pz) else 0.0
+        state[23] = self._road_net.speed_limit_at(px, pz) / 130.0
+        state[24] = dist_norm
+        state[25] = time_norm
+        return state
+
+    # ── Info ──────────────────────────────────────────────────────────────────
+
+    def episode_info(self) -> dict:
+        tel = self._vehicle.state.telemetry
+        return {
+            "mode":              self.mode,
+            "goal":              self._goal_label,
+            "dist_to_goal_m":    round(self._dist_to_goal, 1),
+            "elapsed_s":         round(self._elapsed_s, 1),
+            "time_limit_s":      round(self._time_limit_s, 1),
+            "time_remaining_s":  round(max(0.0, self._time_limit_s - self._elapsed_s), 1),
+            "speed_violations":  self._speed_violations,
+            "reached_goal":      self._reached_goal,
+            "speed_kmh":         round(tel.speed_kmh, 1),
+            "regen_kwh":         round(self._total_regen, 4),
+            "traffic_cars":      self._traffic.active_count,
+            "traffic_collisions": self._traffic_collisions,
+        }
+
+
+# ── Tovární funkce ────────────────────────────────────────────────────────────
+
+class TimedNavLegal(TimedNavigationTask):
+    """Přísná varianta — agent se musí naučit trasu, ne jen rychlost."""
+    name = "timed_nav_legal"
+    def __init__(self, seed=0): super().__init__(mode="legal",    seed=seed)
+
+class TimedNavRealistic(TimedNavigationTask):
+    """Realistická varianta — emerguje řidičské chování ve spěchu."""
+    name = "timed_nav_realistic"
+    def __init__(self, seed=0): super().__init__(mode="realistic", seed=seed)
+
+class TimedNavRace(TimedNavigationTask):
+    """Závodní varianta — čistý rychlostní optimalizátor."""
+    name = "timed_nav_race"
+    def __init__(self, seed=0): super().__init__(mode="race",     seed=seed)