@oh-story/dsh 0.1.18 → 0.1.19

package/lib/drama/skills/short-drama-review/scripts/review_check.py

@@ -1,325 +0,0 @@
-#!/usr/bin/env python3
-"""Validate standalone review findings and their verdict summary."""
-
-from __future__ import annotations
-
-import argparse
-import json
-import re
-import sys
-from pathlib import Path
-from typing import Any, NamedTuple
-
-MINIMUM_PYTHON = (3, 9)
-if sys.version_info < MINIMUM_PYTHON:
-    raise SystemExit("review_check.py requires Python 3.9 or newer")
-
-SKILL_ROOT = Path(__file__).resolve().parents[1]
-HASH_RE = re.compile(r"[0-9a-f]{64}")
-SEVERITIES = {"fatal", "error", "warning", "note"}
-STATUSES = {"open", "closed"}
-VERDICTS = {"APPROVE", "APPROVE_WITH_NOTES", "REVISE", "PROVISIONAL"}
-DISPOSITIONS = {"keep", "post_production", "targeted_edit", "resubmit", "rewrite", "not_applicable"}
-
-
-class ValidationError(ValueError):
-    pass
-
-
-# ---------------------------------------------------------------------------
-# REFERENCE RESOLVER
-#
-# A file declares each upstream snapshot once, and every reference names the
-# declared snapshot plus the record. This skill carries its own copy so it stays
-# runnable after copying only this directory; do not import it from elsewhere.
-# ---------------------------------------------------------------------------
-
-SOURCES_RECORD_TYPE = "sources"
-SOURCES_SCHEMA_VERSION = "1.0.0"
-
-
-class ResolvedRef(NamedTuple):
-    """An upstream reference with its snapshot resolved."""
-
-    owner: str
-    artifact: str
-    record_id: str | None
-    field: str | None
-    authority: str | None
-
-
-class RefFinding(NamedTuple):
-    """A structural defect in a reference object."""
-
-    code: str
-    location: str
-    detail: str
-
-
-def load_sources(document: Any) -> dict[str, dict[str, Any]]:
-    """Return the ``sources`` declaration of a parsed file, or ``{}`` if absent.
-
-    Accepts a parsed ``.json`` document (a dict) or the parsed record list of a
-    ``.jsonl`` file, whose declaration lives on the first record.
-    """
-    if isinstance(document, list):
-        document = document[0] if document else None
-    if not isinstance(document, dict):
-        return {}
-    declared = document.get("sources")
-    if not isinstance(declared, dict):
-        return {}
-    return {key: value for key, value in declared.items() if isinstance(value, dict)}
-
-
-def resolve_ref(
-    ref: Any, sources: dict[str, dict[str, Any]], location: str
-) -> tuple[ResolvedRef | None, RefFinding | None]:
-    """Resolve a reference object written in either the compact or expanded form."""
-    if not isinstance(ref, dict):
-        return None, RefFinding("REF_IS_NOT_AN_OBJECT", location, f"got {type(ref).__name__}")
-    src = ref.get("src")
-    if isinstance(src, str):
-        entry = sources.get(src)
-        if entry is None:
-            return None, RefFinding(
-                "REF_SRC_IS_NOT_DECLARED", location, f"src {src!r} has no sources entry"
-            )
-        owner, artifact = entry.get("owner"), entry.get("artifact")
-        if not (isinstance(owner, str) and isinstance(artifact, str)):
-            return None, RefFinding(
-                "SOURCE_ENTRY_IS_INCOMPLETE", location, f"sources[{src!r}] needs owner/artifact"
-            )
-    elif all(isinstance(ref.get(key), str) for key in ("owner", "artifact")):
-        owner, artifact = ref["owner"], ref["artifact"]
-    else:
-        return None, RefFinding(
-            "REF_HAS_NO_UPSTREAM_BINDING", location, "needs src, or owner+artifact"
-        )
-    optional = {
-        key: ref[key] for key in ("record_id", "field", "authority") if isinstance(ref.get(key), str)
-    }
-    return (
-        ResolvedRef(
-        owner,
-        artifact,
-            optional.get("record_id"),
-            optional.get("field"),
-            optional.get("authority"),
-        ),
-        None,
-    )
-
-
-# ---------------------------------------------------------------------------
-# END REFERENCE RESOLVER
-# ---------------------------------------------------------------------------
-
-
-def split_sources(
-    records: list[dict[str, Any]],
-) -> tuple[dict[str, dict[str, Any]], list[dict[str, Any]]]:
-    """Separate a leading ``sources`` header record from the payload records."""
-    first = records[0] if records else None
-    if isinstance(first, dict) and first.get("record_type") == SOURCES_RECORD_TYPE:
-        return load_sources(first), records[1:]
-    return {}, records
-
-
-def resolve_input(value: str | Path) -> Path:
-    path = Path(value).expanduser()
-    if path.exists() or path.is_absolute():
-        return path
-    return SKILL_ROOT / path
-
-
-def load_jsonl(value: str | Path) -> list[dict[str, Any]]:
-    path = resolve_input(value)
-    records: list[dict[str, Any]] = []
-    for number, line in enumerate(path.read_text(encoding="utf-8").splitlines(), 1):
-        if not line.strip():
-            continue
-        try:
-            record = json.loads(line)
-        except json.JSONDecodeError as exc:
-            raise ValidationError(f"{path}:{number}: invalid JSON") from exc
-        if not isinstance(record, dict):
-            raise ValidationError(f"{path}:{number}: record must be an object")
-        records.append(record)
-    return records
-
-
-def load_object(value: str | Path) -> dict[str, Any]:
-    path = resolve_input(value)
-    try:
-        document = json.loads(path.read_text(encoding="utf-8"))
-    except json.JSONDecodeError as exc:
-        raise ValidationError(f"{path}: invalid JSON") from exc
-    if not isinstance(document, dict):
-        raise ValidationError(f"{path}: verdict must be an object")
-    return document
-
-
-def text(record: dict[str, Any], key: str, label: str, *, empty_ok: bool = False) -> str:
-    value = record.get(key)
-    if not isinstance(value, str) or (not empty_ok and not value.strip()):
-        qualifier = "text" if empty_ok else "non-empty text"
-        raise ValidationError(f"{label}: {key} must be {qualifier}")
-    return value
-
-
-def validate_ref(
-    value: Any,
-    label: str,
-    sources: dict[str, dict[str, Any]],
-    *,
-    record_optional: bool = False,
-) -> None:
-    resolved, defect = resolve_ref(value, sources, label)
-    if resolved is None:
-        detail = f"{defect.code}: {defect.detail}" if defect is not None else "unresolvable reference"
-        raise ValidationError(f"{label}: {detail}")
-    for key, field_value in (("owner", resolved.owner), ("artifact", resolved.artifact)):
-        if not field_value.strip():
-            raise ValidationError(f"{label}: {key} must be non-empty text")
-    if not record_optional and not resolved.record_id and not resolved.field:
-        raise ValidationError(f"{label}: record_id or field is required")
-
-
-def validate_findings(records: list[dict[str, Any]]) -> dict[str, dict[str, Any]]:
-    sources, findings = split_sources(records)
-    indexed: dict[str, dict[str, Any]] = {}
-    for index, finding in enumerate(findings, 1):
-        label = f"finding[{index}]"
-        finding_id = text(finding, "finding_id", label)
-        if finding_id in indexed:
-            raise ValidationError(f"{label}: duplicate finding_id {finding_id}")
-        indexed[finding_id] = finding
-        for key in (
-            "diagnostic_code",
-            "scope",
-            "classification",
-            "enforcer",
-            "evidence",
-            "impact",
-            "disposition_rationale",
-            "owner_skill",
-        ):
-            text(finding, key, label)
-        text(finding, "required_change", label, empty_ok=True)
-        if finding.get("severity") not in SEVERITIES:
-            raise ValidationError(f"{label}: invalid severity")
-        if finding.get("status") not in STATUSES:
-            raise ValidationError(f"{label}: invalid status")
-        disposition = finding.get("disposition")
-        if disposition not in DISPOSITIONS:
-            raise ValidationError(
-                f"{label}: invalid disposition {disposition!r}; "
-                f"use one of {', '.join(sorted(DISPOSITIONS))}"
-            )
-        # A finding that blocks delivery has to say what to do about it,
-        # whatever its disposition. REV-11 exempts dispositions that call for no
-        # change, and routes every non-calibration finding to `not_applicable`
-        # -- which is one of the exempt three. So the common case was exempt,
-        # and an open `fatal` that told its owner nothing was stamped valid.
-        # REV-02 requires the fix; this is where that requirement lands.
-        if (
-            finding.get("status") == "open"
-            and finding.get("severity") in {"fatal", "error"}
-            and not str(finding.get("required_change") or "").strip()
-        ):
-            raise ValidationError(
-                f"{label}: an open {finding.get('severity')} finding blocks "
-                f"delivery and must state its required change"
-            )
-        if disposition in {"targeted_edit", "resubmit", "rewrite"} and not finding["required_change"].strip():
-            raise ValidationError(f"{label}: disposition requires required_change")
-        refs = finding.get("evidence_refs")
-        if not isinstance(refs, list) or not refs:
-            raise ValidationError(f"{label}: evidence_refs must be a non-empty list")
-        for ref_index, ref in enumerate(refs, 1):
-            validate_ref(ref, f"{label}.evidence_refs[{ref_index}]", sources)
-        validate_ref(finding.get("target_ref"), f"{label}.target_ref", sources)
-    return indexed
-
-
-def validate_records(records: list[dict[str, Any]], verdict: dict[str, Any]) -> dict[str, Any]:
-    indexed = validate_findings(records)
-    _, findings = split_sources(records)
-    verdict_sources = load_sources(verdict)
-    text(verdict, "review_id", "verdict")
-    scopes = verdict.get("scope")
-    if not isinstance(scopes, list) or not scopes or any(not isinstance(item, str) or not item for item in scopes):
-        raise ValidationError("verdict: scope must be a non-empty text list")
-    artifacts = verdict.get("reviewed_artifacts")
-    if not isinstance(artifacts, list) or not artifacts:
-        raise ValidationError("verdict: reviewed_artifacts must be non-empty")
-    for index, artifact in enumerate(artifacts, 1):
-        validate_ref(
-            artifact,
-            f"verdict.reviewed_artifacts[{index}]",
-            verdict_sources,
-            record_optional=True,
-        )
-    validate_ref(
-        verdict.get("findings_ref"), "verdict.findings_ref", verdict_sources, record_optional=True
-    )
-    if verdict.get("review_method") not in {"uninvolved_reviewer", "self_check"}:
-        raise ValidationError("verdict: review_method must be uninvolved_reviewer or self_check")
-    text(verdict, "reviewer", "verdict")
-    if verdict.get("verdict") not in VERDICTS:
-        raise ValidationError("verdict: invalid verdict")
-
-    blockers = sorted(
-        finding_id
-        for finding_id, finding in indexed.items()
-        if finding["status"] == "open" and finding["severity"] in {"fatal", "error"}
-    )
-    declared = verdict.get("blocking_findings")
-    if not isinstance(declared, list) or sorted(declared) != blockers:
-        raise ValidationError("verdict: blocking_findings must equal the open fatal/error findings")
-    if verdict.get("open_blocker_count") != len(blockers):
-        raise ValidationError("verdict: open_blocker_count does not match blocking_findings")
-    decision = verdict["verdict"]
-    if blockers and decision != "REVISE":
-        raise ValidationError("verdict: open blockers require REVISE")
-    if not blockers and decision == "REVISE":
-        raise ValidationError("verdict: REVISE requires an open blocker")
-
-    return {
-        "status": "valid",
-        "findings": len(findings),
-        "open_blockers": len(blockers),
-        "verdict": decision,
-        # `evidence_declaration`: each evidence reference names a snapshot the
-        # findings file declares. The records it points at live in artifacts
-        # this checker never opens.
-        "checks": [
-            "finding_shape",
-            "evidence_declaration",
-            "blocker_count",
-            "verdict_consistency",
-        ],
-    }
-
-
-def validate_files(findings: str | Path, verdict: str | Path) -> dict[str, Any]:
-    return validate_records(load_jsonl(findings), load_object(verdict))
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--findings", required=True)
-    parser.add_argument("--verdict", required=True)
-    args = parser.parse_args()
-    try:
-        result = validate_files(args.findings, args.verdict)
-    except (OSError, ValidationError) as exc:
-        print(f"review check failed: {exc}", file=sys.stderr)
-        return 2
-    print(json.dumps(result, ensure_ascii=True, indent=2))
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/lib/drama/skills/short-drama-review/scripts/selftest.py

