sagadeck 1.9.0 → 1.11.0

package/src/runtime/solution.js

@@ -0,0 +1,131 @@
+// Exercício resolvido com contas de verdade (layout solution): o número do passo nasce da fórmula, não do texto.
+// Os dados com símbolo e valor viram variáveis; cada passo com `fn` é calculado na ordem (um usa os anteriores pelo
+// nome) com o compilador de src/runtime/formula.js (sem eval), e `{{nome}}` ou `{{expressão:casas}}` no LaTeX ou no
+// texto vira o valor. O mesmo arquivo roda no motor (prévia, PDF) e na apresentação (interactive: o dado vira
+// controle e os passos recalculam). Precisa de SagaFormula carregado antes.
+(function (root) {
+  const ID = /^[A-Za-z][A-Za-z0-9_]*$/;
+  // "L_1" → L1 · "\rho" → rho · "v_{0}" → v0 · "h_f" → hf
+  function varName(symbol) {
+    const n = String(symbol ?? "").replace(/\\(?:mathrm|mathit|text|bar|vec|hat)\b/g, "").replace(/[\\_{}\s]/g, "");
+    return ID.test(n) ? n : "";
+  }
+  // "0,05" → 0.05 · "1.000" → 1000 · "9.81" → 9.81 · "1{,}5" → 1.5 · "2,5e-3" → 0.0025; texto → null
+  function parseNum(v) {
+    if (typeof v === "number") return Number.isFinite(v) ? v : null;
+    let t = String(v ?? "").replace(/\{,\}/g, ",").replace(/\\,|[\s  ]/g, "");
+    if (/^-?\d{1,3}(\.\d{3})+(,\d+)?$/.test(t)) t = t.replace(/\./g, "");
+    t = t.replace(",", ".");
+    return /^-?(\d+\.?\d*|\.\d+)(e[+-]?\d+)?$/i.test(t) ? Number(t) : null;
+  }
+  // casas que a pessoa escreveu ("0,026" → 3): o dado aparece como foi escrito
+  const writtenDecimals = (v) => { const m = String(v).replace(/\{,\}/g, ",").match(/[.,](\d+)$/); return m && !/^\d{1,3}(\.\d{3})+$/.test(String(v)) ? m[1].length : 0; };
+
+  // o modelo: variáveis (dados) e contas (passos e resposta com fn), na ordem
+  function model(s) {
+    const vars = [];
+    for (const g of [].concat(s.givens || s.data || [])) {
+      if (!g || typeof g !== "object") continue;
+      const name = g.name ? String(g.name) : varName(g.symbol), value = parseNum(g.value);
+      if (!ID.test(name) || value == null || vars.some((v) => v.name === name)) continue;
+      const min = g.min != null ? Number(g.min) : value > 0 ? value / 10 : value < 0 ? value * 10 : -10;
+      const max = g.max != null ? Number(g.max) : value > 0 ? value * 10 : value < 0 ? value / 10 : 10;
+      const decimals = g.decimals != null ? Number(g.decimals) : writtenDecimals(g.value);
+      // passo do controle nas casas do dado (1000 anda de 1 em 1, 0,026 de 0,001), sem passar de ~20 mil posições
+      const fine = 10 ** -decimals, range = Math.abs(max - min) || 1;
+      const step = g.step != null ? Number(g.step) : range / fine <= 20000 ? fine : 10 ** Math.floor(Math.log10(range / 1000));
+      // mínimo e máximo na grade do passo: o controle só para em múltiplos do mínimo, e 0,01 virava 0,011
+      const snap = (x, f) => Number((f(x / step) * step).toPrecision(12));
+      vars.push({ name, value, decimals, min: snap(min, Math.floor), max: snap(max, Math.ceil), step, label: String(g.label || g.symbol || name) });
+    }
+    const calcs = [];
+    const add = (o, key, label) => {
+      if (!o || typeof o !== "object" || o.fn == null || o.fn === "") return;
+      const name = o.name && ID.test(String(o.name)) ? String(o.name) : `_${key}`;
+      calcs.push({ key, label, name, fn: String(o.fn), ...(o.decimals != null ? { decimals: Number(o.decimals) } : {}) });
+    };
+    (s.steps || []).forEach((st, i) => add(st, `p${i}`, `passo ${i + 1}`));
+    add(s.answer, "resp", "resposta");
+    return { vars, calcs };
+  }
+
+  // calcula tudo na ordem; cada conta devolve { value, error } (erro em português, para o slide e para a IA)
+  function evaluate(m, values = {}) {
+    const env = Object.create(null);
+    for (const v of m.vars) env[v.name] = Number.isFinite(values[v.name]) ? values[v.name] : v.value;
+    const known = [...m.vars.map((v) => v.name), ...m.calcs.map((c) => c.name)];
+    const out = {};
+    for (const c of m.calcs) {
+      let value = null, error = "";
+      try {
+        const f = root.SagaFormula.compile(c.fn, known);
+        const missing = f.params.filter((p) => !(p in env));
+        if (missing.length) error = `a fórmula usa ${missing.map((p) => `"${p}"`).join(", ")}, que não está nos dados (símbolo e valor) nem nos passos anteriores (name)`;
+        else { value = f.eval(env); if (value == null) error = "a conta não deu um número (divisão por zero ou raiz de negativo?)"; }
+      } catch (e) { error = `fórmula "${c.fn}": ${e.message}`; }
+      if (value != null) env[c.name] = value;
+      out[c.key] = { value, error };
+    }
+    return { env, results: out };
+  }
+  // valor de {{expressão}}: nome, ou conta com os nomes já calculados
+  function evalExpr(expr, env) {
+    if (expr in env) return env[expr];
+    try { const f = root.SagaFormula.compile(expr, Object.keys(env)); return f.params.every((p) => p in env) ? f.eval(env) : null; } catch { return null; }
+  }
+
+  // número para a tela: casas pedidas, ou 4 algarismos (inteiro a partir de 1000); 10 elevado se for extremo.
+  // tex: "1\,430{,}77" · math: "1 430,77" (o mesmo, em texto, para trocar dentro da fórmula) · text: "1.430,77"
+  const SUP = { "-": "⁻", 0: "⁰", 1: "¹", 2: "²", 3: "³", 4: "⁴", 5: "⁵", 6: "⁶", 7: "⁷", 8: "⁸", 9: "⁹" };
+  function format(v, decimals, mode = "tex") {
+    if (v == null || !Number.isFinite(v)) return mode === "tex" ? "\\text{—}" : "—";
+    const comma = mode === "tex" ? "{,}" : ",", group = mode === "tex" ? "\\," : mode === "math" ? " " : ".";
+    const a = Math.abs(v);
+    if (v !== 0 && (a < 1e-3 || a >= 1e7) && !(decimals != null && a >= 1e7)) {
+      const [mant, e] = v.toExponential(decimals != null ? Math.min(decimals, 4) : 2).split("e");
+      const mm = String(Number(mant)).replace(".", comma);
+      return mode === "tex" ? `${mm}\\times10^{${Number(e)}}` : `${mm} × 10${String(Number(e)).split("").map((c) => SUP[c] ?? c).join("")}`;
+    }
+    const s = decimals != null ? v.toFixed(decimals) : a >= 1000 ? v.toFixed(0) : String(Number(v.toPrecision(4)));
+    const [int, frac] = s.replace(/^-0(\.0*)?$/, "0$1").split(".");
+    return `${int.replace(/\B(?=(\d{3})+(?!\d))/g, group)}${frac ? `${comma}${frac}` : ""}`;
+  }
+
+  // na apresentação: o dado vira controle; mexeu, recalcula e troca os números marcados (data-solv)
+  function mount(doc) {
+    doc.querySelectorAll("[data-solution]:not([data-solution-ready])").forEach((el) => {
+      el.dataset.solutionReady = "1";
+      const m = JSON.parse(el.querySelector(".sol-model").textContent);
+      const inputs = [...el.querySelectorAll("[data-solv-in]")];
+      // a cópia em MathML (para leitor de tela) não acompanha o número novo: quem lê passa a ser o próprio desenho
+      el.querySelectorAll(".katex").forEach((k) => {
+        if (!k.querySelector("[data-solv]")) return;
+        k.querySelector(".katex-mathml")?.setAttribute("hidden", "");
+        k.querySelector(".katex-html")?.removeAttribute("aria-hidden");
+      });
+      const redraw = () => {
+        const values = Object.fromEntries(inputs.map((i) => [i.dataset.solvIn, Number(i.value)]));
+        const { env } = evaluate(m, values);
+        el.querySelectorAll("[data-solv]").forEach((n) => {
+          const mk = m.marks[+n.dataset.solv];
+          if (mk) n.textContent = format(evalExpr(mk.expr, env), mk.decimals, n.dataset.solvMode === "text" ? "text" : "math");
+        });
+        const slide = el.closest(".slide");
+        if (slide && root.SagadeckFit?.fitSteps) root.requestAnimationFrame(() => root.SagadeckFit.fitSteps(el));
+      };
+      const stop = (e) => e.stopPropagation(); // setas e cliques no controle não trocam de slide nem de passo
+      inputs.forEach((i) => { ["keydown", "pointerdown", "click"].forEach((ev) => i.addEventListener(ev, stop)); i.addEventListener("input", redraw); });
+      const reset = el.querySelector("[data-solv-reset]");
+      if (reset) {
+        ["keydown", "pointerdown", "click"].forEach((ev) => reset.addEventListener(ev, stop));
+        reset.addEventListener("click", () => { inputs.forEach((i) => { i.value = String(m.vars.find((v) => v.name === i.dataset.solvIn)?.value ?? i.value); }); redraw(); });
+      }
+    });
+  }
+
+  root.SagaSolution = { model, evaluate, evalExpr, format, varName, parseNum, mount };
+  if (typeof document !== "undefined") {
+    const go = () => mount(document);
+    document.readyState === "loading" ? document.addEventListener("DOMContentLoaded", go) : go();
+  }
+})(typeof globalThis !== "undefined" ? globalThis : window);

