@oh-story/dsh 0.1.9 → 0.1.11

package/lib/video-recap/skills/video-understanding/scripts/brief_inputs.py

@@ -1,290 +0,0 @@
-"""Validate optional ASR, MiMo, and stage-status inputs for the brief."""
-
-import hashlib
-import json
-from pathlib import Path
-
-from lib import CONFIG, file_fingerprint, stable_hash
-from brief_context import _clean_asr_prompt_fingerprint, _consolidation_model
-
-# Shared with consolidate.py, which this byte-identical copy cannot import (the sibling
-# skill ships no consolidate.py). Keep both literals in sync.
-_ASR_SPAN_TOL = 0.05
-
-_MIMO_REJECTION_MARKERS = (
-    "request was rejected",
-    "considered high risk",
-    "high risk",
-    "content policy",
-    "cannot process",
-    "无法处理",
-    "内容审核",
-    "违规",
-)
-
-
-def _load_clean_asr(work_dir, asr_result):
-    """Return consolidate.py's cleaned ASR segments, or None to fall back to raw asr_result.
-
-    Accepted only when the file is at least as fresh as asr_result.json, its provenance
-    (source_md5 / model / prompt_md5) matches, and every segment keeps its original span
-    within _ASR_SPAN_TOL."""
-    if not asr_result:
-        return None
-    work_dir = Path(work_dir)
-    clean_path = work_dir / "asr_clean.json"
-    src_path = work_dir / "asr_result.json"
-    try:
-        fresh = (
-            clean_path.exists()
-            and clean_path.stat().st_mtime >= src_path.stat().st_mtime
-        )
-    except OSError:
-        return None
-    if not fresh:
-        return None
-    try:
-        payload = json.loads(clean_path.read_text(encoding="utf-8"))
-        source_md5 = hashlib.md5(src_path.read_bytes()).hexdigest()
-    except (OSError, json.JSONDecodeError):
-        return None
-    if not isinstance(payload, dict):
-        return None
-    provenance = {
-        "source_md5": source_md5,
-        "model": _consolidation_model(),
-        "prompt_md5": _clean_asr_prompt_fingerprint(),
-    }
-    if not payload.items() >= provenance.items():
-        return None
-    segments = payload.get("segments")
-    if not isinstance(segments, list) or len(segments) != len(asr_result):
-        return None
-    for orig, clean in zip(asr_result, segments):
-        if (
-            not isinstance(clean, dict)
-            or not isinstance(clean.get("start"), (int, float))
-            or not isinstance(clean.get("end"), (int, float))
-        ):
-            return None
-        if (
-            abs(clean["start"] - orig["start"]) > _ASR_SPAN_TOL
-            or abs(clean["end"] - orig["end"]) > _ASR_SPAN_TOL
-        ):
-            return None
-    return segments
-
-
-def _is_mimo_chunk_usable(content):
-    """A chunk is usable only if MiMo returned real analysis (not empty / a moderation refusal)."""
-    text = (content or "").strip()
-    if not text:
-        return False
-    low = text.lower()
-    return not any(marker in low for marker in _MIMO_REJECTION_MARKERS)
-
-
-def _mimo_video_settings_fingerprint():
-    """Non-secret MiMo video-overview settings that affect generated content."""
-    return {
-        "model": CONFIG["mimo_video_model"],
-        "mimo_video_api_url": CONFIG["mimo_video_api_url"],
-        "mimo_video_fps": CONFIG["mimo_video_fps"],
-        "mimo_media_resolution": CONFIG["mimo_media_resolution"],
-        "mimo_video_chunk_max_seconds": CONFIG["mimo_video_chunk_max_seconds"],
-        "mimo_video_chunk_min_seconds": CONFIG["mimo_video_chunk_min_seconds"],
-        "mimo_video_base64_max_mb": CONFIG["mimo_video_base64_max_mb"],
-        "mimo_video_prompt": CONFIG["mimo_video_prompt"],
-        "mimo_disable_thinking": CONFIG["mimo_disable_thinking"],
-    }
-
-
-def _mimo_chunk_cache_key(chunk):
-    """Stable identifier for a MiMo chunk (index + scene span) for partial-cache reuse."""
-    return f"{chunk['chunk_id']}|{chunk['scene_id']}|{chunk['start']:.3f}-{chunk['end']:.3f}"
-
-
-def _mimo_cached_chunks_fingerprint(done):
-    return stable_hash(done)
-
-
-def _mimo_overview_payload_fingerprint(overview):
-    payload = dict(overview)
-    payload.pop("overview_fingerprint", None)
-    return stable_hash(payload)
-
-
-def _mimo_video_chunks(scenes):
-    """Split scene spans into MiMo video chunks. scenes.json rows carry no scene_id, so the
-    row index stands in for it there."""
-    max_seconds = CONFIG["mimo_video_chunk_max_seconds"]
-    min_seconds = CONFIG["mimo_video_chunk_min_seconds"]
-    chunks = []
-    for scene_index, scene in enumerate(scenes):
-        start, end = scene["start"], scene["end"]
-        scene_id = scene.get("scene_id", scene_index)
-        cursor = start
-        while cursor < end:
-            chunk_end = min(end, cursor + max_seconds)
-            if end - chunk_end < min_seconds and chunk_end < end:
-                chunk_end = end
-            chunks.append(
-                {
-                    "chunk_id": len(chunks),
-                    "scene_id": scene_id,
-                    "start": round(cursor, 3),
-                    "end": round(chunk_end, 3),
-                }
-            )
-            cursor = chunk_end
-    return chunks
-
-
-def _mimo_overview_matches_current_inputs(overview, scenes, video_path=None):
-    """True only when mimo_video_overview.json was produced from the current settings,
-    source video and scene plan, and none of its chunks was moderation-rejected.
-    Provenance keys are read with .get: a stale or partial file simply does not match."""
-    if not isinstance(overview, dict) or overview.get("input") != "scene_chunks":
-        return False
-    settings = _mimo_video_settings_fingerprint()
-    expected_keys = [
-        _mimo_chunk_cache_key(chunk) for chunk in _mimo_video_chunks(scenes)
-    ]
-    chunks = overview.get("chunks")
-    if not isinstance(chunks, list) or not all(
-        isinstance(chunk, dict)
-        and isinstance(chunk.get("content"), str)
-        and _is_mimo_chunk_usable(chunk["content"])
-        for chunk in chunks
-    ):
-        return False
-    if video_path is not None:
-        try:
-            if overview.get("source_video_fingerprint") != file_fingerprint(video_path):
-                return False
-        except OSError:
-            return False
-    try:
-        cached_keys = [_mimo_chunk_cache_key(chunk) for chunk in chunks]
-    except (KeyError, TypeError, ValueError):
-        return False
-    return (
-        overview.get("settings") == settings
-        and overview.get("overview_fingerprint")
-        == _mimo_overview_payload_fingerprint(overview)
-        and overview.get("chunks_fingerprint")
-        == _mimo_cached_chunks_fingerprint(chunks)
-        and cached_keys == expected_keys
-    )
-
-
-def _load_mimo_overview_for_brief(work_dir, scenes, enabled=None, video_path=None):
-    """The current MiMo overview for the brief, or None when disabled, absent or stale."""
-    if not (CONFIG["mimo_video_overview"] if enabled is None else enabled):
-        return None
-    path = Path(work_dir) / "mimo_video_overview.json"
-    if not path.exists():
-        return None
-    try:
-        overview = json.loads(path.read_text(encoding="utf-8"))
-    except (OSError, json.JSONDecodeError):
-        return None
-    if not _mimo_overview_matches_current_inputs(
-        overview, scenes, video_path=video_path
-    ):
-        return None
-    return overview
-
-
-def _load_optional_stage_status(work_dir, filename):
-    """Optional-stage status sidecar, or None when the stage never ran."""
-    path = Path(work_dir) / filename
-    if not path.exists():
-        return None
-    try:
-        status = json.loads(path.read_text(encoding="utf-8"))
-    except (OSError, json.JSONDecodeError):
-        return None
-    if not (
-        isinstance(status, dict)
-        and isinstance(status.get("enabled"), bool)
-        and isinstance(status.get("status"), str)
-        and isinstance(status.get("message"), str)
-    ):
-        return None
-    return status
-
-
-def _optional_stage_warning(stage, status, message):
-    line = f"- {stage}: {status}"
-    return f"{line} — {message[:180]}" if message else line
-
-
-def _format_optional_stage_warnings(
-    work_dir,
-    *,
-    mimo_overview_enabled=None,
-    mimo_overview=None,
-    consolidation_index=None,
-):
-    """Surface fail-open optional-stage loss near the top of the brief."""
-    work_dir = Path(work_dir)
-    warnings = []
-
-    overview_enabled = (
-        CONFIG["mimo_video_overview"]
-        if mimo_overview_enabled is None
-        else mimo_overview_enabled
-    )
-    overview_status = _load_optional_stage_status(
-        work_dir, "mimo_video_overview.status.json"
-    )
-    if (
-        overview_status is not None
-        and overview_status["enabled"]
-        and overview_status["status"] in {"failed", "skipped_no_key"}
-    ):
-        warnings.append(
-            _optional_stage_warning(
-                "mimo_video_overview",
-                overview_status["status"],
-                overview_status["message"],
-            )
-        )
-    elif overview_enabled and not mimo_overview:
-        warnings.append(
-            _optional_stage_warning(
-                "mimo_video_overview",
-                "missing_artifact",
-                "enabled but no valid mimo_video_overview.json is available to this brief",
-            )
-        )
-
-    consolidation_status = _load_optional_stage_status(
-        work_dir, "consolidation.status.json"
-    )
-    if consolidation_status is not None and consolidation_status["enabled"]:
-        if consolidation_status["status"] == "failed":
-            warnings.append(
-                _optional_stage_warning(
-                    "consolidation", "failed", consolidation_status["message"]
-                )
-            )
-        elif consolidation_status.get("do_index") is True and not consolidation_index:
-            warnings.append(
-                _optional_stage_warning(
-                    "consolidation",
-                    "missing_index",
-                    "enabled but no valid understanding_index.json is available to this brief",
-                )
-            )
-
-    if not warnings:
-        return []
-    return [
-        "## Optional stage warnings",
-        "",
-        "These stages are fail-open; continue, but do not assume their missing context exists.",
-        *warnings,
-        "",
-    ]