@@ -1,87 +0,0 @@
-#!/usr/bin/env python3
-"""Offline self-test for the standalone review checker."""
-
-from __future__ import annotations
-
-import copy
-import sys
-
-from review_check import SKILL_ROOT, ValidationError, load_jsonl, load_object, validate_records
-
-MINIMUM_PYTHON = (3, 9)
-if sys.version_info < MINIMUM_PYTHON:
-    raise SystemExit("selftest.py requires Python 3.9 or newer")
-
-
-def require(condition: bool, message: str) -> None:
-    if not condition:
-        raise AssertionError(message)
-
-
-def fail(findings: list[dict], verdict: dict, marker: str) -> None:
-    try:
-        validate_records(findings, verdict)
-    except ValidationError as exc:
-        require(marker in str(exc), f"expected {marker!r}, got {exc!s}")
-    else:
-        raise AssertionError(f"expected failure containing {marker!r}")
-
-
-def expand(records: list[dict], verdict: dict) -> tuple[list[dict], dict]:
-    """Rewrite the fixture into the expanded reference form.
-
-    Projects written before the ``sources`` declaration carry that form on disk,
-    so the checker keeps resolving it.
-    """
-    sources = records[0]["sources"]
-    expanded_findings = [copy.deepcopy(record) for record in records[1:]]
-    for finding in expanded_findings:
-        for ref in [*finding["evidence_refs"], finding["target_ref"]]:
-            ref.update(sources[ref.pop("src")])
-    expanded_verdict = copy.deepcopy(verdict)
-    verdict_sources = expanded_verdict.pop("sources")
-    for ref in [*expanded_verdict["reviewed_artifacts"], expanded_verdict["findings_ref"]]:
-        ref.update(verdict_sources[ref.pop("src")])
-    return expanded_findings, expanded_verdict
-
-
-def main() -> int:
-    findings = load_jsonl(SKILL_ROOT / "examples/minimal-findings.jsonl")
-    verdict = load_object(SKILL_ROOT / "examples/minimal-verdict.json")
-    result = validate_records(findings, verdict)
-    require(
-        result["open_blockers"] == 1 and result["verdict"] == "REVISE",
-        "valid fixture verdict",
-    )
-    require(result["findings"] == 1, "the sources header is not counted as a finding")
-
-    expanded_findings, expanded_verdict = expand(findings, verdict)
-    expanded = validate_records(expanded_findings, expanded_verdict)
-    require(expanded == result, "expanded references validate to the same result")
-
-    undeclared = copy.deepcopy(findings)
-    undeclared[1]["target_ref"] = {"src": "unknown-source", "record_id": "SC001"}
-    fail(undeclared, verdict, "REF_SRC_IS_NOT_DECLARED")
-
-    unbound = copy.deepcopy(findings)
-    unbound[1]["evidence_refs"][0] = {"role": "source", "record_id": "SC001-A01"}
-    fail(unbound, verdict, "REF_HAS_NO_UPSTREAM_BINDING")
-
-    wrong_count = copy.deepcopy(verdict)
-    wrong_count["open_blocker_count"] = 0
-    fail(findings, wrong_count, "open_blocker_count")
-
-    false_approval = copy.deepcopy(verdict)
-    false_approval["verdict"] = "APPROVE"
-    fail(findings, false_approval, "open blockers require REVISE")
-
-    broken_finding = copy.deepcopy(findings)
-    broken_finding[1]["evidence_refs"] = []
-    fail(broken_finding, verdict, "evidence_refs")
-
-    print("8 self-tests passed")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/lib/drama/skills/short-drama-storyboard/assets/coverage-audition.example.jsonl

