@oh-story/dsh 0.1.0

package/lib/drama/skills/short-drama-assets/scripts/asset_check.py

@@ -0,0 +1,267 @@
+#!/usr/bin/env python3
+"""Validate the structural core of standalone character and look records."""
+
+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("asset_check.py requires Python 3.9 or newer")
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+HASH_RE = re.compile(r"[0-9a-f]{64}")
+ACCEPTANCE_STATUSES = {"accepted", "proposed", "pending_choice"}
+
+
+# ---------------------------------------------------------------------------
+# 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
+# ---------------------------------------------------------------------------
+
+
+class ValidationError(ValueError):
+    pass
+
+
+class RecordFile(NamedTuple):
+    """One JSONL file: its upstream snapshot declaration and its records."""
+
+    sources: dict[str, dict[str, Any]]
+    records: list[dict[str, Any]]
+
+
+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) -> RecordFile:
+    path = resolve_input(value)
+    parsed: 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 JSONL record must be an object")
+        parsed.append(record)
+    sources = load_sources(parsed)
+    records = [
+        record for record in parsed if record.get("record_type") != SOURCES_RECORD_TYPE
+    ]
+    if not records:
+        raise ValidationError(f"{path}: no records")
+    return RecordFile(sources, records)
+
+
+def require_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 require_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
+) -> ResolvedRef:
+    resolved, finding = resolve_ref(value, sources, label)
+    if finding is not None:
+        raise ValidationError(f"{label}: {finding.code}: {finding.detail}")
+    assert resolved is not None
+    if not resolved.record_id or not resolved.record_id.strip():
+        raise ValidationError(f"{label}: record_id must be non-empty text")
+    return resolved
+
+
+def validate_acceptance(
+    value: Any, sources: dict[str, dict[str, Any]], label: str
+) -> None:
+    if not isinstance(value, dict) or value.get("status") not in ACCEPTANCE_STATUSES:
+        raise ValidationError(f"{label}: invalid creator_acceptance status")
+    decision_ref = value.get("decision_ref")
+    if value["status"] == "accepted" or decision_ref is not None:
+        resolved = validate_ref(decision_ref, sources, f"{label}.decision_ref")
+        # A decision_ref pointing at a block or an asset record binds acceptance to
+        # something that never recorded a creator decision.
+        if not str(resolved.record_id).startswith("CD-"):
+            raise ValidationError(
+                f"{label}.decision_ref: record_id must be a creator decision starting with CD-"
+            )
+
+
+def validate_records(characters: RecordFile, looks: RecordFile) -> dict[str, Any]:
+    character_ids: set[str] = set()
+    for index, record in enumerate(characters.records, 1):
+        label = f"character[{index}]"
+        character_id = require_text(record, "character_id", label)
+        if not character_id.startswith("CHAR-"):
+            raise ValidationError(f"{label}: character_id must start with CHAR-")
+        if character_id in character_ids:
+            raise ValidationError(f"{label}: duplicate character_id {character_id}")
+        character_ids.add(character_id)
+        require_text(record, "display_name", label)
+        anchors = require_list(record, "identity_anchors", label)
+        if any(not isinstance(item, str) or not item.strip() for item in anchors):
+            raise ValidationError(f"{label}: identity_anchors must contain text")
+        for ref_index, ref in enumerate(require_list(record, "source_refs", label), 1):
+            validate_ref(ref, characters.sources, f"{label}.source_refs[{ref_index}]")
+        validate_acceptance(record.get("creator_acceptance"), characters.sources, label)
+
+    look_ids: set[str] = set()
+    for index, record in enumerate(looks.records, 1):
+        label = f"look[{index}]"
+        look_id = require_text(record, "look_id", label)
+        if not look_id.startswith("LOOK-"):
+            raise ValidationError(f"{label}: look_id must start with LOOK-")
+        if look_id in look_ids:
+            raise ValidationError(f"{label}: duplicate look_id {look_id}")
+        look_ids.add(look_id)
+        character_ref = validate_ref(
+            record.get("character_ref"), looks.sources, f"{label}.character_ref"
+        )
+        if character_ref.record_id not in character_ids:
+            raise ValidationError(
+                f"{label}: character_ref does not resolve: {character_ref.record_id}"
+            )
+        differences = record.get("differences")
+        if not isinstance(differences, dict) or not any(differences.values()):
+            raise ValidationError(f"{label}: differences must describe an observable change")
+        validity = record.get("validity")
+        if not isinstance(validity, dict) or not validity.get("from"):
+            raise ValidationError(f"{label}: validity.from is required")
+        validate_acceptance(record.get("creator_acceptance"), looks.sources, label)
+
+    return {
+        "status": "valid",
+        "characters": len(characters.records),
+        "looks": len(looks.records),
+        # `source_declaration` is this file's own `sources` header resolving;
+        # `look_binding` is a real cross-record lookup, and it is one only
+        # because both files are handed to this checker.
+        "checks": ["unique_ids", "acceptance_shape", "source_declaration", "look_binding"],
+    }
+
+
+def validate_files(characters: str | Path, looks: str | Path) -> dict[str, Any]:
+    return validate_records(load_jsonl(characters), load_jsonl(looks))
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--characters", required=True)
+    parser.add_argument("--looks", required=True)
+    args = parser.parse_args()
+    try:
+        result = validate_files(args.characters, args.looks)
+    except (OSError, ValidationError) as exc:
+        print(f"asset check failed: {exc}", file=sys.stderr)
+        return 2
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+"""Offline self-test for the standalone asset checker."""
+
+from __future__ import annotations
+
+import copy
+import sys
+from pathlib import Path
+
+from asset_check import SKILL_ROOT, RecordFile, 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 expect_failure(characters: RecordFile, looks: RecordFile, marker: str) -> None:
+    try:
+        validate_records(characters, looks)
+    except ValidationError as exc:
+        if marker not in str(exc):
+            raise AssertionError(f"expected {marker!r}, got {exc!s}") from exc
+    else:
+        raise AssertionError(f"expected validation failure containing {marker!r}")
+
+
+def edited(source: RecordFile, index: int) -> tuple[RecordFile, dict]:
+    records = copy.deepcopy(source.records)
+    return RecordFile(copy.deepcopy(source.sources), records), records[index]
+
+
+def main() -> int:
+    example = Path(SKILL_ROOT, "examples/minimal")
+    characters = load_jsonl(example / "characters.jsonl")
+    looks = load_jsonl(example / "looks.jsonl")
+    result = validate_records(characters, looks)
+    require(result["characters"] == 1 and result["looks"] == 1, "valid fixture count")
+
+    duplicate = copy.deepcopy(characters.records[0])
+    expect_failure(
+        RecordFile(characters.sources, [*characters.records, duplicate]),
+        looks,
+        "duplicate character_id",
+    )
+
+    broken_look, record = edited(looks, 0)
+    record["character_ref"]["record_id"] = "CHAR-MISSING"
+    expect_failure(characters, broken_look, "does not resolve")
+
+    undeclared, record = edited(looks, 0)
+    record["character_ref"]["src"] = "not-declared"
+    expect_failure(characters, undeclared, "REF_SRC_IS_NOT_DECLARED")
+
+    unbound, record = edited(looks, 0)
+    record["character_ref"] = {"record_id": "CHAR-LIN"}
+    expect_failure(characters, unbound, "REF_HAS_NO_UPSTREAM_BINDING")
+
+    # A released project may still carry the snapshot inline on the reference.
+    inline, record = edited(looks, 0)
+    record["character_ref"] = {
+        **inline.sources["characters"],
+        "record_id": "CHAR-LIN",
+    }
+    inline.sources.pop("characters")
+    require(validate_records(characters, inline)["status"] == "valid", "inline snapshot")
+
+    candidate, record = edited(characters, 0)
+    record["creator_acceptance"] = {"status": "proposed", "decision_ref": None}
+    require(validate_records(candidate, looks)["status"] == "valid", "candidate status")
+
+    invalid, record = edited(characters, 0)
+    record["creator_acceptance"] = {"status": "approved", "decision_ref": None}
+    expect_failure(invalid, looks, "invalid creator_acceptance status")
+
+    misbound, record = edited(characters, 0)
+    record["creator_acceptance"]["decision_ref"]["record_id"] = "SC001-A01"
+    expect_failure(misbound, looks, "must be a creator decision starting with CD-")
+
+    print("9 self-tests passed")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/lib/drama/skills/short-drama-develop/SKILL.md

