Overview

Chapter 4: Visual Asset & Mascot Consistency Agent: Imagen 3 Fleet

Playbook Track: 03 – Autonomous Agentic Video Studio (Kids Karaoke & Educational Songs)
Agent Specialization: Visual Asset & Mascot Consistency Agent (VisualAssetAgent)
Target Audience: Year 1 Computer Science & Software Engineering Students Tooling Stack: Google Imagen 3 (imagen-3.0-generate-002), Gemini 2.5 Flash (Asset Manifest & Linter), Python 3.11+
Status: Ready for Production Deployment
Upstream Handoff: `ch02-curriculum-and-song-selection.md` (SongCurriculumManifest) & `ch03-music-and-lyricist-agent.md` (SongMusicalManifest)
Downstream Handoff: `ch05-animation-director-veo.md` (SceneVisualKeyframes for Google Veo 2 I2V conditioning)

0. The Big Picture: Nintendo Character Bibles vs. Probabilistic Drift

Think of Nintendo's official design manual for Mario or Pikachu:

• Nintendo's brand team has strict, millimeter-accurate specifications: Mario's cap is always red hex #E52521 with a white circle and red 'M', his overalls are denim blue with two yellow buttons, and his mustache has exactly 6 rounded bumps.
• If a game developer drew Mario with green overalls and a pointy mustache, Nintendo would reject the build immediately.
• In children's media, toddlers rely on the mascot as a friendly, reassuring guide. If Barnaby Bunny's fur color changes from yellow to orange in shot 3, toddlers get confused and stop following the lesson.

In this chapter, you will build the Visual Asset & Mascot Consistency Agent:

1. It maintains an immutable 7-Dimension Mascot Invariant Registry (species, hex colors, eye catchlights, wardrobe, head proportions, lighting, and textures).
2. It generates 4-view orthographic turnaround sheets in Google Imagen 3.
3. It lints every prompt before submission to reject missing tokens or forbidden words (claws, sharp teeth), ensuring 100% character stability across the entire episode.

0.1 Engineering Jargon Demystifier Table

0.2 The 5-Minute Micro-Lab: The Mascot Lexical Invariant Linter

Run this zero-dependency Python script to see how automated software audits an Imagen 3 prompt to ensure character consistency:

"""
Micro-Lab: Mascot Lexical Invariant Linter
PB-03 Chapter 4 Micro-Lab (Zero External Dependencies)
"""

REQUIRED_INVARIANTS = ["baby lop-eared bunny", "#FFF099", "turquoise overalls", "dual white catchlights"]
BANNED_HAZARDS = ["sharp teeth", "claws", "realistic skin", "fangs", "creepy"]

def lint_mascot_prompt(prompt: str) -> dict:
    p_lower = prompt.lower()
    missing = [req for req in REQUIRED_INVARIANTS if req.lower() not in p_lower]
    hazards = [haz for haz in BANNED_HAZARDS if haz.lower() in p_lower]
    
    passed = (len(missing) == 0) and (len(hazards) == 0)
    return {
        "missing_invariants": missing,
        "hazard_violations": hazards,
        "verdict": "[PASS]" if passed else "[FAIL]"
    }

if __name__ == "__main__":
    valid_prompt = "A 3D baby lop-eared bunny rabbit with pastel buttercup yellow fur (#FFF099), wearing turquoise overalls, with large circular eyes and dual white catchlights, smiling warmly."
    res = lint_mascot_prompt(valid_prompt)
    print("Mascot Invariant Linter Report:")
    print(f"  Missing Tokens: {res['missing_invariants']}")
    print(f"  Hazard Tokens:  {res['hazard_violations']}")
    print(f"  Linter Status:  {res['verdict']}")
    assert res["verdict"] == "[PASS]"
    print("[PASS] Micro-lab assertions verified successfully.")

0.3 Freshman Survival Guide: 3 Traps to Avoid

