fix(v2): redefine AI actionability semantics + version the classifier (AI_CLASSIFIER_VERSION)

Production-readiness cycle. Classifier was excessively conservative (real
Run A: ACTIONABLE_NOW/UNASSIGNED_ACTIONABLE both 0) and made concrete
semantic mistakes on real tickets:
- #34419: technician "Rafael Brito" (internal) classified as WAITING_VENDOR
  waiting_for -- an internal technician is not a vendor.
- #37389: ticket had concrete open tasks ("Realizar um inventário das
  máquinas", "Alinhar o dia...") but was classified INSUFFICIENT_CONTEXT.
- Generic next_action ("Revisar chamado") repeated across unrelated
  tickets, proving nothing about real actionability.

Rewrote the system prompt (n8n/nodes/prepare-ai-prompt.node.js) with:
practical actionability definition ("suporte consegue fazer algo util
agora", explicit inclusion list); contatar-vs-aguardar distinction with
examples; WAITING_* requires positive evidence (action already taken AND
external dependency still open); technician-vs-vendor distinction citing
the TECNICO context field; STATUS Planejado alone != blocked/scheduled;
SCHEDULED requires an explicit date/window; mandatory chronological
interpretation (most recent apontamento wins over a superseded old
blocker); next_action must be concrete, with explicit accepted/rejected
examples; INSUFFICIENT_CONTEXT bar raised (ask "is there a diagnostic
step available even without full info" first).
n8n/nodes/prepare-ai-prompt.node.test.js: 10 new tests asserting each
rule's text is still present in the prompt (deterministic proxy --
behavioral proof comes from the real DEV run, inspected manually).

logic/classification.js: added AI_CLASSIFIER_VERSION=3 (stamped on every
valid classification); added a deterministic safety net (not just a
prompt hope) -- isWaitingForInternalTechnician() rejects WAITING_VENDOR
when waiting_for matches the ticket's own TECNICO field, routing to a new
fallback_reason 'ai_semantic_conflict' instead of accepting a known-wrong
semantic classification; added next_action genericness rejection
(isGenericNextAction) for ACTIONABLE_NOW/UNASSIGNED_ACTIONABLE only.
n8n/nodes/validate-ai-response.node.js: now passes the ticket into
validateAiClassification() so the technician guard has the facts it needs.

logic/cache.js: added buildCacheKey(contextHash, classifierVersion) ->
"<hash>:v<version>", stored in the same last_context_hash column (no
schema migration) -- bumping AI_CLASSIFIER_VERSION now forces a cache
miss on every ticket without manually clearing the Data Table.
n8n/nodes/decide-needs-ai.node.js / prepare-memoria-analise-record.node.js
updated to compute/persist the composite key.

logic/config.js: AI_MAX_CANDIDATES default raised 30->60 (now equals
CANDIDATE_POOL_SIZE) -- no candidate should go unanalyzed by an
artificial cap now that Run B already proved the cache makes repeat runs
cheap; AI_FALLBACK stays reserved for real provider failures. Also added
SEND_ENABLED (default false) and ENVIRONMENT config fields for the real
Slack send gate (used by logic/slack.js, next commit).

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

logic/cache.js

@@ -5,4 +5,13 @@ function needsReanalysis({ memory, currentHash, now }) {
   return { needsAi: false, reason: 'cache_valid' };
 }
 
-module.exports = { needsReanalysis };
+// Chave de cache composta (conteudo do chamado + versao do classificador). Guardada no MESMO
+// campo last_context_hash que ja existia -- sem migracao de schema na Data Table. Uma classe
+// derivada e valida SE E SOMENTE SE contextHash bate E classifierVersion bate: bump de versao
+// (logic/classification.js -> AI_CLASSIFIER_VERSION) forca cache miss em todo chamado, sem
+// precisar apagar a Data Table na mao (missao "finalizacao para producao", secao 12).
+function buildCacheKey(contextHash, classifierVersion) {
+  return `${contextHash}:v${classifierVersion}`;
+}
+
+module.exports = { needsReanalysis, buildCacheKey };

logic/cache.test.js

@@ -1,6 +1,6 @@
 const { test } = require('node:test');
 const assert = require('node:assert/strict');
-const { needsReanalysis } = require('./cache');
+const { needsReanalysis, buildCacheKey } = require('./cache');
 
 test('sem memoria previa, sempre precisa de IA', () => {
   const result = needsReanalysis({ memory: null, currentHash: 'abc', now: 1000 });
@@ -28,3 +28,25 @@ test('next_review_at vencido forca reavaliacao mesmo com hash igual', () => {
   assert.equal(result.needsAi, true);
   assert.equal(result.reason, 'review_due');
 });
+
+test('buildCacheKey combina hash de conteudo e versao do classificador', () => {
+  assert.equal(buildCacheKey('abc123', 3), 'abc123:v3');
+  assert.equal(buildCacheKey('abc123', 4), 'abc123:v4');
+});
+
+test('mudanca de AI_CLASSIFIER_VERSION invalida o cache mesmo com conteudo identico -- missao secao 12', () => {
+  const contentHash = 'abc123';
+  const oldCacheKey = buildCacheKey(contentHash, 2);
+  const newCacheKey = buildCacheKey(contentHash, 3);
+  const memory = { last_context_hash: oldCacheKey, next_review_at: null };
+  const result = needsReanalysis({ memory, currentHash: newCacheKey, now: 1000 });
+  assert.equal(result.needsAi, true, 'bump de versao deve forcar reclassificacao mesmo com o mesmo conteudo');
+});
+
+test('mesma versao + mesmo hash de conteudo usa cache normalmente -- missao secao 12', () => {
+  const cacheKey = buildCacheKey('abc123', 3);
+  const memory = { last_context_hash: cacheKey, next_review_at: null };
+  const result = needsReanalysis({ memory, currentHash: cacheKey, now: 1000 });
+  assert.equal(result.needsAi, false);
+  assert.equal(result.reason, 'cache_valid');
+});

logic/classification.js

@@ -4,6 +4,11 @@ const VALID_CLASSIFICATIONS = [
   'PROJECT_LONG_TERM', 'DUPLICATE_OR_OBSOLETE', 'INSUFFICIENT_CONTEXT',
 ];
 
+// Versao do prompt/classificador. Bump manual sempre que o system prompt ou as regras de
+// validacao mudarem de forma que mudaria o julgamento da IA -- forca cache miss em TODO
+// chamado (ver logic/cache.js -> buildCacheKey), sem precisar apagar a Data Table na mao.
+const AI_CLASSIFIER_VERSION = 3;
+
 // O modelo, apesar do schema permitir null de verdade em blocker_type/waiting_for, as vezes
 // devolve a STRING "null" (ou variantes equivalentes) em vez do valor JSON null. Normaliza
 // aqui, na camada de validacao -- unico lugar que toca a resposta crua da IA.
@@ -16,7 +21,43 @@ function normalizeNullableString(value) {
   return trimmed;
 }
 
-function validateAiClassification(raw) {
+// next_action generico nao prova acionabilidade nenhuma -- ver missao "finalizacao para
+// producao", secao 9. So se aplica a ACTIONABLE_NOW/UNASSIGNED_ACTIONABLE: nessas duas
+// classes o next_action E a evidencia de que existe um proximo passo concreto sob controle
+// do suporte; nas demais classes o campo descreve o que se espera de terceiros, entao uma
+// frase curta ("aguardar resposta") e legitima ali.
+const ACTIONABLE_CLASSES_REQUIRING_CONCRETE_NEXT_ACTION = new Set(['ACTIONABLE_NOW', 'UNASSIGNED_ACTIONABLE']);
+const GENERIC_NEXT_ACTION_PHRASES = new Set([
+  'revisar chamado', 'revisar o chamado', 'dar andamento', 'dar andamento no chamado',
+  'analisar situacao', 'analisar a situacao', 'verificar chamado', 'verificar o chamado',
+  'acompanhar', 'acompanhar chamado', 'acompanhar o chamado',
+]);
+
+function normalizeForComparison(text) {
+  return String(text || '')
+    .trim()
+    .toLowerCase()
+    .normalize('NFD')
+    .replace(/[̀-ͯ]/g, '') // remove acentos (combining marks) p/ comparar "situação" == "situacao"
+    .replace(/[.!]+$/g, '');
+}
+
+function isGenericNextAction(nextAction) {
+  return GENERIC_NEXT_ACTION_PHRASES.has(normalizeForComparison(nextAction));
+}
+
+// Guarda deterministica: tecnico interno (aparece no campo TECNICO do proprio chamado) nunca
+// pode ser tratado como fornecedor externo (WAITING_VENDOR). Ver missao "finalizacao para
+// producao", secao 6. Isso nao depende do prompt se comportar bem -- e verificado aqui.
+function isWaitingForInternalTechnician(waitingFor, ticket) {
+  if (!waitingFor || !ticket || !ticket.tecnico_atribuido) return false;
+  const tecnico = normalizeForComparison(ticket.tecnico_atribuido);
+  const alvo = normalizeForComparison(waitingFor);
+  if (!alvo || tecnico === 'sem tecnico atribuido') return false;
+  return tecnico.includes(alvo);
+}
+
+function validateAiClassification(raw, ticket) {
   const errors = [];
   if (!raw || typeof raw !== 'object') {
     return { valid: false, data: null, errors: ['resposta nao e um objeto JSON'] };
@@ -27,10 +68,22 @@ function validateAiClassification(raw) {
   if (typeof raw.actionable_today !== 'boolean') errors.push('actionable_today deve ser boolean');
   const confidence = Number(raw.confidence);
   if (!Number.isFinite(confidence) || confidence < 0 || confidence > 1) errors.push('confidence deve estar entre 0 e 1');
-  if (typeof raw.next_action !== 'string' || raw.next_action.trim().length === 0 || raw.next_action.length > 200) errors.push('next_action invalido (vazio ou muito longo)');
+  if (typeof raw.next_action !== 'string' || raw.next_action.trim().length === 0 || raw.next_action.length > 200) {
+    errors.push('next_action invalido (vazio ou muito longo)');
+  } else if (
+    ACTIONABLE_CLASSES_REQUIRING_CONCRETE_NEXT_ACTION.has(raw.classification)
+    && isGenericNextAction(raw.next_action)
+  ) {
+    errors.push(`next_action generico demais para ${raw.classification}: "${raw.next_action}"`);
+  }
   if (raw.evidence != null && !Array.isArray(raw.evidence)) errors.push('evidence deve ser array');
   if (typeof raw.reason !== 'string') errors.push('reason deve ser string');
 
+  const waitingFor = normalizeNullableString(raw.waiting_for);
+  if (raw.classification === 'WAITING_VENDOR' && isWaitingForInternalTechnician(waitingFor, ticket)) {
+    errors.push(`waiting_for ("${waitingFor}") corresponde a tecnico interno do chamado, nao pode ser WAITING_VENDOR`);
+  }
+
   if (errors.length) return { valid: false, data: null, errors };
 
   return {
@@ -41,7 +94,7 @@ function validateAiClassification(raw) {
       actionable_today: raw.actionable_today,
       confidence,
       blocker_type: normalizeNullableString(raw.blocker_type),
-      waiting_for: normalizeNullableString(raw.waiting_for),
+      waiting_for: waitingFor,
       next_action: raw.next_action,
       suggested_action_type: raw.suggested_action_type ?? 'technical_action',
       business_risk: raw.business_risk ?? 'medium',
@@ -49,8 +102,16 @@ function validateAiClassification(raw) {
       evidence: Array.isArray(raw.evidence) ? raw.evidence.slice(0, 5) : [],
       is_fallback: false,
       fallback_reason: null,
+      classifier_version: AI_CLASSIFIER_VERSION,
     },
   };
 }
 
-module.exports = { VALID_CLASSIFICATIONS, validateAiClassification, normalizeNullableString };
+module.exports = {
+  VALID_CLASSIFICATIONS,
+  AI_CLASSIFIER_VERSION,
+  validateAiClassification,
+  normalizeNullableString,
+  isGenericNextAction,
+  isWaitingForInternalTechnician,
+};

logic/classification.test.js

@@ -1,6 +1,6 @@
 const { test } = require('node:test');
 const assert = require('node:assert/strict');
-const { validateAiClassification, VALID_CLASSIFICATIONS } = require('./classification');
+const { validateAiClassification, VALID_CLASSIFICATIONS, AI_CLASSIFIER_VERSION } = require('./classification');
 
 function validRaw(overrides) {
   return Object.assign({
@@ -80,3 +80,56 @@ test('blocker_type/waiting_for com valor real nao sao afetados pela normalizacao
   assert.equal(result.data.blocker_type, 'fornecedor');
   assert.equal(result.data.waiting_for, 'Patricia');
 });
+
+test('AI_CLASSIFIER_VERSION esta definida e e carimbada em toda classificacao valida', () => {
+  assert.equal(typeof AI_CLASSIFIER_VERSION, 'number');
+  const result = validateAiClassification(validRaw({}));
+  assert.equal(result.data.classifier_version, AI_CLASSIFIER_VERSION);
+});
+
+test('tecnico interno (aparece em TECNICO do chamado) nunca vira WAITING_VENDOR -- missao secao 6', () => {
+  const ticket = { tecnico_atribuido: 'Rafael Brito' };
+  const result = validateAiClassification(
+    validRaw({ classification: 'WAITING_VENDOR', waiting_for: 'Rafael Brito', actionable_today: false }),
+    ticket,
+  );
+  assert.equal(result.valid, false);
+  assert.ok(result.errors.some((e) => e.includes('tecnico interno')));
+});
+
+test('WAITING_VENDOR com fornecedor externo de verdade (nao aparece em TECNICO) continua valido', () => {
+  const ticket = { tecnico_atribuido: 'Rafael Brito' };
+  const result = validateAiClassification(
+    validRaw({ classification: 'WAITING_VENDOR', waiting_for: 'fornecimento de baterias', actionable_today: false }),
+    ticket,
+  );
+  assert.equal(result.valid, true);
+});
+
+test('WAITING_VENDOR sem ticket informado (uso legado/sem contexto) nao quebra a validacao', () => {
+  const result = validateAiClassification(
+    validRaw({ classification: 'WAITING_VENDOR', waiting_for: 'fornecedor XPTO', actionable_today: false }),
+  );
+  assert.equal(result.valid, true);
+});
+
+test('next_action generico ("Revisar chamado") e rejeitado para ACTIONABLE_NOW -- missao secao 9', () => {
+  const result = validateAiClassification(validRaw({ classification: 'ACTIONABLE_NOW', next_action: 'Revisar chamado' }));
+  assert.equal(result.valid, false);
+  assert.ok(result.errors.some((e) => e.includes('generico')));
+});
+
+test('next_action generico ("Acompanhar") e rejeitado para UNASSIGNED_ACTIONABLE', () => {
+  const result = validateAiClassification(validRaw({ classification: 'UNASSIGNED_ACTIONABLE', next_action: 'Acompanhar', actionable_today: true }));
+  assert.equal(result.valid, false);
+});
+
+test('next_action concreto ("Realizar inventario das maquinas") passa para ACTIONABLE_NOW', () => {
+  const result = validateAiClassification(validRaw({ classification: 'ACTIONABLE_NOW', next_action: 'Realizar inventário das máquinas' }));
+  assert.equal(result.valid, true);
+});
+
+test('next_action curto tipo "aguardar resposta" e permitido em classes WAITING_* (nao exige verbo de acao do suporte)', () => {
+  const result = validateAiClassification(validRaw({ classification: 'WAITING_REQUESTER', next_action: 'Aguardar resposta do cliente', actionable_today: false }));
+  assert.equal(result.valid, true);
+});

logic/config.js

@@ -15,7 +15,11 @@ function parseConfig(env) {
     aiProvider: e.AI_PROVIDER || 'openai',
     aiModel: e.AI_MODEL || 'gpt-4o-mini',
     candidatePoolSize: toNumber(e.CANDIDATE_POOL_SIZE, 60),
-    aiMaxCandidates: toNumber(e.AI_MAX_CANDIDATES, 30),
+    // Igual a candidatePoolSize por padrao -- nenhum candidato elegivel deve ficar sem
+    // analise semantica por um cap artificial (missao "finalizacao para producao", secao
+    // 13). AI_FALLBACK fica reservado para falha real de provider/timeout, nao para
+    // economia de chamadas dentro de um pool que o cache ja deixou barato de repetir.
+    aiMaxCandidates: toNumber(e.AI_MAX_CANDIDATES, 60),
     topN: Math.min(toNumber(e.TOP_N, 10), 10),
     cooldownDays: toNumber(e.COOLDOWN_DAYS, 1),
     aiConfidenceThreshold: toNumber(e.AI_CONFIDENCE_THRESHOLD, 0.6),
@@ -24,6 +28,11 @@ function parseConfig(env) {
     shadowMode: toBool(e.SHADOW_MODE, true),
     diasSemInteracaoAlerta: toNumber(e.DIAS_SEM_INTERACAO_ALERTA, 2),
     horasSlaRisco: toNumber(e.HORAS_SLA_RISCO, 8),
+    // Gate explicito de envio real -- nunca depende de editar codigo pra habilitar/desabilitar
+    // (missao "finalizacao para producao", secao 22). Default false: so quem liga
+    // explicitamente no Config node manda mensagem de verdade.
+    environment: e.ENVIRONMENT || 'dev',
+    sendEnabled: toBool(e.SEND_ENABLED, false),
   };
 }
 

logic/config.test.js

@@ -7,11 +7,24 @@ test('valores padrao quando env vazio', () => {
   assert.equal(config.aiEnabled, true);
   assert.equal(config.aiProvider, 'openai');
   assert.equal(config.candidatePoolSize, 60);
-  assert.equal(config.aiMaxCandidates, 30);
+  assert.equal(config.aiMaxCandidates, 60);
   assert.equal(config.topN, 10);
   assert.equal(config.aiConfidenceThreshold, 0.6);
   assert.equal(config.shadowMode, true);
   assert.equal(config.devMode, true);
+  assert.equal(config.environment, 'dev');
+  assert.equal(config.sendEnabled, false);
+});
+
+test('aiMaxCandidates default e igual a candidatePoolSize default -- nenhum candidato elegivel fica de fora por cap artificial (missao secao 13)', () => {
+  const config = parseConfig({});
+  assert.equal(config.aiMaxCandidates, config.candidatePoolSize);
+});
+
+test('SEND_ENABLED=true liga o envio real; ENVIRONMENT=production e respeitado', () => {
+  const config = parseConfig({ SEND_ENABLED: 'true', ENVIRONMENT: 'production' });
+  assert.equal(config.sendEnabled, true);
+  assert.equal(config.environment, 'production');
 });
 
 test('AI_ENABLED=false desliga a IA', () => {

n8n/nodes/decide-needs-ai.node.js

@@ -1,4 +1,4 @@
-// @requires config.js cache.js
+// @requires config.js cache.js classification.js
 // Instancia bloqueia $env em Code nodes -- config vem do node "Config - Coordenador GLPI v2".
 const config = parseConfig($('Config - Coordenador GLPI v2').first().json);
 const now = Date.now();
@@ -12,8 +12,14 @@ for (const row of memoryRows) memoryByTicket[String(row.ticket_id)] = row;
 
 const withDecision = items.map((item) => {
   const memory = memoryByTicket[String(item.ticket.id)] || null;
-  const analysis = needsReanalysis({ memory, currentHash: item.contextHash, now });
-  return { ticket: item.ticket, contextHash: item.contextHash, memory, needsAiReason: analysis.reason, needsAiRaw: analysis.needsAi };
+  // Chave de cache = conteudo do chamado + versao do classificador (logic/cache.js). Bump de
+  // AI_CLASSIFIER_VERSION forca cache miss em TODO chamado, mesmo sem nenhuma mudanca real no
+  // GLPI -- sem precisar apagar a Data Table na mao (missao "finalizacao para producao", secao 12).
+  const cacheKey = buildCacheKey(item.contextHash, AI_CLASSIFIER_VERSION);
+  const analysis = needsReanalysis({ memory, currentHash: cacheKey, now });
+  return {
+    ticket: item.ticket, contextHash: item.contextHash, cacheKey, memory, needsAiReason: analysis.reason, needsAiRaw: analysis.needsAi,
+  };
 });
 
 const needingAi = withDecision
@@ -35,6 +41,7 @@ return withDecision.map((item) => {
     json: {
       ticket: item.ticket,
       contextHash: item.contextHash,
+      cacheKey: item.cacheKey,
       memory: item.memory,
       needsAiReason: item.needsAiReason,
       resolucao,

n8n/nodes/prepare-ai-prompt.node.js

@@ -11,9 +11,36 @@ const systemPrompt = [
   'Distinga evidencia (o que esta escrito no chamado) de inferencia (sua conclusao).',
   'SLA vencido sozinho NAO e evidencia de que existe uma acao executavel agora.',
   'Idade do chamado sozinha NAO e evidencia de acionabilidade.',
-  'Identifique: existe acao executavel hoje? quem pode executar? existe bloqueio? quem segura o bloqueio? qual a proxima acao concreta? existe data conhecida para revisao? existe evidencia nos apontamentos que justifique a conclusao?',
-  'Se a informacao for insuficiente para decidir com confianca, use a classificacao INSUFFICIENT_CONTEXT e confidence baixo -- nao invente uma acao.',
-  `Responda em JSON estrito com os campos: classification (uma de: ${VALID_CLASSIFICATIONS.join(', ')}), actionable_today (boolean), confidence (0 a 1), blocker_type, waiting_for, next_action (curto, poucas palavras, sem paragrafo), suggested_action_type, business_risk (low|medium|high), reason (uma frase), evidence (lista curta de evidencias textuais encontradas).`,
+  '',
+  '=== O QUE SIGNIFICA ACIONAVEL (ACTIONABLE_NOW / UNASSIGNED_ACTIONABLE) ===',
+  'ACTIONABLE_NOW significa: existe pelo menos uma acao concreta que um integrante do suporte pode executar AGORA para fazer o chamado avancar. NAO precisa significar que o chamado sera resolvido integralmente hoje -- precisa significar que o suporte consegue fazer algo util agora.',
+  'Isso INCLUI, entre outras: executar diagnostico; testar equipamento; verificar configuracao; solicitar informacao ao cliente (quando ainda NAO foi solicitada); entrar em contato com fornecedor (quando ainda NAO foi contatado); marcar/agendar visita; combinar horario; atribuir tecnico; realizar inventario; validar cenario; executar instalacao; iniciar migracao; cobrar informacao que ainda NAO foi solicitada; atualizar configuracao; reproduzir problema; levantar requisitos; ou qualquer outro proximo passo concreto sob controle do suporte.',
+  '',
+  '=== CONTATAR != AGUARDAR (diferenca critica) ===',
+  'Precisar contatar alguem (cliente ou fornecedor) que AINDA NAO foi contatado e ACIONAVEL AGORA: ex. "Precisamos perguntar ao cliente qual horario pode realizar a manutencao" -> ACTIONABLE_NOW, next_action "Contatar cliente para combinar horario". "Precisamos pedir orcamento ao fornecedor" -> ACTIONABLE_NOW.',
+  'Ja ter contatado e estar esperando resposta e WAITING_*: ex. "Cliente ja foi contatado em 23/08 e estamos aguardando resposta" -> WAITING_REQUESTER. "Orcamento ja solicitado; aguardando retorno do fornecedor" -> WAITING_VENDOR.',
+  'So classifique WAITING_REQUESTER, WAITING_VENDOR ou WAITING_APPROVAL quando existir evidencia POSITIVA no historico de que (1) a acao necessaria ja foi executada pelo suporte E (2) existe uma dependencia externa ainda aberta. Sem essa evidencia dupla, NAO assuma espera -- procure se existe uma acao ainda nao realizada primeiro.',
+  '',
+  '=== TECNICO INTERNO NAO E FORNECEDOR ===',
+  'O campo TECNICO do chamado lista responsaveis/tecnicos internos da equipe de suporte. Se uma pendencia depende de alguem listado nesse campo, NUNCA classifique como WAITING_VENDOR (fornecedor externo) -- normalmente e ACTIONABLE_NOW (se o proprio suporte pode agir) ou UNASSIGNED_ACTIONABLE (se depende de atribuicao). WAITING_VENDOR e reservado para fornecedores/terceiros genuinamente externos a equipe.',
+  '',
+  '=== STATUS "PLANEJADO" NAO SIGNIFICA BLOQUEADO ===',
+  'STATUS Planejado sozinho NAO significa WAITING_REQUESTER, WAITING_VENDOR nem SCHEDULED. Se existe tarefa ou apontamento descrevendo um passo operacional disponivel agora, o chamado pode ser ACTIONABLE_NOW mesmo estando "Planejado".',
+  'Use SCHEDULED apenas quando existir data, horario, janela ou evento futuro explicito no chamado (ou evidencia inequivoca de que nenhuma acao pode/deve ocorrer antes dessa data).',
+  '',
+  '=== CRONOLOGIA E OBRIGATORIA ===',
+  'Interprete os apontamentos em ordem temporal -- o mais recente relevante prevalece sobre um bloqueio antigo ja superado. Exemplo: "20/08 aguardando fornecedor" seguido de "22/08 pecas chegaram" seguido de "23/08 falta instalar" -> ACTIONABLE_NOW (instalar pecas), NAO WAITING_VENDOR. Nao se prenda a um estado antigo se um apontamento mais novo o superou.',
+  '',
+  '=== NEXT_ACTION DEVE SER CONCRETO ===',
+  'Para ACTIONABLE_NOW/UNASSIGNED_ACTIONABLE, next_action precisa nomear a acao real: "Realizar inventario das maquinas", "Contatar cliente para combinar recolha", "Testar nobreak com carga", "Atribuir tecnico para visita", "Iniciar migracao dos e-mails", "Validar configuracao da impressora", "Solicitar dados de acesso ao cliente".',
+  'NUNCA aceite como next_action frases genericas que nao provam acionabilidade nenhuma: "Revisar chamado", "Dar andamento", "Analisar situacao", "Verificar chamado", "Acompanhar". Se voce so consegue pensar numa frase generica dessas, reconsidere a classificacao -- provavelmente falta evidencia concreta.',
+  '',
+  '=== QUANDO USAR INSUFFICIENT_CONTEXT ===',
+  'Antes de classificar como INSUFFICIENT_CONTEXT, pergunte-se: existe alguma acao concreta que o suporte consegue executar mesmo sem informacao completa? Falta de diagnostico nao significa falta de acao -- ex. "nao sabemos por que o notebook nao conecta" ainda pode ser ACTIONABLE_NOW com next_action "Realizar diagnostico de conectividade".',
+  'Use INSUFFICIENT_CONTEXT somente quando realmente nao for possivel determinar um proximo passo razoavelmente especifico -- nem mesmo um passo de diagnostico/investigacao.',
+  '',
+  'Identifique sempre: existe acao executavel hoje? quem pode executar? existe bloqueio? quem segura o bloqueio (interno ou externo)? qual a proxima acao concreta? existe data conhecida para revisao? existe evidencia nos apontamentos, em ordem cronologica, que justifique a conclusao?',
+  `Responda em JSON estrito com os campos: classification (uma de: ${VALID_CLASSIFICATIONS.join(', ')}), actionable_today (boolean), confidence (0 a 1), blocker_type, waiting_for, next_action (curto, poucas palavras, sem paragrafo, deve ser uma acao concreta quando ACTIONABLE_NOW/UNASSIGNED_ACTIONABLE), suggested_action_type, business_risk (low|medium|high), reason (uma frase), evidence (lista curta de evidencias textuais encontradas, em ordem cronologica quando relevante).`,
 ].join('\n');
 
 return $input.all().map((item) => {

n8n/nodes/prepare-ai-prompt.node.test.js

@@ -0,0 +1,69 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+// O prompt em si nao pode ser testado deterministicamente sem chamar a IA de verdade -- estes
+// testes garantem que as REGRAS exigidas pela missao "finalizacao para producao" continuam
+// escritas no prompt (nao foram removidas/reescritas por acidente numa edicao futura). A prova
+// comportamental real fica nas execucoes reais contra o GLPI (Run com AI_CLASSIFIER_VERSION
+// nova), inspecionadas manualmente no relatorio.
+function readPrompt() {
+  return fs.readFileSync(path.join(__dirname, 'prepare-ai-prompt.node.js'), 'utf8');
+}
+
+test('prompt define acionabilidade de forma pratica ("suporte consegue fazer algo util agora")', () => {
+  const src = readPrompt();
+  assert.ok(/suporte consegue fazer algo util agora/i.test(src));
+});
+
+test('prompt distingue contatar (ainda nao feito) de aguardar (ja feito) -- teste obrigatorio #2/#3', () => {
+  const src = readPrompt();
+  assert.ok(/AINDA NAO foi contatado/.test(src));
+  assert.ok(/ja foi contatado/i.test(src) || /Ja ter contatado/.test(src));
+});
+
+test('prompt exige evidencia dupla (acao ja executada + dependencia externa aberta) pra WAITING_*', () => {
+  const src = readPrompt();
+  assert.ok(/evidencia POSITIVA/.test(src));
+  assert.ok(/dependencia externa ainda aberta/.test(src));
+});
+
+test('prompt instrui que tecnico interno (campo TECNICO) nunca vira WAITING_VENDOR -- teste obrigatorio #1', () => {
+  const src = readPrompt();
+  assert.ok(/NUNCA classifique como WAITING_VENDOR/.test(src));
+  assert.ok(/tecnicos internos da equipe de suporte/.test(src));
+});
+
+test('prompt instrui que STATUS Planejado sozinho nao significa bloqueio -- teste obrigatorio #6', () => {
+  const src = readPrompt();
+  assert.ok(/Planejado sozinho NAO significa/.test(src));
+});
+
+test('prompt exige data/horario/janela explicita para SCHEDULED', () => {
+  const src = readPrompt();
+  assert.ok(/SCHEDULED apenas quando existir data, horario, janela/.test(src));
+});
+
+test('prompt exige interpretacao cronologica (apontamento mais recente prevalece) -- teste obrigatorio #8', () => {
+  const src = readPrompt();
+  assert.ok(/ordem temporal/.test(src));
+  assert.ok(/mais recente relevante prevalece/.test(src));
+});
+
+test('prompt rejeita next_action generico com exemplos explicitos', () => {
+  const src = readPrompt();
+  for (const frase of ['Revisar chamado', 'Dar andamento', 'Analisar situacao', 'Verificar chamado', 'Acompanhar']) {
+    assert.ok(src.includes(frase), `prompt deveria citar "${frase}" como exemplo generico rejeitado`);
+  }
+});
+
+test('prompt pede para considerar acao de diagnostico antes de usar INSUFFICIENT_CONTEXT -- teste obrigatorio #7', () => {
+  const src = readPrompt();
+  assert.ok(/Falta de diagnostico nao significa falta de acao/.test(src));
+});
+
+test('prompt continua exigindo resposta em JSON estrito com o dominio de classes correto', () => {
+  const src = readPrompt();
+  assert.ok(src.includes('VALID_CLASSIFICATIONS.join'));
+});

n8n/nodes/prepare-memoria-analise-record.node.js

@@ -11,7 +11,10 @@ return items.map((data) => {
     json: {
       ticket_id: data.ticket.id,
       last_analyzed_at: data.contextChanged ? data.now : (data.memory ? data.memory.last_analyzed_at : data.now),
-      last_context_hash: data.contextHash,
+      // Guarda a chave composta (hash de conteudo + AI_CLASSIFIER_VERSION), nao o hash puro --
+      // e o que faz o cache invalidar sozinho quando o prompt/classificador muda de versao,
+      // sem precisar apagar a Data Table na mao. Ver logic/cache.js -> buildCacheKey.
+      last_context_hash: data.cacheKey,
       last_meaningful_change_at: data.contextChanged ? data.now : (data.memory ? data.memory.last_meaningful_change_at : data.now),
       ai_classification: cls,
       ai_confidence: data.aiClassification.confidence,

n8n/nodes/validate-ai-response.node.js

@@ -18,8 +18,17 @@ return responseItems.map((responseItem, index) => {
     raw = null;
   }
 
-  const validation = validateAiClassification(raw);
-  const aiClassification = validation.valid ? validation.data : buildFallbackClassification('invalid_json');
+  // Passa o ticket pra validacao poder aplicar a guarda deterministica "tecnico interno nunca
+  // vira WAITING_VENDOR" (logic/classification.js -> isWaitingForInternalTechnician). Sem
+  // isso a validacao so olha o JSON cru, nunca os fatos do proprio chamado.
+  const validation = validateAiClassification(raw, original.ticket);
+  let aiClassification;
+  if (validation.valid) {
+    aiClassification = validation.data;
+  } else {
+    const isSemanticConflict = validation.errors.some((e) => e.includes('tecnico interno'));
+    aiClassification = buildFallbackClassification(isSemanticConflict ? 'ai_semantic_conflict' : 'invalid_json');
+  }
 
   return { json: { ...original, aiClassification } };
 });