@oh-story/dsh 0.1.12 → 0.1.13

package/lib/video-recap/skills/video-recap/scripts/library.py

@@ -23,7 +23,7 @@ import stat
 import sys
 from pathlib import Path
 
-from materials import file_identity
+from lib import file_identity
 
 LIBRARY_ENV = "VIDEO_RECAP_MATERIAL_LIBRARY_DIR"
 LIBRARY_SCHEMA = "video-recap.library.v1"
@@ -39,7 +39,14 @@ RESOURCE_EXTS = {
     "font": {".ttf", ".otf", ".ttc"},
     "image": {".png", ".jpg", ".jpeg", ".webp"},
 }
-TEMPLATE_KINDS = ("subtitle_style", "packaging")
+TEMPLATE_KINDS = ("subtitle_style", "packaging", "production_reference")
+# A production_reference template points at an export of the on-demand reference skill. This is
+# a separate shape check (no import of that skill): methods only, never the source's facts.
+REFERENCE_FILE = "production_reference.json"
+REFERENCE_SCHEMA = "video-reference.production.v1"
+REFERENCE_DIMENSIONS = ("narrative_structure", "pacing", "shots_editing", "narration_subtitles", "audio_visual")
+# Same banned keys as the reference export's own re-scan: source facts plus the measurement pointers.
+REFERENCE_FACT_KEYS = {"source_facts", "labels", "evidence", "entities", "statement", "from", "path"}
 LICENSE_STATUSES = ("unknown", "owned", "licensed", "restricted")
 CONSENT_STATUSES = ("unknown", "granted", "denied")
 TEMPLATE_STATUSES = ("draft", "adopted", "retired")
@@ -90,7 +97,7 @@ class Report:
 MAX_RECORD_BYTES = 2 * 1024 * 1024
 
 
-def _load(path: Path, schema: str, keys: set, report: Report):
+def _load(path: Path, schema: str, keys: set | None, report: Report):
     try:
         st = os.stat(path)
         if not stat.S_ISREG(st.st_mode) or st.st_size > MAX_RECORD_BYTES:
@@ -106,7 +113,7 @@ def _load(path: Path, schema: str, keys: set, report: Report):
     if data.get("schema") != schema:
         report.error(path, "schema", f"schema 必须是 {schema}")
         return None
-    unknown = sorted(set(data) - keys)
+    unknown = sorted(set(data) - keys) if keys is not None else []
     if unknown:
         report.error(path, "unknown_keys", f"未知字段: {', '.join(unknown)}")
     return data
@@ -217,6 +224,33 @@ def _param_number(params, key):
     return value if isinstance(value, (int, float)) and not isinstance(value, bool) and value > 0 else None
 
 
+def _check_production_reference(path: Path, params: dict, report: Report):
+    """Issues are filed on template.json, so a binding refuses the template when its file is bad."""
+    if params != {"reference": {"path": REFERENCE_FILE}}:
+        report.error(path, "reference_params",
+                     f'production_reference 的 params 必须恰好是 {{"reference": {{"path": "{REFERENCE_FILE}"}}}}')
+        return
+    target = resolve_inside(path.parent, path.parent, REFERENCE_FILE)
+    if target is None or not target.is_file():
+        report.error(path, "file_missing", f"版本目录内没有 {REFERENCE_FILE}")
+        return
+    loaded = Report(report.root)
+    data = _load(target, REFERENCE_SCHEMA, None, loaded)
+    for item in loaded.errors:
+        report.error(path, item["code"], f"{REFERENCE_FILE}: {item['message']}")
+    if data is None:
+        return
+    methods = data.get("methods")
+    if not (isinstance(methods, list) and methods and all(
+        isinstance(m, dict) and m.get("dimension") in REFERENCE_DIMENSIONS and _nonempty_str(m.get("rule"))
+        for m in methods
+    )):
+        report.error(path, "methods", f"{REFERENCE_FILE} 的 methods 需要非空，每条有 {REFERENCE_DIMENSIONS} 之一的 dimension 与非空 rule")
+    leaked = sorted({key for _, node in _param_values(data) for key in node if key in REFERENCE_FACT_KEYS})
+    if leaked:
+        report.error(path, "source_facts", f"{REFERENCE_FILE} 只放方法，不能带原片事实字段: {', '.join(leaked)}")
+
+
 def _check_template(path: Path, data: dict, report: Report) -> dict | None:
     vdir = path.parent
     tid, kind = vdir.parent.name, vdir.parent.parent.name