package/src/studio/ai-chat-route.js

@@ -8,6 +8,7 @@ import { loadSpec } from "../build.js";
 import { writeRecording } from "../api-client.js";
 import { editDeck, coverDocumentVisuals, checkNumbers } from "../ai/deck-ai.js";
 import { reviewExperience } from "../ai/quality.js";
+import { checkMath, hasMath, mathSignature, mathWarning } from "../ai/math-check.js";
 import { maybeResearch } from "../research/chat-research.js";
 import { mapDataPrompt, runMapData, mapDataInstruction } from "../ai/map-data.js";
 import { chatErrorResult } from "./errors.js";
@@ -17,6 +18,8 @@ import { critiqueMaterials, critiqueMarkdown, saveCritique, loadCritique, critiq
 import { styleAction } from "./style-routes.js";
 import * as Project from "./project.js";
 import { carryVisualEdits } from "./visual-keys.js";
+import { conferenceItems, conferencePrompt, recordMath, loadGenReport } from "./conference.js";
+import { saveGenerationRequest } from "./generation-request.js";
 
 // Arquivos que a IA pode pedir para ver (ver: […]): imagens DENTRO da pasta da apresentação (os recortes e as
 // páginas do material ficam em contexto/visuais/). Caminho que sai da pasta, que não existe ou que não é imagem fica
@@ -105,8 +108,23 @@ _${c.naoConfirmados.length} observação(ões) descartada(s): o trecho citado n
     res.on('close', onClose);
     // Capture o arquivo da tarefa: abrir outro deck não redireciona a escrita.
     const taskWorkspace = { ...owner, spec: structuredClone(owner.spec) };
+    const originFile = owner.file, originPreview = owner.preview;
+    let materialized = null;
     const prompt = body.message || "";
     const spec = body.spec || taskWorkspace.spec;
+    // Conversar com uma prévia não cria arquivo. Edição/imagem ou documento binário precisam da cópia pessoal.
+    const imageOptionsFor = (deck = spec) => {
+      const options = imageOptions(taskWorkspace, withBase(taskWorkspace, deck));
+      if (originPreview && !originFile && taskWorkspace.file && !materialized) {
+        materialized = { id: taskWorkspace.library.idOf(taskWorkspace.file), title: taskWorkspace.spec.title,
+          topic: originPreview.topic, file: taskWorkspace.file };
+        if (owner.file === originFile && owner.preview === originPreview) {
+          owner.file = taskWorkspace.file;
+          owner.preview = null;
+        }
+      }
+      return materialized ? { ...options, baseDir: path.dirname(taskWorkspace.file) } : options;
+    };
     const issues = body.issues || [];
     // a IA vê (e testa) os slides api no ambiente atual, que pode ser o embutido "ensaio"
     if (!apiBlocked(req) && (spec.slides || []).some((sl) => sl && sl.layout === "api")) await ensureEnsaio();
@@ -128,8 +146,12 @@ _${c.naoConfirmados.length} observação(ões) descartada(s): o trecho citado n
         const target = typeof body.targetSlide === "number" ? body.targetSlide : null;
         const visuals = await lookAt(withBase(taskWorkspace, spec), target, prompt, emit);
         // anexos: imagens vão como visão; documentos (id do /api/ai/context) vão como texto
-        let materials = await prepareDocumentMaterials(takeMaterials(taskWorkspace, (Array.isArray(body.attachments) ? body.attachments : [])
-          .filter((a) => a && typeof a === "object" && a.type === "doc").map((a) => a.id)), path.dirname(taskWorkspace.file), {signal,onProgress:emit});
+        const attached = takeMaterials(taskWorkspace, (Array.isArray(body.attachments) ? body.attachments : [])
+          .filter((a) => a && typeof a === "object" && a.type === "doc").map((a) => a.id));
+        let materials = attached;
+        if (!taskWorkspace.file && taskWorkspace.preview && materials.some(m => m.bytes)) imageOptionsFor();
+        const materialDir = taskWorkspace.file && !isBundledTemplate(taskWorkspace.file) ? path.dirname(taskWorkspace.file) : null;
+        if (materialDir) materials = await prepareDocumentMaterials(materials, materialDir, {signal,onProgress:emit});
         for (const [i, url] of (Array.isArray(body.attachments) ? body.attachments : []).entries()) {
           if (typeof url === "string" && url.startsWith("data:image/")) visuals.push({ label: `imagem colada pelo usuário ${i + 1}`, dataUrl: url });
         }
@@ -148,13 +170,15 @@ _${c.naoConfirmados.length} observação(ões) descartada(s): o trecho citado n
         materials = chatResearch.materials;
         if (chatResearch.report?.fontes?.length) linkActions.push(`Pesquisa na web: ${chatResearch.report.fontes.length} fonte(s) (${chatResearch.report.fontes.map((f) => f.site).join(", ")})`);
         const firstInstruction = chatResearch.instruction ? `${chatResearch.instruction}\n${prompt}` : prompt;
+        // o que o painel Conferência ainda tem pendente (o ignorado não vai): a IA sabe o que falta sem reler avisos velhos
+        const pending = materialDir ? conferencePrompt(conferenceItems(loadGenReport(materialDir), spec, { dir: materialDir })) : "";
         const editOpts = (extra = {}) => ({
           spec: withBase(taskWorkspace, spec), signal,
           instruction: firstInstruction,
           targetSlide: target,
           issues,
           images: true, // a IA decide (regra no prompt: só quando pedirem ou aceitarem)
-          imageOptions: imageOptions(taskWorkspace, withBase(taskWorkspace, spec)),
+          imageOptions: () => imageOptionsFor(),
           history,
           onProgress: emit,
           visuals,
@@ -167,6 +191,7 @@ _${c.naoConfirmados.length} observação(ões) descartada(s): o trecho citado n
           styles: taskWorkspace.file && !isBundledTemplate(taskWorkspace.file) ? { list: taskWorkspace.library.listStyles(), current: taskWorkspace.spec?.style?.name || null } : null,
           // dados para o mapa (bloco mapa:): só com a pasta da apresentação, que é onde os arquivos ficam
           mapData: P ? mapDataPrompt() : null,
+          pending,
           ...extra,
         });
         result = await editDeck(editOpts());
@@ -212,6 +237,7 @@ _${c.naoConfirmados.length} observação(ões) descartada(s): o trecho citado n
           result.actions = [...(before.actions || []), ...r.feitos.map((f) => `Mapa: gravei ${f.arquivo} (${f.linhas} ${f.tipo === "contorno" ? "contorno" : "itens"}${f.fonte ? `; fonte: ${f.fonte}` : ""})`), ...r.falhas.map((x) => `Mapa: não deu (${x})`), ...(result.actions || [])];
         }
         if (result.geo?.length) result = { ...result, geo: undefined, talk: true, reply: P ? `${result.reply}\n(Já busquei os dados duas vezes; me diga o que ainda falta.)` : "Os dados do mapa ficam na pasta da apresentação: abra-a pela biblioteca e peça de novo." };
