primocode 10.16.0 → 10.17.0

package/editor/helpers/noise_check.py

@@ -0,0 +1,134 @@
+"""How much background noise each source has, and whether to offer the noise removal (audio.denoise).
+
+For every video: the noise floor in its pauses (RMS of edit/regions/<stem>.json silences trimmed 60 ms,
+measured now when the regions file is missing or belongs to another file), the speech level (RMS in the
+speech regions) and their difference. With almost no pause (under 0.1 s) the noise is estimated on the
+quietest 50 ms windows (+3 dB, they catch the dips of the noise). The channels are folded like render_cut.
+
+  difference >= 30 dB  "limpo, não precisa"
+  20 to 30 dB          "ruído leve"   (offer Remover ruído de fundo: Leve)
+  under 20 dB          "ruído forte"  (offer Forte)
+
+Prints one PT-BR line per video plus a recommendation, and writes edit/verify/noise_check.json.
+
+It also measures, per video, saturation and room echo of the voice (helpers/voz_check.py): one "Voz" line per
+video and the key "voz" in the JSON. Saturated voice does not come back whole; echo is treated lightly and judged
+at the same perceived loudness (references/revisao.md, Voz). `--sem-voz` skips it.
+
+Usage:
+    uv run python helpers/noise_check.py <videos_dir | video ...> [--edit-dir DIR] [--json]
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from common import now_iso, require_binary, save_json  # noqa: E402
+import denoise  # noqa: E402
+import voz_check  # noqa: E402
+
+VIDEO_EXT = {".mov", ".mp4", ".m4v", ".mkv", ".webm"}
+ORDER = {"limpo": 0, "leve": 1, "forte": 2}
+
+
+def utf8_console() -> None:
+    for stream in (sys.stdout, sys.stderr):
+        try:
+            stream.reconfigure(encoding="utf-8", errors="replace")  # type: ignore[attr-defined]
+        except (AttributeError, ValueError, OSError):
+            pass
+
+
+def collect(paths: list[Path]) -> list[Path]:
+    out: list[Path] = []
+    for p in paths:
+        if p.is_dir():
+            out += sorted(f for f in p.iterdir() if f.is_file() and f.suffix.lower() in VIDEO_EXT
+                          and not f.name.startswith("."))
+        elif p.is_file():
+            out.append(p)
+        else:
+            raise FileNotFoundError(f"não encontrado: {p}")
+    return list(dict.fromkeys(out))
+
+
+def line_for(r: dict) -> str:
+    name = r.get("stem", "?")
+    if r.get("error"):
+        return f"  {name}: {r['error']}"
+    extra = " (quase sem pausa: fundo estimado nas partes mais quietas)" if r.get("noise_from") != "pausas" else ""
+    return (f"  {name} · fundo {r['noise_db']:.1f} dB · voz {r['speech_db']:.1f} dB · diferença {r['snr_db']:.0f} dB · "
+            f"{r['advice']}{extra}")
+
+
+def recommendation(results: list[dict]) -> dict:
+    measured = [r for r in results if r.get("level")]
+    if not measured:
+        return {"suggest": None, "text": "Não deu para medir o ruído (sem áudio ou sem fala)."}
+    worst = max(measured, key=lambda r: (ORDER[r["level"]], -r["snr_db"]))
+    if worst["level"] == "limpo":
+        return {"suggest": "off", "worst": worst["stem"],
+                "text": "Recomendação: nenhum vídeo precisa de limpeza de ruído (deixe Desligado)."}
+    label = "Leve" if worst["level"] == "leve" else "Forte"
+    return {"suggest": worst["suggest"], "worst": worst["stem"],
+            "text": (f"Recomendação: ofereça Remover ruído de fundo {label} (o pior é {worst['stem']}, "
+                     f"diferença de {worst['snr_db']:.0f} dB entre voz e fundo).")}
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description="Mede o ruído de fundo de cada vídeo e diz se vale limpar a voz.")
+    ap.add_argument("paths", nargs="+", type=Path, help="pasta dos vídeos ou arquivos de vídeo")
+    ap.add_argument("--edit-dir", type=Path, default=None,
+                    help="pasta edit (padrão: <pasta dos vídeos>/edit); usa regions/<nome>.json de lá")
+    ap.add_argument("--json", action="store_true", help="imprime o JSON em vez das linhas")
+    ap.add_argument("--sem-voz", action="store_true", help="não mede saturação nem eco da voz")
+    args = ap.parse_args()
+    utf8_console()
+    require_binary("ffmpeg")
+    require_binary("ffprobe")
+    paths = [p.expanduser().absolute() for p in args.paths]
+    try:
+        videos = collect(paths)
+    except FileNotFoundError as e:
+        print(f"erro: {e}", file=sys.stderr)
+        return 2
+    if not videos:
+        print("erro: nenhum vídeo encontrado (.mov, .mp4, .m4v, .mkv, .webm)", file=sys.stderr)
+        return 2
+    first = paths[0] if paths[0].is_dir() else videos[0].parent
+    edit_dir = (args.edit_dir.expanduser().absolute() if args.edit_dir else first / "edit")
+    results = [denoise.measure_source(v, edit_dir if edit_dir.is_dir() else None) for v in videos]
+    if not args.sem_voz:
+        for v, r in zip(videos, results):
+            try:
+                r["voz"] = voz_check.measure_voice(v)
+            except Exception as exc:  # noqa: BLE001
+                r["voz"] = {"error": f"não consegui medir a voz ({exc.__class__.__name__})"}
+    rec = recommendation(results)
+    doc = {"created_at": now_iso(), "edit_dir": str(edit_dir), "videos": results, "recommendation": rec,
+           "thresholds_db": {"limpo": 30, "leve": 20}}
+    if edit_dir.is_dir():
+        try:
+            save_json(edit_dir / "verify" / "noise_check.json", doc)
+        except OSError:
+            pass
+    if args.json:
+        print(json.dumps(doc, ensure_ascii=False, indent=2))
+        return 0
+    print("Ruído de fundo (fundo = volume nas pausas, voz = volume da fala):")
+    for r in results:
+        print(line_for(r))
+    print(rec["text"])
+    if not args.sem_voz:
+        print("Voz (saturação e eco de sala, medidos na onda; confirme ouvindo os tempos citados):")
+        for r in results:
+            print(voz_check.line_for(r.get("stem", "?"), r.get("voz") or {"error": "sem medida"}))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/editor/helpers/pack_transcripts.py

@@ -0,0 +1,223 @@
+# Adapted from browser-use/video-use (MIT, (c) 2026 Browser Use). See THIRD_PARTY_NOTICES.md.
+"""Pack the word-level transcripts of <edit>/transcripts/ into one phrase-level reading view.
+
+Words are grouped into phrases, breaking on any gap >= --silence seconds between words.
+Each phrase gets a [start-end] prefix in source seconds. This is the file the agent reads
+to pick cuts: a fraction of the tokens of the raw JSON, with word-boundary precision.
+
+Only source transcripts are packed; cut.json (the transcript of the cut) is skipped. With `--corte`,
+or when cut.json is the only transcript in the folder, the speech of the cut is packed instead: short
+phrases (a pause of 0.3 s, a sentence end or 12 words) with the time each one starts in cut.mp4, to read
+against the `quote` of every range.
+
+Output: <edit>/takes_packed.md (the cut: <edit>/fala_do_corte.md)
+
+Usage:
+    uv run --directory '<SKILL>' python helpers/pack_transcripts.py --edit-dir <edit_dir> [--silence 0.5] [-o FILE]
+    uv run --directory '<SKILL>' python helpers/pack_transcripts.py --edit-dir <edit_dir> --corte
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+SKIP_STEMS = {"cut"}
+SKILL_ROOT = Path(__file__).resolve().parent.parent
+RODE_ANTES = (f"Rode antes: uv run --directory '{SKILL_ROOT}' python helpers/transcribe_batch.py '<pasta dos vídeos>' "
+              "--edit-dir '<EDIT>'")
+CUT_STEM = "cut"
+CUT_SILENCE_S = 0.3        # the cut has joints of ~0.12 s: a shorter pause breaks the phrase
+CUT_MAX_WORDS = 12
+
+
+def format_time(seconds: float) -> str:
+    """Seconds as zero-padded "NNN.NN" (fixed width for alignment)."""
+    return f"{max(0.0, seconds):06.2f}"
+
+
+def format_duration(seconds: float) -> str:
+    """Seconds with one decimal, as in the contract ("70.8s")."""
+    return f"{seconds:.1f}s"
+
+
+def _plural(n: int, one: str, many: str) -> str:
+    return f"{n} {one if n == 1 else many}"
+
+
+_SENTENCE_END = (".", "!", "?", "…")
+
+
+def group_into_phrases(words: list[dict], silence: float = 0.5, segment_starts: set[float] | None = None,
+                       sentence_breaks: bool = True) -> list[dict]:
+    """Break the word list into phrases. Returns [{start, end, text, words}].
+
+    Breaks on a gap >= silence between words. Fluent ad speech rarely pauses that long,
+    so it also breaks after a sentence end (. ! ? …) and where Whisper started a new
+    segment (segment_starts, times rounded to 3 decimals).
+    """
+    phrases: list[dict] = []
+    current: list[dict] = []
+    prev_end: float | None = None
+    seg_starts = segment_starts or set()
+
+    def flush() -> None:
+        nonlocal current
+        parts = [(w.get("text") or "").strip() for w in current]
+        parts = [p for p in parts if p]
+        if parts:
+            phrases.append({
+                "start": float(current[0]["start"]),
+                "end": float(max(w.get("end", w["start"]) for w in current)),
+                "text": " ".join(parts),
+                "words": current,
+            })
+        current = []
+
+    for w in words:
+        start = w.get("start")
+        if start is None:
+            continue
+        if current and prev_end is not None:
+            last_text = (current[-1].get("text") or "").strip()
+            if (start - prev_end >= silence
+                    or (sentence_breaks and last_text.endswith(_SENTENCE_END))
+                    or round(float(start), 3) in seg_starts):
+                flush()
+        current.append(w)
+        prev_end = max(prev_end or 0.0, w.get("end", start))
+    flush()
+    return phrases
+
+
+def split_long(phrases: list[dict], max_words: int = CUT_MAX_WORDS) -> list[dict]:
+    """Phrases of at most max_words, broken after a comma when one is near the limit (a line you read at once)."""
+    out: list[dict] = []
+    for p in phrases:
+        words = [w for w in p["words"] if (w.get("text") or "").strip()]
+        while len(words) > max_words:
+            cut = max_words
+            for k in range(max_words, max(1, max_words // 2) - 1, -1):
+                if (words[k - 1].get("text") or "").strip().endswith((",", ";", ":")):
+                    cut = k
+                    break
+            out.append(_phrase(words[:cut]))
+            words = words[cut:]
+        if words:
+            out.append(_phrase(words))
+    return out
+
+
+def _phrase(words: list[dict]) -> dict:
+    return {"start": float(words[0]["start"]), "end": float(max(w.get("end", w["start"]) for w in words)),
+            "text": " ".join((w.get("text") or "").strip() for w in words), "words": words}
+
+
+def cut_phrases(data: dict, silence: float = CUT_SILENCE_S, max_words: int = CUT_MAX_WORDS) -> list[dict]:
+    """Short phrases of the transcript of the cut (used by --corte and by conferir_corte.py)."""
+    return split_long(phrases_for_transcript(data, silence), max_words)
+
+
+def render_cut_markdown(data: dict, phrases: list[dict]) -> str:
+    n_words = len(data.get("words", []))
+    lines = [f"# Fala do corte · {Path(str(data.get('source') or 'cut.mp4')).name}, "
+             f"{format_duration(float(data.get('duration') or 0))}, {_plural(n_words, 'palavra', 'palavras')}",
+             "Tempo = começo da frase no corte (a transcrição adianta até 0,3 s; animação se mede na onda).", ""]
+    if not phrases:
+        lines.append("  _sem fala detectada_")
+    for p in phrases:
+        lines.append(f"  [{format_time(p['start'])}] {p['text']}")
+    return "\n".join(lines) + "\n"
+
+
+def source_transcripts(transcripts_dir: Path) -> list[Path]:
+    return sorted((p for p in transcripts_dir.glob("*.json")
+                   if p.stem not in SKIP_STEMS and not p.name.startswith(".")),
+                  key=lambda p: p.stem.lower())
+
+
+def phrases_for_transcript(data: dict, silence: float = 0.5) -> list[dict]:
+    """Phrases of a Contract 1 transcript dict (used by pack and voice_levels)."""
+    words = sorted(data.get("words", []), key=lambda w: w.get("start", 0.0))
+    seg_starts = {round(float(s["start"]), 3) for s in data.get("segments", []) if "start" in s}
+    return group_into_phrases(words, silence, seg_starts)
+
+
+def pack_one_file(json_path: Path, silence: float) -> tuple[str, float, list[dict]]:
+    """(stem, source duration, phrases) for one transcript file."""
+    data = json.loads(json_path.read_text(encoding="utf-8"))
+    phrases = phrases_for_transcript(data, silence)
+    duration = float(data.get("duration") or (phrases[-1]["end"] if phrases else 0.0))
+    return data.get("stem") or json_path.stem, duration, phrases
+
+
+def render_markdown(entries: list[tuple[str, float, list[dict]]]) -> str:
+    total = sum(e[1] for e in entries)
+    lines = [f"# Tomadas · {_plural(len(entries), 'fonte', 'fontes')}, {format_duration(total)} no total", ""]
+    for name, duration, phrases in entries:
+        lines.append(f"## {name}  ({format_duration(duration)}, {_plural(len(phrases), 'frase', 'frases')})")
+        if not phrases:
+            lines.append("  _sem fala detectada_")
+        for p in phrases:
+            lines.append(f"  [{format_time(p['start'])}-{format_time(p['end'])}] {p['text']}")
+        lines.append("")
+    return "\n".join(lines)
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description="Junta as transcrições em takes_packed.md, uma frase por linha.")
+    ap.add_argument("--edit-dir", type=Path, required=True, help="pasta edit com transcripts/")
+    ap.add_argument("--silence", type=float, default=0.5,
+                    help="quebra a frase em pausas maiores ou iguais a isso, em segundos (padrão 0.5)")
+    ap.add_argument("-o", "--output", type=Path, default=None, help="arquivo de saída (padrão: <edit-dir>/takes_packed.md)")
+    ap.add_argument("--corte", action="store_true",
+                    help="junta a fala do corte (transcripts/cut.json) em fala_do_corte.md, com o tempo de cada frase")
+    args = ap.parse_args()
+
+    edit_dir = args.edit_dir.absolute()
+    transcripts_dir = edit_dir / "transcripts"
+    if not transcripts_dir.is_dir():
+        sys.exit(f"não achei a pasta de transcrições: {transcripts_dir}\n{RODE_ANTES}")
+    if args.silence <= 0:
+        sys.exit("--silence precisa ser maior que zero")
+    files = source_transcripts(transcripts_dir)
+    cut_json = transcripts_dir / f"{CUT_STEM}.json"
+    if args.corte or (not files and cut_json.is_file()):
+        if not cut_json.is_file():
+            sys.exit(f"não achei {cut_json}\nRode antes: uv run --directory '{SKILL_ROOT}' python "
+                     f"helpers/conferir_corte.py '{edit_dir}'")
+        if not args.corte:
+            print("só tem a transcrição do corte nesta pasta: juntando a fala do corte (as fontes precisam do "
+                  "transcribe_batch.py na pasta dos vídeos)", file=sys.stderr)
+        data = json.loads(cut_json.read_text(encoding="utf-8"))
+        silence = args.silence if args.silence != 0.5 else CUT_SILENCE_S
+        phrases = cut_phrases(data, silence)
+        out_path = (args.output or edit_dir / "fala_do_corte.md").absolute()
+        out_path.write_text(render_cut_markdown(data, phrases), encoding="utf-8")
+        print(f"fala do corte: {_plural(len(phrases), 'frase', 'frases')}, "
+              f"{format_duration(float(data.get('duration') or 0))} · {out_path}")
+        return
+    if not files:
+        sys.exit(f"nenhuma transcrição em {transcripts_dir}\n{RODE_ANTES}")
+
+    entries = []
+    for path in files:
+        try:
+            entries.append(pack_one_file(path, args.silence))
+        except (json.JSONDecodeError, OSError, KeyError, TypeError) as exc:
+            print(f"aviso: ignorei {path.name} (arquivo inválido: {exc})", file=sys.stderr)
+    if not entries:
+        sys.exit("nenhuma transcrição válida para juntar")
+
+    out_path = (args.output or edit_dir / "takes_packed.md").absolute()
+    out_path.write_text(render_markdown(entries), encoding="utf-8")
+    n_phrases = sum(len(e[2]) for e in entries)
+    total = sum(e[1] for e in entries)
+    print(f"{_plural(len(entries), 'fonte', 'fontes')}, {_plural(n_phrases, 'frase', 'frases')}, "
+          f"{format_duration(total)} no total · {out_path} ({out_path.stat().st_size / 1024:.1f} KB)")
+
+
+if __name__ == "__main__":
+    main()

package/editor/helpers/palavras_na_onda.py

@@ -0,0 +1,176 @@
+"""When each word really starts, measured on the waveform (Whisper puts the start up to 0.3 s early).
+
+The transcription of the cut marks word starts early, most of all after a joint or a pause: "éééé" came 0.22 s
+early and "Eu" at 0.00 when the voice starts at 0.58 (exemplos, 29/09/2026). A caption can live with that; an
+animation, a sound or a cut that must land ON the word cannot. This helper takes the cut (or any video) and its
+transcript and, for every word, looks at the waveform around the Whisper start (0.10 s before to 0.40 s after,
+never into the previous word):
+
+  pausa   the voice comes back after a quiet run: the start is the first sustained sound after it (sharp,
+          ~0.01 s). The usual case after a joint of the cut or a breath.
+  vale    no pause (the words run together): the start is the rise after the deepest dip (10 dB or more) near
+          the Whisper start (about 0.03 s).
+  whisper nothing to measure (a dip too shallow): the Whisper time is kept.
+
+Same measure as corte_por_onda.py (mono RMS in 10 ms windows; pause threshold from the floor of the file).
+
+Output: a table of the words that moved 0.05 s or more (or the ones asked for with --palavra / --de --ate) and
+<edit>/palavras_onda.json: [{"i", "text", "whisper", "start", "end", "dif", "como"}], times in seconds of the video.
+
+Use: to fire an animation, a sound or a cut on a word, put the `start` of this file in the project as a time in
+seconds (`"em": 3.42` instead of `"em": "éééé"`); the word name uses the Whisper time. Rerun after every new cut.
+
+Usage:
+    uv run --directory '<SKILL>' python helpers/palavras_na_onda.py '<EDIT>' [--palavra éééé] [--de 2 --ate 6] [--todas]
+    uv run --directory '<SKILL>' python helpers/palavras_na_onda.py --video X.mp4 --transcricao X.json [...]
+"""
+
+from __future__ import annotations
+
+import argparse
+import re
+import sys
+import unicodedata
+from pathlib import Path
+
+import numpy as np
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import corte_por_onda as onda  # noqa: E402
+from common import fmt_time, load_json, save_json  # noqa: E402
+
+ANTES_S = 0.10          # Whisper can also be a little late
+DEPOIS_S = 0.40         # ... and is up to 0.3 s early
+QUIETO_MIN_S = 0.03     # a quiet run this long before the word is a pause
+SOM_MIN_S = 0.04        # sound this long after it is the word (not a click)
+VALE_DB = 10.0          # a dip this deep between two words marks the start of the second
+MOSTRAR_S = 0.05        # the table shows words that moved at least this much
+
+
+def _norm(texto: str) -> str:
+    t = unicodedata.normalize("NFKD", (texto or "").lower())
+    return re.sub(r"[^\w]+", "", "".join(c for c in t if not unicodedata.combining(c)))
+
+
+def medir(db: np.ndarray, th: float, whisper: float, depois_de: float, ate: float) -> tuple[float, str]:
+    """(start, como) of one word, searched between `depois_de` (the previous word has started) and `ate` (where the
+    next word starts: its onset must not be taken for this one)."""
+    hop = onda.HOP_S
+    lo = max(depois_de, whisper - ANTES_S, 0.0)
+    hi = max(lo + hop, ate)
+    i0, i1 = int(round(lo / hop)), min(len(db), int(round(hi / hop)))
+    if i1 - i0 < 2:
+        return round(whisper, 3), "whisper"
+    seg = db[i0:i1]
+    quiet_need, som_need = int(round(QUIETO_MIN_S / hop)), int(round(SOM_MIN_S / hop))
+    # 1. pause -> sound: first sustained sound after a quiet run; the one nearest after the Whisper start wins
+    cands = []
+    run = 0
+    for k in range(len(seg)):
+        if seg[k] < th:
+            run += 1
+            continue
+        if run >= quiet_need and k + som_need <= len(seg) and bool((seg[k:k + som_need] >= th).all()):
+            cands.append(k)
+        run = 0
+    if cands:
+        w = int(round(whisper / hop)) - i0
+        depois = [k for k in cands if k >= w - int(round(0.05 / hop))]
+        k = depois[0] if depois else cands[-1]
+        return round((i0 + k) * hop, 3), "pausa"
+    # 2. no pause: the rise after the deepest dip near the Whisper start
+    j0 = max(0, int(round((whisper - 0.08) / hop)) - i0)
+    j1 = min(len(seg), int(round((whisper + 0.20) / hop)) - i0)
+    if j1 - j0 >= 3:
+        k = j0 + int(np.argmin(seg[j0:j1]))
+        fundo = float(seg[k])
+        adiante = seg[k:min(len(seg), k + int(round(0.15 / hop)))]
+        if len(adiante) and float(adiante.max()) - fundo >= VALE_DB:
+            meio = fundo + (float(adiante.max()) - fundo) / 2
+            sobe = int(np.argmax(adiante >= meio))
+            return round((i0 + k + sobe) * hop, 3), "vale"
+    return round(whisper, 3), "whisper"
+
+
+def medir_palavras(db: np.ndarray, th: float, words: list[dict]) -> list[dict]:
+    out = []
+    ws = sorted(words, key=lambda w: float(w["start"]))
+    for i, w in enumerate(ws):
+        s, e = float(w["start"]), float(w.get("end", w["start"]))
+        depois_de = out[-1]["start"] + 0.05 if out else 0.0
+        # up to 0.4 s after the Whisper start (more when Whisper stretched the word over the silence before it,
+        # as the first word of a cut), never into the next word
+        ate = max(s + DEPOIS_S, e - 0.02)
+        if i + 1 < len(ws):
+            ate = min(ate, float(ws[i + 1]["start"]))
+        ate = max(ate, s + 0.05)
+        start, como = medir(db, th, s, depois_de, ate)
+        out.append({"i": i, "text": w.get("text", ""), "whisper": round(s, 3), "start": start,
+                    "end": round(max(e, start), 3), "dif": round(start - s, 3), "como": como})
+    return out
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(description="Começo de cada palavra medido na onda (o Whisper adianta até 0,3 s).")
+    ap.add_argument("edit", nargs="?", type=Path, help="pasta edit do corte (usa cut.mp4 e transcripts/cut.json)")
+    ap.add_argument("--video", type=Path, help="outro vídeo (com --transcricao)")
+    ap.add_argument("--transcricao", type=Path, help="transcrição do vídeo (transcripts/<nome>.json)")
+    ap.add_argument("--palavra", action="append", default=[], help="só esta palavra (pode repetir; sem acento conta)")
+    ap.add_argument("--de", type=float, help="só palavras a partir deste segundo")
+    ap.add_argument("--ate", type=float, help="só palavras até este segundo")
+    ap.add_argument("--todas", action="store_true", help="mostra todas as palavras, não só as que mudaram")
+    ap.add_argument("--limiar", type=float, help="dB abaixo do qual é pausa (padrão: medido, como no corte pela onda)")
+    ap.add_argument("-o", "--saida", type=Path, help="JSON de saída (padrão: <edit>/palavras_onda.json)")
+    a = ap.parse_args(argv)
+
+    if a.edit:
+        edit = a.edit.resolve()
+        video = a.video or edit / "cut.mp4"
+        tr = a.transcricao or edit / "transcripts" / f"{Path(video).stem}.json"
+        saida = a.saida or edit / "palavras_onda.json"
+    elif a.video and a.transcricao:
+        video, tr = a.video, a.transcricao
+        saida = a.saida or Path(tr).with_name(Path(tr).stem + "_onda.json")
+    else:
+        ap.error("passe a pasta edit, ou --video e --transcricao")
+    video, tr = Path(video), Path(tr)
+    for p in (video, tr):
+        if not p.is_file():
+            print(f"ERRO: não achei {p}" + (" (rode o conferir_corte.py antes: ele transcreve o corte)"
+                                            if p == tr else ""), file=sys.stderr)
+            return 2
+    data = load_json(tr)
+    words = data.get("words", []) if isinstance(data, dict) else []
+    if not words:
+        print(f"ERRO: {tr.name} não tem palavras", file=sys.stderr)
+        return 2
+    db = onda.envelope(video, None)
+    th = a.limiar if a.limiar is not None else onda.threshold(db)
+    res = medir_palavras(db, th, words)
+    save_json(saida, {"video": str(video), "transcricao": str(tr), "limiar_db": th, "palavras": res})
+
+    alvo = {_norm(x) for x in a.palavra}
+    def quer(r: dict) -> bool:
+        if alvo and _norm(r["text"]) not in alvo:
+            return False
+        if a.de is not None and r["start"] < a.de - 0.3:
+            return False
+        if a.ate is not None and r["start"] > a.ate:
+            return False
+        return a.todas or bool(alvo) or a.de is not None or a.ate is not None or abs(r["dif"]) >= MOSTRAR_S
+    linhas = [r for r in res if quer(r)]
+    n_mov = sum(1 for r in res if abs(r["dif"]) >= MOSTRAR_S)
+    print(f"{video.name}: {len(res)} palavras, {n_mov} com o começo 0,05 s ou mais longe do Whisper "
+          f"(pausa abaixo de {th:.0f} dB) · {saida}")
+    if linhas:
+        print(f"  {'onda':>8s}  {'whisper':>8s}  {'dif':>6s}  {'como':7s}  palavra")
+    for r in linhas:
+        print(f"  {fmt_time(r['start']):>8s}  {fmt_time(r['whisper']):>8s}  {r['dif']:+.2f}  {r['como']:7s}  {r['text']}")
+    if alvo and not linhas:
+        print("  nenhuma palavra com esse texto (confira a grafia na fala do corte)")
+    print("  para animação, som ou corte na palavra: use o tempo da coluna onda (\"em\": segundos) no projeto.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())