Deploy Epic Errands V2 Space clean

README.md

@@ -1,5 +1,5 @@
 ---
-title: Epic Errands V1 Mobile Review
+title: Epic Errands V2 Mobile Review
 emoji: 🧭
 colorFrom: blue
 colorTo: purple
@@ -10,70 +10,26 @@ pinned: false
 license: mit
 ---
 
-# Epic Errands V1 Mobile Review
+# Epic Errands V2 Mobile Review
 
-This Space package runs a hi-fi mobile review prototype for Epic Errands V1.
-The visible product surface is a fully-custom mobile UI served at `/` by
-`gradio.Server`. Gradio remains the HF Space-compatible server and API layer;
-the public app is not a `gr.HTML` island inside `gr.Blocks`.
+Private hosted testing package for Epic Errands V2.
 
-The prototype includes:
-
-- Home, Parent Goals, Kid Goals, and disabled DIY Lab navigation.
-- Quest, Classroom, and Comic app theme switching.
-- Questbook is the default visible theme; the canonical internal style id is
-  `questbook`, with legacy `magical` accepted only as a compatibility alias.
-- Theme-based parent/kid titles such as Quest Keeper and Young Adventurer.
-- Kid completion state separated from parent approval/reward state.
-- Parent approve-only reward flow.
-- Disabled V1.1 audio hook.
-- Session-only avatar note.
-
-## Runtime Honesty
-
-Current review-prototype package mode:
+Runtime honesty for this Space package:
 
 ```text
-lifecycle_stage=testing
-app_host=local or hf_space
+lifecycle_stage=hosted testing
+app_host=hf_space
 model_runtime=none
-model_backend=static_review_asset
-inference_engine=none
-model_artifact_format=png
-quantization=none
-model_id=none
 fallback_used=true
 ```
 
-The visible hero images are cached review assets. This Space does not claim live
-image generation, generated audio, sponsor-model proof, or judge-ready status.
-
-Future live image generation may use:
-
-```text
-APP_MODAL_BASE_URL
-APP_MODAL_AUTH_TOKEN
-APP_MODAL_TIMEOUT_SECONDS
-```
-
-Secret values must be configured as HF Space secrets/variables and must never
-be committed.
-
-## Local Run
-
-```bash
-python3 app.py
-```
+Fresh live model proof is recorded outside the Space package under the V2
+evidence folder. The hosted app currently uses deterministic/cached review
+assets and does not claim hosted live model execution or judge-ready status.
 
 Main routes:
 
-- `/`: custom mobile app shell.
-- `/frontend/...`: static CSS and JS.
-- `/assets/...`: static review images.
-- `/health`: hosted smoke endpoint.
-- `/api/bootstrap` and `/api/quest-pack`: lightweight JSON endpoints with
-  inline image data stripped.
-
-Future FLUX, HF Inference, Modal, or other image-generation paths should be
-added behind `epic_errands_space/adapters.py` and must keep provenance visible
-in the UI.
+- `/`: custom mobile shell when the Gradio server route is exposed.
+- `/epic/index.html`: explicit static hosted product shell.
+- `/epic-diy/index.html`: explicit static DIY shell.
+- `/health`: custom health endpoint when exposed by the Gradio server.

app.py

@@ -32,8 +32,10 @@ def build_server() -> Server:
     )
 
     app.mount("/frontend", StaticFiles(directory=FRONTEND_ROOT), name="frontend")
+    app.mount("/epic", StaticFiles(directory=FRONTEND_ROOT), name="epic_frontend")
     app.mount("/assets", StaticFiles(directory=ASSETS_ROOT), name="assets")
     app.mount("/diy-assets", StaticFiles(directory=DIY_FRONTEND_ROOT), name="diy_assets")