+        if (!taskWorkspace.file && taskWorkspace.preview && !result.talk && !result.variants) imageOptionsFor(result.spec);
         // documento anexado NESTA mensagem e a resposta montou/reescreveu a maior parte do deck (criar a apresentação
         // do paper pelo chat): a mesma conferência de cobertura da geração. Pedido pontual ("use a figura 3 no slide
         // 5") não dispara: mexe em poucos slides.
@@ -220,15 +246,17 @@ _${c.naoConfirmados.length} observação(ões) descartada(s): o trecho citado n
           const rewritten = Array.isArray(result.changed) ? result.changed.length : 0;
           if (rewritten >= Math.max(5, result.spec.slides.length / 2)) {
             const covered = await coverDocumentVisuals(result.spec, { materials, briefing: prompt, say: (s) => emit({ phase: "step", text: s }),
-              edit: (o) => editDeck({ signal, images: true, imageOptions: imageOptions(taskWorkspace, withBase(taskWorkspace, spec)), onProgress: emit, materials, drawCheck: diagramCheck, ...o }) });
+              edit: (o) => editDeck({ signal, images: true, imageOptions: () => imageOptionsFor(), onProgress: emit, materials, drawCheck: diagramCheck, ...o }) });
             signal.throwIfAborted();
             if (covered.spec !== result.spec) { result.spec = covered.spec; result.actions = [...(result.actions || []), ...covered.actions]; }
             if (covered.coverage?.missing.length) result.actions = [...(result.actions || []), `Sem slide (figuras/tabelas do material): ${covered.coverage.missing.join("; ")}`];
             const checked = await checkNumbers(result.spec, { materials, say: (s) => emit({ phase: "step", text: s }),
-              edit: (o) => editDeck({ signal, images: true, imageOptions: imageOptions(taskWorkspace, withBase(taskWorkspace, spec)), onProgress: emit, materials, drawCheck: diagramCheck, ...o }) });
+              edit: (o) => editDeck({ signal, images: true, imageOptions: () => imageOptionsFor(), onProgress: emit, materials, drawCheck: diagramCheck, ...o }) });
             signal.throwIfAborted();
             if (checked.spec !== result.spec) { result.spec = checked.spec; result.actions = [...(result.actions || []), ...checked.actions]; }
             if (checked.facts?.unsupported.length) result.actions = [...(result.actions || []), `Números sem base no material: ${checked.facts.unsupported.map((b) => `${b.number} (slide ${b.slide})`).join(", ")}`];
