Clipador: Equipe de IA (papéis com IA própria), juiz de contexto e linha do tempo JSON

- roles.py: varredura, analista, editor e juiz, cada um com provedor, modelo, raciocínio
  (Codex), liga/desliga (o editor não desliga) e instruções do administrador somadas às
  padrão; gravado em settings `judge.roles`, com migração automática da configuração antiga
  (provedor/modelo único vira o de todos; o modelo do analista é respeitado). A reserva vale
  por papel.
- Juiz de contexto (só texto): vê só o que vai no corte (+20 s antes/15 s depois marcados
  out=1), escreve o que um espectador frio entende e responde sim/não; context_judge.decide
  decide pelo código: aprova, ajusta o trecho e confere uma vez de novo, frase de contexto
  na tela (vira o texto de abertura do projeto) ou descarta com motivo em português
  (forçável). Corte manual só recebe aviso.
- timeline.py: linha do tempo JSON curta (fala com falante, chat, rosto, volume e a frase
  de tela que a varredura/analista escrevem ao ver os quadros, em scene_notes); mosaico 4x2
  (media.mosaic) no lugar dos quadros soltos; perfil do jogo enxuto. O formato antigo fica
  atrás da opção timelineJson.
- Medição (F0): ai_calls por chamada (papel, IA, tamanho do prompt/imagens, tokens quando a
  CLI informa: codex --json, claude e gemini), avaliação do dono (owner_label: bom/ruim/sem
  contexto) e GET /v1/judge/report (taxa de aprovação, decisões do juiz, concordância).
