feat(v2): real Slack send pipeline (guard, idempotency, success/failure registration)

Implements the actual send branch: Selecionar Top N -> Montar Mensagem ->
Guard de Envio -> Slack real -> registrar resultado (only after
confirmed success/failure) -- previously simulated/absent.

logic/slack.js (new): shouldSendByConfig (SEND_ENABLED gate, defaults
false), computeMessageHash (djb2Hash of the exact message text, reused
from logic/hash.js), alreadySentSuccessfully (idempotency check: only a
prior status='success' record for the same report_date+run_type+
message_hash blocks a resend -- a prior 'failed' record does not, so
retries after a real failure aren't stuck), evaluateSendGuard (single
auditable decision combining both), buildEnvioDigestRecord.
logic/slack.test.js: 13 tests covering all of the above, explicitly
labeled against the mission's required tests #13-#16.

New node drivers:
- guard-envio-slack.node.js: reads the digest + recent envio records
  (fetched by report_date), computes the send decision.
- Slack node itself (n8n-nodes-base.slack, native, not a raw webhook):
  reuses the real "Slack account" credential (slackApi) and
  $vars.SLACK_CHANNEL_TECNICO channel variable already used by this
  org's own "Notificacao de Erros Globais" workflow on the same n8n
  instance -- V1's own Slack webhook URL was never actually deployed
  (its Config value is literally "SEU/WEBHOOK/AQUI", same class of
  placeholder as the old GLPI URL from the prior cycle), so this reuses
  the one REAL, credentialed Slack mechanism that exists in this
  environment rather than inventing a new destination. onError:
  continueErrorOutput splits success/failure into two branches.
- registrar-envio-sucesso.node.js / registrar-envio-falha.node.js: build
  the success/failure record; only the success path continues to the
  existing per-ticket send-counter logic (rewired below).
- lancar-erro-envio.node.js: after the failure record is written,
  explicitly throws so the n8n execution shows status=error (never
  silently swallow a send failure).
- pular-envio.node.js: terminal no-op for the "should not send" branch
  (SEND_ENABLED=false or already sent today), for observability only.

n8n/nodes/prepare-envio-record.node.js: rewired to read the Top10
selection by name ($('Code - Selecionar Top 10').all()) instead of
$input, since it now runs downstream of the Slack-success registration,
not directly off Selecionar Top10 -- registering per-ticket send counts
before Slack ever confirmed anything was the exact "don't register
before confirmation" bug the mission called out.

logic/message.test.js: added a full-Top10 message-length regression test
(mission requirement: message stays short, no leaked JSON/score/evidence).

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

logic/message.test.js

@@ -49,3 +49,15 @@ test('digest de coordenacao lista apenas os itens passados (novos/alterados)', (
   const digest = buildCoordinationDigest([{ ticket: { id: 37691 }, aiClassification: { reason: 'aguardando definicao' }, exclusionReason: 'needs_coordination' }], '24/08');
   assert.ok(digest.includes('#37691'));
 });
+
+test('mensagem com 10 chamados continua curta (teste obrigatorio #19 -- nao vira relatorio longo)', () => {
+  const dezItens = Array.from({ length: 10 }, (_, i) => selectedItem({
+    ticket: { ...selectedItem({}).ticket, id: 38600 + i, titulo: `Titulo do chamado numero ${i} com texto razoavelmente longo` },
+  }));
+  const msg = buildTopMessage(dezItens, '25/08', {});
+  // 10 blocos de ~4 linhas curtas cada + cabecalho: bem abaixo de um "relatorio". Limite
+  // generoso o suficiente pra nao quebrar por titulos longos, mas que pegaria regressao real
+  // (ex.: reason/evidence/JSON vazando pra mensagem).
+  assert.ok(msg.length < 2000, `mensagem ficou com ${msg.length} caracteres, esperado < 2000`);
+  assert.ok(!/"classification"|"evidence"|"confidence"/.test(msg), 'mensagem nao pode vazar campos internos/JSON');
+});