@@ -0,0 +1,157 @@
+---
+name: short-drama-develop
+description: 将中文小说、短剧或漫剧想法、梗概、改编材料、已有系列笔记或多集完整剧本发展成可追溯的改编方案、戏剧方向、创作简报、导演阐述、故事引擎与分集地图，并按题材与制作形态（画风）选择写法。用户提出“导入小说做短剧”“从多集整稿生成/补分集地图”“开发短剧/漫剧”“做故事设定/系列大纲/分集规划”“写导演阐述”“这个题材怎么写”“定画风/制作形态”“把这个点子变成短剧”或需要梳理人物冲突与集间交接时使用；已有单集剧本可直接进入写作、资产或审查流程，不强制补开发文件。
+license: MIT
+---
+
+# 短剧开发
+
+把创作者的意图变成能持续制造**选择、代价与状态变化**的故事系统。保留创作者的题材、结局和尺度选择；不要把流行套路当成剧情答案。
+
+## Quick Start
+
+离线验证多集整稿的精确索引、切片和源文件变更检测：
+
+```bash
+python3 {技能目录}/scripts/selftest.py
+python3 {技能目录}/scripts/episode_intake.py index <多集整稿> --out <episode-intake-index.json>
+```
+
+## 开始前
+
+本技能可独立安装和执行。先读取用户明确提供的材料与本任务直接输入；若当前目录是
+`short-drama` 项目且项目工具可用，可以读取 `status` 并使用其发布生命周期，但缺少 core
+或任何其他技能都不是开发工作的阻断条件。[阶段契约](references/stage-contract.md) 给出
+本阶段边界、制作形态输入与规则表，无需读取其他技能的文件。
+
+## 先判断入口
+
+1. **只有想法、题材或情绪目标**：完成方向探索，再建立创作简报与故事引擎。
+2. **已有梗概、小说、改编材料或系列笔记**：保存来源并先列出已承诺事实、可改范围、
+   来源片段与待确认项。长材料先做语义分段、功能账本和候选分集，不用正则人名/名词命中
+   直接发布剧集或资产；不要偷换原意。
+3. **方向已定，只需规划分集**：读取既有简报与引擎，直接制作或修订分集地图。
+4. **已有单集剧本**：不要为了流程完整而虚构开发材料。写/改剧本交给 `$short-drama-write`；拆资产或后续制作可从相应技能直接进入。
+5. **已有多集整稿，要生成或补分集地图**：保留原文件，只加载
+   [多集整稿接入与断点续跑](references/multi-episode-intake.md)。让 Agent 按文件实际结构决定
+   边界与本轮批次；工具只做精确索引、单集切片、校验和续跑，不代写创作判断。
+
+信息足够时直接工作。只有会改变主角、冲突引擎、结局承诺或改编边界的缺口才需要提问。
+
+## 每次执行
+
+### 1. 锁定创作者契约
+
+读取创作者输入和已接受文件，区分：
+
+- 不可改的事实、主题、角色与结局承诺；
+- 可探索的空白；
+- 形式约束与制作边界；
+- 目标观众反复能获得的情绪、信息或权力回报。
+
+新项目复制 [creative-brief.md](assets/creative-brief.md)。若改动已接受事实，先展示语义差异与下游影响，不直接覆盖。
+
+### 2. 探索真正不同的方向
+
+方向未定时，提出少量**机制不同**的候选：改变主角策略、对抗来源、代价或持续冲突方式，而不只是换标题、职业和措辞。方向明确时直接深化，不为凑选项制造伪差异。
+
+每个候选都说明：戏剧承诺、主角追求、对抗机制、反复回报、可升级的状态、长线终止条件、主要制作负担。让创作者选择或组合，并记录取舍理由；未选方案不进入既定事实。
+
+需要完整方法时读取 [story-craft.md](references/story-craft.md)。题材已经确定时，可从
+[genre-cards.md](references/genre-cards.md) 按索引取**一张**题材卡，用来校准该题材更常用的
+压力来源、场面颗粒与制作负担；它是可被创作者一句话覆盖的参考，不替代方向选择，也不进入交付物。
+
+若设定里主角带着一段已经发生过的经历，或获得了一套外部授权的能力，那是叠加在题材之上的
+**前提装置**，另读 [premise-devices.md](references/premise-devices.md)——装置取消阻力，
+必须先给它边界与代价。装置不替代题材卡，也不为它单独建题材。
+
+### 3. 建立故事引擎
+
+复制 [story-engine.md](assets/story-engine.md)，写清：
+
+- 压力如何出现，主角通常如何应对；
+- 对手或系统如何反制，主角为何不能轻易退出；
+- 每轮冲突改变什么，而不是怎样重复得更响；
+- 人物各自的目标、筹码、底线和关系压力；
+- 哪种人物转变或事实揭开会终结这个引擎；
+- 视觉、声音、场景规模和内容边界。
+
+连续剧、长篇改编或人物纵向变化较重时，再读取
+[serial-character-and-memory.md](references/serial-character-and-memory.md)：先建立只供
+作者决策的前史储备，选择旧策略开始付出代价的叙事切入窗口，再记录人物被捍卫的
+信念、压力测试、信息权限和跨集记忆。不要把前史储备直接倒进首集对白。
+
+### 4. 把系列运动落到分集
+
+读取 [episode-design.md](references/episode-design.md)，再复制 [episode-map.jsonl](assets/episode-map.jsonl)。每一集记录进入状态、开场、当集追求、阻力、方向性转折、当集结果、信息释放、出去的压力以及下一集必须继承的事实。
+
+先保证每集产生局部戏剧结果、相邻集能精确交接，再讨论外部压力/情感负荷的双轨
+节奏。集数、钩子类型、是否反转和高潮位置由创作者与项目决定。
+
+### 5. 做所有者检查并交接
+
+在提交预览前检查：
+
+- 引用的集、铺垫和兑现记录可找到，未决项被明确标记；
+- 候选确实改变机制，选定方向贯穿简报、引擎与分集地图；
+- 每次升级能指出权力、信息、关系、暴露、资源、时间或代价的变化；
+- 每集先兑现一部分当集承诺，再留下具体的决定、危险或问题；
+- 没有把格式偏好冒充普遍规律。
+
+这些是所有者自检，不是终审。展示创作者可读的新增/修改摘要，请创作者接受后再作为下游来源；
+需要质量结论时，把 `$short-drama-review` 作为后续单独请求，优先由未参与当前版本创作的 reviewer 执行。
+
+若项目需要导演阐述，本技能只产出 `项目开发/director-brief.md` 候选，并标明它准备
+写入的 `visual_direction` / `production_profile` 语义差异。创作者接受后，由
+`$short-drama` 路由把选择提升到 creator authority；开发技能不直接改写该权威配置。
+
+## 规则分级
+
+- **`structural_invariant`**：本地可证明的引用、ID、显式状态矛盾；可由校验器阻断。
+- **`reviewed_invariant`**：升级是否真实、承诺是否兑现等语义义务；由 reviewer 引用证据判断。
+- **`craft_default`**：通常有帮助的做法；创作者说明理由后可覆盖。
+- **`taste_option`**：钩子、弧线、视角、结局气质等选择；不得单独阻断。
+
+不要用固定的情节点、转折时刻、篇幅比例或数量配方替代因果判断。
+
+## 产物与边界
+
+本技能只拥有：
+
+- `项目开发/creative-brief.md`
+- `项目开发/story-engine.md`
+- `项目开发/director-brief.md`（项目需要时；仅为 creator authority 候选）
+- `项目开发/adaptation-map.jsonl`（长材料改编时；只保留输入 locator/span、
+  去引用的功能摘要、候选去向与未决项，不复制原文；例见
+  [adaptation-map.example.jsonl](assets/adaptation-map.example.jsonl)）
+- `项目开发/series-arc.json`（项目需要时）
+- `项目开发/episode-intake-index.json`（多集整稿接入时；可重建的机械索引，不是创作事实）
+- `项目开发/episode-map.jsonl`
+
+它不写场景动作与台词，不拆资产，不写图片/视频提示词，不生成媒体，也不签发终审结论。剧本语义由 `$short-drama-write` 接管。
+
+## 按需加载
+
+- **承诺、引擎、人物压力、升级与铺垫兑现**：[story-craft.md](references/story-craft.md)
+- **分集契约、因果节拍、集间交接与地图修订**：[episode-design.md](references/episode-design.md)
+- **已有多集完整剧本/散稿，要避免整稿进入上下文并可中断续跑**：
+  [multi-episode-intake.md](references/multi-episode-intake.md)
+- **人物驱动力、前史与切入、跨集变化、信息权限、双轨节奏与恢复记忆**：
+  [serial-character-and-memory.md](references/serial-character-and-memory.md)
+- **有原材料、需要压缩/合并人物场景/把信息视觉化**：
+  [adaptation-craft.md](references/adaptation-craft.md)
+- **创作者提供对标作品、样例剧本或提示词，希望学习机制而非仿写表达**：
+  [creative-reference-intake.md](references/creative-reference-intake.md)
+- **单元故事里同一套机制被反复运行，或中段开始重复、越写越薄**：
+  [mechanism-loop.md](references/mechanism-loop.md)
+- **需要区分揭示、反转、回报和钩子，或按题材选压力机制**：
+  [reveal-reversal-payoff.md](references/reveal-reversal-payoff.md)
+- **按题材选择冲突推进方式、设计开场或规划集尾钩子时的定性案例方法**：
+  [genre-and-hook-playbook.md](references/genre-and-hook-playbook.md)
+- **已确定题材，需要该题材更常用的压力、场面颗粒、钩子取向与制作难点**：
+  [genre-cards.md](references/genre-cards.md)（索引与召回规范；一次只读一张卡）
+- **主角带着已知结果开局，或获得外部授权的能力**：
+  [premise-devices.md](references/premise-devices.md)（装置层，叠加在题材卡之上）
+- **起草项目级视觉方向与生产规则（导演阐述）**：
+  [director-brief-craft.md](references/director-brief-craft.md)
+- **本阶段拥有什么、继承什么、不越权什么**：[stage-contract.md](references/stage-contract.md)