@@ -1,2 +0,0 @@
-{"record_type":"sources","schema_version":"1.0.0","sources":{"<characters-or-props>":{"owner":"short-drama-assets","artifact":"设定集/<characters-or-props>.jsonl"},"<looks-or-prop-states>":{"owner":"short-drama-assets","artifact":"设定集/<looks-or-prop-states>.jsonl"},"location-views":{"owner":"short-drama-assets","artifact":"设定集/location-views.jsonl"},"locations":{"owner":"short-drama-assets","artifact":"设定集/locations.jsonl"},"screenplay-index":{"owner":"short-drama-write","artifact":"剧集/EP001/screenplay-index.jsonl"},"short-drama":{"owner":"creator","artifact":"short-drama.json"}}}
-{"example_only":true,"audition_id":"AUD-EP001-SC001","status":"candidate","scene_ref":{"src":"screenplay-index","record_id":"BLK-EP001-SC001-H01","field":"/scene_id"},"visual_direction_ref":{"src":"short-drama","field":"/creator_authority/visual_direction"},"production_profile_ref":{"src":"short-drama","field":"/creator_authority/production_profile"},"location_binding":{"identity_ref":{"src":"locations","record_id":"LOC-<id>"},"variant_ref":{"src":"location-views","record_id":"VIEW-<id>"}},"asset_bindings":[{"identity_ref":{"src":"<characters-or-props>","record_id":"CHAR/PROP-<id>"},"variant_ref":{"src":"<looks-or-prop-states>","record_id":"LOOK/PSTATE-<id>"},"role":"<performance_owner/evidence/observer>"}],"reason_for_audition":"<为什么导演选择会显著改变体验>","approaches":[{"approach_id":"APPROACH-A","directing_hypothesis":"<表演/证据/主观/空间/声音等真正不同的命题>","audience_knowledge":"<何时知道什么>","audience_alignment":"<站在哪个人物一边>","performance_space":"<谁拥有主要表演通道，谁只承担差异化反应>","strongest_image":"<最强画面>","landing":"<最终落点>","tradeoffs":{"preserves":["<保住什么>"],"risks_losing":["<可能丢什么>"],"production_fit":"<与已接受制作形态怎样相容或冲突>"}}],"comparison_summary":"<真正分歧与不可同时获得的收益>"}

