senado-br-mcp 3.19.0 → 3.20.0

package/README.md

@@ -688,7 +688,7 @@ The frozen NDJSON is **not** committed (built from the sovereign D1 corpus on de
 | `senado_ecidadania_obter_consulta` | Detalhe de uma consulta: votos, autor, relator, comentários |
 | `senado_ecidadania_consultas_analise` | Analisa o conjunto completo de consultas **abertas** via `modo` (consenso/polarizada); `status` padrão `aberta` |
 | `senado_ecidadania_listar_ideias` | Ideias legislativas de cidadãos; ranking das mais apoiadas via `ordenarPor: apoios` |
-| `senado_ecidadania_obter_ideia` | Detalhe de uma ideia: texto, apoios, status de conversão em projeto |
+| `senado_ecidadania_obter_ideia` | Detalhe de uma ideia: texto, apoios, data em que foi proposta, linha do tempo (meta, Sugestão, decisão da CDH, encerramento) e proposições em que virou |
 | `senado_ecidadania_listar_eventos` | Eventos interativos (audiências, sabatinas, lives); ranking dos mais comentados via `ordenarPor` |
 | `senado_ecidadania_obter_evento` | Detalhe de um evento: pauta, convidados, link de vídeo |
 | `senado_ecidadania_sugerir_tema_enquete` | Sugere temas para enquete mensal a partir de critérios configuráveis |

package/dist/dataset/schema.js

@@ -167,8 +167,8 @@ const ideiasSchema = {
             type: "string",
             description: "Título da ideia legislativa.",
             sourceEndpoint: EP_IDEIAS_LISTING,
-            sourceField: "article.resumo-ideia > section > a (texto da âncora)",
-            operationalization: "Texto da âncora da seção, com entidades HTML decodificadas.",
+            sourceField: "li.resumo-ideia > a > h4 (até 11/10/2026: article.resumo-ideia > section > a)",
+            operationalization: "Texto do <h4> do bloco (antes de 12/10/2026, da âncora da seção), com entidades HTML decodificadas.",
         },
         {
             name: "apoios",
@@ -176,8 +176,8 @@ const ideiasSchema = {
             unit: "apoios",
             description: "Número de apoios recebidos pela ideia.",
             sourceEndpoint: EP_IDEIAS_LISTING,
-            sourceField: "article.resumo-ideia > figure.grafico-ideia-legislativa > footer > span[1] (\"N apoios\")",
-            operationalization: "Primeiro <span> do footer do figure.grafico-ideia-legislativa (\"253.804 apoios\"); número BR via parseBrNum. O span de meta (limiar) é ignorado.",
+            sourceField: "li.resumo-ideia > a > figure.componente-grafico-ideia > figcaption > span.contabilizacao (\"N apoios confirmados\"; até 11/10/2026: article.resumo-ideia > figure.grafico-ideia-legislativa > footer > span[1])",
+            operationalization: "Número do span.contabilizacao (\"253.804 apoios confirmados\"; antes de 12/10/2026, primeiro <span> do footer do figure.grafico-ideia-legislativa); número BR via parseBrNum. O span de meta (\"Meta de 20.000 apoios\") é ignorado.",
         },
         {
             name: "status",
@@ -185,7 +185,7 @@ const ideiasSchema = {
             description: "Situação da ideia: \"aberta\" | \"encerrada\" | \"convertida\" | \"removida\" (retirada do portal; demais campos = último estado conhecido).",
             sourceEndpoint: EP_IDEIAS_LISTING,
             sourceField: "(derivado) parâmetro GET situacao da listagem varrida",
-            operationalization: "A listagem é varrida por situacao=N; o status é o mapa SITUACAO_STATUS ({5,6,8}→aberta, {7,9}→encerrada, 10→convertida) do valor usado no crawl. Ideia que sai das listas vivas tem a página de detalhe lida e recebe o status do texto de situação (mesmo mapa); \"removida\" quando o detalhe responde HTTP 410 (desde 06/10/2026).",
+            operationalization: "A listagem é varrida por situacao=N; o status é o mapa SITUACAO_STATUS ({5,6,8}→aberta, {7,9}→encerrada, 10→convertida) do valor usado no crawl. Ideia que sai das listas vivas tem a página de detalhe lida: até 12/10/2026 recebia o status do texto de situação (mesmo mapa); a página redesenhada não publica mais a situação, e desde a 3.20.0 o status vem da categoria da listagem quando a ideia aparece na fatia da situacao 7 da mesma rodada e, senão, é classificado pela linha do tempo do detalhe (regra que reproduz a categoria do portal em 335 de 336 ideias medidas em 17/10/2026). \"removida\" quando o detalhe responde HTTP 410 (desde 06/10/2026).",
             derived: true,
         },
         {
@@ -193,7 +193,7 @@ const ideiasSchema = {
             type: "date",
             description: "Data limite para atingir os 20.000 apoios (única âncora temporal upstream da ideia). NÃO é a data de criação: o nome é histórico, mantido pela compatibilidade do esquema.",
             sourceEndpoint: EP_IDEIAS_DETALHE,
-            sourceField: "página de detalhe: bloco \"Data limite para receber 20.000 apoios\" (DD/MM/AAAA)",
+            sourceField: "página de detalhe: até 12/10/2026 o bloco \"Data limite para receber 20.000 apoios\"; depois, a linha do tempo \"Essa ideia pode receber apoios até DD/MM/AAAA\"",
             operationalization: "extractDate sobre a data-limite exibida no detalhe (visualizacaoideia) → ISO YYYY-MM-DD; lido no crawl de detalhe. Reaberto na v2 (era null por design na v1). Data provável de criação = esta data − 120 dias (regra dos 4 meses do portal; medida exata em 4 ideias convertidas de 2017-2020 contra a base de Pereira, UFPE 2024) — derivação do leitor, não variável do dataset.",
             caveat: "Em ideia aberta esta data está no futuro (é o fim do prazo de apoios). Detail-only (v2): null nas ideias ainda não enriquecidas pelo backfill de detalhe (censura à esquerda residual nesses campos até o backfill completar).",
         },
@@ -202,7 +202,7 @@ const ideiasSchema = {
             type: "string",
             description: "UF do cidadão autor da ideia (SEM nome — conteúdo de cidadão).",
             sourceEndpoint: EP_IDEIAS_DETALHE,
-            sourceField: "página de detalhe: \"Ideia proposta por … (UF)\" — apenas o \"(UF)\"",
+            sourceField: "página de detalhe: \"Ideia proposta por … (UF)\" (na linha do tempo desde 12/10/2026) — apenas o \"(UF)\"",
             operationalization: "Extrai só a sigla de UF entre parênteses; o NOME do cidadão é descartado NA ORIGEM (nunca gravado no corpus). Postura de privacidade: conteúdo de cidadão → só UF.",
             caveat: "Detail-only (v2): null nas ideias ainda não enriquecidas. Nome do autor deliberadamente não coletado.",
         },
@@ -220,8 +220,8 @@ const ideiasSchema = {
             type: "string",
             description: "Proposição gerada pela ideia (ex.: \"SUG 12/2024\"), quando convertida.",
             sourceEndpoint: EP_IDEIAS_DETALHE,
-            sourceField: "página de detalhe: identificação da proposição (SUG/PL nº)",
-            operationalization: "Regex de identificação de proposição no detalhe; null quando a ideia não gerou proposição.",
+            sourceField: "página de detalhe: identificação da proposição (SUG/PL nº); desde a 3.20.0, o acontecimento \"Essa ideia gerou a Sugestão nº N, de AAAA\" da linha do tempo",
+            operationalization: "Até a 3.19: regex de identificação de proposição no detalhe. Desde a 3.20.0 (página redesenhada): a Sugestão gerada, \"SUG N/AAAA\"; as proposições em que a ideia virou (pela CDH ou adotada por parlamentar) saem só no detalhe ao vivo (senado_ecidadania_obter_ideia). Leitura sem Sugestão não apaga valor já gravado.",
             caveat: "Detail-only (v2): null nas ideias ainda não enriquecidas ou não convertidas.",
         },
         {

package/dist/scraper/ecidadania.js

@@ -13,6 +13,8 @@ import { UpstreamError as PkgUpstreamError } from "@sbissoli/mcp-upstream";
 import { UPSTREAM_TIMEOUT_MS } from "../types.js";
 import { USER_AGENT } from "../version.js";
 import { CorpoForaDoPrazoError, PrazoDoCorpo, upstreamCall } from "../throttle/upstream.js";
+import { lerBrNum, mesclarCampo } from "./mesclar.js";
+import { lerIdeiaDetalhe } from "./ideia-detalhe.js";
 export const ECIDADANIA_BASE = "https://www12.senado.leg.br/ecidadania";
 /**
  * Error carrying a `retryable` flag, mirroring UpstreamError so the tool layer
@@ -123,7 +125,7 @@ async function idaEcidadania(path, headers, rotulo) {
         throw e;
     }
 }
-/** Parse Brazilian number: 1.234.567 -> 1234567 */
+/** Parse Brazilian number: 1.234.567 -> 1234567. Ausente/lixo → 0: NÃO use em escritor do corpus (ver `lerBrNum`). */
 export function parseBrNum(s) {
     return parseInt(s.replace(/\./g, ""), 10) || 0;
 }
@@ -206,21 +208,34 @@ export async function obterConsultaDetalheCorpus(id) {
     const html = await fetchPage(`/visualizacaomateria?id=${id}`);
     return parseConsultaDetalheCorpus(html);
 }
+export async function lerDestaquesConsultas() {
+    const data = await fetchEcidadaniaJson("/restcolecaomaismateria");
+    return data.map((item) => ({
+        id: item.id,
+        materia: item.identificacaoBasica || "",
+        ementa: item.ementa || "",
+        votosSim: lerBrNum(item.votosFavor),
+        votosNao: lerBrNum(item.votosContra),
+        totalVotos: lerBrNum(item.totalVotos),
+    }));
+}
 export async function listarConsultasInternal(params) {
     const { limite = 20 } = params;
-    const data = await fetchEcidadaniaJson("/restcolecaomaismateria");
+    const data = await lerDestaquesConsultas();
     // status is hardcoded "aberta" here because this path serves only the REST "highlight"
     // collection (/restcolecaomais*), which lists active consultations by construction. Real
     // per-item status for the full set is derived from /processo (tramitando) in the ingestion
     // job, which is the source of truth. Edge case: a just-closed highlight may briefly show
     // "aberta" until the next corpus run corrects it — acceptable on this cold-start/fallback path.
+    // Contagem ausente vira 0 só AQUI, na saída ao vivo (comportamento histórico da tool); o splice
+    // do corpus lê `lerDestaquesConsultas` e não grava esse 0.
     return data.slice(0, limite).map((item) => buildConsultaResumo({
         id: item.id,
-        materia: item.identificacaoBasica || "",
-        ementa: item.ementa || "",
-        votosSim: parseBrNum(String(item.votosFavor || "0")),
-        votosNao: parseBrNum(String(item.votosContra || "0")),
-        totalVotos: parseBrNum(String(item.totalVotos || "0")),
+        materia: item.materia,
+        ementa: item.ementa,
+        votosSim: item.votosSim ?? 0,
+        votosNao: item.votosNao ?? 0,
+        totalVotos: item.totalVotos ?? 0,
         status: "aberta",
     }));
 }
@@ -284,9 +299,17 @@ export const IDEIA_PRAZO_APOIOS_DIAS = 120;
  * da tool: a descrição é lida uma vez, o dado é lido a cada resposta, e a data limite de uma ideia
  * aberta cai no futuro — sem o aviso o leitor conclui que o servidor errou.
  */
-export const AVISO_DATAS_IDEIA = "dataPublicacao é a data limite para receber os 20.000 apoios, a única data que o portal publica (o nome do campo é histórico); " +
+export const AVISO_DATAS_IDEIA = "dataPublicacao é a data limite para receber os 20.000 apoios, a única data que o corpus guarda (o nome do campo é histórico); " +
     "por isso cai no futuro em ideia aberta. dataCriacaoEstimada = data limite menos 120 dias, calculada pelo servidor " +
-    "(regra dos 4 meses do portal, medida em 4 ideias de 2017-2020): é estimativa, não dado da fonte.";
+    "(regra dos 4 meses do portal, medida em 4 ideias de 2017-2020): é estimativa, não dado da fonte. " +
+    "A data real em que a ideia foi proposta sai em senado_ecidadania_obter_ideia (dataProposta).";
+/**
+ * Aviso de datas do DETALHE: desde o redesenho de 12/10/2026 a página publica a data de proposição
+ * na linha do tempo. `dataCriacaoEstimada` fica por compatibilidade.
+ */
+export const AVISO_DATAS_IDEIA_DETALHE = "dataProposta é a data em que a ideia foi proposta, publicada pela fonte — use esta. dataPublicacao (= prazoApoios) é a " +
+    "data limite para receber os 20.000 apoios (o nome do campo é histórico). dataCriacaoEstimada (data limite menos 120 dias, " +
+    "calculada pelo servidor) é estimativa mantida por compatibilidade.";
 /**
  * Data provável de criação da ideia: data limite (ISO) − `IDEIA_PRAZO_APOIOS_DIAS`. Aritmética em UTC
  * sobre o dia civil (sem fuso, sem horário de verão). Data ausente ou inválida → null, nunca uma data
@@ -329,124 +352,37 @@ export function buildIdeiaResumo(fields) {
         url: fields.url || `${ECIDADANIA_BASE}/visualizacaoideia?id=${fields.id}`,
     };
 }
-/**
- * Texto da situação na página de detalhe (`<em>` em section[title="Situação da Ideia"]) → vocabulário
- * de status do corpus (aberta | encerrada | convertida), o MESMO que `SITUACAO_STATUS` atribui por
- * bucket da listagem. Uma função só, usada pela tool ao vivo e pelo crawl de transições — antes
- * cada um tinha o seu mapeamento, e o da tool lia "Não acatada" (bucket 9, encerrada) como aberta.
- *
- * Textos REAIS medidos em 06/10/2026, uma ideia por bucket:
- *   s5 "Aberta" · s6 "Na comissão" · s8 "Aguardando envio à CDH"      → aberta
- *   s7 "Encerrada - Sem apoio suficiente" · s9 "Não acatada"          → encerrada
- *   s10 "Convertida em Proposição"                                     → convertida
- *
- * Comparação EXATA (sem caixa e sem acento), decisão do dono em 06/10/2026: texto novo do portal vira
- * null e aparece no log, em vez de ser gravado no histórico com um status adivinhado por palavra-chave.
- * Se o log mostrar um texto novo, acrescente-o aqui e no teste dos textos medidos.
- */
 /**
  * Status de corpus de uma ideia que o portal REMOVEU (detalhe responde HTTP 410). Não vem de texto de
  * situação — o portal não publica nada sobre ela —, só da resposta 410. Decisão do dono (06/10/2026):
  * manter o registro e o histórico no banco com este status, em vez de apagar ou deixar "aberta".
  */
 export const STATUS_IDEIA_REMOVIDA = "removida";
-export function statusFromSituacaoIdeia(texto) {
-    const t = texto.normalize("NFD").replace(/\p{Diacritic}/gu, "").toLowerCase();
-    if (t === "aberta" || t === "na comissao" || t === "aguardando envio a cdh")
-        return "aberta";
-    if (t === "encerrada - sem apoio suficiente" || t === "nao acatada")
-        return "encerrada";
-    if (t === "convertida em proposicao")
-        return "convertida";
-    return null;
-}
-/** Texto cru da situação da ideia na página de detalhe, ou null se a seção não existe. */
-export function extractSituacaoIdeia(html) {
-    const m = html.match(/title="Situa[çc][ãa]o da Ideia"[\s\S]*?<em>([^<]+)<\/em>/i);
-    // O portal manda o texto em UTF-8 literal ("Não acatada", medido 06/10/2026) — sem entidades.
-    return m ? m[1].replace(/\s+/g, " ").trim() : null;
-}
-/**
- * Pure parser of an idea detail page (`visualizacaoideia?id=`) for the CORPUS — extracts only the
- * four detail fields, keeping ONLY the UF of the citizen author (name discarded at source, never
- * returned). Distinct from `obterIdeiaInternal` (the live tool), which still surfaces the portal's
- * semi-anonymized author string; this corpus path never touches the name.
- */
-export function parseIdeiaDetalheCorpus(html) {
-    const text = stripHtml(html);
-    // "Ideia proposta por <span>NOME</span> <span>(UF)</span>" — capturamos SÓ a UF.
-    const autorMatch = html.match(/Ideia proposta por<\/div>\s*<div[^>]*>\s*<span>[^<]+<\/span>\s*<span>\s*\(([A-Z]{2})\)<\/span>/);
-    const autorUf = autorMatch ? autorMatch[1] : null;
-    const dataMatch = html.match(/Data limite[\s\S]*?<div[^>]*>\s*(\d{2}\/\d{2}\/\d{4})\s*<\/div>/i);
-    const dataPublicacao = dataMatch ? extractDate(dataMatch[1]) : null;
-    const descMatch = html.match(/<b><div[^>]*>[^<]+<\/div><\/b>\s*<div[^>]*>([\s\S]*?)<\/div>/);
-    const descricao = descMatch ? stripHtml(descMatch[1]).substring(0, 2000) || null : null;
-    const plMatch = text.match(/(SUGEST[ÃA]O|PEC|PL|PLP)\s*n?º?\s*(\d+)\s*(?:de\s*)?(\d{4})/i);
-    const plConvertido = plMatch
-        ? `${plMatch[1].toUpperCase().includes("SUGEST") ? "SUG" : plMatch[1].toUpperCase()} ${plMatch[2]}/${plMatch[3]}`
-        : null;
-    const apoiosMatch = html.match(/class="contabilizacao"[^>]*>([^<]+)</);
-    const apoios = apoiosMatch ? parseBrNum(apoiosMatch[1]) : null;
-    const situacao = extractSituacaoIdeia(html);
-    const status = situacao === null ? null : statusFromSituacaoIdeia(situacao);
-    return { dataPublicacao, autorUf, descricao, plConvertido, apoios, status };
-}
-/** Fetch + parse the corpus-facing (UF-only) idea detail. */
-export async function obterIdeiaDetalheCorpus(id) {
-    const html = await fetchPage(`/visualizacaoideia?id=${id}`);
-    return parseIdeiaDetalheCorpus(html);
+export async function lerDestaquesIdeias() {
+    const data = await fetchEcidadaniaJson("/restcolecaomaisideia");
+    return data.map((item) => ({ id: item.id, titulo: item.titulo || "", apoios: lerBrNum(item.apoiamentos) }));
 }
 export async function listarIdeiasInternal(params) {
     const { limite = 20 } = params;
-    const data = await fetchEcidadaniaJson("/restcolecaomaisideia");
+    const data = await lerDestaquesIdeias();
     // status is hardcoded "aberta" (via the builder default) because this REST "highlight" collection
     // lists active ideas by construction; real per-idea status for the full set comes from the
     // per-situacao corpus crawl (the source of truth). See buildConsultaResumo for the same rationale.
-    let ideias = data.map((item) => buildIdeiaResumo({
-        id: item.id,
-        titulo: item.titulo || "",
-        apoios: parseBrNum(String(item.apoiamentos || "0")),
-    }));
+    // apoios ausente vira 0 só na saída ao vivo (histórico da tool); o splice não grava esse 0.
+    let ideias = data.map((item) => buildIdeiaResumo({ id: item.id, titulo: item.titulo, apoios: item.apoios ?? 0 }));
     if (params.ordenarPor === "apoios") {
         ideias.sort((a, b) => params.ordem === "asc" ? a.apoios - b.apoios : b.apoios - a.apoios);
     }
     return ideias.slice(0, limite);
 }
+/**
+ * Detalhe de uma ideia ao vivo (`senado_ecidadania_obter_ideia`), pelo leitor da página redesenhada
+ * em 12/10/2026 (`lerIdeiaDetalhe`). Devolve a leitura como o portal publica; a situação NÃO sai daqui
+ * (a página não a publica) — a tool a toma do corpus ou a deriva da linha do tempo. Página fora do
+ * molde lança `IdeiaDetalheForaDoMoldeError` (não retentável); 410 lança antes, em `fetchPage`.
+ */
 export async function obterIdeiaInternal(id) {
-    const html = await fetchPage(`/visualizacaoideia?id=${id}`);
-    const text = stripHtml(html);
-    // Title: <b><div style="font-size:24px;...">TITLE</div></b> inside article#ideia-legislativa
-    const tituloMatch = html.match(/id="ideia-legislativa"[\s\S]*?<b><div[^>]*>([^<]+)<\/div><\/b>/);
-    const titulo = tituloMatch ? stripHtml(tituloMatch[1]) : "";
-    // Description: first <div style="margin-bottom:15px;"> after the title that has content
-    const descMatch = html.match(/<b><div[^>]*>[^<]+<\/div><\/b>\s*<div[^>]*>([\s\S]*?)<\/div>/);
-    const descricao = descMatch ? stripHtml(descMatch[1]).substring(0, 2000) : "";
-    // Support count: <span class="contabilizacao">17.978</span>
-    const apoiosMatch = html.match(/class="contabilizacao"[^>]*>([^<]+)</);
-    const apoios = apoiosMatch ? parseBrNum(apoiosMatch[1]) : 0;
-    // Status: o mesmo mapeamento do corpus (statusFromSituacaoIdeia). Sem seção ou texto não
-    // reconhecido, mantém o "aberta" histórico desta tool — o default antigo, agora só para o
-    // desconhecido, não mais para "Não acatada".
-    const situacao = extractSituacaoIdeia(html);
-    const status = (situacao !== null ? statusFromSituacaoIdeia(situacao) : null) ?? "aberta";
-    // Author: after "Ideia proposta por"
-    const autorMatch = html.match(/Ideia proposta por<\/div>\s*<div[^>]*>\s*<span>([^<]+)<\/span>\s*<span>\s*\(([A-Z]{2})\)<\/span>/);
-    // Date limit
-    const dataMatch = html.match(/Data limite[\s\S]*?<div[^>]*>\s*(\d{2}\/\d{2}\/\d{4})\s*<\/div>/i);
-    const dataPublicacao = dataMatch ? extractDate(dataMatch[1]) : extractDate(text);
-    const comentarioMatch = text.match(/(\d+)\s*coment[aá]rio/i);
-    const plMatch = text.match(/(SUGEST[ÃA]O|PEC|PL|PLP)\s*n?º?\s*(\d+)\s*(?:de\s*)?(\d{4})/i);
-    return {
-        id, titulo, descricao, apoios, dataPublicacao, status,
-        autor: autorMatch ? `${autorMatch[1].trim()} (${autorMatch[2]})` : null,
-        url: `${ECIDADANIA_BASE}/visualizacaoideia?id=${id}`,
-        problema: null, solucao: null,
-        comentarios: comentarioMatch ? parseInt(comentarioMatch[1]) : 0,
-        dataEncerramento: null,
-        plConvertido: plMatch
-            ? `${plMatch[1].toUpperCase().includes("SUGEST") ? "SUG" : plMatch[1].toUpperCase()} ${plMatch[2]}/${plMatch[3]}`
-            : null,
-    };
+    return lerIdeiaDetalhe(await fetchPage(`/visualizacaoideia?id=${id}`));
 }
 /**
  * Canonical `EventoResumo` builder — single source of the object's field order, so the JSON payload
@@ -709,19 +645,21 @@ export async function contarComentariosAudiencia(id) {
  */
 export function buildEventoResumoEnriquecido(fields) {
     const d = fields.detalhe ?? null;
+    const g = fields.guardado;
     return buildEventoResumo({
         id: fields.id,
         titulo: d?.titulo || fields.titulo,
-        data: d?.data ?? fields.dataListagem ?? null,
-        hora: d?.hora ?? fields.horaListagem ?? null,
-        comissao: fields.comissao ?? d?.comissao ?? null,
-        comissaoNomeCompleto: d?.comissaoNomeCompleto ?? null,
-        local: d?.local ?? null,
-        descricao: d?.descricao ?? null,
-        pauta: d?.pauta ?? [],
-        convidados: d?.convidados ?? [],
-        videoUrl: d?.videoUrl ?? null,
-        comentarios: fields.comentariosCanon ?? fields.comentariosListagem ?? 0,
+        data: mesclarCampo(d?.data, g?.data) ?? fields.dataListagem ?? null,
+        hora: mesclarCampo(d?.hora, g?.hora) ?? fields.horaListagem ?? null,
+        comissao: fields.comissao ?? mesclarCampo(d?.comissao, g?.comissao),
+        comissaoNomeCompleto: mesclarCampo(d?.comissaoNomeCompleto, g?.comissaoNomeCompleto),
+        local: mesclarCampo(d?.local, g?.local),
+        descricao: mesclarCampo(d?.descricao, g?.descricao),
+        pauta: mesclarCampo(d?.pauta, g?.pauta) ?? [],
+        convidados: mesclarCampo(d?.convidados, g?.convidados) ?? [],
+        videoUrl: mesclarCampo(d?.videoUrl, g?.videoUrl),
+        // A contagem da listagem é a degradada (0 espúrio em 82% dos eventos, estudo A3): só por último.
+        comentarios: mesclarCampo(fields.comentariosCanon, g?.comentarios) ?? fields.comentariosListagem ?? 0,
         status: fields.status ?? d?.status,
     });
 }

package/dist/scraper/ideia-detalhe.js

@@ -0,0 +1,316 @@
+/**
+ * Leitor da página de detalhe de uma ideia legislativa (`visualizacaoideia?id=`) na forma redesenhada
+ * pelo portal em 12/10/2026: a seção "Situação da Ideia" sumiu e virou uma "Linha do Tempo" de
+ * acontecimentos datados (`<ol class="timeline">`, mais recente no topo), e a UF do autor e a data
+ * limite mudaram de marcação. Fase A1 do ROADMAP ("Detalhe das ideias redesenhado…").
+ *
+ * Vocabulário FECHADO, medido em 17/10/2026 sobre 340 ideias de 2013 a 2026 em todas as situações
+ * (`docs/_local/ideias-linha-do-tempo-2026-10-17/`): cada item da linha do tempo é de um dos tipos de
+ * `TipoAcontecimento`; o que não casar com nenhum vira `naoReconhecido`, é copiado verbatim e ganha um
+ * aviso — nunca é encaixado no tipo mais parecido. Um item que casa com um tipo mas não entrega os
+ * campos do tipo (deriva parcial), ou um acontecimento de valor único que aparece duas vezes (duas
+ * Sugestões, duas decisões da CDH…), LANÇA `IdeiaDetalheForaDoMoldeError`: escolher um dos dois seria
+ * adivinhar, e quem chama (crawler, tool) decide o que fazer com a página — nunca gravar meio registro.
+ *
+ * Tudo aqui é COPIADO do que o portal publica: nenhuma situação é inferida (a situação do portal não é
+ * o último acontecimento — medido —, ela vem do bucket da listagem). As únicas padronizações são de
+ * forma, sem perda: datas para ISO, "Senadora"/"Deputada" para `transformadaPor` + `sexo`, número de
+ * proposição em partes. O nome do autor é registrado como o portal publica (abreviado), decisão do
+ * dono de 17/10/2026; os nomes de parlamentares são de agentes públicos.
+ *
+ * Puro: sem rede, sem banco. A página 410 (ideia removida) nunca chega aqui — `fetchPage` a trata pelo
+ * status HTTP.
+ */
+export class IdeiaDetalheForaDoMoldeError extends Error {
+    /** Repetir não muda a página; quem conserta é o leitor (telemetria: `defeito`, ver `anexarClasse`). */
+    retryable = false;
+    classe = "defeito";
+    constructor(message) {
+        super(`detalhe da ideia fora do molde medido: ${message}`);
+        this.name = "IdeiaDetalheForaDoMoldeError";
+    }
+}
+// ── utilidades de texto ───────────────────────────────────────────────────
+function decodificar(s) {
+    return s
+        .replace(/&nbsp;/g, " ")
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&#(\d+);/g, (_, n) => String.fromCharCode(parseInt(n, 10)))
+        .replace(/&amp;/g, "&");
+}
+/**
+ * Texto sem tags. Tags de bloco viram espaço; tags de linha somem sem espaço — o portal parte palavras
+ * em `<span>` ("pel<span>o</span>"), e trocar toda tag por espaço daria "pel o Deputado".
+ */
+export function textoDoHtml(html) {
+    return decodificar(html
+        .replace(/<!--[\s\S]*?-->/g, " ")
+        .replace(/<\/?(?:p|div|li|ul|ol|h\d|br|section|figure|figcaption)\b[^>]*>/gi, " ")
+        .replace(/<[^>]+>/g, "")).replace(/\s+/g, " ").trim();
+}
+/** dd/mm/aaaa → aaaa-mm-dd (validado: 31/02 é recusado, não "corrigido"). */
+function isoDeDataBr(s, onde) {
+    const m = /^(\d{2})\/(\d{2})\/(\d{4})$/.exec(s.trim());
+    if (!m)
+        throw new IdeiaDetalheForaDoMoldeError(`${onde}: data "${s}" não é dd/mm/aaaa`);
+    return isoValida(Number(m[3]), Number(m[2]), Number(m[1]), onde);
+}
+const MESES = ["janeiro", "fevereiro", "março", "abril", "maio", "junho", "julho", "agosto", "setembro", "outubro", "novembro", "dezembro"];
+/** "26 de junho de 2018" → 2018-06-26. */
+function isoDeDataExtenso(s, onde) {
+    const m = /^(\d{1,2}) de (\p{L}+) de (\d{4})$/u.exec(s.trim());
+    const mes = m ? MESES.indexOf(m[2].toLowerCase()) + 1 : 0;
+    if (!m || mes === 0)
+        throw new IdeiaDetalheForaDoMoldeError(`${onde}: data "${s}" não é "d de mês de aaaa"`);
+    return isoValida(Number(m[3]), mes, Number(m[1]), onde);
+}
+function isoValida(ano, mes, dia, onde) {
+    const d = new Date(Date.UTC(ano, mes - 1, dia));
+    if (d.getUTCFullYear() !== ano || d.getUTCMonth() !== mes - 1 || d.getUTCDate() !== dia) {
+        throw new IdeiaDetalheForaDoMoldeError(`${onde}: data inexistente ${dia}/${mes}/${ano}`);
+    }
+    return d.toISOString().slice(0, 10);
+}
+function inteiroBr(s) {
+    return parseInt(s.replace(/\./g, ""), 10);
+}
+/** "Projeto de Lei nº 3630, de 2021 (Substitutivo-CD)" → partes; null se não casar. */
+export function partesDaProposicao(rotulo) {
+    const m = /^(.+?) nº ([\d.]+), de (\d{4})(?: \(([^)]+)\))?$/.exec(rotulo.trim());
+    return m ? { tipoNome: m[1], numero: inteiroBr(m[2]), ano: Number(m[3]), complemento: m[4] ?? null } : null;
+}
+function referenciaSugestao(rotulo, onde) {
+    const p = partesDaProposicao(rotulo);
+    if (!p || p.tipoNome !== "Sugestão" || p.complemento) {
+        throw new IdeiaDetalheForaDoMoldeError(`${onde}: "${rotulo}" não é "Sugestão nº N, de AAAA"`);
+    }
+    return { numero: p.numero, ano: p.ano };
+}
+/** Links `<a href>` do item, com o texto já limpo. */
+function links(html) {
+    return [...html.matchAll(/<a\b[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/g)].map((m) => ({ href: decodificar(m[1]), texto: textoDoHtml(m[2]) }));
+}
+/**
+ * Link de uma proposição: o primeiro "… nº N, de AAAA" que não é a Sugestão (a decisão da CDH cita as
+ * duas) nem a Consulta Pública do próprio portal.
+ */
+function linkDaProposicao(html, onde) {
+    const l = links(html).find((x) => !/^\/?ecidadania\//.test(x.href) && !x.texto.startsWith("Sugestão") && partesDaProposicao(x.texto));
+    if (!l)
+        throw new IdeiaDetalheForaDoMoldeError(`${onde}: proposição sem link "… nº N, de AAAA"`);
+    return l;
+}
+/**
+ * Construtor canônico: ordem de campos FIXA em todos os caminhos (o corpus compara payloads por hash,
+ * e ordem diferente faria a mesma proposição parecer mudada — ver `buildIdeiaResumo`).
+ */
+function novaProposicao(p) {
+    return {
+        ordem: p.ordem, data: p.data, transformadaPor: p.transformadaPor, sexo: p.sexo,
+        parlamentar: p.parlamentar, parlamentarUf: p.parlamentarUf, tipoSigla: p.tipoSigla,
+        tipoNome: p.tipoNome, numero: p.numero, ano: p.ano, complemento: p.complemento, url: p.url,
+    };
+}
+// ── leitura de um item ────────────────────────────────────────────────────
+const CARGOS = {
+    Senador: { por: "Senador", sexo: "masculino" },
+    Senadora: { por: "Senador", sexo: "feminino" },
+    Deputado: { por: "Deputado", sexo: "masculino" },
+    Deputada: { por: "Deputado", sexo: "feminino" },
+};
+/** Campo de valor único: a segunda ocorrência é molde novo, nunca sobrescrita. */
+function unico(c, campo, valor) {
+    if (c.ideia[campo] !== null)
+        throw new IdeiaDetalheForaDoMoldeError(`${c.onde}: segundo acontecimento para "${String(campo)}"`);
+    c.ideia[campo] = valor;
+}
+/** Tenta cada tipo em ordem; devolve o tipo reconhecido (e preenche a ideia) ou null. */
+function lerItem(c) {
+    const { html, item, onde } = c;
+    const t = item.texto;
+    if (/^Ideia proposta por /.test(t)) {
+        const m = /Ideia proposta por\s*<strong>\s*<span>([\s\S]*?)<\/span>\s*(?:<span>\s*\(([A-Z]{2})\)\s*<\/span>)?\s*<\/strong>/.exec(html);
+        if (!m)
+            throw new IdeiaDetalheForaDoMoldeError(`${onde}: proposta sem "<strong><span>NOME</span><span> (UF)</span>"`);
+        unico(c, "autorNome", textoDoHtml(m[1]) || null);
+        c.ideia.autorUf = m[2] ?? null;
+        unico(c, "dataProposta", item.data);
+        return "proposta";
+    }
+    if (/^O que pode acontecer com essa ideia\?/.test(t)) {
+        const m = /pode receber apoios até\s*<strong>\s*([^<]+?)\s*<\/strong>/.exec(html);
+        if (!m)
+            throw new IdeiaDetalheForaDoMoldeError(`${onde}: regras sem "pode receber apoios até <strong>data</strong>"`);
+        unico(c, "prazoApoios", isoDeDataBr(m[1], onde));
+        return "prazo";
+    }
+    if (/class="oficina_legislativa"/.test(html)) {
+        const nivel = /realizada com participantes de nível\s*<span>([^<]+)<\/span>/.exec(html);
+        const cad = /Ideia cadastrada pelo usuário em\s*<span>(\d{2}\/\d{2}\/\d{4}) às (\d{2}:\d{2}:\d{2})<\/span>/.exec(html);
+        if (!nivel || !cad)
+            throw new IdeiaDetalheForaDoMoldeError(`${onde}: oficina sem nível ou sem data de cadastro`);
+        // Hora local do portal, sem fuso: o portal não publica o fuso (e houve horário de verão até 2019).
+        unico(c, "oficina", { nivel: nivel[1].trim(), dataCadastro: `${isoDeDataBr(cad[1], onde)}T${cad[2]}` });
+        return "oficina";
+    }
+    const meta = /^Ideia alcançou ([\d.]+) apoios$/.exec(t);
+    if (meta) {
+        unico(c, "dataMeta", item.data);
+        c.ideia.meta = inteiroBr(meta[1]);
+        return "meta";
+    }
+    if (/^Período de apoio encerrado /.test(t)) {
+        const m = /^Período de apoio encerrado Esta ideia recebeu (\d+) apoios e não alcançou a meta dentro do prazo\. O período terminou em (.+?)\.$/.exec(t);
+        if (!m)
+            throw new IdeiaDetalheForaDoMoldeError(`${onde}: encerramento sem "recebeu N apoios … terminou em data"`);
+        unico(c, "encerramento", { data: item.data, apoios: Number(m[1]), terminouEm: isoDeDataExtenso(m[2], onde) });
+        return "prazoEncerrado";
+    }
+    if (/^Essa ideia gerou a Sugestão /.test(t)) {
+        const l = links(html).find((x) => x.texto.startsWith("Sugestão"));
+        if (!l)
+            throw new IdeiaDetalheForaDoMoldeError(`${onde}: "gerou a Sugestão" sem o link da Sugestão`);
+        unico(c, "sugestao", { ...referenciaSugestao(l.texto, onde), data: item.data, url: l.href });
+        return "sugestao";
+    }
+    if (/^A CDH do Senado debateu e decidiu não transformar a Sugestão /.test(t)) {
+        const l = links(html).find((x) => x.texto.startsWith("Sugestão"));
+        if (!l)
+            throw new IdeiaDetalheForaDoMoldeError(`${onde}: decisão da CDH sem o link da Sugestão`);
+        unico(c, "decisaoCdh", { data: item.data, resultado: "não transformou", sugestao: referenciaSugestao(l.texto, onde) });
+        return "cdhNaoTransformou";
+    }
+    const titulo = /<h3>\s*Ideia transformada em\s*<span>([^<]+)<\/span>\s*(pela|por)\s*<span>([^<]+)<\/span>\s*<\/h3>/.exec(html);
+    if (titulo) {
+        const [, sigla, , quemBruto] = titulo;
+        const quem = quemBruto.trim();
+        // Autor fora do vocabulário medido (Comissão, Senador(a), Deputado(a)) é acontecimento novo:
+        // fica verbatim com aviso, em vez de virar um "por" adivinhado.
+        if (quem !== "Comissão" && !CARGOS[quem])
+            return null;
+        const prop = linkDaProposicao(html, onde);
+        const partes = partesDaProposicao(prop.texto);
+        const base = { ordem: item.ordem, data: item.data, tipoSigla: sigla.trim(), ...partes, url: prop.href };
+        if (quem === "Comissão") {
+            const sug = links(html).find((x) => x.texto.startsWith("Sugestão"));
+            if (!sug || !/A CDH do Senado debateu a Sugestão .+ e decidiu transformá-la no\(a\) /.test(t)) {
+                throw new IdeiaDetalheForaDoMoldeError(`${onde}: "transformada pela Comissão" sem "a CDH debateu a Sugestão … e decidiu transformá-la"`);
+            }
+            unico(c, "decisaoCdh", { data: item.data, resultado: "transformou", sugestao: referenciaSugestao(sug.texto, onde) });
+            c.ideia.proposicoes.push(novaProposicao({ ...base, transformadaPor: "Comissão", sexo: null, parlamentar: null, parlamentarUf: null }));
+            return "cdhTransformou";
+        }
+        const cargo = CARGOS[quem];
+        const autor = /A ideia foi adotada pel<span>[oa]<\/span>\s*<span>\s*(Senador|Senadora|Deputado|Deputada) (.+?) \(([A-Z]{2})\)\s*<\/span>/.exec(html);
+        if (!autor || autor[1] !== quem) {
+            throw new IdeiaDetalheForaDoMoldeError(`${onde}: "transformada por ${quem}" sem "adotada pelo(a) ${quem} NOME (UF)" correspondente`);
+        }
+        c.ideia.proposicoes.push(novaProposicao({ ...base, transformadaPor: cargo.por, sexo: cargo.sexo, parlamentar: autor[2].trim(), parlamentarUf: autor[3] }));
+        return "adocao";
+    }
+    if (/^Ideia transformada em /.test(t)) {
+        const prop = linkDaProposicao(html, onde);
+        c.ideia.proposicoes.push(novaProposicao({
+            ordem: item.ordem, data: item.data, transformadaPor: null, sexo: null, parlamentar: null, parlamentarUf: null,
+            tipoSigla: null, ...partesDaProposicao(prop.texto), url: prop.href,
+        }));
+        return "transformadaEm";
+    }
+    return null;
+}
+// ── a página ──────────────────────────────────────────────────────────────
+/** Lê a página de detalhe inteira (ou o recorte `#container-ideia-legislativa`). */
+export function lerIdeiaDetalhe(html) {
+    if (/class="object-not-found"/.test(html)) {
+        throw new IdeiaDetalheForaDoMoldeError('a página diz "Ideia Legislativa não encontrada!" (object-not-found)');
+    }
+    // Título em <b><div>, seguido da descrição no primeiro <div> (o mesmo par que o leitor antigo lia).
+    const cabeca = /id="ideia-legislativa"[\s\S]*?<b><div[^>]*>([\s\S]*?)<\/div><\/b>(?:\s*<div[^>]*>([\s\S]*?)<\/div>)?/.exec(html);
+    const titulo = cabeca ? textoDoHtml(cabeca[1]) : "";
+    if (!titulo)
+        throw new IdeiaDetalheForaDoMoldeError("sem título em #ideia-legislativa");
+    const descricao = cabeca?.[2] !== undefined ? textoDoHtml(cabeca[2]) || null : null;
+    const apoiosM = /<span class="contabilizacao">\s*([\d.]+)\s*<\/span>\s*apoios confirmados/.exec(html);
+    const linha = /<ol class="timeline">([\s\S]*?)<\/ol>\s*<\/section>/.exec(html);
+    if (!linha)
+        throw new IdeiaDetalheForaDoMoldeError("sem a Linha do Tempo (<ol class=\"timeline\">)");
+    const itens = linha[1].split(/(?=<li class="timeline-item)/).slice(1);
+    if (itens.length === 0)
+        throw new IdeiaDetalheForaDoMoldeError("Linha do Tempo vazia");
+    const ideia = {
+        titulo, descricao, apoios: apoiosM ? inteiroBr(apoiosM[1]) : null,
+        autorNome: null, autorUf: null, dataProposta: null, prazoApoios: null, dataMeta: null, meta: null,
+        sugestao: null, decisaoCdh: null, encerramento: null, oficina: null,
+        proposicoes: [], linhaDoTempo: [], avisos: [],
+    };
+    itens.forEach((li, ordem) => {
+        const corpo = li.replace(/<time\b[\s\S]*?<\/time>/, "").replace(/<a\b[^>]*href="declaracaoideia[^"]*"[\s\S]*?<\/a>/, "");
+        const item = {
+            ordem,
+            data: /<time datetime="(\d{4}-\d{2}-\d{2})"/.exec(li)?.[1] ?? null,
+            ativo: /^<li class="timeline-item active"/.test(li),
+            tipo: "naoReconhecido",
+            texto: textoDoHtml(corpo),
+        };
+        const tipo = lerItem({ ideia, item, html: corpo, onde: `item ${ordem}` });
+        if (tipo)
+            item.tipo = tipo;
+        else
+            ideia.avisos.push(`acontecimento não reconhecido no item ${ordem} (${item.data ?? "sem data"}): "${item.texto.slice(0, 120)}"`);
+        ideia.linhaDoTempo.push(item);
+    });
+    if (ideia.dataProposta === null)
+        throw new IdeiaDetalheForaDoMoldeError('Linha do Tempo sem "Ideia proposta por"');
+    return ideia;
+}
+/**
+ * Status DERIVADO da linha do tempo, para quando a categoria da listagem não está à mão. É
+ * classificação NOSSA — a categoria do portal (bucket da listagem) sempre prevalece sobre ele, e quem
+ * o usa marca a resposta como derivada.
+ *
+ * Regra medida em 17/10/2026 sobre a amostra de 336 ideias com bucket conhecido
+ * (`docs/_local/ideias-linha-do-tempo-2026-10-17/`): acerta 335. A divergência é irredutível — 103929
+ * (s10) e 136304 (s9) têm a MESMA linha do tempo (adoção por parlamentar e, depois, a CDH decidindo
+ * não transformar a Sugestão); o portal as classificou diferente.
+ *   - decisão da CDH transformando, ou "transformada em" sem autor          → convertida (s10)
+ *   - CDH decidiu não transformar                                            → encerrada (s9)
+ *   - Sugestão sem decisão da CDH (mesmo adotada por parlamentar)            → aberta (s6, na comissão)
+ *   - adotada por parlamentar fora da Sugestão                               → convertida (s10)
+ *   - período de apoio encerrado                                             → encerrada (s7)
+ *   - o resto (só proposta/prazo/oficina/meta)                               → aberta (s5, s8)
+ */
+export function statusDaLinhaDoTempo(d) {
+    const tem = (t) => d.linhaDoTempo.some((e) => e.tipo === t);
+    if (tem("cdhTransformou") || tem("transformadaEm"))
+        return "convertida";
+    if (tem("cdhNaoTransformou"))
+        return "encerrada";
+    if (tem("sugestao"))
+        return "aberta";
+    if (tem("adocao"))
+        return "convertida";
+    if (tem("prazoEncerrado"))
+        return "encerrada";
+    return "aberta";
+}
+/** Limite histórico da descrição no corpus (o leitor antigo cortava aqui; mantém o hash das linhas). */
+const DESCRICAO_CORPUS_MAX = 2000;
+/** `IdeiaDetalhe` → campos do corpus. UF-only: o nome do autor cidadão não vai para o corpus. */
+export function detalheParaCorpus(d) {
+    return {
+        dataPublicacao: d.prazoApoios,
+        autorUf: d.autorUf,
+        descricao: d.descricao ? d.descricao.substring(0, DESCRICAO_CORPUS_MAX) : null,
+        plConvertido: d.sugestao ? `SUG ${d.sugestao.numero}/${d.sugestao.ano}` : null,
+    };
+}
+/**
+ * Apoios publicados: o contador da página, ou o número do acontecimento "Período de apoio encerrado"
+ * (os dois são da fonte). Null se nenhum dos dois aparece — nunca 0 inventado.
+ */
+export function apoiosPublicados(d) {
+    return d.apoios ?? d.encerramento?.apoios ?? null;
+}

package/dist/scraper/mesclar.js

@@ -0,0 +1,123 @@
+/**
+ * Regra da classe dos escritores do corpus e-Cidadania: LEITURA VAZIA NUNCA APAGA VALOR GUARDADO.
+ *
+ * Origem (17/10/2026): o portal redesenhou a página de detalhe da ideia em 12/10 e o leitor antigo
+ * passou a devolver `autorUf`/`dataPublicacao` null em páginas lidas com sucesso. O backfill de
+ * detalhe gravava `detail ? detail.x : prev.x` — leitura bem-sucedida com campo vazio substituía o
+ * guardado — e apagou 21.265 UFs e 21.535 datas em cinco dias, com o workflow VERDE. Medido no
+ * `ecidadania_history`: de 01/09 a 12/10, zero campos preenchidos viraram null; de 13/10 a 17/10,
+ * 98–99% dos preenchidos de cada rodada.
+ *
+ * Duas defesas, as duas aqui:
+ *   1. `mesclarCampo` — todo escritor passa cada campo por ela: vazio lido mantém o guardado; apagar
+ *      exige `apagarComMotivo(motivo)`, explícito e com motivo que o chamador registra.
+ *   2. `vigiarCampos` — a mesclagem esconde a deriva (o valor velho fica), então cada rodada mede, por
+ *      campo, quantos valores guardados a leitura desta rodada ainda enxerga. Queda brusca reprova.
+ *
+ * Puro e sem dependência de Workers: roda no Cron de 2 h (src/) e nos jobs off-Worker (scripts/).
+ */
+/** Pedido explícito de apagar um campo guardado. Sem motivo não existe. */
+export class Apagado {
+    motivo;
+    constructor(motivo) {
+        if (!motivo.trim())
+            throw new Error("apagar campo guardado exige motivo");
+        this.motivo = motivo;
+    }
+}
+export function apagarComMotivo(motivo) {
+    return new Apagado(motivo);
+}
+/**
+ * Vazio = o leitor não achou o campo: null, undefined, string só de espaço, lista vazia, NaN.
+ * `0` NÃO é vazio — é contagem lida (apoios, votos, comentários). Quem não leu a contagem devolve null,
+ * nunca 0 (ver `lerBrNum`).
+ */
+export function ehVazio(v) {
+    if (v === null || v === undefined)
+        return true;
+    if (typeof v === "string")
+        return v.trim() === "";
+    if (typeof v === "number")
+        return Number.isNaN(v);
+    if (Array.isArray(v))
+        return v.length === 0;
+    return false;
+}
+/**
+ * Valor a gravar para UM campo: o lido, se a leitura trouxe algo; senão o guardado; `null` só quando
+ * os dois são vazios ou quando o chamador pede `apagarComMotivo`.
+ */
+export function mesclarCampo(lido, guardado) {
+    if (lido instanceof Apagado)
+        return null;
+    if (!ehVazio(lido))
+        return lido;
+    if (!ehVazio(guardado))
+        return guardado;
+    return null;
+}
+/**
+ * Número no formato brasileiro ("1.234.567") ou null quando não há número para ler. Par do
+ * `parseBrNum` (que devolve 0 para ausente/lixo e por isso não serve a escritor do corpus: ausência
+ * vira medida, e o 0 inventado sobrescreve a contagem guardada).
+ */
+export function lerBrNum(v) {
+    if (typeof v === "number")
+        return Number.isFinite(v) ? v : null;
+    if (typeof v !== "string")
+        return null;
+    const s = v.trim().replace(/\./g, "");
+    if (!/^\d+$/.test(s))
+        return null;
+    return Number(s);
+}
+// ── vigia de taxa de leitura por campo ─────────────────────────────────────────
+/**
+ * Limiar do vigia, escolhido pela medição de 17/10/2026 no `ecidadania_history` (ideias): no regime
+ * são, a retenção foi 100% (0 perdas em ~13 mil versões de 01/09 a 12/10); na quebra, 1–2%
+ * (UF 1.984 de 2.017 perdidas no 1º dia). 90% fica longe dos dois; abaixo disso é deriva de forma,
+ * não ruído.
+ */
+export const RETENCAO_MINIMA = 0.9;
+/**
+ * Com poucos guardados a taxa não diz nada (o splice de 2 h lê ~5 ideias; um id esquisito seria 20%).
+ * 50 mantém o vigia mudo ali e ativo nos jobs diários, que leem centenas a milhares.
+ */
+export const N_MINIMO = 50;
+/**
+ * Para cada campo: entre os ids lidos nesta rodada que já tinham o campo preenchido no corpus, que
+ * fração a leitura desta rodada ainda trouxe preenchida. Compara a leitura com os MESMOS ids guardados
+ * — não com a taxa do acervo inteiro, que muda com a fatia lida.
+ *
+ * `pares` recebe a LEITURA CRUA (antes da mesclagem): é ela que deriva; o mesclado nunca cairia.
+ */
+export function vigiarCampos(pares, campos, opts = {}) {
+    const minimo = opts.retencaoMinima ?? RETENCAO_MINIMA;
+    const nMin = opts.nMinimo ?? N_MINIMO;
+    const cont = new Map(campos.map((c) => [c, { guardados: 0, lidos: 0 }]));
+    for (const { lido, guardado } of pares) {
+        if (!guardado)
+            continue;
+        for (const c of campos) {
+            if (ehVazio(guardado[c]))
+                continue;
+            const k = cont.get(c);
+            k.guardados++;
+            if (!ehVazio(lido[c]))
+                k.lidos++;
+        }
+    }
+    const resultado = campos.map((campo) => {
+        const { guardados, lidos } = cont.get(campo);
+        return { campo, guardados, lidos, retencao: guardados > 0 ? lidos / guardados : 1 };
+    });
+    const quedas = resultado.filter((r) => r.guardados >= nMin && r.retencao < minimo);
+    return { ok: quedas.length === 0, campos: resultado, quedas };
+}
+/** Linha de log do veredito: `autorUf 12/2017 (0.6%)`. */
+export function descreverVigia(v) {
+    return v.campos
+        .map((c) => `${c.campo} ${c.lidos}/${c.guardados} (${(c.retencao * 100).toFixed(1)}%)`)
+        .join(" · ");
+}

package/dist/scraper/pipeline.js

@@ -11,7 +11,8 @@
  * — the last good state is preserved; only a scrape_runs row is written so the failure is visible.
  */
 import { classifyRun } from "./anomaly.js";
-import { buildConsultaResumo, buildEventoResumo, buildIdeiaResumo, listarConsultasInternal, listarIdeiasInternal, listarEventosInternal, } from "./ecidadania.js";
+import { buildConsultaResumo, buildEventoResumo, buildIdeiaResumo, lerDestaquesConsultas, lerDestaquesIdeias, listarEventosInternal, } from "./ecidadania.js";
+import { mesclarCampo } from "./mesclar.js";
 /** FNV-1a 32-bit + length suffix — fast, synchronous, good enough for change detection. */
 export function contentHash(s) {
     let h = 0x811c9dc5;
@@ -82,7 +83,9 @@ async function refreshHighlights(db, now, cfg) {
             .prepare(SQL.currentRow)
             .bind(cfg.entidade, hl.id)
             .first();
-        const item = existing ? cfg.splice(JSON.parse(existing.payload_json), hl) : hl;
+        const item = cfg.splice(existing ? JSON.parse(existing.payload_json) : undefined, hl);
+        if (!item)
+            continue;
         const payloadJson = JSON.stringify(item);
         const hash = contentHash(payloadJson);
         if (existing && existing.content_hash === hash)
@@ -95,27 +98,44 @@ async function refreshHighlights(db, now, cfg) {
     await db.batch(stmts);
     return { entidade: cfg.entidade, status: "ok-metrica", rowsScraped: highlights.length, rowsChanged };
 }
-const consultasHighlightCfg = {
+export const consultasHighlightCfg = {
     entidade: "consultas",
-    scrape: () => listarConsultasInternal({ limite: 100 }),
+    scrape: () => lerDestaquesConsultas(),
     metrica: (c) => c.totalVotos,
     comissao: () => null,
     // Preserves the corpus-authoritative detail fields (autoria/relator, v2) so the 2h metric splice
-    // never wipes them; only the volatile vote counts come from the fresh REST highlight.
-    splice: (corpus, fresh) => buildConsultaResumo({
-        id: fresh.id,
-        materia: corpus.materia,
-        ementa: corpus.ementa,
-        votosSim: fresh.votosSim,
-        votosNao: fresh.votosNao,
-        totalVotos: fresh.totalVotos,
-        autoria: corpus.autoria,
-        relator: corpus.relator,
-        status: corpus.status,
-        url: corpus.url,
-    }),
+    // never wipes them; only the volatile vote counts come from the fresh REST highlight — and only
+    // the ones it actually carried.
+    splice: (corpus, fresh) => {
+        if (!corpus) {
+            if (fresh.votosSim === null || fresh.votosNao === null)
+                return null;
+            return buildConsultaResumo({
+                id: fresh.id, materia: fresh.materia, ementa: fresh.ementa,
+                votosSim: fresh.votosSim, votosNao: fresh.votosNao, totalVotos: fresh.totalVotos ?? undefined,
+                status: "aberta",
+            });
+        }
+        const votosSim = mesclarCampo(fresh.votosSim, corpus.votosSim) ?? 0;
+        const votosNao = mesclarCampo(fresh.votosNao, corpus.votosNao) ?? 0;
+        return buildConsultaResumo({
+            id: fresh.id,
+            materia: corpus.materia,
+            ementa: corpus.ementa,
+            votosSim,
+            votosNao,
+            // Total do REST quando veio; senão o guardado só se os votos também são os guardados (nada
+            // lido); com votos novos e total ausente, o builder deriva votosSim + votosNao.
+            totalVotos: fresh.totalVotos ??
+                (fresh.votosSim === null && fresh.votosNao === null ? corpus.totalVotos : undefined),
+            autoria: corpus.autoria,
+            relator: corpus.relator,
+            status: corpus.status,
+            url: corpus.url,
+        });
+    },
 };
-const eventosHighlightCfg = {
+export const eventosHighlightCfg = {
     entidade: "eventos",
     scrape: () => listarEventosInternal({ limite: 100 }),
     metrica: (e) => e.comentarios,
@@ -126,7 +146,7 @@ const eventosHighlightCfg = {
     // fresh REST count: it stays byte-stable (no ping-pong / history churn against the daily crawl) and
     // also carries all v2 detail fields through untouched. The eventos splice is thus effectively inert
     // between daily crawls — the daily crawl is the sole source of the canonical count.
-    splice: (corpus, _fresh) => buildEventoResumo({
+    splice: (corpus, fresh) => !corpus ? fresh : buildEventoResumo({
         id: corpus.id,
         titulo: corpus.titulo,
         data: corpus.data,
@@ -143,24 +163,29 @@ const eventosHighlightCfg = {
         url: corpus.url,
     }),
 };
-const ideiasHighlightCfg = {
+export const ideiasHighlightCfg = {
     entidade: "ideias",
-    scrape: () => listarIdeiasInternal({ limite: 100 }),
+    scrape: () => lerDestaquesIdeias(),
     metrica: (i) => i.apoios,
     comissao: () => null,
     // Preserves the corpus-authoritative detail fields (dataPublicacao/autorUf/descricao/plConvertido,
-    // v2) so the 2h apoios splice never wipes them.
-    splice: (corpus, fresh) => buildIdeiaResumo({
-        id: fresh.id,
-        titulo: corpus.titulo,
-        apoios: fresh.apoios,
-        dataPublicacao: corpus.dataPublicacao,
-        autorUf: corpus.autorUf,
-        descricao: corpus.descricao,
-        plConvertido: corpus.plConvertido,
-        status: corpus.status,
-        url: corpus.url,
-    }),
+    // v2) so the 2h apoios splice never wipes them; apoios only when the REST item carried it.
+    splice: (corpus, fresh) => {
+        if (!corpus) {
+            return fresh.apoios === null ? null : buildIdeiaResumo({ id: fresh.id, titulo: fresh.titulo, apoios: fresh.apoios });
+        }
+        return buildIdeiaResumo({
+            id: fresh.id,
+            titulo: mesclarCampo(corpus.titulo, fresh.titulo) ?? undefined,
+            apoios: mesclarCampo(fresh.apoios, corpus.apoios) ?? undefined,
+            dataPublicacao: corpus.dataPublicacao,
+            autorUf: corpus.autorUf,
+            descricao: corpus.descricao,
+            plConvertido: corpus.plConvertido,
+            status: corpus.status,
+            url: corpus.url,
+        });
+    },
 };
 /** Thin wrappers (kept by name for tests/back-compat). */
 export function refreshConsultasHighlights(db, now) {

package/dist/scraper/store.js

@@ -45,6 +45,24 @@ export async function readCurrent(db, entidade) {
     });
     return { items, lastScrapedAt };
 }
+/**
+ * One current row of an entity: its denormalized `status` and when it was scraped, or null when the id
+ * is not in the corpus (or D1 is absent/unavailable — the caller then derives what it needs).
+ */
+export async function readCurrentStatus(db, entidade, entityId) {
+    if (!db)
+        return null;
+    try {
+        const row = await db
+            .prepare("SELECT status, scraped_at FROM ecidadania_current WHERE entidade = ? AND entity_id = ?")
+            .bind(entidade, entityId)
+            .first();
+        return row && row.status ? { status: row.status, scrapedAt: row.scraped_at } : null;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Resolve a list with the D1-first / live-fallback policy above.
  * `liveScrape` is the existing live path (e.g. listarConsultasInternal).

package/dist/tools/ecidadania.js

@@ -12,13 +12,14 @@
 import { z } from "zod";
 import { cachedFetchWithMeta } from "../cache/manager.js";
 import { errorFrom } from "../utils/validation.js";
-import { leituraDoCache, provenanceEcidadania, NOTA_DERIVACAO_DATA_ESTIMADA, NOTA_DERIVACAO_PERCENTUAIS, NOTA_DERIVACAO_RANKING_ECIDADANIA, NOTA_DERIVACAO_SOMAS, derivado, derivadoSe, provenanceArquimedesVotos, resultWithProvenance, withFieldSources, } from "../utils/provenance.js";
+import { leituraDoCache, provenanceEcidadania, NOTA_DERIVACAO_DATA_ESTIMADA, NOTA_DERIVACAO_PERCENTUAIS, NOTA_DERIVACAO_RANKING_ECIDADANIA, NOTA_DERIVACAO_SOMAS, NOTA_DERIVACAO_STATUS_IDEIA, derivado, derivadoSe, provenanceArquimedesVotos, resultWithProvenance, withFieldSources, } from "../utils/provenance.js";
 import { tagUntrustedFields, tagUntrustedList, neutralizeUntrustedText, sanitizeScrapedText } from "../utils/untrusted.js";
 import { CACHE_ON_DEMAND } from "../types.js";
-import { resolveList, writeDetalheThrough } from "../scraper/store.js";
-import { ECIDADANIA_BASE, parseBrNum, extractId, normalizeEcidadaniaUrl, stripHtml, extractDate, extractTime, buildConsultaResumo, listarConsultasInternal, obterConsultaInternal, listarIdeiasInternal, obterIdeiaInternal, listarEventosInternal, obterEventoInternal, estimarCriacaoIdeia, AVISO_DATAS_IDEIA, IDEIA_PRAZO_APOIOS_DIAS, } from "../scraper/ecidadania.js";
+import { readCurrentStatus, resolveList, writeDetalheThrough } from "../scraper/store.js";
+import { apoiosPublicados, detalheParaCorpus, statusDaLinhaDoTempo } from "../scraper/ideia-detalhe.js";
+import { ECIDADANIA_BASE, parseBrNum, extractId, normalizeEcidadaniaUrl, stripHtml, extractDate, extractTime, buildConsultaResumo, listarConsultasInternal, obterConsultaInternal, listarIdeiasInternal, obterIdeiaInternal, listarEventosInternal, obterEventoInternal, estimarCriacaoIdeia, AVISO_DATAS_IDEIA, AVISO_DATAS_IDEIA_DETALHE, IDEIA_PRAZO_APOIOS_DIAS, } from "../scraper/ecidadania.js";
 // Re-export the scraper's pure/IO helpers so existing unit tests keep importing them from here.
-export { estimarCriacaoIdeia, AVISO_DATAS_IDEIA, IDEIA_PRAZO_APOIOS_DIAS, ECIDADANIA_BASE, parseBrNum, extractId, normalizeEcidadaniaUrl, stripHtml, extractDate, extractTime, buildConsultaResumo, listarConsultasInternal, obterConsultaInternal, listarIdeiasInternal, obterIdeiaInternal, listarEventosInternal, obterEventoInternal, };
+export { estimarCriacaoIdeia, AVISO_DATAS_IDEIA, AVISO_DATAS_IDEIA_DETALHE, IDEIA_PRAZO_APOIOS_DIAS, ECIDADANIA_BASE, parseBrNum, extractId, normalizeEcidadaniaUrl, stripHtml, extractDate, extractTime, buildConsultaResumo, listarConsultasInternal, obterConsultaInternal, listarIdeiasInternal, obterIdeiaInternal, listarEventosInternal, obterEventoInternal, };
 /** Format an integer with pt-BR thousands separators ("253804" → "253.804").
  *  Avoids toLocaleString, whose Intl data is not guaranteed on Workers (OBS-12). */
 export function formatIntBR(n) {
@@ -101,6 +102,67 @@ export const NOTA_DERIVACAO_ANALISE_CONSULTAS = `${NOTA_DERIVACAO_RANKING_ECIDAD
 export const provenanceDasConsultas = (prov) => derivado(prov, NOTA_DERIVACAO_PERCENTUAIS);
 export const provenanceDaAnaliseDeConsultas = (prov) => derivado(prov, NOTA_DERIVACAO_ANALISE_CONSULTAS);
 export const provenanceDasIdeias = (prov, ideias) => derivadoSe(prov, ideias.some((i) => i.dataCriacaoEstimada != null), NOTA_DERIVACAO_DATA_ESTIMADA);
+/**
+ * Proveniência de `senado_ecidadania_obter_ideia`. O detalhe é lido ao vivo; a situação vem do corpus
+ * em D1 (categoria do portal, lida noutro instante → sub-fonte, topo = o mais antigo) ou, fora do
+ * corpus, é derivada da linha do tempo. A data estimada é sempre derivada quando há data limite.
+ */
+export function provenanceDaIdeia(prov, detalhe, statusDoCorpus, leitura) {
+    const comFontes = statusDoCorpus
+        ? withFieldSources(prov, [
+            { fields: Object.keys(detalhe).filter((k) => k !== "status"), source_url: prov.source_url, dataset_id: `ideia=${detalhe.id}`, ...leituraDoCache(leitura) },
+            subFonteDoCorpus("/principalideia", "ideias", { lastScrapedAt: statusDoCorpus.scrapedAt }, ["status"]),
+        ])
+        : prov;
+    const notas = [
+        ...(detalhe.dataCriacaoEstimada != null ? [NOTA_DERIVACAO_DATA_ESTIMADA] : []),
+        ...(statusDoCorpus ? [] : [NOTA_DERIVACAO_STATUS_IDEIA]),
+    ];
+    return notas.length ? derivado(comFontes, notas.join(" ")) : comFontes;
+}
+/**
+ * Resposta de `senado_ecidadania_obter_ideia` a partir da leitura do leitor novo (fase A4). Campos que
+ * já existiam mantêm tipo e não-nulidade (saída que passa a aceitar null seria MAJOR): `descricao` ""
+ * quando ausente, `apoios` 0 quando a página não publica contagem (com aviso), `status` sempre preenchido,
+ * `autor` "NOME (UF)". Os novos vêm depois, na ordem da leitura.
+ */
+export function montarDetalheDaIdeia(id, d, statusDoCorpus) {
+    const apoios = apoiosPublicados(d);
+    const avisos = [...d.avisos, ...(apoios === null ? ["a página não publica a contagem de apoios desta ideia; apoios saiu 0 por compatibilidade"] : [])];
+    const autor = d.autorNome ? `${d.autorNome}${d.autorUf ? ` (${d.autorUf})` : ""}` : null;
+    return {
+        id,
+        titulo: d.titulo,
+        descricao: d.descricao ?? "",
+        apoios: apoios ?? 0,
+        dataPublicacao: d.prazoApoios,
+        status: statusDoCorpus ?? statusDaLinhaDoTempo(d),
+        origemStatus: statusDoCorpus ? "categoria do portal (listagem)" : "derivado da linha do tempo",
+        autor,
+        url: `${ECIDADANIA_BASE}/visualizacaoideia?id=${id}`,
+        problema: null,
+        solucao: null,
+        // OBS-9: a página de ideia não tem recurso de comentários — null, não um 0 espúrio.
+        comentarios: null,
+        dataEncerramento: d.encerramento?.data ?? null,
+        plConvertido: detalheParaCorpus(d).plConvertido,
+        dataCriacaoEstimada: estimarCriacaoIdeia(d.prazoApoios),
+        avisoDatas: AVISO_DATAS_IDEIA_DETALHE,
+        autorNome: d.autorNome,
+        autorUf: d.autorUf,
+        dataProposta: d.dataProposta,
+        prazoApoios: d.prazoApoios,
+        dataMeta: d.dataMeta,
+        meta: d.meta,
+        sugestao: d.sugestao,
+        decisaoCdh: d.decisaoCdh,
+        encerramento: d.encerramento,
+        oficina: d.oficina,
+        proposicoes: d.proposicoes,
+        linhaDoTempo: d.linhaDoTempo,
+        avisos,
+    };
+}
 export const provenanceDosVotosHistoricos = (prov) => derivado(prov, NOTA_DERIVACAO_SOMAS);
 /**
  * Proveniência de `senado_ecidadania_sugerir_tema_enquete`: as sugestões cruzam DOIS corpora
@@ -235,7 +297,7 @@ export function registerECidadaniaTools(server, _baseUrl, env, ctx) {
         }
     });
     // G5. senado_ecidadania_listar_ideias
-    server.tool("senado_ecidadania_listar_ideias", "Lista ideias legislativas propostas por cidadãos no e-Cidadania — **conjunto completo** (corpus persistido em D1; ideias em andamento atualizadas diariamente; ~118 mil ideias, incluindo encerradas e convertidas em proposição). Retorna `{ count, ideias, avisoDatas }`, cada ideia com `id`, `titulo`, `apoios`, `status` (`aberta`/`encerrada`/`convertida`/`removida` — `removida` = retirada do portal, que não a publica mais; o corpus guarda o último estado conhecido), `url` e os campos lidos do detalhe quando o backfill já passou por ela (`dataPublicacao`, `autorUf`, `descricao`, `plConvertido`; `null` até lá). **Datas:** `dataPublicacao` é a DATA LIMITE para receber os 20.000 apoios — a única data que o portal publica; o nome do campo é histórico — e por isso cai no futuro em ideia aberta; `dataCriacaoEstimada` (= data limite − 120 dias, a regra dos 4 meses do portal) é calculada pelo servidor e é estimativa, não dado da fonte; `avisoDatas` repete isso na resposta. Aceita filtro por `status` e `limite` (padrão 20). Para um ranking das mais apoiadas, ordene por apoios (`ordenarPor: \"apoios\"`, `ordem: \"desc\"`). Para o detalhe completo de uma ideia (texto, autor, se virou projeto de lei) chame `senado_ecidadania_obter_ideia` com o `id`.", {
+    server.tool("senado_ecidadania_listar_ideias", "Lista ideias legislativas propostas por cidadãos no e-Cidadania — **conjunto completo** (corpus persistido em D1; ideias em andamento atualizadas diariamente; ~118 mil ideias, incluindo encerradas e convertidas em proposição). Retorna `{ count, ideias, avisoDatas }`, cada ideia com `id`, `titulo`, `apoios`, `status` (a categoria da listagem do portal em que a ideia aparece: `aberta` = \"Aberta\", \"Na comissão\" ou \"Aguardando envio à CDH\"; `encerrada` = \"Encerrada – sem apoio suficiente\" ou \"Não acatada\" pela CDH; `convertida` = \"Transformada em proposição\"; `removida` = retirada do portal, que não a publica mais — o corpus guarda o último estado conhecido), `url` e os campos lidos do detalhe quando o backfill já passou por ela (`dataPublicacao`, `autorUf`, `descricao`, `plConvertido`; `null` até lá). **Datas:** `dataPublicacao` é a DATA LIMITE para receber os 20.000 apoios — a única data que o corpus guarda; o nome do campo é histórico — e por isso cai no futuro em ideia aberta; `dataCriacaoEstimada` (= data limite − 120 dias, a regra dos 4 meses do portal) é calculada pelo servidor e é estimativa, não dado da fonte; a data REAL da proposição sai em `senado_ecidadania_obter_ideia` (`dataProposta`); `avisoDatas` repete isso na resposta. Aceita filtro por `status` e `limite` (padrão 20). Para um ranking das mais apoiadas, ordene por apoios (`ordenarPor: \"apoios\"`, `ordem: \"desc\"`). Para o detalhe completo de uma ideia (texto, autor, linha do tempo, Sugestão, decisão da CDH, proposições em que virou) chame `senado_ecidadania_obter_ideia` com o `id`.", {
         status: z.enum(["aberta", "encerrada", "convertida", "removida", "todas"]).optional().describe("Filtrar por status (`removida` = retirada do portal)"),
         ordenarPor: z.enum(["apoios", "data", "comentarios"]).optional().describe("Campo para ordenação (apoios é o disponível no corpus; data/comentarios só no detalhe)"),
         ordem: z.enum(["asc", "desc"]).optional().describe("Ordem de ordenação"),
@@ -267,21 +329,15 @@ export function registerECidadaniaTools(server, _baseUrl, env, ctx) {
         }
     });
     // G6. senado_ecidadania_obter_ideia
-    server.tool("senado_ecidadania_obter_ideia", "Obtém o detalhe de uma ideia legislativa do e-Cidadania. Retorna um objeto com `id`, `titulo`, `descricao` (texto completo, truncado em ~2000 caracteres), `apoios`, `dataPublicacao`, `dataCriacaoEstimada`, `avisoDatas`, `status`, `autor`, `url` e `plConvertido` (sigla/número quando virou projeto de lei). **Datas:** `dataPublicacao` é a DATA LIMITE para receber os 20.000 apoios — a única data que o portal publica; o nome do campo é histórico — e por isso cai no futuro em ideia aberta; `dataCriacaoEstimada` (= data limite − 120 dias, a regra dos 4 meses do portal) é calculada pelo servidor e é estimativa, não dado da fonte. O campo `comentarios` vem `null`: a página de ideia não possui recurso de comentários. Obtenha o `id` antes via `senado_ecidadania_listar_ideias`.", { id: z.number().int().positive().describe("ID da ideia legislativa") }, async (params) => {
+    server.tool("senado_ecidadania_obter_ideia", "Obtém o detalhe de uma ideia legislativa do e-Cidadania, lido ao vivo da página da ideia. Retorna `id`, `titulo`, `descricao`, `apoios`, `status`, `origemStatus`, `autor` (\"NOME (UF)\", o nome abreviado como o portal publica), `url`, `plConvertido` (a Sugestão gerada, \"SUG n/ano\"), `dataEncerramento` (fim do período de apoio, quando encerrado) e os campos da linha do tempo do portal: `dataProposta` (data em que a ideia foi proposta, publicada pela fonte), `prazoApoios` (data limite para os 20.000 apoios), `dataMeta`/`meta` (quando alcançou a meta), `sugestao` (número, ano, data e link da Sugestão), `decisaoCdh` (a CDH transformou ou não a Sugestão), `encerramento` (apoios recebidos e fim do período), `oficina` (ideia de Oficina Legislativa), `proposicoes` (cada proposição em que a ideia virou — pela CDH ou adotada por senador/deputado —, com sigla, número, ano, parlamentar e link), `linhaDoTempo` (os acontecimentos como publicados, mais recente primeiro) e `avisos` (acontecimento que o servidor não reconheceu, copiado sem interpretação). **Situação:** `status` é a categoria do portal guardada no corpus (`aberta`/`encerrada`/`convertida`/`removida`, as mesmas de `senado_ecidadania_listar_ideias`); se a ideia ainda não está no corpus, o servidor a classifica pela linha do tempo e `origemStatus` diz isso. **Datas:** use `dataProposta`; `dataPublicacao` é a data limite (nome histórico, igual a `prazoApoios`) e `dataCriacaoEstimada` é estimativa mantida por compatibilidade. `comentarios`, `problema` e `solucao` vêm `null`: a página não os publica. Obtenha o `id` antes via `senado_ecidadania_listar_ideias`.", { id: z.number().int().positive().describe("ID da ideia legislativa") }, async (params) => {
         try {
-            const { value: r, fetchedAt } = await cachedFetchWithMeta("ecidadania_ideia", { id: params.id }, CACHE_ON_DEMAND, () => obterIdeiaInternal(params.id));
-            writeDetalheThrough(db, ctx, "ideias", params.id, r);
-            // OBS-9: idea pages have no comments resource — serve null instead of a spurious 0.
-            // Datas: `dataCriacaoEstimada` e `avisoDatas` entram SÓ na resposta (não no write-through acima,
-            // que guarda o que a página diz).
-            const ideia = r;
-            const detalhe = {
-                ...r,
-                dataCriacaoEstimada: estimarCriacaoIdeia(ideia.dataPublicacao),
-                comentarios: null,
-                avisoDatas: AVISO_DATAS_IDEIA,
-            };
-            return resultWithProvenance(tagUntrustedFields("ideias", detalhe), provenanceDasIdeias(provDetalhe(r, `/visualizacaoideia?id=${params.id}`, `ideia=${params.id}`, fetchedAt), [detalhe]));
+            // v2: a chave muda com o formato — o L1 guardaria a leitura do leitor antigo.
+            const { value: lida, fetchedAt, fromCache } = await cachedFetchWithMeta("ecidadania_ideia_v2", { id: params.id }, CACHE_ON_DEMAND, () => obterIdeiaInternal(params.id));
+            // A situação é a categoria do portal guardada no corpus (bucket da listagem), lida a cada chamada.
+            const doCorpus = await readCurrentStatus(db, "ideias", params.id);
+            const detalhe = montarDetalheDaIdeia(params.id, lida, doCorpus?.status ?? null);
+            writeDetalheThrough(db, ctx, "ideias", params.id, detalhe);
+            return resultWithProvenance(tagUntrustedFields("ideias", detalhe), provenanceDaIdeia(provDetalhe(detalhe, `/visualizacaoideia?id=${params.id}`, `ideia=${params.id}`, fetchedAt), detalhe, doCorpus, { fetchedAt, fromCache }));
         }
         catch (e) {
             return ecidadaniaError(e);

package/dist/utils/provenance.js

@@ -296,6 +296,8 @@ export const NOTA_DERIVACAO_PERCENTUAIS = "Percentuais de sim e não, e o total
 export const NOTA_DERIVACAO_RANKING_ECIDADANIA = "Polarização, consenso e ordem por participação calculados pelo servidor a partir dos votos e apoios publicados pela fonte.";
 /** Data de criação estimada das ideias legislativas. */
 export const NOTA_DERIVACAO_DATA_ESTIMADA = "A data de criação é estimada pelo servidor (fim do prazo de apoio menos 120 dias); a fonte não a publica.";
+/** Situação de uma ideia fora do corpus: classificada pelo servidor a partir da linha do tempo. */
+export const NOTA_DERIVACAO_STATUS_IDEIA = "A situação da ideia foi classificada pelo servidor a partir da linha do tempo publicada, porque a ideia ainda não está no corpus; a categoria do portal, quando lida da listagem, prevalece.";
 /** Legislatura sem número na fonte: o próprio número é o padrão do servidor. */
 export const NOTA_DERIVACAO_LEGISLATURA_PADRAO = "A fonte não informou a legislatura: o servidor assume a 57ª (2023–2027) e calcula o período e as datas.";
 /** Período e datas da legislatura derivados do número dela. */

package/dist/utils/untrusted.js

@@ -70,7 +70,7 @@ function applyStringArray(value, fn) {
  */
 const CITIZEN_STRING_FIELDS = {
     consultas: [],
-    ideias: ["titulo", "descricao", "autor"],
+    ideias: ["titulo", "descricao", "autor", "autorNome"],
     eventos: [],
     consultas_votos: [],
 };
@@ -91,6 +91,12 @@ const OFFICIAL_STRING_FIELDS = {
 const OFFICIAL_ARRAY_FIELDS = {
     eventos: ["pauta", "convidados"],
 };
+/**
+ * Texto de cidadão dentro de estruturas do detalhe da ideia (fase A4): os acontecimentos da linha do
+ * tempo copiam o texto da página (com o nome do autor), e um aviso cita o item não reconhecido.
+ */
+const CITIZEN_ARRAY_FIELDS = { ideias: ["avisos"] };
+const CITIZEN_OBJECT_ARRAY_FIELDS = { ideias: { linhaDoTempo: ["texto"] } };
 /**
  * Retorna uma CÓPIA rasa de `item` com os campos de texto tratados para a entidade dada: campos de
  * cidadão demarcados, campos oficiais sanitizados. Não muta a entrada (o item persistido em
@@ -115,6 +121,24 @@ export function tagUntrustedFields(entidade, item) {
         if (f in out)
             out[f] = applyStringArray(out[f], sanitizeScrapedText);
     }
+    for (const f of CITIZEN_ARRAY_FIELDS[entidade] ?? []) {
+        if (f in out)
+            out[f] = applyStringArray(out[f], neutralizeUntrustedText);
+    }
+    for (const [f, campos] of Object.entries(CITIZEN_OBJECT_ARRAY_FIELDS[entidade] ?? {})) {
+        const arr = out[f];
+        if (!Array.isArray(arr))
+            continue;
+        out[f] = arr.map((el) => {
+            if (!el || typeof el !== "object")
+                return el;
+            const copia = { ...el };
+            for (const c of campos)
+                if (c in copia)
+                    copia[c] = applyField(copia[c], neutralizeUntrustedText);
+            return copia;
+        });
+    }
     return out;
 }
 /** Versão para listas: mapeia `tagUntrustedFields` sobre cada item. */

package/dist/version.js

@@ -1,3 +1,3 @@
 /** Single source of truth for the server version (kept in sync with package.json). */
-export const VERSION = "3.19.0";
+export const VERSION = "3.20.0";
 export const USER_AGENT = `senado-br-mcp/${VERSION} (+https://senado.sidneybissoli.com; sbissoli76@gmail.com)`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "senado-br-mcp",
-  "version": "3.19.0",
+  "version": "3.20.0",
   "description": "MCP server for Brazilian Senate open data — runs hosted on Cloudflare Workers or locally via npx (stdio)",
   "keywords": [
     "mcp",