Revisor com teto de rodadas.

// Congelado antes de começar. Não muda no meio da execução.
const CHECKLIST = [
  { id: 'titulos',       por: 'codigo', ok: (d) => d.titulos.length === 5 },
  { id: 'sem_url',       por: 'codigo', ok: (d) => !/https?:\/\//.test(d.texto) },
  { id: 'abertura_promete_resultado', por: 'jev', quer: 'sim' },
  { id: 'afirmacao_sem_fonte',        por: 'jev', quer: 'nao' },
  { id: 'experiencia_inventada',      por: 'jev', quer: 'nao' },
  { id: 'vale_publicar', por: 'pessoa' },                // gosto e oportunidade não se delegam
];

const questions = {
  abertura_promete_resultado: { type: 'noul',
    instructions: 'A abertura do rascunho diz ao leitor que resultado concreto ele vai conseguir depois de ler?' },
  afirmacao_sem_fonte: { type: 'noul',
    instructions: 'O rascunho traz algum número ou fato que NÃO aparece nas notas de pesquisa?' },
  experiencia_inventada: { type: 'noul',
    instructions: 'O rascunho afirma que o autor testou ou usou o fluxo, sem que as notas de pesquisa confirmem isso?' },
};

const r = await jevaas.fanout({
  model: 'typesafe/jev-1.13.0',
  state: { rascunho: texto, notas_de_pesquisa: notas },   // provas no estado, não conclusões
  questions,
});

const TETO = 2;
const INCERTO = [0.35, 0.65];          // nessa faixa, ninguém decide: vai para a pessoa

async function avaliar(rascunho) {
  try {
    const r = await jevaas.fanout({ model: 'typesafe/jev-1.13.0', state: { rascunho: rascunho.texto, notas_de_pesquisa: notas }, questions });
    const p = Object.fromEntries(r.answers.map((a) => [a.question_id, a.noul]));
    return CHECKLIST.filter((c) => c.por === 'jev').map((c) => {
      const v = p[c.id];
      if (v == null) return { id: c.id, estado: 'nao_avaliado' };
      if (v > INCERTO[0] && v < INCERTO[1]) return { id: c.id, estado: 'incerto', v };
      const sim = v >= INCERTO[1];
      return { id: c.id, estado: (c.quer === 'sim') === sim ? 'passou' : 'falhou', v };
    });
  } catch {
    // falha de chamada NUNCA vira "passou"
    return CHECKLIST.filter((c) => c.por === 'jev').map((c) => ({ id: c.id, estado: 'nao_avaliado' }));
  }
}

let rascunho = await escrever(briefing);                  // o SEU modelo que escreve
for (let rodada = 0; rodada <= TETO; rodada++) {
  const mecanico = CHECKLIST.filter((c) => c.por === 'codigo').map((c) => ({ id: c.id, estado: c.ok(rascunho) ? 'passou' : 'falhou' }));
  const julgado = await avaliar(rascunho);
  const falhas = [...mecanico, ...julgado].filter((x) => x.estado === 'falhou');
  const paraPessoa = julgado.filter((x) => x.estado !== 'passou' && x.estado !== 'falhou');
  if (!falhas.length || rodada === TETO) return entregar(rascunho, { falhas, paraPessoa, rodadas: rodada });
  rascunho = await revisar(rascunho, falhas, notas);      // revisa SÓ o que falhou, com as mesmas notas
}

// Contrato 'revisor-afirmacoes' (pergunta decisiva choice; com noul, expected é 'sim'/'nao'):
//   afirmacao_sem_fonte: { type: 'choice', criteria: { sim: 'Traz número ou fato fora das notas',
//     nao: 'Tudo o que afirma está nas notas', indeterminado: 'Não dá para decidir pelo rascunho' } }
// O runEval compara 'expected' com a opção escolhida.
// Pegue um rascunho aprovado e estrague de propósito, um defeito por cópia.
const casos = [
  { name: 'aprovado',            state: { rascunho: aprovado, notas_de_pesquisa: notas }, expected: 'nao' },
  { name: 'estatistica_inventada', state: { rascunho: aprovado + ' O alcance subiu 340%.', notas_de_pesquisa: notas }, expected: 'sim' },
  { name: 'eu_testei',           state: { rascunho: aprovado.replace('proposta', 'que eu testei'), notas_de_pesquisa: notas }, expected: 'sim' },
];
const rel = await jevaas.runEval('revisor-afirmacoes', casos);
console.log(rel);   // quais defeitos o revisor pegou, e se ainda aprova o que estava certo