@oh-story/dsh 0.1.10 → 0.1.12

package/lib/video-recap/skills/video-recap/scripts/{mimo_qc_report.py → qc/mimo_report.py}

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import base64
-import hashlib
 import json
 import math
 import os
@@ -14,18 +13,17 @@ from typing import Any
 from collections.abc import Callable, Mapping, Sequence
 
 import qc_contract
-from mimo_qc_client import mimo_qc_api_call
-from mimo_qc_evidence import (
+from qc.mimo_client import mimo_qc_api_call
+from qc.mimo_evidence import (
     _cache_evidence,
     _effective_config,
     _existing_final_output,
-    _fingerprint_value,
     collect_evidence,
     safe_mimo_config,
 )
-from mimo_qc_observations import normalize_observations
-from mimo_qc_payload import _request_payload, _validated_live_output, build_payload
-from mimo_qc_contract import (
+from qc.mimo_observations import normalize_observations
+from qc.mimo_payload import _request_payload, _validated_live_output, build_payload
+from qc.mimo_contract import (
     ARTIFACT_NAME,
     DEFAULT_STAGE,
     FRAME_SAMPLER_VERSION,
@@ -121,7 +119,7 @@ def sample_video_frames(
                 {
                     "data_url": "data:image/jpeg;base64,"
                     + base64.b64encode(raw).decode("ascii"),
-                    "sha256": hashlib.sha256(raw).hexdigest(),
+                    "bytes": len(raw),
                     "timestamp": round(timestamp, 3),
                 }
             )
@@ -135,7 +133,7 @@ def _frame_metadata(samples: Sequence[Mapping[str, Any]]) -> dict[str, Any]:
         "max_dimension": MAX_FRAME_DIMENSION,
         "sampler_version": FRAME_SAMPLER_VERSION,
         "samples": [
-            {"sha256": sample["sha256"], "timestamp": sample["timestamp"]}
+            {"bytes": sample["bytes"], "timestamp": sample["timestamp"]}
             for sample in samples
         ],
     }
@@ -147,10 +145,13 @@ def _cache_input(
     evidence: Mapping[str, Any],
     frames: Mapping[str, Any],
 ) -> dict[str, Any]:
+    """Everything a stage report depends on; an existing report whose stored cache_input
+    equals this dict is reused instead of a new request."""
     return {
         "stage": stage,
         "model": payload["model"],
-        "payload_fingerprint": payload["payload_fingerprint"],
+        "config": payload["config"],
+        "instructions": payload["instructions"],
         "evidence": _cache_evidence(evidence),
         "frames": frames,
         "contract": qc_contract.SCHEMA_VERSION,
@@ -158,23 +159,13 @@ def _cache_input(
 
 
 def _stage_reports(path: Path) -> dict[str, dict[str, Any]]:
-    """Per-stage reports from an existing aggregate mimo_qc.json, or {} before the first stage."""
+    """Per-stage reports from an existing aggregate mimo_qc.json, or {} before the first stage.
+
+    The aggregate is this module's own atomically written, contract-validated report, so a
+    corrupt one raises (recap_stage_qc keeps the pipeline fail-open around the whole stage)."""
     if not path.is_file():
         return {}
-    try:
-        stages = json.loads(path.read_text(encoding="utf-8"))["metadata"]["stages"]
-        for report in stages.values():
-            qc_contract.validate_report(report)
-        return dict(stages)
-    except (
-        OSError,
-        ValueError,
-        TypeError,
-        KeyError,
-        AttributeError,
-        qc_contract.QCContractError,
-    ):
-        return {}
+    return dict(json.loads(path.read_text(encoding="utf-8"))["metadata"]["stages"])
 
 
 def _error_name(exc: Exception) -> str:
@@ -211,12 +202,11 @@ def build_report(
             )[:MAX_FRAMES]
     frame_meta = _frame_metadata(samples)
     cache_input = _cache_input(stage, payload, evidence, frame_meta)
-    cache_key = _fingerprint_value(cache_input)
 
     if (
         not refresh
         and existing is not None
-        and existing.get("metadata", {}).get("cache_key") == cache_key
+        and existing["metadata"]["cache_input"] == cache_input
     ):
         cached = json.loads(json.dumps(existing))
         cached["metadata"].update(status="cached", mode="live_cache", request_count=0)
@@ -271,7 +261,6 @@ def build_report(
         "request_count": 1
         if mode == "live" and status in {"completed", "failed"}
         else 0,
-        "cache_key": cache_key,
         "cache_input": cache_input,
         "frame_samples": frame_meta,
         "evidence": evidence,

package/lib/video-recap/skills/video-recap/scripts/{mimo_qc_runner.py → qc/mimo_runner.py}

@@ -15,8 +15,8 @@ from collections.abc import Callable, Mapping, Sequence
 
 import qc_contract
 
-from mimo_qc_report import _stage_reports, build_report, write_report
-from mimo_qc_contract import ARTIFACT_NAME, DEFAULT_STAGE
+from qc.mimo_report import _stage_reports, build_report, write_report
+from qc.mimo_contract import ARTIFACT_NAME, DEFAULT_STAGE
 
 JudgeCallable = Callable[
     [Mapping[str, Any]], Mapping[str, Any] | Sequence[Mapping[str, Any]]

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

@@ -6,7 +6,6 @@ pipeline, or attempt automatic fixes.
 """
 from __future__ import annotations
 
-import hashlib
 import re
 from pathlib import Path
 from typing import Any
@@ -32,7 +31,6 @@ ARTIFACTS = frozenset({"final_qc.json", "golden_eval.json", "mimo_qc.json", "pre
 
 DETERMINISTIC_CATEGORIES = frozenset({
     "missing_artifact",
-    "stale_fingerprint",
     "duration",
     "stream",
     "subtitle",
@@ -107,7 +105,6 @@ _REQUIRED_FINDING_FIELDS = frozenset({
     "evidence",
     "sample_policy",
     "model_used",
-    "artifact_fingerprints",
     "next_action",
     # Helper fields kept for current rule semantics and compatibility.
     "category",
@@ -132,15 +129,6 @@ class QCContractError(ValueError):
     """Raised when a QC report or finding violates the shared contract."""
 
 
-def artifact_fingerprint(path: str | Path) -> str:
-    """Return a stable sha256 hex digest for an artifact file."""
-    h = hashlib.sha256()
-    with Path(path).open("rb") as f:
-        for chunk in iter(lambda: f.read(1024 * 1024), b""):
-            h.update(chunk)
-    return h.hexdigest()
-
-
 def build_finding(
     *,
     stage: str,
@@ -155,7 +143,6 @@ def build_finding(
     rule_id: str | None = None,
     decision_reason: str | None = None,
     model_used: str | None = None,
-    artifact_fingerprints: Mapping[str, Any] | None = None,
     next_action: str | None = None,
     deterministic: bool | None = None,
     blocking: bool | None = None,
@@ -181,8 +168,6 @@ def build_finding(
         decision_reason = message
     if model_used is None:
         model_used = "local_deterministic"
-    if artifact_fingerprints is None:
-        artifact_fingerprints = {}
     if next_action is None:
         next_action = "manual_review"
     if isinstance(sample_policy, str):
@@ -200,7 +185,6 @@ def build_finding(
     if evidence is None:
         evidence = {}
     evidence = redact_secrets(evidence)
-    artifact_fingerprints = redact_secrets(artifact_fingerprints)
     objective_corroboration = redact_secrets(objective_corroboration or {})
 
     is_non_deterministic = (not deterministic) or category in NON_DETERMINISTIC_CATEGORIES
@@ -226,7 +210,6 @@ def build_finding(
         "evidence": dict(evidence),
         "sample_policy": dict(sample_policy),
         "model_used": model_used,
-        "artifact_fingerprints": dict(artifact_fingerprints),
         "next_action": next_action,
         "category": category,
         "code": code,
@@ -324,8 +307,6 @@ def _validate_finding(finding: Mapping[str, Any]) -> None:
         raise QCContractError("source must be an object")
     if finding["evidence"] is None or not isinstance(finding["evidence"], Mapping):
         raise QCContractError("evidence must be an object")
-    if finding["artifact_fingerprints"] is None or not isinstance(finding["artifact_fingerprints"], Mapping):
-        raise QCContractError("artifact_fingerprints must be an object")
     if finding["objective_corroboration"] is None or not isinstance(finding["objective_corroboration"], Mapping):
         raise QCContractError("objective_corroboration must be an object")
     for field in ("finding_id", "rule_id", "decision_reason", "model_used", "next_action"):

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

@@ -4,137 +4,206 @@ import argparse
 import os
 
 from lib import env_bool
+from recap_source import AUDIO_MODES
 
-TTS_PROVIDERS = ("auto", "mimo-tts", "fish-audio")
+TTS_PROVIDERS = ("auto", "mimo-tts", "fish-audio", "index-tts")
 
 
-def parse_args():
+class _RecordExplicit:
+    """Record the option argparse actually consumed, not the raw argv spelling."""
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        if option_string is not None:
+            recorded = getattr(namespace, "_explicit_options", None)
+            if recorded is None:
+                recorded = set()
+                setattr(namespace, "_explicit_options", recorded)
+            recorded.add(option_string)
+        super().__call__(parser, namespace, values, option_string)
+
+
+def _record_explicit_options(parser):
+    """Make every optional action report itself, so guards never re-parse sys.argv."""
+    tracked = {}
+    for action in parser._actions:
+        if not action.option_strings:
+            continue
+        base = type(action)
+        if not issubclass(base, _RecordExplicit):
+            action.__class__ = tracked.setdefault(
+                base, type(base.__name__, (_RecordExplicit, base), {})
+            )
+
+
+def parse_args(argv=None):
     parser = argparse.ArgumentParser(
-        description="Full video recap orchestrator (video-* skill bundle)."
+        description="Full video recap orchestrator (video-* skill bundle).",
+        allow_abbrev=False,
     )
     parser.add_argument("video", nargs="*")
-    parser.add_argument("--work-dir", default=None)
-    parser.add_argument("--context", default="")
-    parser.add_argument("--scene-threshold", type=float, default=None)
-    parser.add_argument("--style", default="纪录片")
-    parser.add_argument(
+
+    core = parser.add_argument_group("核心流程")
+    core.add_argument("--work-dir", default=None)
+    core.add_argument("--context", default="")
+    core.add_argument("--scene-threshold", type=float, default=None)
+    core.add_argument("--style", default="纪录片")
+    core.add_argument(
         "--edit-mode",
         default=os.environ.get("EDIT_MODE", "full"),
         choices=["full", "cut", "dub"],
     )
-    parser.add_argument(
+    core.add_argument(
         "--target-duration", default=os.environ.get("TARGET_DURATION") or None
     )
-    parser.add_argument(
+    core.add_argument(
         "--allow-duration-drift",
         action="store_true",
         help="cut mode: accept clip duration drift from --target-duration (primary override)",
     )
-    parser.add_argument(
-        "--allow-sparse-cut",
-        action="store_true",
-        help="compatibility: accept sparse cut mapping and legacy duration drift override",
-    )
-    parser.add_argument("--skip-asr", action="store_true")
-    parser.add_argument("--mimo-video-overview", action="store_true")
-    parser.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",
-    )
-    parser.add_argument(
-        "--mimo-qc-refresh",
-        action="store_true",
-        default=env_bool("MIMO_QC_REFRESH", False),
-        help="ignore a matching MiMo QC stage cache",
-    )
-    parser.add_argument(
+    core.add_argument("--output-dir", default=None)
+    core.add_argument("--skip-asr", action="store_true")
+    core.add_argument("--mimo-video-overview", action="store_true")
+    core.add_argument(
         "--consolidate",
         action=argparse.BooleanOptionalAction,
         default=True,
         help="build the understanding story index (Pass B); default ON, --no-consolidate to skip",
     )
-    parser.add_argument(
+    core.add_argument(
         "--consolidate-asr", action="store_true", help="also clean ASR (Pass A)"
     )
-    parser.add_argument("--mimo-tts-voice", default=None, help="MiMo TTS voice")
-    parser.add_argument(
+
+    voice = parser.add_argument_group("声音策略与配音")
+    voice.add_argument("--audio-mode", choices=AUDIO_MODES, default="narration")
+    voice.add_argument("--audio-stream-index", type=int, default=0)
+    voice.add_argument(
         "--tts-provider",
         default=os.environ.get("TTS_PROVIDER", "auto"),
         choices=TTS_PROVIDERS,
-        help="voiceover provider; auto prefers configured MiMo, then Fish Audio",
+        help="voiceover provider; auto prefers configured MiMo, then Fish Audio; Index is explicit",
     )
-    parser.add_argument(
+    voice.add_argument("--mimo-tts-voice", default=None, help="MiMo TTS voice")
+    voice.add_argument(
         "--voice-ref",
         default=None,
         help="reference audio for cloned narration voice (mimo-v2.5-tts-voiceclone)",
     )
-    parser.add_argument(
+    voice.add_argument(
+        "--preserve-approved-text",
+        action="store_true",
+        help="forward strict approved-text preservation to narration voiceover",
+    )
+    voice.add_argument(
         "--allow-partial-tts",
         action="store_true",
         help="allow video-voiceover to continue when some narration segments fail TTS",
     )
-    parser.add_argument(
+    voice.add_argument(
         "--burn-subtitles",
         action=argparse.BooleanOptionalAction,
         default=None,
         help="burn narration subtitles into the video (default on; --no-burn-subtitles to disable)",
     )
-    parser.add_argument(
+    voice.add_argument(
         "--subtitle-y-top",
         type=int,
         default=None,
         help="inclusive auto-rotated display-frame Y at the top of the measured subtitle band",
     )
-    parser.add_argument(
+    voice.add_argument(
         "--subtitle-y-bot",
         type=int,
         default=None,
         help="exclusive auto-rotated display-frame Y at the bottom of the measured subtitle band",
     )
-    parser.add_argument(
+
+    adoption = parser.add_argument_group("本地采用三件套（assembly-only）")
+    adoption.add_argument(
+        "--tts-meta", default=None,
+        help="local adopted tts_meta.json; requires both adoption flags",
+    )
+    adoption.add_argument(
+        "--narration-adoption", default=None,
+        help="local narration_adoption v1; requires --tts-meta and --audio-mix-adoption",
+    )
+    adoption.add_argument(
+        "--audio-mix-adoption", default=None,
+        help="local audio_mix_adoption v1 for assembly-only full-sound rendering",
+    )
+
+    review = parser.add_argument_group("评审、QC 与导出")
+    review.add_argument(
         "--review-narration",
         action=argparse.BooleanOptionalAction,
         default=None,
         help="run advisory narration quality review before TTS (default on; fail-open)",
     )
-    parser.add_argument(
+    review.add_argument(
         "--require-narration-review",
         action="store_true",
         help="make narration review a strict pre-TTS gate (also REQUIRE_NARRATION_REVIEW=1)",
     )
-    parser.add_argument("--output-dir", default=None)
-    parser.add_argument(
+    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",
+    )
+    review.add_argument(
         "--export-jianying",
         action="store_true",
         help="also export an OPTIONAL 剪映/JianYing draft (decoupled; never required)",
     )
-    parser.add_argument(
+    review.add_argument(
         "--jianying-bundle-media",
         action="store_true",
         help="copy media into the 剪映 draft (default on; portable to another machine)",
     )
-    parser.add_argument(
+    review.add_argument(
         "--jianying-no-bundle-media",
         action="store_true",
         help="reference media in place instead of copying it into the draft",
     )
-    parser.add_argument(
+
+    materials = parser.add_argument_group("素材库")
+    materials.add_argument(
         "--material-library-dir",
         default=None,
         help="filesystem material library dir (or VIDEO_RECAP_MATERIAL_LIBRARY_DIR)",
     )
-    parser.add_argument(
+    materials.add_argument(
         "--use-materials",
         action=argparse.BooleanOptionalAction,
         default=False,
         help="restore compatible analyzed artifacts from the material library",
     )
-    parser.add_argument(
+    materials.add_argument(
         "--save-materials",
         action="store_true",
         help="save analyzed JSON/MD artifacts into the material library",
     )
-    parser.add_argument("--doctor", action="store_true")
-    return parser, parser.parse_args()
+
+    materials.add_argument(
+        "--project",
+        default=None,
+        help="recap_project.json（或其所在目录）：绑定资源库里已采用的字幕样式、包装模板、音色与 BGM",
+    )
+
+    selfcheck = parser.add_argument_group("自检")
+    selfcheck.add_argument("--doctor", action="store_true")
+
+    _record_explicit_options(parser)
+    args = parser.parse_args(argv)
+    args._explicit_options = frozenset(getattr(args, "_explicit_options", ()))
+    return parser, args