Overview

Chapter 7: The Quality Auditor & COPPA Compliance Gatekeeper

Playbook Track: 03 – Autonomous Agentic Video Studio (Kids Karaoke & Educational Songs)
Agent Specialization: Quality Auditor & COPPA Compliance Gatekeeper (QualityAuditorAgent)
Target Audience: Year 1 Computer Science & Software Engineering Students Tooling Stack: Gemini 2.5 Pro (Multimodal Vision QA), Python 3.11+, COPPA / FTC Rule Engine
Status: Ready for Production Deployment
Upstream Handoff: `ch06-post-production-karaoke-agent.md` (RenderedEpisodeArtifact)
Downstream Handoff: `ch08-autonomous-studio-orchestrator.md` (CertifiedProductionRelease for YouTube Kids publishing)

0. The Big Picture: Baby Food Factory Inspectors vs. Silent Glitches

Think of the strict health inspectors at a baby food packaging factory:

• Before any jar of baby puree can ship to supermarket shelves, independent laboratory testers test samples for harmful bacteria, verify that nutrition facts match the label, and ensure the jar's vacuum seal is airtight.
• Nobody is allowed to say: "It smells fine to me, let's ship it!"
• In children's educational media, the stakes are just as high:
  • Federal COPPA laws impose massive fines if personal data, GPS markers, or QR codes leak into videos watched by children under 13.
  • Pediatric health standards (ITU-R BT.1702) strictly ban rapid screen flashing above 3.0 Hz, which can trigger epileptic seizures in photosensitive children.
  • If subtitles drift by more than 50 milliseconds, young children lose the phonetic sing-along connection.

In this chapter, you will build the Quality Auditor & COPPA Compliance Gatekeeper:

1. It acts as the automated FDA/regulatory inspector for your video studio.
2. It audits every finished episode across 6 critical safety dimensions (COPPA, strobe frequency, acoustic loudness, subtitle phase, character consistency, and duration).
3. If an episode fails, it automatically issues targeted repair tickets back to the specific upstream agent, with a hard retry ceiling of 3 to prevent infinite loops.

0.1 Engineering Jargon Demystifier Table

0.2 The 5-Minute Micro-Lab: The COPPA & Photosensitive Strobe Linter

Run this zero-dependency Python script to see how automated software audits video parameters against pediatric safety and COPPA rules:

"""
Micro-Lab: COPPA & Photosensitive Strobe Linter
PB-03 Chapter 7 Micro-Lab (Zero External Dependencies)
"""

def audit_episode_safety(strobe_hz: float, subtitle_delta_ms: int, prompt_text: str) -> dict:
    violations = []
    
    # 1. Anti-seizure check (ITU-R BT.1702: Max 3.0 Hz)
    if strobe_hz > 3.0:
        violations.append(f"Strobe rate {strobe_hz} Hz exceeds 3.0 Hz safety threshold")
        
    # 2. Subtitle synchrony (Max 50 ms phase delta)
    if subtitle_delta_ms > 50:
        violations.append(f"Subtitle phase delta {subtitle_delta_ms} ms exceeds 50 ms limit")
        
    # 3. COPPA / Visual safety (No brand logos, real faces, or predator traits)
    banned = ["qr code", "sharp teeth", "brand logo", "phone number"]
    for b in banned:
        if b in prompt_text.lower():
            violations.append(f"COPPA violation: found banned token '{b}'")
            
    passed = len(violations) == 0
    return {
        "passed": passed,
        "violations_count": len(violations),
        "violations": violations,
        "verdict": "[PASS]" if passed else "[FAIL]"
    }

if __name__ == "__main__":
    res = audit_episode_safety(strobe_hz=2.0, subtitle_delta_ms=30, prompt_text="Barnaby Bunny singing happily on clean pastel farm")
    print("Safety & COPPA Gatekeeper Report:")
    print(f"  Violations Found: {res['violations_count']}")
    print(f"  Audit 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 Human Review Bottleneck: Trying to have humans manually check all 50 generated videos every week. Code assertions can verify 95% of safety rules in 100 milliseconds.
2. Trap 2: Infinite Thrashing Loops: Allowing an agent to retry forever when an asset fails. Always set max_retries = 3 so you don't burn $100 in runaway API tokens.
3. Trap 3: Strobe Lighting in Animations: Adding rapid white flashes or lightning bolts during celebrations. Flashes above 3 Hz cause seizures in photosensitive children; use smooth glowing sparkles instead.

Executive Architectural Summary

In an autonomous video production company operating without human animators or editors, the Quality Auditor Agent is the final, unyielding line of defense. In children's digital media, quality control is not merely an aesthetic preference—it is a legal and developmental mandate:

• Under the Children's Online Privacy Protection Act (COPPA) and FTC regulations, unintentional inclusion of personal identifiable information (PII), QR codes, or geolocation markers incurs severe regulatory fines and channel termination.
• Under international pediatric broadcast guidelines (ITU-R BT.1702), visual luminance flashing above 3.0 Hz can trigger epileptic seizures in photosensitive children.
• In educational karaoke, subtitle desynchronization beyond 50 milliseconds or acoustic vocal masking disrupts phonetic entrainment, turning an educational sing-along into cognitive noise.

The Quality Auditor Agent acts as an autonomous multimodal inspector and closed-loop repair dispatcher. Rather than simply logging errors, it intercepts flawed episodes and dispatches targeted Repair Tickets directly to failing upstream agents (re-cueing lyrics to the Music Agent, re-rendering turnarounds to the Visual Asset Agent, or re-mixing audio to the Post-Production Agent) with an automated retry ceiling of 3 to prevent infinite thrashing loops.

flowchart TD
    subgraph Inputs["1. Upstream Handoff"]
        REA["RenderedEpisodeArtifact (Ch 06)\n- 60.000s MP4 Master\n- Burned Subtitles & Ducked Audio"]
    end

    subgraph AuditorAgent["2. Quality Auditor & COPPA Gatekeeper"]
        CPV["COPPA & Visual Safety Linter\n- Zero PII, QR Codes, Real Faces\n- Negative Lexicon Verification"]
        STR["Anti-Seizure Luminance Analyzer\n- ITU-R BT.1702 Strobe Linter\n- Max Flash <= 3.0 Hz"]
        ACU["Acoustic Loudness & Mix Inspector\n- EBU R128: -15.5 to -12.5 LUFS\n- True Peak <= -1.0 dBFS"]
        PHS["Subtitle-Vocal Phase Linter\n- Max Phase Delta <= 50ms\n- Syllable Velocity <= 2.0 syl/sec"]
        DIS["Closed-Loop Repair Dispatcher\n- Max Retries: 3\n- Generates Targeted Agent Tickets"]
    end

    subgraph Outputs["3. Branching Decisions"]
        APR["APPROVED: CertifiedProductionRelease\n-> Handoff to Ch 08 Publishing Engine"]
        REJ["REJECTED: Repair Tickets\n-> Routed to Failing Upstream Agents"]
        FTL["FATAL: Quota / Retries Breached\n-> Quarantine & Human Incident Flag"]
    end

    REA --> CPV
    REA --> STR
    REA --> ACU
    REA --> PHS
    CPV --> DIS
    STR --> DIS
    ACU --> DIS
    PHS --> DIS
    DIS -->|All Passed| APR
    DIS -->|Retry < 3| REJ
    DIS -->|Retry >= 3| FTL

Gate 1: Zero Fluff & Agentic Engineering Rigor

1.1 The 6 Production Quality Invariant Dimensions

The Quality Auditor executes automated assertions across 6 deterministic quality dimensions:

1.2 The Closed-Loop Repair State Machine

To prevent the studio from falling into infinite rejection loops (e.g., an agent repeatedly fixing one error while introducing another), the Quality Auditor enforces a bounded state machine: $$\text{State}(E) = \begin{cases} \text{APPROVED} & \text{if } \sum_{i=1}^6 \text{Failures}i = 0 \ \text{REJECTED} & \text{if } \sum{i=1}^6 \text{Failures}_i > 0 \land \text{Retries} < 3 \ \text{FATAL_FAILURE} & \text{if } \text{Retries} \ge 3 \end{cases}$$

When an episode is rejected, the auditor generates a typed RepairTicket specifying the exact failing metric, observed numerical value, expected threshold, and targeted agent role.

Gate 2: Mandatory Naive vs. Production Contrasts

Gate 3: Latest Google Model Configurations & Schemas

3.1 Gemini 2.5 Pro Multimodal Vision QA Configuration

VISION_QA_GEMINI_CONFIG = {
    "model": "gemini-2.5-pro",
    "generation_config": {
        "temperature": 0.1,          # Minimal temperature ensures deterministic QA auditing
        "top_p": 0.90,
        "max_output_tokens": 1024,
        "response_mime_type": "application/json"
    },
    "system_instruction": (
        "You are the Studio Quality Auditor & COPPA Compliance Gatekeeper. "
        "Your task is to inspect rendered frames from a children's educational sing-along video. "
        "Strictly evaluate: "
        "1. COPPA: Zero real human faces, zero brand logos, zero QR codes, zero PII. "
        "2. Mascot Invariant: Character must be Barnaby Bunny with buttercup yellow fur and turquoise overalls. "
        "3. Safety: Zero scary teeth, claws, or threatening visual elements. "
        "Return structured JSON adhering to the QualityCheckResult schema."
    )
}

3.2 Quality Audit Report Schema

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "title": "QualityAuditReport",
  "type": "object",
  "required": ["episode_id", "overall_status", "total_checks", "passed_checks", "failed_checks", "results", "repair_tickets"],
  "properties": {
    "episode_id": { "type": "string" },
    "overall_status": { "type": "string", "enum": ["APPROVED", "REJECTED_REPAIR_REQUIRED", "FATAL_FAILURE"] },
    "total_checks": { "type": "integer" },
    "passed_checks": { "type": "integer" },
    "failed_checks": { "type": "integer" },
    "results": {
      "type": "array",
      "items": {
        "type": "object",
        "required": ["check_name", "passed", "score", "observed_value", "expected_range"],
        "properties": {
          "check_name": { "type": "string" },
          "passed": { "type": "boolean" },
          "score": { "type": "number" },
          "observed_value": { "type": "string" },
          "expected_range": { "type": "string" },
          "error_message": { "type": "string" },
          "target_repair_agent": { "type": "string" }
        }
      }
    },
    "repair_tickets": {
      "type": "array",
      "items": {
        "type": "object",
        "required": ["ticket_id", "target_agent", "failed_check", "required_fix", "retry_count"]
      }
    }
  }
}