package/lib/drama/skills/short-drama-storyboard/assets/revision-lineage.fragment.json

@@ -1,12 +0,0 @@
-{
-  "revision_lineage": {
-    "change": "split | merge | restore",
-    "predecessor_shot_ids": [
-      "SHOT-<same-file-prior-id>"
-    ],
-    "retired_shot_ids": [
-      "SHOT-<same-file-retired-id>"
-    ],
-    "reason": "<导演职责怎样被拆开、合并或恢复>"
-  }
-}

package/lib/drama/skills/short-drama-storyboard/assets/scene-visual-plan.example.jsonl

@@ -1,2 +0,0 @@
-{"record_type":"sources","schema_version":"1.0.0","sources":{"<characters-or-props>":{"owner":"short-drama-assets","artifact":"设定集/<characters-or-props>.jsonl"},"<looks-or-prop-states>":{"owner":"short-drama-assets","artifact":"设定集/<looks-or-prop-states>.jsonl"},"coverage-audition":{"owner":"short-drama-storyboard","artifact":"剧集/EP001/storyboard/coverage-auditions/SC001.jsonl"},"creator-decision":{"owner":"creator","artifact":"创作者决策/EP001-coverage-audition-SC001.json"},"location-views":{"owner":"short-drama-assets","artifact":"设定集/location-views.jsonl"},"locations":{"owner":"short-drama-assets","artifact":"设定集/locations.jsonl"},"screenplay-index":{"owner":"short-drama-write","artifact":"剧集/EP001/screenplay-index.jsonl"},"short-drama":{"owner":"creator","artifact":"short-drama.json"}}}
-{"example_only":true,"plan_id":"SVP-EP001-SC001","status":"candidate","scene_ref":{"src":"screenplay-index","record_id":"BLK-EP001-SC001-H01","field":"/scene_id"},"source_block_refs":[{"src":"screenplay-index","record_id":"BLK-EP001-SC001-A01"}],"visual_direction_ref":{"src":"short-drama","field":"/creator_authority/visual_direction"},"production_profile_ref":{"src":"short-drama","field":"/creator_authority/production_profile"},"location_binding":{"identity_ref":{"src":"locations","record_id":"LOC-<id>"},"variant_ref":{"src":"location-views","record_id":"VIEW-<id>"}},"asset_bindings":[{"identity_ref":{"src":"<characters-or-props>","record_id":"CHAR/PROP-<id>"},"variant_ref":{"src":"<looks-or-prop-states>","record_id":"LOOK/PSTATE-<id>"},"role":"<performance_owner/evidence/observer>"}],"source_audition_ref":{"src":"coverage-audition","record_id":"AUD-EP001-SC001"},"creator_selection_ref":{"src":"creator-decision","record_id":"CD-EP001-COVERAGE-AUDITION-SC001","field":"/selected_approach_id"},"dramatic_turn":"<本场不可逆的关系/信息/选择变化>","audience_alignment":{"start":"<开场站在哪一方或保持什么距离>","end":"<结束被移到哪里>"},"spatial_pressure":"<入口、距离、占位、遮挡、让路或退路怎样承载人物策略>","visual_progression":["<按注意、关系、信息、压力或节奏写推进，不预写 shot 数量>"],"camera_strategy":"<何时固定、移动、切近或停留，以及触发原因>","reveal_image":"<关键揭示怎样进入画面且服从信息权限>","reaction_landing":"<谁的选择、反应或空间后果承担结尾>","sound_strategy":{"opening_attention":"<先听见什么>","power_or_space_sound":"<代表当前空间/权力的声源>","withdrawal_or_silence":"<何时撤出/留白及对象>","return_or_distance_change":"<何时恢复或改变距离>","sound_bridge":"<与相邻场怎样连接或 none>"},"constraints":["<必须保持的剧本、资产与视觉方向事实>"],"creator_overrides":[]}

