CenaForge: primeira versão pública

Gerador de vídeos narrativos (Godot + FFmpeg), painel Next.js, serviço de voz,
Clipador de lives e Publicador para YouTube, TikTok e Instagram.

Inclui a leitura das visualizações dos posts para o Dashboard e o botão
"Publicar no <rede>" nos cartões das publicações.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-17 16:35:09 -03:00
co-authored by Claude Opus 5.5
commit 84f30bbc2d
484 changed files with 74826 additions and 0 deletions
+507
View File
@@ -0,0 +1,507 @@
"""Inteligência do Clipador além da heurística: contexto do jogo, varredura da IA, webcam e emotes que aprendem.
Pedido do usuário (17/11/2026), depois de uma live com chat pequeno (skipnho, 0,15 msg/s) passar 15 min sem corte:
- a IA precisa saber QUE JOGO é (categoria da plataforma, título, chat e a própria tela) e conhecer o jogo
(pesquisa na web, guardada por jogo);
- a IA precisa VER a tela (frames) e procurar momentos sozinha, mesmo sem pico de chat (varredura);
- achar a webcam do streamer para o layout câmera-em-cima;
- emotes da Twitch/7TV/BTTV/FFZ contam como reação e ganham peso por canal conforme os cortes aprovados.
"""
from __future__ import annotations
import json
import logging
import re
import threading
import time
from pathlib import Path
from typing import TYPE_CHECKING
from . import clip_delete, layout
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
from .scoring import fit_window
from .sources import parse_source
if TYPE_CHECKING: # pragma: no cover
from .worker import Engine
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}
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
MEMORY_KEEP = 6
SCAN_MAX_MOMENTS = 2
SCAN_MIN_PROPOSAL = 4 # proposta da varredura abaixo disso nem vai aos juízes (economia)
class CamRetryLater(JudgeError):
"""Câmera local indisponível por um motivo passageiro (modelo/download): não é "sem câmera"."""
def game_id(name: str) -> str:
return re.sub(r"[^a-z0-9]+", "-", name.lower()).strip("-")[:60] or "desconhecido"
PROFILE_LISTS = ("mechanics", "clip_worthy", "avoid", "jargon", "news", "hashtags", "sources")
def clean_profile(raw: dict) -> dict:
"""Normaliza um perfil de jogo (vindo da IA ou da edição à mão): textos aparados, listas sem vazios/duplicados.
Hashtags viram tag de verdade ("rob run" → "#RobRun"; sem letra some), comparadas sem acento/maiúscula."""
raw = raw if isinstance(raw, dict) else {}
out: dict = {k: str(raw.get(k) or "").strip()[:limit] for k, limit in (("name", 120), ("summary", 1500), ("genre", 120))}
for key in PROFILE_LISTS:
items, seen = [], set()
for item in raw.get(key) or []:
text = str(item or "").strip()[:300]
if key == "hashtags":
text = to_tag(text) or ""
if text and fold(text) not in seen:
seen.add(fold(text))
items.append(text)
continue
if text and text.lower() not in seen:
seen.add(text.lower())
items.append(text)
out[key] = items[:20]
return out
class Intel:
def __init__(self, engine: "Engine"):
self.e = engine
self.catalog = EmoteCatalog()
self._weights: dict[str, tuple[float, dict[str, float]]] = {}
self._rooms_ready: set[str] = set()
self._game_checked: dict[int, float] = {}
self._cam_retry_at: dict[int, float] = {} # falha transitória da câmera local (modelo/download): só em memória
self.last_scan_error: str | None = None
saved = {r["key"]: r["value"] for r in engine.db.all("SELECT key, value FROM settings")}
self.opts = dict(OPTION_DEFAULTS)
for key in OPTION_DEFAULTS:
if f"opt_{key}" in saved:
self.opts[key] = json.loads(saved[f"opt_{key}"])
# ---------------------------------------------------------------- opções (painel)
def set_options(self, values: dict) -> dict:
clean = {}
for key, value in values.items():
if key not in OPTION_DEFAULTS or value is None:
continue
if key == "scanIntervalS":
value = int(value)
if not 60 <= value <= 900:
raise JudgeError("intervalo da varredura vai de 60 a 900 s")
else:
value = bool(value)
clean[key] = value
self.opts.update(clean)
self.e.db.many("INSERT INTO settings (key, value) VALUES (?, ?) ON CONFLICT (key) DO UPDATE SET value = excluded.value",
[(f"opt_{k}", json.dumps(v)) for k, v in clean.items()])
return dict(self.opts)
# ---------------------------------------------------------------- canal / configuração do corte
@staticmethod
def channel_key(session: dict) -> str:
source = parse_source(session["url"])
return source.channel_id if source.channel else ""
def settings_for(self, session: dict) -> dict:
channel = None
if session.get("channel_id"):
channel = self.e.db.get("SELECT settings_json FROM channels WHERE id = ?", session["channel_id"])
return layout.merge(loads(channel["settings_json"], {}) if channel else {}, loads(session.get("settings_json"), {}))
# ---------------------------------------------------------------- emotes
def ingest_chat(self, session_id: int, channel_key: str, room_id: str | None,
batch: list[tuple[float, str, str, list[str]]]) -> None:
if room_id:
if room_id not in self._rooms_ready:
self.e.db.run("UPDATE sessions SET room_id = ? WHERE id = ? AND room_id IS NULL", room_id, session_id)
# Baixa o catálogo do canal fora da linha do chat (APIs externas podem demorar).
self._rooms_ready.add(room_id)
threading.Thread(target=self.catalog.names, args=(room_id,), daemon=True).start()
catalog = self.catalog.cached(room_id)
rows, seen = [], []
for wall, user, text, twitch_emotes in batch:
found = extract(text, twitch_emotes, catalog)
rows.append((session_id, wall, user, text, json.dumps([n for n, _ in found], ensure_ascii=False) if found else None))
seen.extend(found)
self.e.db.many("INSERT INTO chat (session_id, wall, user, text, emotes) VALUES (?, ?, ?, ?, ?)", rows)
if channel_key and seen:
ts = now()
self.e.db.many(
"INSERT INTO emotes (channel_key, name, source, uses, weight, first_seen, last_seen) VALUES (?, ?, ?, 1, 0, ?, ?)"
" ON CONFLICT (channel_key, name) DO UPDATE SET uses = uses + 1, last_seen = excluded.last_seen",
[(channel_key, name, source, ts, ts) for name, source in seen])
def weights(self, channel_key: str) -> dict[str, float]:
cached = self._weights.get(channel_key)
if cached and time.time() - cached[0] < 30:
return cached[1]
rows = self.e.db.all("SELECT name, weight FROM emotes WHERE channel_key = ? AND weight != 0", channel_key)
weights = {r["name"]: r["weight"] for r in rows}
self._weights[channel_key] = (time.time(), weights)
return weights
def bonus(self, emotes: list[str], channel_key: str) -> float:
return message_bonus(emotes, self.weights(channel_key)) if emotes else 0.0
def learn_from_clip(self, clip: dict, positive: bool, factor: float = 1.0, mark: bool = False) -> int:
"""Emotes da reação do corte (−10 s a +6 s do pico) ganham (aprovado) ou perdem (rejeitado) peso no canal."""
session = self.e.db.get("SELECT * FROM sessions WHERE id = ?", clip["session_id"])
if not session or (mark and clip.get("learned")):
return 0
key = self.channel_key(session)
if not key:
return 0
tl = self.e.load_timeline(session["id"], max(0.0, clip["peak_s"] - 120))
names = {e for m in tl["chat"] if clip["peak_s"] - 10 <= m.t <= clip["peak_s"] + 6 for e in m.emotes}
delta = learn_delta(positive) * factor
self.e.db.many("UPDATE emotes SET weight = MAX(-1.0, MIN(3.0, weight + ?)) WHERE channel_key = ? AND name = ?",
[(delta, key, n) for n in names])
if mark:
self.e.db.run("UPDATE clips SET learned = 1 WHERE id = ?", clip["id"])
self._weights.pop(key, None)
return len(names)
# ---------------------------------------------------------------- jogo
def check_game(self, session: dict, force: bool = False) -> None:
"""Categoria atual da live (Streamlink) → jogo da sessão; troca registrada; perfil pesquisado se novo."""
if session["kind"] != "live":
return
last = self._game_checked.get(session["id"], 0)
if not force and time.time() - last < GAME_CHECK_S:
return
self._game_checked[session["id"]] = time.time()
meta = self.e.check_meta(session["url"])
if not meta:
return
if meta.get("title") and not session.get("title"):
self.e.db.run("UPDATE sessions SET title = ? WHERE id = ?", meta["title"][:200], session["id"])
category = (meta.get("category") or "").strip()
if category and category != session.get("game") and session.get("game_source") != "user":
self.set_game(session["id"], category, "platform")
def set_game(self, session_id: int, name: str, source: str) -> None:
session = self.e.db.get("SELECT * FROM sessions WHERE id = ?", session_id)
if not session:
return
history = loads(session["games_json"], [])
history.append({"game": name, "source": source, "atS": session["duration_s"], "at": now()})
self.e.db.run("UPDATE sessions SET game = ?, game_source = ?, games_json = ? WHERE id = ?",
name[:120], source, json.dumps(history[-20:], ensure_ascii=False), session_id)
gid = game_id(name)
if not self.e.db.get("SELECT 1 FROM games WHERE id = ?", gid):
self.e.db.run("INSERT INTO games (id, name, status) VALUES (?, ?, 'pending')", gid, name[:120])
def research_pending(self) -> None:
if not self.e.judge.enabled:
return # IA desligada: o jogo fica 'pending' até ligar (antes: um WARNING no log a cada 30 s)
for game in self.e.db.all("SELECT * FROM games WHERE status = 'pending' LIMIT 1"):
self.research(game["id"])
def research(self, gid: str) -> dict:
game = self.e.db.get("SELECT * FROM games WHERE id = ?", gid)
if not game:
raise JudgeError("jogo não encontrado")
if not self.e.judge.enabled:
raise JudgeError("IA desligada: ligue o Codex ou o Claude para pesquisar o jogo")
title = (self.e.db.get("SELECT title FROM sessions WHERE game = ? ORDER BY id DESC LIMIT 1", game["name"]) or {}).get("title", "")
notes = [n.get("text", "") for n in loads(game.get("notes_json"), []) if n.get("text")]
try:
profile = self.e.judge.research_game(game["name"], title, notes)
except (JudgeError, json.JSONDecodeError) as exc:
self.e.db.run("UPDATE games SET status = 'error', error = ? WHERE id = ?", str(exc)[:300], gid)
raise JudgeError(str(exc)) from exc
self.e.db.run("UPDATE games SET status = 'ready', profile_json = ?, error = NULL, model = ?, researched_at = ? WHERE id = ?",
json.dumps(profile, ensure_ascii=False), f"{self.e.judge.provider}:{self.e.judge.model}", now(), gid)
return profile
def save_profile(self, gid: str, profile: dict) -> dict:
"""Grava o perfil editado à mão no painel. Vale na hora para a IA (status 'ready')."""
if not self.e.db.get("SELECT 1 FROM games WHERE id = ?", gid):
raise JudgeError("jogo não encontrado")
clean = clean_profile(profile)
self.e.db.run("UPDATE games SET status = 'ready', profile_json = ?, error = NULL, edited_at = ? WHERE id = ?",
json.dumps(clean, ensure_ascii=False), now(), gid)
return clean
def refine(self, gid: str, instruction: str, search: bool = True, section: str = "",
history: list[dict] | None = None) -> tuple[dict, str]:
"""Pede à IA para acrescentar/corrigir algo no perfil (opcionalmente numa seção). O pedido fica guardado e
volta em toda pesquisa. Devolve (perfil, resposta curta da IA)."""
game = self.e.db.get("SELECT * FROM games WHERE id = ?", gid)
if not game:
raise JudgeError("jogo não encontrado")
if not self.e.judge.enabled:
raise JudgeError("IA desligada: ligue o Codex ou o Claude para editar o perfil pela IA")
current = loads(game["profile_json"], None) or clean_profile({"name": game["name"]})
try:
data = self.e.judge.refine_game(game["name"], current, instruction, search, section, history)
except json.JSONDecodeError as exc:
raise JudgeError(f"a IA devolveu um perfil inválido: {exc}") from exc
reply = str(data.get("reply") or "").strip()[:600]
profile = clean_profile(data)
notes = loads(game.get("notes_json"), [])
notes.append({"text": instruction, "at": now(), **({"section": section} if section else {})})
self.e.db.run("UPDATE games SET status = 'ready', profile_json = ?, error = NULL, notes_json = ?, edited_at = ?,"
" model = ? WHERE id = ?", json.dumps(profile, ensure_ascii=False),
json.dumps(notes[-30:], ensure_ascii=False), now(), f"{self.e.judge.provider}:{self.e.judge.model}", gid)
return profile, reply
def delete_note(self, gid: str, index: int) -> None:
"""Esquece um pedido (ele deixa de voltar nas próximas pesquisas; o perfil atual não muda)."""
game = self.e.db.get("SELECT notes_json FROM games WHERE id = ?", gid)
if not game:
raise JudgeError("jogo não encontrado")
notes = loads(game["notes_json"], [])
if 0 <= index < len(notes):
notes.pop(index)
self.e.db.run("UPDATE games SET notes_json = ? WHERE id = ?", json.dumps(notes, ensure_ascii=False), gid)
def profile(self, name: str) -> dict | None:
if not name:
return None
row = self.e.db.get("SELECT profile_json FROM games WHERE id = ? AND status = 'ready'", game_id(name))
return loads(row["profile_json"], None) if row else None
def session_game(self, session: dict) -> tuple[str, dict | None]:
"""(nome do jogo, perfil) da sessão — o mesmo critério do contexto: jogo confirmado por você vale sozinho;
senão a categoria e, sem perfil dela, o jogo que a IA viu na tela."""
confirmed = session.get("game_source") == "user" and bool(session.get("game"))
game, screen = session.get("game") or "", session.get("screen_game") or ""
profile = self.profile(game)
if profile or confirmed:
return game, profile
screen_profile = self.profile(screen) if screen.lower() not in ("", "desconhecido") else None
return (screen, screen_profile) if screen_profile else (game or ("" if screen.lower() == "desconhecido" else screen), None)
def context(self, session: dict) -> str:
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", "")))
return 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)
# ---------------------------------------------------------------- frames
def frames(self, session: dict, times: list[float], tag: str) -> list[tuple[float, Path]]:
if not self.opts["vision"]:
return []
segments = [(self.e.repo_path(s["file"]), s["start_s"], s["end_s"])
for s in self.e.db.all("SELECT * FROM segments WHERE session_id = ? AND deleted = 0 ORDER BY idx", session["id"])]
out_dir = self.e.repo_path(session["dir"]) / "frames"
frames = []
for t in times:
try:
frames.append((t, self.e.grab_frame(segments, t, out_dir / f"{tag}-{int(t)}.jpg")))
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
# ---------------------------------------------------------------- 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."""
if not self.opts["camDetect"] or time.time() < self._cam_retry_at.get(session["id"], 0.0):
return
saved = loads(session.get("cam_json"), None)
# Sem rosto na 1ª olhada (tela de "já volto" no começo da live): tenta de novo mais tarde enquanto grava.
# Falha sem rosto decidido (poucos quadros legíveis): tenta de novo pelo relógio, também em VOD/sessão parada.
due = saved and ((saved.get("retryAfterS") and session["duration_s"] >= saved["retryAfterS"])
or (saved.get("retryAt") is not None and time.time() >= saved["retryAt"]
and saved.get("attempts", 1) < CAM_MAX_ATTEMPTS))
if saved and not due:
return
analyzed = self.e.db.get("SELECT COUNT(*) AS n FROM segments WHERE session_id = ? AND analyzed = 1", session["id"])["n"]
if analyzed < 2:
return
if self.settings_for(session)["layout"]["cam"]:
self.e.db.run("UPDATE sessions SET cam_json = ? WHERE id = ?",
json.dumps({"skipped": "já definida", "source": "manual"}), session["id"])
return
try:
self.detect_cam(session["id"], apply=True)
except CamRetryLater as exc:
# Modelo indisponível/download falhou: nada a ver com a live. Não grava "sem câmera" (seria permanente e
# o rastreio marcaria tudo no_cam); tenta de novo em 5 min.
self._cam_retry_at[session["id"]] = time.time() + CAM_RETRY_S
log.warning("câmera da sessão %s: %s (nova tentativa em %d s)", session["id"], exc, CAM_RETRY_S)
except JudgeError as exc:
# Sem frame legível e sem IA: registra para não repetir a cada 30 s, com nova tentativa marcada
# (por tempo de gravação enquanto grava; pelo relógio em qualquer estado, até CAM_MAX_ATTEMPTS vezes).
attempts = (saved or {}).get("attempts", 0) + 1
self.e.db.run("UPDATE sessions SET cam_json = ? WHERE id = ?", json.dumps(
{"hasWebcam": False, "cam": None, "source": "yunet", "error": str(exc)[:200], "at": now(),
"retryAt": time.time() + CAM_RETRY_S, "attempts": attempts,
**({"retryAfterS": session["duration_s"] + CAM_RETRY_S} if session["status"] == "recording" else {})},
ensure_ascii=False), session["id"])
def detect_cam(self, session_id: int, apply: bool = False, use_ai: bool = False) -> dict:
"""Onde está a webcam. Primeiro local (YuNet + reaction.locate_cam, sem custo de IA); a IA só entra se o
local não achar rosto (e a IA estiver ligada com visão) ou se pedirem (`use_ai`). `cam_json.source` diz
quem achou: yunet | ai | manual."""
session = self.e.db.get("SELECT * FROM sessions WHERE id = ?", session_id)
if not session or session["duration_s"] < 5:
raise JudgeError("gravação curta demais para achar a câmera")
ai_ready = self.opts["vision"] and self.e.judge.enabled
local, local_error, transient = None, "", False
if not use_ai:
try:
local = self.e.face.locate(session)
except FaceUnavailable as exc: # modelo/biblioteca/download: passageiro, não é "sem câmera"
local_error, transient = str(exc), True
log.info("câmera local da sessão %s indisponível: %s", session_id, exc)
except FaceError as exc:
local_error = str(exc)
log.info("câmera local da sessão %s falhou: %s", session_id, exc)
if local is not None and (local["hasWebcam"] or not ai_ready):
result = local
if not local["hasWebcam"] and session["status"] == "recording":
result["retryAfterS"] = session["duration_s"] + CAM_RETRY_S
self.e.db.run("UPDATE sessions SET cam_json = ? WHERE id = ?", json.dumps(result, ensure_ascii=False), session_id)
# Câmera em tela cheia (só o streamer) não vira layout câmera-em-cima; o rastreio usa o quadro inteiro.
if local["hasWebcam"] and not local["fullFrame"] and apply:
try:
rect = layout.validate({"layout": {"cam": local["cam"]}})["layout"]["cam"]
except layout.LayoutError:
rect = None
if rect:
self._apply_cam(session, rect)
return result
if not ai_ready:
if transient:
raise CamRetryLater(f"detector de rosto indisponível agora ({local_error}); tente de novo em instantes")
raise JudgeError(f"não deu para achar a câmera sem a IA ({local_error or 'sem rosto'}); ligue a visão ou marque à mão")
d = session["duration_s"]
frames = self.frames(session, [d * 0.25, d * 0.55, max(1.0, d - 8)], "cam")
if not frames:
raise JudgeError("sem frames (visão desligada ou blocos apagados)")
data = self.e.judge.detect_cam([p for _, p in frames])
rect = None
if data.get("has_webcam"):
try:
rect = layout.validate({"layout": {"cam": {k: data[k] for k in ("x", "y", "w", "h")}}})["layout"]["cam"]
except layout.LayoutError:
rect = None
result = {"hasWebcam": bool(data.get("has_webcam")), "cam": rect, "gameOnScreen": data.get("game_on_screen", ""),
"frame": self.e.rel(frames[-1][1]), "at": now(), "source": "ai"}
self.e.db.run("UPDATE sessions SET cam_json = ? WHERE id = ?", json.dumps(result, ensure_ascii=False), session_id)
if rect and apply:
self._apply_cam(session, rect)
if result["gameOnScreen"] and result["gameOnScreen"].lower() not in ("desconhecido", "não identificável"):
self.e.db.run("UPDATE sessions SET screen_game = ? WHERE id = ?", result["gameOnScreen"][:120], session_id)
return result
def _apply_cam(self, session: dict, rect: dict) -> None:
"""Câmera achada vira padrão do canal (se o canal não tiver uma); sem canal, vale para a sessão."""
if session.get("channel_id"):
row = self.e.db.get("SELECT settings_json FROM channels WHERE id = ?", session["channel_id"])
current = loads(row["settings_json"], {}) if row else {}
if row and not (current.get("layout") or {}).get("cam"):
current.setdefault("layout", {})["cam"] = rect
self.e.db.run("UPDATE channels SET settings_json = ? WHERE id = ?", json.dumps(current), session["channel_id"])
return
current = loads(session.get("settings_json"), {})
if not (current.get("layout") or {}).get("cam"):
current.setdefault("layout", {})["cam"] = rect
self.e.db.run("UPDATE sessions SET settings_json = ? WHERE id = ?", json.dumps(current), session["id"])
# ---------------------------------------------------------------- varredura
def scan_due(self, session: dict, analyzed_until: float) -> tuple[float, float] | None:
if not (self.opts["scanEnabled"] and self.e.judge.enabled):
return None
if session["status"] == "recording" and session["kind"] == "vod":
return None # VOD baixa mais rápido que o tempo real: varre quando terminar
lo = session["scanned_until"]
hi = lo + self.opts["scanIntervalS"]
if hi <= analyzed_until:
return lo, hi
if session["status"] in ("processing", "stopped") and analyzed_until - lo >= 20:
return lo, analyzed_until # fim da gravação: varre o resto
return None
def scan_session(self, session: dict) -> int | None:
"""Varre a próxima janela pronta. None = nada a varrer agora; senão, quantos cortes criou."""
if not (self.opts["scanEnabled"] and self.e.judge.enabled):
return None
tl = self.e.load_timeline(session["id"], max(0.0, session["scanned_until"] - 200))
window = self.scan_due(session, tl["analyzedUntil"])
if not window:
return None
lo, hi = window
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")
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"])
created = 0
try:
data = self.e.judge.scan(prompt, [p for _, p in frames])
self.last_scan_error = None
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]
log.warning("varredura %s %.0f–%.0fs falhou: %s", session["id"], lo, hi, exc)
data = {"moments": [], "summary": "", "screen_game": ""}
proposals = data.get("moments", [])[:SCAN_MAX_MOMENTS]
for moment in proposals:
if self._insert_scan_moment(session, moment, back_lo, hi, dur, existing):
created += 1
# Quantas propostas a IA fez e quantas viraram candidato (as outras: nota < SCAN_MIN_PROPOSAL, curtas ou em
# cima de um corte). Antes não ficava registrado (diagnóstico de 17/11/2026: impossível saber se a varredura
# não propôs nada ou se foi barrada).
log.info("varredura %s %.0f–%.0fs: %d proposta(s), %d candidato(s)", session["id"], lo, hi, len(proposals), created)
memory = loads(session.get("memory_json"), [])
if data.get("summary") or proposals:
memory.append({"fromS": lo, "toS": hi, "summary": str(data.get("summary") or "")[:240],
"proposals": len(proposals), "created": created})
screen = str(data.get("screen_game") or "")
if screen.lower() in ("desconhecido", "não identificável", "nao identificavel"):
screen = ""
self.e.db.run("UPDATE sessions SET scanned_until = ?, memory_json = ?, screen_game = CASE WHEN ? != '' THEN ? ELSE screen_game END WHERE id = ?",
hi, json.dumps(memory[-MEMORY_KEEP:], ensure_ascii=False), screen, screen[:120], session["id"])
if screen and not session.get("game"):
self.set_game(session["id"], screen, "screen") # sem categoria (YouTube/VOD): o jogo vem da tela
return created
def _insert_scan_moment(self, session: dict, m: dict, lo: float, hi: float, dur: dict, existing: list) -> bool:
"""Momento proposto pela varredura vira CANDIDATO: passa pelos dois juízes (analista + editor) como os do chat."""
try:
# Mínimo + 1 s de verdade: se o fim bate no fim da janela, o início recua (fit_window).
start, end = fit_window(float(m["start_s"]), float(m["end_s"]), lo, hi,
layout.min_target({"duration": dur}), float(dur["maxS"]), keep="start")
score = max(0.0, min(10.0, float(m["score"])))
except (KeyError, TypeError, ValueError):
return False
if end - start < min(10.0, dur["minS"]) or score < SCAN_MIN_PROPOSAL:
return False
from .scoring import overlaps # import local: evita ciclo na carga do módulo
if any(overlaps(start, end, a, b) for a, b, _ in existing):
return False
ts = now()
reasons = {"via": "varredura", "scanFromS": lo, "scanToS": hi, "proposalScore": score,
"proposalTitle": str(m.get("title", ""))[:100], "proposalReason": str(m.get("reason", ""))[:300]}
self.e.db.run(
"INSERT INTO clips (session_id, peak_s, start_s, end_s, score, source, reasons_json, status, created_at, updated_at)"
" VALUES (?, ?, ?, ?, ?, 'ai', ?, 'candidate', ?, ?)",
session["id"], round((start + end) / 2, 2), round(start, 2), round(end, 2), score,
json.dumps(reasons, ensure_ascii=False), ts, ts)
existing.append((start, end, ""))
return True