+            // criou a apresentação do documento pelo chat: o pedido fica gravado como na geração (.sagadeck/geracao.json)
+            if (materialDir) try { saveGenerationRequest(materialDir, { origem: "chat", pedido: { briefing: prompt }, materials: attached, spec: result.spec, research: chatResearch.report }); } catch { /* o registro não derruba a resposta */ }
           }
         }
         if (linkActions.length) result.actions = [...linkActions, ...(result.actions || [])];
@@ -264,12 +292,46 @@ _${c.naoConfirmados.length} observação(ões) descartada(s): o trecho citado n
           emit({ phase: "test", text: reports.every((x) => x.ok) ? "Os testes passaram; conferindo…" : "Corrigindo com base no resultado…" });
           const next = await editDeck({
             spec: withBase(taskWorkspace, result.spec), signal, instruction, targetSlide: target, images: false,
-            imageOptions: imageOptions(taskWorkspace, withBase(taskWorkspace, result.spec)), history: convo, onProgress: emit, apiContext: apiContextFor(req, taskWorkspace),
+            imageOptions: () => imageOptionsFor(result.spec), history: convo, onProgress: emit, apiContext: apiContextFor(req, taskWorkspace),
             drawCheck: diagramCheck, runCommand: commandRunner(req, emit, body, taskWorkspace, signal),
           });
           convo.push({ role: "user", text: instruction });
           result = { ...next, actions: [...result.actions, ...(next.actions || [])], spec: next.spec };
         }
+        // Contas: a IA pediu a conferência (contas: [n] ou true) ou mexeu nos números de um slide com conta. Ela escreve
+        // cada resultado como fórmula, o código calcula (src/ai/math-check.js) e o que não bate volta para ela corrigir.
+        if (!result.talk && !result.transform && !result.style && !result.variants && result.spec?.slides) {
+          const all = result.spec.slides.map((_, i) => i);
+          // contas pedidas pelo Studio (Corrigir com IA no painel Conferência): conferidas depois da resposta, sempre
+          const fromPanel = [].concat(body.contas || []).map(Number).filter((n) => Number.isInteger(n) && n >= 1 && n <= all.length).map((n) => n - 1);
+          const asked = result.contas === "all" ? all : [...new Set([...(result.contas || []), ...fromPanel])];
+          const before = new Map((spec.slides || []).map((s) => [s?.uid, s]));
+          const touched = (result.changed || []).filter((i) => { const s = result.spec.slides[i]; const old = s?.uid ? before.get(s.uid) : spec.slides?.[i]; return hasMath(s) && mathSignature(s) !== mathSignature(old || {}); });
+          const only = [...new Set([...asked, ...touched])];
+          if (only.length) {
+            emit({ phase: "step", text: "Conferindo as contas…" });
+            const counted = await checkMath(result.spec, { materials, only, signal, say: (t) => emit({ phase: "step", text: t }),
+              // a conversa vai junto: o que a pessoa pediu com todas as letras ("pode corrigir o material") vale
+              edit: (o) => editDeck({ signal, images: false, onProgress: emit, materials, drawCheck: diagramCheck, history: [...history, { role: "user", text: prompt }], ...o, spec: withBase(taskWorkspace, o.spec) }) });
+            signal.throwIfAborted();
+            if (counted.spec !== result.spec) {
+              const fixedChanged = counted.spec.slides.map((s, i) => (JSON.stringify(s) !== JSON.stringify(result.spec.slides[i]) ? i : -1)).filter((i) => i >= 0);
+              result = { ...result, spec: counted.spec, changed: [...new Set([...(result.changed || []), ...fixedChanged])].sort((a, b) => a - b) };
+            }
+            const m = counted.math;
+            result.math = m;
+            // o painel Conferência passa a mostrar o resultado desta conferência para esses slides
+            if (deckDir) try { recordMath(deckDir, only, m); } catch (e) { console.error("[Studio] conferência:", e.message); }
+            result.actions = [...(result.actions || []), ...counted.actions,
+              m?.failed ? `Conferência das contas falhou: ${m.failed}`
+                : m ? `Contas conferidas: ${m.checked + (m.fixed?.length || 0)} ok${m.fixed?.length ? ` (${m.fixed.length} corrigida(s): ${m.fixed.map((d) => `slide ${d.slide}, ${d.afirmado} ${d.unidade}`.trim()).join("; ")})` : ""}${m.unchecked?.length ? `, ${m.unchecked.length} sem como calcular` : ""}` : "Nenhuma conta para conferir nesses slides",
+              ...(mathWarning(m) ? [mathWarning(m)] : [])];
+            if (asked.length && result.reply === "Vou conferir as contas.") result.reply = m?.divergent?.length ? "Conferi as contas; algumas ainda não batem (veja abaixo)." : m?.fixed?.length ? "Conferi as contas e corrigi o que não batia." : "Conferi as contas: estão certas.";
+            if (m?.reply) result.reply = `${result.reply}
+
+${m.reply}`;
+          }
+        }
         result.mode = "llm";
       } catch (e) {
         if (signal.aborted) return { reply: "Parado a pedido. Nenhuma resposta pendente foi aplicada.", spec, actions: [], talk: true, mode: "cancelled" };
@@ -286,7 +348,7 @@ _${c.naoConfirmados.length} observação(ões) descartada(s): o trecho citado n
       persist(taskWorkspace);
       if (owner.file === taskWorkspace.file) owner.spec = taskWorkspace.spec;
       return { ...result, spec: taskWorkspace.spec, conflicts: merged.conflicts, kept: merged.kept };
-    }, signal)); } finally { owner.aiChats.delete(requestId); res.off("close", onClose); }
+    }, signal).then(result => materialized ? { ...result, materialized } : result)); } finally { owner.aiChats.delete(requestId); res.off("close", onClose); }
     return true;
   }
   return false;

