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
+127
View File
@@ -0,0 +1,127 @@
"""Equipe de IA do Clipador (doc/clipador/EQUIPE-IA.md): quatro papéis, cada um com a sua IA.
- **varredura** (`scan`): assiste a live por janelas e propõe momentos (e descreve a tela para a linha do tempo);
- **analista** (`analyst`): diz O QUE aconteceu no trecho candidato (cruza tela, fala e chat);
- **editor** (`editor`): decide se vira corte, escolhe o trecho e escreve título/legenda — não pode ser desligado;
- **juiz** (`judge`): só texto, vê só o que vai no corte final e confere se ele tem CONTEXTO (começo, desfecho,
funciona sozinho). Quem decide pelas respostas é o código (`context_judge.decide`).
Cada papel tem provedor + modelo (+ esforço de raciocínio no Codex), liga/desliga e as **instruções do
administrador** (texto extra somado às instruções padrão, que continuam no código). Gravado na tabela `settings`
com a chave `judge.roles` (JSON). Sem essa chave (banco de antes), a configuração antiga vira a de todos os papéis:
o provedor/modelo único de hoje vale para todos e o "modelo do analista" que já existia é respeitado.
"""
from __future__ import annotations
import copy
import json
SETTINGS_KEY = "judge.roles"
ROLES = ("scan", "analyst", "editor", "judge")
ROLE_NAMES = {"scan": "Varredura", "analyst": "Analista", "editor": "Editor", "judge": "Juiz"}
ROLE_PROVIDERS = ("codex", "claude", "gemini")
# Esforço de raciocínio: só o Codex aceita (`model_reasoning_effort`). "" = padrão (low, o de sempre).
EFFORTS = ("", "low", "medium", "high")
# Imagens da varredura e do analista: mosaico 4×2 numa imagem só (novo), frames soltos (antigo) ou nenhuma.
IMAGE_MODES = ("mosaic", "frames", "none")
IMAGE_ROLES = ("scan", "analyst")
EXTRA_MAX = 2000
# Perguntas sim/não do juiz (doc/clipador/PESQUISA-JUIZ.md §6). As críticas decidem; as outras só baixam a nota.
CHECKS = ("setup", "payoff", "who_what", "standalone", "intelligible", "faithful", "strong_open")
CHECK_NAMES = {"setup": "começo (setup)", "payoff": "desfecho", "who_what": "quem/o quê", "standalone": "funciona sozinho",
"intelligible": "fala clara", "faithful": "título fiel", "strong_open": "abertura forte"}
DEFAULT_CRITICAL = ("setup", "payoff", "standalone")
DEFAULT_PENALTY = 0.5
def _role(provider: str, model: str = "", effort: str = "", enabled: bool = True) -> dict:
return {"enabled": enabled, "provider": provider, "model": model, "effort": effort, "extra": ""}
def default_roles(provider: str = "codex", model: str = "", analyst_model: str = "") -> dict:
"""Configuração de partida: todos os papéis na mesma IA (como era antes). O juiz pensa um pouco mais
(esforço médio no Codex), como a pesquisa recomenda; os outros continuam no esforço baixo de sempre."""
provider = provider if provider in ROLE_PROVIDERS else "codex"
roles = {
"scan": _role(provider, model),
"analyst": _role(provider, analyst_model or model),
"editor": _role(provider, model),
"judge": _role(provider, model, "medium" if provider == "codex" else ""),
}
roles["scan"]["images"] = "mosaic"
roles["analyst"]["images"] = "mosaic"
roles["judge"] |= {"critical": list(DEFAULT_CRITICAL), "allowFix": True, "allowContextLine": True,
"penalty": DEFAULT_PENALTY}
return roles
def _text(value: object, limit: int) -> str:
return str(value or "").replace("\r\n", "\n").strip()[:limit]
def normalize_roles(raw: object, base: dict | None = None) -> dict:
"""Valida campo a campo sobre `base` (padrão: `default_roles()`). O que vier errado fica como estava.
O editor nunca desliga (é quem decide se vira corte)."""
roles = copy.deepcopy(base or default_roles())
if not isinstance(raw, dict):
return roles
for name in ROLES:
item = raw.get(name)
if not isinstance(item, dict):
continue
role = roles[name]
if isinstance(item.get("enabled"), bool):
role["enabled"] = item["enabled"]
if item.get("provider") in ROLE_PROVIDERS:
if item["provider"] != role["provider"] and "model" not in item:
role["model"] = "" # trocou de provedor sem dizer o modelo: o padrão do provedor novo
role["provider"] = item["provider"]
if isinstance(item.get("model"), str):
model = item["model"].strip()[:80]
if all(c.isalnum() or c in "._:-" for c in model):
role["model"] = model
if item.get("effort") in EFFORTS:
role["effort"] = item["effort"]
if "extra" in item:
role["extra"] = _text(item.get("extra"), EXTRA_MAX)
if name in IMAGE_ROLES and item.get("images") in IMAGE_MODES:
role["images"] = item["images"]
if name == "judge":
critical = item.get("critical")
if isinstance(critical, list):
role["critical"] = [c for c in CHECKS if c in critical]
for key in ("allowFix", "allowContextLine"):
if isinstance(item.get(key), bool):
role[key] = item[key]
penalty = item.get("penalty")
if isinstance(penalty, (int, float)) and not isinstance(penalty, bool) and 0 <= penalty <= 3:
role["penalty"] = float(penalty)
roles["editor"]["enabled"] = True
return roles
def from_settings(saved: dict[str, str], provider: str, model: str) -> dict:
"""Papéis gravados (`judge.roles`) ou, sem eles, a MIGRAÇÃO da configuração antiga: `judge_provider`/
`judge_model` viram os de todos os papéis e `judge_analyst_model` (se havia) fica com o analista.
`provider`/`model` = os valores iniciais do .env, para quando nem a antiga existe."""
legacy_provider = saved.get("judge_provider", provider)
legacy_model = saved.get("judge_model", model) or ""
base = default_roles(legacy_provider, legacy_model, saved.get("judge_analyst_model", "") or "")
raw = saved.get(SETTINGS_KEY)
if not raw:
return base
try:
return normalize_roles(json.loads(raw), base)
except ValueError:
return base
def admin_notes(role: dict, lang: str = "pt") -> str:
"""Bloco que vai DEPOIS das instruções padrão. Os juízes em inglês entendem português: o dono escreve como quiser."""
extra = (role or {}).get("extra", "").strip()
if not extra:
return ""
title = ("Admin notes (may be written in Portuguese; when they conflict with the rules above, they win):"
if lang == "en" else "Instruções do administrador (quando conflitarem com as regras acima, valem estas):")
return f"\n\n{title}\n{extra}"