@oh-story/dsh 0.1.11 → 0.1.13

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

@@ -1,320 +0,0 @@
-"""Shared shift-left QC report contract for video-recap artifacts.
-
-This module is intentionally standalone: it defines a small schema and local
-validation helpers only. It does not call MiMo, read credentials, connect the
-pipeline, or attempt automatic fixes.
-"""
-from __future__ import annotations
-
-import re
-from pathlib import Path
-from typing import Any
-from collections.abc import Mapping, Sequence
-from urllib.parse import urlsplit, urlunsplit
-
-
-SCHEMA_VERSION = 1
-
-STAGES = frozenset({
-    "pre_cut",
-    "post_cut",
-    "pre_tts",
-    "post_tts",
-    "pre_assemble",
-    "post_render",
-    "golden",
-})
-SEVERITIES = frozenset({"info", "advisory", "warning", "blocker"})
-CONFIDENCES = frozenset({"low", "medium", "high", "objective"})
-SAMPLE_POLICIES = frozenset({"all", "deterministic", "sampled", "semantic", "aesthetic"})
-ARTIFACTS = frozenset({"final_qc.json", "golden_eval.json", "mimo_qc.json", "preflight_qc.json"})
-
-DETERMINISTIC_CATEGORIES = frozenset({
-    "missing_artifact",
-    "duration",
-    "stream",
-    "subtitle",
-    "tts_placement",
-    "schema_invalid",
-    "placement",
-})
-NON_DETERMINISTIC_CATEGORIES = frozenset({"semantic", "aesthetic", "mimo_semantic", "mimo_aesthetic"})
-BLOCKING_SEVERITIES = frozenset({"blocker"})
-_SECRET_KEY_RE = re.compile(r"(?i)(api[_-]?key|token|secret|password|authorization|credential)")
-_SECRET_VALUE_RE = re.compile(r"\b(?:sk|tp)-[A-Za-z0-9_-]{6,}\b")
-_URL_SCHEMES_TO_SCRUB = frozenset({"http", "https", "ws", "wss"})
-REDACTED = "<redacted>"
-
-
-def _redact_url(value: str) -> str:
-    """Strip URL credentials, query, and fragment while preserving useful host/path."""
-    try:
-        parts = urlsplit(value)
-    except ValueError:
-        return value
-    if parts.scheme.lower() not in _URL_SCHEMES_TO_SCRUB or not parts.netloc:
-        return value
-    host = parts.hostname or ""
-    if not host:
-        return value
-    if ":" in host and not host.startswith("["):
-        host = f"[{host}]"
-    netloc = host
-    try:
-        port = parts.port
-    except ValueError:
-        port = None
-    if port is not None:
-        netloc = f"{netloc}:{port}"
-    return urlunsplit((parts.scheme, netloc, parts.path, "", ""))
-
-
-def redact_secrets(value: Any) -> Any:
-    """Return a JSON-safe copy with likely credentials removed.
-
-    Centralized for all video-recap QC reports: redacts secret-looking keys,
-    common synthetic key/token values, and URL userinfo/query/fragment fields.
-    """
-    if isinstance(value, Mapping):
-        redacted: dict[str, Any] = {}
-        for key, item in value.items():
-            key_s = str(key)
-            redacted[key_s] = REDACTED if _SECRET_KEY_RE.search(key_s) else redact_secrets(item)
-        return redacted
-    if isinstance(value, list):
-        return [redact_secrets(item) for item in value]
-    if isinstance(value, tuple):
-        return [redact_secrets(item) for item in value]
-    if isinstance(value, Path):
-        return str(value)
-    if isinstance(value, str):
-        return _SECRET_VALUE_RE.sub(REDACTED, _redact_url(value))
-    return value
-
-
-_REQUIRED_FINDING_FIELDS = frozenset({
-    "finding_id",
-    "stage",
-    "severity",
-    "blocking",
-    "deterministic",
-    "confidence",
-    "rule_id",
-    "decision_reason",
-    "location",
-    "evidence",
-    "sample_policy",
-    "model_used",
-    "next_action",
-    # Helper fields kept for current rule semantics and compatibility.
-    "category",
-    "code",
-    "message",
-    "source",
-    "objective_corroboration",
-})
-_REQUIRED_LOCATION_FIELDS = frozenset({"timecode", "source_span"})
-_REQUIRED_REPORT_FIELDS = frozenset({
-    "schema_version",
-    "artifact",
-    "stage",
-    "ok",
-    "blocker_count",
-    "finding_count",
-    "findings",
-})
-
-
-class QCContractError(ValueError):
-    """Raised when a QC report or finding violates the shared contract."""
-
-
-def build_finding(
-    *,
-    stage: str,
-    severity: str,
-    confidence: str,
-    sample_policy: str | Mapping[str, Any],
-    category: str,
-    code: str,
-    message: str,
-    finding_id: str | None = None,
-    id: str | None = None,
-    rule_id: str | None = None,
-    decision_reason: str | None = None,
-    model_used: str | None = None,
-    next_action: str | None = None,
-    deterministic: bool | None = None,
-    blocking: bool | None = None,
-    source: Mapping[str, Any] | None = None,
-    location: Mapping[str, Any] | None = None,
-    evidence: Mapping[str, Any] | None = None,
-    objective_corroboration: Mapping[str, Any] | None = None,
-    **extra: Any,
-) -> dict[str, Any]:
-    """Build and validate one normalized QC finding.
-
-    Deterministic objective findings may block. MiMo semantic/aesthetic findings
-    default to advisory and may never block. Objective checks belong in the
-    deterministic QC producers instead of upgrading subjective model findings.
-    """
-    if finding_id is None:
-        finding_id = id
-    if finding_id is None:
-        raise QCContractError("finding_id is required")
-    if rule_id is None:
-        rule_id = code
-    if decision_reason is None:
-        decision_reason = message
-    if model_used is None:
-        model_used = "local_deterministic"
-    if next_action is None:
-        next_action = "manual_review"
-    if isinstance(sample_policy, str):
-        sample_policy = {"type": sample_policy}
-
-    if deterministic is None:
-        deterministic = category in DETERMINISTIC_CATEGORIES
-    if source is None:
-        source = {}
-    source = redact_secrets(source)
-    if location is None:
-        location = {"timecode": None, "source_span": None}
-    else:
-        location = {"timecode": location.get("timecode"), "source_span": location.get("source_span")}
-    if evidence is None:
-        evidence = {}
-    evidence = redact_secrets(evidence)
-    objective_corroboration = redact_secrets(objective_corroboration or {})
-
-    is_non_deterministic = (not deterministic) or category in NON_DETERMINISTIC_CATEGORIES
-    if is_non_deterministic and blocking is None:
-        blocking = False
-    elif blocking is None:
-        blocking = severity in BLOCKING_SEVERITIES
-
-    if is_non_deterministic and blocking:
-        raise QCContractError(f"non-deterministic blocking finding is not allowed: {category}/{code}")
-
-    finding = {
-        "finding_id": finding_id,
-        "id": finding_id,
-        "stage": stage,
-        "severity": severity,
-        "blocking": bool(blocking),
-        "deterministic": bool(deterministic),
-        "confidence": confidence,
-        "rule_id": rule_id,
-        "decision_reason": decision_reason,
-        "location": dict(location),
-        "evidence": dict(evidence),
-        "sample_policy": dict(sample_policy),
-        "model_used": model_used,
-        "next_action": next_action,
-        "category": category,
-        "code": code,
-        "message": message,
-        "source": dict(source),
-        "objective_corroboration": dict(objective_corroboration),
-    }
-    finding.update(redact_secrets(extra))
-    _validate_finding(finding)
-    return finding
-
-
-def build_report(
-    *,
-    artifact: str,
-    stage: str,
-    findings: Sequence[Mapping[str, Any]] | None = None,
-    metadata: Mapping[str, Any] | None = None,
-) -> dict[str, Any]:
-    """Build and validate a minimal report for a supported QC artifact."""
-    normalized_findings = [redact_secrets(dict(f)) for f in (findings or [])]
-    blocker_count = sum(1 for f in normalized_findings if f.get("blocking") is True)
-    report = {
-        "schema_version": SCHEMA_VERSION,
-        "artifact": artifact,
-        "stage": stage,
-        "ok": blocker_count == 0,
-        "blocker_count": blocker_count,
-        "finding_count": len(normalized_findings),
-        "findings": normalized_findings,
-        "metadata": redact_secrets(dict(metadata or {})),
-    }
-    validate_report(report)
-    return report
-
-
-def validate_report(report: Mapping[str, Any]) -> bool:
-    """Validate report shape, value domains, and blocking semantics."""
-    if not isinstance(report, Mapping):
-        raise QCContractError("report must be an object")
-    missing = _REQUIRED_REPORT_FIELDS - set(report)
-    if missing:
-        raise QCContractError(f"report missing required fields: {sorted(missing)}")
-    if report["schema_version"] != SCHEMA_VERSION:
-        raise QCContractError(f"unsupported schema_version: {report['schema_version']!r}")
-    if report["artifact"] not in ARTIFACTS:
-        raise QCContractError(f"unsupported artifact: {report['artifact']!r}")
-    if report["stage"] not in STAGES:
-        raise QCContractError(f"unsupported stage: {report['stage']!r}")
-    if not isinstance(report["findings"], list):
-        raise QCContractError("findings must be a list")
-    for finding in report["findings"]:
-        _validate_finding(finding)
-    blocker_count = sum(1 for f in report["findings"] if f.get("blocking") is True)
-    if report["blocker_count"] != blocker_count:
-        raise QCContractError("blocker_count does not match findings")
-    if report["finding_count"] != len(report["findings"]):
-        raise QCContractError("finding_count does not match findings")
-    if report["ok"] != (blocker_count == 0):
-        raise QCContractError("ok must be true exactly when blocker_count is zero")
-    return True
-
-
-def _validate_finding(finding: Mapping[str, Any]) -> None:
-    if not isinstance(finding, Mapping):
-        raise QCContractError("finding must be an object")
-    missing = _REQUIRED_FINDING_FIELDS - set(finding)
-    if missing:
-        raise QCContractError(f"finding missing required fields: {sorted(missing)}")
-    if finding["stage"] not in STAGES:
-        raise QCContractError(f"unsupported finding stage: {finding['stage']!r}")
-    if finding["severity"] not in SEVERITIES:
-        raise QCContractError(f"unsupported severity: {finding['severity']!r}")
-    if finding["confidence"] not in CONFIDENCES:
-        raise QCContractError(f"unsupported confidence: {finding['confidence']!r}")
-    sample_policy = finding["sample_policy"]
-    if not isinstance(sample_policy, Mapping):
-        raise QCContractError("sample_policy must be an object")
-    sample_policy_type = sample_policy.get("type")
-    if sample_policy_type not in SAMPLE_POLICIES:
-        raise QCContractError(f"unsupported sample_policy.type: {sample_policy_type!r}")
-    if not isinstance(finding["deterministic"], bool):
-        raise QCContractError("deterministic must be boolean")
-    if not isinstance(finding["blocking"], bool):
-        raise QCContractError("blocking must be boolean")
-    if finding["blocking"] and finding["severity"] != "blocker":
-        raise QCContractError("blocking findings must use severity='blocker'")
-    location = finding["location"]
-    if not isinstance(location, Mapping):
-        raise QCContractError("location must be an object")
-    missing_location = _REQUIRED_LOCATION_FIELDS - set(location)
-    if missing_location:
-        raise QCContractError(f"location missing required fields: {sorted(missing_location)}")
-    if finding["source"] is None or not isinstance(finding["source"], Mapping):
-        raise QCContractError("source must be an object")
-    if finding["evidence"] is None or not isinstance(finding["evidence"], Mapping):
-        raise QCContractError("evidence must be an object")
-    if finding["objective_corroboration"] is None or not isinstance(finding["objective_corroboration"], Mapping):
-        raise QCContractError("objective_corroboration must be an object")
-    for field in ("finding_id", "rule_id", "decision_reason", "model_used", "next_action"):
-        if not isinstance(finding[field], str) or not finding[field]:
-            raise QCContractError(f"{field} must be a non-empty string")
-
-    is_non_deterministic = (not finding["deterministic"]) or finding["category"] in NON_DETERMINISTIC_CATEGORIES
-    if is_non_deterministic and finding["blocking"]:
-        raise QCContractError(
-            f"non-deterministic blocking finding is not allowed: {finding['category']}/{finding['code']}"
-        )

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

@@ -1,108 +0,0 @@
-"""Fuse scenes, ASR, and quiet windows for narration planning."""
-
-from lib import CONFIG
-from agent_text import _overlap_seconds, _recommended_char_budget
-from narration_lint import _validate_narration_budget
-
-
-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 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.
-
-    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:
-        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:
-        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 _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"])
-            if end > start:
-                windows.append((start, end))
-    return windows
-
-
-def _build_timeline_fusion(scenes, asr_segments, silence_periods):
-    """Fuse VLM scenes, ASR dialogue and quiet narration slots on one timeline."""
-    fusion = []
-    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:
-            overlap = _overlap_seconds(start, end, seg["start"], seg["end"])
-            if overlap <= 0:
-                continue
-            dialogue_overlap += overlap
-            dialogue_segments.append(
-                {
-                    "start": round(seg["start"], 2),
-                    "end": round(seg["end"], 2),
-                    "overlap_seconds": round(overlap, 2),
-                    "text": seg["text"],
-                }
-            )
-
-        narration_slots = []
-        for window in quiet_windows:
-            overlap = _overlap_seconds(start, end, window["start"], window["end"])
-            if overlap <= 0:
-                continue
-            slot_start = max(start, window["start"])
-            slot_end = min(end, window["end"])
-            narration_slots.append(
-                {
-                    "start": round(slot_start, 2),
-                    "end": round(slot_end, 2),
-                    "duration": round(slot_end - slot_start, 2),
-                    "char_budget": _recommended_char_budget(slot_start, slot_end),
-                }
-            )
-
-        fusion.append(
-            {
-                "scene_id": scene["scene_id"],
-                "time_range": [round(start, 2), round(end, 2)],
-                "visual_description": scene["description"],
-                "depth_analysis": scene.get("depth_analysis", ""),
-                "frame_facts": scene.get("frame_facts", {}),
-                "dialogue_segments": dialogue_segments,
-                "dialogue_overlap_seconds": round(dialogue_overlap, 2),
-                "narration_slots": narration_slots,
-                "recommended_mode": "quiet-slot"
-                if narration_slots and dialogue_overlap < (end - start) * 0.4
-                else "ducked-bed",
-            }
-        )
-    return fusion

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

@@ -1,9 +0,0 @@
-"""Public narration-brief API for this self-contained skill."""
-
-from briefing.builder import build_agent_brief
-from briefing.context import assess_understanding_substrate
-
-__all__ = [
-    "assess_understanding_substrate",
-    "build_agent_brief",
-]

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

@@ -1,211 +0,0 @@
-"""Deterministic narration readability/QC scanner.
-
-This module is intentionally report-only. It flags local readability and
-packaging hygiene risks for video narration; it is not an AIGC detector and it
-never rewrites text.
-"""
-
-from __future__ import annotations
-
-import json
-import re
-from pathlib import Path
-from typing import Any
-
-CONTRACT = (
-    "Local readability/QC report only: this is not an AIGC detector, does not "
-    "claim AI-generation accuracy, and never rewrites text. Corrections remain "
-    "human/agent rewrite work."
-)
-
-EM_DASH_RE = re.compile(r"——|—")
-NEGATIVE_FLIP_RE = re.compile(r"并?不是[^。！？!?；;\.]{0,40}而是")
-# Catch verbatim copy of the brief's example scaffolding without over-matching real text.
-# The bracketed role token 【主角】 is the placeholder; anchor the pronoun signal to the
-# example's exact phrase "TA要赌上" so the legitimate gender-neutral pronoun "TA" (他/她) +
-# 要 (idiomatic 解说 suspense device "凶手就在其中，TA要做的下一件事…") is NOT hard-blocked.
-PLACEHOLDER_RE = re.compile(r"【主角】|TA要赌上")
-
-CLICHE_TERMS = [
-    "命运的齿轮", "殊不知", "与此同时", "一场阴谋", "背后真相", "不为人知",
-    "故事就此展开", "命运", "真相", "秘密", "危机", "反转", "救赎",
-]
-ABSTRACT_TERMS = ["人性", "成长", "救赎", "命运", "时代", "宿命", "选择", "意义", "价值", "情感"]
-REASONING_MARKERS = ["因为", "所以", "因此", "也就是说", "换句话说", "这意味着", "原因是", "可见"]
-METAPHOR_MARKERS = ["像", "仿佛", "好似", "犹如", "如同", "一把", "一场", "一张", "棋局", "风暴"]
-CONNECTIVE_MARKERS = ["但", "却", "而", "于是", "随后", "直到", "结果", "因为", "所以", "这时", "最后"]
-
-
-def _sentence_pieces(text: str) -> list[str]:
-    """Split text into sentence-like pieces while keeping terminal punctuation."""
-    text = re.sub(r"\s+", " ", text).strip()
-    if not text:
-        return []
-    parts = re.split(r"([。！？!?；;.])", text)
-    out: list[str] = []
-    for idx in range(0, len(parts), 2):
-        body = parts[idx].strip()
-        punct = parts[idx + 1] if idx + 1 < len(parts) else ""
-        if body or punct:
-            out.append((body + punct).strip())
-    return out or [text]
-
-
-def _text_units(text: str) -> int:
-    """Length unit for prose: CJK characters, otherwise words."""
-    if re.search(r"[\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff]", text):
-        return len(re.sub(r"\s+", "", text))
-    return len(re.findall(r"\b\w+\b", text))
-
-
-def _normalise_segments(payload: list[dict[str, Any]], *, source: str) -> list[dict[str, Any]]:
-    key = "narration" if source == "narration" else "text"
-    segments: list[dict[str, Any]] = []
-    for idx, item in enumerate(payload):
-        text = str(item.get(key, "")).strip()
-        if text:
-            segments.append({"source": source, "index": idx, "text": text})
-    return segments
-
-
-def _load_original_subtitles(work_dir: Path | None) -> list[dict[str, Any]]:
-    if work_dir is None:
-        return []
-    path = work_dir / "original_subtitles.json"
-    if not path.exists():
-        return []
-    return _normalise_segments(json.loads(path.read_text(encoding="utf-8")), source="original_subtitles")
-
-
-def _style_card_requirement(work_dir: Path | None) -> tuple[bool, str]:
-    """Read the explicit requirements contract; workspaces without one are advisory-only."""
-    if work_dir is None:
-        return False, "legacy_default"
-    path = work_dir / "deslop_qc_requirements.json"
-    if not path.exists():
-        return False, "legacy_default"
-    data = json.loads(path.read_text(encoding="utf-8"))
-    return data["style_card_required"], "deslop_qc_requirements.json"
-
-
-def _style_card_issue(work_dir: Path | None, required: bool) -> dict[str, Any] | None:
-    if work_dir is None:
-        return None
-    severity = "blocker" if required else "advisory"
-    path = work_dir / "style_card.json"
-    if not path.exists():
-        return {
-            "severity": severity,
-            "code": "missing_style_card",
-            "source": "style_card",
-            "index": None,
-            "message": (
-                "style_card.json is required by this expression/packaging run but is missing"
-                if required else
-                "style_card.json is absent; legacy/migration workspaces may continue, but new expression-special runs should author it"
-            ),
-        }
-    data = json.loads(path.read_text(encoding="utf-8"))
-    if not isinstance(data, dict) or not data:
-        return {
-            "severity": severity,
-            "code": "malformed_style_card",
-            "source": "style_card",
-            "index": None,
-            "message": (
-                "style_card.json is required but empty or not a JSON object"
-                if required else
-                "style_card.json is present but empty or not a JSON object; treat as migration warning unless the run requires it"
-            ),
-        }
-    return None
-
-
-def _add_issue(bucket: list[dict[str, Any]], severity: str, code: str, source: str, index: int | None, message: str, **extra: Any) -> None:
-    issue = {"severity": severity, "code": code, "source": source, "index": index, "message": message}
-    issue.update({k: v for k, v in extra.items() if v is not None})
-    bucket.append(issue)
-
-
-def analyze_deslop_qc(narration: list[dict[str, Any]], *, work_dir: str | Path | None = None, original_subtitles: list[dict[str, Any]] | None = None) -> dict[str, Any]:
-    """Return a structured report; never mutates or rewrites input text."""
-    work_path = Path(work_dir) if work_dir is not None else None
-    segments = _normalise_segments(narration, source="narration")
-    if original_subtitles is None:
-        segments.extend(_load_original_subtitles(work_path))
-    else:
-        segments.extend(_normalise_segments(original_subtitles, source="original_subtitles"))
-
-    blockers: list[dict[str, Any]] = []
-    advisories: list[dict[str, Any]] = []
-
-    required, requirement_source = _style_card_requirement(work_path)
-    style_issue = _style_card_issue(work_path, required)
-    if style_issue:
-        (blockers if style_issue["severity"] == "blocker" else advisories).append(style_issue)
-
-    all_text = "\n".join(seg["text"] for seg in segments)
-    total_units = max(1, _text_units(all_text))
-    sentences: list[str] = []
-    for seg in segments:
-        text = seg["text"]
-        if EM_DASH_RE.search(text):
-            _add_issue(blockers, "blocker", "em_dash", seg["source"], seg["index"], "破折号（—/——）不得出现在 narration/original_subtitles 中", matches=EM_DASH_RE.findall(text))
-        if PLACEHOLDER_RE.search(text):
-            _add_issue(blockers, "blocker", "placeholder_leakage", seg["source"], seg["index"], "示例占位内容泄漏到成稿中（如【主角】/TA要赌上）", matches=PLACEHOLDER_RE.findall(text))
-        for sentence in _sentence_pieces(text):
-            sentences.append(sentence)
-            if NEGATIVE_FLIP_RE.search(sentence):
-                _add_issue(advisories, "advisory", "negative_positive_flip", seg["source"], seg["index"], "“不是…而是…”模板化转折偏多，建议改成更具体的因果/行动表达", sentence=sentence[:120])
-
-    def term_count(terms: list[str]) -> int:
-        return sum(all_text.count(term) for term in terms)
-
-    cliche_count = term_count(CLICHE_TERMS)
-    abstract_count = term_count(ABSTRACT_TERMS)
-    reasoning_count = term_count(REASONING_MARKERS)
-    metaphor_count = term_count(METAPHOR_MARKERS)
-    connective_count = term_count(CONNECTIVE_MARKERS)
-
-    if cliche_count >= 4 or (cliche_count / total_units) > 0.025:
-        _add_issue(advisories, "advisory", "cliche_density", "narration", None, "套话/高频抽象词偏密，建议换成具体行动、选择和后果", count=cliche_count)
-    if abstract_count >= 5 or (abstract_count / total_units) > 0.03:
-        _add_issue(advisories, "advisory", "abstract_summary", "narration", None, "抽象总结词偏多，容易像概括论文；补足画面证据和具体抉择", count=abstract_count)
-    if reasoning_count >= 4:
-        _add_issue(advisories, "advisory", "reasoning_chain", "narration", None, "解释链标记偏多，建议减少“因为/所以/这意味着”等讲理口吻", count=reasoning_count)
-    if metaphor_count >= 4:
-        _add_issue(advisories, "advisory", "metaphor_markers", "narration", None, "比喻/包装化标记偏多，确认没有遮住剧情事实", count=metaphor_count)
-    if total_units >= 180 and connective_count <= 1:
-        _add_issue(advisories, "advisory", "low_connective_density", "narration", None, "长文本缺少转折/因果连接，可能像平铺摘要", connective_count=connective_count)
-
-    long_segments = [seg for seg in segments if seg["source"] == "narration" and _text_units(seg["text"]) > 180]
-    if long_segments:
-        _add_issue(advisories, "advisory", "overlong_narration_block", "narration", long_segments[0]["index"], "单个解说块过长，建议拆成更可听的段落", max_units=max(_text_units(seg["text"]) for seg in long_segments))
-    long_sentences = [s for s in sentences if _text_units(s) > 90]
-    if long_sentences:
-        _add_issue(advisories, "advisory", "long_paragraph", "narration", None, "长句/长段落偏多，字幕阅读压力较大", max_units=max(_text_units(s) for s in long_sentences))
-
-    return {
-        "ok": not blockers,
-        "contract": CONTRACT,
-        "scanner": "deslop_qc.py",
-        "style_card_required": required,
-        "style_card_requirement_source": requirement_source,
-        "blocker_count": len(blockers),
-        "advisory_count": len(advisories),
-        "blockers": blockers,
-        "advisories": advisories,
-        "metrics": {
-            "segments_scanned": len(segments),
-            "text_units": total_units if all_text else 0,
-            "sentence_count": len(sentences),
-            "cliche_count": cliche_count,
-            "abstract_count": abstract_count,
-            "reasoning_marker_count": reasoning_count,
-            "metaphor_marker_count": metaphor_count,
-            "connective_count": connective_count,
-        },
-    }
-
-
-__all__ = ["CONTRACT", "analyze_deslop_qc"]