@hed-hog/core 0.0.400 → 0.0.402

package/src/integration-profile/testers/integration-tester.types.ts

@@ -26,6 +26,11 @@ export type IntegrationTestOutcome = {
    * verificado, service account sem acesso ao app, pool inexistente). Não reprova.
    */
   warning?: string;
+  /**
+   * Códigos estáveis dos avisos, na ordem do `warning`, para a UI traduzir. O
+   * `warning` continua sendo o texto de fallback de quem não conhece o código.
+   */
+  warningCodes?: string[];
 };
 
 export type IntegrationTestContext = {

package/src/integration-profile/testers/oauth.testers.spec.ts

@@ -126,6 +126,19 @@ describe('microsoft-oauth tester', () => {
     expect(outcome.info).toContain('contoso');
   });
 
+  it('aprova quando o token é maior que o limite de texto guardado', async () => {
+    fetchMock.mockResolvedValue(
+      jsonResponse({ token_type: 'Bearer', access_token: 'x'.repeat(5_000) }),
+    );
+
+    const outcome = await tester.test(
+      { client_id: 'a', client_secret: 'b', tenant_id: 'contoso' },
+      ctx(),
+    );
+
+    expect(outcome.ok).toBe(true);
+  });
+
   it.each([
     ['AADSTS7000215', 'Invalid client secret.'],
     ['AADSTS700016', 'Application not found in tenant "contoso".'],

package/src/integration-profile/testers/remaining.testers.spec.ts

@@ -26,11 +26,14 @@ const all = [
 const bySlug = (slug: string): IntegrationTester =>
   all.find((tester) => tester.providerSlug === slug)!;
 
-const ctx = (): IntegrationTestContext => ({
+const ctx = (
+  overrides: Partial<IntegrationTestContext> = {},
+): IntegrationTestContext => ({
   signal: AbortSignal.timeout(5_000),
   typeSlug: 'test',
   providerSlug: 'test',
   secretValues: [],
+  ...overrides,
 });
 
 function jsonResponse(body: unknown, status = 200) {
@@ -252,6 +255,67 @@ describe('openai tester', () => {
       error: 'Invalid OpenAI API key.',
     });
   });
+
+  // O header de organização é opcional e só este testador o envia. Um `org-...`
+  // errado devolve 401, e a mensagem fixa de "chave inválida" mandava conferir
+  // justamente o campo que estava certo.
+  it('culpa a organização, e não a chave, quando é ela que a OpenAI recusa', async () => {
+    fetchMock.mockResolvedValue(
+      jsonResponse(
+        {
+          error: {
+            message: 'No such organization: org-errada.',
+            code: 'invalid_organization',
+          },
+        },
+        401,
+      ),
+    );
+
+    const outcome = await tester.test(
+      { api_key: 'sk-test', organization: 'org-errada' },
+      ctx(),
+    );
+
+    expect(outcome.ok).toBe(false);
+    expect(outcome.error).toContain('organization');
+    expect(outcome.error).toContain('org-errada');
+    expect(outcome.error).not.toContain('Invalid OpenAI API key');
+  });
+
+  it('acrescenta o motivo que a OpenAI deu quando a chave é mesmo o problema', async () => {
+    fetchMock.mockResolvedValue(
+      jsonResponse(
+        { error: { message: 'Incorrect API key provided.', code: 'invalid_api_key' } },
+        401,
+      ),
+    );
+
+    const outcome = await tester.test({ api_key: 'sk-bad' }, ctx());
+
+    expect(outcome.error).toBe(
+      'Invalid OpenAI API key. Incorrect API key provided.',
+    );
+  });
+
+  // O resultado de um tester não passa por `sanitizeTesterError`, então a
+  // redação do segredo tem de acontecer dentro do próprio testador.
+  it('não deixa a chave vazar pela mensagem do provider', async () => {
+    fetchMock.mockResolvedValue(
+      jsonResponse(
+        { error: { message: 'Incorrect API key provided: sk-supersecreta.' } },
+        401,
+      ),
+    );
+
+    const outcome = await tester.test(
+      { api_key: 'sk-supersecreta' },
+      ctx({ secretValues: ['sk-supersecreta'] }),
+    );
+
+    expect(outcome.error).not.toContain('sk-supersecreta');
+    expect(outcome.error).toContain('***');
+  });
 });
 
 describe('claude tester', () => {

package/src/integration-profile/testers/tester-coverage.spec.ts

@@ -15,6 +15,18 @@ const EXTERNAL_PROVIDERS = new Set([
   // Abrir o certificado A1 é código do domínio fiscal: o tester se registra pelo
   // NfseNationalModule (libraries/fiscal).
   'nfse-national',
+  // App da Meta para redes sociais: o tester se registra pelo SocialModule
+  // (libraries/social), junto do client da Graph API.
+  'meta-social',
+  // App do Instagram (Instagram Login): o tester vive em libraries/social.
+  'instagram-social',
+  // Apps do Google do modulo social: os testers vivem em libraries/social.
+  'youtube-social',
+  'google-business-social',
+  // App do LinkedIn (paginas de empresa): o tester vive em libraries/social.
+  'linkedin-social',
+  // App do X (OAuth 2.0 com PKCE): o tester vive em libraries/social.
+  'x-social',
 ]);
 
 /** Providers legítimos sem nenhum campo secreto. */

package/src/mail/mail.service.spec.ts

@@ -82,6 +82,31 @@ describe('MailService', () => {
       expect(call('A\r\nB', {})).toBe('A<br/>B');
     });
 
+    // Bug real: o aviso interno do SAC, escrito em HTML indentado, chegava com
+    // um vao entre cada campo — cada quebra entre dois <p> virava <br/>.
+    it('não gera <br/> na quebra que só separa uma tag da seguinte', () => {
+      expect(call('<div>\n  <p>A</p>\n  <p>B</p>\n</div>', {})).toBe(
+        '<div><p>A</p><p>B</p></div>',
+      );
+      expect(call('<p>A</p>\r\n\r\n<p>B</p>', {})).toBe('<p>A</p><p>B</p>');
+    });
+
+    it('não gera <br/> entre tag e bloco {{#if}}/{{/if}}', () => {
+      const src =
+        '<p>A</p>\n{{#if x}}<p>X</p>{{/if}}\n<p>B</p>\n{{#if y}}\n  <p>Y</p>\n{{else}}\n  <p>N</p>\n{{/if}}';
+      expect(call(src, { x: true })).toBe('<p>A</p><p>X</p><p>B</p><p>N</p>');
+    });
+
+    it('mantém o <br/> da quebra que vem depois de texto ou de variável', () => {
+      expect(call('Olá,\n<div>x</div>', {})).toBe('Olá,<br/><div>x</div>');
+      expect(call('Oi {{name}}\n<p>x</p>', { name: 'Bob' })).toBe(
+        'Oi Bob<br/><p>x</p>',
+      );
+      expect(call('<strong>A</strong>\ntexto', {})).toBe(
+        '<strong>A</strong><br/>texto',
+      );
+    });
+
     it('preserva as quebras de linha de um documento HTML completo (não injeta <br/> dentro de <style>/<head>)', () => {
       // Bug real: um HTML completo colado em Templates de e-mail (que
       // funciona no preview cru de Campanhas) aparecia quebrado aqui porque

package/src/mail/mail.service.ts

@@ -44,6 +44,14 @@ import { IncidentService } from '../incident/incident.service';
 
 export type { SendTemplatedMailResult } from './dto/send.dto';
 
+/**
+ * Quebra de linha (com a indentacao em volta) entre o fim de uma tag ou de um
+ * bloco do Handlebars e o comeco da proxima tag ou bloco. `{{variavel}}` nao
+ * conta como bloco: depois dela vem texto, e a quebra e do autor.
+ */
+const TAG_TO_TAG_LINE_BREAK =
+  /(>|\{\{[#/][^}]*\}\}|\{\{else\}\})[ \t]*(?:\r\n|\n|\r)\s*(?=<|\{\{[#/]|\{\{else\}\})/g;
+
 @Injectable()
 export class MailService implements OnModuleInit {
   private readonly logger = new Logger(MailService.name);
@@ -692,9 +700,18 @@ export class MailService implements OnModuleInit {
       // caso; aqui só espelhamos a mesma detecção pra não mutilar antes
       // disso). Emails simples (sem <html>) continuam ganhando <br/> pra
       // preservar quebras de linha digitadas pelo usuário.
+      //
+      // A quebra que só separa uma tag (ou um bloco `{{#if}}`/`{{/if}}`) da
+      // seguinte é indentação do template, não texto: virar <br/> ali punha
+      // uma linha em branco entre cada <p> de todo template escrito em HTML
+      // de várias linhas. Essa sai antes; a que vem depois de texto continua.
+      // A quebra final (todo bloco `|` do YAML termina em uma) também sai.
       const normalized = isFullHtmlDocument(source)
         ? source
-        : source.replace(/(\r\n|\n|\r)/g, '<br/>');
+        : source
+            .trimEnd()
+            .replace(TAG_TO_TAG_LINE_BREAK, '$1')
+            .replace(/(\r\n|\n|\r)/g, '<br/>');
       const template = Handlebars.compile(normalized, { noEscape: !escapeHtml });
       return template(data);
     } catch (error: any) {

package/src/mcp/mcp-server.service.spec.ts

@@ -195,6 +195,22 @@ describe('McpServerService', () => {
       );
     });
 
+    it('handler void responde { success: true } em vez de um text ausente', async () => {
+      const { service, deps } = makeService();
+      const handler = jest.fn<any>().mockResolvedValue(undefined);
+      deps.registry.getAll.mockReturnValue([]);
+      deps.registry.get.mockReturnValue({ definition: { name: 'tool-a' }, handler });
+
+      (service as any).buildServer(context);
+      const callHandler = getRegisteredHandler(CallToolRequestSchema);
+
+      const result = await callHandler({ params: { name: 'tool-a', arguments: {} } });
+
+      expect(result).toEqual({
+        content: [{ type: 'text', text: JSON.stringify({ success: true }) }],
+      });
+    });
+
     it('trata argumentos ausentes como objeto vazio', async () => {
       const { service, deps } = makeService();
       const handler = jest.fn<any>().mockResolvedValue({});

package/src/mcp/mcp-server.service.ts

@@ -88,7 +88,16 @@ export class McpServerService {
           success: true,
           durationMs: Date.now() - start,
         });
-        return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+        // Handler `void` (ex.: um delete) dá `JSON.stringify(undefined) === undefined`, e o
+        // cliente MCP recusa o resultado inteiro por faltar `text` — mesmo com a ação feita.
+        return {
+          content: [
+            {
+              type: 'text',
+              text: result === undefined ? JSON.stringify({ success: true }) : JSON.stringify(result),
+            },
+          ],
+        };
       } catch (e: any) {
         await this.audit.record({
           userId: context.userId,

package/src/mcp/mcp.module.ts

@@ -32,6 +32,7 @@ import { McpPermissionService } from './mcp-permission.service';
 import { McpRegistryService } from './mcp-registry.service';
 import { McpServerService } from './mcp-server.service';
 import { McpController } from './mcp.controller';
+import { CoreAccessLogMcpTools } from './tools/core-access-log.mcp-tools';
 import { CoreAiMcpTools } from './tools/core-ai.mcp-tools';
 import { CoreDashboardItemsMcpTools } from './tools/core-dashboard-items.mcp-tools';
 import { CoreDashboardMcpTools } from './tools/core-dashboard.mcp-tools';
@@ -111,6 +112,7 @@ import { AccessLogModule } from '../access-log/access-log.module';
     CoreAiMcpTools,
     CoreMcpChatMcpTools,
     CoreSystemMcpTools,
+    CoreAccessLogMcpTools,
   ],
   exports: [McpRegistryService, McpServerService, McpApiKeyService, McpPermissionService],
 })

package/src/mcp/tools/core-access-log.mcp-tools.ts

@@ -0,0 +1,66 @@
+import { Injectable } from '@nestjs/common';
+import { AccessLogService } from '../../access-log/access-log.service';
+import { McpTool } from '../decorators/mcp-tool.decorator';
+import { McpContext } from '../types/mcp-context.type';
+
+const TYPES = ['http', 'mcp', 'all'] as const;
+const SIMULATED = ['all', 'only', 'exclude'] as const;
+
+@Injectable()
+export class CoreAccessLogMcpTools {
+  constructor(private readonly accessLogService: AccessLogService) {}
+
+  @McpTool({
+    name: 'core.access-log.list',
+    description:
+      'Lists the access log (the admin "Access log" screen): every authenticated HTTP request and MCP tool call, with user, method/URL or tool, IP, user agent and whether it happened during an access simulation. Newest first.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        page: { type: 'number', description: 'Page number (default: 1)' },
+        pageSize: { type: 'number', description: 'Items per page (default: 20)' },
+        userId: { type: 'number', description: 'Filter by user id' },
+        userSearch: { type: 'string', description: 'Matches the user name' },
+        createdAtFrom: { type: 'string', description: 'Start date (YYYY-MM-DD)' },
+        createdAtTo: { type: 'string', description: 'End date (YYYY-MM-DD), inclusive' },
+        type: {
+          type: 'string',
+          description: 'http = REST requests, mcp = MCP tool calls (default: all)',
+          enum: [...TYPES],
+        },
+        simulated: {
+          type: 'string',
+          description: 'only/exclude accesses made while an admin simulated another user (default: all)',
+          enum: [...SIMULATED],
+        },
+      },
+    },
+    readOnly: true,
+  })
+  async list(
+    args: {
+      page?: number;
+      pageSize?: number;
+      userId?: number;
+      userSearch?: string;
+      createdAtFrom?: string;
+      createdAtTo?: string;
+      type?: string;
+      simulated?: string;
+    },
+    _context: McpContext,
+  ): Promise<any> {
+    return this.accessLogService.list({
+      page: args.page ?? 1,
+      pageSize: args.pageSize ?? 20,
+      userId: args.userId,
+      userSearch: args.userSearch,
+      createdAtFrom: args.createdAtFrom,
+      createdAtTo: args.createdAtTo,
+      type: TYPES.includes(args.type as any) ? (args.type as (typeof TYPES)[number]) : undefined,
+      simulated: SIMULATED.includes(args.simulated as any)
+        ? (args.simulated as (typeof SIMULATED)[number])
+        : undefined,
+    });
+  }
+}

package/src/mcp/tools/core-files.mcp-tools.ts

@@ -130,7 +130,7 @@ export class CoreFilesMcpTools {
   @McpTool({
     name: 'core.files.create-upload-url',
     description:
-      'Opens an upload and returns a short-lived, single-use URL to PUT the file to. This is how you send a file without putting its bytes in the conversation: call this, PUT the binary to the returned url, then call core.files.upload.complete to get the fileId, and pass that fileId to whichever tool needs the file. Works for files up to the storage-max-size setting (10mb by default).',
+      'Opens an upload and returns a short-lived, single-use URL on the Hub API host to PUT the file to: PUT the binary to the returned url, then call core.files.upload.complete to get the fileId (or pass the uploadId straight to the tool that needs the file). Fastest path, but the url must be reachable from wherever the PUT runs. Clients in a network-restricted sandbox (e.g. claude.ai) usually cannot reach it; if you are in one, or the PUT fails with host_not_allowed, 403 or a network error, use core.files.upload.init instead, which sends the file through MCP calls. Works for files up to the storage-max-size setting (10mb by default).',
     inputSchema: {
       type: 'object',
       properties: {
@@ -185,14 +185,14 @@ export class CoreFilesMcpTools {
       headers: { 'Content-Type': ticket.mimetype },
       expiresAt: ticket.expires_at.toISOString(),
       sizeBytes: ticket.size_bytes,
-      next: 'PUT the raw file bytes to url, then call core.files.upload.complete with this uploadId.',
+      next: 'PUT the raw file bytes to url, then call core.files.upload.complete with this uploadId. If the PUT is blocked (host_not_allowed, 403, network error), open a new upload with core.files.upload.init and send the file in chunks instead.',
     };
   }
 
   @McpTool({
     name: 'core.files.upload.init',
     description:
-      'Opens an upload to be sent in base64 chunks. Only for clients that cannot make an HTTP request: it is far slower than core.files.create-upload-url, because the content still travels through the conversation, just split across calls. Follow with core.files.upload.append for each chunk and core.files.upload.complete at the end.',
+      'Opens an upload sent in base64 chunks through MCP calls, with no extra network access. Use it when core.files.create-upload-url is not an option: a network-restricted sandbox (e.g. claude.ai), or a PUT that failed with host_not_allowed, 403 or a network error. Works for files up to the storage-max-size setting (10mb by default), well beyond the ~256kb limit of inline fileBase64. Returns uploadId, chunkBytes and totalChunks. Then call core.files.upload.append once per chunk (index 0..totalChunks-1, each chunk at most chunkBytes raw bytes before base64 encoding) and finish with core.files.upload.complete to get the fileId, or pass the uploadId to the tool that needs the file. Generate the chunks programmatically in your sandbox (split the file and print the base64 of each chunk) rather than typing base64 by hand. The upload expires at expiresAt.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -225,7 +225,7 @@ export class CoreFilesMcpTools {
       chunkBytes,
       totalChunks: Math.ceil(ticket.size_bytes / chunkBytes),
       expiresAt: ticket.expires_at.toISOString(),
-      next: `Send each chunk with core.files.upload.append, indexes 0..n-1, at most ${chunkBytes} bytes before encoding.`,
+      next: `Send each chunk with core.files.upload.append, indexes 0..${Math.ceil(ticket.size_bytes / chunkBytes) - 1}, at most ${chunkBytes} raw bytes per chunk before base64 encoding, then call core.files.upload.complete with this uploadId.`,
     };
   }
 

package/src/meeting/meeting-provider.registry.ts

@@ -1,4 +1,5 @@
 import { Injectable, Logger } from '@nestjs/common';
+import { MeetingChatMessage } from './meeting.constants';
 
 /**
  * Pedido de criação de uma reunião online para uma entidade de negócio qualquer.
@@ -218,6 +219,61 @@ export interface MeetingChatAttachmentContent {
   size: number;
 }
 
+/**
+ * Pedido de publicação de uma mensagem no chat da reunião de uma origem.
+ *
+ * O corpo é HTML simples — `<p>`, `<br>`, `<strong>`, `<a href>` — e não texto
+ * puro porque o que motiva este contrato é mandar um link clicável para dentro
+ * da reunião. Provedor que não renderize HTML degrada tirando as tags; o texto
+ * continua legível.
+ */
+export interface PostMeetingChatMessageInput {
+  sourceModule: string;
+  sourceEntity: string;
+  sourceEntityId: string;
+  html: string;
+}
+
+/**
+ * Desfecho da publicação, sem exceção.
+ *
+ * Postar no chat é conveniência, não o caminho crítico: quem chama tem sempre o
+ * plano B de mostrar o texto para alguém colar à mão. Transformar "o tenant
+ * desligou o chat da reunião" em exceção obrigaria toda tela a tratar erro para
+ * uma situação que é normal.
+ */
+export type PostMeetingChatFailure =
+  /** Não há identidade/configuração para escrever. */
+  | 'unavailable'
+  /** A reunião não tem chat (ninguém entrou, ou o tenant o desligou). */
+  | 'no_chat'
+  /** Falta consentimento do escopo de envio na conta que escreve. */
+  | 'missing_scope'
+  /** O provedor recusou por outro motivo. */
+  | 'failed';
+
+/**
+ * Um objeto com campos opcionais, e não uma união discriminada, porque o
+ * monorepo compila com `strictNullChecks: false` — e sem essa flag o
+ * TypeScript não estreita a união pelo `ok`, obrigando todo consumidor a um
+ * cast. Melhor um contrato que funciona do que um mais elegante que ninguém
+ * consegue usar sem contorno.
+ *
+ * `ok: true` traz `providerMessageId`; `ok: false` traz `reason` e `message`.
+ */
+export interface PostMeetingChatMessageResult {
+  ok: boolean;
+  providerMessageId?: string | null;
+  reason?: PostMeetingChatFailure;
+  message?: string;
+}
+
+export interface ListMeetingChatMessagesInput {
+  sourceModule: string;
+  sourceEntity: string;
+  sourceEntityId: string;
+}
+
 /**
  * Provedor de reuniões online (Teams hoje; Meet/Zoom cabem no mesmo contrato).
  *
@@ -269,6 +325,30 @@ export interface IMeetingProvider {
   fetchChatAttachment?(
     input: FetchMeetingChatAttachmentInput,
   ): Promise<MeetingChatAttachmentContent | null>;
+  /**
+   * Publica uma mensagem no chat da reunião.
+   *
+   * Opcional pelo mesmo motivo de {@link fetchChatAttachment}, e nunca lança:
+   * o desfecho vem no retorno.
+   */
+  postChatMessage?(
+    input: PostMeetingChatMessageInput,
+  ): Promise<PostMeetingChatMessageResult>;
+  /**
+   * As mensagens do chat que o provedor já capturou para esta origem.
+   *
+   * Existe porque o evento `MEETING_CHAT_AVAILABLE_EVENT` tem teto de mensagens
+   * e, quando estoura, entrega as mais RECENTES. Isso serve para achar o
+   * material que o instrutor colou no fim da aula, e não serve para uma turma
+   * de 250 pessoas em que cada uma escreve: as primeiras somem do payload.
+   *
+   * Lê o que o provedor já guardou, sem ida nova ao serviço remoto — é a
+   * alternativa a fazer o módulo de origem ler a tabela do provedor, que é
+   * exatamente o acoplamento que este contrato existe para evitar.
+   */
+  listChatMessages?(
+    input: ListMeetingChatMessagesInput,
+  ): Promise<MeetingChatMessage[]>;
 }
 
 /**

package/src/oauth/oauth-token-broker.service.spec.ts

@@ -70,6 +70,32 @@ describe('OAuthTokenBrokerService', () => {
     token_expires_at: new Date('2020-01-01T00:00:00Z'),
   });
 
+  /**
+   * O Prisma 6 devolve coluna `Bytes` como `Uint8Array`, não como `Buffer`. Os
+   * mocks daqui usavam `Buffer`, então os testes passavam enquanto produção
+   * falhava em TODA conta: `Uint8Array.toString()` imprime os bytes em decimal
+   * ("115,97,...") em vez de decodificar utf8, o decrypt não achava as 4 partes
+   * e o usuário via "reconecte a conta" — que reconectar não resolvia.
+   */
+  it('decrypts a Bytes column that chega como Uint8Array (Prisma 6)', async () => {
+    const encrypted = deps.security.encrypt('refresh-original');
+    deps.prisma.user_account.findFirst.mockResolvedValue({
+      id: 42,
+      refresh_token: new Uint8Array(Buffer.from(encrypted)),
+      scopes: 'openid,offline_access',
+      token_expires_at: new Date('2020-01-01T00:00:00Z'),
+    } as any);
+    deps.http.post.mockReturnValue(
+      of({ data: { access_token: 'ACCESS-1', expires_in: 3600 } }) as any,
+    );
+
+    const result = await service.getAccessToken(1, PROVIDER);
+
+    expect(result.accessToken).toBe('ACCESS-1');
+    const [, body] = deps.http.post.mock.calls[0] as [string, string, unknown];
+    expect(body).toContain('refresh_token=refresh-original');
+  });
+
   it('decrypts the stored refresh token, exchanges it, and returns an access token', async () => {
     deps.prisma.user_account.findFirst.mockResolvedValue(
       storedRefreshTokenRow(deps.security, 'refresh-original') as any,
@@ -161,6 +187,88 @@ describe('OAuthTokenBrokerService', () => {
     });
   });
 
+  /**
+   * A Microsoft rotaciona o refresh token a cada troca e invalida o anterior.
+   * Com várias réplicas disparando o mesmo tick de cron, a segunda a chegar
+   * recebe `invalid_grant` por uma corrida, não por revogação — e reportar
+   * "reconecte a conta" ali é enganoso: reconectar não resolve, a corrida se
+   * repete no ciclo seguinte.
+   */
+  describe('rotação concorrente', () => {
+    it('refaz a troca com o token que outro processo gravou', async () => {
+      deps.prisma.user_account.findFirst
+        // leitura inicial: o token que vai falhar
+        .mockResolvedValueOnce(
+          storedRefreshTokenRow(deps.security, 'refresh-antigo') as any,
+        )
+        // releitura após o invalid_grant: outro processo já rotacionou
+        .mockResolvedValueOnce(
+          storedRefreshTokenRow(deps.security, 'refresh-novo') as any,
+        )
+        // a retentativa carrega a conta de novo
+        .mockResolvedValueOnce(
+          storedRefreshTokenRow(deps.security, 'refresh-novo') as any,
+        );
+
+      deps.http.post
+        .mockReturnValueOnce(
+          throwError(() => ({
+            response: { data: { error: 'invalid_grant' }, status: 400 },
+          })) as any,
+        )
+        .mockReturnValueOnce(
+          of({ data: { access_token: 'token-bom', expires_in: 3600 } }) as any,
+        );
+
+      const result = await service.getAccessToken(1, PROVIDER);
+
+      expect(result.accessToken).toBe('token-bom');
+      expect(deps.http.post).toHaveBeenCalledTimes(2);
+      // A segunda troca tem que usar o token NOVO, não repetir o que falhou.
+      const segundaChamada = String((deps.http.post.mock.calls[1] as any[])[1]);
+      expect(segundaChamada).toContain('refresh-novo');
+      expect(segundaChamada).not.toContain('refresh-antigo');
+    });
+
+    it('ainda reporta revogação quando o token no banco não mudou', async () => {
+      // Sem essa distinção, uma conta de fato desconectada entraria em laço.
+      deps.prisma.user_account.findFirst.mockResolvedValue(
+        storedRefreshTokenRow(deps.security, 'refresh-original') as any,
+      );
+      deps.http.post.mockReturnValue(
+        throwError(() => ({
+          response: { data: { error: 'invalid_grant' }, status: 400 },
+        })) as any,
+      );
+
+      await expect(service.getAccessToken(1, PROVIDER)).rejects.toMatchObject({
+        reason: 'refresh_revoked',
+      });
+      // Uma tentativa só: não adianta insistir contra revogação real.
+      expect(deps.http.post).toHaveBeenCalledTimes(1);
+    });
+
+    it('não persegue rotações indefinidamente', async () => {
+      // Cada releitura devolve um token diferente, simulando réplicas
+      // rotacionando sem parar. O teto tem que encerrar.
+      let n = 0;
+      deps.prisma.user_account.findFirst.mockImplementation(
+        async () =>
+          storedRefreshTokenRow(deps.security, `refresh-${n++}`) as any,
+      );
+      deps.http.post.mockReturnValue(
+        throwError(() => ({
+          response: { data: { error: 'invalid_grant' }, status: 400 },
+        })) as any,
+      );
+
+      await expect(service.getAccessToken(1, PROVIDER)).rejects.toMatchObject({
+        reason: 'refresh_revoked',
+      });
+      expect(deps.http.post.mock.calls.length).toBeLessThanOrEqual(3);
+    });
+  });
+
   it('parses granted scopes from the stored account', async () => {
     deps.prisma.user_account.findFirst.mockResolvedValue({
       scopes: 'openid, Calendars.Read  offline_access',