logic/slack.js

@@ -0,0 +1,58 @@
+const { djb2Hash } = require('./hash');
+
+// Hash estavel do texto exato que seria enviado -- usado como parte da chave de
+// idempotencia (junto com report_date/run_type). Duas mensagens com o mesmo conteudo no
+// mesmo dia nunca devem gerar dois envios reais.
+function computeMessageHash(text) {
+  return djb2Hash(String(text || ''));
+}
+
+// SEND_ENABLED e o unico gate de "isso pode realmente sair pro Slack" -- nunca depende de
+// editar codigo (missao "finalizacao para producao", secao 22).
+function shouldSendByConfig(config) {
+  return Boolean(config && config.sendEnabled);
+}
+
+// Idempotencia: so conta como "ja enviado" um registro com status 'success' para a MESMA
+// data + tipo de execucao + hash de mensagem. Um retry apos falha (status 'failed') nao
+// bloqueia um novo envio -- so um sucesso anterior bloqueia.
+function alreadySentSuccessfully(existingRecords, { reportDate, runType, messageHash }) {
+  return (existingRecords || []).some((record) => (
+    record
+    && record.status === 'success'
+    && record.report_date === reportDate
+    && record.run_type === runType
+    && record.message_hash === messageHash
+  ));
+}
+
+// Decisao unica de "devo mandar pro Slack agora" -- centraliza os dois motivos possiveis de
+// NAO enviar (SEND_ENABLED=false, ou ja enviado com sucesso hoje) num so lugar auditavel.
+function evaluateSendGuard({ config, existingRecords, reportDate, runType, messageHash }) {
+  if (!shouldSendByConfig(config)) {
+    return { shouldSend: false, reason: 'send_disabled' };
+  }
+  if (alreadySentSuccessfully(existingRecords, { reportDate, runType, messageHash })) {
+    return { shouldSend: false, reason: 'already_sent' };
+  }
+  return { shouldSend: true, reason: 'ok' };
+}
+
+function buildEnvioDigestRecord({ reportDate, runType, messageHash, sentAt, status, errorDetail }) {
+  return {
+    report_date: reportDate,
+    run_type: runType,
+    message_hash: messageHash,
+    sent_at: sentAt,
+    status,
+    error_detail: errorDetail || null,
+  };
+}
+
+module.exports = {
+  computeMessageHash,
+  shouldSendByConfig,
+  alreadySentSuccessfully,
+  evaluateSendGuard,
+  buildEnvioDigestRecord,
+};

logic/slack.test.js