1. Trap 1: The Vague Description Trap: Writing "cute yellow rabbit". Imagen 3 will generate a different rabbit breed every time. Specify breed, exact hex code, eye catchlights, and clothing.
2. Trap 2: Scary Predator Features: Forgetting negative prompts and generating sharp animal claws or realistic fangs. Toddlers find predatory features scary; always ban sharp teeth in prompts.
3. Trap 3: Multi-Character Bleed: Prompting two animals without spatial anchors. Their colors will blend together into weird hybrids. Always specify normalized spatial coordinates (e.g. Mascot A at $x=0.35$, Mascot B at $x=0.68$).

Executive Architectural Summary

In children's educational animation, character recognition is the anchor of emotional engagement. Toddlers (ages 2–6) form intense parasocial attachments to visual mascots. If a mascot's fur color shifts between shots, if their clothing changes subtly, or if their eye proportions warp, young children experience cognitive confusion, breaking their learning focus and immersion.

Standard image generation pipelines fail catastrophically at multi-shot character consistency. Generative diffusion models treat every prompt as an isolated probabilistic sample. The Visual Asset & Mascot Consistency Agent solves this through a rigorous Token Invariant Architecture:

1. Immutable Mascot Token Registry: Every studio mascot is defined by an immutable set of 7 visual invariants (species, fur hex palette, eye catchlights, wardrobe patches, chibi head-to-body ratios, surface render shaders, and lighting).
2. Multi-Angle Orthographic Turnaround Synthesis: Generates 4 standard orthographic model sheets per character (front_neutral, three_quarter_singing, profile_walking, back_view) on seamless pastel studio backgrounds at 1:1 square ratio.
3. Automated Lexical Invariant Linting: Intercepts and rejects prompts before submission to Imagen 3 (imagen-3.0-generate-002) if required identity tokens are missing or forbidden tokens (e.g. sharp teeth, claws, realistic pores) are detected.
4. Spatial Multi-Character Scene Composition: Calculates normalized bounding box anchors (x_center, y_center, scale) for multi-character interactions, preventing style cross-contamination between mascots.
5. I2V Keyframe Conditioning Output: Packages 16:9 widescreen master keyframe images with spatial anchor metadata, serving as the direct visual conditioning source for the Animation Director Agent's Google Veo 2 video generation (Chapter 5).

flowchart TD
    subgraph Inputs["1. Upstream Handoffs (Ch 02 & Ch 03)"]
        SCM["SongCurriculumManifest\n- Mascots: [Barnaby Bunny, Penny Pup]\n- Scene Contexts: Town, Bus, Stop"]
        SMM["SongMusicalManifest\n- 27-Bar Breakdown\n- Verse & Chorus Rhythms"]
    end

    subgraph VisualAgent["2. Visual Asset & Mascot Consistency Agent"]
        REG["Immutable Mascot Registry\n- 7 Visual Invariants\n- Chibi 2.5-Head Proportions\n- Hex Color Palettes"]
        LNT["Lexical Invariant Linter\n- Token Presence Assertion\n- Forbidden Token Rejection\n- Negative Prompt Synthesis"]
        IMG["Imagen 3 Engine (imagen-3.0-generate-002)\n- 1:1 Turnaround Model Sheets\n- 16:9 Multi-Character Scene Keyframes\n- Octane Claymation Rendering"]
        CMP["Spatial Anchor Compositor\n- Normalized Bounding Coordinates\n- Dual-Character Scene Layouts"]
    end

    subgraph Outputs["3. Downstream Handoff (Ch 05 Veo 2)"]
        VMF["VisualAssetManifest (.json)\n- 6 Validated Mascot Turnarounds\n- 5 Master Scene Keyframes (16:9)\n- Spatial Anchor Metadata"]
    end

    SCM --> REG
    SMM --> CMP
    REG --> LNT
    LNT --> IMG
    IMG --> CMP
    CMP --> VMF

Gate 1: Zero Fluff & Agentic Engineering Rigor

1.1 The 7 Immutable Mascot Invariant Dimensions

To guarantee that mascots maintain identical silhouettes, colors, and textures across hundreds of generated scenes, every mascot is specified across exactly 7 non-negotiable invariant dimensions:

