@oh-story/dsh 0.1.8 → 0.1.9

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

@@ -2,18 +2,12 @@
 
 from __future__ import annotations
 
-
 import hashlib
-
 import json
-
-
 import os
-
-
 from pathlib import Path
-
-from typing import Any, Mapping, Sequence
+from typing import Any
+from collections.abc import Mapping, Sequence
 
 import qc_contract
 from mimo_qc_client import DEFAULT_CONFIG
@@ -62,13 +56,8 @@ def _fingerprint_value(value: Any) -> str:
     return hashlib.sha256(_stable_json(value).encode("utf-8")).hexdigest()
 
 
-def _redact(value: Any) -> Any:
-    return qc_contract.redact_secrets(value)
-
-
 def _load_json(path: Path) -> Any:
-    with path.open("r", encoding="utf-8") as handle:
-        return _redact(json.load(handle))
+    return json.loads(path.read_text(encoding="utf-8"))
 
 
 def _read_text_sample(path: Path, *, max_chars: int = 4000) -> dict[str, Any]:
@@ -77,7 +66,7 @@ def _read_text_sample(path: Path, *, max_chars: int = 4000) -> dict[str, Any]:
         "kind": "text",
         "bytes": path.stat().st_size,
         "truncated": len(text) > max_chars,
-        "sample": _redact(text[:max_chars]),
+        "sample": text[:max_chars],
     }
 
 
@@ -85,7 +74,6 @@ def _summarize(
     value: Any, *, max_items: int = 8, max_string: int = 700, depth: int = 0
 ) -> Any:
     """Keep request/report evidence bounded while retaining useful structure."""
-    value = _redact(value)
     if depth >= 4:
         return {"type": type(value).__name__, "fingerprint": _fingerprint_value(value)}
     if isinstance(value, Mapping):
@@ -118,22 +106,17 @@ def _collect_file(work_dir: Path, name: str) -> dict[str, Any] | None:
     path = work_dir / name
     if not path.is_file():
         return None
-    try:
-        if path.suffix.lower() == ".json":
-            summary = _summarize(_load_json(path))
-            kind = "json"
-        else:
-            summary = _summarize(_read_text_sample(path))
-            kind = "text"
-        return {
-            "path": name,
-            "kind": kind,
-            "bytes": path.stat().st_size,
-            "fingerprint": qc_contract.artifact_fingerprint(path),
-            "summary": summary,
-        }
-    except Exception as exc:  # evidence collection is advisory too
-        return {"path": name, "kind": "unreadable", "error": type(exc).__name__}
+    if path.suffix.lower() == ".json":
+        kind, summary = "json", _summarize(_load_json(path))
+    else:
+        kind, summary = "text", _summarize(_read_text_sample(path))
+    return {
+        "path": name,
+        "kind": kind,
+        "bytes": path.stat().st_size,
+        "fingerprint": qc_contract.artifact_fingerprint(path),
+        "summary": summary,
+    }
 
 
 def _first_existing(work_dir: Path, names: Sequence[str]) -> str | None:
@@ -145,32 +128,21 @@ def _collect_multi_source_asr(work_dir: Path) -> dict[str, Any]:
     manifest_path = work_dir / "multi_source_manifest.json"
     if not manifest_path.is_file():
         return {}
-    try:
-        manifest = _load_json(manifest_path)
-    except Exception:
-        return {}
-    sources = manifest.get("sources") if isinstance(manifest, Mapping) else None
-    if not isinstance(sources, list):
-        return {}
+    root = work_dir.resolve(strict=False)
     collected = {}
-    for source in sources:
-        if not isinstance(source, Mapping):
-            continue
-        source_id = str(source.get("source_id") or "").strip()
-        relative_dir = str(source.get("source_work_dir") or "").strip()
-        if not source_id or not relative_dir:
-            continue
-        source_dir = (work_dir / relative_dir).resolve(strict=False)
-        try:
-            source_dir.relative_to(work_dir.resolve(strict=False))
-        except ValueError:
+    for source in _load_json(manifest_path)["sources"]:
+        relative_dir = source["source_work_dir"]
+        source_dir = (root / relative_dir).resolve(strict=False)
+        if not source_dir.is_relative_to(root):
             continue
-        relative_name = _first_existing(source_dir, _SOURCE_ASR_ARTIFACTS)
-        if not relative_name:
-            continue
-        item = _collect_file(work_dir, str(Path(relative_dir) / relative_name))
-        if item is not None:
-            collected[source_id] = item
+        name = _first_existing(source_dir, _SOURCE_ASR_ARTIFACTS)
+        if name is not None:
+            evidence_path = (source_dir / name).resolve(strict=False)
+            if not evidence_path.is_relative_to(root):
+                continue
+            collected[source["source_id"]] = _collect_file(
+                root, str(evidence_path.relative_to(root))
+            )
     return collected
 
 