Gate 4: Quantitative Trade-Off Matrix

Gate 5: The 10 Operational Failure Modes in Studio QA

1. The Infinite Repair Thrashing Loop: Agent fixes audio loudness, which causes subtitle timing to shift, which triggers lyric re-generation in an endless cycle. Defense: Hard retry ceiling of 3; quarantines episode and alerts human producer if $N \ge 3$.
2. COPPA Text OCR Blind Spots: AI video generator hallucinates a real brand name or URL on a background storefront sign. Defense: Gemini 2.5 Pro Vision runs high-resolution OCR specifically searching for text strings outside the approved syllabus vocabulary.
3. Photosensitive Flicker False Negatives: Scene cuts during rhythmic downbeats cause rapid luminance transitions ($> 3\text{ Hz}$) undetected by static image checks. Defense: Dedicated frame difference analyzer computing delta luminance across sliding 1.0-second windows.
4. Vocal Drowning False Passes: Backing track is ducked overall, but a loud acoustic horn transient coincides with a soft consonant, rendering "town" inaudible. Defense: Frequency-domain signal-to-noise ratio (SNR) check asserting vocal dominance in the 1–3 kHz band.
5. Subtitle Misalignment Drift Accumulation: Subtitles start in sync at bar 4 but lag by 250 ms by bar 22 due to frame rate rounding. Defense: Verification checks phase delta at 4 discrete checkpoints across the episode (Verse 1, Verse 2, Verse 3, Outro).
6. Mascot Silhouette Drift False Pass: Model renders Barnaby Bunny in purple overalls instead of turquoise overalls, but since the bunny has long ears, basic classifiers pass it. Defense: Strict color-histogram assertion verifying turquoise hex #00CCCC presence on bib region.
7. Token Budget Exhaustion during QA: Feeding raw 4K uncompressed video frames into multimodal vision models blows past agent token limits. Defense: Extract lightweight 1080p JPEG keyframes sampled at exactly 1 frame per musical bar.
8. Stale Asset Reference Deadlocks: Quality Auditor rejects an episode, but upstream agents read cached outputs from disk, re-submitting the identical flawed video. Defense: Enforce cryptographic content-hash invalidation on all rejected artifacts.
9. Over-Lenient Heuristic Relaxation: Engineering teams loosen thresholds to hit delivery deadlines, allowing distorted audio onto YouTube Kids. Defense: Quality gates are hard-coded invariants in git version control, requiring explicit peer sign-off to modify.
10. Schema Invalidation during Repair Handoff: Auditor issues a repair ticket with missing fields, crashing the receiving agent's state machine. Defense: Repair tickets validated against strict JSON schema before dispatch.

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

