fix(schema): a 0224 sobrescrevia o conserto da 0223, e agora um gate mede isso

A migration 0224 redefine `fn_service_event_origin` — assinatura idêntica, logo
`create or replace` puro — com o corpo ANTERIOR ao conserto da 0223. E
`20260906120000 > 20260906030000`: na CADEIA de migrations o conserto sumia.

No `baseline.sql` não sumia, porque lá o bloco foi editado à mão. Os dois
artefatos divergiram, e nenhum gate via: `pnpm test:db` aplica só o baseline.
Quem aplica a cadeia (Supabase CLI, `db reset`, clone que migra em vez de
re-aplicar o baseline) ficava com o defeito. Reproduzido em Postgres: aplicar o
bloco da 0224 sobre o baseline reintroduz `service_stale` no segundo evento.

O conserto entrou DENTRO da 0224, que é a versão funcionalmente mais nova (ela
acrescenta o ramo de `appointment.outcome_confirmed`) — não numa migration
nova, porque a 0224 é deste mesmo PR e nunca foi aplicada em lugar nenhum.

E como o custo aqui não é o defeito e sim a INVISIBILIDADE dele, entra o gate:
`apendice-do-baseline-nao-diverge-da-cadeia.test.ts` compara, para toda função
escrita à mão no apêndice, o corpo da última definição da cadeia com o do
baseline. Ele mede SEMÂNTICA, não prosa — três normalizações, cada uma exigida
por um falso vermelho que ele mesmo produziu antes de eu confiar nele:

· comentários fora (11 funções antigas diferiam só em comentário reescrito);
· marca do delimitador uniformizada (`$fn$` do baseline contra `$$` da
  migration — o corpo é o mesmo, e um parser que procura `$$;` fixo lê ALÉM do
  fim da função);
· espaço colado ou não em `(`, `)`, `,` (o `pg_dump` e a mão humana discordam).

Com a régua certa: 88 funções tocadas por este PR, 129 comuns aos dois
artefatos, e ZERO divergências — sem allowlist nenhuma, que é o que separa um
gate de uma lista de desculpas.

Terceira peça: o resumo do dreno passa a carregar `pulados`. O `detail` de um
`skipped` já sobrevivia na linha do `event_log`, e isso basta para quem tem
psql — não basta para o CI, onde o único artefato que sobra do job é o trace, e
o trace guarda o CORPO da resposta. Um e2e que morre porque o gatilho pulou não
conseguia dizer QUAL pulo foi: `failed=0` e nenhuma pista, que foi o que travou
o diagnóstico de `gatilho-de-etapa.spec.ts`.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: melgarafael

lib/event-log/drain.ts

@@ -6,11 +6,7 @@
  * handler no registry e ficam intocados.
  */
 import type { SupabaseClient } from "@supabase/supabase-js";
-import {
-  dispatchEvent,
-  getRegisteredHandlers,
-  type EventRow,
-} from "@/lib/event-log/dispatcher";
+import { dispatchEvent, getRegisteredHandlers, type EventRow } from "@/lib/event-log/dispatcher";
 import { logger } from "@/lib/logger";
 
 const MAX_ATTEMPTS = 5;