package/lib/video-recap/skills/video-understanding/scripts/brief_timeline.py

@@ -1,327 +0,0 @@
-"""Remap cut evidence and format output-timeline brief directives."""
-
-import json
-import math
-import re
-from pathlib import Path
-
-from lib import CONFIG, stable_hash
-
-
-def _parse_target_seconds(value):
-    """Parse a cut-mode target duration ("30m" / "600" / "1h5m" / "00:30:00") to seconds.
-
-    None or blank means the knob is unset (None). Any other value that does not parse to
-    a positive duration is a typo in user input and raises ValueError.
-    """
-    if value is None:
-        return None
-    if isinstance(value, (int, float)):
-        seconds = float(value)
-    else:
-        text = str(value).strip().lower()
-        if not text:
-            return None
-        if ":" in text:
-            parts = [float(p) for p in text.split(":")]
-            if len(parts) == 2:
-                seconds = parts[0] * 60 + parts[1]
-            elif len(parts) == 3:
-                seconds = parts[0] * 3600 + parts[1] * 60 + parts[2]
-            else:
-                raise ValueError(f"unparseable target duration: {value!r}")
-            if any(p < 0 for p in parts):
-                raise ValueError(f"unparseable target duration: {value!r}")
-        else:
-            factors = {"ms": 0.001, "s": 1, "m": 60, "h": 3600}
-            seconds = 0.0
-            pos = 0
-            for m in re.finditer(r"([0-9]+(?:\.[0-9]+)?)(ms|s|m|h)?", text):
-                if m.start() != pos:
-                    break
-                pos = m.end()
-                seconds += float(m.group(1)) * factors[m.group(2) or "s"]
-            if pos == 0 or pos != len(text):
-                raise ValueError(f"unparseable target duration: {value!r}")
-    if not seconds > 0:
-        raise ValueError(f"target duration must be positive: {value!r}")
-    return seconds
-
-
-def _format_research_directive(work_dir, substrate):
-    """A loud, actionable research-first directive — but ONLY when the substrate is too thin
-    for real commentary (no dialogue/story spine) and no background_research.json exists yet.
-
-    The narration's quality ceiling is how much story context the agent has: with only frame
-    descriptions it can only narrate pixels, so research the title FIRST (see
-    references/research-guide.md). Fires only for thin/empty substrate — NOT merely because a
-    title was given — so a dialogue-rich titled run is never nagged.
-    """
-    if (Path(work_dir) / "background_research.json").exists():
-        return []  # already researched; _format_background_research surfaces it
-    if substrate["level"] not in ("thin", "empty"):
-        return []  # rich enough to write from dialogue/spine; do not nag
-    context = CONFIG["context_info"].strip()
-    return [
-        "## ⚑ Research the story FIRST (do this before writing narration)",
-        "",
-        "Reason: the understanding substrate is thin — no dialogue/story spine, only frame",
-        "descriptions, so without research the narration can only describe pixels.",
-        "1. Pull the title/keywords from `--context`, the filename, or the user's description"
-        + (f" (context: {context})." if context else "."),
-        "2. Use any available web-search/browser tool to look up synopsis, characters, and",
-        "   relationships (see `references/research-guide.md`).",
-        "3. Write `work_dir/background_research.json`, then re-read this brief and write narration",
-        "   that names people and reads the picture through the plot.",
-        "4. If no tool/network or nothing found: skip — keep beats sparse and strictly grounded in",
-        "   the visible ASR/frame evidence rather than inventing drama.",
-        "",
-    ]
-
-
-def _load_cut_output_spans_for_brief(work_dir, *, required=False):
-    """Load fresh source→output spans for cut pass 2 brief evidence.
-
-    Pass 2 narration is authored against edited_source.mp4's OUTPUT timeline, so
-    ASR chunks and timeline_fusion must use the same OUTPUT clock. Before pass 2
-    (no edited_source.mp4 yet), callers may fall back to source-time evidence; once
-    pass 2 exists, missing/stale validated spans are a hard contract failure.
-    """
-
-    def fail(reason):
-        if required:
-            raise SystemExit(
-                "cut pass2 brief requires fresh clip_plan_validated.json with explicit "
-                f"source/output spans ({reason})"
-            )
-        return None
-
-    work_dir = Path(work_dir)
-    if not (work_dir / "edited_source.mp4").exists():
-        return None
-    validated_path = work_dir / "clip_plan_validated.json"
-    if not validated_path.exists():
-        return fail("missing clip_plan_validated.json")
-    plan = json.loads(validated_path.read_text(encoding="utf-8"))
-    raw_path = work_dir / "clip_plan.json"
-    if raw_path.exists() and plan["raw_plan_fingerprint"] != stable_hash(
-        json.loads(raw_path.read_text(encoding="utf-8"))
-    ):
-        return fail("stale clip_plan_validated.json")
-    spans = []
-    for clip in plan["clips"]:
-        span = {
-            key: clip[key]
-            for key in ("source_start", "source_end", "output_start", "output_end")
-        }
-        if not all(math.isfinite(value) for value in span.values()):
-            return fail("non-finite clip span")
-        if span["source_end"] <= span["source_start"] or span["output_end"] <= span["output_start"]:
-            return fail("non-positive clip span")
-        spans.append(span)
-    return spans or fail("no clips")
-
-
-def _source_output_overlaps_for_brief(start, end, spans):
-    overlaps = []
-    for span in spans:
-        source_start = max(start, span["source_start"])
-        source_end = min(end, span["source_end"])
-        if source_end <= source_start:
-            continue
-        output_start = span["output_start"] + (source_start - span["source_start"])
-        output_end = span["output_start"] + (source_end - span["source_start"])
-        overlaps.append(
-            {
-                "source_start": source_start,
-                "source_end": source_end,
-                "output_start": output_start,
-                "output_end": output_end,
-            }
-        )
-    return overlaps
-
-
-def _remap_frame_facts_for_brief(frame_facts, overlap):
-    out = {}
-    for raw_ts, vals in frame_facts.items():
-        ts = float(raw_ts)
-        if not (overlap["source_start"] <= ts <= overlap["source_end"]):
-            continue
-        out_ts = overlap["output_start"] + (ts - overlap["source_start"])
-        out[f"{out_ts:.3f}"] = vals
-    return out
-
-
-def _remap_scenes_to_output_for_brief(scenes, spans):
-    out = []
-    for scene in scenes:
-        overlaps = _source_output_overlaps_for_brief(scene["start"], scene["end"], spans)
-        for part_idx, overlap in enumerate(overlaps):
-            item = dict(scene)
-            item["start"] = round(overlap["output_start"], 3)
-            item["end"] = round(overlap["output_end"], 3)
-            item["frame_facts"] = _remap_frame_facts_for_brief(
-                scene.get("frame_facts", {}), overlap
-            )
-            if len(overlaps) > 1:
-                item["scene_id"] = f"{scene['scene_id']}.{part_idx}"
-            out.append(item)
-    out.sort(key=lambda x: (x["start"], x["end"]))
-    return out
-
-
-def _remap_segments_to_output_for_brief(segments, spans):
-    out = []
-    for seg in segments:
-        for overlap in _source_output_overlaps_for_brief(seg["start"], seg["end"], spans):
-            item = dict(seg)
-            item["start"] = round(overlap["output_start"], 3)
-            item["end"] = round(overlap["output_end"], 3)
-            if "duration" in item:
-                item["duration"] = round(item["end"] - item["start"], 3)
-            out.append(item)
-    out.sort(key=lambda x: (x["start"], x["end"]))
-    return out
-
-
-def _remap_brief_evidence_to_output_timeline(
-    work_dir, scenes_analysis, asr_result, silence_periods, *, required=False
-):
-    spans = _load_cut_output_spans_for_brief(work_dir, required=required)
-    if not spans:
-        return scenes_analysis, asr_result, silence_periods
-    return (
-        _remap_scenes_to_output_for_brief(scenes_analysis, spans),
-        _remap_segments_to_output_for_brief(asr_result, spans),
-        _remap_segments_to_output_for_brief(silence_periods, spans),
-    )
-
-
-def _read_json(path, default):
-    """JSON artifact, or `default` when the optional file was never written."""
-    return json.loads(path.read_text(encoding="utf-8")) if path.exists() else default
-
-
-def _sentence_entry_anchors_for_brief(work_dir, edit_mode):
-    """Load sentence anchors and remap them to cut OUTPUT time when needed."""
-    work_dir = Path(work_dir)
-    anchors = [
-        dict(item)
-        for item in _read_json(
-            work_dir / "speech_boundary_anchors.json", {"sentence_anchors": []}
-        )["sentence_anchors"]
-    ]
-    if edit_mode != "cut" or not (work_dir / "edited_source.mp4").exists():
-        return anchors
-
-    spans = _load_cut_output_spans_for_brief(work_dir, required=True)
-    remapped = []
-    for anchor in anchors:
-        source_time = anchor["time"]
-        for span in spans:
-            if span["source_start"] - 0.05 <= source_time <= span["source_end"] + 0.05:
-                item = dict(anchor)
-                item["source_time"] = round(source_time, 3)
-                item["time"] = round(
-                    span["output_start"] + source_time - span["source_start"], 3
-                )
-                # Preserve the measured safe pause in OUTPUT time too, so cut-mode lint
-                # compares one clock.
-                source_pause_start = max(
-                    span["source_start"], min(anchor.get("pause_start", source_time - 0.12), source_time)
-                )
-                item["source_pause_start"] = round(source_pause_start, 3)
-                item["pause_start"] = round(
-                    span["output_start"] + source_pause_start - span["source_start"], 3
-                )
-                remapped.append(item)
-
-    speech_rows = [
-        row for row in _read_json(work_dir / "asr_result.json", []) if row["text"]
-    ]
-    quiet_rows = [
-        row
-        for row in _read_json(work_dir / "silence_periods.json", [])
-        if not row["has_speech"]
-    ]
-    out_payload = {
-        "schema_version": 2,
-        "artifact": "speech_boundary_anchors_output.json",
-        "timeline": "cut_output",
-        "source_artifact": "speech_boundary_anchors.json",
-        "clip_plan_fingerprint": stable_hash(
-            json.loads((work_dir / "clip_plan_validated.json").read_text(encoding="utf-8"))
-        ),
-        "sentence_anchors": sorted(remapped, key=lambda item: item["time"]),
-        "speech_spans": _remap_segments_to_output_for_brief(speech_rows, spans),
-        "quiet_windows": _remap_segments_to_output_for_brief(quiet_rows, spans),
-    }
-    (work_dir / "speech_boundary_anchors_output.json").write_text(
-        json.dumps(out_payload, ensure_ascii=False, indent=2), encoding="utf-8"
-    )
-    return out_payload["sentence_anchors"]
-
-
-def _format_sentence_entry_anchors_for_brief(work_dir, edit_mode):
-    anchors = [
-        anchor
-        for anchor in _sentence_entry_anchors_for_brief(work_dir, edit_mode)
-        if anchor["confidence"] in {"high", "medium"}
-    ]
-    if not anchors:
-        return []
-    lines = [
-        "## 原声句末安全切入点",
-        "",
-        "这些时间是 ASR 句末标点与短声学停顿对齐后的旁白安全入口。旁白在原声已开始后切入时，"
-        "必须从其中一个点开始；否则会在 TTS 前被 `interrupts_source_sentence` 硬阻断。",
-        "- 调整方式：优先把 `start` 移到建议锚点；放不下时缩短文本、移动整块或删除该旁白，不能让脚本静默挪音频。",
-        '- 原声句子完整性是硬约束：切入块写 `"source_entry_policy": "sentence_boundary"`；'
-        "不存在 `intentional_interrupt` 绕过方式。没有后续可靠句末锚点时，移动、缩短或删除旁白块。",
-    ]
-    for anchor in anchors:
-        source_suffix = (
-            f" (SOURCE {anchor['source_time']:.2f}s)" if "source_time" in anchor else ""
-        )
-        text_tail = str(anchor.get("text_tail", "")).strip()
-        lines.append(
-            f"- {anchor['time']:.2f}s [{anchor['confidence']}]{source_suffix} {text_tail}".rstrip()
-        )
-    lines.append("")
-    return lines
-
-
-def _format_output_clip_list(work_dir):
-    """List the kept clips on the OUTPUT timeline (cut-first/narrate-second pass 2), so the
-    agent narrates against the real rendered cut instead of the source timeline."""
-    path = Path(work_dir) / "clip_plan_validated.json"
-    if not path.exists():
-        return []
-    plan = json.loads(path.read_text(encoding="utf-8"))
-    out = ["## Kept clips on the OUTPUT timeline", ""]
-    for c in plan["clips"]:
-        reason = c.get("reason", "")
-        out.append(
-            f"- OUTPUT {c['output_start']:.1f}–{c['output_end']:.1f}s ← SOURCE[{c.get('source_id', '0')}] "
-            f"{c['source_start']:.1f}–{c['source_end']:.1f}s (clip_id={c.get('clip_id', '?')})"
-            + (f" — {reason}" if reason else "")
-        )
-    out.append("")
-    return out if len(out) > 2 else []
-
-
-def _write_deslop_qc_requirements(work_dir):
-    """Write the stable deslop QC contract consumed by deslop_qc.py.
-
-    style_card_required defaults to False (advisory): a missing style_card.json is a
-    warning, not a render-blocking error. A future opt-in run can set it True to make
-    style_card.json a hard requirement — deslop_qc.py reads that field.
-    """
-    payload = {
-        "schema_version": 1,
-        "style_card_required": False,
-    }
-    path = Path(work_dir) / "deslop_qc_requirements.json"
-    path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
-    return path