package/src/studio/conference-routes.js

@@ -0,0 +1,44 @@
+// Rotas do painel Revisar › Conferência (src/studio/conference.js): a lista, a decisão por item e o Conferir de novo.
+import path from "node:path";
+import { storedDocumentMaterials } from "../ai/document-materials.js";
+import { llmAvailable } from "../ai/llm.js";
+import * as Project from "./project.js";
+import { conferenceItems, decideItem, recheckDeck, loadGenReport } from "./conference.js";
+
+const send = (res, data, status = 200) => { res.writeHead(status, { "Content-Type": "application/json" }); res.end(JSON.stringify(data)); };
+
+// o material da apresentação: o documento guardado na criação ou no chat; sem ele, os arquivos de contexto/
+export async function deckMaterials(file) {
+  const dir = path.dirname(file);
+  let materials = storedDocumentMaterials(dir);
+  if (!materials.length) { try { materials = await Project.contextMaterials(Project.projectOf(file)); } catch { materials = []; } }
+  return materials;
+}
+
+export async function conferenceRoutes({ req, res, pathname, W, readJSON, isBundledTemplate }) {
+  if (!pathname.startsWith("/api/conferencia")) return false;
+  const dir = W.file && !isBundledTemplate(W.file) ? path.dirname(W.file) : null;
+  const list = (report = loadGenReport(dir)) => ({ items: dir ? conferenceItems(report, W.spec, { dir }) : [], conferidoEm: report?.conferidoEm || null, salvo: !!dir });
+  if (pathname === "/api/conferencia" && req.method === "GET") { send(res, list()); return true; }
+  if (pathname === "/api/conferencia/item" && req.method === "POST") {
+    const body = await readJSON(req);
+    try { decideItem(dir, String(body.id || ""), String(body.status || "")); send(res, { ok: true, ...list() }); }
+    catch (e) { send(res, { error: e.message }, 400); }
+    return true;
+  }
+  if (pathname === "/api/conferencia/conferir" && req.method === "POST") {
+    if (!dir) { send(res, { error: "A apresentação precisa estar salva na biblioteca." }, 400); return true; }
+    const notes = [];
+    try {
+      const materials = await deckMaterials(W.file);
+      const ai = await llmAvailable({ force: true });
+      // sem IA: números e figuras se conferem do mesmo jeito; as contas precisam do modelo para escrever as fórmulas
+      const r = await recheckDeck(dir, W.spec, materials, ai ? {} : { complete: async () => { throw new Error("a IA está desligada"); } });
+      notes.push(...r.notes);
+      if (r.unchecked) notes.push(`${r.unchecked} conta(s) sem como calcular.`);
+      send(res, { ok: true, notes, ...list(r.report) });
+    } catch (e) { send(res, { error: e.message }, 500); }
+    return true;
+  }
+  return false;
+}

package/src/studio/conference.js

