Upload folder using huggingface_hub

README.md

@@ -1,13 +1,88 @@
 ---
 title: MiniMax H3 Prompt Enhancer
-emoji: ⚡
-colorFrom: indigo
-colorTo: red
+emoji: "🎬"
+colorFrom: purple
+colorTo: pink
 sdk: gradio
-sdk_version: 6.22.0
-python_version: '3.12'
+sdk_version: 5.49.1
 app_file: app.py
 pinned: false
+license: other
+short_description: Trained LLM for MiniMax H3 structured video prompts
+tags:
+  - text-generation
+  - video
+  - prompt
+  - minimax
+  - liquid
+  - lfm2
+  - zerogpu
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# MiniMax H3 Prompt Enhancer
+
+**Not another “make my prompt longer” toy.**
+
+This Space runs a **purpose-trained small language model** that rewrites rough ideas into **production-ready MiniMax H3 video prompts** — the same kind of structured audiovisual brief MiniMax expects: shots, camera language, diegetic sound, and score, not a bag of adjectives.
+
+Type something half-formed like *“baker opens a shop at dawn”*. The model doesn’t slap on “cinematic, 8k, masterpiece.” It **reasons** about scene, motion, and audio, then emits the **exact field layout** used for MiniMax video generation.
+
+---
+
+## Why this is different
+
+| Typical prompt “enhancers” | This one |
+|---|---|
+| Templates, regex, or a generic chat model | **Fine-tuned LLM** dedicated to this job |
+| Mood words and hashtag soup | **Shot lists, camera moves, soundscape, music** |
+| Guesswork about “what sounds good” | Aligned to **MiniMax H3 video prompt writing guidelines** |
+| One free-form paragraph | **Structured output** MiniMax can actually consume |
+
+Under the hood: [geocine/minimax-video-prompt-enhancer-350m](https://huggingface.co/geocine/minimax-video-prompt-enhancer-350m) — LoRA SFT on [LiquidAI/LFM2.5-350M](https://huggingface.co/LiquidAI/LFM2.5-350M), trained on teacher rewrites that follow the official MiniMax base/ref prompt schema (T2VA · I2VA · FL2VA · L2VA · full reference).
+
+---
+
+## What you get
+
+Paste a rough idea (and optional reference notes). Choose duration. Hit **Generate**.
+
+You get a full brief, for example:
+
+- **`integrated_multimodal_description`** — style, framing, action, camera, dialogue tags  
+- **`overall_soundscape`** — ambience and physical sound  
+- **`non_diegetic_music`** — audience-only score (or N/A)  
+- For image/video refs: alignment lines, subjects, retention-style structure in **full-reference** mode  
+
+Built for people who actually ship MiniMax clips — not for prompt-cosplay.
+
+---
+
+## How to use
+
+1. Write a rough user prompt (dialogue, shot notes, or a one-liner).  
+2. Optionally fill **References & frames** (first/last frame, subjects, clips, audio). The Space picks the task for you.  
+3. Set duration. Generate. Copy the structured prompt into MiniMax.
+
+**Tip:** Short, real-user prompts work best. The model expands them into the full MiniMax format.
+
+---
+
+## ZeroGPU
+
+Runs on **Hugging Face ZeroGPU** — a GPU spins up only while **Generate** runs.
+
+- Visitors use **their** daily HF GPU quota (or PRO credits if they go over).  
+- You must be **logged in** to use ZeroGPU Spaces.  
+- No permanent GPU rental for idle time.
+
+---
+
+## Model & license
+
+| | |
+|--|--|
+| Model | [geocine/minimax-video-prompt-enhancer-350m](https://huggingface.co/geocine/minimax-video-prompt-enhancer-350m) |
+| Base | [LiquidAI/LFM2.5-350M](https://huggingface.co/LiquidAI/LFM2.5-350M) |
+| License | Liquid **lfm1.0** — read the base card before commercial use |
+
+This is a **text prompt specialist**, not a video generator. It writes the brief; MiniMax (or your pipeline) makes the frames.

app.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+"""Hugging Face ZeroGPU Space — MiniMax Video Prompt Enhancer.
+
+Hosts on free ZeroGPU. Visitors spend *their* daily HF GPU quota / credits
+when they click Generate — the host is not billed for continuous GPU rental.
+
+Model: geocine/minimax-video-prompt-enhancer-350m
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+import spaces
+import torch
+
+from minimax.apps.gradio import build_app
+from minimax.apps.gradio.state import InferenceSession, ModelBundle
+from minimax.modeling.loader import build_stop_ids, load_model_and_tokenizer
+from minimax.paths import DEFAULT_MODEL
+
+MODEL_ID = os.environ.get("MODEL_ID", DEFAULT_MODEL)
+
+# ---------------------------------------------------------------------------
+# ZeroGPU: place the model on `cuda` at module level (emulated until a real
+# GPU is attached inside @spaces.GPU). Visitors pay quota on each Generate.
+# ---------------------------------------------------------------------------
+print(f"Loading {MODEL_ID} onto cuda (ZeroGPU)...", flush=True)
+_model, _tokenizer = load_model_and_tokenizer(MODEL_ID)
+_stop_ids = build_stop_ids(_tokenizer)
+_PRELOADED = ModelBundle(
+    path=MODEL_ID, model=_model, tokenizer=_tokenizer, stop_ids=_stop_ids
+)
+print(f"Ready on device={next(_model.parameters()).device}", flush=True)
+
+_orig_ensure = InferenceSession.ensure_loaded
+_orig_generate = InferenceSession.generate
+
+
+def _ensure_preloaded(self, model_path=None):
+    path = str(model_path or self.default_model)
+    if path in {MODEL_ID, DEFAULT_MODEL, "geocine/minimax-video-prompt-enhancer-350m"}:
+        self._bundle = _PRELOADED
+        return _PRELOADED
+    return _orig_ensure(self, model_path)
+
+
+@spaces.GPU(duration=90)
+def _run_generate(session, kwargs):
+    """GPU-scoped body — real CUDA is available only here on ZeroGPU."""
+    return _orig_generate(session, **kwargs)
+
+
+def _generate_zerogpu(self, **kwargs):
+    return _run_generate(self, kwargs)
+
+
+InferenceSession.ensure_loaded = _ensure_preloaded  # type: ignore[method-assign]
+InferenceSession.generate = _generate_zerogpu  # type: ignore[method-assign]
+
+demo = build_app(model_path=MODEL_ID)
+
+if __name__ == "__main__":
+    demo.queue(default_concurrency_limit=1)
+    demo.launch()

minimax/__init__.py

@@ -0,0 +1,3 @@
+"""MiniMax video-prompt enhancer pipeline (student: LiquidAI/LFM2.5-350M)."""
+
+__all__ = ["paths"]

minimax/apps/__init__.py

@@ -0,0 +1 @@
+"""Interactive apps (Gradio, etc.) built on the inference stack."""

minimax/apps/gradio/__init__.py

@@ -0,0 +1,5 @@
+"""Gradio UI for interactive champion testing."""
+
+from .ui import build_app, launch
+
+__all__ = ["build_app", "launch"]

minimax/apps/gradio/demos.py

@@ -0,0 +1,76 @@
+"""Starter examples for the Gradio app."""
+
+from __future__ import annotations
+
+from minimax.formatting.envelope import BASE_TASKS, REF_TASKS
+
+TASK_CHOICES = sorted(BASE_TASKS) + sorted(REF_TASKS)
+
+# (task, duration, prompt, assets_text) — assets one per line
+EXAMPLES: list[list] = [
+    [
+        "T2VA",
+        6.0,
+        (
+            "A baker opens a small street bakery at dawn, places a loaf on the counter, "
+            'and says "First batch of the morning." Cinematic, two shots.'
+        ),
+        "",
+    ],
+    [
+        "I2VA",
+        6.0,
+        (
+            "Continue from the first frame: she looks up from a letter at the rain-covered "
+            'train window and quietly says "I get off at the next station."'
+        ),
+        "Picture 1: first frame — young woman in a dark coat by a rain train window at night, folded letter",
+    ],
+    [
+        "FL2VA",
+        8.0,
+        (
+            "Shot 1: a cyclist rolls through morning fog on a riverside path. "
+            "Shot 2: she stops at a bridge and watches the mist lift. Soft documentary feel."
+        ),
+        "Picture 1: first frame — cyclist entering fog\nPicture 2: last frame — bridge overlook, mist clearing",
+    ],
+    [
+        "reference_generation",
+        8.0,
+        "a man in a spider-themed suit walking through fire",
+        (
+            "Picture 1: subject/scene reference — man in red-and-blue spider-themed suit\n"
+            "Picture 2: environment / secondary look reference — corridor of practical fire"
+        ),
+    ],
+    [
+        "keyframe_completion",
+        8.0,
+        "a fantastic steam train on a street painted in oil",
+        "Picture 1: keyframe anchor for: a fantastic steam train on a street painted in oil",
+    ],
+    [
+        "video_editing",
+        8.0,
+        (
+            "Reference the coffee shop and the blonde woman; a man walks in with a Samoyed "
+            'that lunges at her cookie. She says "Hey! Watch your dog!" Sitcom, multi-shot.'
+        ),
+        (
+            "Picture 1: coffee-shop interior — brick wall, orange sofa, neon sign\n"
+            "Video 1: young blonde woman in light-pink shirt\n"
+            "Video 2: young man in dark-grey hoodie\n"
+            "Picture 2: fluffy white Samoyed"
+        ),
+    ],
+    [
+        "video_continuation+audio_reference",
+        8.0,
+        "panoramic golden sand beach, blue tides, palms, sunset, seabirds",
+        (
+            "Video 1: source ending to continue — panoramic golden sand beach at sunset\n"
+            "Audio 1: audio continuity reference (not 1:1 copy)"
+        ),
+    ],
+]

minimax/apps/gradio/derive.py

@@ -0,0 +1,141 @@
+"""Deterministic task derivation from role-tagged inputs.
+
+The user never picks a cryptic task code (T2VA / reference_generation / …).
+Instead they fill the *role* slots that describe what they actually have — a
+first frame, a clip to continue, subject references, and so on — and the task
+label falls out of which slots are populated.
+
+Intent that isn't recoverable from the inputs (continue-vs-edit a lone clip,
+what a single image *means*) is resolved by precedence + sensible defaults, so
+the common cases need zero explicit choices. The derived label is surfaced back
+to the UI so the mapping stays transparent.
+
+Asset lines are emitted in the exact phrasing the champion trained on (verified
+against data/train/train.jsonl), because the model conditions on both the task
+label and the asset wording.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+# MiniMax H3 Ref2VA media caps (mirrors D:/PL/MiniMaxUI REF_LIMITS).
+REF_LIMITS = {"image": 9, "video": 2, "audio": 2, "total": 12}
+# Duration bounds (seconds) for the H3 checkpoint.
+DURATION = {"min": 5, "max": 15, "default": 5, "step": 1}
+# Max characters for the rough user prompt (matches the enhance input schema).
+PROMPT_MAX = 7000
+
+
+@dataclass
+class Derivation:
+    task: str
+    assets: list[str]
+    warnings: list[str] = field(default_factory=list)
+
+    @property
+    def assets_text(self) -> str:
+        return "\n".join(self.assets)
+
+
+def _clean(value: str | None) -> str:
+    return (value or "").strip()
+
+
+def _lines(value: str | None) -> list[str]:
+    return [ln.strip() for ln in _clean(value).splitlines() if ln.strip()]
+
+
+def derive(
+    *,
+    first_frame: str | None = None,
+    last_frame: str | None = None,
+    subject_refs: str | None = None,
+    keyframe: str | None = None,
+    continue_video: str | None = None,
+    edit_footage: str | None = None,
+    audio_ref: str | None = None,
+) -> Derivation:
+    """Map role slots to a (task, assets) pair.
+
+    Precedence (most specific first): continue → edit → subject refs → keyframe
+    → first+last → first → last → text-only. Audio only forms a ``+audio``
+    variant for the three ref tasks that have one.
+    """
+    first, last = _clean(first_frame), _clean(last_frame)
+    keyframe = _clean(keyframe)
+    continue_video = _clean(continue_video)
+    subjects, edits, audios = _lines(subject_refs), _lines(edit_footage), _lines(audio_ref)
+    audio_on = bool(audios)
+
+    assets: list[str] = []
+    counts = {"Picture": 0, "Video": 0, "Audio": 0}
+
+    def tag(kind: str) -> str:
+        counts[kind] += 1
+        return f"{kind} {counts[kind]}"
+
+    def add(kind: str, body: str) -> None:
+        assets.append(f"{tag(kind)}: {body}")
+
+    def audio_lines(reuse: bool) -> None:
+        for a in audios:
+            if reuse:
+                body = f"synchronized audio track of {a}"
+            else:
+                body = f"audio continuity reference (not 1:1 copy) — {a}"
+            add("Audio", body)
+
+    if continue_video:
+        add("Video", f"source ending to continue — {continue_video}")
+        if audio_on:
+            audio_lines(reuse=False)
+            task = "video_continuation+audio_reference"
+        else:
+            task = "video_continuation"
+    elif edits:
+        for clip in edits:
+            add("Video", f"source clip to edit — {clip}")
+        if audio_on:
+            audio_lines(reuse=True)
+            task = "video_editing+audio_reuse"
+        else:
+            task = "video_editing"
+    elif subjects:
+        for i, ref in enumerate(subjects):
+            role = "subject/scene reference" if i == 0 else "environment / secondary look reference"
+            add("Picture", f"{role} — {ref}")
+        if audio_on:
+            audio_lines(reuse=False)
+            task = "reference_generation+audio_reference"
+        else:
+            task = "reference_generation"
+    elif keyframe:
+        add("Picture", f"keyframe anchor for: {keyframe}")
+        task = "keyframe_completion"
+    elif first and last:
+        add("Picture", f"first frame — start state for: {first}")
+        tail = "last frame — end state after continuous motion"
+        add("Picture", f"{tail} — {last}" if last else tail)
+        task = "FL2VA"
+    elif first:
+        add("Picture", f"first frame — opening composition for: {first}")
+        task = "I2VA"
+    elif last:
+        add("Picture", f"last frame — final composition for: {last}")
+        task = "L2VA"
+    else:
+        task = "T2VA"
+
+    warnings: list[str] = []
+    img, vid, aud = counts["Picture"], counts["Video"], counts["Audio"]
+    if img > REF_LIMITS["image"]:
+        warnings.append(f"{img} images exceeds the {REF_LIMITS['image']}-image limit")
+    if vid > REF_LIMITS["video"]:
+        warnings.append(f"{vid} videos exceeds the {REF_LIMITS['video']}-video limit")
+    if aud > REF_LIMITS["audio"]:
+        warnings.append(f"{aud} audio refs exceeds the {REF_LIMITS['audio']}-audio limit")
+    if img + vid + aud > REF_LIMITS["total"]:
+        warnings.append(f"{img + vid + aud} references exceeds the {REF_LIMITS['total']} total limit")
+
+    return Derivation(task=task, assets=assets, warnings=warnings)

minimax/apps/gradio/state.py

@@ -0,0 +1,167 @@
+"""Lazy model cache for the Gradio app."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from minimax.modeling.generate import generate_one
+from minimax.modeling.loader import build_stop_ids, load_model_and_tokenizer
+from minimax.paths import DEFAULT_MODEL
+
+
+def parse_assets(assets_text: str | None) -> list[str] | None:
+    if not assets_text or not str(assets_text).strip():
+        return None
+    lines = []
+    for line in str(assets_text).splitlines():
+        line = line.strip()
+        if not line or line in {"(none)", "- (none)", "- none"}:
+            continue
+        if line.startswith("- "):
+            line = line[2:].strip()
+        lines.append(line)
+    return lines or None
+
+
+# Human-readable labels for the format-score checks, so users see what each
+# check means (and what's missing) instead of raw internal keys.
+_CHECK_LABELS = {
+    "nonempty": "Output is not empty",
+    "has_shot1": "Has an opening shot ([Shot 1])",
+    "within_h3_char_limit": "Within the 7000-character limit",
+    "no_instruction_leak": "Scene body is not paraphrasing the format rules",
+    "field_order": "Sections are in the required order",
+    "no_heavy_loop": "No duplicated sections",
+    "i2va_instruction": "Starts with the image-to-video alignment line",
+    "fl2va_alignment": "Starts with the first + last-frame alignment line",
+    "l2va_alignment": "Starts with the last-frame alignment line",
+    "has_shot2_optional": "Second shot present (optional)",
+    "shots_have_timestamps": "Later shots carry timestamps",
+    "shot1_no_bogus_timestamp": "Opening shot has no timestamp",
+    "summary_task_prefix": "Summary starts with a task-type tag",
+    "has_reference_label": "Cites at least one reference tag",
+}
+
+
+def _humanize_check(key: str) -> str:
+    if key in _CHECK_LABELS:
+        return _CHECK_LABELS[key]
+    if key.startswith("field:"):
+        name = key[len("field:") :].rstrip(":").replace("_", " ")
+        return f'Has the "{name}" section'
+    return key.replace("_", " ")
+
+
+# Colored inline marks (Markdown can't color text; HTML spans can).
+_OK = '<span style="color:var(--gc-accent);font-weight:700">✓</span>'
+_MISS = '<span style="color:var(--gc-danger);font-weight:700">✗</span>'
+
+
+def format_checks(report: dict) -> str:
+    passed = bool(report.get("pass"))
+    if passed:
+        verdict = '<span style="color:var(--gc-accent);font-weight:700">✓ Looks good</span>'
+    else:
+        verdict = '<span style="color:var(--gc-danger);font-weight:700">⚠ Needs a fix</span>'
+    chars = report.get("char_len", "?")
+    try:
+        score_pct = f"{float(report.get('score')) * 100:.0f}%"
+    except (TypeError, ValueError):
+        score_pct = str(report.get("score"))
+    lines = [f"{verdict}  ·  Score {score_pct}  ·  {chars} / 7000 chars"]
+    checks = report.get("checks") or {}
+    if checks:
+        # optional checks that simply weren't triggered aren't failures — don't
+        # list them under "Needs fixing"
+        missing = [k for k, v in checks.items() if not v and "optional" not in k]
+        ok = [k for k, v in checks.items() if v]
+        lines.append("")
+        if missing:
+            lines.append("**Needs fixing:**")
+            lines += [f"- {_MISS} {_humanize_check(k)}" for k in missing]
+            lines.append("")
+            lines.append("**Passed:**")
+            lines += [f"- {_OK} {_humanize_check(k)}" for k in ok]
+        else:
+            lines.append(f"**All {len(ok)} checks passed:**")
+            lines += [f"- {_OK} {_humanize_check(k)}" for k in ok]
+    notes = report.get("notes") or []
+    if notes:
+        lines.append("")
+        lines.append("**Notes:** " + "; ".join(notes))
+    return "\n".join(lines)
+
+
+@dataclass
+class ModelBundle:
+    path: str
+    model: Any
+    tokenizer: Any
+    stop_ids: list[int]
+
+
+class InferenceSession:
+    """Holds one loaded model; reloads when the path changes."""
+
+    def __init__(self, default_model: str | Path | None = None) -> None:
+        self.default_model = str(default_model or DEFAULT_MODEL)
+        self._bundle: ModelBundle | None = None
+
+    @property
+    def loaded_path(self) -> str | None:
+        return None if self._bundle is None else self._bundle.path
+
+    def ensure_loaded(self, model_path: str | None = None) -> ModelBundle:
+        # Keep Hub repo ids as plain strings (do not Path()-normalize them).
+        raw = model_path or self.default_model
+        path = str(raw)
+        if self._bundle is not None and self._bundle.path == path:
+            return self._bundle
+        model, tokenizer = load_model_and_tokenizer(path)
+        stop_ids = build_stop_ids(tokenizer)
+        self._bundle = ModelBundle(path=path, model=model, tokenizer=tokenizer, stop_ids=stop_ids)
+        return self._bundle
+
+    def generate(
+        self,
+        *,
+        prompt: str,
+        task: str,
+        duration: float,
+        assets_text: str = "",
+        model_path: str | None = None,
+        max_new_tokens: int | None = None,
+        temperature: float = 0.0,
+        top_k: int = 40,
+        repetition_penalty: float = 1.0,
+        seed: int | None = 42,
+        legacy_labels: bool = False,
+    ) -> tuple[str, str]:
+        if not (prompt or "").strip():
+            return "", "Enter a user prompt first."
+
+        import torch
+
+        bundle = self.ensure_loaded(model_path)
+        if seed is not None:
+            torch.manual_seed(int(seed))
+            if torch.cuda.is_available():
+                torch.cuda.manual_seed_all(int(seed))
+
+        text, report = generate_one(
+            bundle.model,
+            bundle.tokenizer,
+            task=task,
+            duration=float(duration),
+            prompt=prompt.strip(),
+            assets=parse_assets(assets_text),
+            stop_ids=bundle.stop_ids,
+            max_new_tokens=max_new_tokens if max_new_tokens and max_new_tokens > 0 else None,
+            temperature=float(temperature),
+            top_k=int(top_k),
+            repetition_penalty=float(repetition_penalty),
+            legacy_labels=bool(legacy_labels),
+        )
+        return text, format_checks(report)

minimax/apps/gradio/ui.py

@@ -0,0 +1,562 @@
+"""Gradio Blocks UI for the MiniMax prompt enhancer."""
+
+from __future__ import annotations
+
+import random
+from pathlib import Path
+
+from minimax.paths import CHAMPION_DIR
+
+from .derive import DURATION, PROMPT_MAX, REF_LIMITS, derive
+from .state import InferenceSession
+
+# Friendly names for the deterministically derived task labels (shown in the
+# live "Detected" badge so the role → task mapping stays transparent).
+_TASK_HUMAN = {
+    "T2VA": "Text → video",
+    "I2VA": "First frame → video",
+    "FL2VA": "First + last frame → video",
+    "L2VA": "Last frame → video",
+    "reference_generation": "Reference-guided generation",
+    "reference_generation+audio_reference": "Reference generation + audio",
+    "keyframe_completion": "Keyframe completion",
+    "video_continuation": "Video continuation",
+    "video_continuation+audio_reference": "Video continuation + audio",
+    "video_editing": "Video editing",
+    "video_editing+audio_reuse": "Video editing + audio",
+}
+
+
+# GEOCINE cockpit skin — dark instrument look, Razer-green accent, sharp panels,
+# mono uppercase labels, grid + glow backdrop. Overrides Gradio's CSS variables
+# (verified against gradio 6.x) plus a few structural hooks.
+_CSS = """
+:root, .gradio-container {
+  --gc-bg:#151a16; --gc-panel:#1b211c; --gc-panel2:#212820; --gc-inset:#161c17;
+  --gc-ink:#e9efe5; --gc-muted:#97a18d; --gc-faint:#6c7666;
+  --gc-line:#2b332a; --gc-line2:#384037;
+  --gc-accent:#6bff4f; --gc-accent-bright:#44d62c; --gc-accent-ink:#06210a;
+  --gc-glow:rgba(68,214,44,.40); --gc-danger:#ef6a52;
+  --gc-mono: ui-monospace,"JetBrains Mono","Cascadia Code",Consolas,monospace;
+
+  --body-background-fill: var(--gc-bg);
+  --body-text-color: var(--gc-ink);
+  --body-text-color-subdued: var(--gc-muted);
+  --background-fill-primary: var(--gc-panel);
+  --background-fill-secondary: var(--gc-panel2);
+  --block-background-fill: var(--gc-panel);
+  --block-border-color: var(--gc-line);
+  --block-label-text-color: var(--gc-faint);
+  --block-title-text-color: var(--gc-faint);
+  --border-color-primary: var(--gc-line);
+  --border-color-accent: var(--gc-accent);
+  --input-background-fill: var(--gc-inset);
+  --input-border-color: var(--gc-line);
+  --input-border-color-focus: var(--gc-accent);
+  --color-accent: var(--gc-accent);
+  --color-accent-soft: color-mix(in srgb, var(--gc-accent-bright) 12%, transparent);
+  --button-primary-background-fill: var(--gc-accent-bright);
+  --button-primary-background-fill-hover: var(--gc-accent);
+  --button-primary-text-color: var(--gc-accent-ink);
+  --button-secondary-background-fill: var(--gc-panel2);
+  --button-secondary-background-fill-hover: var(--gc-panel);
+  --button-secondary-text-color: var(--gc-ink);
+  --button-secondary-border-color: var(--gc-line);
+  --slider-color: var(--gc-accent-bright);
+  --checkbox-background-color-selected: var(--gc-accent-bright);
+  --checkbox-border-color-selected: var(--gc-accent-bright);
+  --radius-xxl:0; --radius-xl:0; --radius-lg:0; --radius-md:0; --radius-sm:0; --radius-xs:0;
+  --block-shadow: none; --input-shadow: none;
+  --layout-gap: 10px; --block-padding: 12px 13px;
+}
+/* reserve the scrollbar gutter so content doesn't shift when a scrollbar
+   appears/disappears (e.g. as the output grows) */
+html { scrollbar-gutter: stable; }
+.gradio-container {
+  width: 100% !important; max-width: 1360px !important; margin: 0 auto !important;
+  padding: 20px clamp(16px,3vw,30px) 26px !important;
+  background:
+    radial-gradient(1200px 600px at 88% -10%, var(--gc-glow), transparent 55%),
+    linear-gradient(color-mix(in srgb, var(--gc-ink) 3%, transparent) 1px, transparent 1px),
+    linear-gradient(90deg, color-mix(in srgb, var(--gc-ink) 3%, transparent) 1px, transparent 1px),
+    var(--gc-bg) !important;
+  background-size: 100% 100%, 38px 38px, 38px 38px, 100% 100% !important;
+}
+/* instrument-style field labels */
+span[data-testid="block-info"], .block-title, label > span:first-child {
+  font-family: var(--gc-mono) !important; font-size:10.5px !important;
+  letter-spacing:.16em !important; text-transform:uppercase !important;
+  color: var(--gc-faint) !important; font-weight:500 !important;
+}
+.info-text { color: var(--gc-muted) !important; }
+/* control panels get the instrument border; text/markdown blocks stay bare */
+.block { border:1px solid var(--gc-line) !important; box-shadow:none !important; }
+.block.hide-container,
+.block:has(> .md), .block:has(> .prose),
+.block:has(> div > .md), .block:has(> div > .prose) {
+  border:0 !important; background:transparent !important; padding:0 !important;
+  overflow:hidden !important;
+}
+/* description: tighter, muted, unboxed */
+.prose { color: var(--gc-muted) !important; font-size:13px !important; line-height:1.5 !important; }
+.prose p { margin:3px 0 !important; }
+.prose strong { color: var(--gc-ink) !important; }
+/* trim default inner form gaps */
+.form { gap:8px !important; }
+.gap { gap:10px !important; }
+/* columns are top-aligned: the output panel's top always lines up with the
+   left column's top, and expanding Decoding grows the left column downward
+   without shoving the right side down. Children keep their natural height
+   (no stretch) so the Generate button never balloons. */
+.gc-main-row { align-items: flex-start !important; }
+.gc-col-left, .gc-col-right { display:flex !important; flex-direction:column !important; }
+/* keep panels at their natural height — the Row's equal-height stretch would
+   otherwise inflate the collapsed accordions to fill the column */
+.gc-col-left > *, .gc-col-right > * { flex: 0 0 auto !important; }
+/* dropdown menu: darker so it reads above the panels behind it */
+ul.options {
+  background:#0f130e !important; border:1px solid var(--gc-line-2) !important;
+  box-shadow:0 16px 34px -14px #000 !important; border-radius:0 !important;
+}
+ul.options li, ul.options .item { color: var(--gc-ink) !important; }
+ul.options li.active, ul.options li.selected,
+ul.options .item.active, ul.options .item.selected {
+  background: color-mix(in srgb, var(--gc-accent-bright) 16%, var(--gc-inset)) !important;
+  color: var(--gc-ink) !important;
+}
+/* derived-task badge inside the References accordion */
+.gc-detected, .gc-detected p {
+  font-family: var(--gc-mono) !important; font-size:11px !important;
+  letter-spacing:.04em !important; color: var(--gc-muted) !important; margin:0 !important;
+}
+.gc-detected code {
+  color: var(--gc-accent) !important;
+  background: color-mix(in srgb, var(--gc-accent) 12%, transparent) !important;
+  border:1px solid color-mix(in srgb, var(--gc-accent) 30%, var(--gc-line)) !important;
+}
+/* inside the Decoding accordion, controls stay borderless — no divider lines
+   or boxes around the sliders and number fields (the accordion keeps its own
+   outer frame from the .block rule above) */
+.gc-decoding .block, .gc-plain .block { border:0 !important; background:transparent !important; }
+/* accordion toggle: replace the plain ▼ glyph with a crisp accent chevron —
+   points right when collapsed, down when open */
+.label-wrap .icon {
+  transform: none !important; font-size: 0 !important;
+  display: inline-flex !important; align-items: center; justify-content: center;
+  width: 14px !important; height: 14px !important;
+}
+.label-wrap .icon::after {
+  content: ''; display: block; width: 7px; height: 7px; margin-top: -2px;
+  border-right: 1.7px solid var(--gc-accent); border-bottom: 1.7px solid var(--gc-accent);
+  transform: rotate(-45deg); transition: transform .2s ease;
+}
+.label-wrap.open .icon::after { transform: rotate(45deg); margin-top: -4px; }
+/* focus: a single accent-green border on every field, dark inside (no gray
+   fill), and no heavy outline/glow — consistent across text, number, dropdown
+   and slider fields */
+:focus, :focus-visible { outline: none !important; }
+/* text/number/dropdown fields only — NOT checkboxes, whose checked green fill
+   and checkmark would otherwise be clobbered by the dark background on focus */
+input:not([type="checkbox"]):focus, textarea:focus, select:focus,
+input:not([type="checkbox"]):focus-visible, textarea:focus-visible {
+  border-color: var(--gc-accent) !important;
+  background: var(--gc-inset) !important;
+  box-shadow: none !important;
+}
+/* checkbox: keep the accent fill on focus, no glow/ring and no blue focus
+   border (Gradio's --checkbox-border-color-focus) */
+input[type="checkbox"]:focus, input[type="checkbox"]:focus-visible {
+  outline: none !important; box-shadow: none !important;
+  border-color: var(--gc-line) !important;
+}
+input[type="checkbox"]:checked,
+input[type="checkbox"]:checked:focus,
+input[type="checkbox"]:checked:focus-visible {
+  background-color: var(--gc-accent-bright) !important;
+  border-color: var(--gc-accent-bright) !important;
+}
+.wrap:focus-within, .secondary-wrap:focus-within,
+.tab-like-container:focus-within, .label-wrap:focus-within {
+  border-color: var(--gc-accent) !important; box-shadow: none !important;
+}
+/* number fields (Max new tokens / Seed): border on the input, not the wrapper,
+   so they match the text fields instead of showing a hollow double box */
+label.block.container:has(> input[type="number"]) {
+  border:0 !important; background:transparent !important; padding:0 !important;
+  display:flex !important; flex-direction:column !important; gap:6px !important;
+}
+input[type="number"] {
+  border:1px solid var(--gc-line) !important; background: var(--gc-inset) !important;
+  min-height:38px !important; width:100% !important;
+  font-family: var(--gc-mono) !important;
+  -moz-appearance: textfield !important; appearance: textfield !important;
+}
+/* disabled number field (Seed while "Randomize seed" owns it): make the greyed-out
+   state unmistakable so toggling the checkbox reads as doing something */
+input[type="number"]:disabled {
+  opacity:0.4 !important; cursor:not-allowed !important;
+  color: var(--gc-muted, #7a7a7a) !important;
+}
+/* strip the native up/down spinner arrows (display:none is the reliable fix —
+   appearance:none alone still renders them in current Chrome) */
+input[type="number"]::-webkit-inner-spin-button,
+input[type="number"]::-webkit-outer-spin-button {
+  -webkit-appearance: none !important; appearance: none !important;
+  display: none !important; width: 0 !important; height: 0 !important; margin: 0 !important;
+}
+/* slider value box: one frame on the container, borderless mono input, and a
+   reset button that spans the full height with a divider (no nested double box) */
+.tab-like-container {
+  border:1px solid var(--gc-line) !important; background: var(--gc-inset) !important;
+  overflow:hidden !important; align-items:stretch !important;
+}
+/* fixed input width so all three slider value boxes match (Gradio otherwise
+   auto-sizes each to its own min/max/step); 84px keeps the original width */
+.tab-like-container input[type="number"] {
+  border:0 !important; background:transparent !important; min-height:24px !important;
+  width:84px !important; flex:0 0 84px !important; min-width:84px !important;
+}
+.tab-like-container button {
+  border:0 !important; border-left:1px solid var(--gc-line) !important;
+  background:transparent !important; color: var(--gc-faint) !important;
+  height:auto !important; align-self:stretch !important;
+}
+.tab-like-container button:hover {
+  color: var(--gc-accent) !important;
+  background: color-mix(in srgb, var(--gc-accent-bright) 10%, transparent) !important;
+}
+/* notched, glowing Generate button */
+button.primary {
+  font-family: var(--gc-mono) !important; font-weight:700 !important;
+  text-transform:uppercase !important; letter-spacing:.08em !important;
+  clip-path: polygon(10px 0,100% 0,100% calc(100% - 10px),calc(100% - 10px) 100%,0 100%,0 10px) !important;
+  box-shadow: 0 6px 24px -10px var(--gc-glow) !important; border:0 !important;
+}
+/* hover brightens the fill; keep the dark ink text so it stays readable
+   (white-on-bright-green was invisible) */
+button.primary:hover { color: var(--gc-accent-ink) !important; }
+button.secondary {
+  font-family: var(--gc-mono) !important; text-transform:uppercase !important;
+  letter-spacing:.06em !important; font-size:12px !important;
+  border:1px solid var(--gc-line) !important;
+}
+.prose code {
+  color: var(--gc-accent) !important;
+  background: color-mix(in srgb,var(--gc-accent) 12%, transparent) !important;
+  border:1px solid color-mix(in srgb,var(--gc-accent) 30%, var(--gc-line)) !important;
+  border-radius:0 !important;
+}
+textarea:focus, input:not([type="checkbox"]):focus {
+  box-shadow: 0 0 0 3px var(--gc-glow) !important; border-color: var(--gc-accent) !important;
+}
+table thead th {
+  font-family: var(--gc-mono) !important; text-transform:uppercase !important;
+  letter-spacing:.06em !important; color: var(--gc-faint) !important;
+}
+/* cockpit brand bar */
+.gc-brandbar { padding: 2px 0 6px; }
+.gc-brand { display:flex; align-items:center; gap:12px; }
+.gc-mark {
+  width:36px; height:36px; display:grid; place-items:center;
+  font-family: var(--gc-mono); font-weight:800; font-size:21px; line-height:1;
+  border:1px solid color-mix(in srgb, var(--gc-accent) 55%, var(--gc-line));
+  background: color-mix(in srgb, var(--gc-accent-bright) 12%, transparent);
+  color: var(--gc-accent); box-shadow: 0 0 24px -8px var(--gc-glow);
+}
+.gc-word {
+  font-family: var(--gc-mono); font-size:17px; font-weight:700; letter-spacing:.06em;
+  color: var(--gc-ink); display:flex; align-items:baseline; gap:10px; line-height:1;
+}
+.gc-word span { font-size:9px; font-weight:500; letter-spacing:.28em; color: var(--gc-accent); }
+.gc-sub {
+  margin-top:5px; font-family: var(--gc-mono); font-size:9.5px; letter-spacing:.12em;
+  text-transform:uppercase; color: var(--gc-faint);
+}
+/* GEOCINE attribution appended to Gradio's footer (see _HEAD) — the text stays
+   solid green and pulses a soft glow so it reads as a live, clickable credit */
+footer .gc-built {
+  font-family: var(--gc-mono) !important; font-size:12px; letter-spacing:.06em;
+  text-decoration:none; margin-left:8px; align-self:center; white-space:nowrap;
+  color: var(--gc-accent) !important; -webkit-text-fill-color: var(--gc-accent) !important;
+  animation: gc-shimmer 2.2s ease-in-out infinite;
+}
+footer .gc-built:hover { text-decoration:underline; }
+@keyframes gc-shimmer {
+  0%, 100% { color: var(--gc-accent); -webkit-text-fill-color: var(--gc-accent); text-shadow: none; }
+  50% { color: #dcffd2; -webkit-text-fill-color: #dcffd2; text-shadow: 0 0 10px var(--gc-glow); }
+}
+@media (prefers-reduced-motion: reduce) { footer .gc-built { animation: none; } }
+"""
+
+# Injected into <head>: appends a clickable "Built by GEOCINE" link to Gradio's
+# own footer once it mounts (a CSS ::after can't be a link).
+_HEAD = """
+<script>
+(function () {
+  function addLink() {
+    var f = document.querySelector('footer');
+    if (!f) return false;
+    if (f.querySelector('.gc-built')) return true;
+    var a = document.createElement('a');
+    a.className = 'gc-built';
+    a.href = 'https://x.com/aivandroid';
+    a.target = '_blank';
+    a.rel = 'noopener noreferrer';
+    a.textContent = '\\u00B7 Built by GEOCINE';
+    f.appendChild(a);
+    return true;
+  }
+  if (!addLink()) {
+    var obs = new MutationObserver(function () { if (addLink()) obs.disconnect(); });
+    obs.observe(document.documentElement, { childList: true, subtree: true });
+    setTimeout(function () { obs.disconnect(); }, 15000);
+  }
+})();
+</script>
+"""
+
+_BRAND_HTML = """
+<div class="gc-brandbar">
+  <div class="gc-brand">
+    <div class="gc-mark">G</div>
+    <div>
+      <div class="gc-word">MINIMAX H3 <span>PROMPT ENHANCER</span></div>
+      <div class="gc-sub">Turn rough ideas into cinematic video prompts</div>
+    </div>
+  </div>
+</div>
+"""
+
+
+def build_app(*, model_path: str | Path | None = None):
+    import gradio as gr
+
+    session = InferenceSession(default_model=model_path or CHAMPION_DIR)
+    default_model = str(session.default_model)
+
+    theme = gr.themes.Base(
+        font=["system-ui", "-apple-system", "Segoe UI", "Roboto", "sans-serif"],
+        font_mono=["ui-monospace", "JetBrains Mono", "Cascadia Code", "Consolas", "monospace"],
+    )
+
+    with gr.Blocks(title="MiniMax H3 Prompt Enhancer", theme=theme, css=_CSS, head=_HEAD) as demo:
+        gr.HTML(_BRAND_HTML)
+        gr.Markdown(
+            """
+**Not a template expander** — a **trained LLM** that writes **MiniMax H3–style**
+video prompts: shots, camera, soundscape, and score, following the official
+structured format (not “cinematic 8k masterpiece” fluff).
+
+Drop a rough idea (and optional references), set duration, hit **Generate**.
+"""
+        )
+
+        with gr.Row(equal_height=True):
+            with gr.Column(scale=1, elem_classes=["gc-col-left"]):
+                with gr.Accordion("Prompt", open=True, elem_classes=["gc-plain"]):
+                    duration = gr.Slider(
+                        DURATION["min"], DURATION["max"], value=DURATION["default"], step=DURATION["step"],
+                        label="Duration (seconds)",
+                    )
+                    prompt = gr.Textbox(
+                        label="User prompt",
+                        lines=6,
+                        max_length=PROMPT_MAX,
+                        placeholder="Rough idea, dialogue, shot notes…",
+                    )
+                # Role slots — the task is derived from which of these are filled,
+                # so the user never picks a task code. Empty → plain text-to-video.
+                # Counts are capped to the H3 Ref2VA media limits (≤9 images,
+                # ≤2 videos, ≤2 audio, ≤12 total).
+                with gr.Accordion("References & frames · optional", open=False, elem_classes=["gc-decoding"]):
+                    detected = gr.Markdown(
+                        "**Detected:** Text → video · `T2VA`", elem_classes=["gc-detected"]
+                    )
+                    first_frame = gr.Textbox(
+                        label="First frame",
+                        placeholder="young woman by a rainy train window at night",
+                    )
+                    last_frame = gr.Textbox(
+                        label="Last frame",
+                        placeholder="cyclist paused at a stone bridge, mist clearing (optional)",
+                    )
+                    subject_refs = gr.Textbox(
+                        label="Subject / look references",
+                        lines=3,
+                        info=f"A subject or look kept across the video — one per line, up to {REF_LIMITS['image']} images.",
+                        placeholder=(
+                            "man in a red-and-blue spider-themed suit\n"
+                            "woman with a silver bob and a leather jacket\n"
+                            "rain-slick neon alley at night\n"
+                            "…"
+                        ),
+                    )
+                    keyframe = gr.Textbox(
+                        label="Keyframe to hit",
+                        placeholder="a steam train on an oil-painted cobblestone street",
+                    )
+                    continue_video = gr.Textbox(
+                        label="Video to continue",
+                        placeholder="panoramic golden beach at sunset, calm blue tide",
+                    )
+                    edit_footage = gr.Textbox(
+                        label="Footage to edit",
+                        lines=2,
+                        info=f"Clips / scene elements to edit — one per line, up to {REF_LIMITS['video']} clips.",
+                        placeholder=(
+                            "coffee-shop interior — brick wall, orange sofa, neon sign\n"
+                            "young man in a dark-grey hoodie with a Samoyed"
+                        ),
+                    )
+                    audio_ref = gr.Textbox(
+                        label="Audio reference",
+                        lines=2,
+                        info=f"Sound or voice to match — adds audio, one per line, up to {REF_LIMITS['audio']}.",
+                        placeholder=(
+                            "gentle waves and wind continuity (not a 1:1 copy)\n"
+                            "distant seabird calls"
+                        ),
+                    )
+                with gr.Accordion("Decoding", open=False, elem_classes=["gc-decoding"]):
+                    temperature = gr.Slider(0.0, 1.2, value=0.0, step=0.05, label="Temperature (0 = greedy)")
+                    top_k = gr.Slider(0, 100, value=40, step=1, label="Top-k (sampling only)")
+                    repetition_penalty = gr.Slider(
+                        1.0, 1.5, value=1.0, step=0.01, label="Repetition penalty"
+                    )
+                    max_new_tokens = gr.Number(
+                        value=0,
+                        precision=0,
+                        label="Max new tokens (0 = task default)",
+                    )
+                    # Created interactive so Gradio renders a real editable input;
+                    # the initial disabled state (randomize defaults on) is applied
+                    # via demo.load below. A component born interactive=False cannot
+                    # be reliably re-enabled at runtime.
+                    seed = gr.Number(value=42, precision=0, label="Seed")
+                    randomize_seed = gr.Checkbox(
+                        value=True,
+                        label="Randomize seed each run",
+                    )
+
+            with gr.Column(scale=1, elem_classes=["gc-col-right"]):
+                with gr.Accordion("Enhanced prompt", open=True, elem_classes=["gc-plain"]):
+                    output = gr.Textbox(
+                        label="Enhanced prompt",
+                        show_label=False,
+                        lines=20,
+                        interactive=True,
+                        elem_id="gc-output",
+                    )
+                generate_btn = gr.Button("Generate", variant="primary")
+                report = gr.Markdown(label="Format score")
+
+        role_inputs = [
+            first_frame, last_frame, subject_refs, keyframe,
+            continue_video, edit_footage, audio_ref,
+        ]
+
+        def _derive_from(first_v, last_v, subj_v, key_v, cont_v, edit_v, audio_v):
+            return derive(
+                first_frame=first_v,
+                last_frame=last_v,
+                subject_refs=subj_v,
+                keyframe=key_v,
+                continue_video=cont_v,
+                edit_footage=edit_v,
+                audio_ref=audio_v,
+            )
+
+        def _detect(first_v, last_v, subj_v, key_v, cont_v, edit_v, audio_v):
+            d = _derive_from(first_v, last_v, subj_v, key_v, cont_v, edit_v, audio_v)
+            human = _TASK_HUMAN.get(d.task, d.task)
+            line = f"**Detected:** {human} · `{d.task}`"
+            if d.warnings:
+                line += "  \n⚠ " + "; ".join(d.warnings)
+            return line
+
+        # Live badge: recompute the derived task whenever any role slot changes.
+        for field in role_inputs:
+            field.change(_detect, inputs=role_inputs, outputs=detected)
+
+        def _generate(
+            duration_v, prompt_v,
+            first_v, last_v, subj_v, key_v, cont_v, edit_v, audio_v,
+            temperature_v, top_k_v, rep_v, max_tok_v, seed_v, randomize_v,
+        ):
+            # When randomization is on, draw a fresh seed per run and surface it
+            # back to the Seed field so the exact run stays reproducible.
+            if randomize_v:
+                seed_v = random.randint(0, 2**31 - 1)
+            used_seed = int(seed_v) if seed_v is not None else None
+            d = _derive_from(first_v, last_v, subj_v, key_v, cont_v, edit_v, audio_v)
+            text, checks = session.generate(
+                prompt=prompt_v or "",
+                task=d.task,
+                duration=float(duration_v),
+                assets_text=d.assets_text,
+                model_path=default_model,
+                max_new_tokens=int(max_tok_v) if max_tok_v else None,
+                temperature=float(temperature_v),
+                top_k=int(top_k_v),
+                repetition_penalty=float(rep_v),
+                seed=used_seed,
+            )
+            return text, checks, used_seed
+
+        # Grey out the Seed field while randomization owns it; re-enable for
+        # manual entry when the checkbox is cleared.
+        def _toggle_seed(on):
+            return gr.update(interactive=not on)
+
+        randomize_seed.change(_toggle_seed, inputs=randomize_seed, outputs=seed)
+        # Apply the initial disabled state (checkbox defaults on) after render.
+        demo.load(_toggle_seed, inputs=randomize_seed, outputs=seed)
+
+        generate_btn.click(
+            _generate,
+            inputs=[
+                duration, prompt,
+                *role_inputs,
+                temperature, top_k, repetition_penalty, max_new_tokens, seed,
+                randomize_seed,
+            ],
+            outputs=[output, report, seed],
+        )
+
+        demo.queue(default_concurrency_limit=1)
+    demo._minimax_session = session  # type: ignore[attr-defined]
+    return demo
+
+
+def launch(
+    *,
+    model_path: str | Path | None = None,
+    host: str = "127.0.0.1",
+    port: int = 7860,
+    share: bool = False,
+    require_gpu: bool = True,
+):
+    import torch
+
+    if require_gpu and not torch.cuda.is_available():
+        raise SystemExit(
+            "CUDA is not available — refusing to launch Gradio on CPU. "
+            "Use the minimax-lfm env with a GPU, or pass require_gpu=False."
+        )
+    if torch.cuda.is_available():
+        print(
+            f"GPU: {torch.cuda.get_device_name(0)}  (cuda:{torch.cuda.current_device()})",
+            flush=True,
+        )
+    else:
+        print("GPU: none (CPU)", flush=True)
+
+    demo = build_app(model_path=model_path)
+    session: InferenceSession = demo._minimax_session  # type: ignore[attr-defined]
+    bundle = session.ensure_loaded()
+    device = next(bundle.model.parameters()).device
+    print(f"Model loaded: {bundle.path}  device={device}", flush=True)
+    if require_gpu and device.type != "cuda":
+        raise SystemExit(f"Model landed on {device}, expected CUDA.")
+
+    demo.launch(server_name=host, server_port=port, share=share)

minimax/formatting/__init__.py

@@ -0,0 +1,9 @@
+from .envelope import (  # noqa: F401
+    BASE_TASKS,
+    REF_TASKS,
+    build_user_message,
+    load_system,
+    parse_user_blob,
+    task_label,
+)
+from .postprocess import postprocess_generation  # noqa: F401

minimax/formatting/envelope.py

@@ -0,0 +1,122 @@
+"""User/system message construction and parsing.
+
+The user envelope is the contract between training data, inference, and eval:
+
+    Task: <label>
+    Duration: <D.DD>s
+    Assets:
+    - <asset or "(none)">
+
+    User prompt:
+    <original rough prompt>
+
+Task labels:
+  - base tasks use the task name directly (T2VA / I2VA / FL2VA / L2VA)
+  - ref tasks use the fine-grained form "video_editing (full-reference rewrite)"
+    so the 350M student can condition on the subtype. The old corpus used the
+    generic "full-reference rewrite" label; ``legacy=True`` reproduces it,
+    which is needed when evaluating checkpoints trained on the old corpus.
+"""
+
+from __future__ import annotations
+
+import html
+import re
+
+from ..paths import SYSTEM_BASE_FILE, SYSTEM_BASE_TASK_FILES, SYSTEM_REF_FILE
+
+BASE_TASKS = {"T2VA", "I2VA", "FL2VA", "L2VA"}
+REF_TASKS = {
+    "reference_generation",
+    "reference_generation+audio_reference",
+    "keyframe_completion",
+    "video_editing",
+    "video_editing+audio_reuse",
+    "video_continuation",
+    "video_continuation+audio_reference",
+}
+
+LEGACY_REF_LABEL = "full-reference rewrite"
+
+
+def is_base_task(task: str) -> bool:
+    return task in BASE_TASKS
+
+
+def task_label(task: str, *, legacy: bool = False) -> str:
+    if task in BASE_TASKS:
+        return task
+    if legacy:
+        return LEGACY_REF_LABEL
+    return f"{task} ({LEGACY_REF_LABEL})"
+
+
+def build_user_message(
+    task: str,
+    duration: float,
+    prompt: str,
+    assets: list[str] | None = None,
+    *,
+    legacy: bool = False,
+) -> str:
+    asset_block = "\n".join(f"- {a}" for a in assets) if assets else "- (none)"
+    return (
+        f"Task: {task_label(task, legacy=legacy)}\n"
+        f"Duration: {float(duration):.2f}s\n"
+        f"Assets:\n{asset_block}\n\n"
+        f"User prompt:\n{html.unescape(prompt).strip()}"
+    )
+
+
+def load_system(task: str) -> str:
+    """Load the system prompt for a task.
+
+    Base tasks use a task-specific file when present (T2VA has no alignment
+    rules; I2VA/FL2VA/L2VA only their own line) to cut cross-task instruction
+    leakage. Falls back to ``system_base.txt`` / ``system_ref.txt``.
+    """
+    if task in BASE_TASKS:
+        path = SYSTEM_BASE_TASK_FILES.get(task, SYSTEM_BASE_FILE)
+        if not path.is_file():
+            path = SYSTEM_BASE_FILE
+    else:
+        path = SYSTEM_REF_FILE
+    return path.read_text(encoding="utf-8").strip()
+
+
+def parse_user_blob(user_content: str) -> dict:
+    """Extract task, duration, assets, original prompt from a packaged user message.
+
+    Handles both the fine-grained label ("video_editing (full-reference rewrite)")
+    and the legacy generic label ("full-reference rewrite").
+    """
+    task = "T2VA"
+    duration = 6.0
+    assets: list[str] = []
+    prompt = user_content
+
+    m = re.search(r"Task:\s*(.+)", user_content)
+    if m:
+        raw = m.group(1).strip()
+        if raw == LEGACY_REF_LABEL:
+            task = "full-reference"
+        else:
+            fm = re.match(r"(.+?)\s*\(full-reference rewrite\)$", raw)
+            task = fm.group(1).strip() if fm else raw
+    m = re.search(r"Duration:\s*([0-9.]+)", user_content)
+    if m:
+        duration = float(m.group(1))
+    if "Assets:" in user_content and "User prompt:" in user_content:
+        asset_block = user_content.split("Assets:", 1)[1].split("User prompt:", 1)[0]
+        for line in asset_block.splitlines():
+            line = line.strip()
+            if line.startswith("- ") and line not in {"- (none)", "- none"}:
+                assets.append(line[2:].strip())
+        prompt = user_content.split("User prompt:", 1)[1].strip()
+
+    return {
+        "task": task,
+        "duration": duration,
+        "assets": assets or None,
+        "prompt": prompt,
+    }

minimax/formatting/fields.py

@@ -0,0 +1,46 @@
+"""Shared field lists and task normalization for base/ref output formats.
+
+Lives in ``formatting`` (not ``scoring``) so both scoring and postprocessing
+can depend on it without import cycles: scoring -> formatting is the allowed
+direction.
+"""
+
+from __future__ import annotations
+
+BASE_FIELDS = [
+    "integrated_multimodal_description:",
+    "overall_soundscape:",
+    "non_diegetic_music:",
+]
+REF_FIELDS = [
+    "subject_definitions:",
+    "summary:",
+    "retention_analysis:",
+    "detailed_description:",
+    "overall_soundscape:",
+    "non_diegetic_music:",
+]
+
+
+def normalize_task(task: str) -> str:
+    t = (task or "T2VA").strip()
+    if t in {"T2VA", "I2VA", "FL2VA", "L2VA"}:
+        return t
+    if t.startswith("full-reference"):
+        return "ref"
+    if any(
+        x in t
+        for x in (
+            "reference_generation",
+            "keyframe",
+            "video_editing",
+            "video_continuation",
+            "audio_",
+        )
+    ):
+        return "ref"
+    return t
+
+
+def is_base(task: str) -> bool:
+    return normalize_task(task) in {"T2VA", "I2VA", "FL2VA", "L2VA"}

minimax/formatting/instructions.py

@@ -0,0 +1,126 @@
+"""Canonical alignment-instruction lines from the official writing guides.
+
+VIDEO_PROMPT_WRITING_GUIDE_base_en.md fixes these lines verbatim (only the
+final shot number N and the duration mark S.SS vary). Teacher batches that
+paraphrase them create mixed supervision and destabilize the student's first
+line, so packaging/validation must enforce the exact forms:
+
+  I2VA : For the target video, at 0.00 seconds into the target video,
+         <Picture 1> (from [Shot 1]) is fully referenced.
+  FL2VA: How the reference pictures align with the target video — Picture 1
+         (from Shot 1) aligns with the 0.00-second mark of the target video;
+         Picture 2 (from Shot N) aligns with the S.SS-second mark of the
+         target video.
+  L2VA : How the reference pictures align with the target video —
+         <Picture 1> (from [Shot N]) aligns with the S.SS-second mark of the
+         target video.
+
+Note the asymmetry from the guide: FL2VA uses bare "Picture 1 (from Shot 1)"
+while L2VA uses bracketed "<Picture 1> (from [Shot N])".
+"""
+
+from __future__ import annotations
+
+import re
+
+I2VA_INSTRUCTION = (
+    "For the target video, at 0.00 seconds into the target video, "
+    "<Picture 1> (from [Shot 1]) is fully referenced."
+)
+
+FL2VA_RE = re.compile(
+    r"^How the reference pictures align with the target video — "
+    r"Picture 1 \(from Shot 1\) aligns with the 0\.00-second mark of the target video; "
+    r"Picture 2 \(from Shot \d+\) aligns with the \d+\.\d{2}-second mark of the target video\.$"
+)
+L2VA_RE = re.compile(
+    r"^How the reference pictures align with the target video — "
+    r"<Picture 1> \(from \[Shot \d+\]\) aligns with the \d+\.\d{2}-second mark of the target video\.$"
+)
+
+
+def fl2va_instruction(final_shot: int, duration: float) -> str:
+    return (
+        "How the reference pictures align with the target video — "
+        "Picture 1 (from Shot 1) aligns with the 0.00-second mark of the target video; "
+        f"Picture 2 (from Shot {final_shot}) aligns with the {duration:.2f}-second mark "
+        "of the target video."
+    )
+
+
+def l2va_instruction(final_shot: int, duration: float) -> str:
+    return (
+        "How the reference pictures align with the target video — "
+        f"<Picture 1> (from [Shot {final_shot}]) aligns with the {duration:.2f}-second "
+        "mark of the target video."
+    )
+
+
+def is_canonical_instruction(task: str, first_line: str) -> bool:
+    line = first_line.strip()
+    if task == "T2VA":
+        return line.startswith("integrated_multimodal_description:")
+    if task == "I2VA":
+        return line == I2VA_INSTRUCTION
+    if task == "FL2VA":
+        return bool(FL2VA_RE.match(line))
+    if task == "L2VA":
+        return bool(L2VA_RE.match(line))
+    return True
+
+
+def final_shot_number(body: str) -> int:
+    shots = [int(n) for n in re.findall(r"\[Shot (\d+)\]", body)]
+    return max(shots) if shots else 1
+
+
+def canonical_instruction(task: str, body: str, duration: float) -> str | None:
+    """The exact guide line for a base task, or None for T2VA."""
+    if task == "I2VA":
+        return I2VA_INSTRUCTION
+    if task == "FL2VA":
+        return fl2va_instruction(final_shot_number(body), duration)
+    if task == "L2VA":
+        return l2va_instruction(final_shot_number(body), duration)
+    return None
+
+
+def enforce_instruction_line(task: str, text: str, duration: float) -> str:
+    """Deterministically (re)build the alignment instruction on a generation.
+
+    A 350M student is unreliable at reproducing long fixed boilerplate (it may
+    omit the line, blend two task lines, or invent a Picture 2). Since the
+    line is fully determined by task + duration + final shot number, the
+    runtime constructs it: keep the body from the first core field onward and
+    prepend the canonical line.
+    """
+    if task not in {"I2VA", "FL2VA", "L2VA"}:
+        return text
+    idx = text.find("integrated_multimodal_description:")
+    if idx < 0:
+        return text  # no recognizable body; nothing safe to repair
+    body = text[idx:].strip()
+    line = canonical_instruction(task, body, duration)
+    return f"{line}\n\n{body}"
+
+
+def repair_base_instruction(task: str, output: str, duration: float) -> str:
+    """Replace a paraphrased/missing alignment instruction with the guide line.
+
+    The instruction is fully deterministic given task, duration, and the final
+    shot number, so this is a safe mechanical repair (no content invented).
+    """
+    if task not in {"I2VA", "FL2VA", "L2VA"}:
+        return output
+
+    text = output.strip()
+    if text.startswith("integrated_multimodal_description:"):
+        body = text  # instruction missing entirely
+    else:
+        parts = text.split("\n", 1)
+        body = parts[1].strip() if len(parts) > 1 else ""
+        if is_canonical_instruction(task, parts[0]):
+            return output
+
+    line = canonical_instruction(task, body, duration)
+    return f"{line}\n\n{body}"

minimax/formatting/meta_leak.py

@@ -0,0 +1,32 @@
+"""Detect system-prompt instruction leakage in generations.
+
+A small student can paraphrase system rules into the scene body. Detection is
+used by the format scorer (and teacher validation) so those outputs fail
+honestly. Content is *not* auto-rewritten here — fix via training + systems.
+"""
+
+from __future__ import annotations
+
+import re
+
+# Phrases that only appear when the model is narrating the *format rules*
+# rather than describing the video.
+_LEAK_RES: list[re.Pattern[str]] = [
+    re.compile(r"(?i)\brequired alignment instruction\b"),
+    re.compile(r"(?i)\bbegin(?:s|ning)? with the required\b"),
+    re.compile(r"(?i)\bintegrated_multimodal_description begins\b"),
+    re.compile(r"(?i)\bdetailed_description begins\b"),
+    re.compile(r"(?i)\bfills in a full story\b"),
+    re.compile(r"(?i)\bfrom the referenced picture\b"),
+    re.compile(r"(?i)\bthree core fields\b"),
+    re.compile(r"(?i)\bas the first line,? then one blank line\b"),
+    re.compile(r"(?i)\bwrites? the body in english\b"),
+    re.compile(r"(?i)\bdo not invent timestamps\b"),
+    re.compile(r"(?i)\boutput rules?\b"),
+]
+
+
+def has_instruction_leak(text: str) -> bool:
+    """True if any known instruction-leak phrase appears in the generation."""
+    t = text or ""
+    return any(rx.search(t) for rx in _LEAK_RES)

minimax/formatting/postprocess.py

@@ -0,0 +1,168 @@
+"""Generation postprocessing: trim chat markers, section loops, structural fixes.
+
+Structural repairs only (deterministic guide rules) — no invented scene prose.
+"""
+
+from __future__ import annotations
+
+import re
+
+from .fields import BASE_FIELDS, REF_FIELDS, is_base, normalize_task
+from .instructions import enforce_instruction_line
+from .timestamps import enforce_shot_timestamps
+
+
+_CITED_SHOTS_RE = re.compile(r"\s*\(appears in ([^)]*\[Shot \d+\][^)]*)\)")
+_SHOT_TOKEN_RE = re.compile(r"\[Shot (\d+)\]")
+_DESC_HEADERS = ("detailed_description:", "integrated_multimodal_description:")
+
+
+def _description_body_span(text: str, header: str) -> tuple[int, int] | None:
+    h = text.find(header)
+    if h < 0:
+        return None
+    start = h + len(header)
+    end = text.find("overall_soundscape:", start)
+    if end < 0:
+        end = len(text)
+    return start, end
+
+
+def ensure_trailing_audio_fields(text: str, *, base: bool) -> str:
+    """Append missing overall_soundscape / non_diegetic_music with N/A.
+
+    Models sometimes EOS right after the description (seen on long FL2VA).
+    Headers are required by the guide; N/A is the guide-legal empty value
+    for music and total silence, so this is structural — not scene invention.
+    """
+    t = text.rstrip()
+    # Only repair when a description section exists (otherwise empty/garbage).
+    if "integrated_multimodal_description:" not in t and "detailed_description:" not in t:
+        return t
+    sep = " " if base else "\n"
+    # Append missing fields in guide order after whatever we already have.
+    if "overall_soundscape:" not in t:
+        t = t + "\n\noverall_soundscape:" + sep + "N/A"
+    if "non_diegetic_music:" not in t:
+        t = t + "\n\nnon_diegetic_music:" + sep + "N/A"
+    return t
+
+
+def ensure_shot1_header(text: str) -> str:
+    """If a description body has content but no [Shot 1], prepend the marker.
+
+    Guide requires an opening shot section; 350M models sometimes write only
+    prose under detailed_description. Injecting the marker is structural —
+    it does not invent visual content.
+    """
+    t = text
+    for header in _DESC_HEADERS:
+        span = _description_body_span(t, header)
+        if span is None:
+            continue
+        start, end = span
+        body = t[start:end]
+        if not body.strip() or "[Shot 1]" in body:
+            continue
+        t = t[:start] + " [Shot 1] " + body.lstrip() + t[end:]
+        break
+    return t
+
+
+def _align_retention_citations(t: str) -> str:
+    """Drop retention citations of shots that have no section in the description.
+
+    The guide only allows retention_analysis to cite shot numbers that exist
+    in detailed_description. Phantom [Shot 2] citations trip the whole-text
+    timestamp scorer even when the description is legitimately single-shot.
+    """
+    if "retention_analysis:" not in t or "detailed_description:" not in t:
+        return t
+    desc = t.split("detailed_description:", 1)[1]
+    real = set(
+        re.findall(r"\[Shot (\d+)\]", desc.split("overall_soundscape:", 1)[0])
+    )
+
+    head, rest = t.split("retention_analysis:", 1)
+    ret, desc_part = rest.split("detailed_description:", 1)
+
+    if not real:
+        # No shot sections in DD — strip all shot tokens from retention so
+        # format scoring is not poisoned by phantom multi-shot claims.
+        ret2 = _CITED_SHOTS_RE.sub("", ret)
+        ret2 = _SHOT_TOKEN_RE.sub("", ret2)
+        return head + "retention_analysis:" + ret2 + "detailed_description:" + desc_part
+
+    def fix_appears(m: re.Match) -> str:
+        cited = re.findall(r"\[Shot (\d+)\]", m.group(1))
+        kept = [n for n in cited if n in real]
+        if not kept:
+            return ""
+        if kept == cited:
+            return m.group(0)
+        return " (appears in " + ", ".join(f"[Shot {n}]" for n in kept) + ")"
+
+    ret2 = _CITED_SHOTS_RE.sub(fix_appears, ret)
+
+    def bare_shot(m: re.Match) -> str:
+        return m.group(0) if m.group(1) in real else ""
+
+    ret2 = _SHOT_TOKEN_RE.sub(bare_shot, ret2)
+    return head + "retention_analysis:" + ret2 + "detailed_description:" + desc_part
+
+
+def postprocess_generation(text: str, task: str, duration: float | None = None) -> str:
+    t = (text or "").strip()
+    for stop in ("<|im_end|>", "<|endoftext|>", "<|im_start|>"):
+        if stop in t:
+            t = t.split(stop, 1)[0].strip()
+
+    task_n = normalize_task(task)
+    fields = BASE_FIELDS if is_base(task_n) else REF_FIELDS
+
+    # Field headers are fixed lowercase tokens; models occasionally emit
+    # sentence-cased variants ("Overall_soundscape:") after a paragraph break.
+    for f in fields:
+        t = re.sub(rf"(?im)^[ \t]*{re.escape(f)}", f, t)
+
+    # If a field header appears twice, keep only the first complete document.
+    for f in fields:
+        first = t.find(f)
+        if first < 0:
+            continue
+        second = t.find(f, first + len(f))
+        if second > 0:
+            t = t[:second].rstrip()
+            break
+
+    # Trim anything after the first paragraph of non_diegetic_music.
+    if "non_diegetic_music:" in t:
+        head, tail = t.split("non_diegetic_music:", 1)
+        music_body = tail.strip().split("\n\n")[0].strip()
+        for f in fields:
+            if f in music_body:
+                music_body = music_body.split(f, 1)[0].strip()
+        sep = " " if is_base(task_n) else "\n"
+        t = head + "non_diegetic_music:" + sep + music_body
+
+    # The alignment instruction is deterministic boilerplate; rebuild it
+    # rather than trusting the model to reproduce it verbatim.
+    if duration is not None and is_base(task_n):
+        t = enforce_instruction_line(task_n, t.strip(), duration)
+
+    # Structural shot markers before timestamp repair / retention cleanup.
+    t = ensure_shot1_header(t)
+
+    # Timestamp grammar is fully specified by the guide; repair missing or
+    # non-increasing "At MM:SS.mmm" stamps by interpolation.
+    if duration is not None:
+        t = enforce_shot_timestamps(t, duration)
+
+    if not is_base(task_n):
+        t = _align_retention_citations(t)
+
+    # Fill trailing sound/music headers when the model stops after the body
+    # (common on long keyframe FL2VA). Uses N/A — not invented ambience.
+    t = ensure_trailing_audio_fields(t, base=is_base(task_n))
+
+    return t.strip()

minimax/formatting/ref_repair.py

@@ -0,0 +1,106 @@
+"""Mechanical repairs for full-reference gold that drifted from the ref guide.
+
+Two known teacher drifts (gold_04..06 era):
+
+1. retention_analysis lines shaped "<Subject 1> fully_preserved" — missing the
+   guide's "<Label> (appears in [Shot ...]): marker - explanation" form. The
+   repair keeps the label + marker and derives the explanation from that
+   label's own subject_definitions entry (content-derived, not templated).
+
+2. video_editing summaries missing the mandated opener sentence
+   "The target video is an edited version of <Video 1>." right after the
+   [task type] prefix.
+"""
+
+from __future__ import annotations
+
+import re
+
+BARE_RET_LINE = re.compile(
+    r"^(?P<label><(?:Subject|Picture|Video|Audio) \d+>)\s+"
+    r"(?P<marker>fully_preserved|partially_preserved|attribute_transfer|"
+    r"weak_reference|fully_copy|partially_copy|reference)\s*$"
+)
+
+_MARKER_PHRASE = {
+    "fully_preserved": "{desc} is retained in the target video",
+    "partially_preserved": "{desc} is used with some defined characteristics changed",
+    "attribute_transfer": "characteristics of {desc} are transferred to the target subject",
+    "weak_reference": "only broad similarity to {desc} is retained",
+    "fully_copy": "the audio of {desc} is reused as the target video's final audio track",
+    "partially_copy": "part of the audio timeline of {desc} is copied into the target video",
+    "reference": "only the audible characteristics of {desc} are referenced without copying the signal",
+}
+
+
+def _label_description(label: str, subject_definitions: str) -> str:
+    """First clause of the label's definition line, e.g. 'the young woman ...'."""
+    for line in subject_definitions.splitlines():
+        line = line.strip()
+        if line.startswith(label):
+            rest = line[len(label):].lstrip()
+            rest = re.sub(r"^(is|are)\s+", "", rest)
+            clause = re.split(r"[.;]", rest, 1)[0].strip().rstrip(",")
+            if clause:
+                return clause
+    return "this reference"
+
+
+def _shots_for_label(label: str, detailed_description: str) -> list[int]:
+    """Shot numbers whose section mentions the label."""
+    parts = re.split(r"(\[Shot (\d+)\])", detailed_description)
+    shots: list[int] = []
+    current = None
+    for chunk in parts:
+        m = re.match(r"\[Shot (\d+)\]$", chunk or "")
+        if m:
+            current = int(m.group(1))
+        elif current is not None and label in (chunk or ""):
+            if current not in shots:
+                shots.append(current)
+    return shots
+
+
+def repair_retention_lines(output: str) -> str:
+    if "retention_analysis:" not in output:
+        return output
+    head, rest = output.split("retention_analysis:", 1)
+    if "detailed_description:" in rest:
+        ret_block, tail = rest.split("detailed_description:", 1)
+        tail = "detailed_description:" + tail
+    else:
+        ret_block, tail = rest, ""
+    subj_defs = head.split("subject_definitions:", 1)[-1]
+    detailed = tail
+
+    fixed_lines = []
+    for line in ret_block.split("\n"):
+        m = BARE_RET_LINE.match(line.strip())
+        if not m:
+            fixed_lines.append(line)
+            continue
+        label, marker = m.group("label"), m.group("marker")
+        desc = _label_description(label, subj_defs)
+        phrase = _MARKER_PHRASE[marker].format(desc=desc)
+        appears = ""
+        if label.startswith("<Subject"):
+            shots = _shots_for_label(label, detailed)
+            if shots:
+                appears = " (appears in " + ", ".join(f"[Shot {n}]" for n in shots) + ")"
+        fixed_lines.append(f"{label}{appears}: {marker} - {phrase}.")
+
+    return head + "retention_analysis:" + "\n".join(fixed_lines) + tail
+
+
+VIDEO_EDIT_OPENER = "The target video is an edited version of <Video 1>."
+
+
+def repair_video_editing_opener(output: str, task: str) -> str:
+    if not task.startswith("video_editing"):
+        return output
+    if "an edited version of <Video 1>" in output:
+        return output
+    m = re.search(r"(summary:\s*\n?\s*\[[^\]]+\])\s*", output)
+    if not m:
+        return output
+    return output[: m.end(1)] + f" {VIDEO_EDIT_OPENER}" + output[m.end(1):]

minimax/formatting/timestamps.py

@@ -0,0 +1,108 @@
+"""Deterministic repair of shot timestamps in generated descriptions.
+
+The guide fixes the timestamp grammar completely: [Shot 1] carries no
+timestamp, every later shot must open with "At MM:SS.mmm," and times must
+increase strictly inside the clip duration. When a generation drops or
+garbles a timestamp, the product layer can rebuild it mechanically —
+existing valid stamps are kept, missing ones are interpolated evenly
+between their known neighbours (0.0 at the start, the duration at the end).
+
+Only the description section is touched, and only its *sequential* shot
+markers ([Shot 1] then [Shot 2] then ...) count as section starts; shot
+references elsewhere (e.g. retention_analysis "appears in [Shot 2]") are
+left alone.
+"""
+
+from __future__ import annotations
+
+import re
+
+SHOT_RE = re.compile(r"\[Shot (\d+)\]\s*")
+STAMP_RE = re.compile(r"^At (\d{2}):(\d{2}\.\d{3}),?\s*")
+
+_DESC_HEADERS = ("detailed_description:", "integrated_multimodal_description:")
+_NEXT_HEADER = "overall_soundscape:"
+
+
+def _fmt(seconds: float) -> str:
+    m = int(seconds // 60)
+    return f"{m:02d}:{seconds - m * 60:06.3f}"
+
+
+def _repair_section(section: str, duration: float) -> str:
+    # Sequential shot-section markers only: [Shot 1], then [Shot 2], ...
+    marks: list[re.Match] = []
+    expected = 1
+    for m in SHOT_RE.finditer(section):
+        if int(m.group(1)) == expected:
+            marks.append(m)
+            expected += 1
+    if len(marks) < 2:
+        return section
+
+    stamps: list[float | None] = []
+    spans: list[tuple[int, int]] = []
+    for m in marks:
+        sm = STAMP_RE.match(section[m.end():])
+        if sm:
+            stamps.append(int(sm.group(1)) * 60 + float(sm.group(2)))
+            spans.append((m.end(), m.end() + sm.end()))
+        else:
+            stamps.append(None)
+            spans.append((m.end(), m.end()))
+
+    # Shot 1 implicitly owns 0.0; keep valid increasing stamps, interpolate
+    # anything missing or out of order toward the next trusted value.
+    times: list[float] = [0.0] * len(stamps)
+    prev = 0.0
+    i = 1
+    while i < len(stamps):
+        s = stamps[i]
+        if s is not None and prev < s < duration:
+            times[i] = s
+            prev = s
+            i += 1
+            continue
+        j = i + 1
+        nxt = duration
+        while j < len(stamps):
+            sj = stamps[j]
+            if sj is not None and prev < sj < duration:
+                nxt = sj
+                break
+            j += 1
+        gaps = (j - i) + 1
+        for k in range(i, j):
+            times[k] = prev + (nxt - prev) * (k - i + 1) / gaps
+        prev = times[j - 1]
+        i = j
+
+    out = section
+    for idx in range(len(marks) - 1, 0, -1):
+        start, end = spans[idx]
+        if stamps[idx] is not None and abs(stamps[idx] - times[idx]) < 0.0005:
+            continue
+        out = out[:start] + f"At {_fmt(times[idx])}, " + out[end:]
+    # Shot 1 must not carry a timestamp.
+    s0, e0 = spans[0]
+    if stamps[0] is not None:
+        out = out[:s0] + out[e0:]
+    return out
+
+
+def enforce_shot_timestamps(text: str, duration: float) -> str:
+    """Ensure every sequential [Shot N>=2] opens with a valid increasing stamp."""
+    if duration <= 0:
+        return text
+
+    for header in _DESC_HEADERS:
+        h = text.find(header)
+        if h < 0:
+            continue
+        start = h + len(header)
+        end = text.find(_NEXT_HEADER, start)
+        if end < 0:
+            end = len(text)
+        section = text[start:end]
+        return text[:start] + _repair_section(section, duration) + text[end:]
+    return text

minimax/modeling/generate.py

@@ -0,0 +1,63 @@
+"""Single-item generation with stop tokens, postprocess, and format scoring."""
+
+from __future__ import annotations
+
+from ..formatting.envelope import build_user_message, load_system
+from ..formatting.postprocess import postprocess_generation
+from ..scoring.format_score import default_max_new_tokens, score_format
+
+
+def generate_one(
+    model,
+    tokenizer,
+    *,
+    task: str,
+    duration: float,
+    prompt: str,
+    assets: list[str] | None,
+    stop_ids: list[int],
+    max_new_tokens: int | None = None,
+    temperature: float = 0.0,
+    top_k: int = 40,
+    repetition_penalty: float = 1.0,
+    legacy_labels: bool = False,
+) -> tuple[str, dict]:
+    import torch
+
+    messages = [
+        {"role": "system", "content": load_system(task)},
+        {
+            "role": "user",
+            "content": build_user_message(task, duration, prompt, assets, legacy=legacy_labels),
+        },
+    ]
+    prompt_text = tokenizer.apply_chat_template(
+        messages, tokenize=False, add_generation_prompt=True
+    )
+    inputs = tokenizer(prompt_text, return_tensors="pt")
+    inputs = {k: v.to(model.device) for k, v in inputs.items()}
+
+    mnt = max_new_tokens if max_new_tokens is not None else default_max_new_tokens(task)
+    gen_kwargs = dict(
+        max_new_tokens=mnt,
+        do_sample=temperature > 0,
+        temperature=max(temperature, 1e-5) if temperature > 0 else None,
+        top_k=top_k if temperature > 0 else None,
+        repetition_penalty=repetition_penalty,
+        pad_token_id=tokenizer.pad_token_id or tokenizer.eos_token_id,
+    )
+    gen_kwargs = {k: v for k, v in gen_kwargs.items() if v is not None}
+    if stop_ids:
+        gen_kwargs["eos_token_id"] = stop_ids
+
+    with torch.inference_mode():
+        out = model.generate(**inputs, **gen_kwargs)
+
+    gen = out[0][inputs["input_ids"].shape[-1] :]
+    raw = tokenizer.decode(gen, skip_special_tokens=True).strip()
+    raw = raw.replace("<|im_end|>", "").replace("<|endoftext|>", "").strip()
+    text = postprocess_generation(raw, task, duration)
+    report = score_format(text, task)
+    report["raw_char_len"] = len(raw)
+    report["max_new_tokens"] = mnt
+    return text, report

minimax/modeling/loader.py

@@ -0,0 +1,80 @@
+"""Model/tokenizer loading — ZeroGPU-friendly (place on cuda at load time)."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from ..paths import BASE_MODEL
+
+
+def resolve_model_dir(model: str | Path) -> tuple[str, str | None]:
+    """Return (model_path, adapter_path). Prefers merged weights when present."""
+    p = Path(model)
+    if p.is_dir():
+        if (p / "merged").is_dir() and (p / "merged" / "config.json").is_file():
+            return str(p / "merged"), None
+        if (p / "config.json").is_file():
+            return str(p), None
+        if (p / "adapter_config.json").is_file():
+            return BASE_MODEL, str(p)
+    return str(model), None
+
+
+def load_model_and_tokenizer(model: str | Path):
+    """Load weights onto CUDA.
+
+    ZeroGPU emulates CUDA at import/startup so ``.to("cuda")`` is required at
+    the root level; a real GPU is only attached inside ``@spaces.GPU`` calls.
+    """
+    import torch
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+
+    model_path, adapter_path = resolve_model_dir(model)
+    tokenizer = AutoTokenizer.from_pretrained(
+        adapter_path or model_path, trust_remote_code=True
+    )
+    # bf16 on GPU; ZeroGPU always exposes a cuda device (real or emulated).
+    dtype = torch.bfloat16 if torch.cuda.is_available() else torch.float32
+    lm = AutoModelForCausalLM.from_pretrained(
+        model_path,
+        trust_remote_code=True,
+        torch_dtype=dtype,
+        low_cpu_mem_usage=True,
+    )
+    if adapter_path:
+        from peft import PeftModel
+
+        lm = PeftModel.from_pretrained(lm, adapter_path).merge_and_unload()
+    # ZeroGPU docs: place models on cuda at root, not lazily inside @spaces.GPU
+    if torch.cuda.is_available():
+        lm = lm.to("cuda")
+    lm.eval()
+    return lm, tokenizer
+
+
+def build_stop_ids(tokenizer) -> list[int]:
+    """ChatML / LFM end tokens for clean stopping."""
+    candidates = ["<|im_end|>", "<|endoftext|>", tokenizer.eos_token]
+    ids: list[int] = []
+    for s in candidates:
+        if not s:
+            continue
+        try:
+            tid = tokenizer.convert_tokens_to_ids(s)
+            if tid is not None and tid != tokenizer.unk_token_id and int(tid) >= 0:
+                ids.append(int(tid))
+        except Exception:
+            pass
+        try:
+            enc = tokenizer.encode(s, add_special_tokens=False)
+            if len(enc) == 1:
+                ids.append(int(enc[0]))
+        except Exception:
+            pass
+    out: list[int] = []
+    for i in ids:
+        if i not in out:
+            out.append(i)
+    if tokenizer.eos_token_id is not None and tokenizer.eos_token_id not in out:
+        out.append(int(tokenizer.eos_token_id))
+    return out

minimax/paths.py

@@ -0,0 +1,24 @@
+"""Paths for the Hugging Face Space package (self-contained)."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+# Space root = parent of the minimax package
+ROOT = Path(__file__).resolve().parent.parent
+PROMPTS = ROOT / "prompts"
+
+SYSTEM_BASE_FILE = PROMPTS / "system_base.txt"
+SYSTEM_REF_FILE = PROMPTS / "system_ref.txt"
+SYSTEM_BASE_TASK_FILES = {
+    "T2VA": PROMPTS / "system_base_t2va.txt",
+    "I2VA": PROMPTS / "system_base_i2va.txt",
+    "FL2VA": PROMPTS / "system_base_fl2va.txt",
+    "L2VA": PROMPTS / "system_base_l2va.txt",
+}
+
+# Default Hub model for this Space
+DEFAULT_MODEL = "geocine/minimax-video-prompt-enhancer-350m"
+BASE_MODEL = "LiquidAI/LFM2.5-350M"
+# Alias used by local app code
+CHAMPION_DIR = DEFAULT_MODEL

minimax/scoring/__init__.py

@@ -0,0 +1,8 @@
+from .format_score import (  # noqa: F401
+    BASE_FIELDS,
+    REF_FIELDS,
+    default_max_new_tokens,
+    is_base,
+    normalize_task,
+    score_format,
+)

minimax/scoring/format_score.py

@@ -0,0 +1,157 @@
+"""MiniMax structure scoring for base + full-reference rewrites.
+
+pass = every critical check true. ``score`` is the fraction of critical checks
+passed (soft signal; a high mean score with low pass rate means outputs are
+one brittle check away from passing).
+
+Changes vs the v1 scorer:
+  - ``has_reference_label`` accepts any of <Subject N> / <Picture N> /
+    <Video N> / <Audio N>. The v1 ``has_subject_label`` required <Subject N>
+    and wrongly failed e.g. video continuations that only track <Video 1>.
+  - every [Shot N] with N >= 2 must carry an "At MM:SS.mmm" timestamp
+    (v1 only checked Shot 2).
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from ..formatting.fields import (  # noqa: F401  (re-exported for compat)
+    BASE_FIELDS,
+    REF_FIELDS,
+    is_base,
+    normalize_task,
+)
+from ..formatting.instructions import FL2VA_RE, I2VA_INSTRUCTION, L2VA_RE
+from ..formatting.meta_leak import has_instruction_leak
+
+REFERENCE_LABEL_RE = re.compile(r"<(?:Subject|Picture|Video|Audio)\s+\d+>")
+
+
+def field_order_ok(text: str, fields: list[str]) -> bool:
+    positions = []
+    for f in fields:
+        p = text.find(f)
+        if p < 0:
+            return False
+        positions.append(p)
+    return positions == sorted(positions)
+
+
+def count_section_repeats(text: str, fields: list[str]) -> int:
+    return sum(1 for f in fields if text.count(f) > 1)
+
+
+def shots_have_timestamps(text: str) -> bool:
+    """Every shot number N >= 2 needs a timestamped header "[Shot N] At MM:SS.mmm".
+
+    Checked per shot number, not per occurrence: sections like
+    retention_analysis legitimately cross-reference shots as "([Shot 1], [Shot 2])"
+    without timestamps.
+    """
+    shot_numbers = {int(n) for n in re.findall(r"\[Shot (\d+)\]", text)}
+    for n in shot_numbers:
+        if n < 2:
+            continue
+        if not re.search(rf"\[Shot {n}\]\s+At\s+\d{{2}}:\d{{2}}\.\d{{3}}", text):
+            return False
+    return True
+
+
+def score_format(text: str, task: str) -> dict[str, Any]:
+    """Return pass/fail + checklist for one generation."""
+    text = (text or "").strip()
+    task_n = normalize_task(task)
+    checks: dict[str, bool] = {}
+    notes: list[str] = []
+
+    if not text:
+        return {
+            "pass": False,
+            "score": 0.0,
+            "task": task_n,
+            "checks": {"nonempty": False},
+            "notes": ["empty generation"],
+        }
+
+    checks["nonempty"] = True
+    checks["has_shot1"] = "[Shot 1]" in text
+    # MiniMax H3 prompt field hard limit: 7,000 characters incl. whitespace.
+    checks["within_h3_char_limit"] = len(text) <= 7000
+    # Reject system-rule paraphrases dumped into the scene body. Structural
+    # field checks alone green-lit this failure mode (T2VA pass with meta text).
+    checks["no_instruction_leak"] = not has_instruction_leak(text)
+
+    if is_base(task_n):
+        fields = BASE_FIELDS
+        for f in fields:
+            checks[f"field:{f}"] = f in text
+        checks["field_order"] = field_order_ok(text, fields)
+        checks["no_heavy_loop"] = count_section_repeats(text, fields) == 0
+
+        # Alignment instructions are fixed verbatim by the writing guide
+        # (only shot number / duration mark vary), so check the exact line.
+        first_line = text.split("\n", 1)[0].strip()
+        if task_n == "I2VA":
+            checks["i2va_instruction"] = first_line == I2VA_INSTRUCTION
+        if task_n == "FL2VA":
+            checks["fl2va_alignment"] = bool(FL2VA_RE.match(first_line))
+        if task_n == "L2VA":
+            checks["l2va_alignment"] = bool(L2VA_RE.match(first_line))
+
+        checks["has_shot2_optional"] = "[Shot 2]" in text
+        checks["shots_have_timestamps"] = shots_have_timestamps(text)
+        # Shot 1 must not carry a timestamp in base style
+        checks["shot1_no_bogus_timestamp"] = not bool(
+            re.search(r"\[Shot 1\]\s+At\s+\d{2}:", text)
+        )
+
+    else:
+        fields = REF_FIELDS
+        for f in fields:
+            checks[f"field:{f}"] = f in text
+        checks["field_order"] = field_order_ok(text, fields)
+        checks["no_heavy_loop"] = count_section_repeats(text, fields) == 0
+
+        if "summary:" in text:
+            sum_part = text.split("summary:", 1)[1]
+            if "retention_analysis:" in sum_part:
+                sum_part = sum_part.split("retention_analysis:", 1)[0]
+            checks["summary_task_prefix"] = bool(re.search(r"\[[^\]]+\]", sum_part))
+        else:
+            checks["summary_task_prefix"] = False
+
+        checks["has_reference_label"] = bool(REFERENCE_LABEL_RE.search(text))
+        checks["has_shot2_optional"] = "[Shot 2]" in text
+        checks["shots_have_timestamps"] = shots_have_timestamps(text)
+
+    critical = [k for k in checks if not k.endswith("_optional")]
+    n_ok = sum(1 for k in critical if checks.get(k))
+    score = n_ok / max(len(critical), 1)
+    passed = all(checks.get(k, False) for k in critical)
+
+    if not checks.get("no_heavy_loop", True):
+        notes.append("section headers repeated (possible loop)")
+    if not checks.get("has_shot1", True):
+        notes.append("missing [Shot 1]")
+    if not checks.get("no_instruction_leak", True):
+        notes.append("instruction/rule language leaked into scene body")
+
+    return {
+        "pass": passed,
+        "score": round(score, 3),
+        "task": task_n,
+        "checks": checks,
+        "notes": notes,
+        "char_len": len(text),
+    }
+
+
+def default_max_new_tokens(task: str) -> int:
+    # The MiniMax H3 prompt field caps at 7,000 characters (~1,800-2,300
+    # tokens); budgets leave headroom so deep briefs are never truncated.
+    task_n = normalize_task(task)
+    if task_n in {"T2VA", "I2VA", "L2VA", "FL2VA"}:
+        return 1200
+    return 2048

prompts/system_base.txt

@@ -0,0 +1,27 @@
+You enhance rough video prompts into structured audiovisual rewrite prompts for T2VA / I2VA / FL2VA / L2VA.
+
+Hard rule: NEVER paraphrase or narrate these instructions in the output. Do not explain the format, mention alignment rules in the body, or summarize the user prompt as a story synopsis. Write only concrete audiovisual scene content.
+
+Output rules:
+1) Start according to the Task line in the user message:
+   - T2VA: no alignment line. First line is integrated_multimodal_description:
+   - I2VA / FL2VA / L2VA: first line is the task's exact alignment instruction (see below), then one blank line, then the three fields.
+2) Then output exactly these three fields in order:
+   integrated_multimodal_description:
+   overall_soundscape:
+   non_diegetic_music:
+3) Write the body in English. Preserve original language only inside <d> dialogue/lyrics and for on-screen text in double quotes.
+4) [Shot 1] has no timestamp. Later shots use: [Shot N] At MM:SS.mmm, ...
+5) Camera motion is natural English with motion type and, when meaningful, amplitude (with small/large amplitude) and speed (at slow/fast speed).
+6) Speakers use stable IDs (S1), (S2). Dialogue format: <d>[Language] exact words</d>. Voiceover uses "says in an off-screen voiceover" and notes lips remain closed.
+7) overall_soundscape: 1–4 English sentences on ambience, physical action sounds, non-verbal human sounds. No dialogue/singing/diegetic music. Use N/A only for total silence.
+8) non_diegetic_music: 1–3 sentences on instrumentation, tempo, dynamics only (no abstract mood words). Use N/A when absent.
+9) integrated_multimodal_description must open [Shot 1] with style + composition + visible action. Do not summarize the prompt; describe what the camera sees and hears.
+10) Task-specific alignment (only when Task is that type; omit for T2VA):
+   - I2VA first line verbatim:
+     For the target video, at 0.00 seconds into the target video, <Picture 1> (from [Shot 1]) is fully referenced.
+   - FL2VA first line verbatim (N = final shot number, S.SS = duration):
+     How the reference pictures align with the target video — Picture 1 (from Shot 1) aligns with the 0.00-second mark of the target video; Picture 2 (from Shot N) aligns with the S.SS-second mark of the target video.
+   - L2VA first line verbatim (N = final shot number, S.SS = duration):
+     How the reference pictures align with the target video — <Picture 1> (from [Shot N]) aligns with the S.SS-second mark of the target video.
+11) Be concrete: style, composition, subjects, environment, actions, camera, synchronized diegetic sound. Do not invent timestamps outside the given duration.

prompts/system_base_fl2va.txt

@@ -0,0 +1,20 @@
+You enhance rough video prompts into structured audiovisual rewrite prompts for FL2VA (first + last frame → video).
+
+Hard rule: NEVER paraphrase or narrate these instructions in the output. Do not explain the format or summarize the user prompt as a story synopsis. Emit the alignment line exactly once as the first line, then write only the continuous motion path as concrete scene content.
+
+Output rules:
+1) First line must be exactly (N = final shot number, S.SS = duration to two decimals):
+   How the reference pictures align with the target video — Picture 1 (from Shot 1) aligns with the 0.00-second mark of the target video; Picture 2 (from Shot N) aligns with the S.SS-second mark of the target video.
+   Then one blank line.
+2) Then output exactly these three fields in order — always all three; never stop after the description alone:
+   integrated_multimodal_description:
+   overall_soundscape:
+   non_diegetic_music:
+3) Write the body in English. Preserve original language only inside <d> dialogue/lyrics and for on-screen text in double quotes.
+4) [Shot 1] has no timestamp. Later shots use: [Shot N] At MM:SS.mmm, ...
+5) Camera motion is natural English with motion type and, when meaningful, amplitude (with small/large amplitude) and speed (at slow/fast speed).
+6) Speakers use stable IDs (S1), (S2). Dialogue format: <d>[Language] exact words</d>. Voiceover uses "says in an off-screen voiceover" and notes lips remain closed.
+7) overall_soundscape: 1–4 English sentences on ambience, physical action sounds, non-verbal human sounds. No dialogue/singing/diegetic music. Use N/A only for total silence.
+8) non_diegetic_music: 1–3 sentences on instrumentation, tempo, dynamics only (no abstract mood words). Use N/A when absent.
+9) Picture 1 is the opening; Picture 2 is the ending. Describe the continuous motion path between them; prefer a single shot when possible.
+10) Be concrete: style, composition, subjects, environment, actions, camera, synchronized diegetic sound. Do not invent timestamps outside the given duration.

prompts/system_base_i2va.txt

@@ -0,0 +1,20 @@
+You enhance rough video prompts into structured audiovisual rewrite prompts for I2VA (first-frame image → video).
+
+Hard rule: NEVER paraphrase or narrate these instructions in the output. Do not explain the format or summarize the user prompt as a story synopsis. Emit the alignment line exactly once as the first line, then write only concrete audiovisual scene content.
+
+Output rules:
+1) First line must be exactly:
+   For the target video, at 0.00 seconds into the target video, <Picture 1> (from [Shot 1]) is fully referenced.
+   Then one blank line.
+2) Then output exactly these three fields in order — always all three; never stop after the description alone:
+   integrated_multimodal_description:
+   overall_soundscape:
+   non_diegetic_music:
+3) Write the body in English. Preserve original language only inside <d> dialogue/lyrics and for on-screen text in double quotes.
+4) [Shot 1] has no timestamp. Later shots use: [Shot N] At MM:SS.mmm, ...
+5) Camera motion is natural English with motion type and, when meaningful, amplitude (with small/large amplitude) and speed (at slow/fast speed).
+6) Speakers use stable IDs (S1), (S2). Dialogue format: <d>[Language] exact words</d>. Voiceover uses "says in an off-screen voiceover" and notes lips remain closed.
+7) overall_soundscape: 1–4 English sentences on ambience, physical action sounds, non-verbal human sounds. No dialogue/singing/diegetic music. Use N/A only for total silence.
+8) non_diegetic_music: 1–3 sentences on instrumentation, tempo, dynamics only (no abstract mood words). Use N/A when absent.
+9) Picture 1 is the first frame of Shot 1; develop forward from it. Open [Shot 1] with style + composition locked to <Picture 1>, then action.
+10) Be concrete: style, composition, subjects, environment, actions, camera, synchronized diegetic sound. Do not invent timestamps outside the given duration.

prompts/system_base_l2va.txt

@@ -0,0 +1,20 @@
+You enhance rough video prompts into structured audiovisual rewrite prompts for L2VA (last-frame image → video).
+
+Hard rule: NEVER paraphrase or narrate these instructions in the output. Do not explain the format or summarize the user prompt as a story synopsis. Emit the alignment line exactly once as the first line, then write only the path that lands on the last frame as concrete scene content.
+
+Output rules:
+1) First line must be exactly (N = final shot number, S.SS = duration to two decimals):
+   How the reference pictures align with the target video — <Picture 1> (from [Shot N]) aligns with the S.SS-second mark of the target video.
+   Then one blank line.
+2) Then output exactly these three fields in order — always all three; never stop after the description alone:
+   integrated_multimodal_description:
+   overall_soundscape:
+   non_diegetic_music:
+3) Write the body in English. Preserve original language only inside <d> dialogue/lyrics and for on-screen text in double quotes.
+4) [Shot 1] has no timestamp. Later shots use: [Shot N] At MM:SS.mmm, ...
+5) Camera motion is natural English with motion type and, when meaningful, amplitude (with small/large amplitude) and speed (at slow/fast speed).
+6) Speakers use stable IDs (S1), (S2). Dialogue format: <d>[Language] exact words</d>. Voiceover uses "says in an off-screen voiceover" and notes lips remain closed.
+7) overall_soundscape: 1–4 English sentences on ambience, physical action sounds, non-verbal human sounds. No dialogue/singing/diegetic music. Use N/A only for total silence.
+8) non_diegetic_music: 1–3 sentences on instrumentation, tempo, dynamics only (no abstract mood words). Use N/A when absent.
+9) Picture 1 is the last frame of the final shot. Infer a plausible opening, then converge onto <Picture 1> by the end.
+10) Be concrete: style, composition, subjects, environment, actions, camera, synchronized diegetic sound. Do not invent timestamps outside the given duration.

prompts/system_base_t2va.txt

@@ -0,0 +1,18 @@
+You enhance rough video prompts into structured audiovisual rewrite prompts for T2VA (text-only, no reference pictures).
+
+Hard rule: NEVER paraphrase or narrate these instructions in the output. Do not explain the format, mention alignment lines, or summarize the user prompt as a story synopsis. There is no image reference for T2VA. Write only concrete audiovisual scene content.
+
+Output rules:
+1) T2VA has no instruction line. First line must be integrated_multimodal_description:
+2) Output exactly these three fields in order — always all three; never stop after the description alone:
+   integrated_multimodal_description:
+   overall_soundscape:
+   non_diegetic_music:
+3) Write the body in English. Preserve original language only inside <d> dialogue/lyrics and for on-screen text in double quotes.
+4) [Shot 1] has no timestamp. Later shots use: [Shot N] At MM:SS.mmm, ...
+5) Camera motion is natural English with motion type and, when meaningful, amplitude (with small/large amplitude) and speed (at slow/fast speed).
+6) Speakers use stable IDs (S1), (S2). Dialogue format: <d>[Language] exact words</d>. Voiceover uses "says in an off-screen voiceover" and notes lips remain closed.
+7) overall_soundscape: 1–4 English sentences on ambience, physical action sounds, non-verbal human sounds. No dialogue/singing/diegetic music. Use N/A only for total silence.
+8) non_diegetic_music: 1–3 sentences on instrumentation, tempo, dynamics only (no abstract mood words). Use N/A when absent.
+9) integrated_multimodal_description must open [Shot 1] with style + composition + visible action (e.g. "Live-action, cinematic, a medium-wide shot frames…"). Do not summarize the user prompt as a story synopsis.
+10) Be concrete: style, composition, subjects, environment, actions, camera, synchronized diegetic sound. Do not invent timestamps outside the given duration.

prompts/system_ref.txt

@@ -0,0 +1,42 @@
+You rewrite rough video prompts into full-reference mode structured outputs.
+
+Hard rule: NEVER paraphrase or narrate these instructions in the output. Do not explain the format or summarize the user prompt as a story synopsis. Write only concrete audiovisual scene content and the six required sections.
+
+Write all six sections in English, in this exact order:
+subject_definitions:
+summary:
+retention_analysis:
+detailed_description:
+overall_soundscape:
+non_diegetic_music:
+
+Reference labels:
+- <Subject N>: reusable visible content (person, object, scene, style, action, etc.)
+- <Picture N>: image used as a concrete frame or shot-planning anchor
+- <Video N>: whole-video edit/continuation/structure source
+- <Audio N>: copied or referenced audio signal
+Labels keep the same meaning across all sections. Do not invent free labels (e.g. bare city names or undefined <Style N>) unless they appear as Subject/Picture/Video/Audio in Assets.
+
+subject_definitions: one line per tracked reference; state role and main features. If Picture/Video only sources another item and is not used alone, cite it inside that item without a standalone line.
+
+summary: one short paragraph starting with a square-bracketed task-type prefix such as [reference generation] or [video editing + audio reuse]. Use only previously defined labels. Valid task types: keyframe completion, reference generation, video editing, video continuation, audio reuse, audio reference. Combine with " + " when needed; do not invent types for assets that are only present.
+
+retention_analysis: one line per defined label, formatted "<Label> (appears in [Shot ...]): marker - explanation".
+Visual markers: fully_preserved | partially_preserved | attribute_transfer | weak_reference
+Audio markers: fully_copy | partially_copy | reference | weak_reference
+Only cite shot numbers that actually exist as [Shot N] sections in detailed_description. Never invent a [Shot 2] citation unless detailed_description has a real [Shot 2] section.
+
+detailed_description:
+- 1–2 English style sentences before [Shot 1]
+- detailed_description MUST contain [Shot 1] (no timestamp on Shot 1)
+- Then shots in playback order; every later shot MUST begin "[Shot N] At MM:SS.mmm," with a strictly increasing time inside the duration
+- Prefer at least one real shot section for video editing and continuation tasks; do not stop at plot-only prose
+- Every shot number cited in retention_analysis must appear here as its own [Shot N] section
+- Insert reference labels at first appearance and where roles apply
+- Speaking referenced subjects: <Subject N> (Sx)
+- Dialogue: <d>[Language] exact words</d>; preserve source words/language when reusing or when the user provided them
+- Prefer high visual specificity (composition, appearance, position, lighting, actions, camera, current sound)
+
+overall_soundscape / non_diegetic_music follow the base guide split (ambience+physical vs audience-only score). When reference audio applies, state copy/reference relationships in the matching section. Always include both fields (use N/A when absent).
+
+Do not reduce detailed_description to a plot summary or a list of reference relationships alone.

requirements.txt

@@ -0,0 +1,10 @@
+# Hugging Face ZeroGPU Space — MiniMax Video Prompt Enhancer
+# ZeroGPU supports Gradio 4+ and recent PyTorch (see HF ZeroGPU docs).
+gradio>=4.44.0
+spaces>=0.30.0
+torch>=2.1.0
+transformers>=4.45.0
+accelerate>=0.33.0
+safetensors>=0.4.0
+sentencepiece>=0.2.0
+protobuf>=4.25.0