+    app.mount("/epic-diy", StaticFiles(directory=DIY_FRONTEND_ROOT), name="epic_diy_assets")
     workflow_app = build_workflow_canvas_app(DIY_WORKFLOW_GRAPH_PATH)
     if workflow_app is not None:
         gr.mount_gradio_app(

diy_lab/frontend/index.html

@@ -4,13 +4,13 @@
     <meta charset="utf-8">
     <meta name="viewport" content="width=device-width, initial-scale=1">
     <title>Epic Errands DIY Lab</title>
-    <link rel="stylesheet" href="/frontend/styles/tokens.css">
-    <link rel="stylesheet" href="/frontend/styles/components.css">
-    <link rel="stylesheet" href="/frontend/styles/app.css">
-    <link rel="stylesheet" href="/diy-assets/styles/diy.css">
+    <link rel="stylesheet" href="/epic/styles/tokens.css">
+    <link rel="stylesheet" href="/epic/styles/components.css">
+    <link rel="stylesheet" href="/epic/styles/app.css">
+    <link rel="stylesheet" href="/epic-diy/styles/diy.css">
   </head>
   <body>
     <main id="diy-app" class="phone-stage" aria-live="polite"></main>
-    <script src="/diy-assets/scripts/diy.js"></script>
+    <script src="/epic-diy/scripts/diy.js"></script>
   </body>
 </html>

epic_errands_space/__init__.py

@@ -1,19 +0,0 @@
-"""Epic Errands Cozy Classroom Adventure Space package."""
-
-from .render import (
-    build_app_bootstrap_js,
-    build_app_css,
-    build_app_document,
-    build_app_head,
-    build_app_island,
-)
-from .quest_generation import build_quest_pack
-
-__all__ = [
-    "build_app_bootstrap_js",
-    "build_app_css",
-    "build_app_document",
-    "build_app_head",
-    "build_app_island",
-    "build_quest_pack",
-]

epic_errands_space/adapters.py

@@ -1,42 +0,0 @@
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-
-from .contracts import ImageRequest, ImageResult, RuntimeMetadata
-
-
-class ImageGenerationAdapter(ABC):
-    """Boundary for future FLUX/HF/Modal image generation backends."""
-
-    @abstractmethod
-    def generate_image(self, request: ImageRequest) -> ImageResult:
-        raise NotImplementedError
-
-
-class FixtureImageAdapter(ImageGenerationAdapter):
-    """Returns the source-crop fixture used by the deterministic dry run."""
-
-    def generate_image(self, request: ImageRequest) -> ImageResult:
-        return ImageResult(
-            asset_id="quest-hero-scene",
-            asset_path="frontend/assets/sc2-hero-scene-clean.png",
-            origin="source_crop",
-            prompt_summary=(
-                "Fixture art for a cozy classroom adventure bridge quest. "
-                "This is not runtime FLUX output."
-            ),
-            runtime_metadata=RuntimeMetadata(),
-        )
-
-
-class DeterministicFallbackAdapter(ImageGenerationAdapter):
-    """Safe fallback adapter used when a future model adapter is unavailable."""
-
-    def generate_image(self, request: ImageRequest) -> ImageResult:
-        return ImageResult(
-            asset_id="quest-hero-scene",
-            asset_path="frontend/assets/sc2-hero-scene-clean.png",
-            origin="deterministic_fallback",
-            prompt_summary=f"Fallback storybook bridge image for goal: {request.ordinary_goal}",
-            runtime_metadata=RuntimeMetadata(fallback_used=True),
-        )

epic_errands_space/contracts.py

@@ -1,76 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import Literal
-
-
-Tone = Literal["cozy", "brave", "magical", "silly", "epic"]
-Mode = Literal["parent", "kid"]
-
-
-@dataclass(frozen=True)
-class RuntimeMetadata:
-    lifecycle_stage: str = "dev"
-    app_host: str = "local"
-    model_runtime: str = "none"
-    model_backend: str = "template"
-    inference_engine: str = "none"
-    model_artifact_format: str = "none"
-    quantization: str = "none"
-    model_id: str = "none"
-    latency_ms: int = 0
-    fallback_used: bool = True
-
-
-@dataclass(frozen=True)
-class GoalInput:
-    id: str
-    text: str
-    completed: bool = False
-
-
-@dataclass(frozen=True)
-class ImageRequest:
-    goal_id: str
-    ordinary_goal: str
-    tone: Tone
-    visual_direction: str = "cozy_classroom_adventure"
-
-
-@dataclass(frozen=True)
-class ImageResult:
-    asset_id: str
-    asset_path: str
-    origin: str
-    prompt_summary: str
-    runtime_metadata: RuntimeMetadata = field(default_factory=RuntimeMetadata)
-
-
-@dataclass(frozen=True)
-class QuestStep:
-    id: str
-    label: str
-    icon: str
-
-
-@dataclass(frozen=True)
-class QuestResult:
-    id: str
-    source_goal_id: str
-    title: str
-    subtitle: str
-    hero_asset_id: str
-    steps: list[QuestStep]
-    reward_label: str
-    reward_description: str
-    ordinary_goal: str
-    why_it_helps: str
-    runtime_metadata: RuntimeMetadata = field(default_factory=RuntimeMetadata)
-
-
-@dataclass
-class AppState:
-    mode: Mode = "parent"
-    tone: Tone = "cozy"
-    goals: list[GoalInput] = field(default_factory=list)
-    result: QuestResult | None = None

epic_errands_space/fixtures.py

@@ -1,31 +0,0 @@
-from __future__ import annotations
-
-from .contracts import GoalInput, QuestResult, QuestStep, RuntimeMetadata
-
-
-RUNTIME_METADATA = RuntimeMetadata()
-
-DEFAULT_GOALS = [
-    GoalInput(id="goal-1", text="Finish class project"),
-    GoalInput(id="goal-2", text="Read for 20 minutes"),
-    GoalInput(id="goal-3", text="Put away laundry"),
-]
-
-DEFAULT_QUEST = QuestResult(
-    id="quest-bridge-bright-ideas",
-    source_goal_id="goal-1",
-    title="Build the Bridge of Bright Ideas",
-    subtitle="Your quest today",
-    hero_asset_id="sc2-hero-scene-clean",
-    steps=[
-        QuestStep(id="step-1", label="Plan your ideas", icon="edit_note"),
-        QuestStep(id="step-2", label="Build your project", icon="construction"),
-        QuestStep(id="step-3", label="Check your work", icon="search"),
-        QuestStep(id="step-4", label="Share your masterpiece", icon="chat_bubble"),
-    ],
-    reward_label="Idea Builder",
-    reward_description="Reward earned after all steps are complete.",
-    ordinary_goal="Finish class project",
-    why_it_helps="Turns a school project into a clear sequence with a visible finish line.",
-    runtime_metadata=RUNTIME_METADATA,
-)

epic_errands_space/quest_generation.py

@@ -1,915 +0,0 @@
-from __future__ import annotations
-
-import base64
-from datetime import datetime, timezone
-import hashlib
-import json
-import mimetypes
-import os
-from pathlib import Path
-import re
-import time
-from typing import Any
-import urllib.error
-import urllib.request
-
-from .fixtures import DEFAULT_GOALS
-
-
-FRONTEND_ROOT = Path(__file__).resolve().parents[1] / "frontend"
-ASSETS_DIR = FRONTEND_ROOT / "assets"
-CACHE_MANIFEST = ASSETS_DIR / "generated-hero-manifest.json"
-FALLBACK_HERO = "sc2-hero-scene-clean.png"
-MODEL_ID = "black-forest-labs/FLUX.2-klein-9B"
-MINICPM_MODEL_ID = "openbmb/MiniCPM4.1-8B"
-NEMOTRON3_MODEL_ID = "nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16"
-VOXCPM2_MODEL_ID = "openbmb/VoxCPM2"
-NEMOTRON_SPEECH_MODEL_ID = "nvidia/nemotron-speech-streaming-en-0.6b"
-
-THEME_ALIASES = {
-    "quest": "questbook",
-    "questbook": "questbook",
-    "magical": "questbook",
-    "class": "classroom",
-    "classroom": "classroom",
-    "comic": "comic",
-}
-
-STEP_LIBRARY = {
-    "project": [
-        ("Plan your ideas", "edit_note"),
-        ("Build your project", "construction"),
-        ("Check your work", "search"),
-        ("Share your masterpiece", "chat_bubble"),
-    ],
-    "read": [
-        ("Find a cozy reading spot", "chair"),
-        ("Read the next pages", "menu_book"),
-        ("Collect three bright clues", "travel_explore"),
-        ("Tell someone the best part", "forum"),
-    ],
-    "laundry": [
-        ("Sort the tiny treasure piles", "inventory_2"),
-        ("Fold each cloth banner", "featured_seasonal_and_gifts"),
-        ("Deliver clothes to their homes", "home"),
-        ("Celebrate the tidy kingdom", "workspace_premium"),
-    ],
-    "default": [
-        ("Name the mission", "flag"),
-        ("Do the first brave bit", "bolt"),
-        ("Check what changed", "search"),
-        ("Mark the win", "workspace_premium"),
-    ],
-}
-
-
-def default_goal_payload() -> list[dict[str, str]]:
-    return [{"id": goal.id, "text": goal.text} for goal in DEFAULT_GOALS]
-
-
-def _theme(value: Any, fallback: str = "questbook") -> str:
-    normalized = str(value or fallback).strip().lower()
-    return THEME_ALIASES.get(normalized, fallback)
-
-
-def normalize_goals(raw_goals: Any) -> list[dict[str, str]]:
-    goals: list[dict[str, str]] = []
-    if isinstance(raw_goals, list):
-        for index, item in enumerate(raw_goals):
-            if not isinstance(item, dict):
-                continue
-            text = str(item.get("text") or "").strip()
-            if not text:
-                continue
-            goals.append({
-                "id": str(item.get("id") or f"goal-{index + 1}"),
-                "text": text,
-                "theme": _theme(item.get("theme") or item.get("style_id"), "questbook"),
-            })
-            if len(goals) == 3:
-                break
-
-    fallback_themes = ["questbook", "classroom", "comic"]
-    for fallback_index, fallback in enumerate(default_goal_payload()):
-        if len(goals) == 3:
-            break
-        if not any(goal["text"].casefold() == fallback["text"].casefold() for goal in goals):
-            goals.append({**fallback, "theme": fallback_themes[fallback_index % len(fallback_themes)]})
-
-    return goals[:3]
-
-
-def generated_file_name(goal: dict[str, str], index: int) -> str:
-    slug = re.sub(r"[^a-z0-9]+", "-", goal["text"].lower()).strip("-")[:36] or f"goal-{index + 1}"
-    digest = hashlib.sha1(f"{goal['id']}:{goal['text']}".encode("utf-8")).hexdigest()[:8]
-    return f"generated-hero-{index + 1}-{slug}-{digest}.png"
-
-
-def generated_audio_file_name(goal: dict[str, str], index: int) -> str:
-    slug = re.sub(r"[^a-z0-9]+", "-", goal["text"].lower()).strip("-")[:36] or f"goal-{index + 1}"
-    digest = hashlib.sha1(f"audio:{goal['id']}:{goal['text']}".encode("utf-8")).hexdigest()[:8]
-    return f"generated-audio-{index + 1}-{slug}-{digest}.wav"
-
-
-def _asset_to_data_uri(file_name: str) -> str:
-    path = ASSETS_DIR / file_name
-    mime_type = mimetypes.guess_type(path.name)[0] or "image/png"
-    return f"data:{mime_type};base64,{base64.b64encode(path.read_bytes()).decode('ascii')}"
-
-
-def _runtime_metadata(**overrides: Any) -> dict[str, Any]:
-    metadata = {
-        "lifecycle_stage": "testing" if os.environ.get("SPACE_ID") else "dev",
-        "app_host": "hf_space" if os.environ.get("SPACE_ID") else "local",
-        "model_runtime": "none",
-        "model_backend": "template",
-        "inference_engine": "none",
-        "model_artifact_format": "none",
-        "quantization": "none",
-        "model_id": "none",
-        "latency_ms": 0,
-        "fallback_used": True,
-    }
-    metadata.update(overrides)
-    return metadata
-
-
-def _step_key(goal_text: str) -> str:
-    lowered = goal_text.lower()
-    if "project" in lowered or "class" in lowered:
-        return "project"
-    if "read" in lowered or "book" in lowered:
-        return "read"
-    if "laundry" in lowered or "clothes" in lowered:
-        return "laundry"
-    return "default"
-
-
-def _quest_title(goal_text: str, tone: str, theme: str = "questbook") -> str:
-    lowered = goal_text.lower()
-    if theme == "classroom":
-        noun = "Quest"
-    elif theme == "comic":
-        noun = "Mission"
-    else:
-        noun = "Quest"
-    tone_word = {
-        "cozy": "Cozy",
-        "brave": "Brave",
-        "questbook": "Quest",
-        "silly": "Silly",
-        "epic": "Epic",
-    }.get(tone, "Cozy")
-    if "project" in lowered or "class" in lowered:
-        return f"{noun}: Bright Idea Bridge"
-    if "read" in lowered:
-        return f"{noun}: Reading Lantern"
-    if "laundry" in lowered or "clothes" in lowered:
-        return f"{noun}: Laundry Launch"
-    if "room" in lowered or "clean" in lowered:
-        return f"{noun}: Tidy Room Rescue"
-    return f"{tone_word} {noun} for {goal_text[:28]}"
-
-
-def _why_it_helps(goal_text: str) -> str:
-    return (
-        "Keeps the ordinary goal visible for parents while giving the child a "
-        "small, story-shaped path to finish it."
-    )
-
-
-def _prompt_for_goal(goal: dict[str, str], tone: str) -> str:
-    theme = _theme(goal.get("theme"), "questbook")
-    visual_direction = {
-        "questbook": (
-            "premium storybook quest card, warm paper, gentle fantasy props, "
-            "earned crest, no monsters or threats"
-        ),
-        "classroom": (
-            "cozy classroom adventure, stickers, notebooks, pencils, sunny desk, "
-            "teacher-approved kid-safe energy"
-        ),
-        "comic": (
-            "bright comic mission panel, bold shapes, action burst composition, "
-            "playful but calm, no readable text"
-        ),
-    }[theme]
-    return (
-        "A delightful family questbook hero image for a children's "
-        "goal-planning app. Warm handcrafted illustration, clear everyday adventure, no readable text, no UI, "
-        "kid-safe, expressive, polished. "
-        f"Theme: {theme}. Tone: {tone}. Visual direction: {visual_direction}. "
-        f"Ordinary goal transformed visually: {goal['text']}."
-    )
-
-
-def _theme_label(theme: str) -> str:
-    return {
-        "questbook": "Questbook",
-        "classroom": "Classroom",
-        "comic": "Comic",
-    }.get(_theme(theme), theme.title())
-
-
-def _text_prompt_for_goal(goal: dict[str, str]) -> str:
-    theme = _theme_label(_theme(goal.get("theme"), "questbook"))
-    return (
-        "Create a kid-safe Epic Errands goal card for an 8-year-old. "
-        f"Theme: {theme}. Plain goal: \"{goal['text']}\". "
-        "Return compact JSON only with keys title, narration, and reward_label. "
-        "Do not include task lists, verification fields, snake_case, UI copy, or "
-        "image text. Keep the ordinary goal visible, positive, parent-readable, and "
-        "achievable. No shame, threats, monsters, weapons, private details, readable "
-        "image text, or user photo references."
-    )
-
-
-def _card_prompt_block(card_text: dict[str, Any] | None) -> str:
-    if not isinstance(card_text, dict) or not card_text:
-        return "Generated Epic Errand card text is unavailable; use the plain goal only."
-    return (
-        f"{str(card_text.get('title') or '').strip()}. "
-        f"{str(card_text.get('narration') or '').strip()}"
-    )
-
-
-def _scene_hint_for_goal(goal_text: str) -> str:
-    lowered = goal_text.lower()
-    if "room" in lowered or "clean" in lowered:
-        return (
-            "Show a child tidying a bright bedroom, placing toys in bins and books "
-            "on shelves, with a cozy dinner glow through the doorway. All papers, "
-            "walls, signs, books, covers, and surfaces are completely blank."
-        )
-    if "project" in lowered or "class" in lowered:
-        return (
-            "Show a child organizing blank papers, colored shapes, pencils, and a "
-            "calm desk, with an encouraging adult nearby. Every worksheet, poster, "
-            "paper, notebook, and board is completely blank."
-        )
-    if "read" in lowered:
-        return (
-            "Show a child enjoying a quiet reading moment in a cozy seat with warm "
-            "light and a single plain book. Use a simple background with no bookshelf, "
-            "no book spines, no posters, and no decorative labels. The book cover, "
-            "book pages, and all background surfaces are completely blank."
-        )
-    return "Show a child-safe everyday accomplishment scene tied to the plain goal."
-
-
-def _image_prompt_for_card(goal: dict[str, str], tone: str, card_text: dict[str, Any] | None) -> str:
-    theme = _theme(goal.get("theme"), "questbook")
-    visual_direction = {
-        "questbook": (
-            "Warm fantasy story illustration, soft lantern light, gentle adventure "
-            "props, cozy handcrafted polish, full-bleed scene, no parchment border, "
-            "no title plaque, no banner."
-        ),
-        "classroom": (
-            "Sunny learning illustration, tidy supplies, pencils, blank notebooks, "
-            "calm school-day polish, simple blank walls, no posters, no signs."
-        ),
-        "comic": (
-            "Bright cartoon action illustration, bold shapes, clean motion lines, "
-            "cheerful everyday hero energy, full-bleed scene, no frame, no panel, "
-            "no banner, no speech bubble."
-        ),
-    }[theme]
-    return (
-        "Generate an image-only hero illustration for a child goal app. "
-        f"Tone: {tone}. "
-        f"{visual_direction} {_scene_hint_for_goal(goal['text'])} "
-        "This is not a poster, title card, label, worksheet, book cover, or UI. Do not render any "
-        "words, alphabet letters, numerals, captions, labels, signs, handwriting, "
-        "book titles, speech bubbles, sound effects, logos, or UI text. Use image "
-        "composition only; all paper and book surfaces stay blank; no user photos, "
-        "no monsters or threats."
-    )
-
-
-def _audio_prompt_for_card(goal: dict[str, str], card_text: dict[str, Any] | None) -> str:
-    theme = _theme(goal.get("theme"), "questbook")
-    voice_direction = {
-        "questbook": "gentle Questbook narrator, warm, clear, encouraging, paced for a child",
-        "classroom": "warm teacher, clear, encouraging, calm classroom cadence",
-        "comic": "upbeat comic narrator, energetic but not loud or frantic, clear and encouraging",
-    }[theme]
-    return (
-        "Generate a friendly spoken version of the Epic Errand produced by the text model. "
-        f"Plain goal: \"{goal['text']}\". Theme: {_theme_label(theme)}. "
-        f"Voice direction: {voice_direction}. Speak only the title and short narration "
-        f"from this generated card text: {_card_prompt_block(card_text)} "
-        "Do not add internal field names, warnings, or unrelated commentary."
-    )
-
-
-def _spoken_text_for_card(goal: dict[str, str], card_text: dict[str, Any] | None) -> str:
-    if not isinstance(card_text, dict) or not card_text:
-        return f"Your Epic Errands card is ready. Today's goal is: {goal['text']}."
-    parts = [
-        str(card_text.get("title") or "").strip(),
-        str(card_text.get("narration") or "").strip(),
-    ]
-    spoken = " ".join(part for part in parts if part)
-    return spoken or f"Your Epic Errands card is ready. Today's goal is: {goal['text']}."
-
-
-def _fallback_image_result(goal: dict[str, str], index: int, reason: str) -> dict[str, Any]:
-    return {
-        "goal_id": goal["id"],
-        "ordinary_goal": goal["text"],
-        "asset_name": FALLBACK_HERO,
-        "hero_src": _asset_to_data_uri(FALLBACK_HERO),
-        "origin": "deterministic_fallback",
-        "prompt_summary": f"Fallback classroom adventure image for goal: {goal['text']}",
-        "resolved_image_prompt": _image_prompt_for_card(goal, "cozy", None),
-        "runtime_metadata": _runtime_metadata(
-            fallback_used=True,
-            fallback_reason=reason,
-        ),
-    }
-
-
-def _fallback_card_text(goal: dict[str, str], tone: str, reason: str) -> dict[str, Any]:
-    return {
-        "goal_id": goal["id"],
-        "ordinary_goal": goal["text"],
-        "theme": _theme(goal.get("theme"), "questbook"),
-        "model_key": "deterministic_fallback",
-        "model_id": "none",
-        "schema_valid": True,
-        "raw_text": "",
-        "text_prompt": _text_prompt_for_goal(goal),
-        "card_text": {
-            "title": _quest_title(goal["text"], tone, _theme(goal.get("theme"), "questbook")),
-            "narration": f"Your goal card is ready: {goal['text']}. Take it one small step at a time.",
-            "reward_label": "Quest Hero",
-        },
-        "runtime_metadata": _runtime_metadata(fallback_used=True, fallback_reason=reason),
-    }
-
-
-def _fallback_audio_result(goal: dict[str, str], index: int, reason: str) -> dict[str, Any]:
-    return {
-        "goal_id": goal["id"],
-        "ordinary_goal": goal["text"],
-        "theme": _theme(goal.get("theme"), "questbook"),
-        "audio_asset_name": "",
-        "audio_src": "",
-        "spoken_text": "",
-        "resolved_audio_prompt": _audio_prompt_for_card(goal, None),
-        "runtime_metadata": _runtime_metadata(
-            model_backend="modal_http",
-            model_id=VOXCPM2_MODEL_ID,
-            fallback_used=True,
-            fallback_reason=reason,
-        ),
-    }
-
-
-def _load_manifest() -> dict[str, Any]:
-    try:
-        return json.loads(CACHE_MANIFEST.read_text(encoding="utf-8"))
-    except (OSError, json.JSONDecodeError):
-        return {"items": []}
-
-
-def _write_manifest(items: list[dict[str, Any]], metadata: dict[str, Any]) -> None:
-    CACHE_MANIFEST.write_text(
-        json.dumps(
-            {
-                "generated_at": datetime.now(timezone.utc).isoformat(),
-                "model_id": MODEL_ID,
-                "items": items,
-                "runtime_metadata": metadata,
-            },
-            indent=2,
-            sort_keys=True,
-        )
-        + "\n",
-        encoding="utf-8",
-    )
-
-
-def _cached_images_for(goals: list[dict[str, str]]) -> list[dict[str, Any]] | None:
-    manifest = _load_manifest()
-    items = manifest.get("items")
-    if not isinstance(items, list) or len(items) < len(goals):
-        return None
-
-    by_goal = {
-        str(item.get("goal_id")): item
-        for item in items
-        if isinstance(item, dict) and item.get("goal_id") and item.get("asset_name")
-    }
-    results: list[dict[str, Any]] = []
-    for index, goal in enumerate(goals):
-        item = by_goal.get(goal["id"])
-        if not item:
-            return None
-        asset_name = str(item["asset_name"])
-        if not (ASSETS_DIR / asset_name).exists():
-            return None
-        results.append({
-            "goal_id": goal["id"],
-            "ordinary_goal": goal["text"],
-            "asset_name": asset_name,
-            "hero_src": _asset_to_data_uri(asset_name),
-            "origin": item.get("origin", "modal_flux_cached"),
-            "prompt_summary": item.get("prompt_summary", _prompt_for_goal(goal, "cozy")),
-            "runtime_metadata": item.get("runtime_metadata", manifest.get("runtime_metadata", {})),
-        })
-    return results
-
-
-def _call_modal(
-    goals: list[dict[str, str]],
-    tone: str,
-    card_texts: dict[str, dict[str, Any]] | None = None,
-) -> tuple[list[dict[str, Any]], dict[str, Any]]:
-    base_url = os.environ.get("EPIC_MODAL_IMAGE_URL", "").strip() or os.environ.get("APP_MODAL_BASE_URL", "").strip()
-    token = os.environ.get("APP_MODAL_AUTH_TOKEN", "").strip()
-    timeout = float(os.environ.get("APP_MODAL_TIMEOUT_SECONDS", "180"))
-    if not base_url or not token:
-        raise RuntimeError("APP_MODAL_BASE_URL and APP_MODAL_AUTH_TOKEN are required for Modal FLUX generation.")
-
-    payload = {
-        "items": [
-            {
-                "goal_id": goal["id"],
-                "ordinary_goal": goal["text"],
-                "theme": _theme(goal.get("theme"), "questbook"),
-                "card_text": (card_texts or {}).get(goal["id"], {}),
-                "prompt": _image_prompt_for_card(goal, tone, (card_texts or {}).get(goal["id"])),
-                "seed": 26000 + index,
-            }
-            for index, goal in enumerate(goals)
-        ],
-        "tone": tone,
-        "height": 768,
-        "width": 768,
-        "steps": 4,
-        "guidance": 1.0,
-    }
-    request = urllib.request.Request(
-        base_url,
-        data=json.dumps(payload).encode("utf-8"),
-        headers={
-            "Authorization": f"Bearer {token}",
-            "Content-Type": "application/json",
-        },
-        method="POST",
-    )
-    started = time.monotonic()
-    with urllib.request.urlopen(request, timeout=timeout) as response:
-        body = json.loads(response.read().decode("utf-8"))
-    latency_ms = int((time.monotonic() - started) * 1000)
-    outputs = body.get("outputs")
-    if not isinstance(outputs, list) or len(outputs) < len(goals):
-        raise RuntimeError("Modal response missing generated image outputs.")
-
-    metadata = {
-        "lifecycle_stage": "testing" if os.environ.get("SPACE_ID") else "dev",
-        "app_host": "hf_space" if os.environ.get("SPACE_ID") else "local",
-        "model_runtime": "modal",
-        "model_backend": body.get("model_backend", "modal_http"),
-        "inference_engine": body.get("inference_engine", "diffusers"),
-        "model_artifact_format": body.get("model_artifact_format", "safetensors"),
-        "quantization": body.get("quantization", "bf16"),
-        "model_id": body.get("model_id", MODEL_ID),
-        "latency_ms": body.get("latency_ms", latency_ms),
-        "fallback_used": bool(body.get("fallback_used", False)),
-    }
-
-    saved: list[dict[str, Any]] = []
-    for index, goal in enumerate(goals):
-        output = outputs[index]
-        image_b64 = output.get("image_png_base64")
-        if not image_b64:
-            raise RuntimeError("Modal image output missing image_png_base64.")
-        image_bytes = base64.b64decode(image_b64)
-        asset_name = generated_file_name(goal, index)
-        (ASSETS_DIR / asset_name).write_bytes(image_bytes)
-        saved.append({
-            "goal_id": goal["id"],
-            "ordinary_goal": goal["text"],
-            "asset_name": asset_name,
-            "hero_src": f"data:image/png;base64,{base64.b64encode(image_bytes).decode('ascii')}",
-            "origin": "modal_flux_generated",
-            "prompt_summary": output.get("prompt_summary", _prompt_for_goal(goal, tone)),
-            "resolved_image_prompt": output.get("resolved_image_prompt", output.get("prompt_summary", "")),
-            "runtime_metadata": metadata,
-            "seed": output.get("seed", 26000 + index),
-        })
-    _write_manifest(saved, metadata)
-    return saved, metadata
-
-
-def _modal_json(url: str, payload: dict[str, Any], timeout: float) -> dict[str, Any]:
-    token = os.environ.get("APP_MODAL_AUTH_TOKEN", "").strip()
-    if not url or not token:
-        raise RuntimeError("Modal URL and APP_MODAL_AUTH_TOKEN are required.")
-    request = urllib.request.Request(
-        url,
-        data=json.dumps(payload).encode("utf-8"),
-        headers={
-            "Authorization": f"Bearer {token}",
-            "Content-Type": "application/json",
-        },
-        method="POST",
-    )
-    with urllib.request.urlopen(request, timeout=timeout) as response:
-        return json.loads(response.read().decode("utf-8"))
-
-
-def _call_text_model(goals: list[dict[str, str]], model_key: str) -> tuple[list[dict[str, Any]], dict[str, Any]]:
-    base_url = os.environ.get("EPIC_MODAL_TEXT_URL", "").strip()
-    timeout = float(os.environ.get("EPIC_MODAL_TEXT_TIMEOUT_SECONDS", os.environ.get("APP_MODAL_TIMEOUT_SECONDS", "300")))
-    if not base_url:
-        raise RuntimeError("EPIC_MODAL_TEXT_URL is required for Modal text generation.")
-    started = time.monotonic()
-    body = _modal_json(
-        base_url,
-        {
-            "model": model_key,
-            "items": [
-                {
-                    "goal_id": goal["id"],
-                    "ordinary_goal": goal["text"],
-                    "theme": _theme(goal.get("theme"), "questbook"),
-                    "text_prompt": _text_prompt_for_goal(goal),
-                }
-                for goal in goals
-            ],
-            "max_new_tokens": 260,
-        },
-        timeout,
-    )
-    latency_ms = int((time.monotonic() - started) * 1000)
-    outputs = body.get("outputs")
-    if not isinstance(outputs, list) or len(outputs) < len(goals):
-        raise RuntimeError(f"Modal text response missing outputs for {model_key}.")
-    metadata = {
-        "lifecycle_stage": "testing" if os.environ.get("SPACE_ID") else "dev",
-        "app_host": "hf_space" if os.environ.get("SPACE_ID") else "local",
-        "model_runtime": "modal",
-        "model_backend": body.get("model_backend", "modal_http"),
-        "inference_engine": body.get("inference_engine", "transformers"),
-        "model_artifact_format": body.get("model_artifact_format", "safetensors"),
-        "quantization": body.get("quantization", "bf16"),
-        "model_id": body.get("model_id", MINICPM_MODEL_ID if model_key == "minicpm" else NEMOTRON3_MODEL_ID),
-        "latency_ms": body.get("latency_ms", latency_ms),
-        "fallback_used": bool(body.get("fallback_used", False)),
-    }
-    return outputs[: len(goals)], metadata
-
-
-def _call_voxcpm2(goals: list[dict[str, str]], card_texts: dict[str, dict[str, Any]]) -> tuple[list[dict[str, Any]], dict[str, Any]]:
-    base_url = os.environ.get("EPIC_MODAL_VOXCPM2_URL", "").strip()
-    timeout = float(os.environ.get("EPIC_MODAL_SPEECH_TIMEOUT_SECONDS", os.environ.get("APP_MODAL_TIMEOUT_SECONDS", "300")))
-    if not base_url:
-        raise RuntimeError("EPIC_MODAL_VOXCPM2_URL is required for Modal VoxCPM2 generation.")
-    started = time.monotonic()
-    body = _modal_json(
-        base_url,
-        {
-            "items": [
-                {
-                    "goal_id": goal["id"],
-                    "ordinary_goal": goal["text"],
-                    "theme": _theme(goal.get("theme"), "questbook"),
-                    "card_text": card_texts.get(goal["id"], {}),
-                    "audio_prompt": _audio_prompt_for_card(goal, card_texts.get(goal["id"])),
-                    "narration": _spoken_text_for_card(goal, card_texts.get(goal["id"])),
-                }
-                for goal in goals
-            ],
-            "cfg_value": 2.0,
-            "inference_timesteps": 10,
-        },
-        timeout,
-    )
-    latency_ms = int((time.monotonic() - started) * 1000)
-    outputs = body.get("outputs")
-    if not isinstance(outputs, list) or len(outputs) < len(goals):
-        raise RuntimeError("Modal VoxCPM2 response missing outputs.")
-
-    saved: list[dict[str, Any]] = []
-    metadata = {
-        "lifecycle_stage": "testing" if os.environ.get("SPACE_ID") else "dev",
-        "app_host": "hf_space" if os.environ.get("SPACE_ID") else "local",
-        "model_runtime": "modal",
-        "model_backend": body.get("model_backend", "modal_http"),
-        "inference_engine": body.get("inference_engine", "voxcpm"),
-        "model_artifact_format": body.get("model_artifact_format", "safetensors"),
-        "quantization": body.get("quantization", "bf16"),
-        "model_id": body.get("model_id", VOXCPM2_MODEL_ID),
-        "latency_ms": body.get("latency_ms", latency_ms),
-        "fallback_used": bool(body.get("fallback_used", False)),
-    }
-    for index, goal in enumerate(goals):
-        output = outputs[index]
-        audio_b64 = output.get("audio_wav_base64")
-        if not audio_b64:
-            raise RuntimeError("Modal VoxCPM2 output missing audio_wav_base64.")
-        audio_bytes = base64.b64decode(audio_b64)
-        asset_name = generated_audio_file_name(goal, index)
-        (ASSETS_DIR / asset_name).write_bytes(audio_bytes)
-        saved.append({
-            "goal_id": goal["id"],
-            "ordinary_goal": goal["text"],
-            "theme": _theme(goal.get("theme"), "questbook"),
-            "audio_asset_name": asset_name,
-            "audio_src": f"data:audio/wav;base64,{base64.b64encode(audio_bytes).decode('ascii')}",
-            "audio_wav_base64": audio_b64,
-            "spoken_text": output.get("spoken_text", ""),
-            "resolved_audio_prompt": output.get("resolved_audio_prompt", output.get("audio_prompt", "")),
-            "sample_rate": output.get("sample_rate"),
-            "runtime_metadata": metadata,
-        })
-    return saved, metadata
-
-
-def _call_nemotron_speech(audio_results: list[dict[str, Any]]) -> tuple[list[dict[str, Any]], dict[str, Any]]:
-    base_url = os.environ.get("EPIC_MODAL_NEMOTRON_SPEECH_URL", "").strip()
-    timeout = float(os.environ.get("EPIC_MODAL_ASR_TIMEOUT_SECONDS", os.environ.get("APP_MODAL_TIMEOUT_SECONDS", "300")))
-    if not base_url:
-        raise RuntimeError("EPIC_MODAL_NEMOTRON_SPEECH_URL is required for Modal Nemotron Speech ASR.")
-    started = time.monotonic()
-    body = _modal_json(
-        base_url,
-        {
-            "items": [
-                {
-                    "goal_id": item["goal_id"],
-                    "ordinary_goal": item["ordinary_goal"],
-                    "audio_wav_base64": item.get("audio_wav_base64", ""),
-                }
-                for item in audio_results
-            ],
-        },
-        timeout,
-    )
-    latency_ms = int((time.monotonic() - started) * 1000)
-    outputs = body.get("outputs")
-    if not isinstance(outputs, list):
-        raise RuntimeError("Modal Nemotron Speech response missing outputs.")
-    metadata = {
-        "lifecycle_stage": "testing" if os.environ.get("SPACE_ID") else "dev",
-        "app_host": "hf_space" if os.environ.get("SPACE_ID") else "local",
-        "model_runtime": "modal",
-        "model_backend": body.get("model_backend", "modal_http"),
-        "inference_engine": body.get("inference_engine", "nemo"),
-        "model_artifact_format": body.get("model_artifact_format", "nemo_archive"),
-        "quantization": body.get("quantization", "bf16"),
-        "model_id": body.get("model_id", NEMOTRON_SPEECH_MODEL_ID),
-        "latency_ms": body.get("latency_ms", latency_ms),
-        "fallback_used": bool(body.get("fallback_used", False)),
-    }
-    return outputs, metadata
-
-
-def _quest_for_goal(
-    goal: dict[str, str],
-    image_result: dict[str, Any],
-    index: int,
-    tone: str,
-    text_results: dict[str, dict[str, Any]] | None = None,
-    secondary_text_results: dict[str, dict[str, Any]] | None = None,
-    audio_results: dict[str, dict[str, Any]] | None = None,
-    asr_results: dict[str, dict[str, Any]] | None = None,
-) -> dict[str, Any]:
-    steps: list[dict[str, str]] = []
-    theme = _theme(goal.get("theme"), "questbook")
-    primary_text = (text_results or {}).get(goal["id"], {})
-    secondary_text = (secondary_text_results or {}).get(goal["id"], {})
-    card_text = primary_text.get("card_text") or _fallback_card_text(goal, tone, "Primary text model did not return card_text.")["card_text"]
-    audio = (audio_results or {}).get(goal["id"], {})
-    asr = (asr_results or {}).get(goal["id"], {})
-    return {
-        "id": f"quest-{goal['id']}",
-        "source_goal_id": goal["id"],
-        "ordinary_goal": goal["text"],
-        "theme": theme,
-        "title": str(card_text.get("title") or _quest_title(goal["text"], tone, theme)),
-        "subtitle": f"Quest {index + 1} of 3",
-        "hero_asset_name": image_result["asset_name"],
-        "hero_src": image_result.get("hero_src", ""),
-        "hero_alt": f"Storybook classroom adventure for {goal['text']}",
-        "reward": {
-            "label": str(card_text.get("reward_label") or (["Idea Builder", "Lantern Reader", "Tidy Hero"][index] if index < 3 else "Quest Hero")),
-            "description": "Reward earned when the ordinary goal is finished.",
-        },
-        "steps": steps,
-        "narration": str(card_text.get("narration") or ""),
-        "why_it_helps": _why_it_helps(goal["text"]),
-        "image_origin": image_result.get("origin", "unknown"),
-        "prompt_summary": image_result.get("prompt_summary", ""),
-        "generation_trace": {
-            "text_prompt": primary_text.get("text_prompt", _text_prompt_for_goal(goal)),
-            "card_text": card_text,
-            "image_prompt_template": "Generated Epic Errand meaning + theme visual direction + strict no-text negatives.",
-            "resolved_image_prompt": image_result.get("resolved_image_prompt", image_result.get("prompt_summary", "")),
-            "audio_prompt_template": "Generated Epic Errand title/narration + theme voice direction + no-field-name rule.",
-            "resolved_audio_prompt": audio.get("resolved_audio_prompt", _audio_prompt_for_card(goal, card_text)),
-            "spoken_text": audio.get("spoken_text", _spoken_text_for_card(goal, card_text)),
-        },
-        "runtime_metadata": image_result.get("runtime_metadata", _runtime_metadata()),
-        "text_models": {
-            "primary": primary_text,
-            "secondary": secondary_text,
-        },
-        "audio_asset_name": audio.get("audio_asset_name", ""),
-        "audio_src": audio.get("audio_src", ""),
-        "spoken_text": audio.get("spoken_text", ""),
-        "speech_runtime_metadata": audio.get("runtime_metadata", _runtime_metadata()),
-        "asr_transcript": asr.get("transcript", ""),
-        "asr_runtime_metadata": asr.get("runtime_metadata", _runtime_metadata()),
-    }
-
-
-def _agent_trace_row(quest: dict[str, Any], run_generated_at: str) -> dict[str, Any]:
-    trace = quest.get("generation_trace", {})
-    primary_text = quest.get("text_models", {}).get("primary", {})
-    secondary_text = quest.get("text_models", {}).get("secondary", {})
-    image_runtime = quest.get("runtime_metadata", _runtime_metadata())
-    speech_runtime = quest.get("speech_runtime_metadata", _runtime_metadata())
-    asr_runtime = quest.get("asr_runtime_metadata", _runtime_metadata())
-    plain_goal = str(quest.get("ordinary_goal") or "")
-    theme = str(quest.get("theme") or "")
-    trace_hash = hashlib.sha1(f"{plain_goal}:{theme}:{run_generated_at}".encode("utf-8")).hexdigest()[:10]
-    return {
-        "trace_id": f"epic-errands-v1-{trace_hash}",
-        "generated_at": run_generated_at,
-        "goal_id": quest.get("source_goal_id", ""),
-        "plain_goal": plain_goal,
-        "theme": theme,
-        "text_model_primary": primary_text.get("model_id", image_runtime.get("model_id", "none")),
-        "text_model_secondary": secondary_text.get("model_id", ""),
-        "text_prompt": trace.get("text_prompt", ""),
-        "card_text": trace.get("card_text", {}),
-        "image_model_id": image_runtime.get("model_id", MODEL_ID),
-        "image_prompt_template": trace.get("image_prompt_template", ""),
-        "resolved_image_prompt": trace.get("resolved_image_prompt", ""),
-        "image_asset_path": quest.get("hero_asset_name", ""),
-        "audio_model_id": speech_runtime.get("model_id", VOXCPM2_MODEL_ID),
-        "audio_prompt_template": trace.get("audio_prompt_template", ""),
-        "resolved_audio_prompt": trace.get("resolved_audio_prompt", ""),
-        "spoken_text": trace.get("spoken_text", quest.get("spoken_text", "")),
-        "audio_asset_path": quest.get("audio_asset_name", ""),
-        "asr_model_id": asr_runtime.get("model_id", NEMOTRON_SPEECH_MODEL_ID),
-        "asr_transcript": quest.get("asr_transcript", ""),
-        "runtime_axes": {
-            "image": image_runtime,
-            "audio": speech_runtime,
-            "asr": asr_runtime,
-        },
-        "fallback_used": (
-            bool(image_runtime.get("fallback_used", True))
-            or bool(speech_runtime.get("fallback_used", True))
-            or bool(asr_runtime.get("fallback_used", True))
-            or bool(primary_text.get("runtime_metadata", {}).get("fallback_used", False))
-        ),
-    }
-
-
-def build_quest_pack(payload: dict[str, Any] | None = None, *, use_cache: bool = True) -> dict[str, Any]:
-    payload = payload or {}
-    tone = str(payload.get("tone") or "cozy").strip().lower() or "cozy"
-    goals = normalize_goals(payload.get("goals"))
-    force_refresh = bool(payload.get("force_refresh"))
-
-    text_blocker = ""
-    minicpm_results = [_fallback_card_text(goal, tone, "Live text generation is disabled.") for goal in goals]
-    nemotron3_results = [_fallback_card_text(goal, tone, "Live text generation is disabled.") for goal in goals]
-    text_metadata: dict[str, Any] = {}
-    if os.environ.get("EPIC_ENABLE_LIVE_GENERATION") == "1":
-        try:
-            minicpm_results, text_metadata["minicpm"] = _call_text_model(goals, "minicpm")
-        except (OSError, RuntimeError, ValueError, urllib.error.URLError, TimeoutError) as exc:
-            text_blocker = f"MiniCPM {type(exc).__name__}: {exc}"
-            minicpm_results = [_fallback_card_text(goal, tone, text_blocker) for goal in goals]
-        try:
-            nemotron3_results, text_metadata["nemotron3"] = _call_text_model(goals, "nemotron3")
-        except (OSError, RuntimeError, ValueError, urllib.error.URLError, TimeoutError) as exc:
-            extra = f"Nemotron3 {type(exc).__name__}: {exc}"
-            text_blocker = f"{text_blocker}; {extra}" if text_blocker else extra
-            nemotron3_results = [_fallback_card_text(goal, tone, extra) for goal in goals]
-
-    minicpm_by_id = {item["goal_id"]: item for item in minicpm_results}
-    nemotron3_by_id = {item["goal_id"]: item for item in nemotron3_results}
-    primary_card_texts = {
-        goal_id: result.get("card_text") or {}
-        for goal_id, result in minicpm_by_id.items()
-        if isinstance(result, dict)
-    }
-
-    images: list[dict[str, Any]] | None = None
-    metadata = _runtime_metadata()
-    blocker = ""
-    if use_cache and not force_refresh:
-        images = _cached_images_for(goals)
-        if images:
-            metadata = dict(images[0].get("runtime_metadata", metadata))
-            metadata["fallback_used"] = any(
-                bool(item.get("runtime_metadata", {}).get("fallback_used", True))
-                for item in images
-            )
-
-    if images is None:
-        try:
-            images, metadata = _call_modal(goals, tone, primary_card_texts)
-        except (OSError, RuntimeError, ValueError, urllib.error.URLError, TimeoutError) as exc:
-            blocker = f"{type(exc).__name__}: {exc}"
-            images = [_fallback_image_result(goal, index, blocker) for index, goal in enumerate(goals)]
-            metadata = _runtime_metadata(fallback_used=True, fallback_reason=blocker)
-
-    audio_blocker = ""
-    audio_results = [_fallback_audio_result(goal, index, "Live speech generation is disabled.") for index, goal in enumerate(goals)]
-    speech_metadata: dict[str, Any] = {}
-    if os.environ.get("EPIC_ENABLE_LIVE_GENERATION") == "1":
-        try:
-            audio_results, speech_metadata["voxcpm2"] = _call_voxcpm2(goals, primary_card_texts)
-        except (OSError, RuntimeError, ValueError, urllib.error.URLError, TimeoutError) as exc:
-            audio_blocker = f"VoxCPM2 {type(exc).__name__}: {exc}"
-            audio_results = [_fallback_audio_result(goal, index, audio_blocker) for index, goal in enumerate(goals)]
-
-    asr_results: list[dict[str, Any]] = []
-    asr_blocker = ""
-    if os.environ.get("EPIC_ENABLE_LIVE_GENERATION") == "1" and any(item.get("audio_wav_base64") for item in audio_results):
-        try:
-            asr_results, speech_metadata["nemotron_speech"] = _call_nemotron_speech(audio_results)
-        except (OSError, RuntimeError, ValueError, urllib.error.URLError, TimeoutError) as exc:
-            asr_blocker = f"Nemotron Speech {type(exc).__name__}: {exc}"
-
-    audio_by_id = {item["goal_id"]: item for item in audio_results}
-    asr_by_id = {
-        item["goal_id"]: {
-            **item,
-            "runtime_metadata": speech_metadata.get("nemotron_speech", _runtime_metadata(
-                model_backend="modal_http",
-                model_id=NEMOTRON_SPEECH_MODEL_ID,
-                fallback_used=True,
-                fallback_reason=asr_blocker or "Nemotron Speech ASR was not run.",
-            )),
-        }
-        for item in asr_results
-        if isinstance(item, dict) and item.get("goal_id")
-    }
-
-    quests = [
-        _quest_for_goal(
-            goal,
-            images[index],
-            index,
-            tone,
-            text_results=minicpm_by_id,
-            secondary_text_results=nemotron3_by_id,
-            audio_results=audio_by_id,
-            asr_results=asr_by_id,
-        )
-        for index, goal in enumerate(goals)
-    ]
-    any_text_fallback = any(
-        bool(item.get("runtime_metadata", {}).get("fallback_used", False))
-        or bool(item.get("validation_error"))
-        for item in [*minicpm_results, *nemotron3_results]
-        if isinstance(item, dict)
-    )
-    any_audio_fallback = any(
-        bool(item.get("runtime_metadata", {}).get("fallback_used", False))
-        for item in audio_results
-        if isinstance(item, dict)
-    )
-    any_asr_fallback = bool(asr_blocker) or (
-        os.environ.get("EPIC_ENABLE_LIVE_GENERATION") == "1"
-        and bool(audio_results)
-        and not asr_results
-    )
-
-    generated_at = datetime.now(timezone.utc).isoformat()
-    agent_traces = [_agent_trace_row(quest, generated_at) for quest in quests]
-
-    return {
-        "goals": goals,
-        "quests": quests,
-        "agent_traces": agent_traces,
-        "runtime_metadata": metadata,
-        "model_runs": {
-            "image": metadata,
-            "text": text_metadata,
-            "speech": speech_metadata,
-        },
-        "fallback_used": (
-            any(bool(quest["runtime_metadata"].get("fallback_used", True)) for quest in quests)
-            or any_text_fallback
-            or any_audio_fallback
-            or any_asr_fallback
-        ),
-        "blocker": "; ".join(part for part in [blocker, text_blocker, audio_blocker, asr_blocker] if part),
-        "generated_at": generated_at,
-    }
-
-
-def build_initial_quest_pack() -> dict[str, Any]:
-    return build_quest_pack({"goals": default_goal_payload(), "tone": "cozy"}, use_cache=True)

epic_errands_space/render.py

@@ -1,983 +0,0 @@
-from __future__ import annotations
-
-import base64
-import json
-import mimetypes
-from pathlib import Path
-from typing import Any
-
-
-FRONTEND_ROOT = Path(__file__).resolve().parents[1] / "frontend"
-ASSETS_DIR = FRONTEND_ROOT / "assets"
-
-STYLE_MODES: dict[str, dict[str, str]] = {
-    "classroom": {
-        "label": "Classroom",
-        "mark": "CL",
-        "goal_noun": "Quest",
-        "parent_title": "Classroom Captain",
-        "kid_title": "Star Student",
-        "reward_noun": "badge",
-        "reward": "Helper badge",
-        "waiting": "Waiting for Classroom Captain approval.",
-        "copy": "Warm school adventure with stickers, notebooks, and clear wins.",
-        "image": "generated-hero-1-finish-class-project-8f64eeb3.png",
-    },
-    "questbook": {
-        "label": "Questbook",
-        "mark": "QB",
-        "goal_noun": "Quest",
-        "parent_title": "Quest Keeper",
-        "kid_title": "Young Adventurer",
-        "reward_noun": "crest",
-        "reward": "Orderkeeper crest",
-        "waiting": "Waiting for Quest Keeper approval.",
-        "copy": "Premium questbook fantasy with warm paper, ink lines, and earned crests.",
-        "image": "generated-hero-2-read-for-20-minutes-895e7642.png",
-    },
-    "comic": {
-        "label": "Comic",
-        "mark": "CM",
-        "goal_noun": "Mission",
-        "parent_title": "Comic Editor",
-        "kid_title": "Panel Hero",
-        "reward_noun": "starburst",
-        "reward": "Pow starburst",
-        "waiting": "Waiting for Comic Editor approval.",
-        "copy": "Bright panels, short action copy, and punchy kid-safe momentum.",
-        "image": "generated-hero-3-put-away-laundry-083482db.png",
-    },
-}
-
-INITIAL_GOALS: list[dict[str, str]] = [
-    {
-        "id": "goal-1",
-        "ordinary_goal": "Finish class project",
-        "title": "Quest: Bright Idea Bridge",
-        "style_id": "questbook",
-        "kid_completion_state": "completed",
-        "parent_reward_state": "waiting_for_approval",
-    },
-    {
-        "id": "goal-2",
-        "ordinary_goal": "Read for 20 minutes",
-        "title": "Quest: Reading Lantern",
-        "style_id": "classroom",
-        "kid_completion_state": "in_progress",
-        "parent_reward_state": "not_reviewed",
-    },
-    {
-        "id": "goal-3",
-        "ordinary_goal": "Put away laundry",
-        "title": "Mission: Laundry Launch",
-        "style_id": "comic",
-        "kid_completion_state": "not_started",
-        "parent_reward_state": "not_reviewed",
-    },
-]
-
-
-def _asset_data_uri(file_name: str) -> str:
-    path = ASSETS_DIR / file_name
-    if not path.exists():
-        return ""
-    mime_type = mimetypes.guess_type(path.name)[0] or "image/png"
-    encoded = base64.b64encode(path.read_bytes()).decode("ascii")
-    return f"data:{mime_type};base64,{encoded}"
-
-
-def _initial_state() -> dict[str, Any]:
-    images = {
-        style_id: _asset_data_uri(style["image"])
-        for style_id, style in STYLE_MODES.items()
-    }
-    return {
-        "activeTab": "home",
-        "defaultStyleId": "questbook",
-        "selectedGoalId": "goal-1",
-        "parentName": "Maya",
-        "kidName": "Ari",
-        "avatarPreviews": {"parent": "", "kid": ""},
-        "styles": STYLE_MODES,
-        "images": images,
-        "goals": INITIAL_GOALS,
-    }
-
-
-def build_app_island() -> str:
-    return """
-<main class="ee-root" data-epic-root aria-label="Epic Errands V1 mobile review prototype">
-  <section class="ee-shell" data-design-id="mobile-app-shell">
-    <p class="ee-loading">Loading Epic Errands...</p>
-  </section>
-</main>
-"""
-
-
-def build_app_css() -> str:
-    return """
-.ee-root {
-  --ink: #172033;
-  --muted: #5b6678;
-  --line: rgba(23, 32, 51, 0.15);
-  --paper: #fffdf8;
-  --surface: #ffffff;
-  --soft: #f2f6fb;
-  --theme: #7652c7;
-  --theme-2: #0f877e;
-  --theme-3: #efb84a;
-  --theme-soft: #f2eaff;
-  --reward: #9b6500;
-  width: 100%;
-  max-width: 448px;
-  margin: 0 auto;
-  padding: 12px;
-  color: var(--ink);
-  background: #e9f1fb;
-  font-family: ui-rounded, "Arial Rounded MT Bold", system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
-}
-
-.ee-root,
-.ee-root * {
-  box-sizing: border-box;
-}
-
-.ee-root button,
-.ee-root input {
-  font: inherit;
-}
-
-.ee-root button {
-  min-height: 44px;
-  border: 0;
-  cursor: pointer;
-}
-
-.ee-root button:focus-visible,
-.ee-root input:focus-visible {
-  outline: 3px solid rgba(28, 101, 242, 0.45);
-  outline-offset: 3px;
-}
-
-.ee-shell {
-  overflow: clip;
-  border: 1px solid var(--line);
-  border-radius: 22px;
-  background: var(--paper);
-  box-shadow: 0 14px 36px rgba(23, 32, 51, 0.14);
-}
-
-.ee-shell[data-style="classroom"] {
-  --theme: #c8332d;
-  --theme-2: #135f9d;
-  --theme-3: #f7c948;
-  --theme-soft: #fff2cf;
-  --reward: #11784f;
-}
-
-.ee-shell[data-style="questbook"] {
-  --theme: #7652c7;
-  --theme-2: #0f877e;
-  --theme-3: #efb84a;
-  --theme-soft: #f2eaff;
-  --reward: #9b6500;
-}
-
-.ee-shell[data-style="comic"] {
-  --theme: #136bd9;
-  --theme-2: #c92754;
-  --theme-3: #ffd33d;
-  --theme-soft: #fff3a8;
-  --reward: #c34220;
-}
-
-.ee-top {
-  display: grid;
-  gap: 12px;
-  padding: 18px 16px 12px;
-  background: linear-gradient(135deg, var(--theme-soft), #ffffff 72%);
-  border-bottom: 1px solid var(--line);
-}
-
-.ee-brand-row,
-.ee-title-row,
-.ee-chip-row,
-.ee-name-row,
-.ee-card-action-row {
-  display: flex;
-  align-items: center;
-  gap: 10px;
-}
-
-.ee-brand-row,
-.ee-title-row {
-  justify-content: space-between;
-}
-
-.ee-kicker,
-.ee-section-label {
-  margin: 0;
-  color: var(--theme-2);
-  font-size: 12px;
-  font-weight: 900;
-  letter-spacing: 0;
-  text-transform: uppercase;
-}
-
-.ee-brand {
-  margin: 0;
-  font-size: 30px;
-  line-height: 0.95;
-  font-weight: 950;
-}
-
-.ee-pill,
-.ee-chip {
-  display: inline-flex;
-  align-items: center;
-  justify-content: center;
-  min-height: 28px;
-  padding: 0 9px;
-  border-radius: 999px;
-  background: #ffffff;
-  color: var(--theme);
-  border: 1px solid var(--line);
-  font-size: 12px;
-  font-weight: 900;
-  white-space: nowrap;
-}
-
-.ee-chip {
-  min-height: 24px;
-  background: var(--theme-soft);
-  font-size: 11px;
-}
-
-.ee-chip[data-tone="waiting"] {
-  background: #fff3d0;
-  color: #805100;
-}
-
-.ee-chip[data-tone="success"] {
-  background: #e6f7ee;
-  color: #0b7048;
-}
-
-.ee-tabs {
-  display: grid;
-  grid-template-columns: repeat(4, 1fr);
-  gap: 6px;
-}
-
-.ee-tab {
-  display: grid;
-  align-content: center;
-  gap: 2px;
-  min-width: 0;
-  padding: 8px 4px;
-  border-radius: 12px;
-  background: rgba(255, 255, 255, 0.72);
-  color: var(--muted);
-  font-size: 12px;
-  font-weight: 900;
-}
-
-.ee-tab[aria-current="page"] {
-  background: var(--theme);
-  color: #ffffff;
-}
-
-.ee-tab[aria-disabled="true"] {
-  opacity: 0.48;
-  cursor: not-allowed;
-}
-
-.ee-tab-mark {
-  font-size: 13px;
-}
-
-.ee-body {
-  display: grid;
-  gap: 14px;
-  padding: 16px;
-  background: linear-gradient(180deg, rgba(255, 255, 255, 0.72), rgba(255, 255, 255, 0)), #f7f9fc;
-}
-
-.ee-screen,
-.ee-stack {
-  display: grid;
-  gap: 14px;
-}
-
-.ee-screen-title {
-  margin: 0;
-  font-size: 27px;
-  line-height: 1;
-  font-weight: 950;
-}
-
-.ee-copy {
-  margin: 4px 0 0;
-  color: var(--muted);
-  font-size: 14px;
-  font-weight: 750;
-  line-height: 1.36;
-}
-
-.ee-panel,
-.ee-goal-row,
-.ee-goal-card,
-.ee-kid-tile,
-.ee-avatar {
-  border: 1px solid var(--line);
-  border-radius: 16px;
-  background: rgba(255, 255, 255, 0.94);
-  box-shadow: 0 7px 18px rgba(23, 32, 51, 0.08);
-}
-
-.ee-panel {
-  display: grid;
-  gap: 10px;
-  padding: 13px;
-}
-
-.ee-style-list {
-  display: grid;
-  gap: 8px;
-}
-
-.ee-style-button {
-  display: grid;
-  grid-template-columns: 42px 1fr auto;
-  align-items: center;
-  gap: 10px;
-  width: 100%;
-  padding: 10px;
-  border: 1px solid var(--line);
-  border-radius: 14px;
-  background: #ffffff;
-  color: var(--ink);
-  text-align: left;
-}
-
-.ee-style-button[aria-pressed="true"] {
-  border-color: var(--theme);
-  background: linear-gradient(135deg, var(--theme-soft), #ffffff);
-}
-
-.ee-mark,
-.ee-avatar-mark {
-  display: grid;
-  width: 42px;
-  height: 42px;
-  place-items: center;
-  border-radius: 13px;
-  background: var(--theme-soft);
-  color: var(--theme);
-  font-size: 13px;
-  font-weight: 950;
-}
-
-.ee-style-name,
-.ee-goal-name,
-.ee-tile-title {
-  display: block;
-  font-size: 16px;
-  line-height: 1.15;
-  font-weight: 950;
-}
-
-.ee-style-meta,
-.ee-goal-meta,
-.ee-small {
-  display: block;
-  color: var(--muted);
-  font-size: 12px;
-  font-weight: 750;
-  line-height: 1.3;
-}
-
-.ee-dot {
-  width: 17px;
-  height: 17px;
-  border: 2px solid var(--theme);
-  border-radius: 50%;
-}
-
-.ee-style-button[aria-pressed="true"] .ee-dot {
-  background: radial-gradient(circle, var(--theme) 45%, transparent 49%);
-}
-
-.ee-avatar-grid,
-.ee-counter-grid,
-.ee-kid-grid {
-  display: grid;
-  grid-template-columns: 1fr 1fr;
-  gap: 10px;
-}
-
-.ee-avatar {
-  display: grid;
-  gap: 10px;
-  padding: 10px;
-  background: linear-gradient(135deg, var(--theme-soft), #ffffff);
-}
-
-.ee-avatar-photo {
-  width: 54px;
-  height: 54px;
-  object-fit: cover;
-  border-radius: 18px;
-  border: 3px solid #ffffff;
-  box-shadow: 0 5px 15px rgba(23, 32, 51, 0.12);
-}
-
-.ee-name-input {
-  width: 100%;
-  min-height: 40px;
-  border: 1px solid var(--line);
-  border-radius: 12px;
-  padding: 0 10px;
-  color: var(--ink);
-  background: #ffffff;
-  font-weight: 850;
-}
-
-.ee-file {
-  width: 100%;
-  min-height: 38px;
-  font-size: 12px;
-}
-
-.ee-privacy {
-  margin: 0;
-  color: #536273;
-  font-size: 12px;
-  font-weight: 750;
-  line-height: 1.35;
-}
-
-.ee-counter {
-  display: grid;
-  align-content: center;
-  min-height: 88px;
-  padding: 12px;
-  border: 1px solid var(--line);
-  border-radius: 16px;
-  background: #ffffff;
-}
-
-.ee-counter strong {
-  color: var(--theme);
-  font-size: 34px;
-  line-height: 0.9;
-}
-
-.ee-counter span {
-  color: var(--muted);
-  font-size: 12px;
-  font-weight: 850;
-}
-
-.ee-goal-list {
-  display: grid;
-  gap: 10px;
-}
-
-.ee-goal-row {
-  display: grid;
-  gap: 10px;
-  padding: 12px;
-}
-
-.ee-approve-button,
-.ee-complete-button,
-.ee-audio-button {
-  justify-self: start;
-  min-height: 44px;
-  padding: 0 14px;
-  border-radius: 999px;
-  background: var(--theme);
-  color: #ffffff;
-  font-weight: 950;
-}
-
-.ee-approve-button:disabled,
-.ee-audio-button:disabled,
-.ee-complete-button:disabled {
-  background: #e9eef5;
-  color: #657185;
-  border: 1px solid var(--line);
-  cursor: not-allowed;
-}
-
-.ee-kid-tile {
-  overflow: clip;
-  padding: 0;
-  color: var(--ink);
-  text-align: left;
-}
-
-.ee-kid-tile[aria-pressed="true"] {
-  border-color: var(--theme);
-}
-
-.ee-kid-tile img,
-.ee-card-image {
-  display: block;
-  width: 100%;
-  background: var(--theme-soft);
-  object-fit: cover;
-}
-
-.ee-kid-tile img {
-  height: 96px;
-}
-
-.ee-tile-body {
-  display: grid;
-  gap: 6px;
-  padding: 10px;
-}
-
-.ee-goal-card {
-  overflow: clip;
-}
-
-.ee-card-image {
-  height: 205px;
-}
-
-.ee-card-body {
-  display: grid;
-  gap: 11px;
-  padding: 13px;
-}
-
-.ee-card-body h2 {
-  margin: 0;
-  font-size: 26px;
-  line-height: 1;
-}
-
-.ee-step-list {
-  display: grid;
-  gap: 8px;
-  margin: 0;
-  padding: 0;
-  list-style: none;
-}
-
-.ee-step-list li {
-  display: grid;
-  grid-template-columns: 30px 1fr;
-  gap: 8px;
-  align-items: center;
-  min-height: 40px;
-  padding: 7px 9px;
-  border-radius: 13px;
-  background: var(--soft);
-  font-size: 13px;
-  font-weight: 850;
-}
-
-.ee-step-list b {
-  display: grid;
-  width: 30px;
-  height: 30px;
-  place-items: center;
-  border-radius: 999px;
-  background: var(--theme-soft);
-  color: var(--theme);
-}
-
-.ee-status-panel {
-  display: grid;
-  gap: 4px;
-  padding: 11px;
-  border-radius: 14px;
-  border: 1px solid var(--line);
-  background: #fff4d7;
-  color: #704800;
-  font-size: 13px;
-  font-weight: 800;
-}
-
-.ee-status-panel[data-tone="success"] {
-  background: #e7f8ef;
-  color: #0d5c3b;
-}
-
-.ee-loading {
-  margin: 0;
-  padding: 18px;
-  color: var(--muted);
-  font-weight: 850;
-}
-
-@media (max-width: 380px) {
-  .ee-root {
-    padding: 8px;
-  }
-
-  .ee-body {
-    padding: 12px;
-  }
-
-  .ee-brand {
-    font-size: 27px;
-  }
-
-  .ee-screen-title {
-    font-size: 24px;
-  }
-
-  .ee-avatar-grid,
-  .ee-kid-grid {
-    grid-template-columns: 1fr;
-  }
-}
-"""
-
-
-def build_app_head() -> str:
-    return """
-<meta name="viewport" content="width=device-width, initial-scale=1">
-"""
-
-
-def build_app_bootstrap_js(asset_base: str = "/file=frontend/assets/") -> str:
-    del asset_base
-    state_json = json.dumps(_initial_state())
-    return (
-        r"""
-const root = element.querySelector("[data-epic-root]");
-if (root && root.dataset.ready !== "true") {
-root.dataset.ready = "true";
-
-const state = __STATE_JSON__;
-const styleAliases = {
-  quest: "questbook",
-  questbook: "questbook",
-  magical: "questbook",
-  class: "classroom",
-  classroom: "classroom",
-  comic: "comic",
-};
-const stepsByStyle = {
-  classroom: ["Find your reading spot", "Read the next pages", "Tell the best part"],
-  questbook: ["Gather your project ideas", "Build the first bright piece", "Check your questbook notes"],
-  comic: ["Sort the pile", "Fold the hero gear", "Launch it to the drawer"],
-};
-
-function escapeHtml(value) {
-  return String(value)
-    .replace(/&/g, "&amp;")
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;")
-    .replace(/"/g, "&quot;")
-    .replace(/'/g, "&#039;");
-}
-
-function normalizeStyleId(value, fallback = "questbook") {
-  const normalized = String(value || fallback).trim().toLowerCase();
-  return styleAliases[normalized] || fallback;
-}
-
-function styleFor(goalOrStyleId) {
-  const rawStyleId = typeof goalOrStyleId === "string" ? goalOrStyleId : goalOrStyleId.style_id;
-  const styleId = normalizeStyleId(rawStyleId);
-  return state.styles[styleId] || state.styles.classroom;
-}
-
-function shellStyle() {
-  return state.styles[normalizeStyleId(state.defaultStyleId)] || state.styles.questbook;
-}
-
-function awaitingApprovalCount() {
-  return state.goals.filter((goal) => goal.parent_reward_state === "waiting_for_approval").length;
-}
-
-function stateChip(goal) {
-  if (goal.parent_reward_state === "approved_reward_given") {
-    return '<span class="ee-chip" data-tone="success">Reward given</span>';
-  }
-  if (goal.kid_completion_state === "completed") {
-    return '<span class="ee-chip" data-tone="waiting">Awaiting parent</span>';
-  }
-  if (goal.kid_completion_state === "in_progress") {
-    return '<span class="ee-chip">In progress</span>';
-  }
-  return '<span class="ee-chip">Ready</span>';
-}
-
-function renderTabs() {
-  const tabs = [
-    ["home", "Home", "HM"],
-    ["parent", "Parent", "PA"],
-    ["kid", "Kid", "KD"],
-    ["diy", "DIY Lab", "DIY"],
-  ];
-  return `<nav class="ee-tabs" data-design-id="mobile-tab-nav" aria-label="Epic Errands tabs">
-    ${tabs.map(([id, label, mark]) => {
-      const disabled = id === "diy";
-      return `<button class="ee-tab" data-action="tab" data-tab="${id}" ${state.activeTab === id ? 'aria-current="page"' : ""} ${disabled ? 'aria-disabled="true" data-design-id="diy-lab-nav" title="DIY Lab is planned for later."' : ""}>
-        <span class="ee-tab-mark">${mark}</span>
-        <span>${label}</span>
-      </button>`;
-    }).join("")}
-  </nav>`;
-}
-
-function renderHeader() {
-  const style = shellStyle();
-  return `<header class="ee-top">
-    <div class="ee-brand-row">
-      <div>
-        <p class="ee-kicker">V1 mobile review</p>
-        <h1 class="ee-brand">Epic Errands</h1>
-      </div>
-      <span class="ee-pill">${escapeHtml(style.label)}</span>
-    </div>
-    ${renderTabs()}
-  </header>`;
-}
-
-function renderHome() {
-  const style = shellStyle();
-  return `<section class="ee-screen" data-design-id="home-screen" aria-labelledby="home-title">
-    <div>
-      <h2 class="ee-screen-title" id="home-title">Choose today's style</h2>
-      <p class="ee-copy">${escapeHtml(state.parentName)} is ${escapeHtml(style.parent_title)}. ${escapeHtml(state.kidName)} is ${escapeHtml(style.kid_title)}.</p>
-    </div>
-
-    <section class="ee-panel" data-design-id="style-mode-picker" aria-labelledby="style-label">
-      <p class="ee-section-label" id="style-label">Goal style</p>
-      <div class="ee-style-list">
-        ${Object.entries(state.styles).map(([id, item]) => `<button class="ee-style-button" data-action="style" data-style="${id}" aria-pressed="${state.defaultStyleId === id}">
-          <span class="ee-mark">${escapeHtml(item.mark)}</span>
-          <span>
-            <span class="ee-style-name">${escapeHtml(item.label)}</span>
-            <span class="ee-style-meta">${escapeHtml(item.goal_noun)} / ${escapeHtml(item.reward_noun)}. ${escapeHtml(item.copy)}</span>
-          </span>
-          <span class="ee-dot" aria-hidden="true"></span>
-        </button>`).join("")}
-      </div>
-    </section>
-
-    <section class="ee-panel" data-design-id="avatar-creator" aria-labelledby="avatar-label">
-      <p class="ee-section-label" id="avatar-label">Avatars</p>
-      <div class="ee-avatar-grid">
-        ${renderAvatar("parent", state.parentName, style.parent_title)}
-        ${renderAvatar("kid", state.kidName, style.kid_title)}
-      </div>
-      <p class="ee-privacy">Photo previews are session-only in this prototype. Nothing is persisted.</p>
-    </section>
-
-    <section class="ee-counter-grid" data-design-id="active-goal-count" aria-label="Goal counts">
-      <div class="ee-counter"><strong>${state.goals.length}</strong><span>active goals</span></div>
-      <div class="ee-counter"><strong>${awaitingApprovalCount()}</strong><span>awaiting approval</span></div>
-    </section>
-  </section>`;
-}
-
-function renderAvatar(role, name, title) {
-  const preview = state.avatarPreviews[role];
-  const label = role === "parent" ? "Parent" : "Kid";
-  return `<div class="ee-avatar">
-    <div class="ee-name-row">
-      ${preview ? `<img class="ee-avatar-photo" src="${preview}" alt="${label} avatar preview">` : `<span class="ee-avatar-mark">${role === "parent" ? "PA" : "KD"}</span>`}
-      <div>
-        <span class="ee-style-name">${escapeHtml(label)}</span>
-        <span class="ee-small">${escapeHtml(title)}</span>
-      </div>
-    </div>
-    <label class="ee-small">${label} name
-      <input class="ee-name-input" data-action="name" data-role="${role}" value="${escapeHtml(name)}" autocomplete="off">
-    </label>
-    <input class="ee-file" data-action="avatar" data-role="${role}" type="file" accept="image/*" aria-label="Upload ${label} photo">
-  </div>`;
-}
-
-function renderParent() {
-  return `<section class="ee-screen" data-design-id="parent-goals-screen" aria-labelledby="parent-title">
-    <div>
-      <h2 class="ee-screen-title" id="parent-title">Parent Goals</h2>
-      <p class="ee-copy">Approve completed goals and grant the reward. Everything else is coordinated offline.</p>
-    </div>
-    <div class="ee-goal-list" data-design-id="parent-goal-list">
-      ${state.goals.map((goal) => {
-        const style = styleFor(goal);
-        const canApprove = goal.parent_reward_state === "waiting_for_approval";
-        const approved = goal.parent_reward_state === "approved_reward_given";
-        return `<article class="ee-goal-row" data-goal-id="${goal.id}">
-          <div class="ee-title-row">
-            <span class="ee-goal-name">${escapeHtml(goal.title)}</span>
-            ${stateChip(goal)}
-          </div>
-          <div class="ee-chip-row">
-            <span class="ee-chip">${escapeHtml(style.label)}</span>
-            <span class="ee-chip">${escapeHtml(style.reward)}</span>
-          </div>
-          <span class="ee-goal-meta">Ordinary goal: ${escapeHtml(goal.ordinary_goal)}</span>
-          <button class="ee-approve-button" data-design-id="parent-approve-action" data-action="approve" data-goal-id="${goal.id}" ${canApprove ? "" : "disabled"}>${approved ? "Approved" : "Approve reward"}</button>
-        </article>`;
-      }).join("")}
-    </div>
-  </section>`;
-}
-
-function renderKid() {
-  const selected = state.goals.find((goal) => goal.id === state.selectedGoalId) || state.goals[0];
-  return `<section class="ee-screen" data-design-id="kid-goals-screen" aria-labelledby="kid-title">
-    <div>
-      <h2 class="ee-screen-title" id="kid-title">Kid Goals</h2>
-      <p class="ee-copy">Tap a goal, open the card, mark it complete, then wait for your grown-up's themed approval.</p>
-    </div>
-    <div class="ee-kid-grid" data-design-id="kid-goal-thumbnail-grid">
-      ${state.goals.map((goal) => {
-        const style = styleFor(goal);
-        return `<button class="ee-kid-tile" data-action="select-goal" data-goal-id="${goal.id}" aria-pressed="${state.selectedGoalId === goal.id}">
-          <img src="${state.images[normalizeStyleId(goal.style_id)] || ""}" alt="${escapeHtml(style.label)} generated image for ${escapeHtml(goal.ordinary_goal)}">
-          <span class="ee-tile-body">
-            <span class="ee-tile-title">${escapeHtml(goal.title)}</span>
-            ${stateChip(goal)}
-          </span>
-        </button>`;
-      }).join("")}
-    </div>
-    ${renderGoalCard(selected)}
-  </section>`;
-}
-
-function renderGoalCard(goal) {
-  const style = styleFor(goal);
-  const styleId = normalizeStyleId(goal.style_id);
-  const steps = stepsByStyle[styleId] || stepsByStyle.classroom;
-  const waiting = goal.parent_reward_state === "waiting_for_approval";
-  const rewarded = goal.parent_reward_state === "approved_reward_given";
-  return `<article class="ee-goal-card" data-design-id="kid-goal-card">
-    <img class="ee-card-image" src="${state.images[styleId] || ""}" alt="${escapeHtml(style.label)} generated goal card image for ${escapeHtml(goal.ordinary_goal)}">
-    <div class="ee-card-body">
-      <div>
-        <p class="ee-kicker">${escapeHtml(style.kid_title)} ${escapeHtml(style.goal_noun)}</p>
-        <h2>${escapeHtml(goal.title)}</h2>
-        <p class="ee-copy">${escapeHtml(style.copy)}</p>
-      </div>
-      <ol class="ee-step-list">
-        ${steps.map((step, index) => `<li><b>${index + 1}</b><span>${escapeHtml(step)}</span></li>`).join("")}
-      </ol>
-      <div class="ee-card-action-row">
-        <button class="ee-audio-button" data-design-id="audio-play-hook" disabled>Audio in V1.1</button>
-        <button class="ee-complete-button" data-action="complete" data-goal-id="${goal.id}" ${goal.kid_completion_state === "completed" ? "disabled" : ""}>${goal.kid_completion_state === "completed" ? "Completed" : `Mark ${style.goal_noun} complete`}</button>
-      </div>
-      ${waiting ? `<div class="ee-status-panel" data-design-id="waiting-for-parent-approval"><strong>${escapeHtml(style.waiting)}</strong><span>Your ${escapeHtml(style.reward_noun)} unlocks when ${escapeHtml(style.parent_title)} approves.</span></div>` : ""}
-      ${rewarded ? `<div class="ee-status-panel" data-tone="success"><strong>${escapeHtml(style.reward)} earned!</strong><span>${escapeHtml(style.parent_title)} approved this goal.</span></div>` : ""}
-    </div>
-  </article>`;
-}
-
-function render() {
-  const shell = root.querySelector(".ee-shell");
-  const screen = state.activeTab === "parent" ? renderParent() : state.activeTab === "kid" ? renderKid() : renderHome();
-  shell.dataset.style = normalizeStyleId(state.defaultStyleId);
-  shell.innerHTML = `${renderHeader()}<div class="ee-body">${screen}</div>`;
-}
-
-root.addEventListener("click", (event) => {
-  const target = event.target.closest("[data-action]");
-  if (!target) return;
-
-  if (target.dataset.action === "tab") {
-    if (target.getAttribute("aria-disabled") === "true") return;
-    state.activeTab = target.dataset.tab || "home";
-    render();
-    return;
-  }
-
-  if (target.dataset.action === "style") {
-    state.defaultStyleId = normalizeStyleId(target.dataset.style || state.defaultStyleId);
-    render();
-    return;
-  }
-
-  if (target.dataset.action === "select-goal") {
-    state.selectedGoalId = target.dataset.goalId || state.selectedGoalId;
-    render();
-    return;
-  }
-
-  if (target.dataset.action === "complete") {
-    const goal = state.goals.find((item) => item.id === target.dataset.goalId);
-    if (goal) {
-      goal.kid_completion_state = "completed";
-      if (goal.parent_reward_state !== "approved_reward_given") {
-        goal.parent_reward_state = "waiting_for_approval";
-      }
-      render();
-    }
-    return;
-  }
-
-  if (target.dataset.action === "approve") {
-    const goal = state.goals.find((item) => item.id === target.dataset.goalId);
-    if (goal && goal.kid_completion_state === "completed") {
-      goal.parent_reward_state = "approved_reward_given";
-      render();
-    }
-  }
-});
-
-root.addEventListener("input", (event) => {
-  const target = event.target;
-  if (!target || target.dataset.action !== "name") return;
-  if (target.dataset.role === "parent") {
-    state.parentName = target.value || "Parent";
-  } else if (target.dataset.role === "kid") {
-    state.kidName = target.value || "Kid";
-  }
-});
-
-root.addEventListener("change", (event) => {
-  const target = event.target;
-  if (!target || target.dataset.action !== "avatar") return;
-  const file = target.files && target.files[0];
-  if (!file) return;
-  const role = target.dataset.role;
-  if (state.avatarPreviews[role]) {
-    URL.revokeObjectURL(state.avatarPreviews[role]);
-  }
-  state.avatarPreviews[role] = URL.createObjectURL(file);
-  render();
-});
-
-render();
-}
-"""
-    ).replace("__STATE_JSON__", state_json)
-
-
-def build_app_document(asset_base: str = "/file=frontend/assets/") -> str:
-    del asset_base
-    return f"""<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1">
-    <title>Epic Errands V1 - Mobile Review Prototype</title>
-    <style>
-      body {{
-        margin: 0;
-        background: #e9f1fb;
-      }}
-      {build_app_css()}
-    </style>
-  </head>
-  <body>
-    {build_app_island()}
-    <script>
-      const element = document;
-      {build_app_bootstrap_js()}
-    </script>
-  </body>
-</html>"""

frontend/assets/generated-audio-1-clean-up-my-room-before-dinner-56693c13.wav

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:52b5cef22f4556f7cb181a6dec7383f5df848cf7bb4d8b97780a0ffe8d91682b
-size 445484

frontend/assets/generated-audio-2-finish-my-class-project-outline-62a0674b.wav

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

frontend/assets/generated-audio-3-read-for-20-minutes-5e944b16.wav

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:425f6bc70db9b75fdd6b4c0209737ea59181dfd72fd50fc6a1cea249f764490b
-size 537644

frontend/index.html

@@ -7,17 +7,17 @@
     <link rel="preconnect" href="https://fonts.googleapis.com">
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
     <link href="https://fonts.googleapis.com/css2?family=Baloo+2:wght@500;600;700;800&family=Nunito:wght@400;600;700;800;900&family=Bangers&family=Hanken+Grotesk:wght@400;500;600;700;800&family=Playfair+Display:ital,wght@0,400;0,500;0,600;0,700;0,800;0,900;1,500&family=Lora:ital,wght@0,400;0,500;0,600;0,700;1,400&display=swap" rel="stylesheet">
-    <link rel="stylesheet" href="frontend/styles/tokens.css">
-    <link rel="stylesheet" href="frontend/styles/components.css">
-    <link rel="stylesheet" href="frontend/styles/app.css">
+    <link rel="stylesheet" href="/epic/styles/tokens.css">
+    <link rel="stylesheet" href="/epic/styles/components.css">
+    <link rel="stylesheet" href="/epic/styles/app.css">
   </head>
   <body>
     <main class="stage" aria-label="Epic Errands V2">
       <div id="app"></div>
     </main>
     <script>
-      window.EPIC_ASSET_BASE = "frontend/assets/";
+      window.EPIC_ASSET_BASE = "/epic/assets/";
     </script>
-    <script src="frontend/scripts/app.js"></script>
+    <script src="/epic/scripts/app.js"></script>
   </body>
 </html>