@@ -0,0 +1,144 @@
+// Painel Revisar › Conferência: junta num lugar o que as checagens automáticas acharam no deck aberto (contas que não
+// batem, contas do material que não fecham, números sem base no material, avisos da revisão visual, figuras do
+// material sem slide, slides que a IA calculou ou incluiu) e o que a pessoa decidiu sobre cada um.
+// Antes os achados ficavam espalhados (relatório da criação, mensagem do chat, selo na miniatura) e a professora
+// entregou a aula com a conta errada: o aviso existia, mas não tinha lugar nem botão.
+// A decisão (ignorado: "está certo assim"; enviado: o pedido de correção já foi ao chat) fica no relatório
+// (.sagadeck/avaliacao-geracao.json, campo `decisoes`): o item some do painel e dos próximos pedidos à IA.
+import { locate, checkMath } from "../ai/math-check.js";
+import { unsupportedNumbers, uncoveredVisuals } from "../ai/document-visuals.js";
+import fs from "node:fs";
+import path from "node:path";
+import YAML from "yaml";
+import { loadGenReport, writeGenReport, slideMark, slideMarks } from "./generation-report.js";
+
+// Como os slides eram quando os avisos da revisão visual nasceram: as marcas do relatório; relatório antigo, sem
+// marcas, usa a versão mais antiga guardada do deck (a primeira gravação depois da criação).
+export function reportBaseline(report, dir) {
+  if (report?.slideMarks) return report.slideMarks;
+  if (!dir) return null;
+  try {
+    const vdir = path.join(dir, ".sagadeck", "versoes");
+    const first = fs.readdirSync(vdir).filter((f) => /\.ya?ml$/i.test(f)).sort()[0];
+    return first ? slideMarks(YAML.parse(fs.readFileSync(path.join(vdir, first), "utf8"))) : null;
+  } catch { return null; }
+}
+
+export const CONF_KINDS = {
+  conta: "Conta que não bate",
+  material: "Conta do material que não fecha",
+  numero: "Número sem base no material",
+  visual: "Aviso da revisão visual",
+  figura: "Figura do material sem slide",
+  derivado: "Calculado pela IA",
+  proprio: "Incluído pela IA",
+};
+
+// id estável para o mesmo achado (o painel e o relatório falam dele pelo id)
+const hash = (s) => { let h = 5381; for (const c of String(s)) h = ((h << 5) + h + c.codePointAt(0)) >>> 0; return h.toString(36); };
+const fmt = (x) => (typeof x === "number" ? Number(x.toPrecision(4)).toLocaleString("pt-BR", { maximumFractionDigits: 6 }) : String(x ?? ""));
+const unit = (d) => (d.unidade ? ` ${d.unidade}` : "");
+
+// Os itens pendentes: relatório + origem dos slides do deck atual, menos o que a pessoa já decidiu. Achado que o
+// deck já não tem (o número saiu do slide, o slide não existe mais) não aparece: foi resolvido.
+export function conferenceItems(report, spec, { dir = null } = {}) {
+  const slides = spec?.slides || [];
+  const baseline = report?.quality?.issues?.length ? reportBaseline(report, dir) : null;
+  // o slide mudou depois do aviso (a IA ou a pessoa já mexeu nele): o aviso pode estar resolvido
+  const changed = (n) => { if (!baseline) return false; const s = slides[n - 1], was = baseline[s?.uid || `#${n}`]; return was != null && was !== slideMark(s); };
+  const decided = report?.decisoes || {};
+  const out = [];
+  const still = (n, number) => slides[n - 1] && locate(slides[n - 1], number).length > 0;
+  for (const d of report?.math?.divergent || []) {
+    if (!still(d.slide, d.afirmado)) continue;
+    out.push({ id: `conta:${d.slide}:${d.afirmado}`, kind: "conta", slide: d.slide, contas: [d.slide],
+      text: `${d.oQue ? `${d.oQue}: ` : ""}o slide diz ${d.afirmado}${unit(d)}; refazendo a conta, dá ${fmt(d.calculado)}${unit(d)}.`,
+      fix: `Confira a conta do slide ${d.slide}${d.oQue ? ` (${d.oQue})` : ""}: o slide diz ${d.afirmado}${unit(d)}; refazendo a partir dos dados, dá ${fmt(d.calculado)}${unit(d)}${d.fn ? ` [${d.fn} com ${JSON.stringify(d.vars || {})}]` : ""}. Se o slide estiver errado, corrija o resultado em todos os campos onde ele aparece e o que depende dele (passos, resposta, notes, gráficos e textos de outros slides); se o slide estiver certo, diga por quê.` });
+  }
+  for (const d of report?.math?.material || []) {
+    if (!still(d.slide, d.afirmado)) continue;
+    out.push({ id: `material:${d.slide}:${d.afirmado}`, kind: "material", slide: d.slide, contas: [d.slide],
+      text: `${d.oQue ? `${d.oQue}: ` : ""}o material traz ${d.afirmado}${unit(d)}, mas a conta com os dados dele dá ${fmt(d.calculado)}${unit(d)}. Confira com quem escreveu.`,
+      fix: `No slide ${d.slide}, o número ${d.afirmado}${unit(d)} está no material, mas não fecha com os dados dele: refazendo, dá ${fmt(d.calculado)}${unit(d)}. Siga a autoria do deck: em \`autoria: autor\` (ou sem autoria definida), mantenha o número do material e explique a divergência nas notes ("Confira: o material traz X; refazendo a conta, dá Y"); em \`autoria: livre\`, corrija no slide e diga nas notes que o material traz outro valor.` });
+  }
+  for (const b of report?.facts?.unsupported || []) {
+    if (!still(b.slide, b.number)) continue;
+    out.push({ id: `numero:${b.slide}:${b.number}`, kind: "numero", slide: b.slide,
+      text: `${b.number} aparece no slide, mas não está escrito no material.`,
+      fix: `O número ${b.number} do slide ${b.slide} não está no material anexado. Se for valor do material lido errado (de um gráfico, por exemplo), troque pelo que o texto ou a tabela do material traz; se for conta sua a partir do material, deixe só com a conta 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.` });
+  }
+  for (const i of report?.quality?.issues || []) {
+    if (!slides[i.slide - 1]) continue;
+    const text = String(i.text || "").trim(), stale = changed(i.slide);
+    out.push({ id: `visual:${i.slide}:${hash(text)}`, kind: "visual", slide: i.slide, ...(stale ? { stale: true } : {}),
+      text: stale ? `O slide mudou depois deste aviso; confira se ainda vale: ${text}` : text,
+      fix: `${stale ? "O slide mudou depois deste aviso da revisão visual; olhe o slide e, se o problema ainda existir, corrija" : "Corrija"} no slide ${i.slide} este aviso: ${text}` });
+  }
+  for (const caption of report?.coverage?.missing || []) {
+    out.push({ id: `figura:${hash(caption)}`, kind: "figura", slide: null, text: String(caption),
+      fix: `Esta figura/tabela do material não aparece em nenhum slide: ${caption}. Encaixe-a 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. Não mexa no resto do deck.` });
+  }
+  slides.forEach((s, k) => {
+    const n = k + 1, note = s?.provenanceNote ? String(s.provenanceNote) : "";
+    if (s?.provenance === "derivado") out.push({ id: `derivado:${s.uid || n}`, kind: "derivado", slide: n, contas: [n],
+      text: note || "Feito pela IA a partir dos números do material: confira as contas.",
+      fix: `O slide ${n} foi feito pela IA a partir dos números do material${note ? ` (${note})` : ""}. Refaça as contas dele a partir dos dados e corrija o que não bater, em todos os campos onde o número aparece.` });
+    else if (s?.provenance === "proprio") out.push({ id: `proprio:${s.uid || n}`, kind: "proprio", slide: n,
+      text: note || "Incluído pela IA: não está no material.",
+      fix: `O slide ${n} foi incluído pela IA e não está no material${note ? ` (${note})` : ""}. Confira se o que ele afirma está correto e coerente com o material; corrija o que não estiver e deixe claro na provenanceNote de onde vem.` });
+  });
+  return out.filter((it) => !decided[it.id]).map((it) => ({ ...it, label: CONF_KINDS[it.kind] }));
+}
+
+// As pendências que vão junto do pedido ao chat (editDeck: pending). O que foi ignorado não vai: a IA não volta a
+// insistir nisso, nem quando a pessoa pede "corrija os avisos da criação" com a mensagem antiga na conversa.
+export function conferencePrompt(items) {
+  // aviso de slide que já mudou não vai: a IA refazia a correção de algo que talvez já tenha corrigido
+  const list = (items || []).filter((it) => it.kind !== "derivado" && it.kind !== "proprio" && !it.stale);
+  if (!list.length) return "";
+  return `PENDÊNCIAS DA CONFERÊNCIA AUTOMÁTICA (painel Revisar › Conferência): o que as checagens acharam e a pessoa ainda não resolveu nem ignorou. Avisos antigos da conversa que não estão nesta lista foram resolvidos ou ignorados pela pessoa: não volte a eles. Mexa nestes só se o pedido tiver a ver.\n${list.slice(0, 40).map((it) => `- ${it.slide ? `slide ${it.slide}` : "deck"} · ${it.label}: ${it.text}`).join("\n")}`;
+}
+
+// A pessoa decidiu sobre um item: ignorado ("está certo assim") ou enviado (o pedido de correção foi ao chat)
+export function decideItem(dir, id, status) {
+  if (!dir) throw new Error("A apresentação precisa estar salva na biblioteca.");
+  if (!["ignorado", "enviado"].includes(status)) throw new Error("status: ignorado ou enviado");
+  if (!/^[a-z]+:[^\s]{1,200}$/.test(String(id || ""))) throw new Error("item da conferência inválido");
+  const report = loadGenReport(dir) || { createdAt: new Date().toISOString(), avisado: true };
+  report.decisoes = { ...(report.decisoes || {}), [id]: { status, em: new Date().toISOString() } };
+  writeGenReport(dir, report);
+  return report.decisoes[id];
+}
+
+// O chat conferiu as contas de alguns slides (pedido da pessoa, do painel ou edição que mexeu nos números): o resultado
+// substitui o que o relatório dizia desses slides. only: índices 0-based.
+export function recordMath(dir, only, math) {
+  if (!dir || !math || math.failed || !only?.length) return;
+  const report = loadGenReport(dir);
+  if (!report && !math.divergent?.length && !math.material?.length) return;
+  const nums = new Set(only.map((i) => i + 1));
+  const keep = (list) => (list || []).filter((d) => !nums.has(d.slide));
+  const prev = report?.math || {};
+  writeGenReport(dir, { ...(report || { createdAt: new Date().toISOString(), avisado: true }),
+    math: { ...prev, divergent: [...keep(prev.divergent), ...(math.divergent || [])], material: [...keep(prev.material), ...(math.material || [])] } });
+}
+
+// Conferir de novo (botão do painel): refaz no deck atual a conferência das contas (só confere, não corrige: a
+// correção é pelo item), a checagem de números e a cobertura das figuras do material. A revisão visual não se refaz
+// aqui (precisa fotografar os slides); os avisos dela ficam até a pessoa corrigir ou ignorar.
+export async function recheckDeck(dir, spec, materials = [], { complete, signal } = {}) {
+  const report = loadGenReport(dir) || { createdAt: new Date().toISOString(), avisado: true };
+  const notes = [];
+  const sources = (materials || []).filter((m) => m && m.kind !== "critica" && m.kind !== "pesquisa");
+  if (sources.some((m) => String(m.text || "").trim())) report.facts = { checked: 0, unsupported: unsupportedNumbers(spec, sources) };
+  if (sources.some((m) => m.inventory?.items?.length)) report.coverage = { missing: uncoveredVisuals(spec, sources).map((m) => m.caption) };
+  const r = await checkMath(spec, { materials: sources, ...(complete ? { complete } : {}), signal });
+  if (r.math?.failed) notes.push(`A conferência das contas falhou (${r.math.failed}); o resto foi conferido.`);
+  else report.math = r.math ? { checked: r.math.checked, fixed: [], unchecked: r.math.unchecked, divergent: r.math.divergent, material: r.math.material } : { checked: 0, fixed: [], unchecked: [], divergent: [], material: [] };
+  if (!sources.length) notes.push("Sem material anexado: a checagem de números e de figuras precisa do documento.");
+  report.conferidoEm = new Date().toISOString();
+  writeGenReport(dir, report);
+  return { report, notes, unchecked: r.math?.unchecked?.length || 0 };
+}
+
+export { loadGenReport };