@@ -19,6 +15,13 @@ const MAX_ATTEMPTS = 5;
 const PROCESSING_STALE_MS = 10 * 60 * 1000;
 
 export interface DrainSummary {
+  /**
+   * Os `skipped` COM motivo, para o resumo poder ser lido de fora do banco.
+   *
+   * Opcional de propósito: quem monta um `DrainSummary` literal (por exemplo
+   * `tests/unit/event-log-drain-loop.test.ts`) não precisa mudar.
+   */
+  pulados?: string[];
   scanned: number;
   done: number;
   retried: number;
@@ -37,7 +40,14 @@ export async function drainEventLog(
   opts: { limit?: number } = {},
 ): Promise<DrainSummary> {
   const limit = opts.limit ?? 50;
-  const summary: DrainSummary = { scanned: 0, done: 0, retried: 0, failed: 0, dead: 0 };
+  const summary: DrainSummary = {
+    scanned: 0,
+    done: 0,
+    retried: 0,
+    failed: 0,
+    dead: 0,
+    pulados: [],
+  };
 
   const handledTypes = [...new Set(getRegisteredHandlers().flatMap((h) => h.events))];
   if (!handledTypes.length) return summary;
@@ -95,11 +105,10 @@ export async function drainEventLog(
 
   if (error) {
     logger.error("[event-log.drain] select failed", { error: error.message });
-  
+
     return summary;
   }
 
-
   for (const raw of rows ?? []) {
     const row = raw as unknown as EventRow;
     summary.scanned += 1;
@@ -115,7 +124,9 @@ export async function drainEventLog(
 
     const results = await dispatchEvent(row);
 
-    const okKeys = results.filter((r) => r.status === "ok" || r.status === "skipped").map((r) => r.consumer_key);
+    const okKeys = results
+      .filter((r) => r.status === "ok" || r.status === "skipped")
+      .map((r) => r.consumer_key);
     const consumedBy = [...new Set([...row.consumed_by, ...okKeys])];
     const retry = results.find((r) => r.status === "retry");
     const errors = results.filter((r) => r.status === "error");
@@ -136,7 +147,11 @@ export async function drainEventLog(
           next_attempt_at: retryAt,
           updated_at: new Date().toISOString(),
           ...(errors.length
-            ? { last_error: errors.map((e) => `${e.consumer_key}: ${e.detail ?? "error"}`).join("; ") }
+            ? {
+                last_error: errors
+                  .map((e) => `${e.consumer_key}: ${e.detail ?? "error"}`)
+                  .join("; "),
+              }
             : {}),
         })
         .eq("id", row.id);
@@ -167,6 +182,17 @@ export async function drainEventLog(
       //
       // Não muda o desfecho do evento; só deixa de jogar fora a resposta.
       const pulados = results.filter((r) => r.status === "skipped" && r.detail);
+      // E o motivo sai também no RESUMO, não só na linha.
+      //
+      // A linha basta para quem tem psql; não basta para o CI, onde o único
+      // artefato que sobrevive ao job é o trace — e o trace guarda o CORPO da
+      // resposta HTTP. Um e2e que morre porque o gatilho pulou ficava sem poder
+      // dizer QUAL pulo foi: travou por horas o diagnóstico de
+      // `gatilho-de-etapa.spec.ts`, com `failed=0` e nenhuma pista.
+      if (pulados.length)
+        summary.pulados?.push(
+          ...pulados.map((r) => `${row.event_type}/${r.consumer_key}: ${r.detail}`),
+        );
       await admin
         .from("event_log")
         .update({

supabase/migrations/20260906120000_0224_presenca_e_recuperacao.sql

@@ -530,6 +530,30 @@ begin
  select service_boundary into current_boundary from public.event_service_origins where organization_id=p_org and event_id=root_event and channel_session_id=sid;
  if found then boundary:=current_boundary;
  elsif boundary is null then
+   -- PARA UM EVENTO, `absent` E PROCEDENCIA — NAO REIVINDICACAO DE ESTADO.
+   --
+   -- O CAS de `fn_service_begin` existe para que dois ATORES com a mesma
+   -- observacao "ausente" nao ajam os dois: o segundo tem de perder, e o
+   -- invariante de `fn_service_begin` guarda isso. Um evento e outra coisa: o
+   -- retrato `absent` diz "quando este evento foi EMITIDO nao havia
+   -- atendimento", e a resolucao de cada evento ja e idempotente pelo memo
+   -- `event_service_origins` logo acima — nao ha corrida a arbitrar aqui.
+   --
+   -- Sem esta distincao o caminho ORDINARIO morria: um lead criado e depois
+   -- movido de etapa gera DOIS eventos, cada um com seu retrato `absent`;
+   -- resolver o primeiro cria a conversa e o segundo levantava 40001 — que
+   -- `serviceForEvent` engole como `stale_origin`, entao o follow-up de etapa
+   -- simplesmente nao nascia, sem erro em lugar nenhum.
+   --
+   -- Zerar `observed` so quando a conversa JA existe mantem o CAS de pe para o
+   -- retrato que descreve uma fronteira concreta (esse continua sendo conferido
+   -- contra a vigente) e para todo chamador direto de `fn_service_begin`.
+   if observed->>'absent' = 'true' and exists(
+        select 1 from public.conversations
+         where organization_id=p_org and contact_id=p_contact
+           and channel_session_id=sid and not is_group) then
+     observed:=null;
+   end if;
    boundary:=public.fn_service_begin(p_org,p_contact,sid,observed) - 'status' - 'demanda_fechada_em' - 'service_started_at';
  end if;
  if boundary->>'organization_id' is distinct from p_org::text or boundary->>'contact_id' is distinct from p_contact::text then

tests/unit/apendice-do-baseline-nao-diverge-da-cadeia.test.ts

@@ -0,0 +1,133 @@
+import { readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+
+/**
+ * O APÊNDICE DO BASELINE É ESPELHO DA CADEIA — E ESPELHO SE DERIVA, NÃO SE COPIA.
+ *
+ * Toda mudança de schema sai em DOIS artefatos: o arquivo em
+ * `supabase/migrations/` (que o Supabase CLI aplica em ordem) e o apêndice
+ * idempotente do `supabase/baseline.sql` (que o `install.sh`/`update.sh` do
+ * self-host aplica). Quando os dois divergem, cada público recebe um produto
+ * diferente — e o gate não vê, porque `pnpm test:db` aplica só o baseline.
+ *
+ * Foi o que aconteceu e o que este arquivo existe para impedir: a migration
+ * 0224 redefiniu `fn_service_event_origin` com o corpo ANTERIOR ao conserto da
+ * 0223. Assinatura idêntica, então `create or replace` sobrescreve, e
+ * `20260906120000 > 20260906030000` — na cadeia o conserto sumia. No baseline
+ * não, porque lá o bloco foi editado à mão. Verde em todo lugar, e quem aplica
+ * a cadeia ficava com o defeito.
+ *
+ * A regra que este teste cobra: para toda função cuja ÚLTIMA definição no
+ * baseline está no APÊNDICE (isto é, foi escrita à mão, e não despejada pelo
+ * `pg_dump`), o corpo tem de ser igual ao da ÚLTIMA definição na cadeia de
+ * migrations. Funções que só existem no corpo do dump ficam de fora de
+ * propósito: ali o `pg_dump` reformata, e comparar texto acusaria diferença que
+ * não é divergência — o modo de falha de medir a FORMA em vez do conteúdo.
+ */
+const RAIZ = join(process.cwd(), "supabase");
+const BASELINE = readFileSync(join(RAIZ, "baseline.sql"), "utf8");
+
+/** Primeira marca de apêndice: daí para baixo, tudo é escrito à mão. */
+const INICIO_DO_APENDICE = BASELINE.search(/^-- ---- .* \(migration \d+\) ----/m);
+
+/**
+ * O que se compara é CÓDIGO, não prosa.
+ *
+ * Comentário reescrito de um lado só é divergência de TEXTO, não de
+ * comportamento — medido: 11 funções antigas diferem exatamente assim (uma
+ * assinatura quebrada em linhas, um comentário reformulado). Um gate que as
+ * acusasse nasceria vermelho por ruído, e gate que tolera ruído é gate que
+ * ninguém lê. Sem os comentários, o que sobra é o que o Postgres executa — e é
+ * ali que a divergência custa caro.
+ *
+ * A varredura de `--` não distingue comentário de hífen duplo dentro de string
+ * literal. Nenhuma função destes artefatos tem uma, e o custo de errar seria um
+ * falso VERMELHO (nunca um falso verde), que é o lado certo para errar.
+ */
+function semComentarios(sql: string): string {
+  return (
+    sql
+      .split("\n")
+      .map((l) => l.replace(/--.*$/, ""))
+      .join(" ")
+      // A MARCA DO DELIMITADOR é escolha de quem escreveu, não semântica: o
+      // baseline usa `$fn$` onde a migration usa `$$`, e o Postgres executa o
+      // mesmo corpo. Uniformizar aqui evita um vermelho que não fala de nada.
+      .replace(/\$[a-z_]*\$/gi, "$$$$")
+      .replace(/\s+/g, " ")
+      // Espaço colado ou não em `(`, `)` e `,` também é estilo — o `pg_dump` e a
+      // mão humana discordam nisso o tempo todo.
+      .replace(/\s*([(),])\s*/g, "$1")
+      .trim()
+  );
+}
+
+function definicoes(texto: string): Map<string, { corpo: string; pos: number }> {
+  const achadas = new Map<string, { corpo: string; pos: number }>();
+  const re = /create or replace function public\.(fn_[a-z_]+)\s*\(/gi;
+  for (let m = re.exec(texto); m !== null; m = re.exec(texto)) {
+    // O DELIMITADOR NÃO É SEMPRE `$$`. O baseline usa `$fn$ … $fn$` em algumas
+    // funções, e procurar `$$;` fixo faz o corpo ser lido ALÉM do fim — foi
+    // exatamente assim que esta sonda acusou `fn_agora` e
+    // `fn_upsert_wa_conversation` como divergentes quando o que divergia era
+    // ela. A marca de abertura é lida do próprio texto e a de fechamento é a
+    // igual a ela.
+    const abertura = /\$([a-z_]*)\$/i.exec(texto.slice(m.index, m.index + 600));
+    if (!abertura) continue;
+    const marca = abertura[0];
+    const fim = texto.indexOf(marca, m.index + abertura.index + marca.length);
+    if (fim === -1) continue;
+    // A ÚLTIMA vence, que é a que o Postgres deixa de pé.
+    achadas.set(m[1]!.toLowerCase(), {
+      corpo: semComentarios(texto.slice(m.index, fim + marca.length)),
+      pos: m.index,
+    });
+  }
+  return achadas;
+}
+
+const cadeia = (() => {
+  const acc = new Map<string, { corpo: string; pos: number }>();
+  for (const arquivo of readdirSync(join(RAIZ, "migrations"))
+    .filter((f) => f.endsWith(".sql"))
+    .sort())
+    for (const [nome, def] of definicoes(readFileSync(join(RAIZ, "migrations", arquivo), "utf8")))
+      acc.set(nome, def);
+  return acc;
+})();
+const noBaseline = definicoes(BASELINE);
+
+describe("apêndice do baseline não diverge da cadeia de migrations", () => {
+  it("a sonda está viva — o apêndice existe e tem função escrita à mão", () => {
+    // Sem este controle, um `search` que voltasse -1 faria o conjunto medido
+    // ficar vazio e o caso abaixo passar por vacuidade.
+    expect(
+      INICIO_DO_APENDICE,
+      "nenhuma marca `-- ---- … (migration N) ----` no baseline",
+    ).toBeGreaterThan(0);
+    const doApendice = [...noBaseline.entries()].filter(([, d]) => d.pos > INICIO_DO_APENDICE);
+    expect(
+      doApendice.length,
+      "nenhuma função no apêndice — o parser mudou de forma?",
+    ).toBeGreaterThan(5);
+  });
+
+  it("toda função escrita à mão no apêndice tem o mesmo corpo da última definição na cadeia", () => {
+    const divergentes: string[] = [];
+    for (const [nome, def] of noBaseline) {
+      if (def.pos <= INICIO_DO_APENDICE) continue; // veio do pg_dump: reformatado, não comparável
+      const naCadeia = cadeia.get(nome);
+      if (!naCadeia) continue; // só no baseline: fora do escopo desta regra
+      if (naCadeia.corpo !== def.corpo) divergentes.push(nome);
+    }
+    expect(
+      divergentes,
+      "A última definição na CADEIA difere da do APÊNDICE. Quem aplica as migrations recebe " +
+        "um corpo, quem aplica o baseline recebe outro — e nenhum gate vê, porque `test:db` só " +
+        "aplica o baseline. Causa típica: uma migration POSTERIOR redefiniu a função com o corpo " +
+        "de antes de um conserto (assinatura igual ⇒ `create or replace` sobrescreve). Derive o " +
+        "apêndice da migration em vez de reescrevê-lo.\n",
+    ).toEqual([]);
+  });
+});