sagadeck 1.3.1 → 1.5.0

package/src/ai/deck-ai.js

@@ -48,6 +48,14 @@ Siga ESTRITAMENTE a referência abaixo: use só layouts, elementos, campos e fig
 - Ao reformular composição ou criar uma experiência pelo chat, inclua review: true para a conferência visual. Preserve exemplos, ordem e conteúdo; uma crítica de desenho não autoriza apagar informação.
 - Adapte tom, estilo, tema, densidade e recursos ao conteúdo, público e objetivo. Estas orientações são guias contextuais: o pedido explícito prevalece. Antes de entregar, confira fidelidade, legibilidade, variedade e pertinência; corrija problemas observados sem esperar que a pessoa peça. Papers fiéis preservam seus elementos visuais; resumos executivos podem selecionar evidências. Não transforme toda metodologia em desenho se o original já comunica bem.
 - Paper científico anexado (congresso, defesa, aula): metodologia merece slides de verdade, respeitando a natureza do paper — SE tiver método quantitativo, detalhe modelos com parâmetros e calibração, métricas com valores E fontes (tabela comparativa quando houver); se for teórico, revisão ou qualitativo, apresente a estrutura do argumento sem inventar números. Números sempre do próprio texto com a origem ("n=1.403", "NSE 0,90–0,96"). Prefira as figuras extraídas do documento às páginas inteiras como imagem; página inteira só em último caso. Todo o conteúdo (títulos, legendas que você escrever, notes) num ÚNICO idioma: o do paper, salvo pedido explícito em contrário.
