@oh-story/dsh 0.1.8 → 0.1.10

package/lib/video-recap/skills/video-script/scripts/review_response.py

@@ -114,36 +114,15 @@ def merge_review_findings(chunks):
 
 
 def _bundle_fingerprint(bundle):
-    try:
-        return stable_hash(
-            {
-                "schema_version": bundle.get("schema_version"),
-                "clock": bundle.get("clock"),
-                "coverage": bundle.get("coverage"),
-                "items": bundle.get("items"),
-                "context_items": bundle.get("context_items"),
-            }
-        )
-    except (TypeError, ValueError, RecursionError) as exc:
-        if isinstance(bundle, dict):
-            bundle.setdefault("metadata", {})["evidence_bundle_fingerprint_warning"] = (
-                f"evidence bundle fingerprint unavailable: {type(exc).__name__}"
-            )
-        return ""
-
-
-def _bundle_fingerprint_warning(bundle):
-    if not isinstance(bundle, dict):
-        return "evidence bundle fingerprint unavailable: invalid bundle"
-    warning = (bundle.get("metadata") or {}).get("evidence_bundle_fingerprint_warning")
-    if warning:
-        return warning
-    return ""
-
-
-def _append_warning_once(target, warning):
-    if warning and warning not in target:
-        target.append(warning)
+    return stable_hash(
+        {
+            "schema_version": bundle.get("schema_version"),
+            "clock": bundle.get("clock"),
+            "coverage": bundle.get("coverage"),
+            "items": bundle.get("items"),
+            "context_items": bundle.get("context_items"),
+        }
+    )
 
 
 def _bundle_prompt_size(bundle):
@@ -163,13 +142,9 @@ def _chunk_evidence_bundle(bundle, *, max_items=80, max_chars=12000):
         one = dict(bundle)
         one["chunk_index"] = 0
         one["chunk_count"] = 1
-        fp = _bundle_fingerprint(bundle)
-        fp_warning = _bundle_fingerprint_warning(bundle)
-        one.setdefault("metadata", {})["evidence_bundle_fingerprint"] = fp
-        if fp_warning:
-            one["metadata"]["evidence_bundle_fingerprint_warning"] = fp_warning
-            one.setdefault("warnings", list(bundle.get("warnings") or []))
-            _append_warning_once(one["warnings"], fp_warning)
+        one.setdefault("metadata", {})["evidence_bundle_fingerprint"] = (
+            _bundle_fingerprint(bundle)
+        )
         return [one]
     ranges = bundle.get("coverage", {}).get("selected_ranges") or []
     chunks = []
@@ -210,15 +185,10 @@ def _chunk_evidence_bundle(bundle, *, max_items=80, max_chars=12000):
         chunks = [chunk]
     count = len(chunks)
     fp = _bundle_fingerprint(bundle)
-    fp_warning = _bundle_fingerprint_warning(bundle)
     for chunk in chunks:
         chunk["chunk_count"] = count
         chunk.setdefault("metadata", {})["chunked_review"] = count > 1
         chunk["metadata"]["evidence_bundle_fingerprint"] = fp
-        if fp_warning:
-            chunk["metadata"]["evidence_bundle_fingerprint_warning"] = fp_warning
-            chunk.setdefault("warnings", list(bundle.get("warnings") or []))
-            _append_warning_once(chunk["warnings"], fp_warning)
     return chunks
 
 

package/lib/video-recap/skills/video-script/scripts/review_runner.py

@@ -17,9 +17,7 @@ from review_grounding import (
     remap_grounding_to_output_timeline,
 )
 from review_response import (
-    _append_warning_once,
     _bundle_fingerprint,
-    _bundle_fingerprint_warning,
     _chunk_evidence_bundle,
     _load_review_research_context,
     _merge_chunk_reviews,
@@ -65,10 +63,6 @@ def review_narration(work_dir, *, timeline="source", strict_evidence=False):
         warnings=warnings,
     )
     bundle_fp = _bundle_fingerprint(bundle)
-    fp_warning = _bundle_fingerprint_warning(bundle)
-    if fp_warning:
-        _append_warning_once(warnings, fp_warning)
-        _append_warning_once(bundle.setdefault("warnings", []), fp_warning)
     chunk_reviews = []
     chunks = _chunk_evidence_bundle(bundle)
     for chunk in chunks:

