primocode 11.3.3 → 11.5.0

package/LICENSES/edit2-terceiros.md

@@ -0,0 +1,31 @@
+# Edit 2.0: terceiros (licença e link)
+
+Cada dependência nova do Edit 2.0 (`editor/pyproject.toml`, bloco "Edit 2.0") tem uma linha aqui. Licença conferida
+em 13/11/2026 na pesquisa da equipe `[LI]` (arquivo LICENSE ou API do GitHub). Regra da casa: GPL/AGPL nunca
+é importada; só poderia ser chamada por linha de comando, e preferimos não usar. Remotion fica de fora (licença paga).
+
+| Peça | Licença | Como entra | Link |
+|---|---|---|---|
+| whisperx | BSD-2-Clause | importado (alinhamento palavra a palavra; diarização não usada) | https://github.com/m-bain/whisperX/blob/main/LICENSE |
+| faster-whisper | MIT | via whisperx | https://github.com/SYSTRAN/faster-whisper/blob/master/LICENSE |
+| wav2vec2 PT (modelo de alinhamento) | Apache-2.0 | baixado pelo whisperx | https://huggingface.co/jonatasgrosman/wav2vec2-large-xlsr-53-portuguese |
+| whisper.cpp | MIT | só por linha de comando (`whisper-cli`), reserva do whisperx | https://github.com/ggml-org/whisper.cpp/blob/master/LICENSE |
+| silero-vad | MIT | importado (fala vs silêncio) | https://github.com/snakers4/silero-vad/blob/master/LICENSE |
+| auto-editor | Unlicense (domínio público) | linha de comando (1º passe do corte) | https://github.com/WyattBlue/auto-editor/blob/master/LICENSE |
+| mediapipe | Apache-2.0 | importado (detector de rosto) | https://github.com/google-ai-edge/mediapipe/blob/master/LICENSE |
+| BlazeFace short-range (`blaze_face_short_range.tflite`) | Apache-2.0 segundo o model card do Google `[VERIFICAR: cartão não relido nesta sessão]` | baixado na 1ª vez para `editor/assets/models/` (sha256 conferido, `assets/baixar.json`) | https://storage.googleapis.com/mediapipe-assets/MediaPipe%20BlazeFace%20Model%20Card%20(Short%20Range).pdf |
+| pysubs2 | MIT | importado (legenda ASS) | https://github.com/tkarabela/pysubs2/blob/master/LICENSE.txt |
+| libass (dentro do ffmpeg) | ISC | queima a legenda ASS | https://github.com/libass/libass/blob/master/COPYING |
+| pyloudnorm | MIT | importado (mede LUFS) | https://github.com/csteinmetz1/pyloudnorm/blob/master/LICENSE |
+| ffmpeg-normalize | MIT | importado/linha de comando (-14 LUFS) | https://github.com/slhck/ffmpeg-normalize/blob/master/LICENSE.md |
+| DeepFilterNet | MIT ou Apache-2.0, à escolha | ambiente à parte (`~/.primocode/editor/df-venv`), chamado por processo | https://github.com/Rikorose/DeepFilterNet/blob/main/LICENSE |
+| FFmpeg (`sidechaincompress`, `lut3d`, `noise`, `deshake`) | LGPL-2.1 (GPL se a build tiver `--enable-gpl`/libx264) | binário do sistema, por linha de comando | https://ffmpeg.org/legal.html |
+| browser-use/video-use (só as regras do corte) | MIT | ideia, sem código novo; crédito em `editor/THIRD_PARTY_NOTICES.md` | https://github.com/browser-use/video-use/blob/main/LICENSE |
+| pyautoflip (só a ideia da câmera suave) | MIT | nenhuma linha copiada | https://github.com/AhmedHisham1/pyautoflip |
+
+## Fora de propósito
+
+- Remotion: licença paga para a Paris Group. Motion e legenda especial seguem no HyperFrames.
+- pyannote (diarização): modelos "gated" no Hugging Face. Fora por enquanto (vem como dependência do whisperx, não é chamado).
+- vid.stab: exige build GPL do ffmpeg. Usamos `deshake`.
+- pedalboard (GPL-3.0), ultralytics (AGPL-3.0), whisper-timestamped (AGPL-3.0), insightface (modelos não comerciais): nunca.