Lab Objective

In this hands-on lab, you will build and test the complete Studio Quality Auditor Engine (StudioQualityAuditorEngine).

Your engine must:

1. Ingest rendered episode metadata manifests.
2. Execute 6 automated quality assertions:
   • Visual COPPA & Safety (zero forbidden tokens: real skin, sharp teeth, brand logos, QR codes).
   • Visual Strobe Safety ($\le 3.0\text{ Hz}$ luminance flicker).
   • Integrated Loudness ($-15.5$ to $-12.5\text{ LUFS}$).
   • True Peak Ceiling ($\le -1.0\text{ dBFS}$).
   • Subtitle-to-Vocal Phase Synchrony ($|\Delta t| \le 50\text{ ms}$).
   • Pedagogical Syllable Velocity ($\le 2.0\text{ syl/sec}$).
3. Pass clean episodes and emit an APPROVED certification report.
4. Catch flawed episodes, reject them with REJECTED_REPAIR_REQUIRED, and compile structured RepairTickets mapped to specific upstream agent roles (VisualAssetAgent, AnimationDirectorAgent, PostProductionAgent, MusicLyricistAgent).
5. Enforce the 3-Retry Ceiling, transitioning to FATAL_FAILURE when retry_count >= 3.
6. Certify 100% compliance through built-in unit test assertions.

Gate 7: Mandatory Recommended Answer & Executable Solution

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