@@ -297,6 +331,8 @@ def _check_template(path: Path, data: dict, report: Report) -> dict | None:
                 _check_rect(path, f"params.layers[{index}].rect", layer.get("rect"), canvas, report)
         if canvas and "safe_rect" in params:
             _check_rect(path, "params.safe_rect", params["safe_rect"], canvas, report)
+    if kind == "production_reference":
+        _check_production_reference(path, params, report)
     status = data.get("status")
     if status not in TEMPLATE_STATUSES:
         report.error(path, "status", f"status 必须是 {TEMPLATE_STATUSES} 之一")

package/lib/video-recap/skills/video-recap/scripts/materials.py

@@ -16,14 +16,16 @@ written into scenes/ASR/VLM/summary JSON.
 from __future__ import annotations
 
 import json
-import os
 import re
 import tempfile
 from datetime import datetime, timezone
 from pathlib import Path
 
-from lib import load_json
+from lib import load_json, material_id_for, read_json_object, source_id_for
 
+# asr_timing_evidence.json stays out on purpose: it binds asr_result.json and audio.wav by
+# {size, mtime_ns}, and a restore rewrites the former (redacted copy) and never copies the
+# latter, so a restored sidecar could only ever read as MISSING_OR_STALE.
 ALLOWED_ARTIFACTS = {
     "scenes.json",
     "asr_result.json",
@@ -35,10 +37,9 @@ ALLOWED_ARTIFACTS = {
     "timeline_fusion.json",
     "understanding_index.json",
     "understanding_index.md",
+    "consolidation.status.json",
     "agent_narration_brief.md",
     "background_research.json",
-    "reference_profile.json",
-    "reference_match_report.json",
     "recap_run_manifest.json",
 }
 # Redaction targets credential VALUE shapes, not English/Chinese dictionary words — the
@@ -67,30 +68,6 @@ def utc_now_iso() -> str:
     return datetime.now(timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z")
 
 
-def file_identity(path: str | Path) -> dict:
-    """``{size, mtime_ns}`` of a file: the identity recap records and compares for a source
-    video or adopted artifact. A file rewritten in place gets a new mtime_ns."""
-    st = os.stat(os.fspath(path))
-    return {"size": st.st_size, "mtime_ns": st.st_mtime_ns}
-
-
-def _slug(text: str, max_len: int = 48) -> str:
-    raw = Path(text).stem.lower()
-    raw = re.sub(r"[^a-z0-9\u4e00-\u9fff._-]+", "-", raw).strip("-._")
-    return (raw or "material")[:max_len].strip("-._") or "material"
-
-
-def _id_stem(source_path: str | Path, max_len: int = 32) -> str:
-    raw = re.sub(r"[^a-z0-9]+", "-", Path(source_path).stem.lower()).strip("-")
-    return (raw or "source")[:max_len].strip("-") or "source"
-
-
-def source_id_for(source_path: str | Path) -> str:
-    """``src_<stem>_<size>``: readable, stable across runs, and distinct for a different cut
-    of the same title (the size changes)."""
-    return f"src_{_id_stem(source_path)}_{os.stat(os.fspath(source_path)).st_size}"
-
-
 def assign_source_ids(sources: list[dict]) -> list[dict]:
     """Assign deterministic source_id values to manifest source records.
 
@@ -115,10 +92,6 @@ def assign_source_ids(sources: list[dict]) -> list[dict]:
     return assigned
 
 
-def material_id_for(source_path: str | Path, source_identity: dict) -> str:
-    return f"{_slug(str(source_path))}-{source_identity['size']}"
-
-
 def material_dir(library_dir: str | Path, material_id: str) -> Path:
     return Path(library_dir) / "materials" / material_id
 
@@ -207,16 +180,8 @@ def write_material_md(path: Path, metadata: dict, summary: str, tags: list[str])
     path.write_text(text, encoding="utf-8")
 
 
-def _read_material_metadata(path: Path) -> dict | None:
-    try:
-        data = load_json(path)
-    except (OSError, ValueError):
-        return None
-    return data if isinstance(data, dict) else None
-
-
 def _material_cache_entry(path: Path) -> dict | None:
-    data = _read_material_metadata(path)
+    data = read_json_object(path)
     if not data or not all(data.get(key) for key in (
         "source_path", "updated_at", "material_id",
     )) or not isinstance(data.get("artifacts"), list):
@@ -261,7 +226,7 @@ def save_material(
         copied.append({"name": src.name, "path": f"artifacts/{src.name}", "bytes": dst.stat().st_size})
 
     meta_path = dest / "material.json"
-    previous = _read_material_metadata(meta_path)
+    previous = read_json_object(meta_path)
     created_at = previous.get("created_at") if previous else None
     if not isinstance(created_at, str) or not created_at:
         created_at = now
@@ -301,32 +266,6 @@ def save_material(
     return metadata
 
 
-def find_material_by_source(
-    library_dir: str | Path, source_path: str | Path, source_identity: dict
-) -> dict | None:
-    """The newest material saved for this exact source file (resolved path + identity)."""
-    root = Path(library_dir) / "materials"
-    if not root.exists():
-        return None
-    resolved = str(Path(source_path).resolve())
-    candidates = []
-    for meta_path in root.glob("*/material.json"):
-        data = _material_cache_entry(meta_path)
-        if (
-            data is not None
-            and data["source_path"] == resolved
-            and data["source_video_identity"] == source_identity
-        ):
-            data["material_dir"] = str(meta_path.parent)
-            candidates.append(data)
-    if not candidates:
-        return None
-    # Deterministic fallback policy for legacy/manual callers that do not know
-    # the expected material_id: newest wins, then material_id for stable ties.
-    candidates.sort(key=lambda d: (d["updated_at"], d["material_id"]), reverse=True)
-    return candidates[0]
-
-
 def restore_material(
     library_dir: str | Path,
     work_dir: str | Path,
@@ -334,7 +273,7 @@ def restore_material(
     source_path: str | Path,
     source_identity: dict,
     settings: dict,
-    material_id: str | None = None,
+    material_id: str,
     overwrite: bool = True,
     prune_stale_allowed: bool = True,
 ) -> dict:
@@ -349,17 +288,11 @@ def restore_material(
     newly restored material. Non-allowed files (for example narration.json or
     clip_plan.json) are never removed here.
     """
-    lib = Path(library_dir)
-    if material_id:
-        meta_path = material_dir(lib, material_id) / "material.json"
-        meta = _material_cache_entry(meta_path)
-        if meta is None:
-            return {"restored": False, "reason": "material missing or invalid"}
-        meta["material_dir"] = str(meta_path.parent)
-    else:
-        meta = find_material_by_source(lib, source_path, source_identity)
-        if meta is None:
-            return {"restored": False, "reason": "material not found"}
+    meta_path = material_dir(Path(library_dir), material_id) / "material.json"
+    meta = _material_cache_entry(meta_path)
+    if meta is None:
+        return {"restored": False, "reason": "material missing or invalid"}
+    meta["material_dir"] = str(meta_path.parent)
     if meta["source_path"] != str(Path(source_path).resolve()) \
             or meta["source_video_identity"] != source_identity:
         return {"restored": False, "reason": "source identity mismatch", "material_id": meta["material_id"]}

package/lib/video-recap/skills/video-recap/scripts/recap_cli.py

@@ -2,12 +2,12 @@
 
 import argparse
 import os
+import sys
+from pathlib import Path
 
-from lib import env_bool
+from lib import TTS_PROVIDERS
 from recap_source import AUDIO_MODES
 
-TTS_PROVIDERS = ("auto", "mimo-tts", "fish-audio", "index-tts")
-
 
 class _RecordExplicit:
     """Record the option argparse actually consumed, not the raw argv spelling."""
@@ -35,6 +35,46 @@ def _record_explicit_options(parser):
             )
 
 
+# Options whose value names a file or directory; the resume command makes them absolute.
+_PATH_DESTS = frozenset({
+    "work_dir", "output_dir", "voice_ref", "material_library_dir", "project",
+    "tts_meta", "narration_adoption", "audio_mix_adoption",
+})
+
+
+def _absolute(value):
+    return str(Path(value).expanduser().resolve()) if value else value
+
+
+def _replayable_argv(parser, argv):
+    """The argv as typed, with videos and path values made absolute so it replays from any cwd.
+
+    Runs only after a successful parse, so every option token is an exact option string
+    (allow_abbrev=False) and every value-taking option is followed by its value.
+    """
+    options = {name: action for action in parser._actions for name in action.option_strings}
+    out, tokens, positional_only = [], iter(argv), False
+    for token in tokens:
+        if positional_only or not token.startswith("-"):
+            out.append(_absolute(token))
+            continue
+        if token == "--":
+            positional_only = True
+            out.append(token)
+            continue
+        name, inline, value = token.partition("=")
+        action = options[name]
+        if action.nargs == 0:
+            out.append(token)
+            continue
+        fix = _absolute if action.dest in _PATH_DESTS else str
+        if inline:
+            out.append(f"{name}={fix(value)}")
+        else:
+            out += [token, fix(next(tokens))]
+    return out
+
+
 def parse_args(argv=None):
     parser = argparse.ArgumentParser(
         description="Full video recap orchestrator (video-* skill bundle).",
@@ -102,7 +142,9 @@ def parse_args(argv=None):
         "--burn-subtitles",
         action=argparse.BooleanOptionalAction,
         default=None,
-        help="burn narration subtitles into the video (default on; --no-burn-subtitles to disable)",
+        help="burn narration subtitles into the video (default on; without libass the default "
+             "delivers a .srt sidecar instead, while an explicit --burn-subtitles fails; "
+             "--no-burn-subtitles to disable)",
     )
     voice.add_argument(
         "--subtitle-y-top",
@@ -143,22 +185,10 @@ def parse_args(argv=None):
         action="store_true",
         help="make narration review a strict pre-TTS gate (also REQUIRE_NARRATION_REVIEW=1)",
     )
-    review.add_argument(
-        "--mimo-qc",
-        default=os.environ.get("MIMO_QC", "off"),
-        choices=["off", "pre-assemble", "post-render", "both"],
-        help="optional advisory MiMo QC stage(s); never blocks the pipeline",
-    )
-    review.add_argument(
-        "--mimo-qc-refresh",
-        action="store_true",
-        default=env_bool("MIMO_QC_REFRESH", False),
-        help="ignore a matching MiMo QC stage cache",
-    )
     review.add_argument(
         "--require-final-qc",
         action="store_true",
-        help="full/cut: require literal passing final_qc and golden_eval summaries",
+        help="full/cut: require a literal passing final_qc summary",
     )
     review.add_argument(
         "--export-jianying",
@@ -204,6 +234,8 @@ def parse_args(argv=None):
     selfcheck.add_argument("--doctor", action="store_true")
 
     _record_explicit_options(parser)
+    argv = sys.argv[1:] if argv is None else [str(token) for token in argv]
     args = parser.parse_args(argv)
     args._explicit_options = frozenset(getattr(args, "_explicit_options", ()))
+    args._argv = _replayable_argv(parser, argv)
     return parser, args

package/lib/video-recap/skills/video-recap/scripts/recap_inspect.py

@@ -21,9 +21,7 @@ import argparse
 import json
 from pathlib import Path
 
-
-def load_json(path):
-    return json.loads(Path(path).read_text(encoding="utf-8"))
+from lib import load_json
 
 
 # --- artifact catalog --------------------------------------------------------