package/LICENSES/models-dev-MIT.txt

@@ -0,0 +1,25 @@
+Catálogo de modelos lido do models.dev (https://github.com/anomalyco/models.dev), licença MIT.
+Usado em: lib/provider/catalogo.js e lib/provider/local/catalogo-embutido.json.gz (recorte enxuto do api.json).
+Ideia de camadas (rede, cache, snapshot embutido) vista no OpenCode (anomalyco/opencode, MIT). Código reescrito.
+
+MIT License
+
+Copyright (c) 2025 models.dev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v11.3.2
+# PrimoCode v11.5.0
 
 Agente de engenharia brasileiro para o terminal, no estilo Claude Code.
 Cria arquivos de verdade, roda comandos, **controla o navegador e o desktop** —
@@ -9,7 +9,7 @@ OpenRouter, e cada apelido (`top`/`main`/`fast`) é uma **corrente**: se um mode
 está no limite de pedidos, o próximo atende. Você não vê o erro, e não paga nada.
 
 ```
- ▐▛███▜▌   Primo Code v11.3.2
+ ▐▛███▜▌   Primo Code v11.5.0
 ▝▜█████▛▘  Bem-vindo de volta, Joel
   ▘▘ ▝▝    ~/primocode  · /dir <pasta> muda
 ```

package/editor/SKILL.md

@@ -67,6 +67,30 @@ aparece em cada momento e por quê. O jeito de trabalhar:
 - Um render por vez na mesma pasta.
 - Dinheiro só com o ok da pessoa: imagem, vídeo, trilha ou efeito gerado por IA, serviço pago.
 
+## Edit 2.0: o que você decide e o que o helper mede
+
+Para um vídeo falado de uma tomada só (ou poucas), o caminho curto é o `helpers/edit2.py` (`references/edit2.md`).
+Ele mede; **você decide o que sai e conta em uma linha**:
+
+- **Você decide a tomada e o erro.** Leia `fala_do_corte.md`/`takes_packed.md`, ache falso começo, palavra repetida
+  e frase dita duas vezes, e passe cada um como `--tirar a-b` (segundos da fonte). Fique com a última tomada inteira.
+  O que o `primeiro_passe.py` já resolve sozinho (VAD + onda): respiro, estalo, ruído. Nunca tire uma ressalva, número
+  ou condição que muda o sentido.
+- **Regras que o helper garante** (do browser-use/video-use, MIT): nunca cortar dentro de palavra; folga de 30 a 200 ms
+  em cada borda; fade de 30 ms em cada emenda; pausa menor que 0,25 s não vira corte. Leia o `primeiro_passe.json`:
+  `cortes_dentro_de_palavra` tem que ser 0. Se não for, não entregue.
+- **Palavra a palavra vem do WhisperX.** Se o relatório diz `motor: whisper.cpp` ou outro, o tempo é menos justo: diga.
+  Nome de marca ou sigla que o Whisper erra ("IA" virou "Iá"): rode de novo com `--prompt`.
+- **Legenda simples** é ASS queimada (`legenda_ass.py`); sem libass no ffmpeg, o relatório diz que usou PNG. Legenda
+  especial e motion continuam no HyperFrames. Nada de Remotion (licença paga).
+- **Som:** voz limpa (DeepFilterNet, se instalado), música abaixo da voz com `sidechaincompress`, tudo em -14 LUFS.
+  O número que vale é o medido (pyloudnorm) no arquivo final, não o pedido.
+- **Rosto e cor:** o corte segue o rosto (MediaPipe, câmera suave); cor só com os filtros do ffmpeg e LUT própria
+  (`look_ffmpeg.py`). Estabilizar (`deshake`) só se a tomada tremer; nunca vid.stab.
+- **Entrega honesta:** diga o que não rodou (DeepFilterNet ausente, libass ausente, motor de reserva) e o antes/depois
+  medido (duração, cortes, LUFS, % do rosto enquadrado). Quem aprova a qualidade é a pessoa, não você.
+- Licença de tudo o que entra: `LICENSES/edit2-terceiros.md`. GPL/AGPL nunca é importada.
+
 ## Onde as coisas ficam
 
 - `<SKILL>`: a pasta deste SKILL.md. Todo helper roda assim:

package/editor/THIRD_PARTY_NOTICES.md

@@ -18,6 +18,7 @@ Arquivos deste projeto que têm código adaptado (todos começam com a linha
 - `helpers/render_cut.py`
 - `helpers/grade.py`
 - `helpers/timeline_view.py`
+- `helpers/primeiro_passe.py` (só as regras do corte: nunca cortar dentro de palavra, folga de 30 a 200 ms, fade de 30 ms)
 
 Texto da licença, como publicado pelo projeto original:
 

package/editor/assets/baixar.json

@@ -594,6 +594,14 @@
    "bytes": 16454537,
    "grupo": "espelho",
    "origem": "MediaPipe selfie_multiclass (Apache-2.0), convertido para ONNX pelo EDIT IA PRO"
+  },
+  {
+   "caminho": "assets/models/blaze_face_short_range.tflite",
+   "sha256": "b4578f35940bf5a1a655214a1cce5cab13eba73c1297cd78e1a04c2380b0152f",
+   "bytes": 229746,
+   "grupo": "essencial",
+   "url": "https://storage.googleapis.com/mediapipe-models/face_detector/blaze_face_short_range/float16/1/blaze_face_short_range.tflite",
+   "origem": "Google MediaPipe BlazeFace short-range (Apache-2.0, conferir model card)"
   }
  ]
