@oh-story/dsh 0.1.11 → 0.1.13

package/lib/video-recap/skills/video-assemble/scripts/pair_media.py

@@ -1,216 +0,0 @@
-#!/usr/bin/env python3
-"""Pair explicit picture and adopted audio assets without re-encoding either stream.
-
-This is asset pairing, not a claim of source reconstruction, correct editorial
-selection, speech alignment, or release approval. Existing assemble then consumes
-paired.mp4; its subtitle binding must be newly computed on that container/a:0.
-"""
-
-import argparse
-from fractions import Fraction
-import json
-from pathlib import Path
-import subprocess
-
-from assemble_constants import SUPPORTED_PICTURE_CODECS
-from adoption.frozen_audio import probe_audio_packets, verify_adopted_audio
-from adoption.strict_inputs import (
-    probe_json, require_declared_path, require_fields, require_integer, run_logged,
-    without_digests, write_json_atomic,
-)
-
-
-_probe = probe_json
-
-
-def _asset(value, audio=False):
-    value = without_digests(value, 'asset')
-    require_fields(value, ['path', 'selected_stream'] if audio else ['path'], 'asset')
-    path = require_declared_path(value, 'asset')
-    if audio:
-        return {'path': str(path),
-                'selected_stream': require_integer(value['selected_stream'], 'Audio selected_stream')}
-    return {'path': str(path)}
-
-
-def _time(value):
-    if value in (None, 'N/A'):
-        raise ValueError('Missing media timing')
-    try:
-        return Fraction(str(value))
-    except (ValueError, ZeroDivisionError) as exc:
-        raise ValueError('Invalid media timing') from exc
-
-
-def probe_picture(path):
-    """Actual full CFR presentation clock plus codec-order packet sizes and timestamps."""
-    data = _probe(path, '-select_streams', 'v:0', '-show_streams', '-show_packets',
-                  '-show_format', '-show_entries',
-                  'format=format_name:stream=codec_name,profile,level,width,height,pix_fmt,'
-                  'sample_aspect_ratio,field_order,color_range,color_space,color_transfer,'
-                  'color_primaries,chroma_location,time_base,start_pts,duration_ts,avg_frame_rate'
-                  ':packet=pts,dts,duration,size,side_data_list')
-    streams = data.get('streams', [])
-    if len(streams) != 1 or streams[0].get('codec_name') not in SUPPORTED_PICTURE_CODECS:
-        raise ValueError('Pairing requires one selected H264/HEVC picture stream')
-    if 'mp4' not in data.get('format', {}).get('format_name', '').split(','):
-        raise ValueError('Pairing currently requires MP4-family picture container')
-    v = streams[0]
-    fps, tb = _time(v.get('avg_frame_rate')), _time(v.get('time_base'))
-    if not 1 <= fps <= 120 or tb <= 0 or v.get('start_pts') != 0:
-        raise ValueError('Picture requires positive CFR and a known zero start')
-    duration = _time(v.get('duration_ts')) * tb
-    frames = _probe(path, '-select_streams', 'v:0', '-show_frames',
-                    '-show_entries', 'frame=pts')['frames']
-    pts = [_time(frame.get('pts')) * tb for frame in frames]
-    if not pts or any(t != Fraction(i, fps) for i, t in enumerate(pts)) or duration != len(pts) / fps:
-        raise ValueError('Picture requires complete zero-origin CFR frame clock and exact duration')
-    decoder_keys = ['codec_name', 'profile', 'level', 'width', 'height', 'pix_fmt',
-                    'sample_aspect_ratio', 'field_order', 'color_range', 'color_space',
-                    'color_transfer', 'color_primaries', 'chroma_location']
-    packets = []
-    for packet in data.get('packets', []):
-        if packet.get('size') is None:
-            raise ValueError('Picture packet missing size')
-        ticks = {key: str(_time(packet.get(key)) * tb) for key in ['pts', 'dts', 'duration']}
-        if _time(ticks['duration']) <= 0:
-            raise ValueError('Picture packet has invalid duration')
-        packets.append({**ticks, 'size': int(packet['size']),
-                        'side_data_list': packet.get('side_data_list', [])})
-    if len(packets) != len(pts):
-        raise ValueError('Picture packet/frame counts disagree')
-    return {'decoder': {key: v.get(key) for key in decoder_keys}, 'packets': packets,
-            'frame_pts': [str(t) for t in pts], 'frame_count': len(pts), 'fps': str(fps),
-            'duration': str(duration), 'start': '0'}
-
-
-def validate_aac_packet_interval(audio):
-    """Validate exact AAC packet continuity against the stream-header interval."""
-    if audio['codec'] != 'aac':
-        raise ValueError('Pairing requires AAC adopted audio')
-    packets = audio['packets']
-    rate = audio['sample_rate']
-    if type(rate) is not int or rate <= 0 or len(packets) < 2:
-        raise ValueError('AAC packet timing is incomplete')
-    nominal = _time(packets[0]['duration'])
-    # Accept known AAC frame sample counts, never an arbitrary huge duration.
-    if nominal * rate not in {960, 1024, 1920, 2048}:
-        raise ValueError('Unsupported AAC nominal packet duration')
-    for i, packet in enumerate(packets):
-        d = _time(packet['duration'])
-        if d <= 0 or d > nominal or (i < len(packets) - 1 and d != nominal):
-            raise ValueError('Nonuniform or invalid AAC packet duration')
-        p, t = _time(packet['pts']), _time(packet['dts'])
-        if p != t:
-            raise ValueError('Unsupported AAC PTS/DTS difference')
-        if i and p != _time(packets[i-1]['pts']) + _time(packets[i-1]['duration']):
-            raise ValueError('AAC packet clock has gaps or overlaps')
-    audio_start, audio_duration = _time(audio['start_time']), _time(audio['duration'])
-    if audio_duration <= 0:
-        raise ValueError('Invalid audio interval')
-    audio_end = audio_start + audio_duration
-    first_pts = _time(packets[0]['pts'])
-    last_end = _time(packets[-1]['pts']) + _time(packets[-1]['duration'])
-    if (not 0 <= audio_start - first_pts <= nominal
-            or abs(last_end - audio_end) > Fraction(1, rate)):
-        raise ValueError('AAC packet clock does not match stream interval')
-    return audio_start, audio_end, nominal
-
-
-def validate_pair_timing(picture, audio):
-    """Narrow AAC/CFR compatibility; not a perceptual synchronization verdict."""
-    audio_start, audio_end, nominal = validate_aac_packet_interval(audio)
-    tolerance = max(1 / Fraction(picture['fps']), nominal)
-    end_delta = audio_end - Fraction(picture['duration'])
-    if abs(audio_start) > tolerance or abs(end_delta) > tolerance:
-        raise ValueError('Picture/audio interval mismatch; no implicit trim, padding, offset or retime')
-    return {'start_delta': str(audio_start),
-            'end_delta': str(end_delta),
-            'tolerance': str(tolerance), 'nominal_aac_packet': str(nominal)}
-
-
-def _run_mux(command, directory):
-    run_logged(command, directory, 'mux', timeout=600)
-
-
-def _verify_output(path):
-    data = _probe(path, '-show_streams')
-    if [stream.get('codec_type') for stream in data['streams']] != ['video', 'audio']:
-        raise ValueError('Paired output must contain only v:0 and a:0')
-    result = subprocess.run(['ffmpeg', '-v', 'error', '-xerror', '-threads', '2', '-i', str(path),
-                             '-map', '0:v:0', '-map', '0:a:0', '-f', 'null', '-'],
-                            capture_output=True, text=True, timeout=600)
-    if result.returncode or result.stderr.strip():
-        raise ValueError('Paired output full decode failed')
-
-
-def run_pair(plan_path, output_dir, *, plan_only=False):
-    plan_path, directory = Path(plan_path).resolve(), Path(output_dir).resolve()
-    directory.mkdir(parents=True, exist_ok=False)
-    report_path = directory / 'pair_run.json'
-    staged, output = directory / 'paired.rendering.mp4', directory / 'paired.mp4'
-    report = {'artifact': 'media_pair_run', 'schema_version': 1, 'status': 'PREPARING',
-              'direct_listening': 'NOT_CHECKED', 'normal_speed_review': 'NOT_CHECKED',
-              'release_approved': False}
-    write_json_atomic(report_path, report)
-    try:
-        plan = json.loads(plan_path.read_bytes())
-        require_fields(plan, ['artifact', 'schema_version', 'picture', 'audio'], 'media_pair plan')
-        if plan['artifact'] != 'media_pair' or type(plan['schema_version']) is not int or plan['schema_version'] != 1:
-            raise ValueError('Unsupported media_pair schema')
-        picture, audio = _asset(plan['picture']), _asset(plan['audio'], audio=True)
-        report.update(plan={'path': str(plan_path)}, inputs={'picture': picture, 'audio': audio})
-        video_facts = probe_picture(picture['path'])
-        audio_facts = probe_audio_packets(audio['path'], audio['selected_stream'])
-        report['timing'] = validate_pair_timing(video_facts, audio_facts)
-        report['picture'] = {k: v for k, v in video_facts.items() if k not in ['packets', 'frame_pts']}
-        report['audio'] = {'input_stream': audio['selected_stream'], 'output_stream': 0,
-                           'packet_count': audio_facts['packet_count']}
-        if plan_only:
-            report['status'] = 'PLANNED'
-            write_json_atomic(report_path, report)
-            return report
-        command = ['ffmpeg', '-nostdin', '-v', 'error', '-n', '-copyts',
-                   '-i', picture['path'], '-i', audio['path'], '-map', '0:v:0',
-                   '-map', f"1:a:{audio['selected_stream']}", '-c', 'copy',
-                   '-movie_timescale', str(audio_facts['sample_rate']),
-                   '-movflags', '+faststart', str(staged)]
-        _run_mux(command, directory)
-        if probe_picture(staged) != video_facts:
-            raise ValueError('Paired picture packets, decoder, geometry/color or full frame clock changed')
-        proof = verify_adopted_audio(audio['path'], staged, audio['selected_stream'], 0)
-        output_timing = validate_pair_timing(video_facts, proof['output'])
-        if output_timing != report['timing']:
-            raise ValueError('Output audio presentation interval changed')
-        report['output_timing'] = output_timing
-        _verify_output(staged)
-        write_json_atomic(directory / 'picture_identity.json', video_facts)
-        write_json_atomic(directory / 'adopted_audio_identity.json', proof)
-        report['output'] = {'path': str(output), 'full_decode': 'PASS',
-                            'picture_identity': 'EXACT', 'audio_packet_identity': 'EXACT'}
-        staged.rename(output)
-        report['status'] = 'PAIR_RENDERED'
-        write_json_atomic(report_path, report)
-        return report
-    except Exception as exc:
-        # A partial unique run is evidence, never a final/current asset. Keep logs.
-        staged.unlink(missing_ok=True)
-        output.unlink(missing_ok=True)
-        report.pop('output', None)
-        report.update(status='FAILED', error=f'{type(exc).__name__}: {exc}')
-        write_json_atomic(report_path, report)
-        raise
-
-
-def main():
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument('plan')
-    parser.add_argument('--output-dir', required=True)
-    parser.add_argument('--plan-only', action='store_true')
-    args = parser.parse_args()
-    report = run_pair(args.plan, args.output_dir, plan_only=args.plan_only)
-    print(json.dumps(report, ensure_ascii=False, indent=2))
-
-
-if __name__ == '__main__':
-    main()

