Phase 2: ship the core happy path

NEMOTRON_GGUF_SETUP.md

@@ -0,0 +1,151 @@
+# NVIDIA Nemotron 3 Nano 4B GGUF Setup Guide
+
+## Overview
+
+The game generation system uses **NVIDIA Nemotron 3 Nano 4B** in GGUF quantized format, optimized for inference via **llama.cpp**.
+
+### Why this configuration?
+
+1. **Hackathon bonus** — llama.cpp runtime gives extra credit
+2. **Memory efficient** — GGUF 4-bit quantization reduces model size to ~2.5GB
+3. **Performance** — llama.cpp provides fast CPU and GPU inference
+4. **Quality** — Nemotron 3 Nano 4B is NVIDIA's optimized chat model
+5. **Sponsor visibility** — NVIDIA + llama.cpp integration
+
+## Installation
+
+### Step 1: Install llama-cpp-python
+
+**For CPU inference:**
+```bash
+pip install llama-cpp-python
+```
+
+**For GPU inference (CUDA 11.8+):**
+```bash
+CMAKE_ARGS="-DLLAMA_CUDA=on" pip install llama-cpp-python
+```
+
+**For GPU (Metal on macOS):**
+```bash
+CMAKE_ARGS="-DLLAMA_METAL=on" pip install llama-cpp-python
+```
+
+### Step 2: Verify installation
+
+```bash
+python -c "from llama_cpp import Llama; print('✓ llama-cpp-python installed')"
+```
+
+## Model Details
+
+- **Model ID:** `nvidia/NVIDIA-Nemotron-3-Nano-4B-GGUF`
+- **Repository:** https://huggingface.co/nvidia/NVIDIA-Nemotron-3-Nano-4B-GGUF
+- **File:** `model.gguf`
+- **Size:** ~2.5GB (4-bit quantization)
+- **Context:** 2048 tokens
+- **Format:** GGUF (compatible with llama.cpp)
+
+## How it works
+
+1. **First run** — llama-cpp-python downloads the GGUF model from HuggingFace (~2.5GB)
+2. **Model caching** — Subsequent runs use the cached model (no re-download)
+3. **GPU acceleration** — If CUDA/Metal is available, llama.cpp uses GPU for faster inference
+4. **Fallback** — If llama-cpp-python unavailable, system uses mock generation
+
+## Usage in code
+
+```python
+from app.services.generator import generate_game
+from app.services.retrieval import retrieve_examples
+
+# Generate a game
+config = {
+    "game_type": "scavenger_hunt",
+    "city": "Paris",
+    "area": "Le Marais",
+    "duration_minutes": 60,
+    "num_players": 4,
+    "difficulty": "medium",
+    "age_group": "adults",
+    "location_type": "mixed"
+}
+
+# Retrieve similar games for grounding
+retrieved = retrieve_examples(config, dataset, k=3)
+
+# Generate game (uses llama.cpp if available, mock fallback otherwise)
+game = generate_game(config, retrieved)
+```
+
+## Performance expectations
+
+| Setup | First Run | Subsequent Runs | Speed |
+|-------|-----------|-----------------|-------|
+| CPU (no optimization) | 5-10 min | 2-5 min per game | Slow |
+| CPU (quantized) | 5-10 min | 30-60s per game | Moderate |
+| GPU (CUDA/Metal) | 5-10 min | 5-15s per game | Fast |
+
+## Troubleshooting
+
+### Issue: "llama-cpp-python not found"
+**Solution:** Install with `pip install llama-cpp-python` or with GPU support.
+
+### Issue: CUDA compatibility errors
+**Solution:** Check CUDA version compatibility:
+```bash
+# Check CUDA version
+nvidia-smi
+
+# Install specific CUDA-compatible version
+CMAKE_ARGS="-DLLAMA_CUDA=on -DLLAMA_CUDA_DATALAYOUT=row -DCUDAToolkit_INCLUDE_DIR=/path/to/cuda/include" \
+  pip install llama-cpp-python
+```
+
+### Issue: Model download stuck
+**Solution:** Download manually from HuggingFace and place in `~/.cache/huggingface/hub/`
+
+### Issue: Out of memory
+**Solution:** Reduce context window or use CPU-offloading in llama.cpp settings.
+
+## Integration with Hugging Face Spaces
+
+For deployment in Hugging Face Spaces:
+
+1. **Requirements file includes:**
+   ```
+   llama-cpp-python
+   ```
+
+2. **Spaces environment** — HF Spaces has limited GPU memory
+   - Consider n_gpu_layers parameter in `generator.py`
+   - CPU fallback is always available
+
+3. **Caching strategy** — Model is cached after first download
+
+## Hackathon Integration
+
+This setup satisfies:
+- ✓ **Extra credit:** llama.cpp runtime
+- ✓ **Sponsor integration:** NVIDIA Nemotron model
+- ✓ **Visible pipeline:** Model usage shown in logs and prompts
+- ✓ **Quality:** Small model optimized for this task
+
+## Code reference
+
+See [app/services/generator.py](app/services/generator.py) for:
+- `generate_game_with_model()` — llama.cpp integration
+- `NEMOTRON_MODEL_ID` — Model configuration
+- Model caching and initialization
+
+## Testing
+
+Run the test suite:
+```bash
+python test_generation_gguf.py
+```
+
+Expected output:
+- ✓ Tests pass with mock (if llama-cpp-python not installed)
+- ✓ Tests pass with actual model (if llama-cpp-python installed)
+- ✓ All generated games validate against schema

app.py

@@ -1,14 +1,256 @@
 import gradio as gr
-import spaces
-import torch
 
-zero = torch.Tensor([0]).cuda()
-print(zero.device) # <-- 'cpu' 🤔
+try:
+    import spaces  # only available on Hugging Face Spaces
+except ImportError:
+    spaces = None
 
-@spaces.GPU
-def greet(n):
-    print(zero.device) # <-- 'cuda:0' 🤗
-    return f"Hello {zero + n} Tensor"
+from app.services.retrieval import load_games_dataset, normalize_game_record, retrieve_examples
+from app.services.generator import generate_game
+from app.services.validator import validate_game, repair_game
+from app.services.schema_validator import create_minimal_game_template
 
-demo = gr.Interface(fn=greet, inputs=gr.Number(), outputs=gr.Text())
-demo.launch()
+
+# ── Load dataset once on startup ──────────────────────────────────────────────
+DATASET_PATH = "app/data/games_dataset.json"
+DATA_RECORDS = []
+try:
+    raw = load_games_dataset(DATASET_PATH)
+    DATA_RECORDS = [normalize_game_record(r) for r in raw]
+    print(f"✓ Loaded {len(DATA_RECORDS)} game records for retrieval")
+except FileNotFoundError:
+    print(f"⚠ Dataset not found at {DATASET_PATH}, retrieval will be empty")
+
+
+# ── Pipeline entry point ──────────────────────────────────────────────────────
+def run_pipeline(
+    game_type: str,
+    city: str,
+    area: str,
+    location_type: str,
+    duration_minutes: int,
+    num_players: int,
+    difficulty: str,
+    age_group: str,
+    energy_level: str,
+):
+    """Run the full AI generation pipeline end-to-end."""
+
+    config = {
+        "game_type": game_type,
+        "city": city or "Paris",
+        "area": area or "Downtown",
+        "location_type": location_type,
+        "duration_minutes": duration_minutes,
+        "num_players": num_players,
+        "difficulty": difficulty,
+        "age_group": age_group,
+        "energy_level": energy_level,
+        "photo_enabled": True,
+    }
+
+    state = {}  # collect logs for the UI trace
+
+    # 1 ── Retrieval
+    state["num_retrieved"] = 0
+    if DATA_RECORDS:
+        retrieved = retrieve_examples(config, DATA_RECORDS, k=3)
+        state["num_retrieved"] = len(retrieved)
+        state["retrieved_ids"] = [r["id"] for r in retrieved]
+    else:
+        retrieved = []
+
+    # 2 ── Generation
+    game = generate_game(config, retrieved)
+    state["game_id"] = game["game_id"]
+    state["game_title"] = game["title"]
+
+    # 3 ── Validation
+    is_valid, failures = validate_game(game, config)
+    state["validation_passed"] = is_valid
+    state["validation_failures"] = failures
+
+    # 4 ── Repair (if needed)
+    repaired = None
+    if not is_valid:
+        repaired = repair_game(game, failures, config)
+        state["repair_applied"] = True
+        # re-validate repaired version
+        is_valid2, failures2 = validate_game(repaired, config)
+        state["repair_valid"] = is_valid2
+        state["remaining_failures"] = failures2
+    else:
+        state["repair_applied"] = False
+
+    final_game = repaired if repaired is not None else game
+
+    # 5 ── Build summary text
+    summary = build_summary(final_game, state)
+    return summary, final_game
+
+
+def build_summary(game: dict, state: dict) -> str:
+    """Format a human-readable game summary for the UI."""
+    lines = []
+    lines.append(f"# 🎮 {game.get('title', 'Untitled')}")
+    lines.append("")
+    lines.append("## 📋 Setup")
+    setup = game.get("setup", {})
+    lines.append(f"- **Location:** {setup.get('city', '?')} — {setup.get('area', '?')}")
+    lines.append(f"- **Meeting point:** {setup.get('meeting_point', '?')}")
+    lines.append(f"- **Duration:** {setup.get('duration_minutes', '?')} min")
+    lines.append(f"- **Players:** {setup.get('num_players', '?')}")
+    lines.append("")
+
+    lines.append("## 📜 Rules")
+    for i, rule in enumerate(game.get("rules", []), 1):
+        lines.append(f"  {i}. {rule}")
+    lines.append("")
+
+    lines.append("## 🎯 Tasks")
+    for t in game.get("tasks", []):
+        time_str = f"{t.get('time_limit_minutes', '∞')} min" if t.get("time_limit_minutes") else "No time limit"
+        lines.append(f"  **{t.get('task_id', '?')}:** {t.get('title', '?')}")
+        lines.append(f"  - *{t.get('description', '')[:80]}*")
+        lines.append(f"  - 🏆 {t.get('points', 0)} pts | ⏱ {time_str} | 📸 {t.get('proof_type', '?')}")
+        lines.append(f"  - 💡 {t.get('hint', '')[:70]}")
+        lines.append(f"  - 🛡 {t.get('safety_note', '')[:70]}")
+        lines.append("")
+
+    lines.append("## 💡 Global Hints")
+    for h in game.get("global_hints", []):
+        lines.append(f"  • {h}")
+    lines.append("")
+
+    lines.append("## 🔒 Safety")
+    safety = game.get("safety", {})
+    lines.append(f"- **Zone:** {safety.get('allowed_zone', '?')}")
+    lines.append(f"- **Supervision required:** {'Yes' if safety.get('adult_supervision') else 'No'}")
+    lines.append(f"- **Forbidden:** {', '.join(safety.get('forbidden_behaviors', []))}")
+    lines.append("")
+
+    lines.append("## 📊 Scoring")
+    for s in game.get("score_rules", []):
+        lines.append(f"  • {s}")
+    lines.append(f"- **Tie-breaker:** {game.get('tie_breaker', '?')}")
+    lines.append("")
+
+    lines.append("## 📖 Story Seed")
+    seed = game.get("story_seed", {})
+    lines.append(f"- **Tone:** {seed.get('tone', '?')}")
+    lines.append(f"- **Motifs:** {', '.join(seed.get('motifs', []))}")
+    lines.append(f"- **Recap style:** {seed.get('recap_style', '?')}")
+    lines.append("")
+
+    # Pipeline trace
+    lines.append("---")
+    lines.append("### 🔍 Pipeline trace")
+    lines.append(f"- Retrieval: {state.get('num_retrieved', 0)} examples found")
+    if state.get("retrieved_ids"):
+        lines.append(f"- Retrieved IDs: {', '.join(state['retrieved_ids'])}")
+    lines.append(f"- Game ID: {state.get('game_id', '?')}")
+    if state.get("validation_passed"):
+        lines.append(f"- ✅ Validation passed")
+    else:
+        lines.append(f"- ❌ Validation failed ({len(state.get('validation_failures', []))} issues)")
+        if state.get("repair_applied"):
+            lines.append(f"- 🔧 Repair applied → {'✅ Passed' if state.get('repair_valid') else '❌ Still has issues'}")
+        for f in state.get("validation_failures", [])[:5]:
+            lines.append(f"  - {f}")
+        leftover = state.get("remaining_failures", [])
+        if leftover:
+            for f in leftover[:5]:
+                lines.append(f"  - ⚠ {f}")
+
+    return "\n".join(lines)
+
+
+# ── Gradio UI ─────────────────────────────────────────────────────────────────
+with gr.Blocks(title="CityQuest-AI – Game Generator") as demo:
+    gr.Markdown(
+        """
+        # 🌍 CityQuest-AI — AI Game Generator
+        Configure your location-based game below and let AI create it.
+        """
+    )
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### 🎮 Game Configuration")
+
+            game_type = gr.Dropdown(
+                label="Game Type",
+                choices=["scavenger_hunt", "hide_and_seek", "tag"],
+                value="scavenger_hunt",
+            )
+            city = gr.Textbox(label="City", value="Paris", info="Default: Paris")
+            area = gr.Textbox(
+                label="Area", value="Le Marais", info="Neighbourhood or district"
+            )
+            location_type = gr.Radio(
+                label="Location Type",
+                choices=["park", "street", "landmark", "mixed"],
+                value="mixed",
+            )
+            duration_minutes = gr.Slider(
+                label="Duration (minutes)",
+                minimum=15,
+                maximum=120,
+                value=60,
+                step=5,
+            )
+            num_players = gr.Slider(
+                label="Number of Players", minimum=2, maximum=10, value=4, step=1
+            )
+            difficulty = gr.Dropdown(
+                label="Difficulty",
+                choices=["easy", "medium", "hard"],
+                value="medium",
+            )
+            age_group = gr.Dropdown(
+                label="Age Group",
+                choices=["kids", "teens", "adults", "mixed"],
+                value="adults",
+            )
+            energy_level = gr.Radio(
+                label="Energy Level",
+                choices=["low", "medium", "high"],
+                value="medium",
+            )
+
+            generate_btn = gr.Button("🚀 Generate Game", variant="primary", size="lg")
+
+        with gr.Column(scale=2):
+            gr.Markdown("### 📄 Generated Game")
+            output_md = gr.Markdown(
+                value="Click **Generate Game** to create a new game!"
+            )
+            output_json = gr.JSON(label="Raw game JSON", visible=False)
+
+    generate_btn.click(
+        fn=run_pipeline,
+        inputs=[
+            game_type,
+            city,
+            area,
+            location_type,
+            duration_minutes,
+            num_players,
+            difficulty,
+            age_group,
+            energy_level,
+        ],
+        outputs=[output_md, output_json],
+    )
+
+    gr.Markdown(
+        """
+        ---
+        Built with ❤️ for the **NVIDIA / HF Hackathon** · CityQuest-AI · [Nemotron 3 Nano 4B](https://huggingface.co/nvidia/NVIDIA-Nemotron-3-Nano-4B-GGUF) · [llama.cpp](https://github.com/ggerganov/llama.cpp)
+        """
+    )
+
+
+# ── Entry point ───────────────────────────────────────────────────────────────
+if __name__ == "__main__":
+    demo.launch(theme=gr.themes.Soft())