-}
+}

package/editor/helpers/df_limpar.py

@@ -0,0 +1,29 @@
+"""Roda DENTRO do ambiente do DeepFilterNet (~/.primocode/editor/df-venv): limpa a voz de um WAV.
+
+Uso: <python do df-venv> df_limpar.py <entrada.wav> <saida.wav>
+O DeepFilterNet (MIT ou Apache-2.0) trabalha a 48 kHz; entra e sai WAV mono/estéreo de 48 kHz.
+Fica separado do ambiente do editor porque pede numpy<2 e torch antigo.
+"""
+import sys
+
+import numpy as np
+import soundfile as sf
+import torch
+from df.enhance import enhance, init_df
+
+
+def main(entrada, saida):
+    modelo, estado, _ = init_df()
+    audio, sr = sf.read(entrada, dtype="float32", always_2d=True)
+    if sr != estado.sr():
+        raise SystemExit(f"esperava {estado.sr()} Hz, veio {sr}")
+    saidas = []
+    for c in range(audio.shape[1]):
+        x = torch.from_numpy(np.ascontiguousarray(audio[:, c])).unsqueeze(0)
+        saidas.append(enhance(modelo, estado, x).squeeze(0).numpy())
+    n = min(len(s) for s in saidas)
+    sf.write(saida, np.stack([s[:n] for s in saidas], axis=1), sr, subtype="PCM_16")
+
+
+if __name__ == "__main__":
+    main(sys.argv[1], sys.argv[2])

package/editor/helpers/edit2.py