package/lib/video-recap/skills/video-recap/references/shift-left-qc-schema.md

@@ -1,23 +0,0 @@
-# 前置 QC 数据契约
-
-`final_qc.json`、`golden_eval.json`、`mimo_qc.json` 与 `preflight_qc.json` 共用一套最小结构，由本技能的 `scripts/qc_contract.py` 实现。
-
-## 字段契约
-
-- `schema_version`：整数 `1`。
-- `artifact`：只能是 `final_qc.json`、`golden_eval.json`、`mimo_qc.json` 或 `preflight_qc.json`。
-- `stage`：只能是 `pre_cut`、`post_cut`、`pre_tts`、`post_tts`、`pre_assemble`、`post_render`、`golden`。
-  - 不得使用 `pre_voiceover`、`post_voiceover`、`pre_export`、`post_export`、`final`、`golden_eval` 或 `mimo_qc` 作为阶段值。
-  - `mimo_qc.json` 是产物名；MiMo finding 必须挂在 `post_tts`、`pre_assemble` 等真实阶段上。
-- `findings[]`：每项必须包含 `finding_id`、`stage`、`severity`、`blocking`、`deterministic`、`confidence`、`rule_id`、`decision_reason`、`location`、`evidence`、`sample_policy`、`model_used` 与 `next_action`。
-- `sample_policy`：至少包含 `type`；其值只能是 `all`、`deterministic`、`sampled`、`semantic` 或 `aesthetic`。
-- `location.timecode` 与 `location.source_span` 必须存在；剪辑前阶段可以把任一字段设为 `null`。
-- 为兼容与诊断，当前辅助函数还可能写出 `id`、`category`、`code`、`message`、`source` 与 `objective_corroboration`。
-
-## 阻断语义
-
-只有确定性的客观规则可以阻断，例如产物缺失或过期、时长或媒体流错误、字幕与 TTS 放置错误、数据结构无效。
-
-MiMo 语义/审美 finding 以及其他所有非确定性 finding **始终只给建议，不能阻断**。若存在客观佐证，必须由确定性生产者单独写成确定性 finding；它不能把主观模型观察升级成 blocker。运行时不存在 allow-list 或规则表逃生口。
-
-`qc_contract.py` 只负责数据结构：不调用 MiMo、不连接流水线，也不自动修复。独立的 `mimo_qc.py` 只有在显式开启时，才会在 `pre_assemble` 和/或 `post_render` 各发起一次实时请求；它保持 fail-open，且不落盘凭证或抽帧 base64。所有报告构建器都通过 `qc_contract.redact_secrets` 处理元数据与证据：脱敏疑似密钥的键值，并从 URL 移除 userinfo、query 与 fragment，同时保留有用的 host/path 上下文。

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

