@optima-chat/optima-agent 0.8.95 → 0.8.96

package/.claude/skills/video-clone/scripts/kling_generate_test.py

@@ -1,191 +0,0 @@
-"""Tests for the pure helper functions in kling_generate.py.
-
-No network. We do not exercise _submit / _poll / _download — those are
-I/O-bound and covered by end-to-end staging runs. Unit tests here keep the
-helper contracts honest so refactors don't silently break the auth-header
-normalization or the token / API-URL discovery order.
-
-Run: python scripts/kling_generate_test.py
-"""
-from __future__ import annotations
-
-import json
-import os
-import subprocess
-import sys
-import tempfile
-from pathlib import Path
-from unittest import mock
-
-SCRIPTS_DIR = Path(__file__).parent
-sys.path.insert(0, str(SCRIPTS_DIR))
-
-import kling_generate  # noqa: E402
-
-
-# ---------- _auth_header ----------
-
-def test_auth_header_adds_bearer_prefix():
-    assert kling_generate._auth_header("xyz123") == "Bearer xyz123"
-
-
-def test_auth_header_preserves_existing_bearer():
-    assert kling_generate._auth_header("Bearer xyz123") == "Bearer xyz123"
-
-
-def test_auth_header_is_case_insensitive_on_existing_prefix():
-    assert kling_generate._auth_header("bearer xyz123") == "bearer xyz123"
-    assert kling_generate._auth_header("BEARER xyz123") == "BEARER xyz123"
-
-
-# ---------- _get_token ----------
-
-def test_get_token_prefers_env_var(tmp_token_file):
-    tmp_token_file.write_text(
-        json.dumps({"access_token": "from-file", "env": "prod"}), encoding="utf-8"
-    )
-    os.environ["OPTIMA_TOKEN"] = "from-env"
-    try:
-        assert kling_generate._get_token() == "from-env"
-    finally:
-        os.environ.pop("OPTIMA_TOKEN", None)
-
-
-def test_get_token_falls_back_to_file(tmp_token_file):
-    os.environ.pop("OPTIMA_TOKEN", None)
-    tmp_token_file.write_text(
-        json.dumps({"access_token": "file-xyz", "env": "stage"}), encoding="utf-8"
-    )
-    assert kling_generate._get_token() == "file-xyz"
-
-
-def test_get_token_exits_when_neither_source_has_token(tmp_token_file):
-    os.environ.pop("OPTIMA_TOKEN", None)
-    # tmp_token_file does not exist (fixture creates parent, caller decides)
-    # Here: don't create the file — _load_token_file should return None
-    code = (
-        "import sys; sys.path.insert(0, r'{d}'); import kling_generate; "
-        "kling_generate._get_token()"
-    ).format(d=str(SCRIPTS_DIR))
-    env = {**os.environ}
-    env.pop("OPTIMA_TOKEN", None)
-    env["HOME"] = str(tmp_token_file.parent.parent)   # .../.optima/token.json → HOME = .../
-    env["USERPROFILE"] = env["HOME"]
-    result = subprocess.run(
-        [sys.executable, "-c", code], capture_output=True, text=True, env=env,
-    )
-    assert result.returncode == 1
-    assert "optima login" in result.stderr or "OPTIMA_TOKEN" in result.stderr
-
-
-# ---------- _get_gen_api_url ----------
-
-def test_get_gen_api_url_env_override_wins(tmp_token_file):
-    tmp_token_file.write_text(
-        json.dumps({"access_token": "t", "env": "stage"}), encoding="utf-8"
-    )
-    os.environ["GENERATION_API_URL"] = "https://custom.example/api"
-    try:
-        assert kling_generate._get_gen_api_url() == "https://custom.example/api"
-    finally:
-        os.environ.pop("GENERATION_API_URL", None)
-
-
-def test_get_gen_api_url_trims_trailing_slash():
-    os.environ["GENERATION_API_URL"] = "https://custom.example/"
-    try:
-        assert kling_generate._get_gen_api_url() == "https://custom.example"
-    finally:
-        os.environ.pop("GENERATION_API_URL", None)
-
-
-def test_get_gen_api_url_reads_env_from_token_file(tmp_token_file):
-    os.environ.pop("GENERATION_API_URL", None)
-    tmp_token_file.write_text(
-        json.dumps({"access_token": "t", "env": "stage"}), encoding="utf-8"
-    )
-    assert kling_generate._get_gen_api_url() == "https://gen-api.stage.optima.onl"
-
-
-def test_get_gen_api_url_defaults_to_prod_when_no_file(tmp_token_file):
-    os.environ.pop("GENERATION_API_URL", None)
-    # tmp_token_file not created → should default to prod
-    assert kling_generate._get_gen_api_url() == "https://gen-api.optima.onl"
-
-
-# ---------- fixture ----------
-
-class _TmpToken:
-    """Manage a throwaway ~/.optima/token.json by monkey-patching the module constant."""
-    def __init__(self):
-        self.tmp = tempfile.TemporaryDirectory()
-        self.path = Path(self.tmp.name) / ".optima" / "token.json"
-        self.path.parent.mkdir(parents=True)
-        self._orig = kling_generate.TOKEN_FILE
-        kling_generate.TOKEN_FILE = self.path
-
-    def write_text(self, *a, **kw):
-        self.path.write_text(*a, **kw)
-
-    @property
-    def parent(self):
-        return self.path.parent
-
-    def cleanup(self):
-        kling_generate.TOKEN_FILE = self._orig
-        self.tmp.cleanup()
-
-
-def _with_tmp_token_file(fn):
-    """Decorator-ish: pass a fresh _TmpToken to the test, then clean up."""
-    def wrapped():
-        h = _TmpToken()
-        try:
-            return fn(h)
-        finally:
-            h.cleanup()
-    return wrapped
-
-
-# Rebind each test to wrap with the fixture
-test_get_token_prefers_env_var = _with_tmp_token_file(test_get_token_prefers_env_var)
-test_get_token_falls_back_to_file = _with_tmp_token_file(test_get_token_falls_back_to_file)
-test_get_token_exits_when_neither_source_has_token = _with_tmp_token_file(test_get_token_exits_when_neither_source_has_token)
-test_get_gen_api_url_env_override_wins = _with_tmp_token_file(test_get_gen_api_url_env_override_wins)
-test_get_gen_api_url_reads_env_from_token_file = _with_tmp_token_file(test_get_gen_api_url_reads_env_from_token_file)
-test_get_gen_api_url_defaults_to_prod_when_no_file = _with_tmp_token_file(test_get_gen_api_url_defaults_to_prod_when_no_file)
-
-
-TESTS = [
-    ("auth_header adds Bearer prefix", test_auth_header_adds_bearer_prefix),
-    ("auth_header preserves Bearer", test_auth_header_preserves_existing_bearer),
-    ("auth_header case-insensitive on prefix", test_auth_header_is_case_insensitive_on_existing_prefix),
-    ("get_token: env wins over file", test_get_token_prefers_env_var),
-    ("get_token: falls back to token.json", test_get_token_falls_back_to_file),
-    ("get_token: exits 1 when neither source", test_get_token_exits_when_neither_source_has_token),
-    ("get_gen_api_url: env override wins", test_get_gen_api_url_env_override_wins),
-    ("get_gen_api_url: trims trailing slash", test_get_gen_api_url_trims_trailing_slash),
-    ("get_gen_api_url: reads env from token.json", test_get_gen_api_url_reads_env_from_token_file),
-    ("get_gen_api_url: defaults to prod", test_get_gen_api_url_defaults_to_prod_when_no_file),
-]
-
-
-def main() -> int:
-    failed = 0
-    for name, fn in TESTS:
-        try:
-            fn()
-            print(f"PASS  {name}")
-        except AssertionError as e:
-            failed += 1
-            print(f"FAIL  {name}: {e}")
-        except Exception as e:
-            failed += 1
-            print(f"ERROR {name}: {type(e).__name__}: {e}")
-    print()
-    print(f"{len(TESTS) - failed}/{len(TESTS)} passed")
-    return 0 if failed == 0 else 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/.claude/skills/video-clone/scripts/preflight.py