@@ -0,0 +1,78 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const {
+  computeMessageHash, shouldSendByConfig, alreadySentSuccessfully, evaluateSendGuard, buildEnvioDigestRecord,
+} = require('./slack');
+
+test('computeMessageHash e deterministico para o mesmo texto', () => {
+  assert.equal(computeMessageHash('ola mundo'), computeMessageHash('ola mundo'));
+});
+
+test('computeMessageHash muda quando o texto muda', () => {
+  assert.notEqual(computeMessageHash('ola mundo'), computeMessageHash('ola mundo!'));
+});
+
+test('SEND_ENABLED=false nunca deixa enviar -- missao secao 22/13', () => {
+  assert.equal(shouldSendByConfig({ sendEnabled: false }), false);
+});
+
+test('SEND_ENABLED=true libera o envio (sujeito ainda a idempotencia)', () => {
+  assert.equal(shouldSendByConfig({ sendEnabled: true }), true);
+});
+
+test('alreadySentSuccessfully detecta envio de sucesso identico (mesma data/tipo/hash)', () => {
+  const existing = [{ report_date: '2026-08-25', run_type: 'scheduled', message_hash: 'abc', status: 'success' }];
+  assert.equal(alreadySentSuccessfully(existing, { reportDate: '2026-08-25', runType: 'scheduled', messageHash: 'abc' }), true);
+});
+
+test('alreadySentSuccessfully ignora registros de falha -- retry apos erro nao fica bloqueado', () => {
+  const existing = [{ report_date: '2026-08-25', run_type: 'scheduled', message_hash: 'abc', status: 'failed' }];
+  assert.equal(alreadySentSuccessfully(existing, { reportDate: '2026-08-25', runType: 'scheduled', messageHash: 'abc' }), false);
+});
+
+test('alreadySentSuccessfully ignora envios de outro dia ou outro hash', () => {
+  const existing = [{ report_date: '2026-08-24', run_type: 'scheduled', message_hash: 'abc', status: 'success' }];
+  assert.equal(alreadySentSuccessfully(existing, { reportDate: '2026-08-25', runType: 'scheduled', messageHash: 'abc' }), false);
+  const existing2 = [{ report_date: '2026-08-25', run_type: 'scheduled', message_hash: 'xyz', status: 'success' }];
+  assert.equal(alreadySentSuccessfully(existing2, { reportDate: '2026-08-25', runType: 'scheduled', messageHash: 'abc' }), false);
+});
+
+test('evaluateSendGuard: Slack NAO envia com SEND_ENABLED=false -- teste obrigatorio #13', () => {
+  const result = evaluateSendGuard({ config: { sendEnabled: false }, existingRecords: [], reportDate: '2026-08-25', runType: 'scheduled', messageHash: 'abc' });
+  assert.equal(result.shouldSend, false);
+  assert.equal(result.reason, 'send_disabled');
+});
+
+test('evaluateSendGuard: Slack envia com SEND_ENABLED=true e nenhum envio anterior -- teste obrigatorio #14', () => {
+  const result = evaluateSendGuard({ config: { sendEnabled: true }, existingRecords: [], reportDate: '2026-08-25', runType: 'scheduled', messageHash: 'abc' });
+  assert.equal(result.shouldSend, true);
+  assert.equal(result.reason, 'ok');
+});
+
+test('evaluateSendGuard: envio duplicado e bloqueado -- teste obrigatorio #15', () => {
+  const existing = [{ report_date: '2026-08-25', run_type: 'scheduled', message_hash: 'abc', status: 'success' }];
+  const result = evaluateSendGuard({ config: { sendEnabled: true }, existingRecords: existing, reportDate: '2026-08-25', runType: 'scheduled', messageHash: 'abc' });
+  assert.equal(result.shouldSend, false);
+  assert.equal(result.reason, 'already_sent');
+});
+
+test('evaluateSendGuard: retry (mensagem diferente) apos falha anterior nao e bloqueado', () => {
+  const existing = [{ report_date: '2026-08-25', run_type: 'scheduled', message_hash: 'abc', status: 'failed' }];
+  const result = evaluateSendGuard({ config: { sendEnabled: true }, existingRecords: existing, reportDate: '2026-08-25', runType: 'scheduled', messageHash: 'abc' });
+  assert.equal(result.shouldSend, true);
+});
+
+test('buildEnvioDigestRecord monta o registro de sucesso corretamente', () => {
+  const record = buildEnvioDigestRecord({ reportDate: '2026-08-25', runType: 'scheduled', messageHash: 'abc', sentAt: 12345, status: 'success' });
+  assert.deepEqual(record, {
+    report_date: '2026-08-25', run_type: 'scheduled', message_hash: 'abc', sent_at: 12345, status: 'success', error_detail: null,
+  });
+});
+
+test('buildEnvioDigestRecord monta o registro de falha com error_detail -- falha nunca registra sucesso (teste obrigatorio #16)', () => {
+  const record = buildEnvioDigestRecord({
+    reportDate: '2026-08-25', runType: 'scheduled', messageHash: 'abc', sentAt: 12345, status: 'failed', errorDetail: 'HTTP 500',
+  });
+  assert.equal(record.status, 'failed');
+  assert.equal(record.error_detail, 'HTTP 500');
+});