@@ -1,33 +0,0 @@
-#!/usr/bin/env python3
-"""Public API and CLI entrypoint for advisory MiMo multimodal QC."""
-
-import qc.mimo_runner as mimo_qc_runner
-from qc.mimo_evidence import collect_evidence, safe_mimo_config
-from qc.mimo_observations import normalize_observations
-from qc.mimo_payload import build_payload
-from qc.mimo_client import mimo_qc_api_call
-
-clear_report = mimo_qc_runner.clear_report
-
-
-def run(work_dir, **kwargs):
-    """mimo_qc_runner.run with the real MiMo transport bound at call time."""
-    return mimo_qc_runner.run(work_dir, api_call=mimo_qc_api_call, **kwargs)
-
-
-def main(argv=None):
-    return mimo_qc_runner.main(argv, run_callable=run)
-
-__all__ = [
-    "build_payload",
-    "clear_report",
-    "collect_evidence",
-    "main",
-    "mimo_qc_api_call",
-    "normalize_observations",
-    "run",
-    "safe_mimo_config",
-]
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/lib/video-recap/skills/video-recap/scripts/qc/__init__.py

@@ -1 +0,0 @@
-"""MiMo QC subpackage."""

package/lib/video-recap/skills/video-recap/scripts/qc/mimo_client.py

