primocode 11.4.0 → 11.5.0

package/editor/helpers/legenda_ass.py

@@ -0,0 +1,124 @@
+"""Edit 2.0, peça 6: legenda simples em ASS (pysubs2, MIT) queimada no ffmpeg (libass, ISC). Sem Remotion.
+
+A legenda especial (tipografia cinética, palavra gigante) continua no HyperFrames. Aqui fica a legenda de dia a dia:
+até 3 palavras por vez, a palavra que está sendo dita acende (karaoke `\\k`) e dá um pulinho (`\\t` de escala),
+na zona segura do Reels (texto entre y 230 e 1530; x 140 a 940).
+
+O ffmpeg do Homebrew desta máquina vem SEM libass (nem o filtro `ass` nem `subtitles`). Então `queimar` confere o
+filtro antes: com libass, queima o .ass; sem libass, devolve `queimou: false` e o `pipeline` usa o caminho antigo
+(PNG por estado, text_render + overlay). Nunca finge que queimou.
+
+Uso:
+    uv run python helpers/legenda_ass.py <transcript.json> <saida.ass> [--tamanho 1080x1920]
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+MAX_PALAVRAS = 3
+GAP_QUEBRA_S = 0.45
+ZONA_Y = (230, 1530)
+ZONA_X = (140, 940)
+FONTE = "Montserrat ExtraBold"
+BRANCO, DESTAQUE, CONTORNO = "&H00FFFFFF&", "&H0000D7FF&", "&H00101010&"   # ASS é BGR: DESTAQUE = âmbar #FFD700
+
+
+def blocos(palavras: list[dict], max_palavras: int = MAX_PALAVRAS, gap: float = GAP_QUEBRA_S) -> list[list[dict]]:
+    """Grupos de até `max_palavras`; quebra em pontuação final ou em pausa. Nenhuma palavra some."""
+    out: list[list[dict]] = []
+    atual: list[dict] = []
+    for w in palavras:
+        if atual and (len(atual) >= max_palavras or w["start"] - atual[-1]["end"] > gap):
+            out.append(atual)
+            atual = []
+        atual.append(w)
+        if re.search(r"[.!?…]$", w["text"].strip()):
+            out.append(atual)
+            atual = []
+    if atual:
+        out.append(atual)
+    return out
+
+
+def _limpo(t: str) -> str:
+    return t.replace("{", "(").replace("}", ")").replace("\\", "").strip()
+
+
+def montar_ass(palavras: list[dict], largura: int = 1080, altura: int = 1920, fonte: str = FONTE,
+               tamanho: int | None = None, margem_v: int | None = None):
+    import pysubs2  # noqa: PLC0415
+
+    tam = tamanho or int(altura * 0.047)
+    # \an2 = base central; a base do texto fica a 22% do fim (y ~ 1500 num 1920), dentro da zona segura
+    mv = margem_v if margem_v is not None else int(altura * 0.22)
+    subs = pysubs2.SSAFile()
+    subs.info["PlayResX"], subs.info["PlayResY"] = str(largura), str(altura)
+    subs.info["ScaledBorderAndShadow"] = "yes"
+    est = pysubs2.SSAStyle(fontname=fonte, fontsize=tam, bold=True, alignment=2, marginl=int(largura * 0.13),
+                           marginr=int(largura * 0.13), marginv=mv, outline=max(3, tam // 11), shadow=0,
+                           primarycolor=pysubs2.Color(255, 215, 0), secondarycolor=pysubs2.Color(255, 255, 255),
+                           outlinecolor=pysubs2.Color(16, 16, 16))
+    subs.styles["Padrao"] = est
+    for grupo in blocos(palavras):
+        ini, fim = grupo[0]["start"], grupo[-1]["end"]
+        # a palavra fica na tela até a próxima começar (sem piscar entre palavras coladas)
+        partes = []
+        for i, w in enumerate(grupo):
+            dur_w = (grupo[i + 1]["start"] if i + 1 < len(grupo) else w["end"]) - w["start"]
+            cs = max(1, int(round(dur_w * 100)))
+            off = int(round((w["start"] - ini) * 1000))   # o pulinho é na hora da palavra, não do bloco
+            partes.append("{\\fscx100\\fscy100\\k%d\\t(%d,%d,\\fscx112\\fscy112)\\t(%d,%d,\\fscx100\\fscy100)}%s"
+                          % (cs, off, off + 120, off + 120, off + 260, _limpo(w["text"])))
+        subs.append(pysubs2.SSAEvent(start=int(round(ini * 1000)), end=int(round(fim * 1000)) + 80, style="Padrao",
+                                     text=" ".join(partes)))
+    return subs
+
+
+def palavras_do_transcript(tr: dict) -> list[dict]:
+    return [{"text": w["text"], "start": float(w["start"]), "end": float(w["end"])} for w in tr["words"]]
+
+
+def tem_libass() -> bool:
+    r = subprocess.run(["ffmpeg", "-hide_banner", "-filters"], capture_output=True, text=True)
+    return bool(re.search(r"\b(ass|subtitles)\b\s+V->V", r.stdout))
+
+
+def filtro_ass(ass: Path, fontsdir: Path | None = None) -> str:
+    esc = lambda p: str(p).replace("\\", "/").replace(":", "\\:").replace("'", "\\'")  # noqa: E731
+    f = f"ass='{esc(ass)}'"
+    if fontsdir:
+        f += f":fontsdir='{esc(fontsdir)}'"
+    return f
+
+
+def queimar(video: Path, ass: Path, saida: Path, fontsdir: Path | None = None) -> dict:
+    if not tem_libass():
+        return {"queimou": False, "motivo": "este ffmpeg não tem libass (filtro ass); use o caminho de PNG do text_render"}
+    r = subprocess.run(["ffmpeg", "-hide_banner", "-nostdin", "-v", "error", "-y", "-i", str(video), "-vf", filtro_ass(ass, fontsdir),
+                        "-c:a", "copy", str(saida)], capture_output=True, text=True)
+    return {"queimou": r.returncode == 0, "motivo": r.stderr[-200:] if r.returncode else "libass"}
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__.split("\n")[0])
+    ap.add_argument("transcript", type=Path)
+    ap.add_argument("saida", type=Path)
+    ap.add_argument("--tamanho", default="1080x1920")
+    a = ap.parse_args()
+    w, h = (int(x) for x in a.tamanho.split("x"))
+    tr = json.loads(a.transcript.read_text(encoding="utf-8"))
+    montar_ass(palavras_do_transcript(tr), w, h).save(str(a.saida))
+    print(a.saida)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/editor/helpers/look_ffmpeg.py

@@ -0,0 +1,105 @@
+"""Edit 2.0, peça 5: cor e acabamento só com filtros nativos do ffmpeg (lut3d, noise, deshake).
+
+- LUT própria, gerada aqui em código (.cube de 33 pontos): nada de LUT baixada da internet, que tem licença própria.
+  Looks: `agencia` (contraste de S suave, sombra levemente fria, pele quente, saturação +6%), `limpo` (só contraste),
+  `quente`. O ffmpeg lê o .cube com `lut3d` (interpolação tetraédrica).
+- Grão: `noise=alls=N:allf=t` (N 4 a 8; some a "cara de vídeo digital chapado" sem sujar a pele).
+- Estabilização: `deshake` do ffmpeg, só quando pedida e quando a tomada treme. NÃO usamos vid.stab (pede build GPL).
+Licenças: LICENSES/edit2-terceiros.md.
+
+Uso:
+    uv run python helpers/look_ffmpeg.py cadeia --look agencia [--grao 6] [--estabilizar] --pasta <edit>
+    uv run python helpers/look_ffmpeg.py cube agencia saida.cube
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+LADO = 33
+LOOKS = {
+    # contraste (0 a 1), sombra (r,g,b somados no preto), luz (idem no branco), saturação
+    "agencia": {"contraste": 0.18, "sombra": (-0.010, 0.004, 0.016), "luz": (0.014, 0.006, -0.012), "sat": 1.06},
+    "limpo": {"contraste": 0.10, "sombra": (0.0, 0.0, 0.0), "luz": (0.0, 0.0, 0.0), "sat": 1.02},
+    "quente": {"contraste": 0.14, "sombra": (0.004, 0.0, -0.008), "luz": (0.022, 0.008, -0.020), "sat": 1.05},
+}
+
+
+def _curva_s(x, forca: float):
+    """Mistura a identidade com uma curva smoothstep: forca 0 = nada; preto e branco ficam onde estão."""
+    import numpy as np  # noqa: PLC0415
+
+    s = x * x * (3 - 2 * x)
+    return np.clip((1 - forca) * x + forca * s, 0.0, 1.0)
+
+
+def grade_cor(rgb, look: str):
+    """rgb: array (...,3) em 0..1 -> mesma forma com o look aplicado."""
+    import numpy as np  # noqa: PLC0415
+
+    p = LOOKS[look]
+    out = _curva_s(rgb, p["contraste"])
+    lum = out @ np.array([0.2126, 0.7152, 0.0722])
+    t = lum[..., None]
+    out = out + np.array(p["sombra"]) * (1 - t) + np.array(p["luz"]) * t     # split-tone
+    out = lum[..., None] + (out - lum[..., None]) * p["sat"]                   # saturação
+    return np.clip(out, 0.0, 1.0)
+
+
+def escrever_cube(look: str, destino: Path) -> Path:
+    """.cube de 33^3: o ffmpeg varia o R mais rápido, depois G, depois B."""
+    import numpy as np  # noqa: PLC0415
+
+    if look not in LOOKS:
+        raise KeyError(f"look desconhecido: {look!r}. Existem: {', '.join(LOOKS)}")
+    eixo = np.linspace(0, 1, LADO)
+    b, g, r = np.meshgrid(eixo, eixo, eixo, indexing="ij")
+    rgb = np.stack([r, g, b], axis=-1).reshape(-1, 3)
+    saida = grade_cor(rgb, look)
+    linhas = [f'TITLE "primocode-{look}"', f"LUT_3D_SIZE {LADO}", "DOMAIN_MIN 0 0 0", "DOMAIN_MAX 1 1 1"]
+    linhas += [f"{a:.6f} {c:.6f} {d:.6f}" for a, c, d in saida]
+    destino.parent.mkdir(parents=True, exist_ok=True)
+    destino.write_text("\n".join(linhas) + "\n", encoding="utf-8")
+    return destino
+
+
+def _esc(p: Path) -> str:
+    return str(p).replace("\\", "/").replace(":", "\\:").replace("'", "\\'")
+
+
+def cadeia(look: str | None = "agencia", grao: int = 6, estabilizar: bool = False, pasta: Path | None = None) -> str:
+    """Pedaço de -vf: [deshake,] lut3d, noise. Tudo nativo. '' quando nada é pedido."""
+    partes: list[str] = []
+    if estabilizar:
+        partes.append("deshake=rx=16:ry=16:edge=mirror")
+    if look and look != "nenhum":
+        cube = escrever_cube(look, (pasta or Path.cwd()) / f"look_{look}.cube")
+        partes.append(f"lut3d=file='{_esc(cube)}':interp=tetrahedral")
+    if grao and grao > 0:
+        partes.append(f"noise=alls={min(max(int(grao), 1), 12)}:allf=t")
+    return ",".join(partes)
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__.split("\n")[0])
+    sp = ap.add_subparsers(dest="cmd", required=True)
+    c = sp.add_parser("cadeia")
+    c.add_argument("--look", default="agencia")
+    c.add_argument("--grao", type=int, default=6)
+    c.add_argument("--estabilizar", action="store_true")
+    c.add_argument("--pasta", type=Path, default=Path.cwd())
+    q = sp.add_parser("cube")
+    q.add_argument("look")
+    q.add_argument("saida", type=Path)
+    a = ap.parse_args()
+    if a.cmd == "cadeia":
+        print(cadeia(a.look, a.grao, a.estabilizar, a.pasta))
+    else:
+        print(escrever_cube(a.look, a.saida))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/editor/helpers/motor_palavras.py