@@ -187,14 +159,7 @@ def _final_output_candidates(
         raw.append(final_output)
     manifest_path = work_dir / "assembly_manifest.json"
     if manifest_path.is_file():
-        try:
-            manifest = _load_json(manifest_path)
-            if isinstance(manifest, Mapping):
-                for key in ("final_output", "output", "output_path", "video_path"):
-                    if manifest.get(key):
-                        raw.append(str(manifest[key]))
-        except Exception:
-            pass
+        raw.append(_load_json(manifest_path)["final_output"])
     raw.extend(("output.mp4", "recap.mp4", "final.mp4"))
     seen: set[str] = set()
     result = []
@@ -221,7 +186,7 @@ def _final_output_metadata(
                 }
             )
         outputs.append(item)
-    return {"candidates": _redact(outputs)}
+    return {"candidates": outputs}
 
 
 def _existing_final_output(
@@ -279,41 +244,28 @@ def collect_evidence(
     if not evidence["source_asr"]:
         evidence["source_asr"] = _collect_multi_source_asr(root)
     evidence["fingerprint"] = _fingerprint_value(_cache_evidence(evidence))
-    return _redact(evidence)
+    # The evidence goes into the MiMo request as well as the persisted report, so it is
+    # redacted here, before either.
+    return qc_contract.redact_secrets(evidence)
 
 
 def _cache_file_group(group: Mapping[str, Any]) -> dict[str, Any]:
     return {
-        name: {
-            key: item.get(key)
-            for key in ("kind", "bytes", "fingerprint")
-            if isinstance(item, Mapping) and item.get(key) is not None
-        }
+        name: {key: item[key] for key in ("kind", "bytes", "fingerprint")}
         for name, item in sorted(group.items())
     }
 
 
 def _cache_evidence(evidence: Mapping[str, Any]) -> dict[str, Any]:
-    final_items = []
-    final_output = evidence.get("final_output")
-    if isinstance(final_output, Mapping):
-        for item in final_output.get("candidates", []):
-            if isinstance(item, Mapping):
-                final_items.append(
-                    {
-                        key: item.get(key)
-                        for key in ("exists", "bytes", "fingerprint")
-                        if key in item
-                    }
-                )
     return {
-        "artifacts": _cache_file_group(evidence.get("artifacts", {})),
-        "source_asr": _cache_file_group(evidence.get("source_asr", {})),
-        "generated_subtitles": _cache_file_group(
-            evidence.get("generated_subtitles", {})
-        ),
-        "visual_metadata": _cache_file_group(evidence.get("visual_metadata", {})),
-        "final_output": final_items,
+        "artifacts": _cache_file_group(evidence["artifacts"]),
+        "source_asr": _cache_file_group(evidence["source_asr"]),
+        "generated_subtitles": _cache_file_group(evidence["generated_subtitles"]),
+        "visual_metadata": _cache_file_group(evidence["visual_metadata"]),
+        "final_output": [
+            {key: item[key] for key in ("exists", "bytes", "fingerprint") if key in item}
+            for item in evidence["final_output"]["candidates"]
+        ],
     }
 
 
@@ -325,7 +277,7 @@ def _effective_config(config: Mapping[str, Any] | None = None) -> dict[str, Any]
             source["mimo_qc_model"] = (
                 config.get("mimo_video_model")
                 or config.get("mimo_model")
-                or source.get("mimo_qc_model")
+                or source["mimo_qc_model"]
             )
     # MIMO_QC_MODEL is intentionally read at call time for embedded/CLI tests and
     # long-running agent processes whose environment may be adjusted between runs.
@@ -354,18 +306,15 @@ def safe_mimo_config(config: Mapping[str, Any] | None = None) -> dict[str, Any]:
         "mimo_media_resolution",
         "mimo_media_resolution_source",
     )
-    safe = {key: source[key] for key in keep if key in source}
+    safe = {key: source[key] for key in keep}
     safe["model"] = (
-        source.get("mimo_qc_model")
-        or source.get("mimo_video_model")
-        or source.get("mimo_model")
-        or "mimo-v2.5"
+        source["mimo_qc_model"] or source["mimo_video_model"] or source["mimo_model"]
     )
     key_present = bool(
         source.get("mimo_video_api_key")
         or source.get("mimo_api_key")
         or source.get("api_key")
     )
-    safe = _redact(safe)
+    safe = qc_contract.redact_secrets(safe)
     safe["key_present"] = key_present
     return safe

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

@@ -2,18 +2,13 @@
 
 from __future__ import annotations
 
-
 import json
-
-
 import re
-
-
-from typing import Any, Mapping
+from typing import Any
+from collections.abc import Mapping
 
 import qc_contract
-
-from mimo_qc_evidence import _fingerprint_value, _redact, _summarize, safe_mimo_config
+from mimo_qc_evidence import _fingerprint_value, _summarize, safe_mimo_config
 from mimo_qc_payload import _strip_json_fence
 from mimo_qc_contract import (
     ARTIFACT_NAME,
@@ -24,11 +19,11 @@ from mimo_qc_contract import (
 
 
 def _extract_observations(model_output: Any) -> list[Mapping[str, Any]]:
-    model_output = _redact(model_output)
+    """Bound whatever shape the model (or an offline fixture) returned to observation dicts."""
     if isinstance(model_output, str):
         try:
             model_output = json.loads(_strip_json_fence(model_output))
-        except (TypeError, ValueError):
+        except ValueError:
             return [
                 {
                     "code": "freeform_observation",
@@ -47,10 +42,9 @@ def _extract_observations(model_output: Any) -> list[Mapping[str, Any]]:
             return [item for item in model_output[key] if isinstance(item, Mapping)][
                 :MAX_OBSERVATIONS
             ]
-    try:
+    if "choices" in model_output:  # a raw chat-completion response saved as a fixture
         return _extract_observations(model_output["choices"][0]["message"]["content"])
-    except (KeyError, IndexError, TypeError):
-        return [model_output] if model_output else []
+    return [model_output] if model_output else []
 
 
 def _norm_choice(raw: Any, allowed: set[str], default: str) -> str:
@@ -59,15 +53,10 @@ def _norm_choice(raw: Any, allowed: set[str], default: str) -> str:
 
 
 def _caption_match_text(value: Any) -> str:
-    return re.sub(r"[^0-9A-Za-z\u3400-\u9fff]+", "", str(value or "")).lower()
+    return re.sub(r"[^0-9A-Za-z㐀-鿿]+", "", str(value or "")).lower()
 
 
 def _generated_subtitle_corpus(payload: Mapping[str, Any]) -> str:
-    group = (
-        (payload.get("evidence") or {}).get("generated_subtitles")
-        if isinstance(payload.get("evidence"), Mapping)
-        else None
-    )
     strings = []
 
     def visit(value: Any) -> None:
@@ -80,7 +69,7 @@ def _generated_subtitle_corpus(payload: Mapping[str, Any]) -> str:
             for child in value:
                 visit(child)
 
-    visit(group or {})
+    visit(payload["evidence"]["generated_subtitles"])
     return _caption_match_text(" ".join(strings))
 
 
@@ -117,21 +106,18 @@ def _misclassified_generated_caption(
 def normalize_observations(
     model_output: Any,
     *,
+    payload: Mapping[str, Any],
     stage: str = DEFAULT_STAGE,
-    payload: Mapping[str, Any] | None = None,
     model_config: Mapping[str, Any] | None = None,
 ) -> list[dict[str, Any]]:
     """Normalize bounded model output into permanently non-blocking findings."""
-    payload = _redact(payload or {})
     cfg = safe_mimo_config(model_config)
-    model_used = str(cfg.get("model") or "mimo-qc-offline-fixture")
+    model_used = cfg["model"]
     findings = []
     for index, observation in enumerate(_extract_observations(model_output), start=1):
         if _misclassified_generated_caption(observation, payload, stage):
             continue
         obs = _summarize(observation, max_items=10, max_string=MAX_MESSAGE_CHARS)
-        if not isinstance(obs, Mapping):
-            continue
         category_hint = str(
             obs.get("category") or obs.get("type") or "semantic"
         ).lower()
@@ -156,18 +142,16 @@ def normalize_observations(
             "aesthetic" if category == "mimo_aesthetic" else "semantic",
         )
         raw_evidence = obs.get("evidence")
-        supplied_evidence: Mapping[str, Any] = (
-            raw_evidence if isinstance(raw_evidence, Mapping) else {}
-        )
         evidence = {
-            **dict(supplied_evidence),
+            **(raw_evidence if isinstance(raw_evidence, Mapping) else {}),
             "model": model_used,
             "config": cfg,
             "fingerprint": {
-                "evidence": payload.get("evidence_fingerprint"),
+                "evidence": payload["evidence_fingerprint"],
                 "observation": _fingerprint_value(observation),
             },
         }
+        location = obs.get("location")
         findings.append(
             qc_contract.build_finding(
                 finding_id=str(
@@ -185,14 +169,12 @@ def normalize_observations(
                 deterministic=False,
                 blocking=False,
                 source={"artifact": ARTIFACT_NAME, "adapter": "mimo_qc.py"},
-                location=obs.get("location")
-                if isinstance(obs.get("location"), Mapping)
-                else {},
-                evidence=_redact(evidence),
+                location=location if isinstance(location, Mapping) else {},
+                evidence=evidence,
                 model_used=model_used,
                 artifact_fingerprints={
-                    "payload": str(payload.get("payload_fingerprint") or "fixture"),
-                    "evidence": str(payload.get("evidence_fingerprint") or "fixture"),
+                    "payload": payload["payload_fingerprint"],
+                    "evidence": payload["evidence_fingerprint"],
                 },
                 next_action="human_review",
                 decision_reason=message,

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

@@ -2,19 +2,12 @@
 
 from __future__ import annotations
 
-
 import json
+from typing import Any
+from collections.abc import Mapping, Sequence
 
-from typing import Any, Mapping, Sequence
-
-
-from mimo_qc_evidence import (
-    _cache_evidence,
-    _fingerprint_value,
-    _redact,
-    safe_mimo_config,
-)
-from mimo_qc_contract import ARTIFACT_NAME, DEFAULT_STAGE, MAX_FRAMES
+from mimo_qc_evidence import _fingerprint_value, safe_mimo_config
+from mimo_qc_contract import ARTIFACT_NAME, DEFAULT_STAGE
 
 
 def _semantic_evidence(evidence: Mapping[str, Any], *, stage: str) -> dict[str, Any]:
@@ -83,22 +76,16 @@ def _semantic_evidence(evidence: Mapping[str, Any], *, stage: str) -> dict[str,
         semantic["evidence_roles"].pop("post_render_frame_limits", None)
         semantic["evidence_roles"].pop("actual_audio_timing", None)
     else:
-        final_output = semantic.get("final_output")
-        candidates = (
-            final_output.get("candidates", [])
-            if isinstance(final_output, Mapping)
-            else []
-        )
         semantic["final_output"] = {
             "candidates": [
                 dict(candidate)
-                for candidate in candidates
-                if isinstance(candidate, Mapping) and candidate.get("exists") is True
+                for candidate in semantic["final_output"]["candidates"]
+                if candidate["exists"]
             ]
         }
     # Artifact summaries are already bounded at collection time; summarizing them again
     # would wrap their ``items`` arrays in another summary layer and obscure the values.
-    return _redact(semantic)
+    return semantic
 
 
 def build_payload(
@@ -144,11 +131,10 @@ def build_payload(
             '"semantic|aesthetic|sampled","evidence":{...}}]}。最多 12 条。'
         ),
         "evidence": _semantic_evidence(evidence, stage=stage),
-        "evidence_fingerprint": evidence.get("fingerprint")
-        or _fingerprint_value(_cache_evidence(evidence)),
+        "evidence_fingerprint": evidence["fingerprint"],
     }
     payload["payload_fingerprint"] = _fingerprint_value(payload)
-    return _redact(payload)
+    return payload
 
 
 def _request_payload(
@@ -167,30 +153,24 @@ def _request_payload(
             ),
         }
     ]
-    for index, sample in enumerate(list(frame_samples)[:MAX_FRAMES], start=1):
-        data_url = sample.get("data_url") if isinstance(sample, Mapping) else None
-        if isinstance(data_url, str) and data_url.startswith("data:image/jpeg;base64,"):
-            timestamp = sample.get("timestamp")
-            try:
-                timestamp_label = f"{float(timestamp):.3f}s"
-            except (TypeError, ValueError):
-                timestamp_label = "unknown"
-            content.append(
-                {
-                    "type": "text",
-                    "text": (
-                        f"BEGIN QC_FRAME_{index}: final-output timestamp {timestamp_label}. "
-                        f"Judge only this image and do not transfer its content to another frame."
-                    ),
-                }
-            )
-            content.append({"type": "image_url", "image_url": {"url": data_url}})
-            content.append(
-                {
-                    "type": "text",
-                    "text": f"END QC_FRAME_{index}: timestamp {timestamp_label}.",
-                }
-            )
+    for index, sample in enumerate(frame_samples, start=1):
+        timestamp_label = f"{sample['timestamp']:.3f}s"
+        content.append(
+            {
+                "type": "text",
+                "text": (
+                    f"BEGIN QC_FRAME_{index}: final-output timestamp {timestamp_label}. "
+                    f"Judge only this image and do not transfer its content to another frame."
+                ),
+            }
+        )
+        content.append({"type": "image_url", "image_url": {"url": sample["data_url"]}})
+        content.append(
+            {
+                "type": "text",
+                "text": f"END QC_FRAME_{index}: timestamp {timestamp_label}.",
+            }
+        )
     return {
         "model": payload["model"],
         "messages": [{"role": "user", "content": content}],
@@ -209,6 +189,8 @@ def _strip_json_fence(text: str) -> str:
 
 
 def _validated_live_output(response: Any) -> Any:
+    """The one shape check on the third-party model response: a list of observations, or an
+    object carrying `observations`/`findings`; anything else is a failed (fail-open) request."""
     try:
         content = response["choices"][0]["message"]["content"]
     except (KeyError, IndexError, TypeError):