package/lib/video-recap/skills/video-script/scripts/speech_ownership.py

@@ -1,7 +1,6 @@
 """Load measured source-speech evidence and classify narration ownership."""
 
 import json
-import math
 from pathlib import Path
 
 from lib import CONFIG, stable_hash
@@ -17,36 +16,16 @@ def _empty_evidence(mode):
 
 
 def _read_json(path):
-    try:
-        return json.loads(Path(path).read_text(encoding="utf-8"))
-    except (OSError, json.JSONDecodeError):
-        return None
-
-
-def _timed_rows(payload, key):
-    rows = payload.get(key, []) if isinstance(payload, dict) else []
-    out = []
-    for row in rows if isinstance(rows, list) else []:
-        if not isinstance(row, dict):
-            continue
-        try:
-            start, end = float(row.get("start")), float(row.get("end"))
-        except (TypeError, ValueError):
-            continue
-        if math.isfinite(start) and math.isfinite(end) and end > start:
-            out.append({**row, "start": start, "end": end})
-    return out
+    """JSON artifact, or None when the optional file was never written."""
+    return json.loads(path.read_text(encoding="utf-8")) if path.exists() else None
 
 
 def _output_payload_is_current(payload, work_dir):
-    if not isinstance(payload, dict):
-        return False
-    if payload.get("schema_version") != 2 or payload.get("timeline") != "cut_output":
-        return False
     plan = _read_json(Path(work_dir) / "clip_plan_validated.json")