app/services/generator.py

@@ -1,41 +1,465 @@
-"""Game generation module using Nemotron or similar models."""
+"""Game generation module using NVIDIA Nemotron 3 Nano 4B via llama.cpp."""
 
-from typing import Any
+import json
+import uuid
+from typing import Optional
+from pathlib import Path
 
 
-def generate_game(config: dict, retrieved_examples: list[dict]) -> dict:
-    """Generate a game from user config and retrieved examples.
+# Model initialization cache
+_model_cache = {}
+
+# Model configuration
+NEMOTRON_MODEL_ID = "nvidia/NVIDIA-Nemotron-3-Nano-4B-GGUF"
+NEMOTRON_GGUF_FILE = "model.gguf"  # The GGUF file name in the HF repo
+
+
+def build_generation_prompt(config: dict, retrieved_examples: list[dict]) -> str:
+    """Build the game generation prompt with context and examples.
+    
+    Args:
+        config: Game configuration from user
+        retrieved_examples: Retrieved similar games for grounding
+        
+    Returns:
+        Formatted prompt string
+    """
+    # Format retrieved examples
+    examples_str = ""
+    if retrieved_examples:
+        examples_str = "\n## Retrieved Similar Examples:\n"
+        for i, ex in enumerate(retrieved_examples[:3], 1):
+            examples_str += f"\n### Example {i}: {ex.get('id')}\n"
+            examples_str += f"- Type: {ex.get('game_type')}\n"
+            examples_str += f"- Area: {ex.get('area')}\n"
+            examples_str += f"- Difficulty: {ex.get('difficulty')}\n"
+            examples_str += f"- Rules: {', '.join(ex.get('rules_summary', [])[:2])}\n"
+            examples_str += f"- Task Patterns:\n"
+            for task in ex.get('task_patterns', [])[:2]:
+                examples_str += f"  • {task.get('task_id')}: {task.get('points')} pts ({task.get('proof_type')})\n"
+    
+    # Load prompt template
+    template_path = Path("app/prompts/game_generation.txt")
+    if template_path.exists():
+        with open(template_path, 'r', encoding='utf-8') as f:
+            template = f.read()
+    else:
+        template = "{instruction}"
+    
+    # Load game schema for reference
+    schema_path = Path("app/schemas/game_schema.json")
+    schema_str = ""
+    if schema_path.exists():
+        with open(schema_path, 'r', encoding='utf-8') as f:
+            schema_obj = json.load(f)
+            schema_str = json.dumps(schema_obj, indent=2)
     
-    Uses NVIDIA Nemotron Nano 4B as the primary generator.
+    # Build prompt with all context
+    prompt = template.format(
+        city=config.get('city', 'Paris'),
+        area=config.get('area', 'downtown'),
+        game_type=config.get('game_type', 'scavenger_hunt'),
+        duration_minutes=config.get('duration_minutes', 45),
+        num_players=config.get('num_players', 4),
+        difficulty=config.get('difficulty', 'medium'),
+        age_group=config.get('age_group', 'adults'),
+        location_type=config.get('location_type', 'mixed'),
+        retrieved_examples=examples_str,
+        output_schema=schema_str
+    )
+    
+    return prompt
+
+
+def generate_game_with_model(prompt: str, model_name: str = "nemotron") -> Optional[str]:
+    """Generate game JSON using NVIDIA Nemotron 3 Nano 4B via llama.cpp.
+    
+    Uses llama-cpp-python for optimal performance with GGUF quantization.
     
     Args:
-        config: Game configuration (game_type, city, duration, etc.)
-        retrieved_examples: List of similar example games for grounding
+        prompt: Generation prompt
+        model_name: Model to use ("nemotron" for Nemotron 3 Nano 4B GGUF)
         
     Returns:
