@oh-story/dsh 0.1.7 → 0.1.9

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

@@ -11,7 +11,6 @@ from recap_runtime import (
     _build_multi_source_records,
     _coerce_videos,
     _entry,
-    _file_fingerprint,
     _material_settings_fingerprint,
     _optional_env_int,
     _preflight_burn_subtitles,
@@ -59,7 +58,7 @@ RUN_MANIFEST = "recap_run_manifest.json"
 def _voiceover_args(work_dir, narration_path, args):
     """Build the shared full/cut invocation for video-voiceover."""
     result = ["--work-dir", str(work_dir), "--narration", str(narration_path)]
-    if getattr(args, "tts_provider", "auto") != "auto":
+    if args.tts_provider != "auto":
         result += ["--tts-provider", args.tts_provider]
     if args.mimo_tts_voice:
         result += ["--mimo-voice", args.mimo_tts_voice]
@@ -75,25 +74,23 @@ def _run_or_restore_understanding(source_record, source_work_dir, args):
     source_work_dir = Path(source_work_dir)
     source_work_dir.mkdir(parents=True, exist_ok=True)
     source_fp = source_record["source_video_fingerprint"]
-    settings_fp = source_record.get(
-        "settings_fingerprint"
-    ) or _material_settings_fingerprint(args)
+    settings_fp = source_record["settings_fingerprint"]
     lib_dir = _material_library_dir(args)
     restored = False
-    if lib_dir and _materials_enabled(args):
+    if _materials_enabled(args):
         result = material_lib.restore_material(
             lib_dir,
             source_work_dir,
             source_fingerprint=source_fp,
             settings_fp=settings_fp,
         )
-        restored = bool(result.get("restored"))
+        restored = result["restored"]
         if restored:
             print(
-                f"[video-recap] ♻️  复用素材库: {result.get('material_id')} → {source_work_dir}",
+                f"[video-recap] ♻️  复用素材库: {result['material_id']} → {source_work_dir}",
                 flush=True,
             )
-        elif result.get("reason"):
+        else:
             print(
                 f"[video-recap] 素材库未复用 {source_record['source_name']}: {result['reason']}",
                 flush=True,
@@ -107,19 +104,19 @@ def _run_or_restore_understanding(source_record, source_work_dir, args):
         )
 
     _write_run_manifest(source_work_dir, source_record["source_path"], args)
-    if lib_dir and _save_materials_enabled(args):
+    if _save_materials_enabled(args):
         meta = material_lib.save_material(
             lib_dir,
             source_work_dir,
             source_record["source_path"],
             source_fp,
             settings_fp,
-            source_id=source_record.get("source_id"),
-            material_id=source_record.get("material_id"),
+            source_id=source_record["source_id"],
+            material_id=source_record["material_id"],
         )
-        source_record["material_id"] = meta.get("material_id")
+        source_record["material_id"] = meta["material_id"]
         print(
-            f"[video-recap] 💾 已沉淀素材: {meta.get('material_id')} → {lib_dir}",
+            f"[video-recap] 💾 已沉淀素材: {meta['material_id']} → {lib_dir}",
             flush=True,
         )
     return restored
@@ -127,7 +124,7 @@ def _run_or_restore_understanding(source_record, source_work_dir, args):
 
 def _single_source_record(video, args):
     """Identity + settings for the one source of a single-video run."""
-    fp = _file_fingerprint(video)
+    fp = material_lib.file_fingerprint(video)
     return {
         "source_id": material_lib.source_id_from_fingerprint(fp),
         "source_path": str(video),
@@ -209,9 +206,9 @@ def _run_multi_cut(videos, work_dir, args):
     ]
     if args.target_duration:
         crender += ["--target-duration", args.target_duration]
-    if getattr(args, "allow_duration_drift", False):
+    if args.allow_duration_drift:
         crender.append("--allow-duration-drift")
-    if getattr(args, "allow_sparse_cut", False):
+    if args.allow_sparse_cut:
         crender.append("--allow-sparse-cut")
     _run("video-cut", "cut.py", *crender)
     cut_qc = _surface_cut_qc(work_dir)
@@ -301,10 +298,7 @@ def _run_multi_cut(videos, work_dir, args):
         aargs.append("--jianying-no-bundle-media")
     _run("video-assemble", "assemble.py", *aargs)
 
-    final_dir = Path(args.output_dir) if args.output_dir else work_dir.parent
-    final_output = _read_assembly_output(work_dir) or (
-        final_dir / ("recap_" + recap_stem + ".mp4")
-    )
+    final_output = _read_assembly_output(work_dir)
     _write_shift_left_stage_qc(
         work_dir,
         "post_render",
@@ -325,7 +319,7 @@ def main():
         ap.error(
             "MIMO_QC/--mimo-qc must be one of: off, pre-assemble, post-render, both"
         )
-    if getattr(args, "tts_provider", "auto") not in TTS_PROVIDERS:
+    if args.tts_provider not in TTS_PROVIDERS:
         ap.error(
             "TTS_PROVIDER/--tts-provider must be one of: auto, mimo-tts, fish-audio"
         )
@@ -354,9 +348,7 @@ def main():
     )
     if explicit_mimo_voice and args.voice_ref:
         ap.error("--mimo-tts-voice and --voice-ref are mutually exclusive")
-    if getattr(args, "tts_provider", "auto") == "fish-audio" and (
-        explicit_mimo_voice or args.voice_ref
-    ):
+    if args.tts_provider == "fish-audio" and (explicit_mimo_voice or args.voice_ref):
         ap.error(
             "--mimo-tts-voice/--voice-ref are only supported by --tts-provider mimo-tts"
         )
@@ -532,9 +524,9 @@ def main():
         crender = [str(video), "--work-dir", str(work_dir), "--no-narration-map"]
         if args.target_duration:
             crender += ["--target-duration", args.target_duration]
-        if getattr(args, "allow_duration_drift", False):
+        if args.allow_duration_drift:
             crender.append("--allow-duration-drift")
-        if getattr(args, "allow_sparse_cut", False):
+        if args.allow_sparse_cut:
             crender.append("--allow-sparse-cut")
         _run("video-cut", "cut.py", *crender)
         cut_qc = _surface_cut_qc(work_dir)
@@ -638,10 +630,7 @@ def main():
         aargs.append("--jianying-no-bundle-media")
     _run("video-assemble", "assemble.py", *aargs)
 
-    final_dir = Path(args.output_dir) if args.output_dir else work_dir.parent
-    final_output = _read_assembly_output(work_dir) or (
-        final_dir / ("recap_" + video.stem + ".mp4")
-    )
+    final_output = _read_assembly_output(work_dir)
     _write_shift_left_stage_qc(
         work_dir,
         "post_render",

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

@@ -1,25 +1,17 @@
-"""Provide subprocess, manifest, review, and preflight runtime helpers."""
-
-import hashlib
+"""Provide subprocess, manifest, and preflight runtime helpers."""
 
 import json
-
 import math
-
 import os
-
 import shlex
-
+import shutil
 import subprocess
-
 import sys
-
 from pathlib import Path
 
-
-from doctor import ffmpeg_has_subtitles_filter
-
 import materials as material_lib
+from doctor import ffmpeg_has_subtitles_filter
+from lib import env_bool, load_json
 
 BUNDLE = Path(__file__).resolve().parents[2]  # the skills/ directory
 
@@ -36,13 +28,6 @@ def _run(skill, script, *cli_args):
         raise SystemExit(f"{skill}/{script} 失败 (exit {res.returncode})")
 
 
-def _env_bool(name, default=False):
-    raw = os.environ.get(name)
-    if raw is None or raw == "":
-        return default
-    return raw.strip().lower() in {"1", "true", "yes", "y", "on"}
-
-
 def _optional_env_int(name):
     raw = os.environ.get(name)
     if raw is None or raw.strip() == "":
@@ -73,8 +58,8 @@ def _read_video_duration_or_raise(path):
         raise SystemExit(f"无法读取成片时长: {path} ({detail})")
     try:
         duration = float(res.stdout.strip())
-    except (TypeError, ValueError):
-        raise SystemExit(f"无法读取成片时长: {path} (ffprobe 输出无效: {res.stdout!r})")
+    except ValueError:
+        raise SystemExit(f"无法读取成片时长: {path} (ffprobe 输出无效: {res.stdout!r})") from None
     if not math.isfinite(duration) or duration <= 0:
         raise SystemExit(f"无法读取成片时长: {path} (duration={duration:.3f})")
     return duration
@@ -96,79 +81,35 @@ def _probe_display_height_or_raise(path, *, require_square_pixels=False):
     ]
     res = subprocess.run(cmd, capture_output=True, text=True)
     try:
-        stream = (json.loads(res.stdout or "{}").get("streams") or [])[0]
+        stream = json.loads(res.stdout)["streams"][0]
         width, height = int(stream["width"]), int(stream["height"])
-    except (IndexError, KeyError, TypeError, ValueError, json.JSONDecodeError):
+    except (IndexError, KeyError, ValueError):
         detail = (res.stderr or res.stdout or "ffprobe failed").strip()
-        raise SystemExit(f"无法读取视频画布: {path} ({detail})")
-    sar = str(stream.get("sample_aspect_ratio") or "1:1")
+        raise SystemExit(f"无法读取视频画布: {path} ({detail})") from None
+    sar = stream.get("sample_aspect_ratio", "1:1")
     try:
         num, den = sar.split(":", 1)
         sar_ratio = float(num) / float(den)
-        display_width = max(1, int(round(width * sar_ratio)))
-    except (TypeError, ValueError, ZeroDivisionError):
+    except (ValueError, ZeroDivisionError):
         sar_ratio = math.nan
-        display_width = width
     if require_square_pixels and (
         not math.isfinite(sar_ratio) or abs(sar_ratio - 1.0) >= 1e-9
     ):
         raise SystemExit(
             f"subtitle Y coordinates currently require square-pixel video (SAR 1:1); got {sar}"
         )
+    display_width = max(1, round(width * sar_ratio)) if math.isfinite(sar_ratio) else width
     rotation_values = [
-        (stream.get("tags") or {}).get("rotate"),
-        *(
-            item.get("rotation")
-            for item in stream.get("side_data_list") or []
-            if isinstance(item, dict)
-        ),
+        stream.get("tags", {}).get("rotate"),
+        *(item.get("rotation") for item in stream.get("side_data_list", [])),
     ]
-    rotation = 0
-    for value in rotation_values:
-        if value not in (None, ""):
-            try:
-                rotation = int(round(float(value))) % 360
-                break
-            except (TypeError, ValueError):
-                pass
+    rotation = next(
+        (int(round(float(value))) % 360 for value in rotation_values if value not in (None, "")),
+        0,
+    )
     return display_width if rotation in {90, 270} else height
 
 
-_FILE_FINGERPRINT_MEMO = {}
-
-
-def _file_identity(path):
-    """(device, inode, size, mtime_ns) — changes whenever the bytes could have changed."""
-    st = os.stat(os.fspath(path))
-    return (st.st_dev, st.st_ino, st.st_size, st.st_mtime_ns)
-
-
-def _file_fingerprint(path, chunk_size=1024 * 1024):
-    """Return a full-content fingerprint for cache-correct identity checks.
-
-    The digest covers CONTENT only — never the path or mtime — so a copied video or
-    artifact is still recognised as the same asset, while any byte change invalidates
-    the cache even if timestamps, size, head, or tail bytes are misleading.
-
-    Identity metadata is used ONLY to memoize within a single process. One understanding
-    run fingerprints the same source video 8-10 times and the whole extracted frame set
-    2-3 times; on a 40-minute video at fps=1 that is gigabytes of redundant reads before
-    any real work starts. A file rewritten in place gets a new (size, mtime_ns) and is
-    re-hashed, so the memo can never serve a stale digest.
-    """
-    key = _file_identity(path)
-    memoized = _FILE_FINGERPRINT_MEMO.get(key)
-    if memoized is not None:
-        return memoized
-    h = hashlib.sha256()
-    with open(os.fspath(path), "rb") as f:
-        for chunk in iter(lambda: f.read(chunk_size), b""):
-            h.update(chunk)
-    digest = h.hexdigest()
-    _FILE_FINGERPRINT_MEMO[key] = digest
-    return digest
-
-
 def _analysis_settings(args):
     return {
         "context": args.context,
@@ -197,7 +138,7 @@ def _run_manifest_payload(video, args):
     return {
         "schema_version": 1,
         "source_video": str(Path(video).resolve()),
-        "source_video_fingerprint": _file_fingerprint(video),
+        "source_video_fingerprint": material_lib.file_fingerprint(video),
         "settings": _analysis_settings(args),
     }
 
@@ -212,7 +153,7 @@ def _write_run_manifest(work_dir, video, args):
 def _build_multi_source_records(videos, args):
     records = []
     for video in _coerce_videos(videos):
-        fp = _file_fingerprint(video)
+        fp = material_lib.file_fingerprint(video)
         records.append(
             {
                 "source_path": str(video),
@@ -234,11 +175,11 @@ def _multi_run_manifest_payload(videos, args, source_records):
         "mode": "multi_source",
         "sources": [
             {
-                "source_id": s.get("source_id"),
-                "source_path": s.get("source_path"),
-                "source_video_fingerprint": s.get("source_video_fingerprint"),
-                "source_work_dir": s.get("source_work_dir"),
-                "material_id": s.get("material_id"),
+                "source_id": s["source_id"],
+                "source_path": s["source_path"],
+                "source_video_fingerprint": s["source_video_fingerprint"],
+                "source_work_dir": s["source_work_dir"],
+                "material_id": s["material_id"],
             }
             for s in source_records
         ],
@@ -265,7 +206,7 @@ def _write_multi_source_manifest(work_dir, source_records):
                 "source_name": s["source_name"],
                 "source_video_fingerprint": s["source_video_fingerprint"],
                 "source_work_dir": s["source_work_dir"],
-                "material_id": s.get("material_id"),
+                "material_id": s["material_id"],
             }
             for s in source_records
         ],
@@ -275,32 +216,18 @@ def _write_multi_source_manifest(work_dir, source_records):
 
 
 def _load_run_manifest(work_dir):
+    """The run manifest, or None before Phase A has written one."""
     path = Path(work_dir) / RUN_MANIFEST
-    if not path.exists():
-        return None
-    try:
-        return json.loads(path.read_text(encoding="utf-8"))
-    except (OSError, ValueError, TypeError):
-        return None
-
-
-def _load_json(path):
-    try:
-        return json.loads(Path(path).read_text(encoding="utf-8"))
-    except (OSError, ValueError, TypeError):
-        return None
+    return load_json(path) if path.exists() else None
 
 
 def _burn_subtitles_intended(args):
     """Effective burn-subtitles state at orchestrator level. Mirrors video-assemble's
     CONFIG default `env_bool("BURN_SUBTITLES", True)` (burn is ON by default); an explicit
     CLI flag (--burn-subtitles / --no-burn-subtitles) overrides the env."""
-    if getattr(args, "burn_subtitles", None) is not None:
-        return bool(args.burn_subtitles)
-    raw = os.environ.get("BURN_SUBTITLES")
-    if raw is None or raw == "":
-        return True
-    return raw.strip().lower() in {"1", "true", "yes", "y", "on"}
+    if args.burn_subtitles is not None:
+        return args.burn_subtitles
+    return env_bool("BURN_SUBTITLES", True)
 
 
 def _ffmpeg_present_but_cannot_burn():
@@ -309,8 +236,6 @@ def _ffmpeg_present_but_cannot_burn():
     entirely: that is a more fundamental problem that surfaces at the first stage (understand
     calls ffprobe/ffmpeg) and is reported by doctor, so this guard stays narrow — and does
     not fire in mocked, ffmpeg-less test environments."""
-    import shutil
-
     if shutil.which("ffmpeg") is None:
         return False
     return not ffmpeg_has_subtitles_filter()

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

@@ -1,126 +1,71 @@
 """Write shift-left, MiMo, and final QC stage reports."""
 
 import json
-
-
 from pathlib import Path
 
-import qc_contract
-
 import final_qc
-
 import mimo_qc
-
-
-from recap_runtime import _load_json
+import qc_contract
 
 ASSEMBLY_MANIFEST = "assembly_manifest.json"
-
-
-def _json_safe(value):
-    """Return a JSON-serializable, secret-redacted copy for local QC metadata."""
-
-    def convert(item):
-        if isinstance(item, Path):
-            return str(item)
-        if isinstance(item, dict):
-            return {str(k): convert(v) for k, v in item.items()}
-        if isinstance(item, (list, tuple)):
-            return [convert(v) for v in item]
-        return item
-
-    return qc_contract.redact_secrets(convert(value))
+PREFLIGHT_QC = "preflight_qc.json"
 
 
 def _load_preflight_stage_reports(work_dir):
-    path = Path(work_dir) / "preflight_qc.json"
+    path = Path(work_dir) / PREFLIGHT_QC
     if not path.exists():
         return {}
-    data = _load_json(path)
-    if not isinstance(data, dict):
-        raise qc_contract.QCContractError("preflight_qc.json must be a JSON object")
-    qc_contract.validate_report(data)
-    stages = None
-    metadata = data.get("metadata")
-    if isinstance(metadata, dict) and isinstance(metadata.get("stages"), dict):
-        stages = metadata.get("stages")
-    elif isinstance(data.get("stages"), dict):
-        stages = data.get("stages")
-    if stages is None:
-        return {data["stage"]: data}
-    stage_reports = {}
-    for stage, report in stages.items():
-        if not isinstance(report, dict):
-            raise qc_contract.QCContractError(
-                f"preflight stage report must be an object: {stage}"
-            )
-        qc_contract.validate_report(report)
-        if report.get("stage") != stage:
-            raise qc_contract.QCContractError(
-                f"preflight stage key does not match report stage: {stage}"
-            )
-        stage_reports[stage] = report
-    return stage_reports
-
-
-def _write_shift_left_stage_qc(work_dir, stage, metadata=None, findings=None):
+    return json.loads(path.read_text(encoding="utf-8"))["metadata"]["stages"]
+
+
+def _write_shift_left_stage_qc(work_dir, stage, metadata, findings=None):
     """Write/roll up local shift-left QC for one pipeline stage.
 
-    This is a local contract artifact only: no MiMo/deep eval calls, no repair, and
-    no credential persistence. Any validation/write failure is allowed to raise.
+    This is a local contract artifact only: no MiMo/deep eval calls, no repair, and no
+    credential persistence (qc_contract redacts every report it builds).
     """
-    work_dir = Path(work_dir)
-    path = work_dir / "preflight_qc.json"
     stage_report = qc_contract.build_report(
-        artifact="preflight_qc.json",
-        stage=stage,
-        findings=findings or [],
-        metadata=_json_safe(metadata or {}),
+        artifact=PREFLIGHT_QC, stage=stage, findings=findings, metadata=metadata
     )
     stage_reports = _load_preflight_stage_reports(work_dir)
     stage_reports[stage] = stage_report
-    aggregate_findings = []
-    for report in stage_reports.values():
-        aggregate_findings.extend(dict(f) for f in report.get("findings", []))
-    top_metadata = dict(stage_report.get("metadata") or {})
+    top_metadata = dict(stage_report["metadata"])
     top_metadata["latest_stage"] = stage
     top_metadata["stages"] = stage_reports
     top_report = qc_contract.build_report(
-        artifact="preflight_qc.json",
+        artifact=PREFLIGHT_QC,
         stage=stage,
-        findings=aggregate_findings,
-        metadata=_json_safe(top_metadata),
+        findings=[f for report in stage_reports.values() for f in report["findings"]],
+        metadata=top_metadata,
     )
-    qc_contract.validate_report(top_report)
-    path.write_text(
+    (Path(work_dir) / PREFLIGHT_QC).write_text(
         json.dumps(top_report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
     )
-    qc_contract.validate_report(_load_json(path))
     return top_report
 
 
 def _tts_qc_metadata(work_dir):
     work_dir = Path(work_dir)
     metadata = {}
-    tts_meta = _load_json(work_dir / "tts_meta.json")
-    if tts_meta is not None:
-        metadata["tts_meta"] = tts_meta
+    tts_meta = work_dir / "tts_meta.json"
+    if tts_meta.exists():
+        metadata["tts_meta"] = json.loads(tts_meta.read_text(encoding="utf-8"))
     tts_dir = work_dir / "tts_segments"
-    if tts_dir.exists() and tts_dir.is_dir():
+    if tts_dir.is_dir():
         metadata["tts_segments"] = [
-            p.relative_to(work_dir).as_posix()
-            for p in sorted(tts_dir.iterdir())
-            if p.is_file()
+            p.relative_to(work_dir).as_posix() for p in sorted(tts_dir.iterdir()) if p.is_file()
         ]
     return metadata
 
 
 def _post_render_qc_metadata(work_dir, final_output):
     work_dir = Path(work_dir)
-    metadata = {"final_output": str(final_output) if final_output is not None else None}
-    assembly_manifest = _load_json(work_dir / ASSEMBLY_MANIFEST)
-    if assembly_manifest is not None:
-        metadata["assembly_manifest"] = assembly_manifest
+    metadata = {"final_output": str(final_output)}
+    manifest = work_dir / ASSEMBLY_MANIFEST
+    if manifest.exists():
+        metadata["assembly_manifest"] = json.loads(
+            manifest.read_text(encoding="utf-8")
+        )
     return metadata
 
 
@@ -136,13 +81,11 @@ def _write_final_qc_reports(work_dir, final_output):
 def _print_final_qc_pointer(result):
     """Surface a report-only final_qc/golden_eval FAIL so the shift-left QC is
     not a silent no-op. Advisory only: it never changes the exit status."""
-    if not isinstance(result, dict):
-        return
-    problems = []
-    for key in ("final_qc", "golden_eval"):
-        section = result.get(key)
-        if isinstance(section, dict) and section.get("ok") is False:
-            problems.append(f"{key} blocker_count={section.get('blocker_count', '?')}")
+    problems = [
+        f"{key} blocker_count={result[key].get('blocker_count', '?')}"
+        for key in ("final_qc", "golden_eval")
+        if result[key].get("ok") is False
+    ]
     if problems:
         print(
             "[video-recap] ⚠️  最终 QC 未通过（仅报告，不阻断）: "
@@ -152,47 +95,34 @@ def _print_final_qc_pointer(result):
 
 
 def _mimo_qc_stage_enabled(args, stage):
-    mode = getattr(args, "mimo_qc", "off") or "off"
     return (
-        mode == "both"
-        or (mode == "pre-assemble" and stage == "pre_assemble")
-        or (mode == "post-render" and stage == "post_render")
+        args.mimo_qc == "both"
+        or (args.mimo_qc == "pre-assemble" and stage == "pre_assemble")
+        or (args.mimo_qc == "post-render" and stage == "post_render")
     )
 
 
 def _prepare_mimo_qc(work_dir, args):
     """Remove an old advisory artifact when this run has MiMo QC disabled."""
-    if getattr(args, "mimo_qc", "off") == "off":
+    if args.mimo_qc == "off":
         mimo_qc.clear_report(work_dir)
 
 
 def _print_mimo_qc_pointer(result, stage):
-    report = result.get("report", {}) if isinstance(result, dict) else {}
-    metadata = report.get("metadata", {}) if isinstance(report, dict) else {}
-    status = metadata.get("status", "unknown")
-    path = (
-        result.get("path", "mimo_qc.json")
-        if isinstance(result, dict)
-        else "mimo_qc.json"
-    )
-    stage_findings = [
-        finding
-        for finding in report.get("findings", [])
-        if isinstance(finding, dict) and finding.get("stage") == stage
-    ]
+    report = result["report"]
+    metadata = report["metadata"]
+    status = metadata["status"]
+    stage_findings = [f for f in report["findings"] if f["stage"] == stage]
     if status in {"failed", "unavailable"}:
-        reason = metadata.get("error") or "unavailable"
         print(
-            f"[video-recap] ⚠ MiMo QC {stage}: {status} ({reason})；建议性检查不可用，继续流水线"
+            f"[video-recap] ⚠ MiMo QC {stage}: {status} ({metadata['error']})；建议性检查不可用，继续流水线"
         )
         return
     print(
-        f"[video-recap] ℹ MiMo QC {stage}: {status}, {len(stage_findings)} 条建议；详见 {path}"
+        f"[video-recap] ℹ MiMo QC {stage}: {status}, {len(stage_findings)} 条建议；详见 {result['path']}"
     )
     for finding in stage_findings[:5]:
-        print(
-            f"[video-recap]   - {finding.get('message') or finding.get('decision_reason')}"
-        )
+        print(f"[video-recap]   - {finding['message']}")
 
 
 def _run_mimo_qc_stage(work_dir, args, stage, *, final_output=None):
@@ -204,7 +134,7 @@ def _run_mimo_qc_stage(work_dir, args, stage, *, final_output=None):
             work_dir,
             stage=stage,
             live=True,
-            refresh=bool(getattr(args, "mimo_qc_refresh", False)),
+            refresh=args.mimo_qc_refresh,
             final_output=final_output,
         )
     except Exception as exc: