@gobing-ai/knowledge-kit 0.0.12 → 0.0.14

package/plugins/generations/omni-voice-gen/src/omni_voice_gen/pipeline.py

@@ -0,0 +1,289 @@
+"""processGeneratorIO port (voice-gen index.ts): Doc[] -> rendered WAV (+MP3) -> audio Content.
+
+Deltas from voice-gen (task 0125 design):
+- One in-process Backend (D6) replaces HTTP generate/poll, so voice-gen's nested network + verify
+  loops collapse to one verify loop with a single inline retry on backend exceptions.
+- Retries resample (seed=None) instead of a random seed + halved max_chunk_chars: an explicit seed
+  pins attempt 0 only, and OmniVoice chunks by duration, not characters.
+- generationId is uuid4 hex[:16] per accepted render (there is no server history id).
+- metadata.duration and qc.totalDuration share one basis: segment durations plus the gaps
+  concat_wavs actually inserts (D8.2).
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+import uuid
+from collections.abc import Callable
+from dataclasses import fields, is_dataclass
+from pathlib import Path
+from time import monotonic
+from typing import Any
+
+import yaml
+
+from .audio import concat_wavs, detect_loudness_dip
+from .backend import Backend, OmnivoiceBackend, SegmentSpec
+from .contract import NOTICE_CONTENT, Content, Doc, content_to_json, parse_doc_list
+from .mp3 import is_mp3_requested, transcode_wav_to_mp3
+from .profiles import load_registry, resolve_profile
+from .qc import (
+    TRANSCRIPTION_FIDELITY_FLOOR,
+    audit_voice_segments,
+    transcription_fidelity,
+)
+from .voicescript import (
+    VoiceScript,
+    VoiceSegment,
+    WarnSink,
+    merge_voice_scripts,
+    parse_doc_to_voicescript,
+    resolve_instruct,
+    validate_voice_script,
+)
+
+GENERATOR = "kk:omni-voice-gen"
+MAX_VERIFY_RETRIES = 2  # verify attempts 0..2 (voice-gen parity)
+
+
+def _log(msg: str) -> None:
+    print(f"omni-voice-gen: {msg}", file=sys.stderr)
+
+
+def _delete(*paths: str) -> None:
+    for path in paths:
+        Path(path).unlink(missing_ok=True)
+
+
+def _first(*values: Any) -> Any:
+    """JS `??` chain: the first value that is not None."""
+    return next((value for value in values if value is not None), None)
+
+
+def _camel(name: str) -> str:
+    head, *rest = name.split("_")
+    return head + "".join(part.capitalize() for part in rest)
+
+
+def _plain(value: Any, camel: bool = False) -> Any:
+    """Dataclass tree -> YAML/JSON-safe tree with None dropped (JS undefined parity).
+
+    `camel` renames dataclass field names only (QC report keys), never user dict keys.
+    """
+    if is_dataclass(value):
+        return {
+            (_camel(f.name) if camel else f.name): _plain(v, camel)
+            for f in fields(value)
+            if (v := getattr(value, f.name)) is not None
+        }
+    if isinstance(value, dict):
+        return {key: _plain(v, camel) for key, v in value.items() if v is not None}
+    if isinstance(value, (list, tuple)):
+        return [_plain(v, camel) for v in value]
+    return value
+
+
+def resolve_profile_target(
+    segment: VoiceSegment, speaker: Any, script: VoiceScript, env_default: str | None, docs: list[Doc]
+) -> str:
+    """D4 resolution order (frozen); none set -> error listing every knob."""
+    doc_profile = (docs[0].metadata or {}).get("voiceProfile")
+    target = _first(
+        segment.profile_id,
+        segment.profile,
+        getattr(speaker, "profile_id", None),
+        getattr(speaker, "profile", None),
+        script.default_profile_id,
+        script.default_profile,
+        env_default,
+        doc_profile if isinstance(doc_profile, str) else None,
+    )
+    if not target:
+        raise ValueError(
+            "No voice profile specified for segment (set profile, profile_id, speaker profile, default_profile, "
+            "default_profile_id, VOICEBOX_DEFAULT_PROFILE, or doc metadata.voiceProfile)"
+        )
+    return str(target)
+
+
+def _max_run_ms() -> int:
+    raw = os.environ.get("VOICE_GEN_MAX_RUN_MS")
+    try:
+        return int(raw) if raw else 0
+    except ValueError as exc:
+        raise ValueError(f"VOICE_GEN_MAX_RUN_MS must be an integer millisecond budget, got {raw!r}") from exc
+
+
+def _generate(backend: Backend, spec: SegmentSpec) -> tuple[bytes, float]:
+    try:
+        return backend.generate(spec)
+    except Exception as exc:  # noqa: BLE001 — one inline retry for transient failures (voice-gen network-attempt parity); a second failure propagates
+        _log(f"segment render failed ({exc}); retrying once")
+        return backend.generate(spec)
+
+
+def _transcribe(backend: Backend, wav: bytes, language: str) -> str | None:
+    try:
+        return backend.transcribe(wav, language)
+    except Exception:  # noqa: BLE001 — ASR unavailable: keep audio, the QC audit is the backstop (voice-gen parity)
+        return None
+
+
+def _render_verified(backend: Backend, spec: SegmentSpec) -> tuple[bytes, float, int, str | None, bool]:
+    """Spec §5 verify-retry -> (wav, duration, verify_retries, transcription, loudness_dip)."""
+    for attempt in range(MAX_VERIFY_RETRIES + 1):
+        final = attempt == MAX_VERIFY_RETRIES  # the final attempt is always accepted
+        if attempt:
+            _log(f"regenerating segment (verify retry {attempt}/{MAX_VERIFY_RETRIES}, resampled)")
+        # Explicit seed pins attempt 0 only; retries resample (diffusion decoding is stochastic).
+        wav, duration = _generate(backend, spec if attempt == 0 else {**spec, "seed": None})
+        transcription = _transcribe(backend, wav, spec["language"])
+        if transcription is not None and not final:
+            fidelity = transcription_fidelity(spec["text"], transcription)
+            if fidelity < TRANSCRIPTION_FIDELITY_FLOOR:
+                _log(
+                    f"transcription fidelity {fidelity:.2f} below {TRANSCRIPTION_FIDELITY_FLOOR} "
+                    f'(looped/garbage audio): "{transcription[:80]}..."'
+                )
+                continue
+        dip, dip_at = detect_loudness_dip(wav)
+        if dip and not final:
+            _log(f"loudness dip detected at {dip_at}s — regenerating segment")
+            continue
+        return wav, duration, attempt, transcription, dip
+    raise AssertionError("unreachable: the final verify attempt always returns")  # pragma: no cover
+
+
+def _render(
+    docs: list[Doc], audio_path: str, mp3_path: str, backend: Backend, transcoder: Callable[[str, str], None]
+) -> Content:
+    env_default = os.environ.get("VOICEBOX_DEFAULT_PROFILE")
+    script = merge_voice_scripts([parse_doc_to_voicescript(doc, env_default) for doc in docs], docs, env_default)
+    sink = WarnSink()
+    validate_voice_script(script, sink)
+    if warning := sink.emit_once():
+        print(warning, file=sys.stderr)
+    # Env + registry failures surface before the (slow) model load.
+    max_run_ms = _max_run_ms()
+    registry = load_registry()
+
+    backend.load()
+    started = monotonic()
+    total = len(script.segments)
+    _log(f"{total} segments queued for render")
+
+    wavs: list[bytes] = []
+    gaps: list[int] = []
+    segments_meta: list[dict[str, Any]] = []
+    audit_meta: list[dict[str, Any]] = []
+    total_duration = 0.0
+    for index, segment in enumerate(script.segments):
+        if max_run_ms > 0 and (monotonic() - started) * 1000 > max_run_ms:
+            raise RuntimeError(
+                f"render budget {max_run_ms}ms exceeded after {index}/{total} segments — "
+                "raise VOICE_GEN_MAX_RUN_MS if the render is legitimately long"
+            )
+        segment_started = monotonic()
+        speaker = (script.speakers or {}).get(segment.speaker) if segment.speaker else None
+        profile = resolve_profile_target(segment, speaker, script, env_default, docs)
+        emotion = _first(segment.emotion, getattr(speaker, "emotion", None), script.default_emotion)
+        spec: SegmentSpec = {
+            "text": segment.text,
+            "language": _first(segment.language, getattr(speaker, "language", None), script.language, "en"),
+            "profile": resolve_profile(profile, registry),
+            "instruct": resolve_instruct(_first(segment.instruct, getattr(speaker, "instruct", None)), emotion),
+            "seed": None if segment.seed is None else int(segment.seed),
+            "speed": None,
+        }
+        wav, duration, retries, transcription, dip = _render_verified(backend, spec)
+
+        gap_ms = segment.gap_ms or 0
+        wavs.append(wav)
+        gaps.append(gap_ms)
+        # D8.2: concat_wavs inserts gaps_ms[i] before segment i only for i > 0 — count exactly that silence.
+        total_duration += duration + (gap_ms / 1000 if index else 0)
+        segments_meta.append(
+            _plain(
+                {
+                    "generationId": uuid.uuid4().hex[:16],
+                    "profile": profile,
+                    "speaker": segment.speaker,
+                    "emotion": emotion,
+                    "duration": duration,
+                    "verifyRetries": retries,
+                    "transcription": transcription,
+                    "loudnessDip": dip,
+                }
+            )
+        )
+        audit_meta.append({"duration": duration, "transcription": transcription, "loudness_dip": dip})
+        retry_note = f" ({retries} verify {'retry' if retries == 1 else 'retries'})" if retries else ""
+        _log(f"segment {index + 1}/{total} done in {monotonic() - segment_started:.1f}s{retry_note}")
+
+    Path(audio_path).write_bytes(concat_wavs(wavs, gaps))
+    report = audit_voice_segments(script, wavs, audit_meta, backend)
+    report.total_duration = round(total_duration, 2)  # D8.2: same basis as metadata.duration
+    metadata: dict[str, Any] = {
+        "generator": GENERATOR,
+        "audioPath": audio_path,
+        "duration": total_duration,
+        "segments": segments_meta,
+        "qc": _plain(report, camel=True),
+    }
+    if os.environ.get("VOICE_GEN_FAIL_ON_QC") == "true" and not report.passed:
+        raise RuntimeError(
+            f"Voice Quality Control failed ({report.overall_score}/100):\n" + "\n".join(report.critical_issues)
+        )
+    if is_mp3_requested():
+        transcoder(audio_path, mp3_path)
+        metadata["mp3Path"] = mp3_path
+
+    return Content(
+        title=script.title or docs[0].title or "Generated voice",
+        body=yaml.safe_dump(_plain(script), sort_keys=False, allow_unicode=True),
+        format="audio",
+        references=[],
+        metadata=metadata,
+    )
+
+
+def run(
+    in_path: str,
+    out_path: str,
+    backend: Backend | None = None,
+    transcoder: Callable[[str, str], None] | None = None,
+) -> None:
+    """Doc[] JSON at in_path -> Content JSON at out_path + sibling <stem>.wav (and .mp3).
+
+    Delete-then-render: stale --out/WAV/MP3 are removed at start AND on any failure, and --out is
+    written once, after Content validation (voice-gen processGeneratorIO parity).
+    """
+    out_dir = os.path.dirname(os.path.abspath(out_path))
+    stem = Path(out_path).stem
+    audio_path = os.path.join(out_dir, f"{stem}.wav")
+    mp3_path = os.path.join(out_dir, f"{stem}.mp3")
+    _delete(out_path, audio_path, mp3_path)
+
+    try:
+        raw = Path(in_path).read_text(encoding="utf-8")
+    except OSError as exc:
+        raise ValueError(f"cannot read input {in_path}: {exc.strerror or exc}") from exc
+    try:
+        docs = parse_doc_list(raw)
+    except ValueError as exc:
+        raise ValueError(f"Invalid DocList input: {exc}") from exc
+
+    os.makedirs(out_dir, exist_ok=True)
+    if not docs:
+        Path(out_path).write_text(content_to_json(NOTICE_CONTENT), encoding="utf-8")
+        return
+
+    try:
+        content = _render(
+            docs, audio_path, mp3_path, backend or OmnivoiceBackend(), transcoder or transcode_wav_to_mp3
+        )
+        Path(out_path).write_text(content_to_json(content), encoding="utf-8")
+    except BaseException:
+        _delete(out_path, audio_path, mp3_path)
+        raise

package/plugins/generations/omni-voice-gen/src/omni_voice_gen/profiles.py

@@ -0,0 +1,100 @@
+"""Profile registry (D4): profile name -> clone / saved-prompt / instruct entry.
+
+Registry source: OMNIVOICE_PROFILE_REGISTRY env, else <plugin>/profiles.json. Resolution is
+case-insensitive by name; unknown names fail loud naming the profile and the registry path.
+The D4 fallback chain (segment -> speaker -> script default -> VOICEBOX_DEFAULT_PROFILE -> doc
+metadata voiceProfile) and plain-text clone-path handling belong to the pipeline (0125); this
+module owns only load + resolve.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal
+
+REGISTRY_ENV_VAR = "OMNIVOICE_PROFILE_REGISTRY"
+DEFAULT_REGISTRY_PATH = Path(__file__).resolve().parents[2] / "profiles.json"
+
+ProfileKind = Literal["clone", "prompt", "instruct"]
+
+
+@dataclass
+class ProfileEntry:
+    """One registry entry; exactly one field family is set (enforced at load time)."""
+
+    kind: ProfileKind
+    ref_audio: str | None = None
+    ref_text: str | None = None
+    prompt: str | None = None
+    instruct: str | None = None
+
+
+class ProfileRegistry(dict[str, ProfileEntry]):
+    """Registry map carrying its source path so resolution errors can name it (task R1)."""
+
+    def __init__(self, entries: dict[str, ProfileEntry], path: Path) -> None:
+        super().__init__(entries)
+        self.path = path
+
+
+def _parse_entry(name: str, spec: object) -> ProfileEntry:
+    def invalid(reason: str) -> ValueError:
+        return ValueError(f'Profile "{name}" is invalid: {reason}')
+
+    if not isinstance(spec, dict):
+        raise invalid("entry must be a JSON object")
+    ref_audio, ref_text = spec.get("ref_audio"), spec.get("ref_text")
+    prompt, instruct = spec.get("prompt"), spec.get("instruct")
+    families = sum([ref_audio is not None or ref_text is not None, prompt is not None, instruct is not None])
+    if families != 1:
+        raise invalid("exactly one of {ref_audio + ref_text, prompt, instruct} must be set")
+    for value in (ref_audio, ref_text, prompt, instruct):
+        if value is not None and not isinstance(value, str):
+            raise invalid("entry values must be strings")
+    if ref_audio is not None or ref_text is not None:
+        if ref_audio is None or ref_text is None:
+            raise invalid("clone profiles require both ref_audio and ref_text")
+        return ProfileEntry(kind="clone", ref_audio=ref_audio, ref_text=ref_text)
+    if prompt is not None:
+        return ProfileEntry(kind="prompt", prompt=prompt)
+    return ProfileEntry(kind="instruct", instruct=instruct)
+
+
+def load_registry(path: Path | None = None) -> ProfileRegistry:
+    """Load the registry JSON; fail loud on unreadable, malformed, or ambiguous content."""
+    if path is None:
+        env = os.environ.get(REGISTRY_ENV_VAR)
+        path = Path(env) if env else DEFAULT_REGISTRY_PATH
+    try:
+        raw = path.read_text(encoding="utf-8")
+    except OSError as exc:
+        raise ValueError(f"cannot read profile registry at {path}: {exc.strerror or exc}") from exc
+    try:
+        data = json.loads(raw)
+    except json.JSONDecodeError as exc:
+        raise ValueError(f"Malformed profile registry JSON at {path}: {exc}") from exc
+    if not isinstance(data, dict):
+        # ValueError, not TypeError: every registry failure must funnel into the single
+        # fail-loud exit path (same contract as contract.py parse errors).
+        raise ValueError(  # noqa: TRY004
+            f"profile registry at {path} must be a JSON object mapping profile names to entries"
+        )
+    entries = {name: _parse_entry(name, spec) for name, spec in data.items()}
+    lowered = [key.lower() for key in entries]
+    if len(set(lowered)) != len(lowered):
+        dupes = sorted({key for key in entries if lowered.count(key.lower()) > 1})
+        raise ValueError(f"profile registry at {path} has case-insensitive duplicate names: {', '.join(dupes)}")
+    return ProfileRegistry(entries, path)
+
+
+def resolve_profile(name: str, registry: dict[str, ProfileEntry]) -> ProfileEntry:
+    """Resolve by case-insensitive name; unknown -> ValueError naming profile + registry path."""
+    lowered = name.lower()
+    for key, entry in registry.items():
+        if key.lower() == lowered:
+            return entry
+    path = getattr(registry, "path", "<in-memory registry>")
+    raise ValueError(f'Unknown voice profile "{name}" in registry at {path}')

package/plugins/generations/omni-voice-gen/src/omni_voice_gen/qc.py

@@ -0,0 +1,234 @@
+"""QC audit — Python port of voice-gen qc.ts (repetition / fidelity / duration-range /
+aggregate). Loudness-dip detection lives in audio.py (spec §2 layout); thresholds identical (D7).
+
+Delta from the TS source: transcription is supplied by a Backend (sync
+`transcribe(wav, language) -> str`, may raise) instead of the async VoiceboxClient.
+"""
+
+from __future__ import annotations
+
+import math
+import re
+from dataclasses import dataclass, field
+from typing import Any, Protocol
+
+from .audio import detect_loudness_dip
+from .voicescript import VoiceScript
+
+# Thresholds — identical to voice-gen qc.ts (D7).
+TRANSCRIPTION_FIDELITY_FLOOR = 0.15
+
+MAX_DURATION_RATIO = 3.0
+MAX_ABS_DIFF_SEC = 15.0
+MAX_RATE_ZH = 15.0
+MAX_RATE_EN = 30.0
+MAX_RATE_OTHER = 25.0
+
+MAX_DURATION_ZH = 15.0
+MAX_DURATION_EN = 30.0
+MAX_DURATION_OTHER = 20.0
+
+MAX_DURATION_ZH_DIVISOR = 15.0
+MAX_DURATION_EN_DIVISOR = 20.0
+MAX_DURATION_OTHER_DIVISOR = 15.0
+
+RE_CHAR_RUN = re.compile(r"(.)\1{2,}", re.DOTALL)
+RE_WORD_RUN = re.compile(r"(.{2,3}?)\1{2,}", re.DOTALL)
+RE_PHRASE_RUN = re.compile(r"(.{4,30}?)\1{1,}", re.DOTALL)
+
+
+class Transcriber(Protocol):
+    # Concrete `raise` body, not `...`: coverage.py excludes it from measurement, keeping
+    # the protocol out of the D2 per-file function gate (same pattern as backend.py).
+    def transcribe(self, wav: bytes, language: str) -> str:
+        raise NotImplementedError
+
+
+@dataclass
+class SegmentQualityAudit:
+    segment_index: int
+    text: str
+    duration: float
+    expected_duration_range: tuple[float, float]
+    speech_rate_chars_per_sec: float
+    transcription: str | None
+    repetition_detected: bool
+    duration_anomaly: bool
+    fidelity_score: float | None
+    issues: list[str] = field(default_factory=list)
+
+
+@dataclass
+class VoiceQualityReport:
+    passed: bool
+    total_duration: float
+    overall_score: int
+    segment_audits: list[SegmentQualityAudit]
+    critical_issues: list[str]
+
+
+def detect_repetitions(text: str) -> bool:
+    """Repeated chars/short words/long phrases — port of voice-gen qc.ts regex battery."""
+    return bool(RE_CHAR_RUN.search(text) or RE_WORD_RUN.search(text) or RE_PHRASE_RUN.search(text))
+
+
+def _ngrams(text: str, n: int) -> set[str]:
+    grams: set[str] = set()
+    for i in range(len(text) - n + 1):
+        grams.add(text[i : i + n])
+    return grams
+
+
+def transcription_fidelity(source: str, transcription: str) -> float:
+    """Character 4-gram Jaccard (short texts fall back to 2-grams)."""
+    if not source or not transcription:
+        return 0.0
+    if source == transcription:
+        return 1.0
+    n = 4 if len(source) >= 20 else 2
+    source_grams = _ngrams(source, n)
+    trans_grams = _ngrams(transcription, n)
+    intersection = 0
+    for gram in source_grams:
+        if gram in trans_grams:
+            intersection += 1
+    union = len(source_grams) + len(trans_grams) - intersection
+    return intersection / union if union else 0.0
+
+
+def _split_words(clean: str) -> list[str]:
+    return [w for w in re.split(r"[\s\[\],.!?;:，。！？；：]+", clean) if len(w) > 0]
+
+
+def compute_expected_duration_range(text: str, language: str = "zh") -> tuple[float, float]:
+    """Heuristic duration window (s) for a segment — port of voice-gen qc.ts."""
+    clean = text.strip()
+    if not clean:
+        return 0.0, 0.0
+    is_zh = language.startswith("zh")
+    is_en = language.startswith("en")
+    if is_zh:
+        cjk_count = sum(1 for ch in clean if ord(ch) > 255)
+        word_count = len(_split_words(clean))
+        effective_chars = cjk_count + word_count
+        min_sec = effective_chars * 0.15
+        max_sec = min_sec * 3
+    else:
+        word_count = len(_split_words(clean))
+        char_count = len(re.sub(r"\s+", "", clean))
+        if is_en:
+            effective_chars = word_count * 4 + math.floor(char_count / 4)
+            min_sec = effective_chars * 0.06
+            max_sec = min_sec * 3
+        else:
+            effective_chars = max(char_count, word_count * 2)
+            min_sec = effective_chars * 0.08
+            max_sec = min_sec * 3
+    return round(min_sec, 2), round(max_sec, 2)
+
+
+def audit_voice_segments(
+    script: VoiceScript,
+    segment_wavs: list[bytes],
+    segment_metadata: list[dict[str, Any]],
+    backend: Transcriber | None = None,
+) -> VoiceQualityReport:
+    """Aggregate QC over rendered segments. `backend.transcribe` may raise; failures only
+    add an issue entry, never crash the audit (voice-gen parity)."""
+    audits: list[SegmentQualityAudit] = []
+    total_duration = 0.0
+    critical_issues: list[str] = []
+
+    for index, segment in enumerate(script.segments):
+        wav = segment_wavs[index]
+        meta = segment_metadata[index]
+        text = segment.text if isinstance(segment.text, str) else str(segment.text or "")
+        language = segment.language or script.language or "zh"
+        duration = float(meta.get("duration") or 0.0)
+        total_duration += duration
+
+        min_sec, max_sec = compute_expected_duration_range(text, language)
+        speech_rate = round((len(text) / duration) if duration > 0 else 0.0, 2)
+
+        issues: list[str] = []
+
+        # Transcription + fidelity (best-effort)
+        transcription = meta.get("transcription")
+        fidelity: float | None = None
+        if transcription is None and backend is not None and language and wav and len(wav) > 0:
+            try:
+                transcription = backend.transcribe(wav, language)
+            except Exception as err:  # noqa: BLE001 — transcription is best-effort; any backend failure only adds an issue (voice-gen parity)
+                issues.append(f"transcription_failed: {err}")
+        if transcription is not None and transcription != "":
+            fidelity = transcription_fidelity(text, transcription)
+            if fidelity < TRANSCRIPTION_FIDELITY_FLOOR:
+                issues.append(f"transcription_fidelity_low:{fidelity:.2f}")
+
+        # Repetition
+        repetition = detect_repetitions(text) or (
+            detect_repetitions(transcription) if transcription is not None else False
+        )
+        if repetition:
+            issues.append("repetition_detected")
+
+        # Loudness dip: reuse the verify-phase result when present; only run the windowed
+        # scan when the verify phase did not (meta.loudness_dip absent).
+        dip, dip_at = (
+            (bool(meta["loudness_dip"]), None) if "loudness_dip" in meta else detect_loudness_dip(wav)
+        )
+        if dip:
+            issues.append(f"loudness_dip:{f'{dip_at}s' if dip_at is not None else 'unknown'}")
+
+        # Duration anomaly
+        ratio_anomaly = duration > MAX_DURATION_RATIO * max_sec if max_sec > 0 else False
+        abs_anomaly = duration > max_sec + MAX_ABS_DIFF_SEC if max_sec > 0 else False
+        max_rate = MAX_RATE_ZH if language.startswith("zh") else MAX_RATE_EN if language.startswith("en") else MAX_RATE_OTHER
+        rate_anomaly = duration > 0 and (len(text) / duration) > max_rate
+        max_possible = (
+            MAX_DURATION_ZH
+            if language.startswith("zh")
+            else MAX_DURATION_EN
+            if language.startswith("en")
+            else MAX_DURATION_OTHER
+        ) + len(text) / (
+            MAX_DURATION_ZH_DIVISOR
+            if language.startswith("zh")
+            else MAX_DURATION_EN_DIVISOR
+            if language.startswith("en")
+            else MAX_DURATION_OTHER_DIVISOR
+        )
+        abs_ceiling_anomaly = duration > max_possible
+        duration_anomaly = ratio_anomaly or abs_anomaly or rate_anomaly or abs_ceiling_anomaly
+        if duration_anomaly:
+            issues.append(
+                f"duration_anomaly: expected {min_sec:.2f}s-{max_sec:.2f}s, got {duration:.2f}s"
+            )
+
+        audits.append(
+            SegmentQualityAudit(
+                segment_index=index,
+                text=text,
+                duration=duration,
+                expected_duration_range=(min_sec, max_sec),
+                speech_rate_chars_per_sec=speech_rate,
+                transcription=transcription,
+                repetition_detected=repetition,
+                duration_anomaly=duration_anomaly,
+                fidelity_score=fidelity,
+                issues=issues,
+            )
+        )
+        critical_issues.extend(issues)
+
+    passed_count = sum(1 for audit in audits if not audit.issues)
+    overall_score = int((passed_count / len(audits)) * 100 + 0.5) if audits else 100
+    all_passed = len(critical_issues) == 0
+
+    return VoiceQualityReport(
+        passed=all_passed,
+        total_duration=round(total_duration, 2),
+        overall_score=overall_score,
+        segment_audits=audits,
+        critical_issues=critical_issues,
+    )