package/lib/drama/skills/short-drama-develop/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "短剧开发"
+  short_description: "把原创想法或长篇小说发展为故事引擎、系列弧线和逐集交接结构"
+  default_prompt: "使用 $short-drama-develop 把我的短剧想法或长篇小说发展成故事引擎和分集地图；方向不清时再给少量可选择方案。"

package/lib/drama/skills/short-drama-develop/assets/adaptation-map.example.jsonl

@@ -0,0 +1 @@
+{"example_only":true,"destination":"项目开发/adaptation-map.jsonl","schema_version":"1.0.0-draft","record_type":"adaptation_mapping","mapping_id":"ADAPT-EXAMPLE","status":"candidate","source_ref":{"owner":"creator","artifact":"输入/original-source.txt"},"source_span":{"byte_start":120,"byte_end":268,"line_start":8,"line_end":14},"function_summary":"一次旧选择使两名角色对当前证据承担不同风险；摘要不复制来源原句","mentioned_entities":[{"source_label":"称谓甲","proposed_identity":"CHAR-CANDIDATE-A","resolution":"unresolved"}],"adaptation_decision":{"disposition":"preserve | merge | change_carrier | compress | omit | unresolved","candidate_episode":"EP-CANDIDATE","new_carrier":"可见行动/证据/空间/对白策略或 unresolved","preserved_functions":["关系压力"],"lost_or_changed":[]},"creator_acceptance":{"status":"pending","decision_ref":null}}