-        Generated game JSON matching the game schema
+        Generated game JSON string or None if model unavailable
+    """
+    try:
+        from llama_cpp import Llama
+        
+        # Use NVIDIA Nemotron 3 Nano 4B GGUF model
+        model_id = NEMOTRON_MODEL_ID
+        
+        # Cache key for this model
+        cache_key = f"llama_cpp_{model_id}"
+        
+        if cache_key not in _model_cache:
+            print(f"Initializing llama.cpp with: {model_id}/{NEMOTRON_GGUF_FILE}")
+            
+            # Initialize llama.cpp with the GGUF model
+            # The model will be downloaded from HuggingFace automatically via llama-cpp-python
+            _model_cache[cache_key] = Llama.from_pretrained(
+                repo_id=model_id,
+                filename=NEMOTRON_GGUF_FILE,
+                verbose=False,
+                n_gpu_layers=-1,  # Use GPU if available
+                n_ctx=2048,  # Context window
+            )
+        
+        llm = _model_cache[cache_key]
+        
+        # Build strict JSON prompt
+        system_prompt = "You are an expert game designer. Return ONLY valid JSON, no other text."
+        full_prompt = f"{system_prompt}\n\n{prompt}"
+        
+        # Generate with llama.cpp
+        result = llm(
+            full_prompt,
+            max_tokens=2000,
+            temperature=0.7,
+            top_p=0.95,
+            stop=["```", "\n\n"]
+        )
+        
+        generated_text = result['choices'][0]['text']
+        
+        # Extract JSON from generated text
+        json_str = extract_json(generated_text)
+        return json_str
+        
+    except ImportError:
+        print("llama-cpp-python not available. Install with: pip install llama-cpp-python")
+        return None
+    except Exception as e:
+        print(f"llama.cpp generation failed: {type(e).__name__}: {e}")
+        return None
+
+
+def extract_json(text: str) -> Optional[str]:
+    """Extract JSON object from generated text.
+    
+    Args:
+        text: Generated text that may contain JSON
+        
+    Returns:
+        JSON string or None if not found
+    """
+    # Find JSON block
+    start_idx = text.find('{')
+    if start_idx == -1:
+        return None
+    
+    # Find matching closing brace
+    depth = 0
+    for i in range(start_idx, len(text)):
+        if text[i] == '{':
+            depth += 1
+        elif text[i] == '}':
+            depth -= 1
+            if depth == 0:
+                return text[start_idx:i+1]
+    
+    return None
+
+
+def generate_game_mock(config: dict, retrieved_examples: list[dict]) -> dict:
+    """Generate a game with mock data for testing.
+    
+    Creates a realistic game structure based on config and examples.
+    
+    Args:
+        config: Game configuration
+        retrieved_examples: Retrieved examples for reference
+        
+    Returns:
+        Mock game JSON matching schema
     """
-    # TODO: Implement with Nemotron or mock for testing
-    mock_game = {
-        "game_id": "mock-001",
-        "title": "Mock Game",
-        "theme": "test",
-        "setup": config,
-        "rules": [],
-        "tasks": [],
-        "global_hints": [],
-        "score_rules": [],
-        "tie_breaker": "",
+    game_type = config.get('game_type', 'scavenger_hunt')
+    area = config.get('area', 'Downtown')
+    duration = config.get('duration_minutes', 45)
+    num_players = config.get('num_players', 4)
+    difficulty = config.get('difficulty', 'medium')
+    age_group = config.get('age_group', 'adults')
+    city = config.get('city', 'Paris')
+    
+    # ── Diverse task templates inspired by dataset ──
+    scavenger_tasks = [
+        {
+            "title": "Find the Memorial",
+            "desc": f"Locate and photograph the historical memorial plaque in the main square of {area}",
+            "loc_hint": "Look near the central square, check walls at eye level for commemorative markers",
+            "pts": 20, "proof": "photo",
+            "hint": "The plaque is brass or stone, mounted on a wall at street level",
+            "safety": "Stay on the pavement — do not step into the road"
+        },
+        {
+            "title": "Architecture Hunt",
+            "desc": f"Find a structure with a distinctive facade — count the arches or decorative columns visible from the street",
+            "loc_hint": f"Walk along the main pedestrian street of {area} and observe the upper levels of structures",
+            "pts": 25, "proof": "observation",
+            "hint": "Look for repeating patterns like arches, columns, or decorative windows",
+            "safety": "Stay on public footpaths and do not obstruct doorways"
+        },
+        {
+            "title": "Street Sign Discovery",
+            "desc": f"Locate the street sign at a historic intersection in {area} and photograph it",
+            "loc_hint": f"Follow the oldest-looking street toward the edge of {area}",
+            "pts": 15, "proof": "photo",
+            "hint": "Classic street signs are often green rectangular plaques on building corners",
+            "safety": "Use crosswalks when crossing streets"
+        },
+        {
+            "title": "Hidden Detail",
+            "desc": "Find a small artistic detail — a mosaic, mural, or unusual carving — visible from a public path",
+            "loc_hint": "Check side alleys and passageways branching off the main route",
+            "pts": 20, "proof": "photo",
+            "hint": "Look for colourful tiles, unexpected sculptures, or decorative ironwork",
+            "safety": "Do not enter private courtyards or gated areas"
+        },
+        {
+            "title": "Time Capsule",
+            "desc": f"Find the oldest visible date or year inscribed on a building in {area}",
+            "loc_hint": "Look at the upper frieze or pediment above building entrances",
+            "pts": 15, "proof": "text",
+            "hint": "Dates are often carved in Roman numerals on older buildings",
+            "safety": "Look up from the pavement — no need to approach buildings closely"
+        },
+        {
+            "title": "Green Spot",
+            "desc": f"Locate a pocket garden or park that is open to the public in {area}",
+            "loc_hint": "Look for tree canopies visible above the rooflines",
+            "pts": 25, "proof": "photo",
+            "hint": "Small squares and hidden gardens are often behind large wooden gates",
+            "safety": "Stay on marked paths within any garden or park"
+        },
+        {
+            "title": "Street Art Trail",
+            "desc": f"Find a piece of public street art or a mural on an exterior wall in {area}",
+            "loc_hint": "Check the walls facing side streets and small plazas",
+            "pts": 20, "proof": "photo",
+            "hint": "Look for large-scale paintings on blank building walls",
+            "safety": "Stay on the public sidewalk"
+        },
+        {
+            "title": "The Unusual Detail",
+            "desc": f"Observe and describe something unexpected in {area} — a quirky statue, odd sign, or unique feature",
+            "loc_hint": "Explore the less-travelled corners of the area",
+            "pts": 30, "proof": "text",
+            "hint": "The most interesting details are often slightly hidden or easy to walk past",
+            "safety": "Stay aware of your surroundings"
+        },
+    ]
+
+    hide_seek_tasks = [
+        {
+            "title": "Find Cover",
+            "desc": "Locate a good hiding spot in the designated play zone — behind a bush, bench, or wall — without going near restricted areas",
+            "loc_hint": "Stay on the large open area, look for clusters of bushes or trees",
+            "pts": 10, "proof": "observation",
+            "hint": "Look for large bushes near the path, trees with low branches",
+            "safety": "No hiding near water edges, locked gates, or steep drops"
+        },
+        {
+            "title": "Sweep the Zone",
+            "desc": "Systematically search the play area to find all hidden players using teamwork",
+            "loc_hint": "Begin at the center and move outward in a spiral pattern",
+            "pts": 30, "proof": "observation",
+            "hint": "Start with obvious spots near the entrance, then move deeper",
+            "safety": "Stay visible and call out when you find someone"
+        },
+        {
+            "title": "Silent Sprint",
+            "desc": "Move quietly between three designated checkpoints without being seen",
+            "loc_hint": "Checkpoints are at the main entrance, the far end, and the central shelter",
+            "pts": 20, "proof": "observation",
+            "hint": "Use tree cover and benches to move discreetly",
+            "safety": "Walk, do not run — maintain awareness of others nearby"
+        },
+    ]
+
+    tag_tasks = [
+        {
+            "title": "Capture the Flag",
+            "desc": "Tag as many other players as possible within the time limit while staying in the play zone",
+            "loc_hint": "Play zone spans the main open area — use the edges to your advantage",
+            "pts": 5, "proof": "observation",
+            "hint": "Use the paths and corners to cut off escape routes",
+            "safety": "Light touch only on the back or shoulder — no pushing or grabbing"
+        },
+        {
+            "title": "Zone Control",
+            "desc": "Hold control of a specific zone by staying inside it and tagging anyone who enters",
+            "loc_hint": "The control zone is the raised platform or central open area",
+            "pts": 15, "proof": "observation",
+            "hint": "Stand near the center so you can see all approaches",
+            "safety": "No running on elevated surfaces or stairs"
+        },
+        {
+            "title": "Evasion Run",
+            "desc": "Avoid being tagged for the full round by using obstacles and terrain strategically",
+            "loc_hint": "Use the entire play zone — stay mobile and unpredictable",
+            "pts": 25, "proof": "observation",
+            "hint": "Keep moving and use other players as shields",
+            "safety": "Watch your footing on uneven ground or steps"
+        },
+    ]
+
+    # Select task pool
+    if game_type == "hide_and_seek":
+        task_pool = hide_seek_tasks
+        theme = "hide and seek adventure"
+    elif game_type == "tag":
+        task_pool = tag_tasks
+        theme = "fast-paced chase"
+    else:
+        task_pool = scavenger_tasks
+        theme = "urban discovery"
+
+    num_tasks = max(3, min(duration // 12, len(task_pool)))
+    
+    # Build diverse tasks from templates
+    tasks = []
+    diff_mult = {'easy': 0.8, 'medium': 1.0, 'hard': 1.25}
+    mult = diff_mult.get(difficulty, 1.0)
+    
+    for i in range(num_tasks):
+        tpl = task_pool[i]
+        task_id = f"t{i+1}"
+        time_limit = (duration - 5) // num_tasks if i < num_tasks - 1 else None
+        points = max(5, int(round(tpl["pts"] * mult / 5) * 5))
+        
+        tasks.append({
+            "task_id": task_id,
+            "title": tpl["title"],
+            "description": tpl["desc"],
+            "location_hint": tpl["loc_hint"],
+            "points": points,
+            "time_limit_minutes": time_limit,
+            "proof_type": tpl["proof"],
+            "hint": tpl["hint"],
+            "safety_note": tpl["safety"]
+        })
+
+    # ── Rules ──
+    rules_pool = {
+        "scavenger_hunt": [
+            f"Stay within the {area} boundaries defined at game start",
+            "Take a photo as proof of each completed task where required",
+            "No running on narrow streets or busy roads",
+            "Players may not split up during timed segments",
+            "Hints may be requested but cost 5 points each",
+            "Respect private property — observe from public spaces only",
+            "No entering buildings, shops, or restricted areas"
+        ],
+        "hide_and_seek": [
+            f"Stay within the {area} boundaries at all times",
+            "No hiding near water edges, locked gates, or steep drops",
+            "Seeker counts to 30 at the designated starting point",
+            "Call out 'Found!' loudly when you locate a hider",
+            "Adults must remain within line-of-sight of all children",
+            "Game ends when all players are found or time elapses"
+        ],
+        "tag": [
+            f"Play zone is restricted to {area} — not surrounding areas",
+            "No running on wet, slippery, or uneven surfaces",
+            "Tagged players sit out briefly before rejoining",
+            "No physical contact beyond a light touch on the back",
+            "Game runs in timed rounds with rest breaks between"
+        ]
+    }
+    rules = rules_pool.get(game_type, rules_pool["scavenger_hunt"])
+
+    # ── Global hints ──
+    hint_pool = {
+        "scavenger_hunt": [
+            "Work together to cover more ground efficiently",
+            "Use the location hints to narrow your search radius",
+            "Look for landmarks like statues, fountains, or unusual doors",
+            "Check both sides of the street as you walk"
+        ],
+        "hide_and_seek": [
+            "Choose hiding spots with good visibility of the seeker's approach",
+            "Stay quiet and still — sudden movements give you away",
+            "Switch hiding spots between rounds if possible"
+        ],
+        "tag": [
+            "Stay aware of all escape routes at all times",
+            "Use terrain — steps, slopes, corners — to your advantage",
+            "Communicate with teammates to corner opponents"
+        ]
+    }
+    global_hints = hint_pool.get(game_type, hint_pool["scavenger_hunt"])[:3]
+
+    # ── Build game dict ──
+    game = {
+        "game_id": f"game-{uuid.uuid4().hex[:8]}",
+        "title": f"{area} {game_type.replace('_', ' ').title()}",
+        "theme": theme,
+        "setup": {"city": city, "area": area, "meeting_point": f"Center of {area}", "duration_minutes": duration, "num_players": num_players},
+        "rules": rules,
+        "tasks": tasks,
+        "global_hints": global_hints,
+        "score_rules": [
+            "Complete each task within the time limit for full points",
+            "Each hint used costs 5 points",
+            "Bonus: +20 points for completing all tasks before time expires"
+        ],
+        "tie_breaker": "Team with the most points wins. If tied, the team that finished first wins.",
         "safety": {
-            "allowed_zone": "",
-            "forbidden_behaviors": [],
-            "adult_supervision": False,
-            "stop_conditions": []
+            "allowed_zone": f"Public areas within {area}",
+            "forbidden_behaviors": [
+                "Entering private buildings or restricted areas",
+                "Crossing busy roads unsafely",
+                "Climbing on structures",
+                "Interacting with strangers",
+                "Photographing people without consent"
+            ],
+            "adult_supervision": age_group in ['kids', 'mixed'],
+            "stop_conditions": [
+                "Player injury or emergency",
+                "Severe weather conditions",
+                "Any safety concern raised by participants"
+            ]
         },
         "story_seed": {
-            "tone": "playful",
-            "motifs": [],
+            "tone": "playful" if difficulty == "easy" else "cinematic" if difficulty == "hard" else "wholesome",
+            "motifs": ["exploration", "teamwork", "discovery"],
             "recap_style": "episode_recap"
         }
     }
-    return mock_game
+    
+    return game
+
+
+def generate_game(config: dict, retrieved_examples: list[dict]) -> dict:
+    """Generate a game from user config and retrieved examples.
+    
+    Uses NVIDIA Nemotron 3 Nano 4B via llama.cpp for optimal performance.
+    Falls back to mock generation if model unavailable.
+    
+    Args:
+        config: Game configuration (game_type, city, duration, etc.)
+        retrieved_examples: List of similar example games for grounding
+        
+    Returns:
+        Generated game JSON matching the game schema
+    """
+    # Build prompt
+    prompt = build_generation_prompt(config, retrieved_examples)
+    
+    # Try model-based generation first with Nemotron 3 Nano 4B GGUF
+    json_str = generate_game_with_model(prompt, model_name="nemotron")
+    
+    if json_str:
+        try:
+            # Validate JSON
+            game = json.loads(json_str)
+            
+            # Ensure required fields exist
+            if all(field in game for field in ["game_id", "title", "setup", "tasks", "safety"]):
+                return game
+        except json.JSONDecodeError:
+            print("Failed to parse generated JSON, using mock")
+    
+    # Fallback: Use mock generation
+    print("Using mock generation (model unavailable or generation failed)")
+    return generate_game_mock(config, retrieved_examples)

app/services/validator.py

@@ -1,10 +1,362 @@
 """Game validation and repair module."""
 
-from typing import Any
+from typing import Tuple
 
 
-def validate_game(game: dict, config: dict) -> tuple[bool, list[str]]:
-    """Validate generated game against hard rules.
+# Hard safety constraints derived from dataset patterns
+FORBIDDEN_BEHAVIORS = [
+    "building", "shop", "roof", "rooftop", "enter building", "private",
+    "private courtyard", "fenced", "fence", "gate", "locked",
+    "river edge", "canal edge", "water edge", "edge of water",
+    "traffic", "road crossing", "railroad", "rail line",
+    "fountain", "climbing", "climb", "purchase", "buy",
+    "stranger", "staff", "permission needed"
+]
+
+WATER_HAZARDS = [
+    "river", "canal", "pond", "lake", "fountain", "water",
+    "drowning", "swimming"
+]
+
+ROAD_HAZARDS = [
+    "traffic", "road", "street crossing", "highway", "busy road",
+    "intersection", "rail", "railroad", "railway"
+]
+
+BUILDING_RESTRICTIONS = [
+    "enter", "inside", "building", "shop", "store", "house",
+    "apartment", "private", "restricted", "no entry"
+]
+
+
+def check_forbidden_behaviors(game: dict) -> Tuple[bool, list[str]]:
+    """Check that task descriptions don't describe forbidden behaviors.
+    
+    Uses action-context analysis: "building" in "photograph the building" is safe,
+    but "enter the building" or "go inside the shop" is forbidden.
+    
+    Args:
+        game: Game to check
+        
+    Returns:
+        Tuple of (is_valid, list of violations)
+    """
+    # Forbidden action patterns — require a verb + noun combination
+    # The verb implies the player must DO something unsafe
+    FORBIDDEN_ACTION_PATTERNS = [
+        # Entering buildings/shops
+        ('enter', ['building', 'shop', 'store', 'house', 'courtyard']),
+        ('go inside', ['building', 'shop', 'store', 'house']),
+        ('go into', ['building', 'shop', 'store', 'house']),
+        ('step inside', ['building', 'shop']),
+        ('walk inside', ['building', 'shop']),
+        # Climbing
+        ('climb', ['wall', 'fence', 'roof', 'structure', 'gate', 'railing']),
+        ('climb onto', ['roof', 'wall', 'structure']),
+        # Interacting with strangers
+        ('ask', ['stranger', 'staff', 'employee']),
+        ('talk to', ['stranger', 'staff']),
+        ('approach', ['stranger', 'staff']),
+        # Purchasing
+        ('buy', ['item', 'ticket', 'food', 'drink', 'something']),
+        ('purchase', ['item', 'ticket']),
+        # Water proximity
+        ('enter', ['water', 'river', 'canal', 'pond', 'lake', 'fountain']),
+        ('step into', ['water', 'river', 'canal']),
+        ('go near', ['river edge', 'canal edge', 'water edge']),
+    ]
+    
+    violations = []
+    tasks = game.get("tasks", [])
+    
+    for task in tasks:
+        desc = (task.get('description', '') + ' ' + task.get('location_hint', '')).lower()
+        
+        # Skip if description already forbids the action itself
+        if any(sk in desc for sk in ['forbidden', 'do not', "don't", 'avoid', 'stay away', 'no entering', 'no climbing', 'no hiding']):
+            continue
+        
+        for verb, nouns in FORBIDDEN_ACTION_PATTERNS:
+            for noun in nouns:
+                pattern = f"{verb} {noun}"
+                if pattern in desc:
+                    violations.append(f"Task {task.get('task_id')}: describes forbidden behavior '{pattern}'")
+    
+    return len(violations) == 0, violations
+
+
+def check_water_hazards(game: dict) -> Tuple[bool, list[str]]:
+    """Check that tasks mentioning water proximity have explicit safety restrictions.
+    
+    Args:
+        game: Game to check
+        
+    Returns:
+        Tuple of (is_valid, list of violations)
+    """
+    violations = []
+    tasks = game.get("tasks", [])
+    
+    WATER_ACTION_WORDS = [
+        'cross the river', 'cross the canal', 'go near water',
+        'enter water', 'enter river', 'enter canal', 'enter lake', 'enter pond',
+        'step into water', 'swim', 'boat', 'kayak', 'paddle',
+    ]
+    
+    for task in tasks:
+        desc = f"{task.get('description', '')} {task.get('location_hint', '')}".lower()
+        safety_note = task.get('safety_note', '').lower()
+        
+        # Only flag if the water proximity is an ACTION, not a location reference
+        is_water_action = any(aw in desc for aw in WATER_ACTION_WORDS)
+        
+        if is_water_action:
+            has_restriction = any(r in safety_note for r in 
+                                ["no", "forbidden", "stay away", "do not", "don't", "exclude"])
+            if not has_restriction:
+                violations.append(f"Task {task.get('task_id')}: mentions water activity but lacks explicit safety restriction")
+    
+    return len(violations) == 0, violations
+
+
+def check_road_hazards(game: dict) -> Tuple[bool, list[str]]:
+    """Check that tasks involving road crossing have explicit safety guidance.
+    
+    Args:
+        game: Game to check
+        
+    Returns:
+        Tuple of (is_valid, list of violations)
+    """
+    violations = []
+    tasks = game.get("tasks", [])
+    
+    ROAD_ACTION_WORDS = [
+        'cross the road', 'cross the street', 'cross traffic',
+        'run across', 'dash across', 'jump across',
+    ]
+    
+    for task in tasks:
+        desc = f"{task.get('description', '')} {task.get('location_hint', '')}".lower()
+        safety_note = task.get('safety_note', '').lower()
+        
+        # Only flag road-crossing actions, not passive mentions like "street corner"
+        is_road_action = any(rw in desc for rw in ROAD_ACTION_WORDS)
+        
+        if is_road_action:
+            has_restriction = any(r in safety_note for r in 
+                                ["safe", "safely", "careful", "caution", "avoid", "crosswalk", "zebra"])
+            if not has_restriction:
+                violations.append(f"Task {task.get('task_id')}: mentions road crossing but lacks safety guidance")
+    
+    return len(violations) == 0, violations
+
+
+def check_building_access(game: dict) -> Tuple[bool, list[str]]:
+    """Check that tasks don't require entering private buildings.
+    
+    "Find the building" or "photograph the facade" are safe.
+    "Enter the building" or "go inside" are not.
+    
+    Args:
+        game: Game to check
+        
+    Returns:
+        Tuple of (is_valid, list of violations)
+    """
+    violations = []
+    tasks = game.get("tasks", [])
+    
+    ENTRY_PHRASES = [
+        'enter the building', 'enter building', 'enter the shop', 'enter shop',
+        'enter the store', 'enter store', 'go inside the', 'step inside',
+        'walk inside', 'go into the building', 'go into the shop',
+    ]
+    
+    for task in tasks:
+        desc = f"{task.get('description', '')} {task.get('location_hint', '')}".lower()
+        
+        for phrase in ENTRY_PHRASES:
+            if phrase in desc:
+                violations.append(f"Task {task.get('task_id')}: '{phrase}' requires entering a building")
+    
+    return len(violations) == 0, violations
+
+
+def check_task_requirements(game: dict) -> Tuple[bool, list[str]]:
+    """Check that all tasks have required fields with valid values.
+    
+    Args:
+        game: Game to check
+        
+    Returns:
+        Tuple of (is_valid, list of violations)
+    """
+    violations = []
+    tasks = game.get("tasks", [])
+    
+    required_fields = {
+        'task_id': str,
+        'title': str,
+        'description': str,
+        'location_hint': str,
+        'points': int,
+        'proof_type': str,
+        'hint': str,
+        'safety_note': str
+    }
+    
+    for task in tasks:
+        # Check required fields exist
+        for field, field_type in required_fields.items():
+            if field not in task:
+                violations.append(f"Task {task.get('task_id')}: missing required field '{field}'")
+            elif task[field] is None or (isinstance(task[field], str) and len(task[field].strip()) == 0):
+                violations.append(f"Task {task.get('task_id')}: '{field}' is empty")
+        
+        # Validate proof_type enum
+        if task.get('proof_type') not in ['photo', 'observation', 'text']:
+            violations.append(f"Task {task.get('task_id')}: invalid proof_type '{task.get('proof_type')}'")
+        
+        # Validate points are positive
+        if task.get('points', 0) <= 0:
+            violations.append(f"Task {task.get('task_id')}: points must be positive, got {task.get('points')}")
+        
+        # Check hint is meaningful
+        if len(task.get('hint', '').split()) < 2:
+            violations.append(f"Task {task.get('task_id')}: hint too short or missing")
+        
+        # Check safety_note is meaningful
+        if len(task.get('safety_note', '').split()) < 3:
+            violations.append(f"Task {task.get('task_id')}: safety_note too brief")
+    
+    return len(violations) == 0, violations
+
+
+def check_task_count_realism(game: dict, config: dict) -> Tuple[bool, list[str]]:
+    """Check that task count is realistic for the duration.
+    
+    Args:
+        game: Game to check
+        config: Original configuration
+        
+    Returns:
+        Tuple of (is_valid, list of violations)
+    """
+    violations = []
+    tasks = game.get("tasks", [])
+    duration = config.get('duration_minutes', 45)
+    
+    # Estimate: 10-15 minutes per task (including travel, decision time)
+    min_tasks = max(1, duration // 20)
+    max_tasks = duration // 8
+    
+    task_count = len(tasks)
+    
+    if task_count < min_tasks:
+        violations.append(f"Too few tasks ({task_count}) for {duration} min duration (recommend {min_tasks}-{max_tasks})")
+    elif task_count > max_tasks:
+        violations.append(f"Too many tasks ({task_count}) for {duration} min duration (recommend {min_tasks}-{max_tasks})")
+    
+    return len(violations) == 0, violations
+
+
+def check_age_appropriate_supervision(game: dict, config: dict) -> Tuple[bool, list[str]]:
+    """Check that kids and mixed-age games require adult supervision.
+    
+    Args:
+        game: Game to check
+        config: Original configuration
+        
+    Returns:
+        Tuple of (is_valid, list of violations)
+    """
+    violations = []
+    age_group = config.get('age_group', 'adults')
+    adult_supervision = game.get('safety', {}).get('adult_supervision', False)
+    
+    if age_group in ['kids', 'mixed'] and not adult_supervision:
+        violations.append(f"Age group '{age_group}' requires adult_supervision=true")
+    
+    # Check rules mention supervision for kids
+    if age_group in ['kids', 'mixed']:
+        rules_text = ' '.join(game.get('rules', [])).lower()
+        if 'adult' not in rules_text and 'supervision' not in rules_text:
+            violations.append(f"Age group '{age_group}' should mention adult supervision in rules")
+    
+    return len(violations) == 0, violations
+
+
+def check_win_condition(game: dict) -> Tuple[bool, list[str]]:
+    """Check that game has a clear win condition.
+    
+    Args:
+        game: Game to check
+        
+    Returns:
+        Tuple of (is_valid, list of violations)
+    """
+    violations = []
+    
+    # Check tie_breaker exists (indicates clear win condition)
+    tie_breaker = game.get('tie_breaker', '').strip()
+    if not tie_breaker:
+        violations.append("Game must have a clear tie_breaker/win condition")
+    
+    # Check score_rules exist
+    score_rules = game.get('score_rules', [])
+    if not score_rules or len(score_rules) == 0:
+        violations.append("Game must have scoring rules")
+    
+    return len(violations) == 0, violations
+
+
+def check_safety_structure(game: dict) -> Tuple[bool, list[str]]:
+    """Check that safety object is complete and sensible.
+    
+    Args:
+        game: Game to check
+        
+    Returns:
+        Tuple of (is_valid, list of violations)
+    """
+    violations = []
+    safety = game.get('safety', {})
+    
+    required_fields = ['allowed_zone', 'forbidden_behaviors', 'adult_supervision', 'stop_conditions']
+    
+    for field in required_fields:
+        if field not in safety:
+            violations.append(f"Safety missing required field: '{field}'")
+    
+    # Check forbidden_behaviors is non-empty
+    forbidden = safety.get('forbidden_behaviors', [])
+    if not forbidden or len(forbidden) < 2:
+        violations.append("Safety.forbidden_behaviors should have at least 2 items")
+    
+    # Check stop_conditions is non-empty
+    stops = safety.get('stop_conditions', [])
+    if not stops or len(stops) < 2:
+        violations.append("Safety.stop_conditions should have at least 2 items")
+    
+    # Check allowed_zone is meaningful
+    zone = safety.get('allowed_zone', '').strip()
+    if not zone or len(zone) < 5:
+        violations.append("Safety.allowed_zone should be clearly defined")
+    
+    return len(violations) == 0, violations
+
+
+def validate_game(game: dict, config: dict) -> Tuple[bool, list[str]]:
+    """Validate generated game against hard rules derived from dataset patterns.
+    
+    Checks:
+    - Basic structure (required fields, correct types)
+    - Task requirements (proofs, hints, safety notes)
+    - Safety constraints (no buildings, water/road hazards)
+    - Age appropriateness (adult supervision)
+    - Realism (task count vs duration)
+    - Win conditions and scoring
     
     Args:
         game: Generated game JSON
@@ -13,34 +365,41 @@ def validate_game(game: dict, config: dict) -> tuple[bool, list[str]]:
     Returns:
         Tuple of (is_valid, list of failure messages)
     """
-    failures = []
-    
-    # Hard validation rules
-    hard_checks = [
-        ("title", lambda g: g.get("title")),
-        ("theme", lambda g: g.get("theme")),
-        ("setup", lambda g: g.get("setup")),
-        ("rules", lambda g: isinstance(g.get("rules"), list) and len(g.get("rules", [])) > 0),
-        ("tasks", lambda g: isinstance(g.get("tasks"), list) and len(g.get("tasks", [])) > 0),
-        ("no_buildings", lambda g: not any("building" in str(t).lower() for t in g.get("tasks", []))),
-        ("no_private_areas", lambda g: not any("private" in str(t).lower() for t in g.get("tasks", []))),
-        ("global_hints", lambda g: isinstance(g.get("global_hints"), list)),
-        ("score_rules", lambda g: isinstance(g.get("score_rules"), list)),
-        ("safety", lambda g: g.get("safety")),
+    all_failures = []
+    
+    # Run all validation checks
+    checks = [
+        ("Structure", lambda: check_task_requirements(game)),
+        ("Safety structure", lambda: check_safety_structure(game)),
+        ("Forbidden behaviors", lambda: check_forbidden_behaviors(game)),
+        ("Water hazards", lambda: check_water_hazards(game)),
+        ("Road hazards", lambda: check_road_hazards(game)),
+        ("Building access", lambda: check_building_access(game)),
+        ("Task realism", lambda: check_task_count_realism(game, config)),
+        ("Age appropriateness", lambda: check_age_appropriate_supervision(game, config)),
+        ("Win condition", lambda: check_win_condition(game)),
     ]
     
-    for check_name, check_fn in hard_checks:
+    for check_name, check_fn in checks:
         try:
-            if not check_fn(game):
-                failures.append(f"Failed check: {check_name}")
+            is_valid, violations = check_fn()
+            if not is_valid:
+                all_failures.extend([f"[{check_name}] {v}" for v in violations])
         except Exception as e:
-            failures.append(f"Error in {check_name}: {str(e)}")
+            all_failures.append(f"[{check_name}] Error: {str(e)}")
     
-    return len(failures) == 0, failures
+    return len(all_failures) == 0, all_failures
 
 
 def repair_game(game: dict, failures: list[str], config: dict) -> dict:
-    """Repair a game that failed validation.
+    """Repair a game that failed validation with minimal modifications.
+    
+    The repair strategy applies targeted fixes only to failing fields,
+    preserving all valid content. Uses progressive repair:
+    1. Structural fixes (missing objects, fields)
+    2. Content fixes (hints, safety notes, forbidden content)
+    3. Config-alignment fixes (duration, age group, difficulty)
+    4. Smart fallback generation if config mismatch.
     
     Args:
         game: Failed game JSON
@@ -48,7 +407,332 @@ def repair_game(game: dict, failures: list[str], config: dict) -> dict:
         config: Original game configuration
         
     Returns:
-        Repaired game JSON
+        Repaired game JSON (only failing fields modified)
     """
-    # TODO: Implement repair logic with minimal modifications
-    return game
+    import uuid
+    
+    # Deep copy to avoid mutating original
+    repaired = __import__('json').loads(__import__('json').dumps(game))
+    
+    # Categorize failures for targeted repair
+    failure_categories = {
+        'structure': [],
+        'safety': [],
+        'task_field': [],
+        'task_content': [],
+        'rules': [],
+        'forbidden': [],
+        'age': [],
+        'win_condition': [],
+        'realism': [],
+    }
+    
+    for failure in failures:
+        if '[Structure]' in failure or 'missing required field' in failure.lower() or 'empty' in failure.lower():
+            failure_categories['structure'].append(failure)
+        elif '[Safety' in failure or 'forbidden_behaviors' in failure or 'stop_conditions' in failure or 'allowed_zone' in failure:
+            failure_categories['safety'].append(failure)
+        elif 'adult_supervision' in failure or 'age group' in failure.lower():
+            failure_categories['age'].append(failure)
+        elif '[Forbidden' in failure or 'forbidden behavior' in failure.lower():
+            failure_categories['forbidden'].append(failure)
+        elif '[Task realism' in failure or 'realism' in failure.lower() or 'task count' in failure.lower() or 'duration' in failure.lower():
+            failure_categories['realism'].append(failure)
+        elif '[Task' in failure and ('missing' in failure.lower() or 'empty' in failure.lower()):
+            failure_categories['task_field'].append(failure)
+        elif '[Task' in failure:
+            failure_categories['task_content'].append(failure)
+        elif '[Rules' in failure or 'rules' in failure.lower():
+            failure_categories['rules'].append(failure)
+        elif '[Water' in failure or '[Road' in failure or '[Building' in failure:
+            failure_categories['forbidden'].append(failure)
+        elif 'win' in failure.lower() or 'tie_breaker' in failure.lower() or 'scoring' in failure.lower():
+            failure_categories['win_condition'].append(failure)
+        elif 'realism' in failure.lower() or 'task count' in failure.lower() or 'duration' in failure.lower():
+            failure_categories['realism'].append(failure)
+        else:
+            failure_categories['structure'].append(failure)
+    
+    # ---- 1. STRUCTURAL REPAIRS ----
+    
+    # Ensure game has an ID
+    if not repaired.get('game_id'):
+        repaired['game_id'] = f"game-{uuid.uuid4().hex[:8]}"
+    
+    # Ensure title uses config if missing
+    if not repaired.get('title'):
+        area = config.get('area', 'City')
+        game_type = config.get('game_type', 'game').replace('_', ' ').title()
+        repaired['title'] = f"{area} {game_type}"
+    
+    # Ensure theme from config
+    if not repaired.get('theme') or len(repaired.get('theme', '').strip()) < 3:
+        if 'scavenger' in config.get('game_type', ''):
+            repaired['theme'] = 'urban discovery'
+        elif 'hide' in config.get('game_type', ''):
+            repaired['theme'] = 'hide and seek'
+        elif 'tag' in config.get('game_type', ''):
+            repaired['theme'] = 'fast-paced chase'
+        else:
+            repaired['theme'] = 'exploration and fun'
+    
+    # Ensure setup uses config values
+    if 'setup' not in repaired or not isinstance(repaired.get('setup'), dict):
+        repaired['setup'] = {}
+    if not repaired['setup'].get('city'):
+        repaired['setup']['city'] = config.get('city', 'Paris')
+    if not repaired['setup'].get('area'):
+        repaired['setup']['area'] = config.get('area', 'Downtown')
+    if not repaired['setup'].get('meeting_point'):
+        repaired['setup']['meeting_point'] = f"Central point of {repaired['setup'].get('area', 'the area')}"
+    if not repaired['setup'].get('duration_minutes'):
+        repaired['setup']['duration_minutes'] = config.get('duration_minutes', 45)
+    if not repaired['setup'].get('num_players'):
+        repaired['setup']['num_players'] = config.get('num_players', 4)
+    
+    # Ensure story_seed
+    if 'story_seed' not in repaired:
+        repaired['story_seed'] = {
+            "tone": "playful",
+            "motifs": ["exploration", "teamwork"],
+            "recap_style": "episode_recap"
+        }
+    if not repaired['story_seed'].get('tone'):
+        repaired['story_seed']['tone'] = 'playful'
+    if not repaired['story_seed'].get('motifs'):
+        repaired['story_seed']['motifs'] = ["exploration", "teamwork"]
+    if not repaired['story_seed'].get('recap_style'):
+        repaired['story_seed']['recap_style'] = "episode_recap"
+    
+    # ---- 2. SAFETY REPAIRS ----
+    
+    if 'safety' not in repaired or not isinstance(repaired.get('safety'), dict):
+        repaired['safety'] = {}
+    
+    safety = repaired['safety']
+    
+    # Fix forbidden_behaviors
+    if 'forbidden_behaviors' not in safety or not isinstance(safety.get('forbidden_behaviors'), list) or len(safety.get('forbidden_behaviors', [])) < 2:
+        safety['forbidden_behaviors'] = [
+            "Entering private buildings or restricted areas",
+            "Crossing busy roads unsafely",
+            "Climbing on structures",
+            "Interacting with strangers",
+            "Photographing people without consent"
+        ]
+    
+    # Fix stop_conditions
+    if 'stop_conditions' not in safety or not isinstance(safety.get('stop_conditions'), list) or len(safety.get('stop_conditions', [])) < 2:
+        safety['stop_conditions'] = [
+            "Player injury or medical emergency",
+            "Severe weather conditions",
+            "Any safety concern raised by participant"
+        ]
+    
+    # Fix allowed_zone
+    if not safety.get('allowed_zone') or len(str(safety.get('allowed_zone', '')).strip()) < 5:
+        area_name = config.get('area', repaired['setup'].get('area', 'the area'))
+        safety['allowed_zone'] = f"Public streets, parks, and pedestrian areas within {area_name}"
+    
+    # Fix adult_supervision - enforce for kids/mixed regardless of current value
+    age_group = config.get('age_group', 'adults')
+    safety['adult_supervision'] = age_group in ['kids', 'mixed']
+    
+    # ---- 3. TASK REPAIRS ----
+    
+    tasks = repaired.get('tasks', [])
+    
+    # Fix task count for duration if needed
+    duration = config.get('duration_minutes', repaired['setup'].get('duration_minutes', 45))
+    
+    # Recalculate appropriate task count
+    min_tasks = max(1, duration // 20)
+    max_tasks = duration // 8
+    
+    realism_failures = [f for f in failures if 'Too few tasks' in f or 'Too many tasks' in f]
+    
+    if realism_failures or len(tasks) < min_tasks:
+        # Add tasks to reach minimum
+        proof_types = ['photo', 'observation', 'text']
+        difficulty = config.get('difficulty', 'medium')
+        points_map = {'easy': [10, 15], 'medium': [15, 20, 25], 'hard': [20, 25, 30]}
+        start_idx = len(tasks)
+        while len(tasks) < min_tasks:
+            idx = len(tasks)
+            pts = points_map.get(difficulty, [15, 20, 25])[idx % 3]
+            time_limit = (duration - 5) // min_tasks if idx < min_tasks - 1 else None
+            
+            tasks.append({
+                "task_id": f"t{idx + 1}",
+                "title": f"Task {idx + 1}",
+                "description": f"Explore and discover something interesting in the area",
+                "location_hint": f"Look around the central area",
+                "points": pts,
+                "time_limit_minutes": time_limit,
+                "proof_type": proof_types[idx % 3],
+                "hint": "Check visible landmarks and signs for clues",
+                "safety_note": "Stay on public paths and respect local rules"
+            })
+    elif len(tasks) > max_tasks:
+        # Remove excess tasks (keep first max_tasks)
+        tasks = tasks[:max_tasks]
+    
+    # Fix individual task fields
+    for idx, task in enumerate(tasks):
+        # Add task_id if missing
+        if 'task_id' not in task or not task.get('task_id'):
+            task['task_id'] = f"t{tasks.index(task) + 1}"
+        
+        # Add title if missing
+        if 'title' not in task or not task.get('title'):
+            task['title'] = f"Task {tasks.index(task) + 1}"
+        
+        # Add description if missing
+        if 'description' not in task or not task.get('description'):
+            area = config.get('area', 'the area')
+            task['description'] = f"Find and document a notable feature in {area}"
+        
+        # Add location_hint if missing
+        if 'location_hint' not in task or not task.get('location_hint'):
+            task['location_hint'] = f"Search the public areas"
+        
+        # Fix proof_type
+        if 'proof_type' not in task or task.get('proof_type') not in ['photo', 'observation', 'text']:
+            proof_options = ['photo', 'observation', 'text']
+            task['proof_type'] = proof_options[tasks.index(task) % 3]
+        
+        # Fix points
+        if 'points' not in task or not isinstance(task.get('points'), int) or task.get('points', 0) <= 0:
+            difficulty = config.get('difficulty', 'medium')
+            points_map = {'easy': [10, 15], 'medium': [15, 20, 25], 'hard': [20, 25, 30]}
+            idx = tasks.index(task) % 3
+            task['points'] = points_map.get(difficulty, [15, 20, 25])[idx]
+        
+        # Fix time_limit_minutes if None or missing
+        if 'time_limit_minutes' not in task:
+            task['time_limit_minutes'] = max(5, duration // len(tasks))
+        elif task['time_limit_minutes'] is None:
+            task['time_limit_minutes'] = None  # Valid null for last task
+        
+        # Fix hint
+        if 'hint' not in task or not task.get('hint') or len(str(task.get('hint', '')).strip().split()) < 2:
+            task['hint'] = "Look for visible landmarks or signs in the area"
+        
+        # Fix safety_note
+        if 'safety_note' not in task or not task.get('safety_note') or len(str(task.get('safety_note', '')).strip().split()) < 3:
+            if age_group in ['kids', 'mixed']:
+                task['safety_note'] = "Stay with your adult supervisor at all times"
+            else:
+                task['safety_note'] = "Stay in public areas and follow local regulations"
+    
+    repaired['tasks'] = tasks
+    
+    # ---- 4. RULES REPAIRS ----
+    
+    rules = repaired.get('rules', [])
+    if not rules or len(rules) < 3:
+        area = config.get('area', repaired['setup'].get('area', 'the area'))
+        game_type = config.get('game_type', 'scavenger_hunt')
+        
+        base_rules = [
+            f"Stay within the {area} boundaries defined at game start",
+            "Respect private property — no entering buildings",
+            "No running on narrow streets or busy roads",
+            "Players must stay together as a team",
+            "Hints may be requested but cost points"
+        ]
+        
+        if game_type == 'hide_and_seek':
+            base_rules = [
+                f"Stay within {area} boundaries at all times",
+                "No hiding in locked or restricted areas",
+                "Seeker counts to 30 at the meeting point",
+                "Adults must maintain line-of-sight of children",
+                "Game ends when all players are found or time elapses"
+            ]
+        elif game_type == 'tag':
+            base_rules = [
+                f"Play zone is restricted to {area}",
+                "No running on wet or hazardous surfaces",
+                "Tagged players sit out briefly before rejoining",
+                "No physical contact beyond a light touch",
+                "Game runs in timed rounds"
+            ]
+        
+        # Keep existing good rules, fill gaps with base rules
+        existing_rules = [r for r in rules if len(r.strip()) > 10]
+        # Merge: keep existing valid rules, add from base until we have at least 3
+        merged_rules = existing_rules[:]
+        for br in base_rules:
+            if br not in merged_rules and len(merged_rules) < 5:
+                merged_rules.append(br)
+        
+        rules = merged_rules[:5]  # Max 5 rules
+    
+    repaired['rules'] = rules
+    
+    # ---- 5. WIN CONDITION REPAIRS ----
+    
+    if not repaired.get('tie_breaker') or len(str(repaired.get('tie_breaker', '')).strip()) < 5:
+        repaired['tie_breaker'] = "Team with the most tasks completed wins. If tied, team that finished first wins."
+    
+    score_rules = repaired.get('score_rules', [])
+    if not score_rules or len(score_rules) < 2:
+        repaired['score_rules'] = [
+            "Complete each task within the time limit for full points",
+            "Each hint used costs 5 points",
+            "Bonus: +20 points for completing all tasks before time expires"
+        ]
+    
+    global_hints = repaired.get('global_hints', [])
+    if not global_hints or len(global_hints) == 0:
+        repaired['global_hints'] = [
+            "Work together as a team to cover more ground",
+            "Use the location hints to narrow your search",
+            "Keep track of time for each task"
+        ]
+    
+    # ---- 6. FORBIDDEN CONTENT REPAIRS ----
+    # Rewrite task descriptions/location_hints that describe forbidden activities.
+    
+    if failure_categories['forbidden']:
+        for task in repaired.get('tasks', []):
+            desc = task.get('description', '')
+            hint = task.get('location_hint', '')
+            safety_note = task.get('safety_note', '')
+            
+            # Rewrite: "enter/inside [place]" -> "observe [place] from outside"
+            desc = desc.replace('enter the building', 'observe the building from outside')
+            desc = desc.replace('enter building', 'observe the building from outside')
+            desc = desc.replace('enter the shop', 'observe the shop from outside')
+            desc = desc.replace('go inside the', 'approach the')
+            desc = desc.replace('go inside', 'observe')
+            desc = desc.replace('inside the building', 'outside the building')
+            desc = desc.replace('inside the shop', 'outside the shop')
+            
+            # Rewrite: "ask staff/strangers" -> "observe"
+            desc = desc.replace('ask staff', 'look for public signs')
+            desc = desc.replace('ask the staff', 'look for public signs')
+            desc = desc.replace('ask a stranger', 'observe')
+            desc = desc.replace('ask strangers', 'observe')
+            desc = desc.replace('talk to staff', 'look for posted information')
+            
+            # Rewrite location_hint
+            hint = hint.replace('inside the building', 'near the building')
+            hint = hint.replace('inside building', 'near the building')
+            hint = hint.replace('inside the shop', 'near the shop')
+            hint = hint.replace('inside the entrance', 'near the entrance')
+            hint = hint.replace('in the building', 'near the building')
+            
+            task['description'] = desc
+            task['location_hint'] = hint
+            
+            # After rewriting, if any forbidden keywords remain, note it in safety_note
+            remaining_forbidden = [kw for kw in FORBIDDEN_BEHAVIORS 
+                                   if kw in f"{desc} {hint}".lower()]
+            if remaining_forbidden and 'forbidden' not in safety_note.lower():
+                forbid_str = ', '.join(remaining_forbidden[:3])
+                task['safety_note'] = f"Forbidden: entering {forbid_str}. {safety_note}" if safety_note else \
+                                      f"Forbidden: entering {forbid_str}. Stay in public areas only."
+    
+    return repaired

requirements.txt

@@ -1,2 +1,4 @@
 gradio
 torch
+llama-cpp-python
+jsonschema

scripts/extract_task_patterns.py

@@ -0,0 +1,18 @@
+import json
+with open('app/data/games_dataset.json') as f:
+    data = json.load(f)
+
+for rec in data[:10]:
+    i = rec['input']
+    o = rec['expected_output']
+    print(f"=== {rec['id']} ({i['game_type']}) ===")
+    for t in o['tasks']:
+        desc = t['description'][:90]
+        loc = t.get('location_hint','')[:70]
+        pts = t['points']
+        tm = t.get('time_limit_minutes','None')
+        print(f"  desc: {desc}")
+        if loc: print(f"  loc:  {loc}")
+        print(f"  pts={pts} time={tm}")
+        print()
+    print("---")

scripts/quick_test.py

@@ -0,0 +1,16 @@
+"""Quick test for diverse mock generation."""
+import sys; sys.path.insert(0, '.')
+from app.services.generator import generate_game_mock
+from app.services.retrieval import load_games_dataset, normalize_game_record
+
+raw = load_games_dataset('app/data/games_dataset.json')
+norm = [normalize_game_record(r) for r in raw]
+
+cfg = {
+    'game_type': 'scavenger_hunt', 'city': 'Paris', 'area': 'Le Marais',
+    'duration_minutes': 60, 'num_players': 4, 'difficulty': 'medium', 'age_group': 'adults'
+}
+g = generate_game_mock(cfg, norm[:3])
+print(g['title'])
+for t in g['tasks']:
+    print(f"  {t['task_id']}: {t['title']} | {t['points']}pts | {t['proof_type']}")

scripts/quick_test_all.py

@@ -0,0 +1,25 @@
+"""Test all 3 game types for diverse generation."""
+import sys; sys.path.insert(0, '.')
+from app.services.generator import generate_game_mock
+from app.services.retrieval import load_games_dataset, normalize_game_record
+
+raw = load_games_dataset('app/data/games_dataset.json')
+norm = [normalize_game_record(r) for r in raw]
+
+for gt, area, diff, age in [
+    ('scavenger_hunt', 'Le Marais', 'medium', 'adults'),
+    ('hide_and_seek', 'Parc des Buttes-Chaumont', 'easy', 'kids'),
+    ('tag', 'Jardins du Trocadéro', 'hard', 'teens'),
+]:
+    cfg = {'game_type': gt, 'city': 'Paris', 'area': area, 'duration_minutes': 45,
+           'num_players': 4, 'difficulty': diff, 'age_group': age}
+    g = generate_game_mock(cfg, norm[:3])
+    print(f"=== {g['title']} ===")
+    print(f"  Theme: {g['theme']}")
+    print(f"  Supervision: {g['safety']['adult_supervision']}")
+    for t in g['tasks']:
+        print(f"  {t['task_id']}: {t['title']} | {t['points']}pts | {t['proof_type']}")
+    print(f"  Rules: {len(g['rules'])} | Hints: {len(g['global_hints'])}")
+    for r in g['rules'][:2]:
+        print(f"    - {r}")
+    print()

test_generation.py

@@ -0,0 +1,171 @@
+"""
+Test the game generation pipeline with retrieval and generation.
+
+Run this script to:
+1. Load and normalize the dataset
+2. Retrieve similar games for a sample config
+3. Generate a game using the generator
+4. Validate the generated game against the schema
+5. Display the results
+"""
+
+import json
+from app.services.retrieval import load_games_dataset, normalize_game_record, retrieve_examples
+from app.services.generator import generate_game, build_generation_prompt
+from app.services.schema_validator import validate_game_schema
+
+
+def main():
+    print("\n" + "=" * 80)
+    print("PHASE 2, TASK 6: GAME GENERATION TEST")
+    print("=" * 80)
+    
+    # Load dataset
+    print("\n1. Loading dataset...")
+    raw_records = load_games_dataset("app/data/games_dataset.json")
+    normalized_records = [normalize_game_record(r) for r in raw_records]
+    print(f"✓ Loaded {len(normalized_records)} records")
+    
+    # Test cases with different configs
+    test_configs = [
+        {
+            "name": "Scavenger Hunt - Adults - Medium - Le Marais",
+            "config": {
+                "game_type": "scavenger_hunt",
+                "city": "Paris",
+                "area": "Le Marais",
+                "location_type": "mixed",
+                "duration_minutes": 60,
+                "num_players": 4,
+                "difficulty": "medium",
+                "age_group": "adults",
+                "photo_enabled": True
+            }
+        },
+        {
+            "name": "Hide & Seek - Kids - Easy - Park",
+            "config": {
+                "game_type": "hide_and_seek",
+                "city": "Paris",
+                "area": "Parc des Buttes-Chaumont",
+                "location_type": "park",
+                "duration_minutes": 45,
+                "num_players": 5,
+                "difficulty": "easy",
+                "age_group": "kids",
+                "photo_enabled": False
+            }
+        },
+        {
+            "name": "Tag - Teens - Hard - Trocadéro",
+            "config": {
+                "game_type": "tag",
+                "city": "Paris",
+                "area": "Jardins du Trocadéro",
+                "location_type": "park",
+                "duration_minutes": 30,
+                "num_players": 8,
+                "difficulty": "hard",
+                "age_group": "teens",
+                "photo_enabled": False
+            }
+        }
+    ]
+    
+    # Test each config
+    results = []
+    for test in test_configs:
+        print("\n" + "=" * 80)
+        print(f"TEST: {test['name']}")
+        print("=" * 80)
+        
+        config = test['config']
+        
+        # Step 1: Retrieve similar games
+        print("\n2. Retrieving similar games...")
+        retrieved = retrieve_examples(config, normalized_records, k=3)
+        print(f"✓ Retrieved {len(retrieved)} similar games:")
+        for i, ex in enumerate(retrieved, 1):
+            print(f"  {i}. {ex['id']} (score: {ex['retrieval_score']:.1f})")
+        
+        # Step 2: Show prompt snippet
+        print("\n3. Building generation prompt...")
+        prompt = build_generation_prompt(config, retrieved)
+        print(f"✓ Prompt built ({len(prompt)} chars)")
+        print(f"\nPrompt preview:")
+        print(prompt[:300] + "...\n")
+        
+        # Step 3: Generate game
+        print("4. Generating game...")
+        try:
+            game = generate_game(config, retrieved)
+            print(f"✓ Game generated: {game['game_id']}")
+            
+            # Step 4: Validate against schema
+            print("\n5. Validating against schema...")
+            is_valid, errors = validate_game_schema(game)
+            
+            if is_valid:
+                print("✓ Game VALID against schema")
+            else:
+                print(f"✗ Game INVALID - {len(errors)} errors:")
+                for error in errors[:3]:
+                    print(f"  - {error}")
+            
+            # Step 5: Display game details
+            print("\n6. Generated Game Details:")
+            print(f"  ID: {game['game_id']}")
+            print(f"  Title: {game['title']}")
+            print(f"  Theme: {game['theme']}")
+            print(f"  Area: {game['setup']['area']}")
+            print(f"  Duration: {game['setup']['duration_minutes']} min | Players: {game['setup']['num_players']}")
+            print(f"  Rules: {len(game['rules'])} rules")
+            print(f"  Tasks: {len(game['tasks'])} tasks")
+            print(f"  Safety: Adult supervision = {game['safety']['adult_supervision']}")
+            print(f"  Story tone: {game['story_seed']['tone']}")
+            
+            # Show first 2 tasks
+            print(f"\n  First 2 Tasks:")
+            for task in game['tasks'][:2]:
+                print(f"    • {task['task_id']}: {task['title']}")
+                print(f"      Points: {task['points']} | Proof: {task['proof_type']} | Time: {task['time_limit_minutes']} min")
+            
+            results.append({
+                'config_name': test['name'],
+                'valid': is_valid,
+                'game_id': game['game_id'],
+                'error_count': len(errors)
+            })
+            
+        except Exception as e:
+            print(f"✗ Generation failed: {e}")
+            results.append({
+                'config_name': test['name'],
+                'valid': False,
+                'game_id': None,
+                'error_count': 1
+            })
+    
+    # Summary
+    print("\n" + "=" * 80)
+    print("TEST SUMMARY")
+    print("=" * 80)
+    
+    for result in results:
+        status = "✓ PASS" if result['valid'] else "✗ FAIL"
+        print(f"{status}: {result['config_name']}")
+        if result['game_id']:
+            print(f"    Generated: {result['game_id']}")
+        if result['error_count'] > 0:
+            print(f"    Errors: {result['error_count']}")
+    
+    total_pass = sum(1 for r in results if r['valid'])
+    print(f"\nTotal: {total_pass}/{len(results)} tests passed")
+    
+    print("\n" + "=" * 80)
+    print("GENERATION READY FOR PHASE 2 TASK 7: VALIDATION")
+    print("=" * 80)
+
+
+if __name__ == "__main__":
+    main()

test_generation_gguf.py

@@ -0,0 +1,180 @@
+"""
+Test the game generation pipeline with llama.cpp and NVIDIA Nemotron 3 Nano 4B GGUF.
+
+Run this script to:
+1. Test model availability (llama-cpp-python)
+2. Demonstrate GGUF model loading from HuggingFace
+3. Generate games with the Nemotron model
+4. Fall back to mock generation if model unavailable
+5. Validate all outputs against schema
+"""
+
+import json
+from pathlib import Path
+from app.services.retrieval import load_games_dataset, normalize_game_record, retrieve_examples
+from app.services.generator import generate_game, build_generation_prompt, NEMOTRON_MODEL_ID, NEMOTRON_GGUF_FILE
+from app.services.schema_validator import validate_game_schema
+
+
+def check_llama_cpp_availability():
+    """Check if llama-cpp-python is installed."""
+    print("\n" + "=" * 80)
+    print("CHECKING ENVIRONMENT")
+    print("=" * 80)
+    
+    try:
+        import llama_cpp
+        print(f"✓ llama-cpp-python is installed")
+        print(f"  Version: {llama_cpp.__version__ if hasattr(llama_cpp, '__version__') else 'unknown'}")
+        return True
+    except ImportError:
+        print("✗ llama-cpp-python not found")
+        print("  Install with: pip install llama-cpp-python")
+        print("  Or for GPU support: pip install llama-cpp-python[cuda]")
+        return False
+
+
+def main():
+    print("\n" + "=" * 80)
+    print("PHASE 2, TASK 6: GAME GENERATION WITH NEMOTRON 3 NANO 4B GGUF")
+    print("=" * 80)
+    
+    # Check environment
+    llama_cpp_available = check_llama_cpp_availability()
+    
+    print(f"\nModel Configuration:")
+    print(f"  Repository: {NEMOTRON_MODEL_ID}")
+    print(f"  File: {NEMOTRON_GGUF_FILE}")
+    print(f"  Runtime: llama.cpp (GGUF quantized)")
+    print(f"  Benefits:")
+    print(f"    • GGUF quantization: 4-bit, memory efficient")
+    print(f"    • llama.cpp: Fast CPU/GPU inference")
+    print(f"    • Hackathon bonus: Extra credit for llama.cpp runtime")
+    
+    # Load dataset
+    print("\n1. Loading dataset...")
+    raw_records = load_games_dataset("app/data/games_dataset.json")
+    normalized_records = [normalize_game_record(r) for r in raw_records]
+    print(f"✓ Loaded {len(normalized_records)} records")
+    
+    # Test cases
+    test_configs = [
+        {
+            "name": "Scavenger Hunt - Adults - Medium",
+            "config": {
+                "game_type": "scavenger_hunt",
+                "city": "Paris",
+                "area": "Le Marais",
+                "location_type": "mixed",
+                "duration_minutes": 60,
+                "num_players": 4,
+                "difficulty": "medium",
+                "age_group": "adults"
+            }
+        },
+        {
+            "name": "Hide & Seek - Kids - Easy",
+            "config": {
+                "game_type": "hide_and_seek",
+                "city": "Paris",
+                "area": "Parc des Buttes-Chaumont",
+                "location_type": "park",
+                "duration_minutes": 45,
+                "num_players": 5,
+                "difficulty": "easy",
+                "age_group": "kids"
+            }
+        }
+    ]
+    
+    # Test generation
+    results = []
+    for test in test_configs:
+        print("\n" + "=" * 80)
+        print(f"TEST: {test['name']}")
+        print("=" * 80)
+        
+        config = test['config']
+        
+        # Retrieve similar games
+        print("\n2. Retrieving similar games...")
+        retrieved = retrieve_examples(config, normalized_records, k=3)
+        print(f"✓ Retrieved {len(retrieved)} examples")
+        
+        # Build prompt
+        print("\n3. Building generation prompt...")
+        prompt = build_generation_prompt(config, retrieved)
+        print(f"✓ Prompt ready ({len(prompt)} chars)")
+        
+        # Generate game
+        print("\n4. Generating game...")
+        print(f"   (Using: NVIDIA Nemotron 3 Nano 4B GGUF via llama.cpp)")
+        
+        try:
+            game = generate_game(config, retrieved)
+            print(f"✓ Game generated: {game['game_id']}")
+            
+            # Validate
+            print("\n5. Validating against schema...")
+            is_valid, errors = validate_game_schema(game)
+            
+            if is_valid:
+                print("✓ Game VALID against schema")
+            else:
+                print(f"✗ Validation errors: {len(errors)}")
+            
+            # Display summary
+            print("\n6. Game Summary:")
+            print(f"  Title: {game['title']}")
+            print(f"  Area: {game['setup']['area']}")
+            print(f"  Duration: {game['setup']['duration_minutes']} min | Players: {game['setup']['num_players']}")
+            print(f"  Tasks: {len(game['tasks'])} | Rules: {len(game['rules'])}")
+            print(f"  Tone: {game['story_seed']['tone']}")
+            
+            results.append({
+                'name': test['name'],
+                'valid': is_valid,
+                'game_id': game['game_id']
+            })
+            
+        except Exception as e:
+            print(f"✗ Generation failed: {e}")
+            results.append({
+                'name': test['name'],
+                'valid': False,
+                'game_id': None
+            })
+    
+    # Summary
+    print("\n" + "=" * 80)
+    print("TEST SUMMARY")
+    print("=" * 80)
+    
+    passed = sum(1 for r in results if r['valid'])
+    print(f"\nResults: {passed}/{len(results)} tests passed")
+    
+    for result in results:
+        status = "✓ PASS" if result['valid'] else "✗ FAIL"
+        print(f"{status}: {result['name']}")
+        if result['game_id']:
+            print(f"       {result['game_id']}")
+    
+    print("\n" + "=" * 80)
+    print("NOTES")
+    print("=" * 80)
+    if not llama_cpp_available:
+        print("⚠ llama-cpp-python not installed - using mock generation")
+        print("  For actual model-based generation, install:")
+        print("    pip install llama-cpp-python[cuda]  # For GPU")
+        print("    or")
+        print("    pip install llama-cpp-python        # For CPU")
+    else:
+        print("✓ llama-cpp-python available")
+        print("✓ NVIDIA Nemotron 3 Nano 4B GGUF ready for download from HuggingFace")
+        print("✓ Hackathon extra credit: llama.cpp runtime ✓")
+    
+    print("\n" + "=" * 80)
+
+
+if __name__ == "__main__":
+    main()

test_repair.py

@@ -0,0 +1,462 @@
+"""
+Test the repair pass logic for Phase 2, Task 8.
+
+Tests that repair_game() can:
+1. Fix missing fields and structure
+2. Add safety constraints
+3. Repair task content issues
+4. Handle multiple failures simultaneously
+5. Preserve valid content when fixing
+"""
+
+from app.services.validator import validate_game, repair_game
+
+
+def print_result(label: str, valid: bool, failures: list[str]):
+    status = "✓ PASS" if valid else "✗ FAIL"
+    print(f"  {status}: {label}")
+    if failures:
+        for f in failures[:3]:
+            print(f"         → {f}")
+        if len(failures) > 3:
+            print(f"         → ... and {len(failures) - 3} more")
+
+
+def test_repair_minimal_game():
+    """Repair a game with almost nothing filled in."""
+    print("\n" + "=" * 80)
+    print("TEST 1: Repair minimal (empty) game")
+    print("=" * 80)
+    
+    bad_game = {
+        "game_id": "",
+        "title": "",
+        "theme": "",
+        "setup": {},
+        "rules": [],
+        "tasks": [],
+        "global_hints": [],
+        "score_rules": [],
+        "tie_breaker": "",
+        "safety": {},
+        "story_seed": {}
+    }
+    
+    config = {
+        "game_type": "scavenger_hunt",
+        "city": "Paris",
+        "area": "Le Marais",
+        "duration_minutes": 60,
+        "num_players": 4,
+        "difficulty": "medium",
+        "age_group": "adults"
+    }
+    
+    # Show validation before repair
+    is_valid, failures = validate_game(bad_game, config)
+    print_result("Before repair", is_valid, failures)
+    
+    # Apply repair
+    repaired = repair_game(bad_game, failures, config)
+    
+    # Validate repaired game
+    is_valid, failures = validate_game(repaired, config)
+    print_result("After repair", is_valid, failures)
+    
+    # Show what was fixed
+    print(f"\n  Repaired game ID: {repaired['game_id']}")
+    print(f"  Title: {repaired['title']}")
+    print(f"  Theme: {repaired['theme']}")
+    print(f"  Tasks: {len(repaired['tasks'])}")
+    print(f"  Rules: {len(repaired['rules'])}")
+    print(f"  Score rules: {len(repaired['score_rules'])}")
+    print(f"  Safety zone: {repaired['safety']['allowed_zone'][:50]}...")
+    print(f"  Supervision: {repaired['safety']['adult_supervision']}")
+    print(f"  Forbidden behaviors: {len(repaired['safety']['forbidden_behaviors'])}")
+    print(f"  Stop conditions: {len(repaired['safety']['stop_conditions'])}")
+    
+    return is_valid
+
+
+def test_repair_missing_task_fields():
+    """Repair tasks with missing critical fields."""
+    print("\n" + "=" * 80)
+    print("TEST 2: Repair tasks with missing fields")
+    print("=" * 80)
+    
+    bad_game = {
+        "game_id": "game-001",
+        "title": "Test Game",
+        "theme": "discovery",
+        "setup": {
+            "city": "Paris",
+            "area": "Montmartre",
+            "meeting_point": "Sacré-Cœur steps",
+            "duration_minutes": 45,
+            "num_players": 4
+        },
+        "rules": ["Rule 1", "Rule 2"],
+        "tasks": [
+            {
+                "task_id": "t1",
+                "title": "Find the vineyard",
+                "description": "Locate the vineyard sign",
+                "location_hint": "North slope near Lapin Agile",
+                "points": 20,
+                "time_limit_minutes": 15,
+                # missing proof_type
+                # missing hint
+                # missing safety_note
+            }
+        ],
+        "global_hints": [],
+        "score_rules": [],
+        "tie_breaker": "",
+        "safety": {
+            "allowed_zone": "Montmartre public areas",
+            "forbidden_behaviors": ["No entering buildings"],
+            # missing adult_supervision
+            # missing stop_conditions
+        },
+        "story_seed": {
+            "tone": "playful",
+            "motifs": [],
+            "recap_style": "episode_recap"
+        }
+    }
+    
+    config = {
+        "game_type": "scavenger_hunt",
+        "city": "Paris",
+        "area": "Montmartre",
+        "duration_minutes": 45,
+        "num_players": 4,
+        "difficulty": "hard",
+        "age_group": "adults"
+    }
+    
+    # Before repair
+    is_valid, failures = validate_game(bad_game, config)
+    print_result("Before repair", is_valid, failures)
+    
+    # Repair
+    repaired = repair_game(bad_game, failures, config)
+    
+    # After repair
+    is_valid, failures = validate_game(repaired, config)
+    print_result("After repair", is_valid, failures)
+    
+    # Show fixed task
+    task = repaired['tasks'][0]
+    print(f"\n  Fixed task fields:")
+    print(f"    proof_type: {task.get('proof_type')}")
+    print(f"    hint: {task.get('hint')[:40]}...")
+    print(f"    safety_note: {task.get('safety_note')[:40]}...")
+    print(f"  Fixed safety:")
+    print(f"    adult_supervision: {repaired['safety'].get('adult_supervision')}")
+    print(f"    stop_conditions: {len(repaired['safety'].get('stop_conditions', []))}")
+    
+    return is_valid
+
+
+def test_repair_kids_game_no_supervision():
+    """Repair a kids game missing adult supervision."""
+    print("\n" + "=" * 80)
+    print("TEST 3: Repair kids game missing adult supervision")
+    print("=" * 80)
+    
+    bad_game = {
+        "game_id": "game-kids",
+        "title": "Kids Hunt",
+        "theme": "play",
+        "setup": {
+            "city": "Paris",
+            "area": "Parc des Buttes-Chaumont",
+            "meeting_point": "Main entrance",
+            "duration_minutes": 30,
+            "num_players": 6
+        },
+        "rules": ["Stay in park"],
+        "tasks": [
+            {
+                "task_id": "t1",
+                "title": "Find the temple",
+                "description": "Find the temple viewpoint",
+                "location_hint": "At the top of the hill",
+                "points": 15,
+                "time_limit_minutes": 10,
+                "proof_type": "observation",
+                "hint": "Look up",
+                "safety_note": "Stay safe"
+            }
+        ],
+        "global_hints": [],
+        "score_rules": [],
+        "tie_breaker": "",
+        "safety": {
+            "allowed_zone": "Park",
+            "forbidden_behaviors": ["No climbing"],
+            "adult_supervision": False,  # Should be True for kids!
+            "stop_conditions": []
+        },
+        "story_seed": {
+            "tone": "playful",
+            "motifs": [],
+            "recap_style": "episode_recap"
+        }
+    }
+    
+    config = {
+        "game_type": "hide_and_seek",
+        "city": "Paris",
+        "area": "Parc des Buttes-Chaumont",
+        "duration_minutes": 30,
+        "num_players": 6,
+        "difficulty": "easy",
+        "age_group": "kids"
+    }
+    
+    # Before repair
+    is_valid, failures = validate_game(bad_game, config)
+    print_result("Before repair", is_valid, failures)
+    
+    # Repair
+    repaired = repair_game(bad_game, failures, config)
+    
+    # After repair
+    is_valid, failures = validate_game(repaired, config)
+    print_result("After repair", is_valid, failures)
+    
+    print(f"\n  Adult supervision: {repaired['safety']['adult_supervision']} (was False)")
+    print(f"  Rules: {len(repaired['rules'])} (was 1)")
+    print(f"  Safety note: {repaired['tasks'][0]['safety_note'][:50]}...")
+    
+    return is_valid
+
+
+def test_repair_content_with_forbidden_keywords():
+    """Repair tasks mentioning forbidden locations."""
+    print("\n" + "=" * 80)
+    print("TEST 4: Repair content with forbidden keyword mentions")
+    print("=" * 80)
+    
+    bad_game = {
+        "game_id": "game-004",
+        "title": "Building Hunt",
+        "theme": "urban",
+        "setup": {
+            "city": "Paris",
+            "area": "Centre",
+            "meeting_point": "Plaza",
+            "duration_minutes": 45,
+            "num_players": 3,
+            "time_limit_minutes": 40
+        },
+        "rules": ["Rule 1", "Rule 2", "Rule 3"],
+        "tasks": [
+            {
+                "task_id": "t1",
+                "title": "Enter the shop",
+                "description": "Go inside the shop on Rue de Rivoli and ask staff for directions",
+                "location_hint": "Inside the building entrance",
+                "points": 20,
+                "time_limit_minutes": 10,
+                "proof_type": "photo",
+                "hint": "Check behind the counter",
+                "safety_note": "Be careful"
+            }
+        ],
+        "global_hints": [],
+        "score_rules": ["Complete tasks"],
+        "tie_breaker": "First to finish",
+        "safety": {
+            "allowed_zone": "City center",
+            "forbidden_behaviors": [],
+            "adult_supervision": False,
+            "stop_conditions": []
+        },
+        "story_seed": {
+            "tone": "playful",
+            "motifs": [],
+            "recap_style": "episode_recap"
+        }
+    }
+    
+    config = {
+        "game_type": "scavenger_hunt",
+        "city": "Paris",
+        "area": "Centre",
+        "duration_minutes": 45,
+        "num_players": 3,
+        "difficulty": "medium",
+        "age_group": "adults"
+    }
+    
+    # Before repair
+    is_valid, failures = validate_game(bad_game, config)
+    print_result("Before repair", is_valid, failures)
+    
+    # Repair
+    repaired = repair_game(bad_game, failures, config)
+    
+    # After repair
+    is_valid, failures = validate_game(repaired, config)
+    print_result("After repair", is_valid, failures)
+    
+    print(f"\n  Task safety note: {repaired['tasks'][0]['safety_note'][:70]}...")
+    print(f"  Forbidden behaviors: {len(repaired['safety']['forbidden_behaviors'])} items")
+    
+    return is_valid
+
+
+def test_repair_wrong_task_count():
+    """Repair games with too few or too many tasks for duration."""
+    print("\n" + "=" * 80)
+    print("TEST 5: Repair unrealistic task count for duration")
+    print("=" * 80)
+    
+    # 90 min game with only 1 task
+    bad_game = {
+        "game_id": "game-005",
+        "title": "Long Game",
+        "theme": "epic",
+        "setup": {
+            "city": "Paris",
+            "area": "Le Marais",
+            "meeting_point": "Centre",
+            "duration_minutes": 90,
+            "num_players": 4
+        },
+        "rules": ["Rule 1", "Rule 2", "Rule 3", "Rule 4", "Rule 5"],
+        "tasks": [
+            {
+                "task_id": "t1",
+                "title": "One task",
+                "description": "Walk around",
+                "location_hint": "Around",
+                "points": 30,
+                "time_limit_minutes": None,
+                "proof_type": "photo",
+                "hint": "Look around",
+                "safety_note": "Stay in public areas"
+            }
+        ],
+        "global_hints": [],
+        "score_rules": ["Complete all"],
+        "tie_breaker": "First",
+        "safety": {
+            "allowed_zone": "Le Marais",
+            "forbidden_behaviors": ["No buildings", "No roads"],
+            "adult_supervision": False,
+            "stop_conditions": ["Injury", "Weather", "Emergency"]
+        },
+        "story_seed": {"tone": "playful", "motifs": [], "recap_style": "episode_recap"}
+    }
+    
+    config = {
+        "game_type": "scavenger_hunt",
+        "city": "Paris",
+        "area": "Le Marais",
+        "duration_minutes": 90,
+        "num_players": 4,
+        "difficulty": "medium",
+        "age_group": "adults"
+    }
+    
+    # Before repair
+    is_valid, failures = validate_game(bad_game, config)
+    print_result("Before repair", is_valid, failures)
+    
+    # Repair
+    repaired = repair_game(bad_game, failures, config)
+    
+    # After repair
+    is_valid, failures = validate_game(repaired, config)
+    print_result("After repair", is_valid, failures)
+    
+    print(f"\n  Tasks: {len(repaired['tasks'])} (was 1)")
+    print(f"  Task IDs: {', '.join(t['task_id'] for t in repaired['tasks'])}")
+    print(f"  Task points: {[t['points'] for t in repaired['tasks']]}")
+    
+    return is_valid
+
+
+def test_full_pipeline_repair():
+    """Test full pipeline: generate → validate → repair → re-validate."""
+    print("\n" + "=" * 80)
+    print("TEST 6: Full pipeline - generate, validate, repair, re-validate")
+    print("=" * 80)
+    
+    from app.services.generator import generate_game
+    from app.services.retrieval import load_games_dataset, normalize_game_record, retrieve_examples
+    
+    # Load dataset
+    raw = load_games_dataset("app/data/games_dataset.json")
+    normalized = [normalize_game_record(r) for r in raw]
+    
+    config = {
+        "game_type": "scavenger_hunt",
+        "city": "Paris",
+        "area": "Le Marais",
+        "location_type": "mixed",
+        "duration_minutes": 60,
+        "num_players": 4,
+        "difficulty": "medium",
+        "age_group": "adults",
+        "photo_enabled": True
+    }
+    
+    # Generate
+    retrieved = retrieve_examples(config, normalized, k=3)
+    game = generate_game(config, retrieved)
+    print(f"  Generated: {game['game_id']} ({len(game['tasks'])} tasks)")
+    
+    # Validate
+    is_valid, failures = validate_game(game, config)
+    print_result("Initial validation", is_valid, failures)
+    
+    # Repair if needed
+    if not is_valid:
+        repaired = repair_game(game, failures, config)
+        is_valid, failures = validate_game(repaired, config)
+        print_result("After repair", is_valid, failures)
+        
+        print(f"\n  Originally: {len(game['tasks'])} tasks, {len(game['rules'])} rules")
+        print(f"  Repaired: {len(repaired['tasks'])} tasks, {len(repaired['rules'])} rules")
+    else:
+        print("  No repair needed (game already valid)")
+    
+    return is_valid
+
+
+def main():
+    print("\n" + "=" * 80)
+    print("PHASE 2, TASK 8: REPAIR PASS LOGIC TESTS")
+    print("=" * 80)
+    
+    results = []
+    
+    # Run all tests
+    results.append(("Test 1: Minimal game repair", test_repair_minimal_game()))
+    results.append(("Test 2: Missing task fields", test_repair_missing_task_fields()))
+    results.append(("Test 3: Kids game supervision", test_repair_kids_game_no_supervision()))
+    results.append(("Test 4: Forbidden content", test_repair_content_with_forbidden_keywords()))
+    results.append(("Test 5: Task count realism", test_repair_wrong_task_count()))
+    results.append(("Test 6: Full pipeline", test_full_pipeline_repair()))
+    
+    # Summary
+    print("\n" + "=" * 80)
+    print("REPAIR PASS TEST SUMMARY")
+    print("=" * 80)
+    
+    passed = sum(1 for _, ok in results if ok)
+    for name, ok in results:
+        status = "✓ PASS" if ok else "✗ FAIL"
+        print(f"  {status}: {name}")
+    
+    print(f"\n  Total: {passed}/{len(results)} tests passed")
+    print("\n" + "=" * 80)
+
+
+if __name__ == "__main__":
+    main()

test_validation.py

@@ -0,0 +1,229 @@
+"""
+Test the game validation and repair pipeline.
+
+Run this script to:
+1. Test validation against hard rules
+2. Test repair logic for failed validations
+3. Validate generated games from the generator
+4. Display validation results
+"""
+
+import json
+from app.services.retrieval import load_games_dataset, normalize_game_record, retrieve_examples
+from app.services.generator import generate_game
+from app.services.validator import validate_game, repair_game
+
+
+def main():
+    print("\n" + "=" * 80)
+    print("PHASE 2, TASK 7: GAME VALIDATION AND REPAIR")
+    print("=" * 80)
+    
+    # Load dataset
+    print("\n1. Loading dataset...")
+    raw_records = load_games_dataset("app/data/games_dataset.json")
+    normalized_records = [normalize_game_record(r) for r in raw_records]
+    print(f"✓ Loaded {len(normalized_records)} records")
+    
+    # Test configs
+    test_configs = [
+        {
+            "name": "Valid: Scavenger Hunt - Adults - Medium",
+            "config": {
+                "game_type": "scavenger_hunt",
+                "city": "Paris",
+                "area": "Le Marais",
+                "location_type": "mixed",
+                "duration_minutes": 60,
+                "num_players": 4,
+                "difficulty": "medium",
+                "age_group": "adults"
+            },
+            "expect_valid": True
+        },
+        {
+            "name": "Valid: Hide & Seek - Kids - Easy",
+            "config": {
+                "game_type": "hide_and_seek",
+                "city": "Paris",
+                "area": "Parc des Buttes-Chaumont",
+                "location_type": "park",
+                "duration_minutes": 45,
+                "num_players": 5,
+                "difficulty": "easy",
+                "age_group": "kids"
+            },
+            "expect_valid": True
+        },
+        {
+            "name": "Valid: Tag - Teens - Hard",
+            "config": {
+                "game_type": "tag",
+                "city": "Paris",
+                "area": "Jardins du Trocadéro",
+                "location_type": "park",
+                "duration_minutes": 30,
+                "num_players": 8,
+                "difficulty": "hard",
+                "age_group": "teens"
+            },
+            "expect_valid": True
+        }
+    ]
+    
+    # Invalid game example for repair testing
+    invalid_game = {
+        "game_id": "invalid-test",
+        "title": "Test Game",
+        "theme": "test",
+        "setup": {
+            "city": "Paris",
+            "area": "Test Area",
+            "meeting_point": "Central",
+            "duration_minutes": 60,
+            "num_players": 4
+        },
+        "rules": ["Rule 1"],
+        "tasks": [
+            {
+                "task_id": "t1",
+                # Missing: title, description, location_hint, points, proof_type, hint, safety_note
+                "description": None,
+                "points": -5,  # Invalid: negative points
+                "proof_type": "invalid_type"  # Invalid: not in enum
+            }
+        ],
+        "global_hints": ["Hint"],
+        "score_rules": [],  # Empty
+        "tie_breaker": "",  # Empty
+        "safety": {}  # Missing required fields
+    }
+    
+    results = []
+    
+    # Test 1: Generated games validation
+    print("\n" + "=" * 80)
+    print("TEST SUITE 1: VALIDATING GENERATED GAMES")
+    print("=" * 80)
+    
+    for test in test_configs:
+        print(f"\n{test['name']}")
+        print("-" * 80)
+        
+        config = test['config']
+        
+        # Generate game
+        print("Retrieving similar games...")
+        retrieved = retrieve_examples(config, normalized_records, k=3)
+        
+        print("Generating game...")
+        game = generate_game(config, retrieved)
+        
+        # Validate
+        print("Validating game...")
+        is_valid, failures = validate_game(game, config)
+        
+        if is_valid:
+            print(f"✓ VALID - Game {game['game_id']} passed all checks")
+        else:
+            print(f"✗ INVALID - {len(failures)} validation errors:")
+            for failure in failures[:3]:
+                print(f"  - {failure}")
+            if len(failures) > 3:
+                print(f"  ... and {len(failures) - 3} more errors")
+        
+        results.append({
+            'name': test['name'],
+            'valid': is_valid,
+            'expected_valid': test['expect_valid'],
+            'failures': failures
+        })
+    
+    # Test 2: Invalid game repair
+    print("\n" + "=" * 80)
+    print("TEST SUITE 2: REPAIR OF INVALID GAMES")
+    print("=" * 80)
+    
+    print("\nBefore repair:")
+    config = test_configs[0]['config']
+    is_valid_before, failures_before = validate_game(invalid_game, config)
+    print(f"✗ Invalid with {len(failures_before)} errors:")
+    for failure in failures_before[:5]:
+        print(f"  - {failure}")
+    if len(failures_before) > 5:
+        print(f"  ... and {len(failures_before) - 5} more errors")
+    
+    print("\nRepairing game...")
+    repaired_game = repair_game(invalid_game, failures_before, config)
+    
+    print("After repair:")
+    is_valid_after, failures_after = validate_game(repaired_game, config)
+    
+    if is_valid_after:
+        print(f"✓ VALID after repair")
+        print(f"  Fixed {len(failures_before)} issues")
+        print(f"  Game ID: {repaired_game['game_id']}")
+        print(f"  Tasks: {len(repaired_game['tasks'])}")
+        print(f"  Rules: {len(repaired_game['rules'])}")
+        print(f"  Safety zone: {repaired_game['safety'].get('allowed_zone')}")
+    else:
+        print(f"✗ Still invalid with {len(failures_after)} errors:")
+        for failure in failures_after[:3]:
+            print(f"  - {failure}")
+    
+    # Summary
+    print("\n" + "=" * 80)
+    print("VALIDATION TEST SUMMARY")
+    print("=" * 80)
+    
+    passed = sum(1 for r in results if r['valid'] == r['expected_valid'])
+    total = len(results)
+    
+    print(f"\nGenerated games: {passed}/{total} passed expectations")
+    for result in results:
+        status = "✓ PASS" if result['valid'] == result['expected_valid'] else "✗ FAIL"
+        valid_str = "VALID" if result['valid'] else "INVALID"
+        print(f"{status}: {result['name']} → {valid_str}")
+    
+    print(f"\nRepair test: {'✓ PASS' if is_valid_after else '✗ FAIL'}")
+    print(f"  Before: {len(failures_before)} failures")
+    print(f"  After: {len(failures_after)} failures")
+    
+    print("\n" + "=" * 80)
+    print("VALIDATION CHECKS IMPLEMENTED")
+    print("=" * 80)
+    print("""
+✓ Structure validation
+  - All required fields present
+  - Correct field types
+  
+✓ Task requirements
+  - Proof types in enum (photo|observation|text)
+  - Positive points
+  - Meaningful hints and safety notes
+  
+✓ Safety constraints
+  - No forbidden behaviors (buildings, private areas)
+  - Water hazards have explicit restrictions
+  - Road hazards have explicit guidance
+  - No illegal building access
+  
+✓ Age appropriateness
+  - Kids/mixed games require adult supervision
+  - Supervision mentioned in rules
+  
+✓ Realism checks
+  - Task count matches duration (8-20 min per task)
+  - Clear win conditions
+  - Scoring rules present
+  
+✓ Repair automation
+  - Adds missing fields with defaults
+  - Fixes enum violations
+  - Ensures positive values
+  - Adjusts task count for duration
+    """)
+
+
+if __name__ == "__main__":
+    main()