package/lib/drama/skills/short-drama-storyboard/scripts/selftest.py

@@ -1,191 +0,0 @@
-#!/usr/bin/env python3
-"""Offline self-test for storyboard bookkeeping checks."""
-
-from __future__ import annotations
-
-import copy
-import sys
-import tempfile
-from pathlib import Path
-from typing import Any
-
-from storyboard_check import (
-    check_boundary_entries,
-    check_episode_duration,
-    check_keyframe_boundaries,
-    check_screenplay_coverage,
-)
-
-MINIMUM_PYTHON = (3, 9)
-if sys.version_info < MINIMUM_PYTHON:
-    raise SystemExit("selftest.py requires Python 3.9 or newer")
-
-
-def require(condition: bool, message: str) -> None:
-    if not condition:
-        raise AssertionError(message)
-
-
-def codes(findings: list[dict[str, Any]]) -> set[Any]:
-    return {item["code"] for item in findings}
-
-
-SHOT: dict[str, Any] = {
-    "shot_id": "SHOT-001",
-    "duration_seconds": 5,
-    "start_boundary": "closed door",
-    "end_boundary": "open door",
-}
-BOUNDED_SHOT: dict[str, Any] = {
-    "shot_id": "SHOT-002",
-    "duration_seconds": 5,
-    "start_boundary": {
-        "positions": ["站在柜台东侧（与上一镜相同）"],
-        "facing": ["面向门口"],
-    },
-    "end_boundary": {"positions": ["退到门内一步"], "facing": ["面向柜台"]},
-}
-SHOTS_SOURCE: dict[str, Any] = {
-    "owner": "short-drama-storyboard",
-    "artifact": "剧集/EP001/storyboard/shots.jsonl",
-    "hash": "a" * 64,
-}
-COVERAGE: dict[str, Any] = {
-    "sources": {"shots": SHOTS_SOURCE},
-    "dispositions": [{"shot_refs": [{"src": "shots", "record_id": "SHOT-001"}]}],
-    "episode_duration": {
-        "counted_shot_ids": ["SHOT-001"],
-        "unresolved_durations": [],
-        "shot_seconds_total": 5,
-        "delta_seconds": 0,
-        "disposition": "within_creator_tolerance",
-    },
-}
-KEYFRAME_SOURCES: dict[str, Any] = {"shots": SHOTS_SOURCE}
-KEYFRAME: dict[str, Any] = {
-    "keyframe_id": "KF-001-END",
-    "boundary_role": "end",
-    "boundary_ref": {"src": "shots", "record_id": "SHOT-001", "field": "/end_boundary"},
-}
-# A reference may also carry its whole snapshot inline instead of naming a
-# sources key; the checker resolves both to the same upstream binding.
-EXPANDED_COVERAGE: dict[str, Any] = {
-    "dispositions": [
-        {"shot_refs": [{**SHOTS_SOURCE, "record_id": "SHOT-001", "authority": "accepted"}]}
-    ],
-    "episode_duration": COVERAGE["episode_duration"],
-}
-EXPANDED_KEYFRAME: dict[str, Any] = {
-    "keyframe_id": "KF-001-END",
-    "boundary_role": "end",
-    "boundary_ref": {**SHOTS_SOURCE, "record_id": "SHOT-001", "field": "/end_boundary"},
-}
-
-
-def test_screenplay_coverage_flags_gaps_and_double_claims() -> None:
-    """Every screenplay block must be claimed by exactly one shot.
-
-    Shots bind to the screenplay through the index, so coverage is measured in
-    block IDs. Measuring it in prose lines instead reported every line of a
-    correctly covered episode as unfilmed.
-    """
-    with tempfile.TemporaryDirectory() as directory:
-        index = Path(directory) / "screenplay-index.jsonl"
-        index.write_text(
-            '{"record_type":"block","block_id":"BLK-A"}\n'
-            '{"record_type":"block","block_id":"BLK-B"}\n'
-            '{"record_type":"block","block_id":"BLK-C"}\n',
-            encoding="utf-8",
-        )
-        sources = {
-            "screenplay-index": {
-                "owner": "short-drama-write",
-                "artifact": "剧集/EP001/screenplay-index.jsonl",
-            }
-        }
-        shots = [
-            {"shot_id": "SH001", "source_refs": [{"src": "screenplay-index", "record_id": "BLK-A"}]},
-            {"shot_id": "SH002", "source_refs": [{"src": "screenplay-index", "record_id": "BLK-B"}]},
-            {"shot_id": "SH003", "source_refs": [{"src": "screenplay-index", "record_id": "BLK-B"}]},
-            {"shot_id": "SH004", "source_refs": [{"src": "screenplay-index", "record_id": "BLK-Z"}]},
-        ]
-        found = {f["code"] for f in check_screenplay_coverage(shots, sources, index)}
-    require("SHT01_BLOCK_UNCLAIMED" in found, "an unfilmed block must be reported")
-    require("SHT01_BLOCK_CLAIMED_TWICE" in found, "a doubly claimed block must be reported")
-    require(
-        "SHT01_BLOCK_NOT_IN_SCREENPLAY" in found,
-        "a shot claiming an absent block must be reported",
-    )
-
-
-def test_screenplay_coverage_is_skipped_when_not_supplied() -> None:
-    require(check_screenplay_coverage([], {}, None) == [], "no index means no claim")
-
-
-def main() -> int:
-    require(check_episode_duration(COVERAGE, [SHOT], 5) == [], "valid duration")
-    require(
-        check_keyframe_boundaries([KEYFRAME], [SHOT], KEYFRAME_SOURCES) == [],
-        "valid boundary",
-    )
-    require(check_episode_duration(EXPANDED_COVERAGE, [SHOT], 5) == [], "expanded duration")
-    require(
-        check_keyframe_boundaries([EXPANDED_KEYFRAME], [SHOT], {}) == [],
-        "expanded boundary",
-    )
-
-    wrong_total = copy.deepcopy(COVERAGE)
-    wrong_total["episode_duration"]["shot_seconds_total"] = 4
-    require(
-        "SHT16_TOTAL_IS_NOT_THE_SUM" in codes(check_episode_duration(wrong_total, [SHOT], 5)),
-        "wrong duration total was not detected",
-    )
-
-    wrong_boundary = copy.deepcopy(KEYFRAME)
-    wrong_boundary["boundary_ref"]["field"] = "/start_boundary"
-    require(
-        "SHT17_BOUNDARY_REF_DISAGREES_WITH_ROLE"
-        in codes(check_keyframe_boundaries([wrong_boundary], [SHOT], KEYFRAME_SOURCES)),
-        "wrong keyframe boundary was not detected",
-    )
-
-    undeclared = copy.deepcopy(COVERAGE)
-    undeclared["sources"] = {}
-    require(
-        "REF_SRC_IS_NOT_DECLARED" in codes(check_episode_duration(undeclared, [SHOT], 5)),
-        "a src without a sources entry was not detected",
-    )
-    require(
-        "REF_SRC_IS_NOT_DECLARED"
-        in codes(check_keyframe_boundaries([KEYFRAME], [SHOT], {})),
-        "a keyframe src without a sources entry was not detected",
-    )
-
-    unbound = copy.deepcopy(COVERAGE)
-    unbound["dispositions"][0]["shot_refs"] = [{"record_id": "SHOT-001"}]
-    require(
-        "REF_HAS_NO_UPSTREAM_BINDING" in codes(check_episode_duration(unbound, [SHOT], 5)),
-        "a reference binding no snapshot was not detected",
-    )
-
-    # A boundary entry that only says "same as before" reads as written but tells
-    # the next stage nothing; an absolute fact that mentions the previous shot in
-    # passing is fine and must not be flagged.
-    require(check_boundary_entries([BOUNDED_SHOT]) == [], "absolute boundary entries")
-    relative = copy.deepcopy(BOUNDED_SHOT)
-    relative["end_boundary"]["positions"] = ["（位置不变）"]
-    require(
-        "SHT05_BOUNDARY_ENTRY_IS_A_BACK_REFERENCE"
-        in codes(check_boundary_entries([relative])),
-        "a boundary entry that only points back was not detected",
-    )
-
-    test_screenplay_coverage_flags_gaps_and_double_claims()
-    test_screenplay_coverage_is_skipped_when_not_supplied()
-
-    print("13 self-tests passed")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())