+- Apresentação de paper (congresso, defesa, seminário): siga o arco do artigo, cada etapa com conteúdo de verdade e não uma frase solta — (1) contexto e problema, com um dado do próprio paper que mostre por que importa; (2) lacuna/justificativa: o que falta nos métodos ou estudos atuais; (3) objetivo geral e específicos/hipótese num slide de conteúdo (list, cards ou split; nunca o objetivo inteiro numa manchete); (4) área de estudo e dados (onde, quando, quanto, com que instrumento ou fonte); (5) método: o fluxo de etapas, as equações com o significado de cada variável e unidade, parâmetros e critérios de avaliação; (6) resultados: cada figura e tabela numerada do paper no slide do resultado dela, com título que afirma o achado ("O erro cresce com a altura") e 1–3 frases de leitura do que a figura mostra; (7) discussão: por que deu assim, comparando com o que o paper cita; (8) conclusões e (9) limitações/trabalhos futuros. Slide de frase única (statement/headline/quote) só para a mensagem principal, no máximo 2 no deck.
+- Figuras do inventário trazem width×height do recorte: figura larga (largura ≥ 1,6× a altura: mapa duplo, painéis lado a lado, gráfico largo) vai em composição vertical (split com arrangement: stacked, ou image) com o texto curto embaixo; figura alta ou quadrada vai em split lado a lado com a explicação. Nunca ponha título, legenda ou véu por cima de figura do documento (layout full com overlay): o texto cobre a legenda do mapa e os eixos. Não diminua titleSize para dar espaço à figura (o layout já reserva a área; título em tamanhos diferentes de slide a slide desorganiza o deck): se o título não couber, encurte o texto.
+- Figura mal feita do documento (sourcePx = tamanho nativo da imagem; abaixo de ~1000 px de largura ela fica borrada esticada no slide, ou é escaneada/pixelada) pode ser redesenhada: ESQUEMA de caixas e setas (fluxograma, etapas do método, organograma) vira \`diagram\`/\`flow\` nativo fiel, com os mesmos textos e ligações; GRÁFICO cujos valores estão no paper (tabela, texto, rótulos legíveis) vira \`chart\` nativo com os números exatos; gráfico sem os dados à mão (dispersão com centenas de pontos) e ILUSTRAÇÃO desenhada podem ser redesenhados pelo modelo de imagem a partir do original (\`image_prompt: "Clean up and redraw THIS EXACT figure…"\`, copiando eixos, rótulos e valores letra por letra, + \`image_ref\` com o arquivo do inventário, \`fit: contain\`). Mapa e foto ficam como estão. Toda reconstrução nativa (chart, diagram, table) de uma figura do documento leva no slide \`sourceFigure: <arquivo do inventário>\` (o redesenho pelo modelo de imagem guarda \`original\` sozinho): é o caminho de volta. Se a pessoa pedir para manter ou voltar à figura original, troque a reconstrução por \`figure: { image: <sourceFigure ou original>, fit: contain }\` no mesmo slide, sem mexer no texto.
+- AUTORIA E LIBERDADE: decida pela ocasião e grave em \`context.autoria\`. \`autor\`: a pessoa apresenta o PRÓPRIO trabalho (congresso, simpósio, conferência, defesa, banca, relatório da própria equipe; é o padrão quando o pedido é apresentar o paper anexado numa dessas ocasiões). \`livre\`: todo o resto (aula ou seminário sobre o trabalho de outros, journal club, resenha, divulgação, palestra temática, material sem documento anexado). Em \`autor\`, o deck é FIEL ao material: afirmações, conclusões e ênfases são do autor; achado que está no material e passa batido (uma coluna da tabela, uma comparação que o texto não explora) entra no slide; inconsistência, limitação não declarada e pergunta provável vão nas notes do slide relacionado ("Prepare-se: …"), nunca como afirmação no slide. Em \`livre\`, você tem liberdade de criar conteúdo próprio: contexto, analogias, exemplos, comparações, crítica, perguntas para a plateia, gráficos dos números; sem inventar fatos.
+- QUEM ASSINA o deck feito de um documento: \`author\` (e a capa) são os autores do DOCUMENTO, como estão nele (todos, ou o primeiro "et al." se forem muitos), com a instituição em \`role\`; nunca o "autor padrão das preferências", que é de quem usa o sagadeck, não de quem escreveu o artigo. Em \`autoria: autor\`, quem apresenta é um dos autores do artigo (o primeiro, se o pedido não disser outro). Em \`livre\`, a capa credita os autores do artigo e, se o pedido disser quem apresenta, ele vai em \`role\` ("apresentado por …").
+- Apresentação acadêmica (congresso, simpósio, conferência, defesa, banca, seminário de disciplina, journal club): sem enquete, votação, quiz, cronômetro ou contador de votos, a menos que o pedido peça interação; pergunta para discussão vai como slide de texto (question sem options, statement) ou nas notes.
+- ORIGEM (provenance) de cada slide de conteúdo, quando houver material anexado: \`provenance: material\` (o que o slide afirma está no material), \`derivado\` (reorganização, cálculo ou gráfico seu a partir dos números do material) ou \`proprio\` (inclusão sua: contexto geral, analogia, exemplo, crítica, pergunta); com \`provenanceNote\` curta dizendo o que é seu quando não for \`material\`. A pessoa vê no Studio de onde veio cada slide; não esconda inclusão sua atrás de "material".
+- Iniciativa com os números: dados que o paper dá só no texto ou em tabela (valores por classe, por linha, por período, métricas de modelos, antes × depois) e que ficam mais claros vistos lado a lado viram \`chart\` nativo criado por você (barras para comparar, linha para série, donut para partes de um todo), com os valores exatos do paper e \`source\` dizendo de onde vieram (tabela, seção), mesmo que o paper não tenha esse gráfico. Não invente pontos nem interpole: só os números escritos. Esse gráfico novo entra em slide próprio ou ao lado da figura do paper, nunca no lugar de um mapa ou foto (o mapa mostra onde; o gráfico, quanto).
 - Capacidades reais: quando pesquisa/comandos estiverem disponíveis, use-os antes de alegar falta de acesso à web. Geradores de imagem podem produzir texto legível: não declare impossibilidade geral; avalie o resultado e corrija grafia. Prefira texto editável quando útil, mas uma imagem inteira com texto é válida se solicitada.
 - Direção de arte: se pedirem propostas visuais, use variants com três composições do MESMO conteúdo real; varie hierarquia, enquadramento e tipografia, não só cor. Cada opção pode levar direction: {theme, rationale}. Escolher aplica o tema ao deck, mantendo outros slides intactos.
 - Para integrar texto ao cenário, componha camadas editáveis em canvas (imagem, texto, primeiro plano). continuity no mesmo objeto em slides consecutivos mantém continuidade espacial. Prefira uma imagem estática forte quando movimento não explicar nada.
@@ -250,12 +258,58 @@ function protectLatex(src) {
   return src.replace(/"(?:[^"\\\n]|\\.)*"/g, (q) => (/\\[A-Za-z]{2,}/.test(q) ? q.replace(LATEX_CMD, "\\\\") : q));
 }
 
+// Vírgula decimal numa sequência ou mapa entre colchetes/chaves: `[07/04/2017, HEC-HMS, 0,93, 0,97]` — no YAML a
+// vírgula ali SEMPRE separa itens, e "0,93" virava duas células (0 e 93): a tabela do paper saiu com NSE 0 e R² 93,
+// as colunas todas deslocadas, sem erro nenhum. Quando os itens são separados por ", " (vírgula e espaço), um
+// "dígitos,dígitos" sem espaço só pode ser número com vírgula decimal: vai entre aspas. `[10,20,30]` (sem ", ") fica.
+export function quoteFlowDecimals(src) {
+  return String(src).split("\n").map((line) => {
+    if (!/[[{]/.test(line) || !/\d,\d/.test(line)) return line;
+    let out = "", depth = 0, quote = null;
+    for (let i = 0; i < line.length; i++) {
+      const c = line[i];
+      if (quote) { out += c; if (c === quote && line[i - 1] !== "\\") quote = null; continue; }
+      if (c === '"' || c === "'") { quote = c; out += c; continue; }
+      if (c === "#" && /\s/.test(line[i - 1] || " ")) { out += line.slice(i); break; }
+      if (c === "[" || c === "{") depth++;
+      if (c === "]" || c === "}") depth = Math.max(0, depth - 1);
+      // início de item no fluxo: número com vírgula decimal colada, terminando no separador ", " ou no fecho
+      if (depth > 0 && /[\s[{:,]/.test(line[i - 1] || "[")) {
+        const m = /^-?\d+,\d+%?(?=\s*(?:,\s|[\]}]|$))/.exec(line.slice(i));
+        if (m && /,\s/.test(line)) { out += `"${m[0]}"`; i += m[0].length - 1; continue; }
+      }
+      out += c;
+    }
+    return out;
+  }).join("\n");
+}
+
+// Número de tabela escrito com zero no fim ("0.90", "7.80", "1.0") virava número no YAML e perdia o zero: a tabela
+// do paper em inglês saiu com "0.9" onde o artigo diz 0.90 (a precisão relatada é dado). Dentro de tabela (rows,
+// head, headers, cells) o número fica como foi escrito; dado de gráfico continua número.
+const TABLE_KEYS = new Set(["rows", "head", "headers", "cells"]);
+function parseKeepingDecimals(src) {
+  const doc = YAML.parseDocument(src);
+  if (doc.errors.length) throw doc.errors[0];
+  YAML.visit(doc, {
+    Scalar(_key, node, path) {
+      if (typeof node.value !== "number" || typeof node.source !== "string" || node.source === String(node.value)) return;
+      if (!/^-?\d+\.\d+$/.test(node.source)) return;
+      const keys = path.filter((p) => YAML.isPair(p)).map((p) => String(p.key?.value));
+      const inChart = keys.some((k) => ["chart", "data", "parts", "series", "values"].includes(k));
+      // valor exibido como texto (número grande do layout number, stats): o contador lê "0.90" com as duas casas
+      if (keys.some((k) => TABLE_KEYS.has(k)) || (keys.at(-1) === "value" && !inChart)) node.value = node.source;
+    },
+  });
+  return doc.toJS();
+}
+
 export function parseYaml(src) {
-  src = protectLatex(src);
+  src = quoteFlowDecimals(protectLatex(src));
   try {
-    return rejoinFlowCommas(YAML.parse(src));
+    return rejoinFlowCommas(parseKeepingDecimals(src));
   } catch (first) {
-    try { return rejoinFlowCommas(YAML.parse(repairYaml(src))); } catch { throw new Error(`YAML inválido: ${first.message}`); }
+    try { return rejoinFlowCommas(parseKeepingDecimals(repairYaml(src))); } catch { throw new Error(`YAML inválido: ${first.message}`); }
   }
 }
 
@@ -474,6 +528,9 @@ export async function materializeImages(spec, { assetsDir, baseDir, max = Infini
       // sem fit escolhido, o encaixe automático decide: a ilustração 16:9 numa caixa em pé cabia cortada ("cover")
       // e a criança da capa saía pela metade
       if (!node.alt) node.alt = prompt.slice(0, 120);
+      // a figura de base fica anotada: "volte para a figura original" pelo chat troca image por original (antes o
+      // caminho se perdia junto com o image_ref e não havia como voltar)
+      if (refFile && !node.original) node.original = node.image_ref;
       delete node.image_prompt;
       delete node.image_ref;
       done.push({ prompt, file, ref: refFile ? path.relative(baseDir, refFile).split(path.sep).join("/") : undefined });
@@ -531,6 +588,13 @@ const CONVERSATION_RULES = `Como responder (você decide pelo que a pessoa quer
    pedido de slide. RESPONDA a pergunta com o que você sabe (e com o material anexado, se houver), sem bloco yaml e sem
    tocar nos slides. Só vira AÇÃO com verbo explícito de fazer ("crie", "adicione", "gere", "monte", "transforme em slides",
    "aplica o que combinamos").
+   1c. OPINIÃO SEM FOCO ("o que você acha desse slide?", "está bom?", "como ficou?") não diz se é sobre o CONTEÚDO ou a
+   APARÊNCIA, e a foto do slide puxa a resposta para o visual. Responda os dois, CONTEÚDO PRIMEIRO: o que o slide afirma
+   está certo e fiel ao material? falta o porquê, o número, a evidência, a conclusão? a ordem conta a história? o que a
+   plateia ou a banca vai perguntar? (use o material e a leitura crítica, se houver). Depois a FORMA em uma ou duas
+   frases (hierarquia, leitura, o que distrai). Até ~180 palavras; opções incluem "Aprofundar o conteúdo" e "Aprofundar o
+   visual". Se a pessoa já disse o foco ("o visual", "o design", "a cor" × "o conteúdo", "o texto", "o argumento",
+   "os dados"), fale só dele.
    1b. BRAINSTORM ANTES DE GERAR — a pessoa diz que vai pedir a geração depois ("primeiro vamos discutir", "depois eu peço
    para gerar", "só ideias por enquanto"): NÃO gere nada parcial nem antecipe slides. Discuta, combine e CONFIRME o plano;
    a geração acontece quando ela pedir. Se ela aprovar uma sugestão tua ou vocês fecharem um ponto ("fechado", "isso mesmo",
@@ -590,6 +654,15 @@ delete: [7]        # números (atuais) dos slides a remover
 test: [2, 3]       # slides "api" para o Studio EXECUTAR agora e te devolver o resultado (números no deck DEPOIS das mudanças)
 review: true       # conferir visualmente os slides alterados; use ao criar experiências ou reformular composição
 \`\`\`
+VER O MATERIAL ANEXADO: do documento você recebe o texto inteiro e o INVENTÁRIO (legendas, caminhos dos recortes e
+das páginas inteiras em \`pages\`), mas NÃO as imagens. Quando a resposta depender do que uma figura, tabela ou página
+mostra (ler um valor de gráfico, conferir um rótulo, comparar o recorte com a página, avaliar se a figura presta),
+peça para ver ANTES de responder ou mexer: responda uma frase e um bloco yaml só com
+\`\`\`yaml
+ver: [contexto/visuais/…/page-06.png, contexto/visuais/…/…-figure-….png]   # até 6 arquivos do inventário
+\`\`\`
+O Studio devolve as imagens e você continua o pedido já vendo. Nunca diga que viu ou leu uma figura que não pediu
+para ver; e não diga que não tem acesso ao material: você tem o texto e pode ver qualquer página ou recorte assim.
 TRANSFORMAR A APRESENTAÇÃO INTEIRA (só quando o deck atual veio de um PowerPoint importado, com \`import:\` no deck e slides
 com \`importado:\`): se a pessoa pedir para MELHORAR a apresentação toda mantendo o estilo do original, ou para RECRIAR do zero,
 não faça patch: responda uma frase dizendo o que vai fazer e um bloco yaml só com
@@ -709,7 +782,7 @@ export function applyPatch(base, patch) {
 const STUDIO_KEYS = ["layout", "notes", "time", "id", "uid", "review", "original", "master", "visualEdits", "auto", "fiscalOk", "from", "image_prompt", "image_ref", "density", "deco", "theme", "palette", "tone",
   "bg", "fg", "background", "backgroundStyle", "footer", "header", "transition", "steps", "markStyle", "maxWords", "fit", "titleAs", "context"];
 const FREE_TEXT_KEYS = new Set(["code", "mermaid", "svg", "html", "request", "realtime", "body", "headers", "response", "notes", "consulta", "output", "json"]);
-const PATCH_WORDS = new Set(["slides", "insert", "delete", "edit", "deck", "variants", "test"]);
+const PATCH_WORDS = new Set(["slides", "insert", "delete", "edit", "deck", "variants", "test", "ver"]);
 let knownKeysCache = null;
 function knownSlideKeys() {
   if (knownKeysCache) return knownKeysCache;
@@ -730,6 +803,13 @@ export function sanitizeCheck(spec, indices) {
       else if (DUMPED_PATCH.test(v)) problems.push(`${where}: o texto parece um pedaço do patch/resposta (slides:, layout:…), não conteúdo`);
     } else if (Array.isArray(v)) v.forEach((x, i) => scan(x, `${where}[${i}]`, key));
     else if (v && typeof v === "object") {
+      // tabela com linha de tamanho diferente do cabeçalho: coluna deslocada (vírgula decimal partindo célula,
+      // célula esquecida) — o número aparece na coluna errada sem erro nenhum
+      const head = Array.isArray(v.head) ? v.head : Array.isArray(v.headers) ? v.headers : null;
+      if (head && Array.isArray(v.rows)) {
+        const bad = v.rows.map((r, k) => (Array.isArray(r) && r.length !== head.length ? k + 1 : 0)).filter(Boolean);
+        if (bad.length) problems.push(`${where}: linha(s) ${bad.slice(0, 5).join(", ")} da tabela com número de células diferente do cabeçalho (${head.length}); número com vírgula decimal vai entre aspas ("0,93") e cada linha tem uma célula por coluna`);
+      }
       if (v.svg) {
         const competing = ["diagram", "chart", "picto", "ufmap", "qr", "points", "image"].filter(k => v[k]);
         if (competing.length) problems.push(`${where}: renderizadores incompatíveis svg e ${competing.join(", ")}; um ocultaria o outro. Ao trocar a figura, remova o tipo anterior com null no edit, ou use elementos separados em row/col/canvas para sobrepor.`);
@@ -740,6 +820,8 @@ export function sanitizeCheck(spec, indices) {
   for (const i of indices) {
     const s = spec.slides[i];
     if (!s || typeof s !== "object") continue;
+    // a tabela pode ser o próprio slide (layout table: head + rows)
+    if (Array.isArray(s.head) && Array.isArray(s.rows)) scan({ head: s.head, rows: s.rows }, `slide ${i + 1}`, null);
     for (const [k, v] of Object.entries(s)) {
       if (PATCH_WORDS.has(k) && k !== "steps") problems.push(`slide ${i + 1}: "${k}" não existe dentro de um slide (é palavra do patch; o slide ficou com um pedaço da resposta)`);
       else if (!known.has(k)) problems.push(`slide ${i + 1}: o campo "${k}" não existe (veja os campos do layout ${s.layout || "?"} na referência)`);
@@ -831,7 +913,7 @@ function parseEditText(text, base) {
   const { text: body, options } = parseOptions(text);
   text = body;
   // Às vezes o patch vem sem a cerca ```: se há uma linha "slides:"/"deck:"/"insert:"/"delete"/"variants:", é YAML.
-  const bare = /^(slides|edit|deck|insert|delete|variants|test)\s*:/m.exec(text);
+  const bare = /^(slides|edit|deck|insert|delete|variants|test|ver)\s*:/m.exec(text);
   if (!/```/.test(text) && bare) text = `${text.slice(0, bare.index)}\n\`\`\`yaml\n${text.slice(bare.index)}\n\`\`\``;
   const hasYaml = /```/.test(text);
   if (!hasYaml) {
@@ -843,6 +925,12 @@ function parseEditText(text, base) {
   const raw = parseYaml(yaml);
   if (!raw || typeof raw !== "object") throw new Error("O bloco yaml precisa ser um objeto com deck/slides/insert/delete (ou variants).");
   if (raw.variants) return parseVariants(raw.variants, base, prose);
+  // ver: [arquivos] → a IA quer OLHAR o material (recorte, página inteira) antes de responder; quem mostra é o Studio
+  if (raw.ver || raw.look) {
+    const files = [].concat(raw.ver || raw.look).map((f) => String(f || "").trim()).filter(Boolean);
+    if (!files.length) throw new Error("ver: mande a lista de arquivos do inventário (recortes ou páginas) que quer ver.");
+    return { spec: base, prose, changed: [], look: files.slice(0, 6) };
+  }
   if (raw.estilo || raw.style) {
     const e = raw.estilo || raw.style;
     const act = typeof e === "string" ? { aplicar: e } : e || {};
@@ -932,7 +1020,7 @@ Antes de responder, verifique (e siga as Regras de edição):
   ];
   let motifObjected = false;
   const drawWarned = new Set();
-  const { spec: edited, prose, attempts, changed = [], talk, options = [], variants, imagesDropped, visionRouted, test = [], commands = [], transform, style, review } =
+  const { spec: edited, prose, attempts, changed = [], talk, options = [], variants, imagesDropped, visionRouted, test = [], commands = [], transform, style, review, look } =
     await askUntilValid(messages, async (t) => {
       const parsed = parseEditText(t, spec);
       if (repairSlides && (parsed.spec.slides.length !== spec.slides.length || parsed.changed?.some(i => !repairSlides.includes(i)))) throw new Error('A revisão só pode corrigir os slides indicados, sem inserir, excluir ou alterar outros slides.');
@@ -953,6 +1041,8 @@ Antes de responder, verifique (e siga as Regras de edição):
   if (talk) return { reply: prose, spec, actions, targetSlide, talk: true, options };
   // transformar a apresentação inteira: quem executa é o servidor (src/ai/transform.js), com o andamento no chat
   if (transform) return { reply: prose || "Vou transformar a apresentação.", spec, actions, targetSlide, transform };
+  // quer ver o material antes de responder: o Studio mostra as imagens e chama de novo (src/studio/ai-chat-route.js)
+  if (look) return { reply: prose || "Vou olhar o material.", spec, actions, targetSlide, look };
   // estilo (Brand Kit): quem aplica/salva é o servidor, com a biblioteca
   if (style) return { reply: prose || "Certo.", spec, actions, targetSlide, style };
   // versões para escolher: nada muda até a pessoa escolher uma
@@ -994,6 +1084,7 @@ Antes de responder, verifique (e siga as Regras de edição):
     quality,
     reviewRequested: !!review,
     test,
+    changed,
     actions,
     targetSlide: changed.includes(targetSlide) ? targetSlide : (changed[0] ?? pickTarget(spec, edited, targetSlide)),
   };
@@ -1059,9 +1150,84 @@ export function styleFor(kind) {
 // Gera um deck inteiro a partir de um briefing. É o MESMO caminho do chat (editDeck): o pedido vai como uma conversa
 // sobre um deck em branco, com as mesmas regras e a mesma temperatura. Antes havia um caminho próprio (direção
 // criativa sorteada, regras rígidas de ritmo, rodadas de reescrita) que saía bem pior que pedir a mesma coisa no chat.
-export async function generateDeck(briefing, { theme, slides, duration, style, direction, materials = [], images = true, imageOptions = {}, onProgress, onEvent, drawCheck = null, reviewCheck = null, ask = false, answer = "", author = "", language = "", research = "auto", web = null, researchDir = null } = {}) {
-  // onProgress(texto): marcos (CLI) · onEvent({ phase, text, chars }): tudo, inclusive o texto chegando (Studio)
-  const say = (text) => { onProgress?.(text); onEvent?.({ phase: "step", text }); };
+// Conferência de cobertura do material (ferramenta de autocrítica da IA): figuras e tabelas numeradas do documento
+// anexado que nenhum slide usa voltam para a IA encaixar no ponto certo da narrativa. Uma rodada; o que ficar de
+// fora vai no relatório (coverage.missing), sem slide enfiado no fim à força.
+export async function coverDocumentVisuals(spec, { materials = [], briefing = "", edit, say = () => {} } = {}) {
+  const { uncoveredVisuals } = await import("./document-visuals.js");
+  const missing = uncoveredVisuals(spec, materials);
+  if (!missing.length) return { spec, coverage: null, actions: [] };
+  say(`${missing.length} figura(s)/tabela(s) do material ainda sem slide; pedindo para encaixar…`);
+  let next = spec, actions = [];
+  try {
+    const r = await edit({ spec, instruction: `Conferência de cobertura: estas figuras e tabelas numeradas do material anexado não aparecem em nenhum slide:
+${missing.map((m) => `- ${m.caption} (página ${m.page}; arquivo ${m.image}${m.width ? `; ${m.width}×${m.height} px` : ""})`).join("\n")}
+Encaixe cada uma no ponto da narrativa em que o assunto dela é discutido (no slide que já fala dele ou num slide novo logo ao lado), com a figura dominante e 1–3 frases de leitura do que ela mostra, sem repetir a legenda numerada. Figuras do mesmo resultado podem dividir um slide. Não mexa no resto do deck. Só deixe alguma de fora se o pedido da pessoa limitou explicitamente a seleção (resumo, poucos slides): nesse caso diga qual e por quê.
+
+Pedido original da pessoa:
+"""
+${briefing}
+"""` });
+    if (!r.talk && r.spec?.slides?.length) { next = r.spec; actions = r.actions || []; }
+  } catch (e) { say(`a conferência de cobertura falhou (${e.message}); sigo com o deck como está`); }
+  const still = uncoveredVisuals(next, materials);
+  if (still.length) say(`Ficaram sem slide: ${still.map((m) => m.caption.slice(0, 60)).join("; ")}.`);
+  return { spec: next, coverage: { total: missing.length, missing: still.map((m) => m.caption) }, actions };
+}
+
+// Idioma do deck pelo texto (quando a IA não gravou `lang`): palavras de ligação de cada língua, que todo texto usa.
+// Deck em inglês sem `lang` saía com os números em português ("1.403", "0,93") e a hifenização errada.
+const LANG_WORDS = { en: /^(the|of|and|to|in|with|for|is|are|from|by|on|this|that|we|our|was|were)$/, pt: /^(de|da|do|das|dos|que|para|com|não|uma|um|os|as|em|no|na|por|são|é)$/, es: /^(el|la|los|las|del|que|para|con|una|por|es|son|en|y)$/ };
+export function guessDeckLang(spec) {
+  const text = JSON.stringify((spec?.slides || []).map(({ notes, consulta, ...s }) => s)).toLowerCase().replace(/"[a-z_]+":/g, " ");
+  const words = text.match(/\p{L}+/gu) || [];
+  const count = Object.fromEntries(Object.entries(LANG_WORDS).map(([k, re]) => [k, words.filter((w) => re.test(w)).length]));
+  const [best, n] = Object.entries(count).sort((a, b) => b[1] - a[1])[0];
+  const second = Object.entries(count).filter(([k]) => k !== best).reduce((m, [, v]) => Math.max(m, v), 0);
+  return n >= 8 && n >= second * 1.5 ? best : null;
+}
+
+// Slide idêntico a outro (mesmo conteúdo, só o uid diferente) é cópia: o deck novo do ICFM10 saiu com duas capas
+// iguais, até nas notes (a IA trocou o slide em branco pela capa e inseriu a capa de novo). Fica o primeiro.
+export function dropDuplicateSlides(spec) {
+  const seen = new Set(), removed = [];
+  const key = (s) => JSON.stringify({ ...s, uid: undefined, auto: undefined });
+  const slides = (spec.slides || []).filter((s, i) => {
+    const k = key(s);
+    if (seen.has(k)) { removed.push(i + 1); return false; }
+    seen.add(k); return true;
+  });
+  return { spec: removed.length ? { ...spec, slides } : spec, removed };
+}
+
+// Checagem dos números (ferramenta de autocrítica): todo número visível do deck que não está no material volta para a
+// IA conferir. Uma rodada; o que sobrar vai no relatório (facts.unsupported) e no aviso.
+export async function checkNumbers(spec, { materials = [], edit, say = () => {} } = {}) {
+  const { unsupportedNumbers } = await import("./document-visuals.js");
+  const bad = unsupportedNumbers(spec, materials);
+  if (!bad.length) return { spec, facts: null, actions: [] };
+  say(`${bad.length} número(s) no deck sem base no material; pedindo para conferir…`);
+  let next = spec, actions = [];
+  try {
+    const r = await edit({ spec, instruction: `Checagem de números: estes números aparecem nos slides, mas não estão escritos no material anexado:\n${bad.map((b) => `- slide ${b.slide}: ${b.number}`).join("\n")}\nPara cada um: se for o valor do material com erro de leitura (por exemplo, lido de um gráfico), troque pelo valor que o texto ou a tabela do material traz; se for uma conta sua a partir de valores do material, deixe só se a conta aparecer no slide ou nas notes; se não houver base, tire o número (reescreva a frase sem ele). Não mexa em mais nada.`, repairSlides: [...new Set(bad.map((b) => b.slide - 1))] });
+    if (!r.talk && r.spec?.slides?.length) { next = r.spec; actions = r.actions || []; }
+  } catch (e) { say(`a checagem de números falhou (${e.message}); sigo com o deck como está`); }
+  const still = unsupportedNumbers(next, materials);
+  if (still.length) say(`Números sem base no material ainda no deck: ${still.map((b) => `${b.number} (slide ${b.slide})`).join(", ")}.`);
+  return { spec: next, facts: { checked: bad.length, unsupported: still }, actions };
+}
+
+export async function generateDeck(briefing, { theme, slides, duration, style, direction, materials = [], images = true, imageOptions = {}, onProgress, onEvent, drawCheck = null, reviewCheck = null, ask = false, answer = "", author = "", language = "", research = "auto", web = null, researchDir = null, board = null, pendingMaterials = null } = {}) {
+  // onProgress(texto): marcos (CLI) · onEvent({ phase, text, chars, stages }): tudo, inclusive o texto chegando (Studio)
+  // Cada etapa passa pelo quadro de etapas (src/ai/progress.js): o aviso diz em que etapa está. pendingMaterials: o
+  // inventário do documento ainda em curso (o Studio começa a ler as páginas e a gerar ao mesmo tempo); pesquisa e
+  // leitura crítica usam o texto e só a escrita espera o inventário.
+  const { stageBoard } = await import("./progress.js");
+  board ||= stageBoard((ev) => onEvent?.(ev));
+  let stageEmit = null;
+  const say = (text) => { onProgress?.(text); if (stageEmit) stageEmit(text); else onEvent?.({ phase: "step", text }); };
+  const stage = (label, fn) => board.run(label, async (emit) => { const prev = stageEmit; stageEmit = emit; try { return await fn(emit); } finally { stageEmit = prev; } });
+  const extras = []; // fontes da pesquisa e a leitura crítica: vão junto do material para a escrita
   const st = style ? styleFor(style) : null;
   if (st && !theme) theme = st.theme;
   if (st && !direction) direction = st.direction;
@@ -1069,15 +1235,14 @@ export async function generateDeck(briefing, { theme, slides, duration, style, d
   // "perguntar quando não souber" (Preferências): uma chamada curta decide para que serve o material (e se precisa perguntar)
   let decided = null;
   if (ask && !answer) {
-    say("entendendo para que serve o material…");
-    decided = await decidePurpose(briefing, materials).catch(() => null);
+    decided = await stage("Entendendo o pedido", () => { say("entendendo para que serve o material…"); return decidePurpose(briefing, materials).catch(() => null); });
     if (decided?.question) return { question: decided.question };
     // ocasião internacional sem idioma informado: confirma antes de gerar no idioma errado
     if (decided?.languageQuestion && (language === "auto" || !language)) return { question: decided.languageQuestion };
   }
   // pesquisa: a IA decide se o que ela sabe basta; se não, busca, escolhe as fontes, lê e anota (src/research)
   let researchReport;
-  if (research !== false) {
+  if (research !== false) await stage("Pesquisa", async () => {
     const R = await import("../research/research.js");
     try {
       say("vendo se precisa pesquisar…");
@@ -1089,13 +1254,34 @@ export async function generateDeck(briefing, { theme, slides, duration, style, d
         const r = off ? { report: { pesquisou: true, motivo: plan.motivo, buscas: plan.buscas, fontes: [], falhas: ["web desligada"], offline: true, data: new Date().toISOString().slice(0, 10) }, materials: [] }
           : await R.runResearch(plan, { briefing, web: web || R.defaultWeb, onProgress: say, saveDir: researchDir });
         researchReport = r.report;
-        materials = [...materials, ...r.materials];
+        extras.push(...r.materials);
         say(r.materials.length ? `pesquisa: ${r.materials.length} fonte(s) lida(s) (${r.report.fontes.map((f) => f.site).join(", ")})`
           : r.report.offline ? "Sem acesso à internet: não deu para pesquisar. Sigo com o que eu sei, sem inventar dado recente; cole links ou anexe arquivos para eu usar."
           : "a pesquisa não achou fonte que desse para ler; sigo com o que eu sei, sem inventar dado recente.");
       }
     } catch (e) { say(`a pesquisa falhou (${e.message}); sigo com o que eu sei`); }
+  });
+  // Leitura crítica do documento antes de escrever (src/ai/critique.js): inconsistências, achados escondidos,
+  // perguntas prováveis, limitações; cada item com trecho conferido. Fica na pasta da apresentação e vai no pedido;
+  // o uso (slide × notes) segue a autoria. Falhou: segue sem ela.
+  let critique = null;
+  {
+    const C = await import("./critique.js");
+    if (C.worthCritique([...materials, ...extras])) await stage("Leitura crítica", async () => {
+      say("lendo o material com olho crítico…");
+      try {
+        critique = await C.critiqueMaterials([...materials, ...extras], { briefing });
+        C.saveCritique(imageOptions.baseDir || researchDir, critique);
+        const cm = C.critiqueMaterial(critique);
+        if (cm) extras.push(cm);
+        say(`leitura crítica: ${critique.itens.length} achado(s) com trecho conferido${critique.naoConfirmados.length ? `, ${critique.naoConfirmados.length} descartado(s) sem trecho no material` : ""}`);
+      } catch (e) { say(`a leitura crítica falhou (${e.message}); sigo sem ela`); }
+    });
   }
+  // o inventário do documento (figuras, tabelas, equações) corria junto: a escrita precisa dele
+  if (pendingMaterials) materials = await stage("Lendo o documento", async (emit) => { emit("terminando a leitura das páginas…"); return pendingMaterials; });
+  materials = [...materials, ...extras];
+  const fromDocument = (materials || []).some((m) => m?.inventory);
   const wishes = [
     researchReport ? (await import("../research/research.js")).researchInstruction(researchReport) : "",
     theme ? `Use o tema "${theme}".` : "Escolha o tema que combina com o assunto.",
@@ -1105,7 +1291,10 @@ export async function generateDeck(briefing, { theme, slides, duration, style, d
     decided?.purpose ? `Para que serve o material (já decidido): purpose: ${decided.purpose}${decided.why ? ` — ${decided.why}` : ""}.` : "",
     decided?.texto ? `A pessoa disse quanto texto quer: ${decided.texto} texto na tela (grave maxWords: ${decided.texto === "muito" ? 200 : 35}).` : "",
     answer ? `Resposta da pessoa à sua pergunta sobre o material: ${answer}` : "",
-    author ? `Autor padrão das preferências: ${author}. É apenas um padrão; autoria ou organização explicitamente indicada no pedido tem prioridade. Grave a atribuição solicitada em author para não aplicar este padrão.` : "",
+    // documento anexado tem autores próprios: o autor das Preferências (quem usa o sagadeck) não assina o artigo dos
+    // outros (a capa do ICFM10 saiu "Narumi Abe" no lugar de Maria Clara Fava)
+    author && !fromDocument ? `Autor padrão das preferências: ${author}. É apenas um padrão; autoria ou organização explicitamente indicada no pedido tem prioridade. Grave a atribuição solicitada em author para não aplicar este padrão.` : "",
+    author && fromDocument ? `Quem usa o sagadeck (Preferências): ${author}. NÃO é o autor do documento anexado: o deck credita os autores do documento; use este nome só se o pedido disser que é quem apresenta.` : "",
     // idioma respondido ou extraído do pedido vale como instrução (inclui a resposta à confirmação de idioma)
     /english|ingl[eê]s/i.test(answer || "") || (!language || language === "auto") && decided?.idioma === "en" ? "Escreva todo o conteúdo em inglês."
     : /portuguese|portugu[eê]s/i.test(answer || "") || (!language || language === "auto") && decided?.idioma === "pt" ? "Escreva todo o conteúdo em português."
@@ -1121,15 +1310,17 @@ ${briefing}
 """
 
 Faça agora, sem oferecer versões. Só pergunte se não der mesmo para saber o que ela quer.`;
-  say("pedindo o deck ao LLM…");
   const creationOptions = { images, maxImages: 8, deferImages: true, drawCheck, materials, onProgress: onEvent };
-  let r;
-  try { r = await editDeck({ ...creationOptions, spec: starter, instruction }); }
-  catch (error) {
-    if (error.code !== 'AI_TOKEN_LIMIT') throw error;
-    const { stagedGeneration } = await import('./staged-generation.js');
-    r = await stagedGeneration(briefing, { starter, wishes, edit: editDeck, options: creationOptions, say });
-  }
+  const inStage = (o) => ({ ...creationOptions, ...o, onProgress: (ev) => (stageEmit || onEvent || (() => {}))(ev) });
+  const r = await stage("Escrevendo a apresentação", async () => {
+    say("pedindo o deck ao LLM…");
+    try { return await editDeck(inStage({ spec: starter, instruction })); }
+    catch (error) {
+      if (error.code !== 'AI_TOKEN_LIMIT') throw error;
+      const { stagedGeneration } = await import('./staged-generation.js');
+      return stagedGeneration(briefing, { starter, wishes, edit: editDeck, options: inStage({}), say });
+    }
+  });
   // a IA preferiu perguntar (como faria no chat): a pergunta volta para a pessoa
   if (r.talk) return { question: { question: r.reply, options: r.options || [] } };
   let spec = r.spec;
@@ -1139,18 +1330,30 @@ Faça agora, sem oferecer versões. Só pergunte se não der mesmo para saber o
   }
   if (spec.slides.length < 2 && spec.slides[0]?.title === "Nova apresentação") throw new Error("A IA não criou a apresentação. Tente de novo ou descreva com mais detalhe.");
   (r.actions || []).filter((x) => /corrigido|não enxerga/.test(x)).forEach(say);
+  // Cobertura do material: figura/tabela numerada do documento que nenhum slide usa volta para a IA decidir onde
+  // entra (ou dizer por que fica de fora, quando o pedido limitou a seleção). Era o "muitas figuras são ignoradas".
+  const covered = await stage("Conferindo as figuras do material", () => coverDocumentVisuals(spec, { materials, briefing, say, edit: (o) => editDeck(inStage(o)) }));
+  spec = covered.spec;
+  const coverage = covered.coverage;
+  const checked = await stage("Conferindo os números", () => checkNumbers(spec, { materials, say, edit: (o) => editDeck(inStage(o)) }));
+  spec = checked.spec;
+  const facts = checked.facts;
+
   // a quantidade de texto que a pessoa pediu com todas as letras vale mesmo se o modelo esquecer de gravar
   if (decided?.texto && !spec.maxWords) spec.maxWords = decided.texto === "muito" ? 200 : 35;
-  if (author && !spec.author) spec.author = author;
+  if (author && !spec.author && !fromDocument) spec.author = author;
   if (!spec.date) spec.date = new Date().toISOString().slice(0, 10); // a data de criação, nunca uma inventada
+  // idioma do deck: números, hifenização e textos automáticos seguem `lang` (pt-BR é o padrão sem nada gravado)
+  if (!spec.lang) { const g = guessDeckLang(spec); if (g && g !== "pt") spec.lang = g; }
   if (spec.title === "Nova apresentação" && spec.slides[0]?.title && spec.slides[0].title !== "Nova apresentação") spec.title = String(spec.slides[0].title).replace(/[=*_`]/g, "");
-  const imgs = await materializeImages(spec, images ? { ...imageOptions, onProgress: say } : { max: 0 });
+  { const d = dropDuplicateSlides(spec); if (d.removed.length) { spec = d.spec; say(`slide(s) repetido(s) removido(s): ${d.removed.join(", ")}`); } }
+  const imgs = await stage("Imagens", () => materializeImages(spec, images ? { ...imageOptions, onProgress: say } : { max: 0 }));
   // foco guiado sobre uma imagem: a visão põe cada destaque no lugar
   try { const { groundSpotlights } = await import("./ground.js"); await groundSpotlights(spec.slides, { baseDir: imageOptions.baseDir || spec._dir, onProgress: say }); } catch {}
   let quality;
-  if (reviewCheck) {
+  if (reviewCheck) await stage("Revisão dos slides", async (emit) => {
     say('Conferindo a apresentação e os estados interativos…');
-    quality = await reviewCheck(spec, spec.slides.map((_, i) => i));
+    quality = await reviewCheck(spec, spec.slides.map((_, i) => i), { onProgress: emit });
     // problema idêntico ao de rodada anterior = tentativa sem efeito: não queima token de novo
     const attempted = new Set();
     for (let round = 0; quality.issues.length && round < 3; round++) {
@@ -1158,8 +1361,8 @@ Faça agora, sem oferecer versões. Só pergunte se não der mesmo para saber o
       if (!fresh.length) { say('Revisão: nada novo para corrigir; encerro as tentativas.'); break; }
       fresh.forEach(x => attempted.add(JSON.stringify(x)));
       try {
-        const repaired = await editDeck({ spec, instruction: `Corrija somente os problemas observados. Não elimine recursos explicitamente pedidos para resolver uma colisão: reposicione, redimensione ou reorganize a composição mantendo a função. Preserve conteúdo e ordem do briefing (${briefing}): ${JSON.stringify(fresh)}.`, images, imageOptions, materials, drawCheck, reviewDepth: 1, repairSlides: fresh.map(x => x.slide - 1), onProgress: onEvent });
-        const nextQuality = await reviewCheck(repaired.spec, repaired.spec.slides.map((_, i) => i));
+        const repaired = await editDeck({ spec, instruction: `Corrija somente os problemas observados. Não elimine recursos explicitamente pedidos para resolver uma colisão: reposicione, redimensione ou reorganize a composição mantendo a função. Preserve conteúdo e ordem do briefing (${briefing}): ${JSON.stringify(fresh)}.`, images, imageOptions, materials, drawCheck, reviewDepth: 1, repairSlides: fresh.map(x => x.slide - 1), onProgress: emit });
+        const nextQuality = await reviewCheck(repaired.spec, repaired.spec.slides.map((_, i) => i), { onProgress: emit });
         spec = repaired.spec; quality = nextQuality;
       } catch (error) {
         quality = { ...quality, verified: false, failures: [...(quality.failures || []), { stage: 'repair', reason: error.message }] };
@@ -1168,8 +1371,9 @@ Faça agora, sem oferecer versões. Só pergunte se não der mesmo para saber o
       }
     }
     if (!quality.verified) say(`Revisão incompleta: ${quality.issues.length} problemas e ${quality.unchecked.length} slides sem conferência.`);
-  }
-  return { spec: publicSpec(spec), images: imgs, direction, variety: varietyReport(spec), ...(quality ? { quality } : {}), ...(researchReport ? { research: researchReport } : {}) };
+  });
+  spec = dropDuplicateSlides(spec).spec; // a correção visual também pode duplicar
+  return { spec: publicSpec(spec), images: imgs, direction, variety: varietyReport(spec), ...(quality ? { quality } : {}), ...(coverage ? { coverage } : {}), ...(facts ? { facts } : {}), ...(critique ? { critique: { itens: critique.itens.length, naoConfirmados: critique.naoConfirmados.length } } : {}), ...(researchReport ? { research: researchReport } : {}) };
 }
 
 export function toYaml(spec) {

package/src/ai/document-materials.js

@@ -23,13 +23,13 @@ export async function prepareDocumentMaterials(materials, dir, options = {}) {
     if (fs.existsSync(cached)) {
       try {
         const saved = JSON.parse(fs.readFileSync(cached,'utf8'));
-        if (saved.visualVersion === 4 && !saved.inventory?.items?.some(item => item.needsReview)) { out.push(saved); continue; }
+        if (saved.visualVersion === 6 && !saved.inventory?.items?.some(item => item.needsReview)) { out.push(saved); continue; }
       } catch { /* refaz inventário interrompido */ }
     }
     fs.mkdirSync(folder,{recursive:true});
     fs.writeFileSync(path.join(folder,name),bytes);
     const inventory = /\.(pdf|docx?)$/i.test(name) ? await extractDocumentVisuals(name,bytes,dir,options) : null;
-    const metadata = {name,text:material.text,detail:material.detail,visualVersion:4,...(inventory ? {inventory} : {})};
+    const metadata = {name,text:material.text,detail:material.detail,visualVersion:6,...(inventory ? {inventory} : {})};
     fs.writeFileSync(path.join(folder,'material.saga.json'),JSON.stringify(metadata));
     out.push(metadata);
   }