@@ -1,13 +0,0 @@
-"""Load this skill's MiMo client without depending on the ambient ``lib`` module."""
-
-import importlib.util
-from pathlib import Path
-
-_SPEC = importlib.util.spec_from_file_location(
-    "video_recap_mimo_qc_lib", Path(__file__).resolve().parents[1] / "lib.py"
-)
-_LIB = importlib.util.module_from_spec(_SPEC)
-_SPEC.loader.exec_module(_LIB)
-
-DEFAULT_CONFIG = _LIB.CONFIG
-mimo_qc_api_call = _LIB.mimo_qc_api_call

package/lib/video-recap/skills/video-recap/scripts/qc/mimo_contract.py

@@ -1,9 +0,0 @@
-"""Shared constants for the self-contained MiMo QC adapter."""
-
-ARTIFACT_NAME = "mimo_qc.json"
-DEFAULT_STAGE = "pre_assemble"
-MAX_OBSERVATIONS = 12
-MAX_MESSAGE_CHARS = 800
-MAX_FRAMES = 6
-MAX_FRAME_DIMENSION = 768
-FRAME_SAMPLER_VERSION = 2

package/lib/video-recap/skills/video-recap/scripts/qc/mimo_evidence.py

@@ -1,287 +0,0 @@
-"""Collect and redact local evidence for MiMo QC."""
-
-from __future__ import annotations
-
-import json
-import os
-from pathlib import Path
-from typing import Any
-from collections.abc import Mapping, Sequence
-
-import qc_contract
-from qc.mimo_client import DEFAULT_CONFIG
-
-_JSON_ARTIFACTS = (
-    "narration.json",
-    "visual_overlays.json",
-    "clip_plan_validated.json",
-    "clip_plan.json",
-    "assembly_manifest.json",
-    "tts_meta.json",
-)
-
-_SOURCE_ASR_ARTIFACTS = (
-    "asr_clean.json",
-    "asr.json",
-    "asr_result.json",
-    "asr_segments.json",
-)
-
-_GENERATED_SUBTITLE_ARTIFACTS = (
-    "subtitles.json",
-    "subtitle.json",
-    "subtitles.srt",
-    "subtitle.srt",
-    "subtitles.vtt",
-    "subtitle.vtt",
-    "output.srt",
-    "output.vtt",
-)
-
-_OPTIONAL_VISUAL_METADATA = (
-    "sampled_frames.json",
-    "frame_samples.json",
-    "storyboard.json",
-    "storyboard_meta.json",
-    "frames_manifest.json",
-)
-
-
-def _load_json(path: Path) -> Any:
-    return json.loads(path.read_text(encoding="utf-8"))
-
-
-def _read_text_sample(path: Path, *, max_chars: int = 4000) -> dict[str, Any]:
-    text = path.read_text(encoding="utf-8", errors="replace")
-    return {
-        "kind": "text",
-        "bytes": path.stat().st_size,
-        "truncated": len(text) > max_chars,
-        "sample": text[:max_chars],
-    }
-
-
-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."""
-    if depth >= 4:
-        return {"type": type(value).__name__, "omitted": True}
-    if isinstance(value, Mapping):
-        out = {
-            str(key): _summarize(
-                item, max_items=max_items, max_string=max_string, depth=depth + 1
-            )
-            for key, item in list(value.items())[:max_items]
-        }
-        if len(value) > max_items:
-            out["_omitted_keys"] = len(value) - max_items
-        return out
-    if isinstance(value, list):
-        return {
-            "count": len(value),
-            "items": [
-                _summarize(
-                    item, max_items=max_items, max_string=max_string, depth=depth + 1
-                )
-                for item in value[:max_items]
-            ],
-            "omitted": max(0, len(value) - max_items),
-        }
-    if isinstance(value, str) and len(value) > max_string:
-        return {"text": value[:max_string], "truncated": True, "chars": len(value)}
-    return value
-
-
-def _collect_file(work_dir: Path, name: str) -> dict[str, Any] | None:
-    path = work_dir / name
-    if not path.is_file():
-        return None
-    if path.suffix.lower() == ".json":
-        kind, summary = "json", _summarize(_load_json(path))
-    else:
-        kind, summary = "text", _summarize(_read_text_sample(path))
-    stat = path.stat()
-    return {
-        "path": name,
-        "kind": kind,
-        "bytes": stat.st_size,
-        "mtime_ns": stat.st_mtime_ns,
-        "summary": summary,
-    }
-
-
-def _first_existing(work_dir: Path, names: Sequence[str]) -> str | None:
-    return next((name for name in names if (work_dir / name).is_file()), None)
-
-
-def _collect_multi_source_asr(work_dir: Path) -> dict[str, Any]:
-    """Collect per-source ASR when a multi-source project has no root transcript."""
-    manifest_path = work_dir / "multi_source_manifest.json"
-    if not manifest_path.is_file():
-        return {}
-    collected = {}
-    for source in _load_json(manifest_path)["sources"]:
-        relative_dir = source["source_work_dir"]  # recap writes sources/<source_id>
-        name = _first_existing(work_dir / relative_dir, _SOURCE_ASR_ARTIFACTS)
-        if name is not None:
-            collected[source["source_id"]] = _collect_file(work_dir, f"{relative_dir}/{name}")
-    return collected
-
-
-def _resolve_candidate(work_dir: Path, candidate: str | Path) -> Path:
-    path = Path(candidate)
-    return path if path.is_absolute() else work_dir / path
-
-
-def _final_output_path(
-    work_dir: Path, final_output: str | Path | None
-) -> tuple[Path, str] | None:
-    """(path, display) of the final output: the caller's, else assembly_manifest.final_output
-    (video-assemble always writes it); None before the assembler has run."""
-    if final_output is None:
-        manifest_path = work_dir / "assembly_manifest.json"
-        if not manifest_path.is_file():
-            return None
-        final_output = _load_json(manifest_path)["final_output"]
-    return _resolve_candidate(work_dir, final_output), str(final_output)
-
-
-def _final_output_metadata(
-    work_dir: Path, final_output: str | Path | None = None
-) -> dict[str, Any]:
-    resolved = _final_output_path(work_dir, final_output)
-    if resolved is None:
-        return {"candidates": []}
-    path, display = resolved
-    item: dict[str, Any] = {"path": display, "exists": path.is_file()}
-    if item["exists"]:
-        stat = path.stat()
-        item.update({"bytes": stat.st_size, "mtime_ns": stat.st_mtime_ns})
-    return {"candidates": [item]}
-
-
-def _existing_final_output(
-    work_dir: Path, final_output: str | Path | None
-) -> Path | None:
-    resolved = _final_output_path(work_dir, final_output)
-    return resolved[0] if resolved is not None and resolved[0].is_file() else None
-
-
-def collect_evidence(
-    work_dir: str | Path, *, final_output: str | Path | None = None
-) -> dict[str, Any]:
-    """Collect lightweight, secret-scrubbed evidence from one work directory."""
-    root = Path(work_dir)
-    artifacts: dict[str, Any] = {}
-    preferred_plan = _first_existing(
-        root, ("clip_plan_validated.json", "clip_plan.json")
-    )
-    for name in _JSON_ARTIFACTS:
-        if (
-            name in {"clip_plan_validated.json", "clip_plan.json"}
-            and name != preferred_plan
-        ):
-            continue
-        item = _collect_file(root, name)
-        if item is not None:
-            artifacts[name] = item
-    evidence = {
-        # Display only; excluded from cache_input so moving the work directory is a cache hit.
-        "work_dir": str(root),
-        "artifacts": artifacts,
-        "source_asr": {
-            name: item
-            for name in _SOURCE_ASR_ARTIFACTS
-            if (item := _collect_file(root, name)) is not None
-        },
-        "generated_subtitles": {
-            name: item
-            for name in _GENERATED_SUBTITLE_ARTIFACTS
-            if (item := _collect_file(root, name)) is not None
-        },
-        "visual_metadata": {
-            name: item
-            for name in _OPTIONAL_VISUAL_METADATA
-            if (item := _collect_file(root, name)) is not None
-        },
-        "final_output": _final_output_metadata(root, final_output),
-    }
-    if not evidence["source_asr"]:
-        evidence["source_asr"] = _collect_multi_source_asr(root)
-    # 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[key] for key in ("kind", "bytes", "mtime_ns")}
-        for name, item in sorted(group.items())
-    }
-
-
-def _cache_evidence(evidence: Mapping[str, Any]) -> dict[str, Any]:
-    """The per-file identities ({kind, bytes, mtime_ns}) a cached stage report was built
-    from; work_dir is excluded so moving the directory is still a cache hit."""
-    return {
-        "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", "mtime_ns") if key in item}
-            for item in evidence["final_output"]["candidates"]
-        ],
-    }
-
-
-def _effective_config(config: Mapping[str, Any] | None = None) -> dict[str, Any]:
-    source = dict(DEFAULT_CONFIG)
-    if config:
-        source.update(dict(config))
-        if not config.get("mimo_qc_model"):
-            source["mimo_qc_model"] = (
-                config.get("mimo_video_model")
-                or config.get("mimo_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.
-    if os.environ.get("MIMO_QC_MODEL") and not (config and config.get("mimo_qc_model")):
-        source["mimo_qc_model"] = os.environ["MIMO_QC_MODEL"]
-    return source
-
-
-def safe_mimo_config(config: Mapping[str, Any] | None = None) -> dict[str, Any]:
-    """Return non-secret settings suitable for persisted report metadata."""
-    source = _effective_config(config)
-    keep = (
-        "api_provider",
-        "mimo_api_url",
-        "mimo_api_url_source",
-        "mimo_video_api_url",
-        "mimo_video_api_url_source",
-        "mimo_qc_model",
-        "mimo_qc_model_source",
-        "mimo_model",
-        "mimo_model_source",
-        "mimo_video_model",
-        "mimo_video_model_source",
-        "mimo_disable_thinking",
-        "mimo_disable_thinking_source",
-        "mimo_media_resolution",
-        "mimo_media_resolution_source",
-    )
-    safe = {key: source[key] for key in keep}
-    safe["model"] = (
-        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 = qc_contract.redact_secrets(safe)
-    safe["key_present"] = key_present
-    return safe