package/lib/drama/skills/short-drama-develop/assets/creative-brief.md

@@ -0,0 +1,120 @@
+# 短剧创作简报
+
+> 复制到 `项目开发/creative-brief.md` 后填写。保留未知项为“待确认”，不要替创作者猜答案。方括号说明填写后删除。
+
+## 1. 项目意图
+
+- **暂定名**：【填写】
+- **一句原始想法**：【尽量保留创作者原话】
+- **这次要完成的工作**：【方向探索 / 系列开发 / 分集规划 / 定点修订】
+- **来源材料**：【无，或填写创作者提供的本地材料引用】
+- **不可更改的来源事实**：每条写清它在哪一集、以什么可见方式落地；本轮不落地的显式写延后到第几集。
+  - 【事实 → 落在 EPxxx，观众看到的是：〈可见载体〉；或：延后到 EPxxx；没有则写“暂无”】
+- **允许改编/探索的范围**：
+  - 【填写】
+
+## 2. 创作者契约
+
+- **希望观众反复获得的体验**：【情绪、信息、关系或权力回报】
+- **不希望作品变成什么**：【填写】
+- **主题张力**：【两项难以兼得的价值，不先写结论】
+- **语气与尺度**：【现实 / 浪漫 / 荒诞 / 克制 / 强烈等，由创作者描述】
+- **结局承诺或禁区**：【已定则写明；未定写“开放”】
+- **内容边界**：【填写】
+
+## 3. 形式与制作边界
+
+- **主要语言**：【填写】
+- **画幅/观看场景**：【如有明确约束则填写】
+- **单集与系列形式**：【仅记录创作者已选约束，不据此推导剧情】
+- **可用角色与场景规模**：【填写】
+- **难以承受的制作元素**：【填写】
+- **必须保留的视觉/声音特征**：【填写】
+
+## 4. 戏剧承诺（工作版）
+
+- **焦点人物**：【谁承受压力并作选择】
+- **当前追求**：【想得到、守住、查明或摆脱什么】
+- **昂贵阻力**：【谁/什么能持续阻挡，以及它的筹码】
+- **独特矛盾**：【主角有效策略如何同时制造代价】
+- **反复回报**：【观众每一阶段期待看到哪类真实变化】
+- **终止性转变**：【什么变化会让旧冲突引擎无法继续】
+
+**一句工作陈述**：
+
+【用自然语言连接以上决策；不是宣传语，也不强求固定句式。】
+
+## 5. 方向候选与选择
+
+> 方向已明确时只记录选定方向，不为凑数制造候选。探索时，候选必须改变机制而非只换包装。
+
+### 候选：【名称】
+
+- 主角惯常策略：【填写】
+- 主要对抗机制：【填写】
+- 退出成本：【填写】
+- 反复回报：【填写】
+- 核心代价：【填写】
+- 引擎终止条件：【填写】
+- 主要制作负担：【填写】
+- 擅长提供：【填写】
+- 会牺牲：【填写】
+
+### 创作者选择
+
+- **选定/组合**：【填写】
+- **选择理由**：【填写】
+- **明确拒绝的方向**：【填写；防止后续悄悄混入】
+- **仍待确认的分支**：【填写】
+
+## 6. 核心人物与关系压力
+
+### 【角色名】
+
+- 当前目标/意识到的追求：【填写】
+- 保护对象/不可失去之物：【填写】
+- 被捍卫的信念：【人物如何解释自己与世界；不要求“正确”】
+- 形成该信念的前史成因：【只写仍会影响现在选择的过去】
+- 惯常策略与优势：【填写】
+- 策略盲区与代价：【填写】
+- 可用筹码：【填写】
+- 底线与可能越线条件：【填写】
+- 可能改变其策略的事实：【填写】
+
+### 核心关系：【角色 A ↔ 角色 B】
+
+- A 需要 B / 害怕 B 看见 / 用来约束 B 的东西：【填写】
+- B 需要 A / 害怕 A 拿走 / 用来反制 A 的东西：【填写】
+- 当前不平衡：【填写】
+- 可能发生的关系状态变化：【填写】
+
+## 7. 叙事切入窗口与前史储备
+
+- **故事切入前已经运行的压力**：【填写】
+- **叙事切入窗口**：【从哪个必须行动的时刻开始】
+- **为什么不更早/更晚开始**：【更早会变成什么准备；更晚会丢掉哪个选择】
+- **开场可见证据**：【让观众从行为、物件、关系或异常结果反推前因】
+- **观众现在必须知道**：【只列当前行动所需】
+- **观众暂时不需要知道**：【继续保留，不塞入首集说明】
+
+### 前史储备
+
+| 过去事实 | 如何解释当前选择 | 作者是否需要 | 观众何时/通过什么可见载体得知 |
+|---|---|---|---|
+| 【填写】 | 【填写】 | 【需要 / 可省】 | 【现在 / 延后 / 不展示；载体】 |
+
+## 8. 成功条件与待确认项
+
+- **本轮产物必须保住的创作者选择**：【填写】
+- **可以由后续单集继续发现的空白**：【填写】
+- **若不确认会改变故事方向的问题**：
+  - 【填写；没有则写“暂无”】
+- **不会阻止继续工作的次要未知项**：
+  - 【填写】
+
+## 9. 接受记录
+
+- **预览版本/日期**：【填写】
+- **语义变化摘要**：【填写】
+- **创作者状态**：【待选择 / 已选择待接受 / 已接受 / 需修订】
+- **创作者备注**：【填写】

package/lib/drama/skills/short-drama-develop/assets/episode-map.jsonl

@@ -0,0 +1 @@
+{"episode_id": "EP001", "incoming_state": {"knowledge": ["__FILL_OR_REMOVE__"], "power": ["__FILL_OR_REMOVE__"], "relationship": ["__FILL_OR_REMOVE__"], "physical": ["__FILL_OR_REMOVE__"], "active_action": ["__FILL_OR_REMOVE__"]}, "hook": {"realization": "__FILL__"}, "objective": {"character": "__FILL__", "desired_change": "__FILL__", "why_now": "__FILL__"}, "opposition": {"actor_or_constraint": "__FILL__", "goal": "__FILL__", "leverage": "__FILL__"}, "turn": {"trigger": "__FILL__"}, "local_dramatic_result": {"goal_outcome": "__SUCCESS_FAILURE_OR_REDIRECTION__", "state_change": "__FILL__", "cost_paid": "__FILL__"}, "information_release": [{"fact_id": "__FILL__", "audience_before": "__KNOWN_SUSPECTED_OR_UNKNOWN__", "visible_carrier": "__ACTION_OBJECT_DIALOGUE_OR_CONSEQUENCE__", "supported_claim": "__STRONGEST_CLAIM_DIRECTLY_SUPPORTED_BY_CARRIER__", "unresolved_inference": "__UNPROVED_IDENTITY_CAUSE_MOTIVE_OR_MECHANISM_OR_NONE__", "audience_after": "__KNOWN_SUSPECTED_OR_UNKNOWN__"}], "premise_device_disclosure": {"clause_ids_disclosed_so_far": ["DEV-01"], "clause_ids_newly_disclosed": [], "who_knows": "<人物/观众各自知道到哪一步>", "misstated": "<本集若有误述，写哪条条款被误述及埋了什么线索>"}, "outgoing_pressure": {"started_decision_danger_or_question": "__FILL__"}, "handoff_state": {"knowledge": ["__FILL_OR_REMOVE__"], "power": ["__FILL_OR_REMOVE__"], "relationship": ["__FILL_OR_REMOVE__"], "physical": ["__FILL_OR_REMOVE__"], "active_action": ["__FILL_OR_REMOVE__"]}, "required_assets": [], "continuity_deltas": [], "open_questions": [], "creator_status": "draft", "setup_ids": [], "payoff_ids": []}