@@ -0,0 +1,155 @@
+"""Edit 2.0: o pipeline inteiro de um vídeo falado, numa chamada só (a IA decide o que tirar; o resto é medido).
+
+  1. WhisperX: palavra a palavra alinhada (whisper.cpp de reserva).               motor_palavras.py
+  2. 1º passe: silero-vad + auto-editor, bordas presas nas palavras.                primeiro_passe.py
+  3. A IA tira o que errou (`--tirar a-b`, em segundos da fonte) e fica com a última tomada.
+  4. Corte pela onda + render do corte (fade de 30 ms, folga), voz em -14 LUFS.      corte_por_onda.py, render_cut.py
+  5. Voz limpa (DeepFilterNet, se instalado).                                       som_edit2.py
+  6. Rosto (MediaPipe) -> câmera suavizada, cor (lut3d + grão), legenda (ASS ou PNG) em UMA passada de vídeo.
+  7. -14 LUFS (ffmpeg-normalize), LUFS medido (pyloudnorm), % do tempo com rosto enquadrado.
+
+Uso:
+    uv run python helpers/edit2.py <video> <pasta_de_trabalho> -o <saida.mp4> [--tirar 8.09-8.59] [--look agencia]
+        [--grao 5] [--zoom 1.12] [--tamanho 1080x1920]
+Gera <pasta>/edit/relatorio_edit2.json com o antes/depois (duração, cortes, LUFS, % enquadrado).
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+HELPERS = Path(__file__).resolve().parent
+sys.path.insert(0, str(HELPERS))
+
+
+def _run(cmd: list[str]) -> None:
+    r = subprocess.run(cmd, capture_output=True, text=True)
+    if r.returncode != 0:
+        raise RuntimeError(f"{cmd[1] if len(cmd) > 1 else cmd[0]} falhou:\n{(r.stderr or r.stdout)[-600:]}")
+
+
+def medir_video(video: Path) -> dict:
+    import face_mediapipe  # noqa: PLC0415
+    import som_edit2  # noqa: PLC0415
+    from common import probe_video  # noqa: PLC0415
+
+    info = probe_video(video)
+    return {"duracao_s": round(float(info["duration"]), 2), "largura": info["width"], "altura": info["height"],
+            **som_edit2.medir_lufs(video), **face_mediapipe.percentual_enquadrado(video)}
+
+
+def cues_das_palavras(palavras: list[dict]) -> dict:
+    import legenda_ass  # noqa: PLC0415
+
+    return {"cues": [{"start": g[0]["start"], "end": g[-1]["end"], "words": g} for g in legenda_ass.blocos(palavras)]}
+
+
+def render_final(cut: Path, palavras: list[dict], trilha: dict, saida: Path, edit: Path, look: str, grao: int, zoom: float,
+                 largura: int, altura: int) -> dict:
+    import enquadrar_camera as ec  # noqa: PLC0415
+    import legenda_ass  # noqa: PLC0415
+    import look_ffmpeg  # noqa: PLC0415
+
+    cam = ec.caminho(trilha, zoom)
+    send = ec.escrever_sendcmd(cam, edit / "camera.sendcmd")
+    base = ec.cadeia(cam, send, largura, altura)
+    cor = look_ffmpeg.cadeia(look, grao, False, edit)
+    if cor:
+        base += "," + cor
+    entradas = ["-i", str(cut)]
+    leg = {"metodo": ""}
+    if legenda_ass.tem_libass():
+        ass = edit / "legenda.ass"
+        legenda_ass.montar_ass(palavras, largura, altura).save(str(ass))
+        fc = f"[0:v]{base},{legenda_ass.filtro_ass(ass)}[v]"
+        leg = {"metodo": "ass (libass)", "arquivo": str(ass)}
+    else:
+        import text_render  # noqa: PLC0415
+
+        pngs = edit / "legenda_png"
+        estados = text_render.render_caption_track(cues_das_palavras(palavras), "legenda_limpa", "#FFD700", str(pngs),
+                                                   canvas=(largura, altura), fps=30)
+        lista = text_render.write_ffconcat(estados, str(edit / "legenda.ffconcat"), float(cut_duracao(cut)), str(pngs / "vazio.png"), fps=30)
+        entradas += ["-f", "concat", "-safe", "0", "-i", str(lista)]
+        fc = f"[0:v]{base}[b];[1:v]format=rgba[cap];[b][cap]overlay=0:0:eof_action=pass:format=auto[v]"
+        leg = {"metodo": "PNG por estado (text_render + overlay): este ffmpeg não tem libass", "estados": len(estados)}
+    _run(["ffmpeg", "-hide_banner", "-nostdin", "-v", "error", "-y", *entradas, "-filter_complex", fc, "-map", "[v]", "-map", "0:a?",
+          "-c:v", "libx264", "-preset", "medium", "-crf", "18", "-pix_fmt", "yuv420p", "-c:a", "copy", "-movflags", "+faststart", str(saida)])
+    return {"camera": ec.relatorio(cam), "cor": cor, "legenda": leg}
+
+
+def cut_duracao(p: Path) -> float:
+    from common import probe_video  # noqa: PLC0415
+
+    return float(probe_video(p)["duration"])
+
+
+def rodar(video: Path, trabalho: Path, saida: Path, tirar: list[list[float]], look: str = "agencia", grao: int = 5,
+          zoom: float = 1.12, tamanho: str = "1080x1920") -> dict:
+    import primeiro_passe  # noqa: PLC0415
+    import rastrear_rosto  # noqa: PLC0415
+    import som_edit2  # noqa: PLC0415
+    import transcribe  # noqa: PLC0415
+    from common import load_json  # noqa: PLC0415
+
+    t0 = time.time()
+    largura, altura = (int(x) for x in tamanho.split("x"))
+    edit = trabalho / "edit"
+    edit.mkdir(parents=True, exist_ok=True)
+    rel: dict = {"fonte": str(video), "passos": {}}
+    rel["antes"] = medir_video(video)
+    rel["antes"]["cortes"] = 0
+
+    tp = transcribe.transcribe_one(video, edit_dir=edit, language="pt", model=transcribe.DEFAULT_MODEL, prompt=transcribe.build_prompt(None, True), verbose=False)
+    tr = load_json(tp)
+    rel["passos"]["transcricao"] = {"motor": tr.get("motor_usado"), "palavras": len(tr["words"]), "aviso": tr.get("aviso")}
+
+    rel["passos"]["primeiro_passe"] = primeiro_passe.montar(video, edit, tirar=tirar or None)
+    _run([sys.executable, str(HELPERS / "corte_por_onda.py"), str(edit / "edl_manual.json"), "-o", str(edit / "edl.json")])
+    _run([sys.executable, str(HELPERS / "render_cut.py"), str(edit / "edl.json")])       # render 1: o corte
+    cut = edit / "cut.mp4"
+
+    limpo = edit / "cut_limpo.mp4"
+    voz = som_edit2.limpar_voz(cut, limpo)
+    rel["passos"]["voz"] = voz
+    fonte_video = limpo if voz["limpou"] else cut
+
+    tpc = transcribe.transcribe_one(cut, edit_dir=edit, language="pt", model=transcribe.DEFAULT_MODEL, prompt=transcribe.build_prompt(None, True), verbose=False)
+    palavras = [{"text": w["text"], "start": w["start"], "end": w["end"]} for w in load_json(tpc)["words"]]
+    trilha = rastrear_rosto.construir(edit, forcar=True)
+    bruto = edit / "final_sem_normalizar.mp4"
+    rel["passos"]["acabamento"] = render_final(fonte_video, palavras, trilha, bruto, edit, look, grao, zoom, largura, altura)  # render 2
+    saida.parent.mkdir(parents=True, exist_ok=True)
+    rel["passos"]["som_final"] = som_edit2.normalizar(bruto, saida)
+
+    rel["depois"] = medir_video(saida)
+    rel["depois"]["cortes"] = len(load_json(edit / "edl.json")["ranges"]) - 1
+    rel["segundos"] = round(time.time() - t0, 1)
+    (edit / "relatorio_edit2.json").write_text(json.dumps(rel, ensure_ascii=False, indent=1), encoding="utf-8")
+    return rel
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__.split("\n")[0])
+    ap.add_argument("video", type=Path)
+    ap.add_argument("trabalho", type=Path)
+    ap.add_argument("-o", "--saida", type=Path, required=True)
+    ap.add_argument("--tirar", action="append", default=[], help="a-b em segundos da fonte (repetível): o que a IA decidiu tirar")
+    ap.add_argument("--look", default="agencia")
+    ap.add_argument("--grao", type=int, default=5)
+    ap.add_argument("--zoom", type=float, default=1.12)
+    ap.add_argument("--tamanho", default="1080x1920")
+    a = ap.parse_args()
+    tirar = [[float(x) for x in t.split("-")] for t in a.tirar]
+    rel = rodar(a.video.absolute(), a.trabalho.absolute(), a.saida.absolute(), tirar, a.look, a.grao, a.zoom, a.tamanho)
+    print(json.dumps({"antes": rel["antes"], "depois": rel["depois"]}, ensure_ascii=False, indent=1))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/editor/helpers/enquadrar_camera.py

@@ -0,0 +1,77 @@
+"""Edit 2.0, peça 7: o enquadramento que segue o rosto (câmera suavizada) direto no ffmpeg, sem HyperFrames.
+
+Entrada: o `rosto_trilha.json` do rastrear_rosto.py (rosto medido 10 vezes por segundo pelo MediaPipe, mediana de 5,
+zona morta de 3%, transição de 0,5 s: a suavização que já existia; a ideia vem do pyautoflip, MIT, sem código copiado).
+Saída: um `sendcmd` que move o `crop` a cada 0,1 s e a cadeia `-vf` (crop com zoom fixo + scale para o quadro final).
+
+Regras: o corte fica sempre dentro do quadro; o olho fica a ~40% da altura do corte (regra dos terços); tomada sem
+rosto fica no enquadramento de antes (centro) e o relatório conta.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+ZOOM_PADRAO = 1.12
+OLHO_NA_ALTURA = 0.42     # onde o centro do rosto cai dentro do corte (fração da altura do corte)
+
+
+def _par(n: float) -> int:
+    return int(n) // 2 * 2
+
+
+def caminho(trilha: dict, zoom: float = ZOOM_PADRAO) -> dict:
+    """-> {"cw","ch","pontos":[(t,x,y)], "sem_rosto_s": segundos de tomada sem rosto}"""
+    W, H = int(trilha["largura"]), int(trilha["altura"])
+    cw, ch = _par(W / zoom), _par(H / zoom)
+    pts: list[tuple[float, int, int]] = []
+    sem = 0.0
+    for tom in trilha["tomadas"]:
+        pontos = tom.get("pontos") or []
+        if not pontos:
+            sem += float(tom["ate"]) - float(tom["de"])
+            for k in range(int((tom["ate"] - tom["de"]) / 0.1) + 1):
+                pts.append((round(tom["de"] + k * 0.1, 3), (W - cw) // 2, (H - ch) // 2))
+            continue
+        for t, cx, cy, w, h, medido in pontos:
+            x = min(max(cx * W - cw / 2, 0), W - cw)
+            y = min(max(cy * H - ch * OLHO_NA_ALTURA, 0), H - ch)
+            pts.append((float(t), int(round(x)), int(round(y))))
+    pts.sort()
+    return {"cw": cw, "ch": ch, "pontos": pts, "sem_rosto_s": round(sem, 2)}
+
+
+def escrever_sendcmd(cam: dict, destino: Path, alvo: str = "cam") -> Path:
+    linhas = []
+    for t, x, y in cam["pontos"]:
+        linhas.append(f"{t:.3f} crop@{alvo} x {x}, crop@{alvo} y {y};")
+    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(cam: dict, sendcmd: Path, saida_w: int, saida_h: int) -> str:
+    x0, y0 = (cam["pontos"][0][1], cam["pontos"][0][2]) if cam["pontos"] else (0, 0)
+    return (f"sendcmd=f='{_esc(sendcmd)}',crop@cam={cam['cw']}:{cam['ch']}:{x0}:{y0}:exact=1,"
+            f"scale={saida_w}:{saida_h}:flags=lanczos,setsar=1")
+
+
+def relatorio(cam: dict) -> dict:
+    xs = [p[1] for p in cam["pontos"]]
+    ys = [p[2] for p in cam["pontos"]]
+    salto = max([abs(xs[i + 1] - xs[i]) for i in range(len(xs) - 1)] or [0])
+    return {"zoom": round(1080 / cam["cw"], 3), "pontos": len(cam["pontos"]), "x_min": min(xs, default=0), "x_max": max(xs, default=0),
+            "y_min": min(ys, default=0), "y_max": max(ys, default=0), "maior_salto_px_por_0_1s": salto,
+            "sem_rosto_s": cam["sem_rosto_s"]}
+
+
+if __name__ == "__main__":
+    import sys
+
+    tr = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
+    c = caminho(tr)
+    print(json.dumps(relatorio(c), ensure_ascii=False))

package/editor/helpers/face_layout.py

@@ -98,6 +98,26 @@ def _detector(w: int, h: int):
 
 
 def detect_array(bgr) -> dict | None:
+    """MediaPipe (Edit 2.0) when installed, YuNet otherwise or when MediaPipe sees nothing."""
+    usou_mp = False
+    try:
+        import face_mediapipe  # noqa: PLC0415
+        if face_mediapipe.disponivel():
+            usou_mp = True
+            r = face_mediapipe.detect_array(bgr)
+            if r is not None:
+                return r
+    except Exception:
+        pass
+    try:
+        return detect_array_yunet(bgr)
+    except FaceLayoutError:
+        if usou_mp:       # o MediaPipe respondeu "sem rosto" e o YuNet não está instalado: sem rosto mesmo
+            return None
+        raise
+
+
+def detect_array_yunet(bgr) -> dict | None:
     """The speaker's face in one BGR frame (numpy HxWx3): the largest confident box.
 
     -> {"x0", "y0", "x1", "y1", "eyes_y", "mouth_y", "score"} as fractions of the frame, or None.

package/editor/helpers/face_mediapipe.py

@@ -0,0 +1,147 @@
+"""Edit 2.0, peça 3: detector de rosto MediaPipe (Apache-2.0, BlazeFace short-range) para o enquadramento.
+
+Mesmo retorno do `face_layout.detect_array` ({x0,y0,x1,y1,eyes_y,mouth_y,score}, frações do quadro), então a
+câmera suavizada que já existe (rastrear_rosto.py: mediana, zona morta, transição de 0,5 s; ideia de câmera suave
+do pyautoflip, MIT, sem código copiado) segue igual e só troca quem enxerga o rosto. Sem o MediaPipe, o
+face_layout continua no YuNet.
+
+Também mede "% do tempo com rosto enquadrado" de um vídeo (`enquadrado`): rosto inteiro dentro da zona segura.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+from pathlib import Path
+
+MODELO = Path(os.environ.get("PRIMOCODE_ROSTO_MODELO") or Path(__file__).resolve().parent.parent / "assets" / "models" / "blaze_face_short_range.tflite")
+SCORE_MIN = 0.6
+MIN_FACE_H = 0.06
+# zona onde um rosto "bem enquadrado" fica (frações do quadro): centro nos 2/3 do meio, rosto inteiro no quadro
+ZONA_X = (0.25, 0.75)
+ZONA_Y = (0.12, 0.60)
+_DET = {}
+
+
+MODELO_URL = "https://storage.googleapis.com/mediapipe-models/face_detector/blaze_face_short_range/float16/1/blaze_face_short_range.tflite"
+MODELO_SHA256 = "b4578f35940bf5a1a655214a1cce5cab13eba73c1297cd78e1a04c2380b0152f"   # o mesmo de assets/baixar.json
+
+
+def garantir_modelo() -> bool:
+    """O modelo (230 KB) não vai no pacote: baixa na primeira vez (como o assets/baixar.json) e confere o sha256."""
+    if MODELO.exists():
+        return True
+    try:
+        import hashlib  # noqa: PLC0415
+        import urllib.request  # noqa: PLC0415
+
+        dados = urllib.request.urlopen(MODELO_URL, timeout=30).read()
+        if hashlib.sha256(dados).hexdigest() != MODELO_SHA256:
+            return False
+        MODELO.parent.mkdir(parents=True, exist_ok=True)
+        MODELO.write_bytes(dados)
+        return True
+    except Exception:
+        return False
+
+
+def disponivel() -> bool:
+    if os.environ.get("PRIMOCODE_ROSTO") == "yunet" or not garantir_modelo():
+        return False
+    try:
+        import mediapipe  # noqa: F401, PLC0415
+        return True
+    except Exception:
+        return False
+
+
+def _detector():
+    if "d" not in _DET:
+        import mediapipe as mp  # noqa: PLC0415
+        from mediapipe.tasks import python as mpt  # noqa: PLC0415
+        from mediapipe.tasks.python import vision  # noqa: PLC0415
+
+        opts = vision.FaceDetectorOptions(base_options=mpt.BaseOptions(model_asset_path=str(MODELO)),
+                                          min_detection_confidence=SCORE_MIN)
+        _DET["d"] = (vision.FaceDetector.create_from_options(opts), mp)
+    return _DET["d"]
+
+
+def escolher(deteccoes: list[dict], w: int, h: int) -> dict | None:
+    """A maior caixa confiável. `deteccoes`: [{"x","y","w","h","score","eyes_y","mouth_y"}] em pixels."""
+    melhor = None
+    for d in deteccoes:
+        if d["score"] < SCORE_MIN or d["h"] < MIN_FACE_H * h:
+            continue
+        if melhor is None or d["w"] * d["h"] > melhor["w"] * melhor["h"]:
+            melhor = d
+    if melhor is None:
+        return None
+    return {"x0": max(0.0, melhor["x"] / w), "y0": max(0.0, melhor["y"] / h),
+            "x1": min(1.0, (melhor["x"] + melhor["w"]) / w), "y1": min(1.0, (melhor["y"] + melhor["h"]) / h),
+            "eyes_y": melhor["eyes_y"] / h, "mouth_y": melhor["mouth_y"] / h, "score": melhor["score"]}
+
+
+def detect_array(bgr) -> dict | None:
+    import numpy as np  # noqa: PLC0415
+
+    det, mp = _detector()
+    h, w = bgr.shape[:2]
+    rgb = np.ascontiguousarray(bgr[:, :, ::-1])
+    res = det.detect(mp.Image(image_format=mp.ImageFormat.SRGB, data=rgb))
+    out = []
+    for d in res.detections:
+        bb = d.bounding_box
+        kp = d.keypoints  # olho dir., olho esq., nariz, centro da boca, orelhas
+        score = d.categories[0].score if d.categories else 0.0
+        if len(kp) >= 4:
+            eyes, mouth = (kp[0].y + kp[1].y) / 2 * h, kp[3].y * h
+        else:
+            eyes, mouth = bb.origin_y + bb.height * 0.4, bb.origin_y + bb.height * 0.8
+        out.append({"x": bb.origin_x, "y": bb.origin_y, "w": bb.width, "h": bb.height, "score": score,
+                    "eyes_y": eyes, "mouth_y": mouth})
+    return escolher(out, w, h)
+
+
+def enquadrado(rosto: dict | None) -> bool:
+    if not rosto:
+        return False
+    cx, cy = (rosto["x0"] + rosto["x1"]) / 2, (rosto["y0"] + rosto["y1"]) / 2
+    return ZONA_X[0] <= cx <= ZONA_X[1] and ZONA_Y[0] <= cy <= ZONA_Y[1] and rosto["x0"] > 0.0 and rosto["x1"] < 1.0 and rosto["y0"] > 0.0
+
+
+def percentual_enquadrado(video: Path, por_segundo: float = 4.0, janelas: list[tuple[float, float]] | None = None) -> dict:
+    """% dos quadros amostrados (4 por segundo) em que há rosto dentro da zona. `janelas`: só esses trechos."""
+    import numpy as np  # noqa: PLC0415
+
+    from common import probe_video  # noqa: PLC0415
+
+    info = probe_video(video)
+    w0, h0 = int(info["width"]), int(info["height"])
+    esc = min(1.0, 540 / min(w0, h0))
+    w, h = max(2, int(round(w0 * esc / 2)) * 2), max(2, int(round(h0 * esc / 2)) * 2)
+    cmd = ["ffmpeg", "-hide_banner", "-nostdin", "-v", "error", "-i", str(video), "-vf", f"fps={por_segundo},scale={w}:{h}",
+           "-an", "-f", "rawvideo", "-pix_fmt", "bgr24", "-"]
+    p = subprocess.Popen(cmd, stdout=subprocess.PIPE)
+    tam = w * h * 3
+    n = com = bem = 0
+    dx, dy = [], []
+    while True:
+        buf = p.stdout.read(tam)
+        if len(buf) < tam:
+            break
+        t = n / por_segundo
+        n += 1
+        if janelas and not any(a <= t <= b for a, b in janelas):
+            continue
+        r = detect_array(np.frombuffer(buf, np.uint8).reshape(h, w, 3))
+        com += r is not None
+        bem += enquadrado(r)
+        if r:
+            dx.append(abs((r["x0"] + r["x1"]) / 2 - 0.5) * 100)
+            dy.append(abs((r["y0"] + r["y1"]) / 2 - 0.40) * 100)
+    p.wait()
+    total = max(1, n if not janelas else sum(1 for k in range(n) if any(a <= k / por_segundo <= b for a, b in janelas)))
+    return {"quadros": total, "com_rosto_pct": round(100 * com / total, 1), "enquadrado_pct": round(100 * bem / total, 1),
+            "desvio_centro_x_pct": round(sum(dx) / len(dx), 1) if dx else None,
+            "desvio_altura_pct": round(sum(dy) / len(dy), 1) if dy else None}

package/editor/helpers/instalar_df.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+# Cria o ambiente do DeepFilterNet (MIT ou Apache-2.0) fora do ambiente do editor: ele pede numpy<2 e torch 2.5.
+set -euo pipefail
+DEST="${PRIMOCODE_DF_VENV:-$HOME/.primocode/editor/df-venv}"
+uv venv "$DEST" --python 3.12
+uv pip install --python "$DEST/bin/python" deepfilternet "torch<2.6" "torchaudio<2.6" "numpy<2" soundfile
+echo "DeepFilterNet pronto em $DEST"