@@ -0,0 +1,157 @@
+"""Edit 2.0, peça 1: motores de transcrição com tempo de palavra alinhado.
+
+WhisperX (BSD-2-Clause, faster-whisper + alinhamento wav2vec2) é o motor novo: o alinhamento forçado dá o
+início e o fim de cada palavra bem mais justos que o do Whisper puro. Diarização (pyannote) fica FORA.
+Se o WhisperX não instalar ou falhar, cai no whisper.cpp (`whisper-cli`, MIT) e, por fim, no motor antigo.
+
+Os dois devolvem o mesmo formato do transcribe.py: segmentos com `words` [{word,start,end,probability}].
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+import tempfile
+import wave
+from pathlib import Path
+
+SAMPLE_RATE = 16000
+_CACHE: dict = {}
+
+
+class MotorIndisponivel(RuntimeError):
+    pass
+
+
+def preencher_tempos(words: list[dict], ini: float, fim: float) -> list[dict]:
+    """Palavra sem tempo (número, símbolo: o alinhador não acha letras) herda o espaço entre as vizinhas."""
+    n = len(words)
+    i = 0
+    while i < n:
+        if "start" in words[i] and "end" in words[i]:
+            i += 1
+            continue
+        j = i
+        while j < n and not ("start" in words[j] and "end" in words[j]):
+            j += 1
+        a = words[i - 1]["end"] if i > 0 else ini
+        b = words[j]["start"] if j < n else fim
+        b = max(b, a)
+        passo = (b - a) / (j - i)
+        for k in range(i, j):
+            words[k]["start"] = round(a + passo * (k - i), 3)
+            words[k]["end"] = round(a + passo * (k - i + 1), 3)
+            words[k]["score"] = 0.0
+        i = j
+    return words
+
+
+def _segmentos(resultado: dict) -> list[dict]:
+    segs = []
+    for seg in resultado.get("segments", []):
+        ws = preencher_tempos([dict(w) for w in seg.get("words", [])], float(seg["start"]), float(seg["end"]))
+        # convenção do transcribe.py (vinda do Whisper): palavra nova começa com espaço; sem ele o collect_words cola tudo
+        words = [{"word": " " + w.get("word", "").lstrip(), "start": float(w["start"]), "end": float(w["end"]),
+                  "probability": float(w.get("score", w.get("probability", 0.0)))} for w in ws]
+        segs.append({"start": float(seg["start"]), "end": float(seg["end"]), "text": seg.get("text", ""), "words": words})
+    return segs
+
+
+def run_whisperx(audio, model: str, language: str | None, prompt: str | None) -> tuple[list[dict], str | None]:
+    try:
+        import whisperx  # noqa: PLC0415
+    except ImportError as exc:
+        raise MotorIndisponivel("whisperx não está instalado. Rode: uv sync") from exc
+    device = "cpu"  # o ctranslate2 não usa a GPU do Mac; int8 na CPU é o caminho
+    if ("wx", model) not in _CACHE:
+        opts = {"condition_on_previous_text": False}
+        if prompt:
+            opts["initial_prompt"] = prompt
+        _CACHE[("wx", model)] = whisperx.load_model(model, device, compute_type="int8", language=language,
+                                                    asr_options=opts)
+    asr = _CACHE[("wx", model)]
+    res = asr.transcribe(audio, batch_size=8, language=language)
+    lang = res.get("language") or language or "pt"
+    if ("al", lang) not in _CACHE:
+        _CACHE[("al", lang)] = whisperx.load_align_model(language_code=lang, device=device)
+    modelo_al, meta = _CACHE[("al", lang)]
+    alinhado = whisperx.align(res["segments"], modelo_al, meta, audio, device, return_char_alignments=False)
+    return _segmentos(alinhado), lang
+
+
+def _wav(audio, caminho: Path) -> None:
+    import numpy as np  # noqa: PLC0415
+
+    pcm = (np.clip(audio, -1, 1) * 32767).astype("<i2")
+    with wave.open(str(caminho), "wb") as w:
+        w.setnchannels(1)
+        w.setsampwidth(2)
+        w.setframerate(SAMPLE_RATE)
+        w.writeframes(pcm.tobytes())
+
+
+def achar_modelo_cpp(model: str) -> str | None:
+    """Procura um ggml-*.bin: PRIMOCODE_WHISPER_CPP_MODEL, ~/.primocode/whisper-cpp, pastas comuns do brew."""
+    env = os.environ.get("PRIMOCODE_WHISPER_CPP_MODEL")
+    if env and Path(env).exists():
+        return env
+    nomes = [f"ggml-{model}.bin", "ggml-large-v3-turbo.bin", "ggml-large-v3.bin", "ggml-medium.bin", "ggml-small.bin", "ggml-base.bin"]
+    pastas = [Path.home() / ".primocode" / "whisper-cpp", Path.home() / ".cache" / "whisper", Path("/opt/homebrew/share/whisper-cpp")]
+    for p in pastas:
+        for n in nomes:
+            if (p / n).exists():
+                return str(p / n)
+    return None
+
+
+def parse_json_cpp(dados: dict) -> list[dict]:
+    """JSON completo do whisper-cli (-ojf): tokens com `offsets` em ms. Junta os pedaços em palavras
+    (token que começa com espaço abre uma palavra nova)."""
+    palavras: list[dict] = []
+    for item in dados.get("transcription", []):
+        for tk in item.get("tokens", []):
+            texto = tk.get("text", "")
+            if not texto or texto.startswith("[_") or texto.startswith("<|"):
+                continue
+            ini, fim = tk["offsets"]["from"] / 1000, tk["offsets"]["to"] / 1000
+            p = float(tk.get("p", 0.0))
+            if texto.startswith(" ") or not palavras:
+                palavras.append({"word": texto, "start": ini, "end": fim, "probability": p, "_n": 1})
+            else:
+                w = palavras[-1]
+                w["word"] += texto
+                w["end"] = fim
+                w["probability"] = (w["probability"] * w["_n"] + p) / (w["_n"] + 1)
+                w["_n"] += 1
+    for w in palavras:
+        w.pop("_n", None)
+        w["word"] = w["word"] if w["word"].startswith(" ") else " " + w["word"]
+    return palavras
+
+
+def run_whisper_cpp(audio, model: str, language: str | None, prompt: str | None) -> tuple[list[dict], str | None]:
+    exe = shutil.which("whisper-cli") or shutil.which("whisper-cpp")
+    if not exe:
+        raise MotorIndisponivel("whisper.cpp (whisper-cli) não está no PATH")
+    mp = achar_modelo_cpp(model)
+    if not mp:
+        raise MotorIndisponivel("nenhum modelo ggml encontrado (veja PRIMOCODE_WHISPER_CPP_MODEL)")
+    with tempfile.TemporaryDirectory() as tmp:
+        wav, saida = Path(tmp) / "a.wav", Path(tmp) / "saida"
+        _wav(audio, wav)
+        cmd = [exe, "-m", mp, "-f", str(wav), "-l", language or "auto", "-ojf", "-of", str(saida), "-ml", "0", "-np"]
+        if prompt:
+            cmd += ["--prompt", prompt]
+        r = subprocess.run(cmd, capture_output=True, text=True)
+        js = Path(str(saida) + ".json")
+        if r.returncode != 0 or not js.exists():
+            raise MotorIndisponivel(f"whisper.cpp falhou: {(r.stderr or '')[-200:]}")
+        dados = json.loads(js.read_text(encoding="utf-8"))
+    words = parse_json_cpp(dados)
+    if not words:
+        return [], language
+    texto = "".join(w["word"] for w in words).strip()
+    return [{"start": words[0]["start"], "end": words[-1]["end"], "text": texto, "words": words}], \
+        (dados.get("result", {}).get("language") or language)

package/editor/helpers/primeiro_passe.py

@@ -0,0 +1,214 @@
+# Regras do corte adaptadas de browser-use/video-use (MIT, (c) 2026 Browser Use). See THIRD_PARTY_NOTICES.md.
+"""Edit 2.0, peça 2: o 1º passe do corte. silero-vad + auto-editor acham a fala; as palavras travam as bordas.
+
+1. silero-vad (MIT) diz onde há voz; respiro e ruído de fundo não viram "fala".
+2. auto-editor (Unlicense), chamado por linha de comando, mede a energia do áudio. Trecho que só ele achou (estalo,
+   tosse, batida) sem voz do VAD é ruído e sai; borda do VAD que o auto-editor estende (consoante fraca) vale.
+3. Regras do video-use: NUNCA cortar dentro de uma palavra; folga de 30 a 200 ms em cada borda (sempre menor que
+   metade da pausa, para não entrar na palavra vizinha); fade de 30 ms em cada emenda (o render_cut já faz).
+   Pausa que sobra com menos de 0,25 s não é corte: o trecho é emendado de volta.
+4. A saída é um `edl_manual.json` de rascunho (trecho por trecho, com a frase). A IA depois escolhe a tomada e tira o
+   erro; o `corte_por_onda.py` ainda mede a onda de cada junta.
+
+Uso:
+    uv run python helpers/primeiro_passe.py <video> <edit_dir> [--folga 0.08] [--saida edl_manual.json]
+Precisa de <edit_dir>/transcripts/<nome>.json (transcribe.py).
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+FOLGA_MIN, FOLGA_MAX, FOLGA_PADRAO = 0.03, 0.20, 0.08
+PAUSA_CORTA_S = 0.25      # silêncio menor que isso depois da folga: o trecho é emendado
+FADE_S = 0.03
+MIN_TRECHO_S = 0.2
+
+
+def uniao(a: list[list[float]], b: list[list[float]]) -> list[list[float]]:
+    xs = sorted([list(x) for x in a + b])
+    out: list[list[float]] = []
+    for s, e in xs:
+        if out and s <= out[-1][1]:
+            out[-1][1] = max(out[-1][1], e)
+        else:
+            out.append([s, e])
+    return out
+
+
+def vad_fala(video: Path, min_silencio_ms: int = 250) -> list[list[float]]:
+    from speech_regions import load_mono  # noqa: PLC0415
+
+    import torch  # noqa: PLC0415
+    from silero_vad import get_speech_timestamps, load_silero_vad  # noqa: PLC0415
+
+    mono, _ = load_mono(video)
+    audio = torch.from_numpy(mono.astype("float32"))
+    ts = get_speech_timestamps(audio, load_silero_vad(), sampling_rate=16000, min_silence_duration_ms=min_silencio_ms,
+                               speech_pad_ms=30, return_seconds=True)
+    return [[round(t["start"], 3), round(t["end"], 3)] for t in ts]
+
+
+def auto_editor_fala(video: Path, saida_json: Path, fps: float, limiar: str = "audio:0.03", margem: str = "0.1sec") -> list[list[float]]:
+    """O que o auto-editor deixa (chunks com velocidade 1). Os chunks vêm em quadros."""
+    exe = Path(sys.executable).parent / "auto-editor"
+    cmd = [str(exe) if exe.exists() else "auto-editor", str(video), "--edit", limiar, "--margin", margem,
+           "--export", "v1", "-o", str(saida_json)]
+    r = subprocess.run(cmd, capture_output=True, text=True)
+    if r.returncode != 0 or not saida_json.exists():
+        raise RuntimeError(f"auto-editor falhou: {(r.stderr or r.stdout)[-200:]}")
+    chunks = json.loads(saida_json.read_text(encoding="utf-8"))["chunks"]
+    return [[round(a / fps, 3), round(b / fps, 3)] for a, b, vel in chunks if vel < 1000]
+
+
+def filtrar_ruido(vad: list[list[float]], energia: list[list[float]]) -> tuple[list[list[float]], int]:
+    """VAD manda. A energia só estende a borda de um trecho que ela compartilha com o VAD (até 0,15 s)."""
+    saida = []
+    for s, e in vad:
+        ini, fim = s, e
+        for a, b in energia:
+            if b > s and a < e:
+                ini, fim = min(ini, max(a, s - 0.15)), max(fim, min(b, e + 0.15))
+        saida.append([ini, fim])
+    solitarios = sum(1 for a, b in energia if not any(b > s and a < e for s, e in vad))
+    return uniao(saida, []), solitarios
+
+
+def _vizinhas(palavras: list[dict]) -> list[dict]:
+    return sorted(palavras, key=lambda w: w["start"])
+
+
+def ajustar_a_palavras(trechos: list[list[float]], palavras: list[dict], duracao: float,
+                       folga: float = FOLGA_PADRAO) -> list[list[float]]:
+    """Cada borda sai do meio de palavra e ganha a folga, sem entrar na vizinha."""
+    folga = min(max(folga, FOLGA_MIN), FOLGA_MAX)
+    ws = _vizinhas(palavras)
+    if not ws:
+        return [list(t) for t in trechos]
+    out = []
+    for s, e in trechos:
+        # borda inicial: se cai dentro de palavra, volta pro começo dela
+        for w in ws:
+            if w["start"] < s < w["end"]:
+                s = w["start"]
+        for w in ws:
+            if w["start"] < e < w["end"]:
+                e = w["end"]
+        prim = min([w["start"] for w in ws if w["end"] > s and w["start"] < e] or [s])
+        ult = max([w["end"] for w in ws if w["start"] < e and w["end"] > s] or [e])
+        antes = max([w["end"] for w in ws if w["start"] < prim - 1e-6] or [0.0])
+        depois = min([w["start"] for w in ws if w["start"] > ult - 1e-6 and w["start"] >= e - 1e-6] or [duracao])
+        ini = max(0.0, prim - min(folga, max(0.0, (prim - antes) / 2)))
+        fim = min(duracao, ult + min(folga, max(0.0, (depois - ult) / 2)))
+        if fim - ini >= MIN_TRECHO_S:
+            out.append([round(ini, 3), round(fim, 3)])
+    # pausa que sobrou menor que 0,25 s não é corte
+    emendado: list[list[float]] = []
+    for s, e in out:
+        if emendado and s - emendado[-1][1] < PAUSA_CORTA_S:
+            emendado[-1][1] = max(emendado[-1][1], e)
+        else:
+            emendado.append([s, e])
+    return emendado
+
+
+def conferir(trechos: list[list[float]], palavras: list[dict]) -> dict:
+    """A conta das regras: borda em cima de palavra, folga mínima, pausa entre trechos."""
+    ws = _vizinhas(palavras)
+    dentro = 0
+    folgas = []
+    for s, e in trechos:
+        for w in ws:
+            if w["start"] + 0.001 < s < w["end"] - 0.001 or w["start"] + 0.001 < e < w["end"] - 0.001:
+                dentro += 1
+        a = [w["end"] for w in ws if w["end"] <= s + 0.001]
+        d = [w["start"] for w in ws if w["start"] >= e - 0.001]
+        if a:
+            folgas.append(s - max(a))
+        if d:
+            folgas.append(min(d) - e)
+    pausas = [trechos[i + 1][0] - trechos[i][1] for i in range(len(trechos) - 1)]
+    return {"cortes_dentro_de_palavra": dentro, "folga_min_s": round(min(folgas), 3) if folgas else None,
+            "menor_pausa_cortada_s": round(min(pausas), 3) if pausas else None, "trechos": len(trechos)}
+
+
+def tirar_trechos(trechos: list[list[float]], tirar: list[list[float]], palavras: list[dict] | None = None) -> list[list[float]]:
+    """A decisão da IA (tomada repetida, erro, falso começo): tira [a, b] dos trechos. Quem tira ganha as palavras
+    inteiras que o intervalo toca (sobra de meia palavra não fica), e sobra menor que o mínimo some. As bordas novas
+    ainda passam por `ajustar_a_palavras`, que as põe de volta no vão entre palavras."""
+    ws = _vizinhas(palavras or [])
+    out = [list(t) for t in trechos]
+    for a, b in sorted(tirar):
+        for w in ws:
+            if w["start"] < b and w["end"] > a:
+                a, b = min(a, w["start"]), max(b, w["end"])
+        novo = []
+        for s, e in out:
+            if b <= s or a >= e:
+                novo.append([s, e])
+                continue
+            if a - s >= MIN_TRECHO_S:
+                novo.append([s, a])
+            if e - b >= MIN_TRECHO_S:
+                novo.append([b, e])
+        out = novo
+    return out
+
+
+def frase_do_trecho(s: float, e: float, palavras: list[dict]) -> str:
+    return " ".join(w["text"] for w in palavras if w["start"] >= s - 0.01 and w["end"] <= e + 0.01)
+
+
+def montar(video: Path, edit: Path, folga: float = FOLGA_PADRAO, saida: Path | None = None,
+           tirar: list[list[float]] | None = None) -> dict:
+    from common import load_json, probe_video  # noqa: PLC0415
+
+    tr = load_json(edit / "transcripts" / f"{video.stem}.json")
+    info = probe_video(video)
+    fps = float(info.get("fps") or 30)
+    dur = float(tr.get("duration") or info.get("duration"))
+    vad = vad_fala(video)
+    erro_ae = None
+    try:
+        energia = auto_editor_fala(video, edit / "auto_editor.json", fps)
+    except Exception as exc:  # sem o auto-editor o VAD segue sozinho; o relatório diz
+        energia, erro_ae = [], str(exc)
+    base, solitarios = filtrar_ruido(vad, energia) if energia else (vad, 0)
+    if tirar:
+        base = tirar_trechos(base, tirar, tr["words"])
+    trechos = ajustar_a_palavras(base, tr["words"], dur, folga)
+    rel = conferir(trechos, tr["words"])
+    rel.update({"vad_trechos": len(vad), "ruido_tirado": solitarios, "auto_editor": "ok" if not erro_ae else erro_ae,
+                "tirado_pela_ia": tirar or [], "folga_s": folga, "fade_s": FADE_S, "mantido_s": round(sum(e - s for s, e in trechos), 2), "duracao_s": round(dur, 2)})
+    edl = {"version": 1, "sources": {video.stem: str(video)},
+           "output": {"format": "vertical", "width": 1080, "height": 1920}, "grade": "",
+           "jcut": {"lead_frames": 4, "tail_trim_frames": 2},
+           "ranges": [{"id": f"p{i + 1:02d}", "source": video.stem, "start": s, "end": e,
+                       "quote": frase_do_trecho(s, e, tr["words"]), "reason": "1º passe (VAD + onda); a IA escolhe a tomada"}
+                      for i, (s, e) in enumerate(trechos)]}
+    out = saida or edit / "edl_manual.json"
+    out.write_text(json.dumps(edl, ensure_ascii=False, indent=1), encoding="utf-8")
+    (edit / "primeiro_passe.json").write_text(json.dumps(rel, ensure_ascii=False, indent=1), encoding="utf-8")
+    return rel
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description="1º passe do corte: silero-vad + auto-editor + palavras.")
+    ap.add_argument("video", type=Path)
+    ap.add_argument("edit", type=Path)
+    ap.add_argument("--folga", type=float, default=FOLGA_PADRAO)
+    ap.add_argument("--saida", type=Path, default=None)
+    a = ap.parse_args()
+    rel = montar(a.video.absolute(), a.edit.absolute(), a.folga, a.saida)
+    print(json.dumps(rel, ensure_ascii=False, indent=1))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())