@hed-hog/core 0.0.399 → 0.0.400

package/src/observability/monitored-cron.spec.ts

@@ -1,7 +1,8 @@
-import { describe, it, expect, jest, beforeEach } from '@jest/globals';
+import { describe, it, expect, jest, beforeEach, afterEach } from '@jest/globals';
 
 const withMonitor = jest.fn((_slug: string, callback: () => any) => callback());
 const startSpan = jest.fn((_opts: any, callback: () => any) => callback());
+const startNewTrace = jest.fn((callback: () => any) => callback());
 const captureException = jest.fn();
 const withScope = jest.fn((cb: (scope: any) => void) => {
   const scope = { setTag: jest.fn() };
@@ -9,41 +10,83 @@ const withScope = jest.fn((cb: (scope: any) => void) => {
   return scope;
 });
 
-jest.mock('@sentry/nestjs', () => ({ withMonitor, startSpan, captureException, withScope }));
+jest.mock('@sentry/nestjs', () => ({
+  withMonitor,
+  startSpan,
+  startNewTrace,
+  captureException,
+  withScope,
+}));
 
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const { runMonitoredCron } = require('./monitored-cron');
 
-function fakePrisma(locked: boolean, overrides: { transactionThrows?: boolean } = {}) {
-  const queryRaw = jest.fn().mockResolvedValue([{ locked }]);
-  const transaction = jest.fn(async (fn: any) => {
-    if (overrides.transactionThrows) throw new Error('transaction aborted');
-    return fn({ $queryRaw: queryRaw });
+type FakeOptions = {
+  /** `false` simula outro pod segurando a lease (nenhuma linha devolvida). */
+  won?: boolean;
+  claimThrows?: boolean;
+  releaseThrows?: boolean;
+};
+
+/**
+ * O Prisma chama a tagged template como `$queryRaw(strings, ...values)`, então os
+ * parâmetros do SQL chegam aqui na ordem em que aparecem na query: o claim manda
+ * [slug, holder, leaseSeconds] e o release manda [slug, holder].
+ */
+function fakePrisma(options: FakeOptions = {}) {
+  const claims: any[][] = [];
+  const releases: any[][] = [];
+
+  const $queryRaw = jest.fn(async (_strings: any, ...values: any[]) => {
+    claims.push(values);
+    if (options.claimThrows) throw new Error('Unable to start a transaction in the given time.');
+    return options.won === false ? [] : [{ won: 1 }];
   });
-  return { $transaction: transaction, $queryRaw: queryRaw };
+
+  const $executeRaw = jest.fn(async (_strings: any, ...values: any[]) => {
+    releases.push(values);
+    if (options.releaseThrows) throw new Error('release falhou');
+    return 1;
+  });
+
+  return { $queryRaw, $executeRaw, claims, releases };
 }
 
+const BASE = { slug: 'meu-cron', schedule: '* * * * *' };
+
 describe('runMonitoredCron', () => {
+  const originalSlugs = process.env.SENTRY_CRON_MONITOR_SLUGS;
+
   beforeEach(() => {
     jest.clearAllMocks();
+    // O default de produção libera check-in só para um slug; os casos abaixo
+    // descrevem o comportamento com o monitor ligado, então valem para todos.
+    process.env.SENTRY_CRON_MONITOR_SLUGS = '*';
+  });
+
+  afterEach(() => {
+    if (originalSlugs === undefined) delete process.env.SENTRY_CRON_MONITOR_SLUGS;
+    else process.env.SENTRY_CRON_MONITOR_SLUGS = originalSlugs;
   });
 
   it('retorna undefined sem executar work() quando outro pod já ganhou o tick', async () => {
-    const prisma = fakePrisma(false);
+    const prisma = fakePrisma({ won: false });
     const work = jest.fn();
 
-    const result = await runMonitoredCron(prisma, { slug: 'meu-cron', schedule: '* * * * *' }, work);
+    const result = await runMonitoredCron(prisma, BASE, work);
 
     expect(result).toBeUndefined();
     expect(work).not.toHaveBeenCalled();
     expect(withMonitor).not.toHaveBeenCalled();
+    // Perder o tick não pode mexer na lease de quem venceu.
+    expect(prisma.$executeRaw).not.toHaveBeenCalled();
   });
 
   it('executa work() e devolve o resultado quando ganha o tick', async () => {
-    const prisma = fakePrisma(true);
+    const prisma = fakePrisma();
     const work = jest.fn().mockResolvedValue({ ok: true });
 
-    const result = await runMonitoredCron(prisma, { slug: 'meu-cron', schedule: '* * * * *' }, work);
+    const result = await runMonitoredCron(prisma, BASE, work);
 
     expect(work).toHaveBeenCalledTimes(1);
     expect(withMonitor).toHaveBeenCalledWith(
@@ -54,44 +97,61 @@ describe('runMonitoredCron', () => {
     expect(result).toEqual({ ok: true });
   });
 
-  it('NUNCA relança quando work() falha — captura no Sentry e retorna undefined', async () => {
-    const prisma = fakePrisma(true);
+  it('libera a lease com o MESMO holder que a tomou', async () => {
+    const prisma = fakePrisma();
+
+    await runMonitoredCron(prisma, BASE, jest.fn().mockResolvedValue(undefined));
+
+    const [claimSlug, claimHolder] = prisma.claims[0];
+    const [releaseSlug, releaseHolder] = prisma.releases[0];
+
+    expect(claimSlug).toBe('meu-cron');
+    expect(releaseSlug).toBe('meu-cron');
+    expect(releaseHolder).toBe(claimHolder);
+  });
+
+  it('usa um holder diferente a cada execução, para um release atrasado não apagar a lease do tick seguinte', async () => {
+    const prisma = fakePrisma();
+    const work = jest.fn().mockResolvedValue(undefined);
+
+    await runMonitoredCron(prisma, BASE, work);
+    await runMonitoredCron(prisma, BASE, work);
+
+    expect(prisma.claims[0][1]).not.toBe(prisma.claims[1][1]);
+  });
+
+  it('NUNCA relança quando work() falha — captura no Sentry, libera a lease e retorna undefined', async () => {
+    const prisma = fakePrisma();
     const boom = new Error('cron falhou');
     const work = jest.fn().mockRejectedValue(boom);
 
-    await expect(
-      runMonitoredCron(prisma, { slug: 'meu-cron', schedule: '* * * * *' }, work),
-    ).resolves.toBeUndefined();
+    await expect(runMonitoredCron(prisma, BASE, work)).resolves.toBeUndefined();
 
     expect(captureException).toHaveBeenCalledWith(
       boom,
       expect.objectContaining({ mechanism: { handled: true, type: 'hedhog.cron' } }),
     );
+    // A lease não pode ficar presa até vencer só porque o trabalho deu erro.
+    expect(prisma.$executeRaw).toHaveBeenCalledTimes(1);
   });
 
-  it('dimensiona o timeout/maxWait da transação a partir de maxRuntimeMinutes', async () => {
-    const prisma = fakePrisma(true);
-    const work = jest.fn().mockResolvedValue(undefined);
+  it('dimensiona a validade da lease a partir de maxRuntimeMinutes', async () => {
+    const prisma = fakePrisma();
 
     await runMonitoredCron(
       prisma,
-      { slug: 'meu-cron', schedule: '* * * * *', maxRuntimeMinutes: 2 },
-      work,
+      { ...BASE, maxRuntimeMinutes: 2 },
+      jest.fn().mockResolvedValue(undefined),
     );
 
-    expect(prisma.$transaction).toHaveBeenCalledWith(
-      expect.any(Function),
-      { timeout: 2 * 60_000 + 30_000, maxWait: 20_000 },
-    );
+    expect(prisma.claims[0][2]).toBe(2 * 60 + 30);
   });
 
-  it('NUNCA relança quando a transação falha (ex.: pool esgotado) — captura no Sentry e retorna undefined', async () => {
-    const prisma = fakePrisma(true, { transactionThrows: true });
+  it('NUNCA relança quando a eleição falha (ex.: banco indisponível) — captura no Sentry', async () => {
+    const prisma = fakePrisma({ claimThrows: true });
     const work = jest.fn();
 
-    await expect(
-      runMonitoredCron(prisma, { slug: 'meu-cron', schedule: '* * * * *' }, work),
-    ).resolves.toBeUndefined();
+    await expect(runMonitoredCron(prisma, BASE, work)).resolves.toBeUndefined();
 
     expect(work).not.toHaveBeenCalled();
     expect(captureException).toHaveBeenCalledWith(
@@ -99,4 +159,77 @@ describe('runMonitoredCron', () => {
       expect.objectContaining({ mechanism: { handled: true, type: 'hedhog.cron' } }),
     );
   });
+
+  it('falha ao liberar a lease não derruba o cron nem mascara o resultado de work()', async () => {
+    const prisma = fakePrisma({ releaseThrows: true });
+    const work = jest.fn().mockResolvedValue({ ok: true });
+
+    await expect(runMonitoredCron(prisma, BASE, work)).resolves.toEqual({ ok: true });
+
+    expect(captureException).not.toHaveBeenCalled();
+  });
+
+  /**
+   * O plano do Sentry cobre UM monitor de cron e o projeto tem cinco. Check-in de
+   * slug sem cota é descartado na entrada, então o que se protege aqui é que a
+   * ausência dele não leve junto o trabalho, o span nem o relato de erro.
+   */
+  describe('allowlist de check-in (SENTRY_CRON_MONITOR_SLUGS)', () => {
+    it('emite check-in para slug listado', async () => {
+      process.env.SENTRY_CRON_MONITOR_SLUGS = 'outro-cron,meu-cron';
+      const prisma = fakePrisma();
+
+      await runMonitoredCron(prisma, BASE, jest.fn().mockResolvedValue({ ok: true }));
+
+      expect(withMonitor).toHaveBeenCalledTimes(1);
+      expect(startNewTrace).not.toHaveBeenCalled();
+    });
+
+    it('slug fora da lista roda work() e o span, sem check-in', async () => {
+      process.env.SENTRY_CRON_MONITOR_SLUGS = 'outro-cron';
+      const prisma = fakePrisma();
+      const work = jest.fn().mockResolvedValue({ ok: true });
+
+      const result = await runMonitoredCron(prisma, BASE, work);
+
+      expect(result).toEqual({ ok: true });
+      expect(work).toHaveBeenCalledTimes(1);
+      expect(withMonitor).not.toHaveBeenCalled();
+      // O trace continua isolado por execução, papel que o `isolateTrace` do
+      // withMonitor cumpre no outro ramo.
+      expect(startNewTrace).toHaveBeenCalledTimes(1);
+      expect(startSpan).toHaveBeenCalledWith(
+        expect.objectContaining({ name: 'meu-cron', op: 'cron.hedhog' }),
+        expect.any(Function),
+      );
+    });
+
+    it('slug fora da lista continua liberando a lease e reportando erro', async () => {
+      process.env.SENTRY_CRON_MONITOR_SLUGS = 'outro-cron';
+      const prisma = fakePrisma();
+      const boom = new Error('cron falhou');
+
+      await expect(
+        runMonitoredCron(prisma, BASE, jest.fn().mockRejectedValue(boom)),
+      ).resolves.toBeUndefined();
+
+      expect(captureException).toHaveBeenCalledWith(
+        boom,
+        expect.objectContaining({ mechanism: { handled: true, type: 'hedhog.cron' } }),
+      );
+      expect(prisma.$executeRaw).toHaveBeenCalledTimes(1);
+    });
+
+    it('sem a env, o default deixa passar só o sac-mailbox-poller', async () => {
+      delete process.env.SENTRY_CRON_MONITOR_SLUGS;
+      const work = jest.fn().mockResolvedValue(undefined);
+
+      await runMonitoredCron(fakePrisma(), { ...BASE, slug: 'sac-mailbox-poller' }, work);
+      expect(withMonitor).toHaveBeenCalledTimes(1);
+
+      await runMonitoredCron(fakePrisma(), BASE, work);
+      expect(withMonitor).toHaveBeenCalledTimes(1);
+      expect(work).toHaveBeenCalledTimes(2);
+    });
+  });
 });

package/src/observability/monitored-cron.ts

@@ -1,4 +1,5 @@
 import * as Sentry from '@sentry/nestjs';
+import { randomUUID } from 'node:crypto';
 
 export type MonitoredCronOptions = {
   /** Slug do monitor no Sentry (Crons). */
@@ -9,34 +10,103 @@ export type MonitoredCronOptions = {
   checkinMarginMinutes?: number;
 };
 
-/** Fallback só para dimensionar o timeout da transação (ver abaixo) quando um
+/** Fallback só para dimensionar a validade da lease (ver abaixo) quando um
  * chamador futuro omitir `maxRuntimeMinutes` — os 5 crons atuais sempre informam. */
 const DEFAULT_MAX_RUNTIME_MINUTES = 5;
 
-/** Folga sobre `maxRuntimeMinutes` para o `timeout` da transação: cobre a
- * diferença entre o que o Sentry tolera (`maxRuntime`/`checkinMargin`, que só
- * marcam o check-in como perdido) e o que o Prisma de fato aborta. */
-const TRANSACTION_TIMEOUT_SLACK_MS = 30_000;
+/** Folga sobre `maxRuntimeMinutes` na validade da lease: cobre a diferença entre o
+ * que o Sentry tolera (`maxRuntime`/`checkinMargin`, que só marcam o check-in como
+ * perdido) e o instante a partir do qual outro pod pode assumir o tick. */
+const LEASE_SLACK_SECONDS = 30;
 
-/** Tempo esperando conexão do pool para abrir a transação — alinhado ao
- * `pool_timeout=20s` que packages/api-prisma/src/datasource-url.ts já aplica
- * quando PRISMA_CONNECTION_LIMIT está setado; o default do Prisma (2s) seria
- * mais apertado que esse teto que o projeto já escolheu deliberadamente. */
-const TRANSACTION_MAX_WAIT_MS = 20_000;
+/**
+ * Slugs cujo check-in de Cron Monitoring é de fato emitido, em CSV. `*` libera
+ * todos.
+ *
+ * O plano do Sentry inclui UM monitor de cron e este projeto tem cinco: os quatro
+ * que sobram tinham o check-in descartado na entrada por cota ("Usage Exceeded"),
+ * e monitor que não recebe check-in não alarma — só marca "missed" para sempre no
+ * painel, que é pior do que não existir.
+ *
+ * A vaga fica com o cron de maior cadência (1 min), porque é o que detecta mais
+ * rápido a falha que SÓ o Cron Monitoring pega: o agendador parado em todos os
+ * pods. Falha com exceção dos outros quatro continua chegando pela captura no
+ * `catch` abaixo, com a tag `cron`.
+ */
+const DEFAULT_CRON_MONITOR_SLUGS = 'sac-mailbox-poller';
+
+/** Cache pelo valor bruto: a env não muda em runtime, mas o teste troca. */
+let parsedSlugsRaw: string | undefined;
+let parsedSlugs: Set<string> = new Set();
+
+function emitsCheckIn(slug: string): boolean {
+  const raw = process.env.SENTRY_CRON_MONITOR_SLUGS ?? DEFAULT_CRON_MONITOR_SLUGS;
+
+  if (raw !== parsedSlugsRaw) {
+    parsedSlugsRaw = raw;
+    parsedSlugs = new Set(
+      raw
+        .split(',')
+        .map((entry) => entry.trim())
+        .filter(Boolean),
+    );
+  }
+
+  return parsedSlugs.has('*') || parsedSlugs.has(slug);
+}
+
+/**
+ * Identidade DESTA execução, não do pod: dois ticks seguidos no mesmo processo
+ * precisam de holders diferentes, senão um release atrasado do tick N apagaria a
+ * lease que o tick N+1 acabou de tomar.
+ */
+function newHolder(): string {
+  return `${process.env.HOSTNAME ?? 'local'}:${randomUUID()}`;
+}
+
+/**
+ * Tenta ganhar o tick com uma ÚNICA statement: quem consegue gravar
+ * `locked_until` no futuro venceu, os demais não recebem linha nenhuma de volta.
+ * Concorrentes serializam no índice único de `slug` — o perdedor reavalia o
+ * `WHERE` já com a linha do vencedor, então nunca há dois vencedores.
+ *
+ * O relógio de referência é sempre o `now()` do Postgres, dos dois lados: nenhum
+ * instante é calculado em JS, então divergência de relógio entre pods não conta.
+ */
+async function claimCronTick(
+  prisma: any,
+  slug: string,
+  holder: string,
+  leaseSeconds: number,
+): Promise<boolean> {
+  const rows: unknown[] = await prisma.$queryRaw`
+    INSERT INTO "cron_lock" ("slug", "holder", "locked_until")
+    VALUES (${slug}, ${holder}, now() + make_interval(secs => ${leaseSeconds}::double precision))
+    ON CONFLICT ("slug") DO UPDATE
+      SET "holder" = EXCLUDED."holder",
+          "locked_until" = EXCLUDED."locked_until"
+      WHERE "cron_lock"."locked_until" <= now()
+    RETURNING 1 AS won
+  `;
+
+  return rows.length > 0;
+}
 
 /**
- * Tenta ganhar o tick. Roda DENTRO da transação de `runMonitoredCron` —
- * reaproveita o MESMO padrão de `pg_try_advisory_xact_lock` já usado em
- * cms-scheduled-publisher.service.ts e class-session-reminder.service.ts, mas
- * aqui generalizado: a variante `xact` só é liberada no commit/rollback DESSA
- * transação, então segurá-la aberta pelo tempo de `work()` é o que de fato
- * garante a exclusão mútua entre pods.
+ * Devolve o tick antes do fim da lease. Sem isso o `sac-mailbox-poller` (que roda
+ * a cada minuto com lease de 2min30) só voltaria a rodar de 3 em 3 minutos.
+ *
+ * O `holder` no WHERE é o que impede liberar a lease de outra execução: se esta
+ * aqui estourou o prazo e outro pod já assumiu, o UPDATE não casa e não faz nada.
  */
-async function claimCronTick(tx: any, slug: string): Promise<boolean> {
-  const rows: { locked: boolean }[] = await tx.$queryRaw`
-    SELECT pg_try_advisory_xact_lock(hashtext(${slug})) AS locked
+async function releaseCronTick(prisma: any, slug: string, holder: string): Promise<void> {
+  await prisma.$executeRaw`
+    UPDATE "cron_lock"
+       SET "locked_until" = now()
+     WHERE "slug" = ${slug}
+       AND "holder" = ${holder}
+       AND "locked_until" > now()
   `;
-  return rows[0]?.locked === true;
 }
 
 /**
@@ -46,61 +116,83 @@ async function claimCronTick(tx: any, slug: string): Promise<boolean> {
  * simultaneamente, o Sentry recebe 2×N check-ins por execução e estoura o
  * rate limit de 6/min por monitor (ver docs/sentry.md).
  *
- * A eleição e `work()` rodam na MESMA transação interativa — é o que faz o
- * `pg_try_advisory_xact_lock` valer como exclusão mútua de verdade. Uma
- * versão anterior comitava a eleição sozinha (fora de transação): o Postgres
- * liberava o lock no instante em que a query retornava, antes do trabalho
- * real começar, e pods suficientemente próximos no tempo (o que é comum,
- * já que o @Cron dispara no mesmo segundo em todos) "ganhavam" o mesmo tick
- * e mandavam check-ins duplicados — foi o que gerou o incidente do
- * sac-sla-sweep. `work()` deliberadamente NÃO recebe `tx` (continua fechando
- * sobre `this.prisma`/outros serviços do chamador): a conexão que segura o
- * lock fica ociosa (idle in transaction) durante o trabalho real, em vez de
- * segurar locks de linha por uma chamada HTTP potencialmente longa (ex.:
- * renovação de assinatura do Graph, até 10 min).
+ * A exclusão mútua é uma LEASE na tabela `cron_lock`, não um lock de banco.
+ * Já passamos por duas versões piores:
+ *
+ * 1. `pg_try_advisory_xact_lock` numa transação que comitava logo em seguida: o
+ *    Postgres liberava o lock no instante em que a query retornava, antes do
+ *    trabalho real começar, e pods próximos no tempo (o que é comum, já que o
+ *    @Cron dispara no mesmo segundo em todos) "ganhavam" o mesmo tick — foi o
+ *    que gerou o incidente do sac-sla-sweep.
+ * 2. O mesmo lock, mas com a transação segurada durante `work()` inteiro. A
+ *    exclusão passou a valer, ao custo de manter uma conexão do pool em
+ *    `idle in transaction` por até 10 minutos. Com PRISMA_CONNECTION_LIMIT=5 por
+ *    pod e cinco crons disputando (um deles de minuto em minuto), o pool
+ *    esgotava e o próprio cron morria em "Unable to start a transaction in the
+ *    given time" — o mecanismo de observabilidade consumindo o pool de que ele
+ *    precisava (Sentry API-1H).
+ *
+ * A lease resolve as duas: a eleição é uma statement só (conexão devolvida na
+ * hora, `work()` roda sem segurar nada) e a validade gravada em `locked_until`
+ * é o que mantém os outros pods fora até o dono terminar ou o prazo vencer.
+ *
+ * Trade-off assumido: se `work()` passar de `maxRuntimeMinutes` + 30s, a lease
+ * vence e outro pod pode iniciar uma execução concorrente. A versão anterior
+ * abortava a transação no timeout — nenhum dos dois é bom, mas este não leva o
+ * pool junto.
  *
  * Quando outro pod já ganhou o tick, resolve para `undefined` sem chamar
  * `work` — não é uma falha, é a mesma semântica de "outro worker já pegou o
  * job" que a fila customizada já usa.
+ *
+ * O check-in só é emitido para os slugs de `SENTRY_CRON_MONITOR_SLUGS` (ver
+ * `DEFAULT_CRON_MONITOR_SLUGS`): a cota do plano não cobre os cinco monitores, e
+ * check-in sem cota é descartado na entrada. Tudo o mais — lease, eleição, span,
+ * captura de exceção — é igual para todos os slugs.
  */
 export async function runMonitoredCron<T>(
   prisma: any,
   options: MonitoredCronOptions,
   work: () => Promise<T>,
 ): Promise<T | undefined> {
-  const timeoutMs =
-    (options.maxRuntimeMinutes ?? DEFAULT_MAX_RUNTIME_MINUTES) * 60_000 +
-    TRANSACTION_TIMEOUT_SLACK_MS;
+  const leaseSeconds =
+    (options.maxRuntimeMinutes ?? DEFAULT_MAX_RUNTIME_MINUTES) * 60 + LEASE_SLACK_SECONDS;
+  const holder = newHolder();
 
   try {
-    return await prisma.$transaction(
-      async (tx: any) => {
-        if (!(await claimCronTick(tx, options.slug))) return undefined;
-
-        return Sentry.withMonitor(
-          options.slug,
-          () => Sentry.startSpan({ name: options.slug, op: 'cron.hedhog' }, work),
-          {
-            schedule: { type: 'crontab', value: options.schedule },
-            timezone: 'America/Sao_Paulo',
-            ...(options.maxRuntimeMinutes ? { maxRuntime: options.maxRuntimeMinutes } : {}),
-            ...(options.checkinMarginMinutes ? { checkinMargin: options.checkinMarginMinutes } : {}),
-            // Distingue cada execução do cron como um trace próprio, em vez de
-            // herdar/continuar um trace pendurado do ciclo de poll anterior.
-            isolateTrace: true,
-          },
-        );
-      },
-      { timeout: timeoutMs, maxWait: TRANSACTION_MAX_WAIT_MS },
-    );
+    if (!(await claimCronTick(prisma, options.slug, holder, leaseSeconds))) return undefined;
+
+    try {
+      const runTraced = () => Sentry.startSpan({ name: options.slug, op: 'cron.hedhog' }, work);
+
+      // Sem cota de monitor, o check-in seria descartado na entrada — o trabalho,
+      // o span e o relato de erro continuam idênticos. `startNewTrace` faz aqui o
+      // que o `isolateTrace` do withMonitor faz no outro ramo.
+      if (!emitsCheckIn(options.slug)) {
+        return await Sentry.startNewTrace(runTraced);
+      }
+
+      return await Sentry.withMonitor(options.slug, runTraced, {
+        schedule: { type: 'crontab', value: options.schedule },
+        timezone: 'America/Sao_Paulo',
+        ...(options.maxRuntimeMinutes ? { maxRuntime: options.maxRuntimeMinutes } : {}),
+        ...(options.checkinMarginMinutes ? { checkinMargin: options.checkinMarginMinutes } : {}),
+        // Distingue cada execução do cron como um trace próprio, em vez de
+        // herdar/continuar um trace pendurado do ciclo de poll anterior.
+        isolateTrace: true,
+      });
+    } finally {
+      // Best-effort: uma falha ao devolver a lease não pode virar o erro do cron
+      // (o trabalho já foi feito) e nem mascarar o erro real de `work()`. No pior
+      // caso a lease expira sozinha em `leaseSeconds`.
+      await releaseCronTick(prisma, options.slug, holder).catch(() => undefined);
+    }
   } catch (error) {
-    // withMonitor já registrou o check-in como 'error' antes de relançar (e um
-    // erro de work() também derruba a transação por rollback — inofensivo,
-    // já que nada é escrito via `tx`, só o lock é liberado). O @Cron do
-    // chamador NUNCA deve rejeitar a partir daqui: a lib `cron` por baixo do
-    // @nestjs/schedule não garante tratamento de uma rejeição vinda do
-    // onTick, e o onUnhandledRejectionIntegration({mode:'strict'}) do
-    // instrument.ts derrubaria o processo por um erro que já está capturado.
+    // withMonitor já registrou o check-in como 'error' antes de relançar. O @Cron
+    // do chamador NUNCA deve rejeitar a partir daqui: a lib `cron` por baixo do
+    // @nestjs/schedule não garante tratamento de uma rejeição vinda do onTick, e
+    // o onUnhandledRejectionIntegration({mode:'strict'}) do instrument.ts
+    // derrubaria o processo por um erro que já está capturado.
     Sentry.withScope((scope) => {
       scope.setTag('cron', options.slug);
       Sentry.captureException(error, { mechanism: { handled: true, type: 'hedhog.cron' } });

package/src/profile/dto/change-password.dto.ts

@@ -1,16 +1,34 @@
 import { getLocaleText } from '@hed-hog/api-locale';
-import { IsString, MinLength } from 'class-validator';
+import { IsString } from 'class-validator';
+import { getLocaleFromContext } from '../../utils/locale-context';
 import { IsStrongPasswordWithSettings } from '../../validators/is-strong-password-with-settings.validator';
 
 export class ChangePasswordDto {
-  @IsStrongPasswordWithSettings({
-    message: (args) =>  getLocaleText('profile.changePassword.currentPasswordIsString', args.value)
+  // Só precisa ser texto — é comparada ao hash já salvo, não precisa atender à
+  // política de senha ATUAL. `@IsStrongPasswordWithSettings` estava aqui por engano:
+  // qualquer conta com senha anterior a um endurecimento de política (mais símbolos
+  // exigidos, por exemplo) ficaria travada pra sempre, sem conseguir nunca mais trocar
+  // a própria senha — a política tem que valer pra senha NOVA, não pra que já existe.
+  //
+  // `message` usa `getLocaleFromContext()` (o mesmo AsyncLocalStorage que
+  // `IsStrongPasswordWithSettingsConstraint.defaultMessage()` lê) porque
+  // `ValidationArguments` não carrega o locale da requisição — só o valor do campo.
+  @IsString({
+    message: () =>
+      getLocaleText(
+        'profile.changePassword.currentPasswordIsString',
+        getLocaleFromContext(),
+        'Current password must be a string.',
+      ),
   })
   currentPassword: string;
 
-  @IsString({
-      message: (args) =>  getLocaleText('profile.changePassword.newPasswordIsString', args.value)
-  })
-  @MinLength(6)
+  // Antes só tinha `@IsString` + `MinLength(6)`: a nova senha não passava por
+  // NENHUMA regra de política (maiúscula, símbolo, senha vazada...) além do
+  // tamanho mínimo fixo. `IsStrongPasswordWithSettingsConstraint` já produz uma
+  // mensagem específica por regra via `defaultMessage()` (usa o mesmo
+  // `getLocaleFromContext()` acima), então não sobrescrevemos com `message` aqui —
+  // mesmo padrão de `CreateWithEmailAndPasswordDTO.password`.
+  @IsStrongPasswordWithSettings()
   newPassword: string;
 }

package/src/profile/profile.service.spec.ts

@@ -0,0 +1,97 @@
+import { describe, it, expect, afterEach, jest } from '@jest/globals';
+import { NotFoundException } from '@nestjs/common';
+
+import { ProfileService } from './profile.service';
+
+/**
+ * O que estes casos protegem é uma frase só: "esta conta tem senha" precisa
+ * significar a mesma coisa aqui e no resto do core.
+ *
+ * `hasPasswordCredential` (usado pelo "esqueci minha senha") sempre exigiu
+ * credencial **ativa**, e a revogação é o que o convite de acesso enterprise usa
+ * para trocar "autorize o acesso" por "crie sua conta e defina a senha". Estas
+ * duas leituras do perfil ignoravam `revoked_at`: `changePassword` aceitava a
+ * senha de uma credencial revogada e regravava o hash nela, e o `hasPassword` do
+ * `GET /profile` — que o app usa para decidir se pede senha — dizia que sim.
+ */
+
+const makeDeps = () => ({
+  prisma: {
+    user: { findUnique: jest.fn() },
+    user_credential: { findFirst: jest.fn(), update: jest.fn() },
+  },
+  user: { registerUserActivity: jest.fn() },
+  jwt: {},
+  setting: {},
+  security: { validatePassword: jest.fn(), hashArgon2: jest.fn() },
+  challenge: { resolveAppKeyFromOrigin: jest.fn() },
+  token: {},
+  mail: { resolveRecipientLocale: jest.fn(), sendTemplatedMail: jest.fn() },
+  eventEmitter: { emit: jest.fn() },
+});
+
+const makeService = (deps = makeDeps()) => ({
+  service: new ProfileService(
+    deps.prisma as any,
+    deps.user as any,
+    deps.jwt as any,
+    deps.setting as any,
+    deps.security as any,
+    deps.challenge as any,
+    deps.token as any,
+    deps.mail as any,
+    deps.eventEmitter as any,
+  ),
+  deps,
+});
+
+describe('ProfileService', () => {
+  afterEach(() => jest.clearAllMocks());
+
+  describe('changePassword', () => {
+    it('procura apenas credencial de senha não revogada', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.user_credential.findFirst.mockResolvedValue(null);
+
+      await expect(
+        service.changePassword('pt-BR', 7, {
+          currentPassword: 'antiga',
+          newPassword: 'nova-senha-forte',
+        } as any),
+      ).rejects.toThrow(NotFoundException);
+
+      expect(deps.prisma.user_credential.findFirst).toHaveBeenCalledWith({
+        where: { user_id: 7, type: 'password', revoked_at: null },
+      });
+      // Nada de validar hash revogado: sem credencial ativa o fluxo para antes.
+      expect(deps.security.validatePassword).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('getProfile', () => {
+    it('conta apenas credencial de senha não revogada em hasPassword', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.user.findUnique.mockResolvedValue({ id: 7, name: 'Aluno' });
+      deps.prisma.user_credential.findFirst.mockResolvedValue(null);
+      const count = jest.fn().mockResolvedValue(0);
+      (deps.prisma.user_credential as any).count = count;
+
+      const result = await service.getProfile(7);
+
+      expect(count).toHaveBeenCalledWith({
+        where: { user_id: 7, type: 'password', revoked_at: null },
+      });
+      expect(result).toEqual({ id: 7, name: 'Aluno', hasPassword: false });
+    });
+
+    it('devolve hasPassword true quando existe credencial ativa', async () => {
+      const { service, deps } = makeService();
+      deps.prisma.user.findUnique.mockResolvedValue({ id: 7, name: 'Aluno' });
+      (deps.prisma.user_credential as any).count = jest.fn().mockResolvedValue(1);
+
+      await expect(service.getProfile(7)).resolves.toMatchObject({
+        hasPassword: true,
+      });
+    });
+  });
+});