@@ -1,102 +0,0 @@
-"""Pre-flight environment check for the video-clone skill.
-
-Verifies the external dependencies the executor scripts will need:
-    - `gen` CLI       — gen image / gen video (routed through generation backend)
-    - `ffmpeg` / `ffprobe`
-    - Optima auth     — either OPTIMA_TOKEN env var or ~/.optima/token.json
-                        (matches @optima-chat/gen-cli convention)
-    - Python >= 3.10
-
-Exits 0 if all checks pass, 1 otherwise. On failure, prints a human-readable
-list of missing items and how to fix each one.
-
-This script is safe to run any time — it only reads env and probes binaries.
-No state, no side effects.
-"""
-from __future__ import annotations
-
-import json
-import os
-import shutil
-import subprocess
-import sys
-from pathlib import Path
-
-TOKEN_FILE = Path.home() / ".optima" / "token.json"
-
-
-def _check_binary(name: str, fix_hint: str) -> tuple[bool, str]:
-    path = shutil.which(name)
-    if path is None:
-        return False, f"{name}: NOT FOUND. {fix_hint}"
-    # probe --version for extra confidence (non-blocking if version flag missing)
-    try:
-        r = subprocess.run(
-            [name, "--version"], capture_output=True, text=True, timeout=5
-        )
-        head = (r.stdout or r.stderr).splitlines()[0] if (r.stdout or r.stderr) else ""
-    except Exception:
-        head = ""
-    return True, f"{name}: OK ({path}) {head}".strip()
-
-
-def _check_optima_auth() -> tuple[bool, str]:
-    """Token comes from OPTIMA_TOKEN env var OR ~/.optima/token.json (gen-cli convention)."""
-    if os.environ.get("OPTIMA_TOKEN"):
-        return True, "Optima token: OK (source=env OPTIMA_TOKEN)"
-    if TOKEN_FILE.is_file():
-        try:
-            data = json.loads(TOKEN_FILE.read_text(encoding="utf-8"))
-            if data.get("access_token"):
-                env = data.get("env", "prod")
-                return True, f"Optima token: OK (source={TOKEN_FILE}, env={env})"
-        except (OSError, json.JSONDecodeError):
-            pass
-    return (
-        False,
-        f"Optima token: NOT FOUND. Run `optima login` or set OPTIMA_TOKEN env var.",
-    )
-
-
-def _check_python() -> tuple[bool, str]:
-    v = sys.version_info
-    ok = (v.major, v.minor) >= (3, 10)
-    msg = f"python: {v.major}.{v.minor}.{v.micro}"
-    if not ok:
-        msg += " — NEED >= 3.10"
-    return ok, msg + (" OK" if ok else "")
-
-
-CHECKS = [
-    lambda: _check_python(),
-    lambda: _check_binary(
-        "gen",
-        "Install the gen CLI and ensure it is on PATH. (gen image / gen video)",
-    ),
-    lambda: _check_binary("ffmpeg", "Install ffmpeg and ensure it is on PATH."),
-    lambda: _check_binary("ffprobe", "Install ffmpeg (bundles ffprobe)."),
-    lambda: _check_optima_auth(),
-]
-
-
-def main() -> int:
-    results = [check() for check in CHECKS]
-    missing = [msg for ok, msg in results if not ok]
-    passing = [msg for ok, msg in results if ok]
-
-    print("== video-clone preflight ==")
-    for msg in passing:
-        print(f"  [OK]    {msg}")
-    for msg in missing:
-        print(f"  [FAIL]  {msg}")
-    print()
-
-    if missing:
-        print(f"{len(missing)} check(s) failed. Fix the above and re-run.")
-        return 1
-    print("All checks passed.")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/.claude/skills/video-clone/scripts/preview.py