"""
studio_quality_auditor_engine.py
Production Reference Implementation for Playbook 03 Chapter 7:
The Quality Auditor & COPPA Compliance Gatekeeper.

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

@dataclasses.dataclass
class QualityCheckResult:
    check_name: str
    passed: bool
    score: float            # 0.0 to 1.0
    observed_value: Any
    expected_range: str
    error_message: Optional[str] = None
    target_repair_agent: Optional[str] = None

@dataclasses.dataclass
class QualityAuditReport:
    episode_id: str
    overall_status: str     # "APPROVED", "REJECTED_REPAIR_REQUIRED", "FATAL_FAILURE"
    total_checks: int
    passed_checks: int
    failed_checks: int
    results: List[QualityCheckResult]
    repair_tickets: List[Dict[str, Any]]

class StudioQualityAuditorEngine:
    """
    Production Subsystem for Quality Auditor & COPPA Compliance Gatekeeper:
    Executes automated multi-modal assertions across visual safety, COPPA,
    acoustic loudness, subtitle phase synchrony, and mascot consistency.
    Dispatches closed-loop repair tickets to failing upstream agents.
    """

    MAX_REPAIR_RETRIES = 3

    def audit_episode(self, episode_manifest: Dict[str, Any], retry_count: int = 0) -> QualityAuditReport:
        """Runs the complete 6-dimension quality audit suite on a rendered episode."""
        results: List[QualityCheckResult] = []

        # 1. COPPA & Visual Safety Audit
        coppa_violations = []
        forbidden_visual_tokens = ["real skin", "sharp teeth", "claws", "brand logo", "child face photo", "qr code"]
        visual_prompt = episode_manifest.get("visual_prompt", "").lower()
        for token in forbidden_visual_tokens:
            if token in visual_prompt:
                coppa_violations.append(token)
        
        results.append(QualityCheckResult(
            check_name="coppa_visual_safety",
            passed=len(coppa_violations) == 0,
            score=1.0 if not coppa_violations else 0.0,
            observed_value=f"Violations detected: {coppa_violations}" if coppa_violations else "Zero safety violations",
            expected_range="Zero forbidden tokens",
            error_message=f"COPPA violation: prompt contains {coppa_violations}" if coppa_violations else None,
            target_repair_agent="VisualAssetAgent" if coppa_violations else None
        ))

        # 2. Visual Strobe Frequency Audit (Anti-Seizure)
        strobe_hz = episode_manifest.get("max_strobe_hz", 0.0)
        strobe_pass = strobe_hz <= 3.0
        results.append(QualityCheckResult(
            check_name="visual_strobe_safety",
            passed=strobe_pass,
            score=1.0 if strobe_pass else 0.0,
            observed_value=f"{strobe_hz} Hz",
            expected_range="<= 3.0 Hz",
            error_message="Luminance flicker exceeds 3 Hz safety limit" if not strobe_pass else None,
            target_repair_agent="AnimationDirectorAgent" if not strobe_pass else None
        ))

        # 3. Acoustic Loudness Audit (EBU R128)
        lufs = episode_manifest.get("integrated_lufs", -14.0)
        lufs_pass = -15.5 <= lufs <= -12.5
        results.append(QualityCheckResult(
            check_name="audio_integrated_lufs",
            passed=lufs_pass,
            score=1.0 if lufs_pass else 0.0,
            observed_value=f"{lufs:.1f} LUFS",
            expected_range="-15.5 to -12.5 LUFS",
            error_message=f"Integrated loudness {lufs:.1f} LUFS outside broadcast tolerance" if not lufs_pass else None,
            target_repair_agent="PostProductionAgent" if not lufs_pass else None
        ))

        # 4. True Peak Audit
        true_peak = episode_manifest.get("true_peak_db", -1.5)
        tp_pass = true_peak <= -1.0
        results.append(QualityCheckResult(
            check_name="audio_true_peak",
            passed=tp_pass,
            score=1.0 if tp_pass else 0.0,
            observed_value=f"{true_peak:.1f} dBFS",
            expected_range="<= -1.0 dBFS",
            error_message=f"True Peak {true_peak:.1f} dBFS exceeds ceiling" if not tp_pass else None,
            target_repair_agent="PostProductionAgent" if not tp_pass else None
        ))

        # 5. Subtitle-to-Vocal Phase Synchrony Audit
        max_phase_delta_ms = episode_manifest.get("max_subtitle_phase_delta_ms", 0)
        phase_pass = max_phase_delta_ms <= 50
        results.append(QualityCheckResult(
            check_name="subtitle_vocal_phase_sync",
            passed=phase_pass,
            score=1.0 if phase_pass else max(0.0, 1.0 - (max_phase_delta_ms / 200.0)),
            observed_value=f"{max_phase_delta_ms} ms",
            expected_range="<= 50 ms",
            error_message=f"Subtitle phase drift {max_phase_delta_ms} ms exceeds 50 ms threshold" if not phase_pass else None,
            target_repair_agent="PostProductionAgent" if not phase_pass else None
        ))

        # 6. Syllable Delivery Velocity Audit
        syl_per_sec = episode_manifest.get("syllable_rate", 1.5)
        velocity_pass = syl_per_sec <= 2.0
        results.append(QualityCheckResult(
            check_name="syllable_velocity_pedagogy",
            passed=velocity_pass,
            score=1.0 if velocity_pass else 0.0,
            observed_value=f"{syl_per_sec:.2f} syl/sec",
            expected_range="<= 2.0 syl/sec",
            error_message=f"Syllable rate {syl_per_sec:.2f} exceeds toddler comprehension ceiling (2.0)" if not velocity_pass else None,
            target_repair_agent="MusicLyricistAgent" if not velocity_pass else None
        ))

        # Compile Overall Report & Repair Tickets
        failed = [r for r in results if not r.passed]
        repair_tickets: List[Dict[str, Any]] = []

        if failed:
            if retry_count >= self.MAX_REPAIR_RETRIES:
                overall_status = "FATAL_FAILURE"
            else:
                overall_status = "REJECTED_REPAIR_REQUIRED"
                for f in failed:
                    repair_tickets.append({
                        "ticket_id": f"REP-{episode_manifest.get('episode_id', 'EP')}-{f.check_name.upper()}",
                        "target_agent": f.target_repair_agent,
                        "failed_check": f.check_name,
                        "observed_value": f.observed_value,
                        "required_fix": f.error_message,
                        "retry_count": retry_count + 1
                    })
        else:
            overall_status = "APPROVED"

        return QualityAuditReport(
            episode_id=episode_manifest.get("episode_id", "EP-001"),
            overall_status=overall_status,
            total_checks=len(results),
            passed_checks=len(results) - len(failed),
            failed_checks=len(failed),
            results=results,
            repair_tickets=repair_tickets
        )

# =====================================================================
# Unit Test Assertions Certifying Gate 7 Compliance
# =====================================================================
def run_tests():
    auditor = StudioQualityAuditorEngine()

    # Test Case 1: Pristine Production Episode
    pristine_manifest = {
        "episode_id": "EP-001-BUS",
        "visual_prompt": "Barnaby Bunny chibi toddler in turquoise overalls singing",
        "max_strobe_hz": 1.2,
        "integrated_lufs": -14.0,
        "true_peak_db": -1.5,
        "max_subtitle_phase_delta_ms": 18,
        "syllable_rate": 1.62
    }

    report_pass = auditor.audit_episode(pristine_manifest, retry_count=0)
    assert report_pass.overall_status == "APPROVED", f"Expected APPROVED, got {report_pass.overall_status}"
    assert report_pass.failed_checks == 0
    assert len(report_pass.repair_tickets) == 0

    # Test Case 2: Flawed Episode with 6 Violations
    flawed_manifest = {
        "episode_id": "EP-002-BUS-FLAWED",
        "visual_prompt": "Barnaby Bunny in overalls with sharp teeth and brand logo",
        "max_strobe_hz": 4.5,
        "integrated_lufs": -9.8,
        "true_peak_db": +0.4,
        "max_subtitle_phase_delta_ms": 120,
        "syllable_rate": 2.85
    }

    report_fail = auditor.audit_episode(flawed_manifest, retry_count=0)
    assert report_fail.overall_status == "REJECTED_REPAIR_REQUIRED"
    assert report_fail.failed_checks == 6
    assert len(report_fail.repair_tickets) == 6

    agents_targeted = {t["target_agent"] for t in report_fail.repair_tickets}
    assert "VisualAssetAgent" in agents_targeted
    assert "AnimationDirectorAgent" in agents_targeted
    assert "PostProductionAgent" in agents_targeted
    assert "MusicLyricistAgent" in agents_targeted

    # Test Case 3: Retry Ceiling Breach (Fatal Failure)
    report_fatal = auditor.audit_episode(flawed_manifest, retry_count=3)
    assert report_fatal.overall_status == "FATAL_FAILURE"
    assert len(report_fatal.repair_tickets) == 0

    # Test Case 4: JSON Serialization
    serialized = json.dumps(dataclasses.asdict(report_fail), indent=2)
    assert len(serialized) > 1000
    deserialized = json.loads(serialized)
    assert deserialized["episode_id"] == "EP-002-BUS-FLAWED"
    assert deserialized["failed_checks"] == 6

    print("\n[PASS] All 4 Acceptance Test Suites Passed (100% Gate 7 Compliance)!")
    print(f"Pristine Checks Passed: {report_pass.passed_checks}/{report_pass.total_checks}")
    print(f"Flawed Checks Caught: {report_fail.failed_checks}/{report_fail.total_checks} (Repair Tickets: {len(report_fail.repair_tickets)})")

if __name__ == "__main__":
    run_tests()

Handoff to Downstream Agents

Once the Quality Auditor certifies an episode as APPROVED:

1. The Autonomous Studio Orchestrator & YouTube Kids Publishing Engine (Chapter 8): Ingests the certified MP4 artifact and metadata to construct YouTube Kids compliant title, description, COPPA flags, thumbnail graphics, and packaging.
2. Quarantine Escalation: In the event of a FATAL_FAILURE, the episode is segregated into the quarantine depot and an urgent incident alert is logged to the studio administrative console.