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
+298
View File
@@ -0,0 +1,298 @@
"""Linha do tempo em JSON curto (v1): o vídeo "lido" como texto barato para a IA (doc/clipador/EQUIPE-IA.md).
Uma linha JSON por instante (JSON Lines), chaves curtas — a legenda das chaves vai uma vez no prompt —, segundos
inteiros da gravação e campos vazios omitidos. Só com o que já existe (nenhum modelo novo):
| chave | conteúdo | de onde vem |
| --- | --- | --- |
| `t`, `d` | início e duração da entrada | pausas da fala, troca de falante ou no máximo 8 s |
| `v` | o que está na tela (frase curta) | a IA que já vê os frames (varredura/analista), guardada em `scene_notes` |
| `sp` | fala literal (até ~25 palavras); `[other1] …` = outra pessoa | Whisper + falantes |
| `face` | expressão do streamer + intensidade 0–9 (`laugh.7`) | série do rosto (face.FaceService.dense + reaction) |
| `lvl` | volume relativo ao normal da live, 0–9 (3 = normal) | dBFS por segundo já medido |
| `chat` | `"mensagens\\|emote×n\\|frase mais repetida"` | chat da sessão |
| `out` | 1 = fora do corte (o espectador NÃO vê) — só no prompt do juiz | — |
Comportamento antigo (transcrição + chat + frames soltos) continua atrás da opção `timelineJson` (intel.opts).
"""
from __future__ import annotations
import json
import logging
import re
import statistics
from collections import Counter
from dataclasses import dataclass, field
from typing import TYPE_CHECKING
from .scoring import ChatMessage, Word
if TYPE_CHECKING: # pragma: no cover
from .worker import Engine
log = logging.getLogger("cenaforge_clipper.timeline")
STEP_MAX_S = 8.0 # uma entrada nunca passa disso (gameplay contínuo quase não tem corte de plano)
COARSE_STEP_S = 20.0 # trecho de "volta" da varredura: resumido
PAUSE_S = 1.2 # pausa na fala que fecha a entrada (se ela já tem MIN_ENTRY_S)
MIN_ENTRY_S = 4.0
FACE_MIN = 3 # expressão abaixo disso (z do rosto) é ruído: fica de fora
LOUD_LVL, QUIET_LVL = 6, 1 # volume só aparece quando foge do normal (alto ou silêncio)
PHRASE_CHARS = 32
SP_WORDS = 25
COARSE_SP_WORDS = 12
NORMAL_LVL = 3
# Rótulos do rosto (reaction.label) → token curto em inglês (as chaves e valores da linha do tempo são em inglês).
FACE_TOKENS = {"risada": "laugh", "grito": "shout", "susto": "scare", "choque": "shock", "confuso": "confused",
"raiva": "anger"}
LEGEND = {
"en": ("Timeline (JSON Lines; one entry per moment; seconds of the recording). Keys: t=start, d=duration, "
"v=what is on screen (short), sp=speech, literal ([other1] = someone else talking, not the streamer), "
"face=streamer expression.intensity 0-9, lvl=loudness vs. the stream's normal 0-9 (3=normal), "
"chat=messages|top emote×count|most repeated message, out=1 → OUTSIDE the clip (the viewer does NOT see it). "
"Missing key = nothing notable."),
"pt": ("Linha do tempo (JSON Lines; uma entrada por instante; segundos da gravação). Chaves: t=início, d=duração, "
"v=o que está na tela (curto), sp=fala literal ([other1] = outra pessoa falando, não o streamer), "
"face=expressão do streamer.intensidade 0-9, lvl=volume em relação ao normal da live 0-9 (3=normal), "
"chat=mensagens|emote mais usado×vezes|mensagem mais repetida, out=1 → FORA do corte (o espectador NÃO vê). "
"Chave ausente = nada a notar."),
}
@dataclass
class Evidence:
"""Tudo que a linha do tempo de uma janela usa. `face` = (segundo, token, intensidade z); `scenes` = (t, texto)."""
words: list[Word]
chat: list[ChatMessage]
loudness: list[float | None]
face: list[tuple[int, str, float]] = field(default_factory=list)
scenes: list[tuple[float, str]] = field(default_factory=list)
# ---------------------------------------------------------------- coleta (motor → Evidence)
def face_marks(engine: "Engine", session: dict, lo: float, hi: float) -> list[tuple[int, str, float]]:
"""Expressões do streamer por segundo em [lo, hi], pelo que o rastreio já gravou (sem rodar nada novo).
Sem câmera, rastreio desligado ou plano B sem expressões: lista vazia."""
try:
from . import reaction
from .face import OpenSeeFaceTracker
face = engine.face
if not face.enabled or not face.has_cam(session):
return []
if face.session_backend(session["id"]) == OpenSeeFaceTracker.name:
return []
seconds = face.dense(session["id"], max(0.0, lo - 240), hi)
if not any(s.smile is not None for s in seconds if lo <= s.t <= hi):
return []
zs = reaction.channel_z(seconds, face.params)
signal = reaction.reaction_signal(seconds, params=face.params)
marks = []
for second, z, value in zip(seconds, zs, signal):
if not lo <= second.t <= hi or z is None:
continue
label = reaction.label(second, z, face.params)
if label and label != "neutro":
marks.append((int(second.t), FACE_TOKENS.get(label, label), float(value or 0.0)))
return marks
except Exception as exc: # noqa: BLE001 - sem rosto a linha do tempo segue sem `face`
log.info("rosto para a linha do tempo indisponível: %s", exc)
return []
def scene_lines(engine: "Engine", session_id: int, lo: float, hi: float) -> list[tuple[float, str]]:
"""Frases de tela guardadas (varredura e analista). Do analista primeiro quando os dois descreveram o mesmo t."""
rows = engine.db.all("SELECT t, source, text FROM scene_notes WHERE session_id = ? AND t >= ? AND t <= ? ORDER BY t",
session_id, lo, hi)
rows.sort(key=lambda r: (r["t"], r["source"] != "analyst"))
return [(float(r["t"]), r["text"]) for r in rows]
def save_scene_lines(engine: "Engine", session_id: int, source: str, lines: object,
tiles: list[float]) -> int:
"""Grava as frases `v` que a IA escreveu para cada quadro (`n` = nº do quadro, 1 = primeiro). Devolve quantas."""
if not isinstance(lines, list) or not tiles:
return 0
rows = []
for item in lines:
if not isinstance(item, dict):
continue
try:
n = int(item.get("n"))
except (TypeError, ValueError):
continue
text = " ".join(str(item.get("v") or "").split())[:120]
if 1 <= n <= len(tiles) and text:
rows.append((session_id, round(tiles[n - 1], 1), source, text, _now()))
if rows:
engine.db.many("INSERT INTO scene_notes (session_id, t, source, text, created_at) VALUES (?, ?, ?, ?, ?)"
" ON CONFLICT (session_id, t, source) DO UPDATE SET text = excluded.text", rows)
return len(rows)
def _now() -> str:
from .db import now
return now()
def collect(engine: "Engine", session: dict, tl: dict, lo: float, hi: float) -> Evidence:
"""Evidência da janela [lo, hi] a partir da linha do tempo já carregada (`Engine.load_timeline`)."""
return Evidence(words=[w for w in tl["words"] if lo - 1 <= w.start <= hi + 1],
chat=[m for m in tl["chat"] if lo - 1 <= m.t <= hi + 1],
loudness=tl["loudness"], face=face_marks(engine, session, lo, hi),
scenes=scene_lines(engine, session["id"], lo, hi))
# ---------------------------------------------------------------- entradas
def boundaries(words: list[Word], lo: float, hi: float, step: float = STEP_MAX_S, split_speech: bool = True) -> list[float]:
"""Onde cada entrada começa: pausa na fala, troca de quem fala ou no máximo `step` segundos.
`split_speech=False` (resumo): só pelo passo."""
cuts = [lo]
last_end: float | None = None
last_sp: str | None = None
for w in sorted((w for w in words if lo <= w.start < hi), key=lambda w: w.start):
while w.start - cuts[-1] > step:
cuts.append(cuts[-1] + step)
cur = cuts[-1]
speaker = w.speaker or "streamer"
new_speaker = last_sp is not None and speaker != last_sp
pause = last_end is not None and w.start - last_end > PAUSE_S and w.start - cur >= MIN_ENTRY_S
if ((split_speech and (new_speaker or pause)) or w.start - cur >= step) and w.start > cur + 0.5:
cuts.append(w.start)
last_end, last_sp = w.end, speaker
while hi - cuts[-1] > step:
cuts.append(cuts[-1] + step)
if hi - cuts[-1] < 0.5 and len(cuts) > 1:
cuts.pop()
return cuts + [hi]
def _speech(words: list[Word], limit: int) -> str:
parts: list[str] = []
current = None
count = 0
for w in words:
speaker = w.speaker or "streamer"
if speaker != current:
if speaker != "streamer":
parts.append(f"[{speaker}]")
elif current is not None:
parts.append("[streamer]")
current = speaker
parts.append(w.word.strip())
count += 1
if count >= limit:
parts.append("…")
break
return " ".join(p for p in parts if p)
def _chat(messages: list[ChatMessage], coarse: bool) -> str:
if not messages:
return ""
emotes = Counter(e for m in messages for e in set(m.emotes))
top = ""
if emotes:
name, n = emotes.most_common(1)[0]
top = f"{name}×{n}"
phrase = ""
if not coarse:
# Só o que o chat REPETE (reação coletiva); resposta a alguém (@) e comando (!) não contam.
texts = Counter(re.sub(r"\s+", " ", m.text.strip().lower())[:PHRASE_CHARS] for m in messages
if m.text.strip() and not m.text.lstrip().startswith(("@", "!")))
if texts:
text, n = texts.most_common(1)[0]
if n >= 2:
phrase = text
return "|".join((str(len(messages)), top, phrase)).rstrip("|")
def _level(loudness: list[float | None], a: float, b: float, normal: float | None) -> int | None:
values = [v for v in loudness[max(0, int(a)): max(int(a) + 1, int(b))] if v is not None]
if not values or normal is None:
return None
return max(0, min(9, round(NORMAL_LVL + (max(values) - normal) / 4)))
def normal_level(loudness: list[float | None], lo: float, hi: float) -> float | None:
"""Volume "normal" da live em volta da janela (mediana dos segundos com som)."""
values = [v for v in loudness[max(0, int(lo) - 120): int(hi) + 1] if v is not None and v > -60]
return statistics.median(values) if values else None
def entries(ev: Evidence, lo: float, hi: float, *, coarse: bool = False, clip: tuple[float, float] | None = None,
sp_words: int | None = None) -> list[dict]:
"""Entradas da janela. `coarse` = resumo (passo maior, fala curta, sem rosto/volume baixos). `clip` = (início,
fim) do corte: as entradas fora dele saem marcadas `out: 1` (prompt do juiz: o espectador não vê) e nenhuma
entrada atravessa o início ou o fim do corte."""
if clip is not None:
start, end = clip
out_items: list[dict] = []
for a, b, outside in ((lo, min(start, hi), True), (max(lo, start), min(end, hi), False), (max(lo, end), hi, True)):
if b - a < 0.3:
continue
for item in entries(ev, a, b, coarse=coarse, sp_words=sp_words):
out_items.append({"t": item.pop("t"), "d": item.pop("d"), **({"out": 1} if outside else {}), **item})
return out_items
step = COARSE_STEP_S if coarse else STEP_MAX_S
limit = sp_words or (COARSE_SP_WORDS if coarse else SP_WORDS)
cuts = boundaries(ev.words, lo, hi, step, split_speech=not coarse)
normal = normal_level(ev.loudness, lo, hi)
out: list[dict] = []
used_scenes: set[int] = set()
for a, b in zip(cuts, cuts[1:]):
if b - a < 0.3:
continue
item: dict = {"t": int(round(a)), "d": max(1, int(round(b - a)))}
scenes = [(i, text) for i, (t, text) in enumerate(ev.scenes) if a <= t < b and i not in used_scenes]
if scenes:
used_scenes.update(i for i, _ in scenes[:2])
item["v"] = " / ".join(dict.fromkeys(text for _, text in scenes[:2]))
words = [w for w in ev.words if a <= w.start < b]
if words:
item["sp"] = _speech(words, limit)
marks = [m for m in ev.face if a <= m[0] < b]
if marks:
_t, token, value = max(marks, key=lambda m: m[2])
intensity = max(0, min(9, round(value)))
if intensity >= (FACE_MIN + 1 if coarse else FACE_MIN):
item["face"] = f"{token}.{intensity}"
level = _level(ev.loudness, a, b, normal)
if level is not None and (level >= LOUD_LVL or level <= QUIET_LVL):
item["lvl"] = level
chat = _chat([m for m in ev.chat if a <= m.t < b], coarse)
if chat:
item["chat"] = chat
out.append(item)
return out
def render(header: dict, items: list[dict]) -> str:
dump = lambda obj: json.dumps(obj, ensure_ascii=False, separators=(",", ":")) # noqa: E731
return "\n".join([dump(header), *(dump(i) for i in items)])
def build(ev: Evidence, lo: float, hi: float, header: dict, *, budget_chars: int = 9000,
coarse_until: float | None = None, clip: tuple[float, float] | None = None) -> str:
"""JSONL da janela dentro do orçamento de caracteres: se passar, a fala de cada entrada encurta (25 → 12 → 6
palavras) e, por último, o trecho mais antigo vira resumo. `coarse_until` = a parte [lo, coarse_until) já sai
resumida (a "volta" da varredura)."""
for sp_words in (SP_WORDS, COARSE_SP_WORDS, 6):
items: list[dict] = []
split = coarse_until if coarse_until is not None and lo < coarse_until < hi else None
if split is not None:
items += entries(ev, lo, split, coarse=True, clip=clip)
items += entries(ev, split, hi, clip=clip, sp_words=sp_words)
else:
items += entries(ev, lo, hi, clip=clip, sp_words=sp_words)
text = render(header, items)
if len(text) <= budget_chars:
return text
return text[:budget_chars].rsplit("\n", 1)[0]
def legend(lang: str) -> str:
return LEGEND["en" if lang == "en" else "pt"]