@@ -1,208 +0,0 @@
-"""Phase 4: collect all prep artifacts into one preview_v{N}.md.
-
-Usage:
-    python scripts/preview.py --project <name>
-
-Behavior:
-    - Reads phase.json (must exist).
-    - For video_clone tasks, requires:
-        source/analysis_v*.json
-        frames/extract_v*/grid.jpg
-        prompt.md (non-empty)
-        frames/frame_v*.png (edited first frame)
-    - For video_gen tasks, only requires prompt.md.
-    - cost.json is optional; missing → "TBD" in cost section, no error.
-    - Renders a six-section markdown to preview_v{N}.md and stdout.
-    - If any required artifact is missing, exits 1 with a stderr listing
-      of missing items WITHOUT writing preview_v{N}.md. The file's
-      existence is the atomic signal that preview succeeded.
-    - Does NOT depend on _gate (preview neither reads nor writes gates).
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import sys
-from datetime import datetime, timezone
-from pathlib import Path
-
-from _project import resolve_project, next_version, append_log
-
-
-def _latest(dir_path: Path, prefix: str, suffix: str) -> Path | None:
-    """Return the highest-version file matching <prefix>v<N><suffix>, or None."""
-    if not dir_path.is_dir():
-        return None
-    candidates = sorted(
-        dir_path.glob(f"{prefix}v*{suffix}"),
-        key=lambda p: int(p.stem.removeprefix(prefix).lstrip("v") or "0"),
-    )
-    return candidates[-1] if candidates else None
-
-
-def _latest_extract_dir(frames_dir: Path) -> Path | None:
-    if not frames_dir.is_dir():
-        return None
-    extracts = sorted(
-        [p for p in frames_dir.iterdir() if p.is_dir() and p.name.startswith("extract_v")],
-        key=lambda p: int(p.name.removeprefix("extract_v") or "0"),
-    )
-    return extracts[-1] if extracts else None
-
-
-def _section_plan(state: dict, analysis: dict | None, cost: dict | None) -> str:
-    has_audio = analysis.get("has_audio") if analysis else None
-    audio_mode = "含音频" if has_audio else "静音" if has_audio is False else "TBD"
-    if analysis:
-        meta = (
-            f"<{state.get('project','?')}> "
-            f"({analysis.get('duration_s','?')}s, "
-            f"{analysis.get('width','?')}x{analysis.get('height','?')}, "
-            f"{analysis.get('fps','?')}fps, "
-            f"has_audio={analysis.get('has_audio','?')})"
-        )
-    else:
-        meta = "(纯生成任务，无源视频)"
-    cost_line = "TBD"
-    duration_line = "TBD"
-    if cost:
-        cost_line = f"~${cost.get('estimate_usd', '?')}"
-        if cost.get("based_on"):
-            duration_line = f"({cost['based_on']})"
-    return (
-        f"## 1. 技术方案\n"
-        f"**任务类型**: {state.get('task_type','?')}\n"
-        f"**源视频**: {meta}\n"
-        f"**生成模式**: {audio_mode}\n"
-        f"**预估成本**: {cost_line}\n"
-        f"**预估说明**: {duration_line}\n"
-    )
-
-
-def _section_analysis(analysis: dict | None) -> str:
-    if not analysis:
-        return "## 2. 源视频分析\n(纯生成任务，无源视频)\n"
-    return (
-        f"## 2. 源视频分析\n"
-        f"- 时长: {analysis.get('duration_s','?')}s\n"
-        f"- 分辨率: {analysis.get('width','?')}x{analysis.get('height','?')}\n"
-        f"- 片段数: {analysis.get('segments','?')} ({analysis.get('classification','?')})\n"
-        f"- 场景切点: {analysis.get('scene_cuts',[])}\n"
-        f"- 含音频: {analysis.get('has_audio','?')}\n"
-    )
-
-
-def _section_grid(grid_path: Path | None) -> str:
-    if grid_path is None:
-        return "## 3. 帧网格\n**MISSING: 没有 extract_v*/grid.jpg**\n"
-    return f"## 3. 帧网格\n路径: {grid_path.relative_to(grid_path.parents[2])}\n"
-
-
-def _section_prompt(prompt_text: str | None) -> str:
-    if prompt_text is None:
-        return "## 4. Motion Prompt\n**MISSING: prompt.md 不存在或为空**\n"
-    return f"## 4. Motion Prompt\n```\n{prompt_text}\n```\n"
-
-
-def _section_frame(frame_path: Path | None, task_type: str) -> str:
-    if task_type == "video_gen":
-        return "## 5. 编辑后首帧\n(纯生成任务，跳过)\n"
-    if frame_path is None:
-        return "## 5. 编辑后首帧\n**MISSING: 没有 frame_v*.png**\n"
-    return f"## 5. 编辑后首帧\n路径: {frame_path.relative_to(frame_path.parents[2])}\n"
-
-
-def _section_next_step(project: str, frame_path: Path | None) -> str:
-    frame_arg = (
-        str(frame_path.relative_to(frame_path.parents[2]))
-        if frame_path else "frames/frame_v*.png"
-    )
-    return (
-        f"## 6. 下一步\n"
-        f"确认无误后运行：\n"
-        f"    python scripts/confirm.py --project {project} --quote \"<你的原话>\"\n"
-        f"然后跑：\n"
-        f"    python scripts/kling_generate.py --project {project} --frame {frame_arg}\n"
-        f"    （或 gen_video.py，如果不需要音频）\n"
-    )
-
-
-def main() -> int:
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--project", required=True)
-    args = ap.parse_args()
-
-    project_dir = resolve_project(args.project)
-    state_path = project_dir / ".state" / "phase.json"
-    if not state_path.is_file():
-        print(f"ERROR: state file not found at {state_path}", file=sys.stderr)
-        return 1
-    state = json.loads(state_path.read_text(encoding="utf-8"))
-    task_type = state.get("task_type", "video_clone")
-
-    # Collect artifacts (None when missing)
-    analysis_path = _latest(project_dir / "source", "analysis_", ".json")
-    analysis = json.loads(analysis_path.read_text(encoding="utf-8")) if analysis_path else None
-
-    extract_dir = _latest_extract_dir(project_dir / "frames")
-    grid_path = (extract_dir / "grid.jpg") if extract_dir and (extract_dir / "grid.jpg").exists() else None
-
-    prompt_path = project_dir / "prompt.md"
-    prompt_text = prompt_path.read_text(encoding="utf-8").strip() if prompt_path.is_file() else None
-
-    frame_path = _latest(project_dir / "frames", "frame_", ".png")
-
-    cost_path = project_dir / "cost.json"
-    cost = json.loads(cost_path.read_text(encoding="utf-8")) if cost_path.is_file() else None
-
-    # Determine missing required artifacts. Atomic behavior: if anything
-    # is missing, we exit 1 WITHOUT writing a preview file.
-    missing: list[str] = []
-    if task_type == "video_clone":
-        if analysis is None:
-            missing.append("source/analysis_v*.json")
-        if grid_path is None:
-            missing.append("frames/extract_v*/grid.jpg")
-        if frame_path is None:
-            missing.append("frames/frame_v*.png")
-    if not prompt_text:
-        missing.append("prompt.md (non-empty)")
-
-    if missing:
-        bullets = "\n".join(f"  - {m}" for m in missing)
-        print(
-            f"ERROR: preview is incomplete. Missing artifacts:\n"
-            f"{bullets}\n"
-            f"Run the missing prep steps before retrying preview.py.",
-            file=sys.stderr,
-        )
-        return 1
-
-    # All artifacts present — render and write atomically.
-    md = (
-        f"# Preview: {args.project}\n"
-        f"Generated: {datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ')}\n\n"
-        + _section_plan(state, analysis, cost)
-        + "\n"
-        + _section_analysis(analysis)
-        + "\n"
-        + _section_grid(grid_path)
-        + "\n"
-        + _section_prompt(prompt_text)
-        + "\n"
-        + _section_frame(frame_path, task_type)
-        + "\n"
-        + _section_next_step(args.project, frame_path)
-    )
-
-    out = next_version(project_dir, "preview_", ".md")
-    out.write_text(md, encoding="utf-8")
-    print(md)
-    print(f"\nWrote: {out}")
-    append_log(project_dir, f"preview_generated → {out.name}")
-
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/.claude/skills/video-clone/scripts/preview_test.py

@@ -1,169 +0,0 @@
-"""Tests for preview.py — Phase 4 artifact collection."""
-from __future__ import annotations
-
-import json
-import os
-import subprocess
-import sys
-import tempfile
-from pathlib import Path
-
-SCRIPTS_DIR = Path(__file__).parent
-SKILL_ROOT = SCRIPTS_DIR.parent
-
-
-def _make_project(tmp: Path, task_type: str = "video_clone") -> Path:
-    proj = tmp / "video-clone" / "test-proj"
-    for sub in ("source", "frames", "videos", ".state"):
-        (proj / sub).mkdir(parents=True)
-    state = {
-        "schema_version": 1,
-        "project": "test-proj",
-        "task_type": task_type,
-        "created_at": "2025-01-01T00:00:00Z",
-        "current_phase": 0,
-        "gates": {
-            "preview_confirmed": {"status": False, "confirmed_at": None, "user_quote": None}
-        },
-        "history": [],
-    }
-    (proj / ".state" / "phase.json").write_text(
-        json.dumps(state, indent=2), encoding="utf-8"
-    )
-    return proj
-
-
-def _run(tmp: Path, extra_args: list[str] | None = None) -> subprocess.CompletedProcess:
-    env = os.environ.copy()
-    env["GEN_OUTPUT_ROOT"] = str(tmp)
-    cmd = [sys.executable, str(SCRIPTS_DIR / "preview.py"), "--project", "test-proj"]
-    if extra_args:
-        cmd += extra_args
-    return subprocess.run(cmd, capture_output=True, text=True, env=env)
-
-
-def _add_analysis(proj: Path) -> None:
-    analysis = {
-        "duration_s": 10,
-        "width": 1280,
-        "height": 720,
-        "fps": 30.0,
-        "has_audio": False,
-        "segments": 1,
-        "classification": "single",
-        "scene_cuts": [],
-    }
-    (proj / "source" / "analysis_v1.json").write_text(
-        json.dumps(analysis), encoding="utf-8"
-    )
-
-
-def _add_grid(proj: Path) -> None:
-    extract = proj / "frames" / "extract_v1"
-    extract.mkdir(parents=True, exist_ok=True)
-    (extract / "grid.jpg").write_bytes(b"\xff\xd8\xff\xe0dummy")
-
-
-def _add_prompt(proj: Path) -> None:
-    (proj / "prompt.md").write_text("A person walking.", encoding="utf-8")
-
-
-def _add_frame(proj: Path) -> None:
-    (proj / "frames" / "frame_v1.png").write_bytes(b"\x89PNG\r\ndummy")
-
-
-def test_preview_full_artifacts_writes_v1():
-    with tempfile.TemporaryDirectory() as td:
-        tmp = Path(td)
-        proj = _make_project(tmp)
-        _add_analysis(proj)
-        _add_grid(proj)
-        _add_prompt(proj)
-        _add_frame(proj)
-
-        result = _run(tmp)
-        assert result.returncode == 0, f"Expected 0 but got {result.returncode}\nstderr: {result.stderr}"
-        out_file = proj / "preview_v1.md"
-        assert out_file.is_file(), "preview_v1.md should be written"
-        content = out_file.read_text(encoding="utf-8")
-        assert "# Preview: test-proj" in content
-        assert "## 1. 技术方案" in content
-        assert "## 4. Motion Prompt" in content
-        assert "A person walking." in content
-    print("PASS test_preview_full_artifacts_writes_v1")
-
-
-def test_preview_missing_prompt_does_not_write_file_and_exits_one():
-    with tempfile.TemporaryDirectory() as td:
-        tmp = Path(td)
-        proj = _make_project(tmp)
-        _add_analysis(proj)
-        _add_grid(proj)
-        # NO prompt
-        _add_frame(proj)
-
-        result = _run(tmp)
-        assert result.returncode == 1, f"Expected 1 but got {result.returncode}"
-        assert "prompt.md" in result.stderr
-        out_file = proj / "preview_v1.md"
-        assert not out_file.exists(), "preview file must NOT be written on failure"
-    print("PASS test_preview_missing_prompt_does_not_write_file_and_exits_one")
-
-
-def test_preview_missing_cost_json_uses_tbd():
-    with tempfile.TemporaryDirectory() as td:
-        tmp = Path(td)
-        proj = _make_project(tmp)
-        _add_analysis(proj)
-        _add_grid(proj)
-        _add_prompt(proj)
-        _add_frame(proj)
-        # No cost.json
-
-        result = _run(tmp)
-        assert result.returncode == 0, f"stderr: {result.stderr}"
-        content = (proj / "preview_v1.md").read_text(encoding="utf-8")
-        assert "TBD" in content
-    print("PASS test_preview_missing_cost_json_uses_tbd")
-
-
-def test_preview_rerun_creates_v2():
-    with tempfile.TemporaryDirectory() as td:
-        tmp = Path(td)
-        proj = _make_project(tmp)
-        _add_analysis(proj)
-        _add_grid(proj)
-        _add_prompt(proj)
-        _add_frame(proj)
-
-        r1 = _run(tmp)
-        assert r1.returncode == 0
-        assert (proj / "preview_v1.md").is_file()
-
-        r2 = _run(tmp)
-        assert r2.returncode == 0
-        assert (proj / "preview_v2.md").is_file()
-    print("PASS test_preview_rerun_creates_v2")
-
-
-def test_preview_video_gen_only_needs_prompt():
-    with tempfile.TemporaryDirectory() as td:
-        tmp = Path(td)
-        proj = _make_project(tmp, task_type="video_gen")
-        _add_prompt(proj)
-        # No analysis, no grid, no frame
-
-        result = _run(tmp)
-        assert result.returncode == 0, f"Expected 0 but got {result.returncode}\nstderr: {result.stderr}"
-        content = (proj / "preview_v1.md").read_text(encoding="utf-8")
-        assert "纯生成任务" in content
-    print("PASS test_preview_video_gen_only_needs_prompt")
-
-
-if __name__ == "__main__":
-    test_preview_full_artifacts_writes_v1()
-    test_preview_missing_prompt_does_not_write_file_and_exits_one()
-    test_preview_missing_cost_json_uses_tbd()
-    test_preview_rerun_creates_v2()
-    test_preview_video_gen_only_needs_prompt()
-    print("\nAll 5 preview tests passed.")