-    return bool(
-        isinstance(plan, dict)
-        and payload.get("clip_plan_fingerprint") == stable_hash(plan)
+    return (
+        payload is not None
+        and plan is not None
+        and payload["clip_plan_fingerprint"] == stable_hash(plan)
     )
 
 
@@ -55,55 +34,31 @@ def load_source_sentence_evidence(work_dir, mode="full"):
     if work_dir is None:
         return _empty_evidence(mode)
     work_dir = Path(work_dir)
-    output_mode = mode in {"cut", "cut_output"}
-    path = work_dir / (
-        "speech_boundary_anchors_output.json"
-        if output_mode
-        else "speech_boundary_anchors.json"
-    )
-    payload = _read_json(path)
-    if mode == "cut_output" and not _output_payload_is_current(payload, work_dir):
-        return _empty_evidence(mode)
-    if not isinstance(payload, dict):
-        payload = {}
-
-    speech_spans = _timed_rows(payload, "speech_spans")
-    quiet_windows = _timed_rows(payload, "quiet_windows")
-    if not output_mode:
-        for name in ("asr_result.json", "asr_clean.json"):
-            raw = _read_json(work_dir / name)
-            if isinstance(raw, list):
-                candidate = {"speech_spans": raw}
-            elif isinstance(raw, dict):
-                candidate = {"speech_spans": raw.get("segments", [])}
-            else:
-                continue
-            speech_spans = _timed_rows(candidate, "speech_spans")
-            if speech_spans:
-                break
-        raw_quiet = _read_json(work_dir / "silence_periods.json")
-        candidate = {
-            "quiet_windows": [
-                row
-                for row in raw_quiet
-                if isinstance(row, dict) and not bool(row.get("has_speech", False))
-            ]
-        } if isinstance(raw_quiet, list) else {}
-        quiet_windows = _timed_rows(candidate, "quiet_windows")
-
-    anchors = []
-    for anchor in payload.get("sentence_anchors", []):
-        if not isinstance(anchor, dict) or anchor.get("confidence") not in {
-            "high",
-            "medium",
-        }:
-            continue
-        try:
-            when = float(anchor.get("time"))
-        except (TypeError, ValueError):
-            continue
-        if math.isfinite(when) and when >= 0:
-            anchors.append({**anchor, "time": round(when, 3)})
+    if mode == "full":
+        payload = _read_json(work_dir / "speech_boundary_anchors.json") or {
+            "sentence_anchors": []
+        }
+        speech_spans = [
+            row for row in _read_json(work_dir / "asr_result.json") or [] if row["text"]
+        ]
+        quiet_windows = [
+            row
+            for row in _read_json(work_dir / "silence_periods.json") or []
+            if not row["has_speech"]
+        ]
+    else:
+        payload = _read_json(work_dir / "speech_boundary_anchors_output.json")
+        if mode == "cut_output" and not _output_payload_is_current(payload, work_dir):
+            return _empty_evidence(mode)
+        if payload is None:
+            payload = {"sentence_anchors": [], "speech_spans": [], "quiet_windows": []}
+        speech_spans = payload["speech_spans"]
+        quiet_windows = payload["quiet_windows"]
+    anchors = [
+        anchor
+        for anchor in payload["sentence_anchors"]
+        if anchor["confidence"] in {"high", "medium"}
+    ]
     return {
         "anchors": sorted(anchors, key=lambda item: item["time"]),
         "speech_spans": speech_spans,
@@ -147,16 +102,9 @@ def _speech_overlap_excluding_quiet(start, end, speech, quiet):
 
 def segment_overlaps_source_speech(seg, evidence):
     """Classify aggregate mix ownership across the complete narration interval."""
-    try:
-        start, end = float(seg.get("start")), float(seg.get("end"))
-    except (AttributeError, TypeError, ValueError):
-        return bool(getattr(seg, "get", lambda *_: True)("overlaps_speech", True))
-    duration = max(0.0, end - start)
+    start, end = seg["start"], seg["end"]
     quiet = evidence["quiet_windows"]
-    quiet_min = max(
-        0.3,
-        duration * float(CONFIG.get("quiet_overlap_min_ratio", 0.8) or 0.8),
-    )
+    quiet_min = max(0.3, (end - start) * CONFIG["quiet_overlap_min_ratio"])
     speech = evidence["speech_spans"]
     if speech:
         return _speech_overlap_excluding_quiet(start, end, speech, quiet) > 0.05
@@ -167,12 +115,8 @@ def segment_overlaps_source_speech(seg, evidence):
     return bool(seg.get("overlaps_speech", True))
 
 
-def entry_overlaps_source_speech(seg, evidence, tolerance=0.05):
+def entry_overlaps_source_speech(start, evidence, *, authored_overlap=True, tolerance=0.05):
     """Classify the entry instant; later quiet time cannot erase an unsafe start."""
-    try:
-        start = float(seg.get("start"))
-    except (AttributeError, TypeError, ValueError):
-        return True
     if any(
         row["start"] - tolerance <= start <= row["end"] + tolerance
         for row in evidence["quiet_windows"]
@@ -187,18 +131,13 @@ def entry_overlaps_source_speech(seg, evidence, tolerance=0.05):
         return False
     if evidence["anchors"] or evidence["require_measured"]:
         return True
-    return bool(seg.get("overlaps_speech", True))
+    return bool(authored_overlap)
 
 
 def measure_narration_speech_ownership(narration, work_dir, mode="full"):
     """Return narration copies with aggregate ownership derived from evidence."""
     evidence = load_source_sentence_evidence(work_dir, mode=mode)
-    measured = []
-    for seg in narration if isinstance(narration, list) else []:
-        if not isinstance(seg, dict):
-            measured.append(seg)
-            continue
-        item = dict(seg)
-        item["overlaps_speech"] = segment_overlaps_source_speech(item, evidence)
-        measured.append(item)
-    return measured
+    return [
+        {**seg, "overlaps_speech": segment_overlaps_source_speech(seg, evidence)}
+        for seg in narration
+    ]

package/lib/video-recap/skills/video-script/scripts/timeline_fusion.py

@@ -1,88 +1,49 @@
 """Fuse scenes, ASR, and quiet windows for narration planning."""
 
-import importlib.util
-
-
-from pathlib import Path
-
 from lib import CONFIG
-
-
 from agent_text import _overlap_seconds, _recommended_char_budget
 from narration_lint import _validate_narration_budget
 
-try:
-    from deslop_qc import analyze_deslop_qc
-except ModuleNotFoundError:
-    _deslop_qc_path = Path(__file__).with_name("deslop_qc.py")
-    _deslop_qc_spec = importlib.util.spec_from_file_location(
-        "deslop_qc", _deslop_qc_path
-    )
-    if _deslop_qc_spec is None or _deslop_qc_spec.loader is None:
-        raise
-    _deslop_qc_module = importlib.util.module_from_spec(_deslop_qc_spec)
-    _deslop_qc_spec.loader.exec_module(_deslop_qc_module)
-    analyze_deslop_qc = _deslop_qc_module.analyze_deslop_qc
+
+def _quiet_windows(silence_periods):
+    return [qp for qp in silence_periods if not qp["has_speech"]]
 
 
 def _align_narration_to_quiet(narration, scenes_analysis, silence_periods):
     """Recompute overlaps_speech from real quiet windows; keep the agent's timing.
 
     The dense continuous-bed design places narration ON the pictured beat over a
-    ducked original bed, so we no longer relocate segments into silence gaps. The
-    old shift moved voiceover up to 3s off the moment it was written for and could
-    silently blank a squeezed segment; both fought the design intent. We now only
-    correct the overlaps_speech flag that the ducking stage consumes, leaving the
-    agent's start/end (and text) intact.
-    """
-    if not silence_periods:
-        for n in narration:
-            n["overlaps_speech"] = True
-        return _validate_narration_budget(narration, scenes_analysis)
+    ducked original bed, so segments are never relocated into silence gaps. Only
+    the overlaps_speech flag that the ducking stage consumes is corrected, leaving
+    the agent's start/end (and text) intact.
 
-    quiet_windows = [
-        qp for qp in silence_periods if _silence_window_is_usable_quiet(qp)
-    ]
-    quiet_ratio_min = float(CONFIG.get("quiet_overlap_min_ratio", 0.8) or 0.8)
-
-    # Run budget/dedup FIRST, then set the flag on the final (possibly merged) spans,
-    # so a dedup-merged beat's overlaps_speech reflects its extended timing, not its
-    # original shorter span (which the ducking stage in assemble.py would mis-duck).
+    Budget/dedup runs FIRST so a dedup-merged beat's overlaps_speech reflects its
+    extended timing, not its original shorter span.
+    """
     aligned = _validate_narration_budget(narration, scenes_analysis)
+    quiet_windows = _quiet_windows(silence_periods)
+    quiet_ratio_min = CONFIG["quiet_overlap_min_ratio"]
     for n in aligned:
-        try:
-            seg_start = float(n["start"])
-            seg_end = float(n["end"])
-        except (KeyError, TypeError, ValueError):
-            n["overlaps_speech"] = True
-            continue
-        seg_dur = max(0.0, seg_end - seg_start)
-        quiet_overlap = _quiet_overlap_seconds(seg_start, seg_end, quiet_windows)
+        seg_dur = n["end"] - n["start"]
+        quiet_overlap = sum(
+            _overlap_seconds(n["start"], n["end"], qw["start"], qw["end"])
+            for qw in quiet_windows
+        )
         n["overlaps_speech"] = quiet_overlap < max(0.3, seg_dur * quiet_ratio_min)
-
     return aligned
 
 
 def _scene_asr_lines(asr_result, scene):
     lines = []
-    for seg in asr_result or []:
-        try:
-            start = float(seg.get("start", 0))
-            end = float(seg.get("end", start))
-        except (TypeError, ValueError):
-            continue
-        if scene["start"] < end and scene["end"] > start:
-            text = str(seg.get("text", "")).strip()
-            if text:
-                lines.append(f"    [{start:.1f}-{end:.1f}] {text}")
+    for seg in asr_result:
+        if scene["start"] < seg["end"] and scene["end"] > seg["start"] and seg["text"]:
+            lines.append(f"    [{seg['start']:.1f}-{seg['end']:.1f}] {seg['text']}")
     return lines
 
 
 def _quiet_windows_for_scene(silence_periods, scene):
     windows = []
-    for qp in silence_periods or []:
-        if not _silence_window_is_usable_quiet(qp):
-            continue
+    for qp in _quiet_windows(silence_periods):
         if qp["start"] < scene["end"] and qp["end"] > scene["start"]:
             start = max(qp["start"], scene["start"])
             end = min(qp["end"], scene["end"])
@@ -91,87 +52,35 @@ def _quiet_windows_for_scene(silence_periods, scene):
     return windows
 
 
-def _silence_window_is_usable_quiet(qp):
-    if not isinstance(qp, dict):
-        return False
-    reason = str(qp.get("has_speech_reason", "")).lower()
-    granularity = str(qp.get("asr_granularity", "")).lower()
-    if reason in {
-        "coarse_asr_overlap_ignored",
-        "asr_overlap_low_confidence_quiet",
-        "coarse_asr_no_overlap",
-    }:
-        return True
-    if granularity == "coarse_grid" and qp.get("has_speech") is True:
-        return True
-    return not qp.get("has_speech", False)
-
-
-def _quiet_overlap_seconds(start, end, quiet_windows):
-    overlap_seconds = 0.0
-    for qw in quiet_windows:
-        try:
-            if isinstance(qw, dict):
-                q_start = float(qw.get("start", 0))
-                q_end = float(qw.get("end", q_start))
-            else:
-                q_start, q_end = qw
-                q_start = float(q_start)
-                q_end = float(q_end)
-        except (TypeError, ValueError):
-            continue
-        overlap_seconds += _overlap_seconds(start, end, q_start, q_end)
-    return overlap_seconds
-
-
 def _build_timeline_fusion(scenes, asr_segments, silence_periods):
     """Fuse VLM scenes, ASR dialogue and quiet narration slots on one timeline."""
     fusion = []
-    quiet_windows = [
-        w for w in silence_periods or [] if _silence_window_is_usable_quiet(w)
-    ]
-    for scene in scenes or []:
-        try:
-            start = float(scene.get("start", 0))
-            end = float(scene.get("end", start))
-        except (TypeError, ValueError):
-            continue
+    quiet_windows = _quiet_windows(silence_periods)
+    for scene in scenes:
+        start, end = scene["start"], scene["end"]
         dialogue_segments = []
         dialogue_overlap = 0.0
-        for seg in asr_segments or []:
-            if not isinstance(seg, dict):
-                continue
-            try:
-                seg_start = float(seg.get("start", 0))
-                seg_end = float(seg.get("end", seg_start))
-            except (TypeError, ValueError):
-                continue
-            overlap = _overlap_seconds(start, end, seg_start, seg_end)
+        for seg in asr_segments:
+            overlap = _overlap_seconds(start, end, seg["start"], seg["end"])
             if overlap <= 0:
                 continue
-            text = str(seg.get("text", "")).strip()
             dialogue_overlap += overlap
             dialogue_segments.append(
                 {
-                    "start": round(seg_start, 2),
-                    "end": round(seg_end, 2),
+                    "start": round(seg["start"], 2),
+                    "end": round(seg["end"], 2),
                     "overlap_seconds": round(overlap, 2),
-                    "text": text,
+                    "text": seg["text"],
                 }
             )
 
         narration_slots = []
         for window in quiet_windows:
-            try:
-                w_start = float(window.get("start", 0))
-                w_end = float(window.get("end", w_start))
-            except (TypeError, ValueError):
-                continue
-            overlap = _overlap_seconds(start, end, w_start, w_end)
+            overlap = _overlap_seconds(start, end, window["start"], window["end"])
             if overlap <= 0:
                 continue
-            slot_start = max(start, w_start)
-            slot_end = min(end, w_end)
+            slot_start = max(start, window["start"])
+            slot_end = min(end, window["end"])
             narration_slots.append(
                 {
                     "start": round(slot_start, 2),
@@ -183,9 +92,9 @@ def _build_timeline_fusion(scenes, asr_segments, silence_periods):
 
         fusion.append(
             {
-                "scene_id": scene.get("scene_id"),
+                "scene_id": scene["scene_id"],
                 "time_range": [round(start, 2), round(end, 2)],
-                "visual_description": scene.get("description", ""),
+                "visual_description": scene["description"],
                 "depth_analysis": scene.get("depth_analysis", ""),
                 "frame_facts": scene.get("frame_facts", {}),
                 "dialogue_segments": dialogue_segments,

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

@@ -220,7 +220,7 @@ def build_agent_brief(
     lines.extend(_format_timeline_fusion_for_brief(timeline_fusion))
     lines.extend(_format_sentence_entry_anchors_for_brief(work_dir, edit_mode))
 
-    overview_text = (mimo_overview.get("content") or "").strip()
+    overview_text = (mimo_overview or {}).get("content", "").strip()
     if overview_text:
         lines.extend(
             [