package/src/studio/developer-starters.js

@@ -0,0 +1,46 @@
+// Bases curtas para começar uma apresentação técnica sem esperar pela IA.
+// São modelos de fábrica; cada uso cria uma instância pela biblioteca.
+export function developerStarter(kind, { title } = {}) {
+  const code = 'function normalizar(nome) {\n  return nome.trim().toLowerCase();\n}\n\nconst usuario = normalizar("  Ada  ");\nconsole.log(usuario);';
+  const curl = ['curl --request POST "$BASE/echo" \\', '  --header "Content-Type: application/json" \\', '  --data \'{"mensagem":"Olá, API"}\''].join("\n");
+  if (!["programacao", "apis"].includes(kind)) throw new Error("Escolha uma base de programação ou APIs com cURL.");
+  const programming = kind === "programacao";
+  const name = String(title || (programming ? "Meu código, passo a passo" : "Minha primeira API com cURL")).trim();
+  return {
+    title: name, theme: programming ? "terminal-pro" : "aurora-dev", duration: 6, purpose: "palestra", maxWords: 70,
+    ...(!programming ? { env: "ensaio" } : {}),
+    slides: [
+      { layout: "cover", kicker: "Exemplo para editar", title: name,
+        subtitle: programming ? "Entrada, transformação e resultado" : "Entenda o comando e experimente uma chamada",
+        figure: { motion: { type: "console", caption: programming ? "normalizar.js · saída de exemplo" : "curl · saída de exemplo", scenes: [{ cmd: programming ? "node normalizar.js" : 'curl --request POST "$BASE/echo"', out: programming ? ["ada"] : ['200 OK', '{ "mensagem": "Olá, API" }'] }] } },
+        notes: "Este é um exemplo de fábrica para você editar. Use Inserir › Código / cURL para colar seu conteúdo. A animação da capa mostra uma saída ilustrativa." },
+      programming ? {
+        layout: "codewalk", title: "Uma transformação em ==três passos==", filename: "normalizar.js", language: "JavaScript", code,
+        steps: [
+          { title: "Definir a regra", text: "A função recebe um nome. trim remove os espaços nas pontas; toLowerCase converte as letras para minúsculas.", highlight: [1, 2, 3] },
+          { title: "Aplicar à entrada", text: "Os espaços e as letras maiúsculas entram no mesmo exemplo.", highlight: [5] },
+          { title: "Conferir a saída", text: "O resultado pode ser copiado e usado no restante do programa.", highlight: [6], output: "ada" },
+        ], notes: "Troque o código em Formatar. Selecione as linhas e crie uma etapa para explicar o trecho. A saída deste guia é ilustrativa, sem executar o código."
+      } : {
+        layout: "codewalk", title: "O cURL em ==três partes==", filename: "pedido.sh", language: "Bash", code: curl,
+        steps: [
+          { title: "Método e destino", text: "POST envia os dados para o endpoint. BASE é o endereço do ambiente.", highlight: [1] },
+          { title: "Formato dos dados", text: "Content-Type avisa ao servidor que o corpo é JSON.", highlight: [2] },
+          { title: "O corpo enviado", text: "A mensagem é o dado que vamos conferir na resposta.", highlight: [3] },
+        ], notes: "Este comando explica a chamada, sem executá-la. O próximo slide chama a API de ensaio do Studio local."
+      },
+      programming ? {
+        layout: "diagram", title: "Veja o ==caminho== dos dados", mermaid: 'flowchart LR\n  A["Entrada: espaços e maiúsculas"] --> B["trim + toLowerCase"] --> C["Saída: ada"]',
+        notes: "Troque os nós pelo fluxo do seu programa. Use a mesma entrada e a mesma saída em toda a explicação."
+      } : {
+        layout: "api", title: "Experimente ==ao vivo==", text: "No Studio local, clique em Executar. Troque a mensagem no Corpo e execute novamente.", tab: "curl",
+        request: { method: "POST", url: "{{base}}/echo", auth: false, body: { mensagem: "Olá, API" } }, answer: "$.recebido",
+        notes: "Ambiente ENSAIO: API de mentira que o Studio local fornece. No servidor multiusuário, chamadas não são executadas. Para usar seu serviço, troque o ambiente e importe seu cURL por Inserir › Código / cURL."
+      },
+      { layout: "code", title: programming ? "Conferir a ==entrada e saída==" : "Ler a ==resposta==", filename: "resposta.json", language: "JSON",
+        code: programming ? '{\n  "entrada": "  Ada  ",\n  "saida": "ada"\n}' : '{\n  "metodo": "POST",\n  "recebido": { "mensagem": "Olá, API" },\n  "consulta": {}\n}',
+        note: programming ? "Mantenha um exemplo concreto do começo ao fim da explicação." : "O campo recebido contém os mesmos dados enviados no corpo." },
+      { layout: "end", title: "Agora, o ==seu exemplo==", subtitle: "Cole seu conteúdo em Inserir › Código / cURL ou peça ao assistente para explicar os trechos.", notes: "Você pode aplicar outro tema em Design. O exemplo é seu para editar; cada uso cria uma apresentação independente." },
+    ],
+  };
+}