- Banco v17 (v16 fica reservada às expressões, como marcador sem efeito).
- Testes: test_roles.py e test_context_judge.py; os testes bloqueiam qualquer CLI de IA real.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Mateuus
2026-11-18 04:36:25 -03:00
co-authored by Claude Opus 5.5
parent 5be6c09c16
commit cb8450399d
17 changed files with 2081 additions and 116 deletions
+62 -13
View File
@@ -18,12 +18,13 @@ import time
from pathlib import Path
from typing import TYPE_CHECKING
from . import clip_delete, layout
from . import clip_delete, layout, media, timeline
from .db import loads, now
from .emotes import EmoteCatalog, extract, learn_delta, message_bonus
from .face import FaceError, FaceUnavailable
from .hashtags import fold, to_tag
from .judge import JudgeError, build_scan_prompt, game_context, lang_key, output_language_note
from .judge import (JudgeError, build_scan_prompt, build_scan_timeline_prompt, game_context, lang_key, lean_profile,
output_language_note)
from .scoring import fit_window
from .sources import parse_source
@@ -33,12 +34,17 @@ if TYPE_CHECKING: # pragma: no cover
log = logging.getLogger("cenaforge_clipper.intel")
# faceTrack: rastreio do rosto do streamer (face.py) — reforça/cria cortes e vai em texto para o analista.
OPTION_DEFAULTS = {"scanEnabled": True, "scanIntervalS": 180, "vision": True, "camDetect": True, "faceTrack": True}
# timelineJson: a IA lê o vídeo como linha do tempo JSON curta (timeline.py); desligado = transcrição + chat + frames
# soltos como antes (para comparar custo e qualidade — doc/clipador/EQUIPE-IA.md).
OPTION_DEFAULTS = {"scanEnabled": True, "scanIntervalS": 180, "vision": True, "camDetect": True, "faceTrack": True,
"timelineJson": True}
CAM_RETRY_S = 300 # câmera não achada enquanto grava: nova tentativa depois de mais 5 min de gravação
CAM_MAX_ATTEMPTS = 6 # falha sem rosto decidido (poucos quadros legíveis): no máximo isto de tentativas
GAME_CHECK_S = 600 # rechecar a categoria da live a cada 10 min (o streamer troca de jogo)
SCAN_FRAME_EVERY_S = 30
SCAN_MAX_FRAMES = 7
SCAN_MOSAIC_TILES = 8 # mosaico 4×2: 1 imagem por janela de varredura
SCAN_TIMELINE_CHARS = 9000
MEMORY_KEEP = 6
SCAN_MAX_MOMENTS = 2
SCAN_MIN_PROPOSAL = 4 # proposta da varredura abaixo disso nem vai aos juízes (economia)
@@ -474,10 +480,13 @@ class Intel:
"""'en' = fonte em inglês (juízes em inglês, tradução para o painel); 'pt' = o resto."""
return lang_key(session.get("language") or self.e.settings.language)
def context(self, session: dict) -> str:
def context(self, session: dict, lean: bool = False) -> str:
"""Contexto do jogo para os prompts. `lean` (linha do tempo JSON): perfil enxuto (judge.lean_profile)."""
memory = loads(session.get("memory_json"), [])
confirmed = session.get("game_source") == "user" and bool(session.get("game"))
profile = self.profile(session.get("game", "")) or (None if confirmed else self.profile(session.get("screen_game", "")))
if lean:
profile = lean_profile(profile)
text = game_context(session.get("game", ""), session.get("screen_game", ""), profile, session.get("title", ""),
" | ".join(m["summary"] for m in memory[-3:] if m.get("summary")), confirmed=confirmed,
lang=self.lang(session))
@@ -486,7 +495,7 @@ class Intel:
return f"{text}\n{note}" if note else text
# ---------------------------------------------------------------- frames
def frames(self, session: dict, times: list[float], tag: str) -> list[tuple[float, Path]]:
def frames(self, session: dict, times: list[float], tag: str, width: int = 768) -> list[tuple[float, Path]]:
if not self.opts["vision"]:
return []
segments = [(self.e.repo_path(s["file"]), s["start_s"], s["end_s"])
@@ -495,11 +504,31 @@ class Intel:
frames = []
for t in times:
try:
frames.append((t, self.e.grab_frame(segments, t, out_dir / f"{tag}-{int(t)}.jpg")))
frames.append((t, self.e.grab_frame(segments, t, out_dir / f"{tag}-{int(t)}.jpg", width)))
except Exception as exc: # noqa: BLE001 - sem frame a IA decide só pelo texto
log.info("frame %.0fs indisponível: %s", t, exc)
return frames
def visual(self, session: dict, times: list[float], tag: str, mode: str) -> tuple[list[Path], list[float], bool]:
"""Imagens para a IA: (arquivos, instante de cada quadro, é mosaico?). `mode`: "mosaic" = os quadros numa
grade 4×2 numa imagem só (384×216 cada); "frames" = soltos em 768 px (o antigo); "none" = nenhuma.
Mosaico que falha cai para os quadros soltos (a IA não fica sem ver a tela)."""
if mode == "none" or not self.opts["vision"] or not times:
return [], [], False
if mode != "mosaic":
frames = self.frames(session, times, tag)
return [p for _, p in frames], [t for t, _ in frames], False
frames = self.frames(session, times, f"{tag}m", width=media.MOSAIC_TILE_W)
if not frames:
return [], [], False
out = self.e.repo_path(session["dir"]) / "frames" / f"{tag}-mosaic-{int(frames[0][0])}.jpg"
try:
media.mosaic(self.e.settings.ffmpeg or "ffmpeg", [p for _, p in frames], out)
except Exception as exc: # noqa: BLE001 - sem mosaico, vão os quadros (pequenos) soltos
log.info("mosaico %s indisponível: %s", tag, exc)
return [p for _, p in frames], [t for t, _ in frames], False
return [out], [t for t, _ in frames], True
# ---------------------------------------------------------------- webcam
def maybe_detect_cam(self, session: dict) -> None:
"""Acha a câmera no início da sessão. A detecção local (YuNet) não precisa de IA, visão nem juiz ligados."""
@@ -633,19 +662,39 @@ class Intel:
cfg = self.settings_for(session)
dur = cfg["duration"]
back_lo = max(0.0, lo - dur["backtrackS"])
step = max(SCAN_FRAME_EVERY_S, (hi - lo) / SCAN_MAX_FRAMES)
times = [lo + step / 2 + i * step for i in range(int((hi - lo) // step) or 1)][:SCAN_MAX_FRAMES]
frames = self.frames(session, times, "scan")
use_timeline = bool(self.opts.get("timelineJson", True))
mode = self.e.judge.roles["scan"].get("images", "mosaic") if use_timeline else "frames"
if mode == "mosaic": # 8 quadros por igual na janela, numa imagem só
step = (hi - lo) / SCAN_MOSAIC_TILES
times = [lo + step / 2 + i * step for i in range(SCAN_MOSAIC_TILES)]
else:
step = max(SCAN_FRAME_EVERY_S, (hi - lo) / SCAN_MAX_FRAMES)
times = [lo + step / 2 + i * step for i in range(int((hi - lo) // step) or 1)][:SCAN_MAX_FRAMES]
images, tiles, mosaic = self.visual(session, times, "scan", mode)
existing = [(c["start_s"], c["end_s"], c["title"]) for c in self.e.db.all(
"SELECT start_s, end_s, title FROM clips WHERE session_id = ? AND end_s > ? AND start_s < ?", session["id"], back_lo, hi)]
existing += clip_delete.mark_spans(self.e.db, session["id"], back_lo, hi) # apagados não voltam pela varredura
prompt = build_scan_prompt(self.e.streamer_name(session), session["platform"], lo, hi, back_lo, tl["words"],
tl["chat"], self.context(session), frames, existing, dur["minS"], dur["maxS"],
lang=self.lang(session))
lang = self.lang(session)
if use_timeline:
# A "volta" (antes da janela) vai resumida: já foi vista na janela anterior.
ev = timeline.collect(self.e, session, tl, back_lo, hi)
text = timeline.build(ev, back_lo, hi, {"win": [int(lo), int(hi)], "back": int(back_lo), "src": lang},
budget_chars=SCAN_TIMELINE_CHARS, coarse_until=lo)
prompt = build_scan_timeline_prompt(self.e.streamer_name(session), session["platform"], lo, hi, back_lo,
self.context(session, lean=True), text, tiles, mosaic, existing, dur["minS"],
dur["maxS"], lang=lang)
else:
prompt = build_scan_prompt(self.e.streamer_name(session), session["platform"], lo, hi, back_lo, tl["words"],
tl["chat"], self.context(session), list(zip(tiles, images)), existing,
dur["minS"], dur["maxS"], lang=lang)
created = 0
try:
data = self.e.judge.scan(prompt, [p for _, p in frames], lang=self.lang(session))
run_mode = ("timeline" if use_timeline else "legacy") + f"+{'mosaic' if mosaic else mode}"
with self.e.judge.scope(session_id=session["id"], mode=run_mode):
data = self.e.judge.scan(prompt, images, lang=lang)
self.last_scan_error = None
# O que a varredura viu em cada quadro vira o `v` da linha do tempo (analista, editor e juiz reaproveitam).
timeline.save_scene_lines(self.e, session["id"], "scan", data.get("lines"), tiles)
except (JudgeError, json.JSONDecodeError) as exc:
# Avança mesmo assim: repetir a mesma janela com a CLI quebrada só gastaria cota.
self.last_scan_error = str(exc)[:300]