feat: implement predictive dialing engine

- apps/dialer-worker: motor do discador preditivo completo
  - predictive-engine.ts: EWMA de answerProbability/avgTalkTimeSeconds/
    abandonRate, previsao de liberacao de agentes, calculo de quantas
    chamadas originar. Logica pura, 14 testes unitarios
  - cps-limiter.ts: token bucket via script Lua atomico no Redis (dois
    buckets independentes campanha+tronco, min() dos dois, seguro com
    multiplos workers)
  - lead-repository.ts: reserva atomica via FOR UPDATE SKIP LOCKED,
    recuperacao de reservas orfas apos queda de worker
  - campaign-lock.ts: lock distribuido por campanha (Redis SET NX PX +
    token de posse, renovacao/liberacao seguras via Lua)
  - schedule.ts: janela de horario da campanha (timezone real via
    Intl.DateTimeFormat, dias da semana), 6 testes unitarios
  - retry-rules.ts: motor de retentativa por causa de encerramento,
    configuravel por campanha, nunca infinito
  - simulation.ts + campaign-worker.ts (modo DIALER_SIMULATION): permite
    testar o motor inteiro sem tronco de operadora real
  - simulation-harness.ts: reproduz em tempo discreto e deterministico o
    cenario exato de aceite da secao 66 (20 agentes/10 CPS/30% atendimento/
    TMA 180s) — 6 testes validando CPS nunca excedido, concorrencia nunca
    excedida, pacing nao diverge
  - campaign-worker.ts: orquestra tudo contra Postgres/Redis/Asterisk reais

- docs/PREDICTIVE_DIALER.md: algoritmo documentado, incluindo dois bugs
  reais encontrados e corrigidos durante o teste do cenario de aceite
  (concorrencia nao contava chamadas em atendimento; pacing subia sem
  limite durante periodos ociosos, causando rajada maxima assim que um
  agente ficava livre) e limitacoes conhecidas (AMD e wrap-up automatico
  via eventos reais ainda pendentes, documentados sem esconder)

Testado ponta a ponta contra containers reais (Postgres/Redis/Asterisk):
campanha completa criada -> agente disponivel via API -> leads importados
-> campanha iniciada -> reserva atomica -> CPS respeitado -> simulacao de
NO_ANSWER (retry agendado) e ANSWERED (AGENT_CONNECTED, EWMA atualizada ao
vivo) -> parada sem derrubar chamadas em andamento.

apps/dialer-worker/src/live-counts.ts

@@ -0,0 +1,44 @@
+import { PrismaClient } from '@b2bcall/database';
+import { estimateAgentsFreeingSoon, type LiveCounts } from './predictive-engine';
+
+/**
+ * Consulta o estado real (Postgres) para montar o LiveCounts que o motor
+ * preditivo usa a cada tick. Nunca lê do Asterisk diretamente — o Asterisk
+ * não é fonte de verdade de negócio (agente.md seção 97).
+ */
+export async function getLiveCounts(
+  prisma: PrismaClient,
+  campaignId: string,
+  queueId: string,
+  avgTalkTimeSeconds: number,
+): Promise<LiveCounts> {
+  const members = await prisma.queueMember.findMany({ where: { queueId }, select: { agentId: true } });
+  const agentIds = members.map((m) => m.agentId);
+
+  const openStates = agentIds.length
+    ? await prisma.agentStateEvent.findMany({
+        where: { agentId: { in: agentIds }, endedAt: null },
+        select: { agentId: true, state: true, startedAt: true },
+      })
+    : [];
+
+  const availableAgents = openStates.filter((s) => s.state === 'AVAILABLE').length;
+  const inCallStartedAt = openStates.filter((s) => s.state === 'IN_CALL').map((s) => s.startedAt);
+  const agentsLikelyToFreeSoon = estimateAgentsFreeingSoon(inCallStartedAt, avgTalkTimeSeconds, 15);
+
+  const [dialingCalls, ringingCalls, connectedWaitingAgent, agentConnectedCalls] = await Promise.all([
+    prisma.dialAttempt.count({ where: { campaignId, state: 'ORIGINATING' } }),
+    prisma.dialAttempt.count({ where: { campaignId, state: 'RINGING' } }),
+    prisma.dialAttempt.count({ where: { campaignId, state: 'QUEUED' } }),
+    prisma.dialAttempt.count({ where: { campaignId, state: 'AGENT_CONNECTED' } }),
+  ]);
+
+  return {
+    availableAgents,
+    agentsLikelyToFreeSoon,
+    dialingCalls,
+    ringingCalls,
+    connectedWaitingAgent,
+    agentConnectedCalls,
+  };
+}