1. Species & Archetype: Precise anthropomorphic breed (e.g., anthro baby lop-eared bunny rabbit).
2. Color Palette & Hex Specifications: Primary fur, secondary belly/snout, and inner ear colors locked to specific hex codes (e.g., pastel buttercup yellow #FFF099 with cream white belly).
3. Ocular Geometry & Catchlights: Cartoon eye style, pupil color, and specular highlight arrangement (e.g., large circular cartoon navy blue eyes #002244 with dual white catchlights).
4. Signature Wardrobe & Emblems: Distinctive clothing with persistent iconic motifs (e.g., bright turquoise denim overalls #00CCCC with single embroidered red apple patch on bib chest).
5. Chibi Toddler Proportions: Strict skeletal ratios preventing anatomical warping (e.g., 2.5 heads tall, chubby rounded cheeks, soft rounded padded paws, zero sharp geometry).
6. Surface Material Shader: Exact 3D rendering aesthetic preventing realistic creepiness (e.g., 3D Pixar-style claymation render, velvety soft matte silicone surface finish).
7. Lighting & Optical Profile: Studio illumination model (e.g., high-key Octane studio lighting, warm golden rim light on ear edges, soft ambient occlusion).

1.2 Multi-Character Interaction Anchoring

When two characters appear in the same frame (e.g., Barnaby Bunny and Penny Pup), diffusion models tend to blend their features—giving the bunny dog ears or turning the puppy yellow. The agent mitigates this by calculating normalized 2D spatial coordinate anchors:

$$\text{Anchor}(C_i) = { x_{\text{center}}, y_{\text{center}}, \text{scale} }$$

In a 16:9 aspect ratio ($1920 \times 1080$), characters are partitioned into discrete screen zones:

• Screen-Left Zone: $x_{\text{center}} \in [0.25, 0.40]$, $y_{\text{center}} = 0.60$, $\text{scale} = 0.45$
• Screen-Right Zone: $x_{\text{center}} \in [0.60, 0.75]$, $y_{\text{center}} = 0.60$, $\text{scale} = 0.45$

This explicit spatial division guides prompt compilation and downstream Veo 2 image-to-video latent conditioning.

Gate 2: Mandatory Naive vs. Production Contrasts

Gate 3: Latest Google Model Configurations & Schemas

3.1 Google Imagen 3 (imagen-3.0-generate-002) Production Payload

The agent compiles parameterized generation requests targeting the latest Imagen 3 endpoint:

IMAGEN_3_PRODUCTION_CONFIG = {
    "model": "imagen-3.0-generate-002",
    "parameters": {
        "aspect_ratio": "16:9",              # 16:9 for scene keyframes; 1:1 for turnarounds
        "number_of_images": 1,
        "safety_filter_level": "block_medium_and_above",
        "person_generation": "ALLOW_ALL",     # Required for anthropomorphic characters
        "output_mime_type": "image/png"
    },
    "default_negative_prompt": (
        "photorealistic, real human skin, detailed fur pores, sharp teeth, claws, scary, "
        "dark shadows, desaturated colors, deformed hands, extra fingers, missing limbs, "
        "grainy, noisy, complex textures, adult proportions, uncanny valley"
    )
}

3.2 Visual Asset Manifest Schema

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "title": "VisualAssetManifest",
  "type": "object",
  "required": ["manifest_id", "song_id", "mascots", "turnarounds", "scene_keyframes"],
  "properties": {
    "manifest_id": { "type": "string" },
    "song_id": { "type": "string" },
    "mascots": {
      "type": "array",
      "items": {
        "type": "object",
        "required": ["character_id", "name", "role", "tokens"],
        "properties": {
          "character_id": { "type": "string" },
          "name": { "type": "string" },
          "role": { "type": "string" },
          "tokens": { "type": "object" }
        }
      }
    },
    "turnarounds": {
      "type": "array",
      "items": {
        "type": "object",
        "required": ["asset_id", "character_id", "view_angle", "aspect_ratio", "imagen_prompt"],
        "properties": {
          "asset_id": { "type": "string" },
          "character_id": { "type": "string" },
          "view_angle": { "type": "string" },
          "aspect_ratio": { "type": "string" },
          "imagen_prompt": { "type": "string" }
        }
      }
    },
    "scene_keyframes": {
      "type": "array",
      "items": {
        "type": "object",
        "required": ["scene_id", "song_bar_range", "spatial_anchors", "composite_prompt"],
        "properties": {
          "scene_id": { "type": "string" },
          "song_bar_range": { "type": "string" },
          "spatial_anchors": { "type": "object" },
          "composite_prompt": { "type": "string" }
        }
      }
    }
  }
}

Gate 4: Quantitative Trade-Off Matrix

Gate 5: The 10 Operational Failure Modes in Generative Mascot Fleets

1. Costume Emblem Mutation: Overalls patch drifts from an embroidered red apple to a red star, cherry, or blank denim bib. Defense: Strict invariant string assertion requiring "single embroidered red apple patch on bib chest" in every character prompt.
2. Anthropomorphic Scale Inversion: The puppy mascot suddenly appears twice the size of the bunny in a two-shot scene. Defense: Hard-coded scale: 0.45 spatial anchor enforcement and explicit "equal toddler height" descriptor.
3. The Uncanny Valley Fur Trap: Model generates micro-detailed animal hair strands and creepy skin pores. Defense: Negative prompt blocks "detailed fur pores", while positive prompt enforces "velvety soft matte silicone surface finish".
4. Sharp Teeth / Carnivore Artifacts: When characters open their mouths to sing nursery vowels ("ah", "oh"), diffusion models occasionally render sharp fangs. Defense: Negative token "sharp teeth" combined with positive descriptor "soft rounded tongue and gentle toothless smile".
5. Multi-Character Identity Cross-Bleed: In a scene with Barnaby Bunny and Penny Pup, Barnaby acquires puppy floppy ears. Defense: Partition prompt into distinct bracketed clauses with explicit screen-left and screen-right spatial demarcation.
6. Eye Catchlight Asymmetry: One eye renders with catchlights while the other is dead-black or has warped pupils. Defense: Quality Auditor Agent (Chapter 7) runs facial symmetry analysis on turnaround orthographics.
7. Aspect Ratio Letterboxing Distortion: Model defaults to 1:1 square for scene frames, forcing clumsy post-production cropping. Defense: Hard constraint enforcing aspect_ratio: "16:9" on all scene keyframes.
8. Negative Token Contamination in Positive Prompts: Writing phrases like "zero sharp claws" in the positive prompt causes diffusion models to latch onto "claws" and render sharp claws. Defense: Positive prompts use only affirmative descriptors ("soft rounded padded paws"); negative concepts belong strictly in negative_prompt.
9. Cyclorama Shadow Cast Artifacts: Turnaround model sheets have heavy cast floor shadows, complicating clean alpha matting. Defense: Include token "isolated character model sheet on plain solid pastel off-white seamless cyclorama studio background, zero shadows on floor".
10. Downstream Keyframe Conditioning Rejection: Keyframe has excessive motion blur or complex perspective, causing Veo 2 video interpolation to fail. Defense: All master keyframes must be composed in static eye-level camera framing with sharp silhouette contrast.

Gate 6: Mandatory Hands-On Lab (Interactive Challenge)

Lab Objective

In this hands-on lab, you will build and test the complete Mascot Fleet Consistency Engine (MascotFleetConsistencyEngine).

Your engine must:

1. Register distinct educational character specifications with 7 locked visual invariant dimensions.
2. Formulate 1:1 square orthographic turnaround prompts for 4 canonical view angles (front_neutral, three_quarter_singing, profile_walking, back_view).
3. Implement an automated lexical invariant linter that validates the presence of mandatory identity tokens and raises explicit exceptions if forbidden tokens are detected.
4. Construct multi-character 16:9 scene composition keyframes with normalized 2D spatial coordinate anchors (x_center, y_center, scale).
5. Format production-grade Imagen 3 payloads with negative anti-masking prompts.
6. Export the complete VisualAssetManifest as a verified JSON artifact ready for handoff to Google Veo 2 video directing in Chapter 5.

Gate 7: Mandatory Recommended Answer & Executable Solution

Below is the production-grade, zero-dependency Python 3.11+ implementation. Save this script as mascot_fleet_consistency_engine.py and run it directly with python3 mascot_fleet_consistency_engine.py.

"""
mascot_fleet_consistency_engine.py
Production Reference Implementation for Playbook 03 Chapter 4:
Visual Asset & Mascot Consistency Agent: Imagen 3 Fleet.

Zero third-party dependencies. Compatible with Python 3.11+.
"""
import dataclasses
import json
import re
from typing import List, Dict, Any, Optional

@dataclasses.dataclass
class VisualTokenSet:
    species: str
    fur_palette: str
    eye_spec: str
    wardrobe: str
    proportions: str
    render_style: str
    lighting: str

@dataclasses.dataclass
class CharacterSpec:
    character_id: str
    name: str
    role: str
    tokens: VisualTokenSet
    forbidden_tokens: List[str]
    required_turnarounds: List[str]

@dataclasses.dataclass
class TurnaroundAsset:
    asset_id: str
    character_id: str
    view_angle: str
    aspect_ratio: str
    imagen_prompt: str
    negative_prompt: str
    status: str = "validated"

@dataclasses.dataclass
class SceneCompositionSpec:
    scene_id: str
    song_bar_range: str
    primary_character_id: str
    secondary_character_id: Optional[str]
    background_environment: str
    camera_framing: str
    spatial_anchors: Dict[str, Dict[str, float]]
    composite_prompt: str

class MascotFleetConsistencyEngine:
    """
    Production Subsystem for Visual Asset & Mascot Consistency Agent:
    Compiles immutable character token invariant models, produces multi-angle
    turnaround generation payloads for Imagen 3, lints prompts against style drift,
    and constructs multi-character spatial scene compositions.
    """

    DEFAULT_NEGATIVE_PROMPT = (
        "photorealistic, real human skin, detailed fur pores, sharp teeth, claws, scary, "
        "dark shadows, desaturated colors, deformed hands, extra fingers, missing limbs, "
        "grainy, noisy, complex textures, adult proportions, uncanny valley"
    )

    def __init__(self):
        self.characters: Dict[str, CharacterSpec] = {}

    def register_character(self, spec: CharacterSpec) -> None:
        """Registers a character model into the studio mascot fleet registry."""
        self.characters[spec.character_id] = spec

    def build_turnaround_prompt(self, character_id: str, view_angle: str) -> str:
        """Constructs an invariant-enforced orthographic turnaround prompt for Imagen 3."""
        if character_id not in self.characters:
            raise KeyError(f"Character {character_id} not registered.")
        
        char = self.characters[character_id]
        t = char.tokens

        angle_descriptions = {
            "front_neutral": "front orthographic full-body view, standing upright, joyful gentle smile, arms relaxed at sides",
            "three_quarter_singing": "three-quarter hero action view, mouth open singing joyful nursery vowel 'ah', one paw raised rhythmically",
            "profile_walking": "side profile walking pose, right foot stepping forward, holding small conductor baton",
            "back_view": "rear orthographic full-body view showing back of overalls and rear head silhouette"
        }

        view_desc = angle_descriptions.get(view_angle, f"{view_angle} view")

        prompt = (
            f"Children educational mascot turnaround: {char.name}, {t.species}. {view_desc}. "
            f"Appearance: {t.fur_palette}, {t.eye_spec}, wearing {t.wardrobe}. "
            f"Anatomy: {t.proportions}. "
            f"Style: {t.render_style}, {t.lighting}. "
            f"Isolated character model sheet on plain solid pastel off-white seamless cyclorama studio background, "
            f"zero shadows on floor, crisp silhouette outline for clean alpha extraction."
        )
        return prompt

    def lint_prompt(self, character_id: str, prompt: str) -> bool:
        """Lints an Imagen 3 prompt to ensure 100% token invariant compliance and zero forbidden leaks."""
        char = self.characters[character_id]
        lower_prompt = prompt.lower()

        # 1. Assert forbidden tokens are absent
        for forbidden in char.forbidden_tokens:
            if forbidden.lower() in lower_prompt:
                raise ValueError(f"Prompt contains forbidden token '{forbidden}':\n{prompt}")

        # 2. Assert key identity tokens are present
        required_elements = [
            char.tokens.species.lower().split()[0],
            "overalls",
            "chibi",
            "toddler"
        ]
        for req in required_elements:
            if req not in lower_prompt:
                raise ValueError(f"Prompt missing required invariant token '{req}':\n{prompt}")

        return True

    def generate_fleet_turnarounds(self) -> List[TurnaroundAsset]:
        """Generates validated turnaround assets for all registered mascots."""
        assets: List[TurnaroundAsset] = []
        for char_id, char in self.characters.items():
            for angle in char.required_turnarounds:
                p = self.build_turnaround_prompt(char_id, angle)
                self.lint_prompt(char_id, p)
                assets.append(TurnaroundAsset(
                    asset_id=f"AST-{char_id}-{angle.upper()}",
                    character_id=char_id,
                    view_angle=angle,
                    aspect_ratio="1:1",
                    imagen_prompt=p,
                    negative_prompt=self.DEFAULT_NEGATIVE_PROMPT
                ))
        return assets

    def build_scene_composition(
        self,
        scene_id: str,
        bar_range: str,
        primary_char_id: str,
        secondary_char_id: Optional[str],
        env: str,
        framing: str
    ) -> SceneCompositionSpec:
        """Compiles a multi-character scene prompt with spatial bounding coordinates."""
        p_char = self.characters[primary_char_id]
        anchors = {
            primary_char_id: {"x_center": 0.35, "y_center": 0.60, "scale": 0.45}
        }
        char_descriptions = [
            f"{p_char.name} ({p_char.tokens.species} in {p_char.tokens.wardrobe}) positioned on screen-left"
        ]

        if secondary_char_id:
            s_char = self.characters[secondary_char_id]
            anchors[secondary_char_id] = {"x_center": 0.68, "y_center": 0.60, "scale": 0.45}
            char_descriptions.append(
                f"{s_char.name} ({s_char.tokens.species} in {s_char.tokens.wardrobe}) positioned on screen-right"
            )

        composite_prompt = (
            f"16:9 widescreen educational nursery song scene. {framing} of {' and '.join(char_descriptions)}. "
            f"Setting: {env}. Characters interact happily with wide joyful expressions. "
            f"Lighting: warm daytime golden-hour sunlight, soft studio rim light. "
            f"Aesthetic: {p_char.tokens.render_style}, vibrant cheerful pastel colors, toddler educational media quality, pristine 4K resolution."
        )

        return SceneCompositionSpec(
            scene_id=scene_id,
            song_bar_range=bar_range,
            primary_character_id=primary_char_id,
            secondary_character_id=secondary_char_id,
            background_environment=env,
            camera_framing=framing,
            spatial_anchors=anchors,
            composite_prompt=composite_prompt
        )

# =====================================================================
# Unit Test Assertions Certifying Gate 7 Compliance
# =====================================================================
def run_tests():
    engine = MascotFleetConsistencyEngine()

    # Register Character 1: Barnaby Bunny (Lead Mascot)
    barnaby = CharacterSpec(
        character_id="CHAR-BUNNY-BARNABY",
        name="Barnaby Bunny",
        role="Lead Singer & Conductor",
        tokens=VisualTokenSet(
            species="anthro baby lop-eared bunny rabbit",
            fur_palette="pastel buttercup yellow fur (#FFF099) with cream white belly and cheeks",
            eye_spec="large glossy circular cartoon navy blue eyes (#002244) with dual white catchlights",
            wardrobe="bright turquoise denim overalls (#00CCCC) with single embroidered red apple patch on bib chest, white cotton undershirt",
            proportions="chibi toddler proportions, 2.5 heads tall, chubby rounded cheeks, soft rounded padded paws",
            render_style="3D Pixar-style claymation render, velvety soft matte silicone surface finish",
            lighting="high-key Octane studio lighting, warm golden rim light on ear edges, soft ambient occlusion"
        ),
        forbidden_tokens=["photorealistic fur", "sharp teeth", "claws", "creepy pores", "dark shadows", "complex fabric textures"],
        required_turnarounds=["front_neutral", "three_quarter_singing", "profile_walking", "back_view"]
    )
    engine.register_character(barnaby)

    # Register Character 2: Penny Pup (Bus Driver Mascot)
    penny = CharacterSpec(
        character_id="CHAR-PUP-PENNY",
        name="Penny Pup",
        role="Friendly Bus Driver",
        tokens=VisualTokenSet(
            species="anthro baby cocker spaniel puppy",
            fur_palette="warm caramel brown fur with cream snout and floppy soft ears",
            eye_spec="warm expressive chocolate brown eyes with sparkling highlights",
            wardrobe="bright red toddler overalls with little brass driver badge on chest, yellow striped undershirt",
            proportions="chibi toddler proportions, 2.5 heads tall, floppy ears, round soft paws",
            render_style="3D Pixar-style claymation render, velvety soft matte surface finish",
            lighting="high-key Octane studio lighting, warm golden rim light"
        ),
        forbidden_tokens=["photorealistic fur", "sharp teeth", "claws", "creepy pores", "dark shadows"],
        required_turnarounds=["front_neutral", "three_quarter_singing"]
    )
    engine.register_character(penny)

    # 1. Test turnaround generation
    assets = engine.generate_fleet_turnarounds()
    assert len(assets) == 6, f"Expected 6 turnaround assets (4 for Barnaby + 2 for Penny), got {len(assets)}"
    for a in assets:
        assert a.aspect_ratio == "1:1", "Turnarounds must be 1:1 square orthographics"
        assert "overalls" in a.imagen_prompt.lower(), "Wardrobe token must be present"
        assert "photorealistic" in a.negative_prompt.lower(), "Negative prompt must be populated"

    # 2. Test forbidden token linting failure
    bad_prompt = "Barnaby Bunny chibi toddler in overalls with sharp teeth"
    try:
        engine.lint_prompt("CHAR-BUNNY-BARNABY", bad_prompt)
        assert False, "Should have raised ValueError for forbidden token"
    except ValueError as e:
        assert "sharp teeth" in str(e)

    # 3. Test multi-character scene composition
    scene = engine.build_scene_composition(
        scene_id="SCN-001-BUS-INTRO",
        bar_range="Bars 0-3",
        primary_char_id="CHAR-BUNNY-BARNABY",
        secondary_char_id="CHAR-PUP-PENNY",
        env="whimsical sunny cartoon town with rounded pastel buildings, cobblestone street, cheerful blooming sunflowers",
        framing="wide eye-level two-shot establishing frame"
    )

    assert "CHAR-BUNNY-BARNABY" in scene.spatial_anchors
    assert "CHAR-PUP-PENNY" in scene.spatial_anchors
    assert scene.spatial_anchors["CHAR-BUNNY-BARNABY"]["x_center"] == 0.35
    assert scene.spatial_anchors["CHAR-PUP-PENNY"]["x_center"] == 0.68
    assert "16:9 widescreen" in scene.composite_prompt

    # 4. Test JSON serialization
    serialized = json.dumps(dataclasses.asdict(scene), indent=2)
    assert len(serialized) > 200
    deserialized = json.loads(serialized)
    assert deserialized["scene_id"] == "SCN-001-BUS-INTRO"

    print("\n[PASS] All 4 Acceptance Test Suites Passed (100% Gate 7 Compliance)!")
    print(f"Total Mascots Registered: {len(engine.characters)}, Turnarounds Generated: {len(assets)}, Scene Anchors: {len(scene.spatial_anchors)}")

if __name__ == "__main__":
    run_tests()

Handoff to Downstream Agents

With the VisualAssetManifest compiled and validated, the multi-agent production flow transitions to video directing:

1. The Animation Director Agent (Chapter 5): Ingests the 16:9 master scene keyframes and spatial anchor metadata, using Google Veo 2 image-to-video (veo-2.0 I2V) conditioning to animate camera movements and mascot dances synchronized to the 27-bar musical score.
2. The Quality Auditor Agent (Chapter 7): Compares synthesized video frames against the orthographic turnaround model sheets using Gemini 2.5 Pro Vision to assert zero character drift throughout the song episode.