@oh-story/dsh 0.1.17 → 0.1.19

package/lib/drama/skills/short-drama-image-prompts/scripts/image_prompt_check.py

@@ -1,443 +0,0 @@
-#!/usr/bin/env python3
-"""Validate standalone image-prompt specs without generating media."""
-
-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("image_prompt_check.py requires Python 3.9 or newer")
-
-# ---------------------------------------------------------------------------
-# REFERENCE RESOLVER -- reference implementation.
-#
-# Each skill checker carries its own copy of this block. The suite has no shared
-# library on purpose: a skill must stay runnable after copying only its own
-# directory, so duplicating these few lines across skills is the correct shape.
-# Copy the block verbatim; do not import it.
-# ---------------------------------------------------------------------------
-
-SOURCES_RECORD_TYPE = "sources"
-SOURCES_SCHEMA_VERSION = "1.0.0"
-
-
-class ResolvedRef(NamedTuple):
-    """An upstream reference with its snapshot resolved, whichever form it used."""
-
-    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
-# ---------------------------------------------------------------------------
-
-SKILL_ROOT = Path(__file__).resolve().parents[1]
-HASH_RE = re.compile(r"[0-9a-f]{64}")
-# `common-recipe.md` forbids weight syntax and any one engine's control words: a
-# generic prompt that carries provider control syntax has stopped being generic.
-# This checks syntax only. Whether the prose leans on generic quality language is
-# `IMG-02`, a `craft_default` a creator may override with a reason, so it is a
-# reviewer's call citing what the description actually lacks — see
-# `common-recipe.md`, which forbids blocking delivery on a fixed word list.
-ENGINE_SYNTAX_RE = re.compile(
-    r"(?:^|[\s,，(（])--(?:ar|v|q|niji|style|no|seed|cref|sref)\b"
-    r"|::-?\d"
-    # Weight syntax is written (x:1.2); prose writes "(aperture: 1.8)" with a space.
-    r"|:[01]\.\d\s*[)）]",
-    re.IGNORECASE,
-)
-PURPOSES = {
-    "character_sheet",
-    "location_plate",
-    "prop_plate",
-    "look_state_variant",
-    "edit_delta",
-    "lookdev_frame",
-}
-VENDOR_FIELDS = {
-    "authorization",
-    "credential",
-    "credentials",
-    "model",
-    "model_id",
-    "model_name",
-    "provider",
-    "provider_id",
-    "api_key",
-    "task_id",
-    "remote_id",
-    "access_token",
-    "token",
-    "secret",
-    "password",
-}
-NORMALIZED_VENDOR_FIELDS = {re.sub(r"[^a-z0-9]", "", key) for key in VENDOR_FIELDS}
-
-
-# The source policy -> render treatment mapping from `common-recipe.md`. A
-# treatment outside its policy's row is a structural defect: the fix is a
-# creator override that changes the accepted policy, never a quiet widening here.
-ALLOWED_TREATMENTS = {
-    "exact_readable": {"readable", "postproduction"},
-    "graphic_only": {"symbolic"},
-    "no_readable_text": {"blank", "symbolic"},
-    "pending_creator_text": {"postproduction"},
-}
-
-# A blanket "no text in the image" instruction, however it is phrased. Matching
-# two literals (`no text` / `无文字`) let the reference document's own worked
-# counter-example through: `画面中不要任何文字` contains neither.
-NO_TEXT_CONSTRAINT = re.compile(
-    r"(无任何(文字|字|文本)|无文字|不要(任何)?(文字|字|文本)|不出现(任何)?(文字|字)"
-    r"|没有(任何)?(文字|字)|不含(任何)?(文字|字)|禁止(出现)?(文字|字)"
-    r"|no\s+(visible\s+)?(text|lettering|writing|words|typography)"
-    r"|without\s+(any\s+)?text|text[-\s]free)",
-    re.IGNORECASE,
-)
-
-
-class ValidationError(ValueError):
-    pass
-
-
-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) -> tuple[dict[str, dict[str, Any]], list[dict[str, Any]]]:
-    """Return the file's ``sources`` declaration and its prompt-spec records.
-
-    A leading ``{"record_type": "sources", ...}`` header declares the upstream
-    snapshots the specs point at; it is not a spec and never counts as one.
-    """
-    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}: each record must be an object")
-        records.append(record)
-    sources: dict[str, dict[str, Any]] = {}
-    if records and records[0].get("record_type") == SOURCES_RECORD_TYPE:
-        header = records.pop(0)
-        if not isinstance(header.get("sources"), dict):
-            raise ValidationError(f"{path}: the sources header must declare a sources object")
-        sources = load_sources(header)
-    if not records:
-        raise ValidationError(f"{path}: no prompt specs")
-    return sources, records
-
-
-def text(record: dict[str, Any], key: str, label: str) -> str:
-    value = record.get(key)
-    if not isinstance(value, str) or not value.strip():
-        raise ValidationError(f"{label}: {key} must be non-empty text")
-    return value
-
-
-def nonempty_list(record: dict[str, Any], key: str, label: str) -> list[Any]:
-    value = record.get(key)
-    if not isinstance(value, list) or not value:
-        raise ValidationError(f"{label}: {key} must be a non-empty list")
-    return value
-
-
-def validate_ref(
-    value: Any,
-    sources: dict[str, dict[str, Any]],
-    label: str,
-    *,
-    field_allowed: bool = True,
-) -> None:
-    if not isinstance(value, dict):
-        raise ValidationError(f"{label}: reference must be an object")
-    resolved, finding = resolve_ref(value, sources, label)
-    if finding is not None:
-        raise ValidationError(f"{label}: {finding.code}: {finding.detail}")
-    if resolved is None:
-        raise ValidationError(f"{label}: reference could not be resolved")
-    if not resolved.owner.strip() or not resolved.artifact.strip():
-        raise ValidationError(f"{label}: owner and artifact must be non-empty text")
-    if "record_id" not in value and (not field_allowed or "field" not in value):
-        raise ValidationError(f"{label}: record_id or field is required")
-
-
-def validate_reference_bindings(
-    record: dict[str, Any], sources: dict[str, dict[str, Any]], label: str
-) -> None:
-    bindings = record.get("reference_bindings", [])
-    if not isinstance(bindings, list):
-        raise ValidationError(f"{label}: reference_bindings must be a list")
-    slots: set[str] = set()
-    orders: set[int] = set()
-    for index, binding in enumerate(bindings, 1):
-        item = f"{label}.reference_bindings[{index}]"
-        if not isinstance(binding, dict):
-            raise ValidationError(f"{item}: binding must be an object")
-        slot = text(binding, "slot_id", item)
-        order = binding.get("order")
-        if slot in slots:
-            raise ValidationError(f"{item}: duplicate slot_id {slot}")
-        if not isinstance(order, int) or order < 1 or order in orders:
-            raise ValidationError(f"{item}: order must be a unique positive integer")
-        slots.add(slot)
-        orders.add(order)
-        validate_ref(binding.get("artifact_ref"), sources, f"{item}.artifact_ref")
-        text(binding, "role", item)
-        nonempty_list(binding, "may_control", item)
-        nonempty_list(binding, "must_not_control", item)
-        admission = binding.get("admission_status")
-        if admission not in {"unverified", "creator_described", "visually_inspected"}:
-            raise ValidationError(f"{item}: invalid admission_status")
-        if admission == "unverified" and not binding.get("unresolved_risks"):
-            raise ValidationError(f"{item}: unverified references need unresolved_risks")
-
-
-def vendor_field_paths(value: object, prefix: str = "") -> list[str]:
-    leaked: list[str] = []
-    if isinstance(value, dict):
-        for key, child in value.items():
-            name = str(key)
-            path = f"{prefix}.{name}" if prefix else name
-            normalized = re.sub(r"[^a-z0-9]", "", name.casefold())
-            if normalized in NORMALIZED_VENDOR_FIELDS:
-                leaked.append(path)
-            leaked.extend(vendor_field_paths(child, path))
-    elif isinstance(value, list):
-        for index, child in enumerate(value):
-            leaked.extend(vendor_field_paths(child, f"{prefix}[{index}]"))
-    return leaked
-
-
-def validate_asset_spec(
-    record: dict[str, Any], sources: dict[str, dict[str, Any]], label: str
-) -> None:
-    binding = record.get("asset_binding")
-    if not isinstance(binding, dict):
-        raise ValidationError(f"{label}: asset_binding must be an object")
-    validate_ref(binding.get("identity_ref"), sources, f"{label}.asset_binding.identity_ref")
-    validate_ref(binding.get("variant_ref"), sources, f"{label}.asset_binding.variant_ref")
-    for index, ref in enumerate(nonempty_list(record, "source_refs", label), 1):
-        validate_ref(ref, sources, f"{label}.source_refs[{index}]")
-    nonempty_list(record, "identity_or_form_anchors", label)
-
-    if record["purpose"] == "edit_delta":
-        edit = record.get("edit")
-        if not isinstance(edit, dict):
-            raise ValidationError(f"{label}: edit_delta requires edit")
-        validate_ref(edit.get("target_ref"), sources, f"{label}.edit.target_ref")
-        nonempty_list(edit, "changes", f"{label}.edit")
-        nonempty_list(edit, "preserve", f"{label}.edit")
-        text(edit, "continuity_impact", f"{label}.edit")
-
-    handling = record.get("text_handling")
-    if isinstance(handling, dict):
-        if "source_policy_ref" in handling:
-            validate_ref(
-                handling.get("source_policy_ref"),
-                sources,
-                f"{label}.text_handling.source_policy_ref",
-            )
-        treatment = handling.get("render_treatment")
-        if not isinstance(treatment, dict):
-            raise ValidationError(f"{label}: text_handling.render_treatment is required")
-        # `common-recipe.md` gives the source policy -> render treatment mapping
-        # as a structural check. Nothing implemented it, so a prop whose accepted
-        # policy is `no_readable_text` could ask for readable lettering and come
-        # back `valid` -- inventing a name or a number the creator never accepted.
-        source_mode = handling.get("source_mode")
-        allowed = (
-            ALLOWED_TREATMENTS.get(source_mode)
-            if isinstance(source_mode, str)
-            else None
-        )
-        mode = treatment.get("mode")
-        if allowed is not None and mode not in allowed:
-            raise ValidationError(
-                f"{label}: text policy {source_mode!r} allows "
-                f"{' or '.join(sorted(allowed))}, not {mode!r}; a creator "
-                f"override must change the policy rather than the treatment"
-            )
-        if source_mode == "exact_readable" and mode == "readable":
-            text(treatment, "exact_text", f"{label}.text_handling.render_treatment")
-            negatives = " ".join(str(item) for item in record.get("negative_constraints", []))
-            if NO_TEXT_CONSTRAINT.search(negatives):
-                raise ValidationError(f"{label}: readable text conflicts with a no-text constraint")
-
-
-def validate_lookdev_spec(
-    record: dict[str, Any], sources: dict[str, dict[str, Any]], label: str
-) -> None:
-    validate_ref(record.get("direction_ref"), sources, f"{label}.direction_ref")
-    validate_ref(record.get("production_profile_ref"), sources, f"{label}.production_profile_ref")
-    subjects = nonempty_list(record, "subject_bindings", label)
-    for index, subject in enumerate(subjects, 1):
-        if not isinstance(subject, dict):
-            raise ValidationError(f"{label}.subject_bindings[{index}]: must be an object")
-        item = f"{label}.subject_bindings[{index}]"
-        validate_ref(subject.get("identity_ref"), sources, f"{item}.identity_ref")
-        if "variant_ref" in subject:
-            validate_ref(subject.get("variant_ref"), sources, f"{item}.variant_ref")
-        text(subject, "role", item)
-    text(record, "test_question", label)
-    nonempty_list(record, "stable_visual_rules", label)
-    if record.get("lookdev_axis") == "high_pressure_scene":
-        refs = nonempty_list(record, "story_context_refs", label)
-        for index, ref in enumerate(refs, 1):
-            validate_ref(ref, sources, f"{label}.story_context_refs[{index}]")
-
-
-def validate_records(
-    records: list[dict[str, Any]], sources: dict[str, dict[str, Any]] | None = None
-) -> dict[str, Any]:
-    sources = sources or {}
-    identifiers: set[str] = set()
-    for index, record in enumerate(records, 1):
-        label = f"spec[{index}]"
-        spec_id = text(record, "spec_id", label)
-        if spec_id in identifiers:
-            raise ValidationError(f"{label}: duplicate spec_id {spec_id}")
-        identifiers.add(spec_id)
-        purpose = record.get("purpose")
-        if purpose not in PURPOSES:
-            raise ValidationError(
-                f"{label}: invalid purpose {purpose!r}; "
-                f"use one of {', '.join(sorted(PURPOSES))}"
-            )
-        if record.get("status") not in {"candidate", "accepted"}:
-            raise ValidationError(f"{label}: status must be candidate or accepted")
-        leaked = sorted(vendor_field_paths(record))
-        if leaked:
-            raise ValidationError(f"{label}: provider execution fields are forbidden: {', '.join(leaked)}")
-        prompt = text(record, "generic_prompt", label)
-        if HASH_RE.search(prompt) or "<sha256>" in prompt:
-            raise ValidationError(f"{label}: generic_prompt leaks internal hashes")
-        engine_syntax = ENGINE_SYNTAX_RE.search(prompt)
-        if engine_syntax:
-            raise ValidationError(
-                f"{label}: generic_prompt carries engine-specific syntax "
-                f"{engine_syntax.group(0).strip()!r}; keep it in a provider adapter"
-            )
-        validate_reference_bindings(record, sources, label)
-        if purpose == "lookdev_frame":
-            validate_lookdev_spec(record, sources, label)
-        else:
-            validate_asset_spec(record, sources, label)
-    return {
-        "status": "valid",
-        "specs": len(records),
-        "sources": len(sources),
-        "checks": [
-            "unique_ids",
-            "accepted_bindings",
-            # Named for what it does: every reference names a snapshot this
-            # file declares. Whether that record exists in the target artifact
-            # is not knowable here -- the checker is handed this file only.
-            "source_declaration",
-            "reference_slots",
-            "prompt_hygiene",
-        ],
-    }
-
-
-def validate_file(path: str | Path) -> dict[str, Any]:
-    sources, records = load_jsonl(path)
-    return validate_records(records, sources)
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("specs")
-    args = parser.parse_args()
-    try:
-        result = validate_file(args.specs)
-    except (OSError, ValidationError) as exc:
-        print(f"image prompt 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-image-prompts/scripts/selftest.py

@@ -1,95 +0,0 @@
-#!/usr/bin/env python3
-"""Offline self-test for the standalone image-prompt checker."""
-
-from __future__ import annotations
-
-import copy
-import sys
-from typing import Any
-
-from image_prompt_check import SKILL_ROOT, ValidationError, load_jsonl, 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(records: list[dict[str, Any]], sources: dict[str, dict[str, Any]], marker: str) -> None:
-    try:
-        validate_records(records, sources)
-    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 expanded(ref: dict[str, Any], sources: dict[str, dict[str, Any]]) -> dict[str, Any]:
-    entry = sources[ref["src"]]
-    inline = {key: entry[key] for key in ("owner", "artifact")}
-    inline.update({key: value for key, value in ref.items() if key != "src"})
-    return inline
-
-
-def main() -> int:
-    sources, records = load_jsonl(SKILL_ROOT / "examples/minimal-image-prompt-specs.jsonl")
-    require(validate_records(records, sources)["specs"] == 1, "valid fixture count")
-    require(len(sources) == 3, "fixture declares its upstream snapshots once")
-
-    duplicate = [records[0], copy.deepcopy(records[0])]
-    fail(duplicate, sources, "duplicate spec_id")
-
-    bad_order = copy.deepcopy(records)
-    bad_order[0]["reference_bindings"].append(copy.deepcopy(bad_order[0]["reference_bindings"][0]))
-    fail(bad_order, sources, "duplicate slot_id")
-
-    leaked = copy.deepcopy(records)
-    leaked[0]["provider"] = "example"
-    fail(leaked, sources, "provider execution fields")
-
-    # A/B Round 2: the suite forbids provider control syntax in a generic prompt,
-    # but nothing enforced it — the only prompt check was for leaked hashes.
-    # Generic quality language is `IMG-02`, a `craft_default`; it is not checked
-    # here, because a validator cannot block delivery on a fixed word list.
-    for syntax in ("--ar 9:16", "(red coat:1.2)", "cat::2"):
-        engine_syntax = copy.deepcopy(records)
-        engine_syntax[0]["generic_prompt"] += f" {syntax}"
-        fail(engine_syntax, sources, "engine-specific syntax")
-
-    nested_provider = copy.deepcopy(records)
-    nested_provider[0]["reference_bindings"][0]["provider"] = "example"
-    fail(nested_provider, sources, "reference_bindings[0].provider")
-
-    nested_secret = copy.deepcopy(records)
-    nested_secret[0]["asset_binding"]["credentials"] = {"token": "not-safe"}
-    fail(nested_secret, sources, "asset_binding.credentials")
-
-    undeclared = copy.deepcopy(records)
-    undeclared[0]["asset_binding"]["identity_ref"]["src"] = "no-such-source"
-    fail(undeclared, sources, "REF_SRC_IS_NOT_DECLARED")
-
-    unbound = copy.deepcopy(records)
-    del unbound[0]["source_refs"][0]["src"]
-    fail(unbound, sources, "REF_HAS_NO_UPSTREAM_BINDING")
-
-    # Projects released before the sources declaration write the snapshot inline on
-    # every reference; both forms resolve to the same upstream binding.
-    inline = copy.deepcopy(records)
-    binding = inline[0]["asset_binding"]
-    binding["identity_ref"] = expanded(binding["identity_ref"], sources)
-    binding["variant_ref"] = expanded(binding["variant_ref"], sources)
-    inline[0]["source_refs"] = [expanded(ref, sources) for ref in inline[0]["source_refs"]]
-    for slot in inline[0]["reference_bindings"]:
-        slot["artifact_ref"] = expanded(slot["artifact_ref"], sources)
-    require(validate_records(inline, {})["specs"] == 1, "inline snapshots resolve without sources")
-
-    print("10 self-tests passed")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/lib/drama/skills/short-drama-review/assets/finding-template.jsonl

@@ -1,2 +0,0 @@
-{"record_type":"sources","schema_version":"1.0.0","sources":{"screenplay-index":{"owner":"short-drama-write","artifact":"剧集/EP001/screenplay-index.jsonl"},"shots":{"owner":"short-drama-storyboard","artifact":"剧集/EP001/storyboard/shots.jsonl"},"screenplay":{"owner":"short-drama-write","artifact":"剧集/EP001/screenplay.md"}}}
-{"finding_id":"FIND-EXAMPLE","diagnostic_code":"SCR_SCENE_NO_TURN","knowhow_rule_id":"SCR-01","scope":"story_script","classification":"reviewed_invariant","enforcer":"reviewer","evidence":"Bounded explanation of the conflict","evidence_refs":[{"role":"source","src":"screenplay-index","record_id":"BLK-EP001-SC001-A01"},{"role":"conflicting_consumer","src":"shots","record_id":"SHOT-001","field":"/purpose"}],"impact":"Audience or production consequence","disposition":"keep | post_production | targeted_edit | resubmit | rewrite | not_applicable","disposition_rationale":"Why this disposition: is the defect text-controllable, and has it recurred? Use not_applicable outside project calibration.","required_change":"Outcome required from the owner, or empty when the disposition calls for no change","owner_skill":"short-drama-write","severity":"error","status":"open","target_ref":{"src":"screenplay","record_id":"EP001-SC001"}}

package/lib/drama/skills/short-drama-review/assets/supersession-decision.example.json

@@ -1,42 +0,0 @@
-{
-  "sources": {
-    "motion-specs-alternate": {
-      "owner": "short-drama-video-prompts",
-      "artifact": "剧集/EP001/storyboard/motion-specs.jsonl"
-    },
-    "motion-specs-master": {
-      "owner": "short-drama-video-prompts",
-      "artifact": "剧集/EP001/storyboard/motion-specs.jsonl"
-    },
-    "shots": {
-      "owner": "short-drama-storyboard",
-      "artifact": "剧集/EP001/storyboard/shots.jsonl"
-    }
-  },
-  "example_only": true,
-  "decision_id": "SUPERSESSION-EXAMPLE",
-  "alternate_ref": {
-    "src": "motion-specs-alternate",
-    "record_id": "MOTION-ALTERNATE",
-    "authority": "candidate"
-  },
-  "master_ref": {
-    "src": "motion-specs-master",
-    "record_id": "MOTION-MASTER",
-    "authority": "accepted"
-  },
-  "checked_obligations": [
-    {
-      "source_ref": {
-        "src": "shots",
-        "record_id": "SHOT-EXAMPLE",
-        "field": "/end_boundary",
-        "authority": "accepted"
-      },
-      "result": "covered | missing | changed",
-      "evidence": "<指出 alternate 中的对应字段>"
-    }
-  ],
-  "decision": "approve_supersession | reject_supersession",
-  "rationale": "<覆盖、对白、揭示、连续性和项目要求的复核结论>"
-}

package/lib/drama/skills/short-drama-review/assets/verdict-template.json

@@ -1,32 +0,0 @@
-{
-  "sources": {
-    "screenplay": {
-      "owner": "short-drama-write",
-      "artifact": "剧集/EP001/screenplay.md"
-    },
-    "findings": {
-      "owner": "short-drama-review",
-      "artifact": "审查/findings.jsonl"
-    }
-  },
-  "review_id": "REVIEW-EXAMPLE",
-  "scope": [
-    "story_script"
-  ],
-  "reviewed_artifacts": [
-    {
-      "src": "screenplay"
-    }
-  ],
-  "findings_ref": {
-    "src": "findings"
-  },
-  "review_method": "uninvolved_reviewer | self_check",
-  "reviewer": "<honest reviewer label>",
-  "structural_validation": "not_run",
-  "verdict": "PROVISIONAL",
-  "blocking_findings": [],
-  "open_blocker_count": 0,
-  "notes": [],
-  "supersession_decisions": []
-}

package/lib/drama/skills/short-drama-review/examples/minimal-findings.jsonl

@@ -1,2 +0,0 @@
-{"record_type":"sources","schema_version":"1.0.0","sources":{"screenplay-index":{"owner":"short-drama-write","artifact":"screenplay-index.jsonl"},"screenplay":{"owner":"short-drama-write","artifact":"screenplay.md"}}}
-{"finding_id":"FIND-SC001-TURN","diagnostic_code":"SCR_SCENE_NO_TURN","knowhow_rule_id":"SCR-01","scope":"story_script","classification":"reviewed_invariant","enforcer":"reviewer","evidence":"SC001 ends with the same decision and relationship state with which it began.","evidence_refs":[{"role":"source","src":"screenplay-index","record_id":"SC001-A01"},{"role":"source","src":"screenplay-index","record_id":"SC001-A04"}],"impact":"The scene consumes time without changing the audience's understanding or the characters' options.","disposition":"targeted_edit","disposition_rationale":"The defect is local to the written scene turn and has not recurred elsewhere.","required_change":"End SC001 with a visible choice or consequence while preserving the accepted entrance facts.","owner_skill":"short-drama-write","severity":"error","status":"open","target_ref":{"src":"screenplay","record_id":"SC001"}}

package/lib/drama/skills/short-drama-review/examples/minimal-verdict.json

@@ -1,34 +0,0 @@
-{
-  "sources": {
-    "screenplay": {
-      "owner": "short-drama-write",
-      "artifact": "screenplay.md"
-    },
-    "findings": {
-      "owner": "short-drama-review",
-      "artifact": "minimal-findings.jsonl"
-    }
-  },
-  "review_id": "REVIEW-SC001",
-  "scope": [
-    "story_script"
-  ],
-  "reviewed_artifacts": [
-    {
-      "src": "screenplay"
-    }
-  ],
-  "findings_ref": {
-    "src": "findings"
-  },
-  "review_method": "self_check",
-  "reviewer": "standalone example self-check",
-  "structural_validation": "passed",
-  "verdict": "REVISE",
-  "blocking_findings": [
-    "FIND-SC001-TURN"
-  ],
-  "open_blocker_count": 1,
-  "notes": [],
-  "supersession_decisions": []
-}