package/src/studio/generation-report.js

@@ -1,10 +1,70 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { mathWarning } from '../ai/math-check.js';
+import { renameRetry } from '../fs-retry.js';
+
+// Relatório da criação com IA (.sagadeck/avaliacao-geracao.json): revisão visual, variedade, números sem base no
+// material, contas e figuras de fora. `avisado` diz se a pessoa já viu os avisos no chat (generationNotice).
+const reportFile = (dir) => path.join(dir, '.sagadeck', 'avaliacao-geracao.json');
+
+export function loadGenReport(dir) {
+  if (!dir) return null;
+  try { return JSON.parse(fs.readFileSync(reportFile(dir), 'utf8')); } catch { return null; }
+}
+
+// grava inteiro (tmp + rename): o painel Conferência e o chat mexem no mesmo arquivo
+export function writeGenReport(dir, report) {
+  const file = reportFile(dir), tmp = `${file}.tmp-${process.pid}`;
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(tmp, JSON.stringify(report, null, 2), 'utf8');
+  renameRetry(tmp, file);
+}
+
+// impressão digital de um slide (o que ele mostra, sem uid nem marcas do Studio): o aviso da revisão visual vale para
+// o slide como ele era; mudou, o painel avisa que o aviso pode estar velho
+export function slideMark(slide) {
+  const s = JSON.stringify({ ...slide, uid: undefined, auto: undefined, review: undefined });
+  let h = 5381; for (const c of s) h = ((h << 5) + h + c.codePointAt(0)) >>> 0;
+  return h.toString(36);
+}
+// marcas por slide: pelo uid (sobrevive a inserir e apagar slides) e, sem uid, pela posição
+export const slideMarks = (spec) => Object.fromEntries((spec?.slides || []).map((s, i) => [s?.uid || `#${i + 1}`, slideMark(s)]));
 
 export function saveGenReport(dir, generation) {
   const reportDir = path.join(dir, '.sagadeck');
   fs.mkdirSync(reportDir, { recursive: true });
-  fs.writeFileSync(path.join(reportDir, 'avaliacao-geracao.json'), JSON.stringify({
+  fs.writeFileSync(reportFile(dir), JSON.stringify({
     createdAt: new Date().toISOString(), quality: generation.quality, variety: generation.variety,
+    ...(generation.spec ? { slideMarks: slideMarks(generation.spec) } : {}),
+    ...(generation.facts ? { facts: generation.facts } : {}), ...(generation.math ? { math: generation.math } : {}),
+    ...(generation.coverage ? { coverage: generation.coverage } : {}), avisado: false,
   }, null, 2), 'utf8');
 }
+
+// Os avisos que a conferência automática deixou sem resolver, como texto para a pessoa
+export function generationWarnings(report) {
+  const out = [];
+  const m = mathWarning(report?.math);
+  if (m) out.push(m);
+  const facts = report?.facts?.unsupported || [];
+  if (facts.length) out.push(`Números sem base no material: ${facts.map((b) => `${b.number} (slide ${b.slide})`).join(', ')}`);
+  const missing = report?.coverage?.missing || [];
+  if (missing.length) out.push(`Figuras e tabelas do material sem slide: ${missing.join('; ')}`);
+  const issues = report?.quality?.issues || [];
+  for (const i of issues.slice(0, 12)) out.push(`Slide ${i.slide}: ${String(i.text).slice(0, 240)}`);
+  if (issues.length > 12) out.push(`… e mais ${issues.length - 12} aviso(s) da revisão visual.`);
+  return out;
+}
+
+// Na primeira vez que a apresentação abre depois da criação, os avisos viram uma mensagem do chat (uma vez só):
+// antes eles ficavam só no arquivo, e ninguém via que a revisão tinha reclamado.
+export function generationNotice(dir) {
+  if (!dir) return null;
+  let report;
+  try { report = JSON.parse(fs.readFileSync(reportFile(dir), 'utf8')); } catch { return null; }
+  if (report.avisado) return null;
+  const warnings = generationWarnings(report);
+  try { fs.writeFileSync(reportFile(dir), JSON.stringify({ ...report, avisado: true }, null, 2), 'utf8'); } catch { return null; }
+  if (!warnings.length) return null;
+  return `A conferência automática da criação desta apresentação deixou estes avisos sem resolver:\n${warnings.map((w) => `- ${w}`).join('\n')}\nPeça "corrija os avisos da criação" para eu tentar de novo, ou ajuste à mão.`;
+}