sagadeck 1.10.0 → 1.11.0

package/src/lessons.js

@@ -8,6 +8,7 @@ import katex from "katex";
 import { md, esc } from "./markup.js";
 import "./runtime/formula.js";
 import "./runtime/calc.js";
+import "./runtime/solution.js";
 
 const F = globalThis.SagaFormula;
 const tex = (s, display = true) => katex.renderToString(String(s ?? ""), { displayMode: display, throwOnError: false, strict: "ignore", trust: false, maxExpand: 1000, maxSize: 20 });
@@ -29,32 +30,92 @@ const panel = (i, inner, cls = "") => `<section class="lesson-panel dyn-frame ${
 const PROSE = /\p{L}{3,}/u;
 const isProse = (s) => !/\\[a-zA-Z]|[\^_{}]/.test(s) && PROSE.test(String(s).replace(/\b(sen|cos|tan|tg|log|ln|exp|max|min|lim|mod)\b/g, ""));
 const mathOrText = (s) => (isProse(String(s ?? "")) ? `<span class="sol-txt t f-body">${md(String(s))}</span>` : tex(s, false));
-function givenTex(g) {
+// % (e # & _ $) são comandos no LaTeX: "60 %" saía como erro vermelho na conta da criança
+const unitTex = (u) => String(u).replace(/(?<!\\)[%#&_$]/g, (c) => `\\${c}`).replace(/°/g, "^{\\circ}").replace(/ /g, "\\,");
+const unitSuffix = (u) => (u ? `\\ \\mathrm{${unitTex(u)}}` : "");
+function givenTex(g, value = null) {
   if (typeof g === "string") return g;
   if (g.latex) return g.latex;
-  const value = typeof g.value === "string" && isProse(g.value) ? `\\text{${g.value.replace(/[{}\\$]/g, "")}}` : commaTex(g.value);
-  // % (e # & _ $) são comandos no LaTeX: "60 %" saía como erro vermelho na conta da criança
-  const unit = g.unit ? String(g.unit).replace(/(?<!\\)[%#&_$]/g, (c) => `\\${c}`).replace(/°/g, "^{\\circ}").replace(/ /g, "\\,") : "";
-  return `${g.symbol ?? ""} = ${value}${unit ? `\\ \\mathrm{${unit}}` : ""}`;
+  value ??= typeof g.value === "string" && isProse(g.value) ? `\\text{${g.value.replace(/[{}\\$]/g, "")}}` : commaTex(g.value);
+  return `${symbolTex(g.symbol)} = ${value}${unitSuffix(g.unit)}`;
 }
+// "p_atm" é p com índice "atm": sem chaves o LaTeX subscrevia só o "a" (aparecia "pₐtm" num exercício de aula)
+const symbolTex = (s) => String(s ?? "").replace(/_([A-Za-z0-9]{2,})/g, "_{$1}");
+// nome da conta em LaTeX, quando o passo não traz nem latex nem symbol: D2 → D_{2}, rho → \rho, fator → \mathrm{fator}
+const GREEK = /^(alpha|beta|gamma|delta|epsilon|theta|lambda|mu|nu|xi|pi|rho|sigma|tau|phi|chi|psi|omega|Delta|Omega|Phi|Sigma)(\d*)$/;
+const nameTex = (n) => (n.startsWith("_") ? "" : GREEK.test(n) ? n.replace(GREEK, (_, g, d) => `\\${g}${d ? `_{${d}}` : ""}`) : /^[A-Za-z]\d*$/.test(n) ? n.replace(/^(.)(\d+)$/, "$1_{$2}") : `\\mathrm{${n}}`);
+// {{nome}} ou {{expressão:casas}}: o valor calculado no lugar
+const PH = /\{\{\s*([^{}:]+?)\s*(?::\s*(\d+)\s*)?\}\}/g;
+const S = globalThis.SagaSolution;
+// \htmlData só para a marca do número que a apresentação troca ao vivo
+const texLive = (s, display = true) => katex.renderToString(String(s ?? ""), { displayMode: display, throwOnError: false, strict: "ignore", trust: (c) => c.command === "\\htmlData" && Object.keys(c.attributes || {}).every((k) => k === "data-solv"), maxExpand: 1000, maxSize: 20 });
 export function solutionHTML(s, ctx, head) {
   const steps = (s.steps || []).map((x) => (typeof x === "string" ? { latex: x } : x || {}));
   const givens = [].concat(s.givens || s.data || []);
   const hasAnswer = !!s.answer;
+  const answer = hasAnswer ? (typeof s.answer === "string" ? { latex: s.answer } : s.answer) : null;
+  // contas: dados com símbolo e valor viram variáveis; passo (e resposta) com fn é calculado pelo motor
+  const m = S.model({ ...s, steps, answer });
+  const { env, results } = S.evaluate(m);
+  const live = !!s.interactive && m.vars.length > 0;
+  const T = live ? texLive : tex;
+  const marks = [], markAt = new Map();
+  const decOf = (name) => m.vars.find((v) => v.name === name)?.decimals ?? m.calcs.find((c) => c.name === name)?.decimals;
+  const mark = (expr, d) => {
+    const decimals = d != null && d !== "" ? Number(d) : decOf(expr), key = `${expr}|${decimals ?? ""}`;
+    if (!markAt.has(key)) { markAt.set(key, marks.length); marks.push({ expr, ...(decimals != null ? { decimals } : {}) }); }
+    return { k: markAt.get(key), decimals, value: S.evalExpr(expr, env) };
+  };
+  const numTex = (r) => { const t = S.format(r.value, r.decimals, "tex"); return live ? `\\htmlData{solv=${r.k}}{${t}}` : t; };
+  const fillTex = (str) => String(str ?? "").replace(PH, (_, e, d) => numTex(mark(e, d)));
+  const fillText = (str) => {
+    const nums = [];
+    const out = md(String(str ?? "").replace(PH, (_, e, d) => {
+      const r = mark(e, d), t = esc(S.format(r.value, r.decimals, "text"));
+      nums.push(live ? `<span data-solv="${r.k}" data-solv-mode="text">${t}</span>` : t);
+      return `\uE000${nums.length - 1}\uE001`;
+    }));
+    return out.replace(/\uE000(\d+)\uE001/g, (_, i) => nums[i]);
+  };
+  const errors = m.calcs.filter((c) => results[c.key].error).map((c) => `${c.label}: ${results[c.key].error}`);
+  if (errors.length) ctx?.warnings?.push(...errors.map((e) => `exercício resolvido: ${e}`));
+  // LaTeX do passo calculado: o valor onde a pessoa pôs {{nome}} (o nome do próprio passo), ou "≈ valor unidade" no fim
+  const calcTex = (o, key) => {
+    const c = m.calcs.find((x) => x.key === key);
+    if (!c) return o.latex ? fillTex(o.latex) : "";
+    if ([...String(o.latex ?? "").matchAll(PH)].some((x) => x[1] === c.name)) return fillTex(o.latex);
+    const r = mark(c.name, c.decimals);
+    const exact = r.value != null && S.parseNum(S.format(r.value, c.decimals, "text")) === r.value;
+    const lhs = o.latex ? fillTex(o.latex) : o.symbol ? String(o.symbol) : nameTex(c.name);
+    const rel = !lhs || /(=|\\approx|≈)\s*$/.test(lhs) ? "" : exact ? "= " : "\\approx ";
+    return `${lhs}${lhs ? " " : ""}${rel}${numTex(r)}${unitSuffix(o.unit)}`;
+  };
+  const calcError = (key) => { const c = m.calcs.find((x) => x.key === key); return c && results[key].error ? `<div class="sol-error dyn-error f-body">${esc(`${c.label[0].toUpperCase()}${c.label.slice(1)}: ${results[key].error}`)}</div>` : ""; };
+  const varOf = (g) => (g && typeof g === "object" ? m.vars.find((v) => v.name === (g.name ? String(g.name) : S.varName(g.symbol))) : null);
+  const givenHTML = (g) => {
+    if (typeof g === "string") return `<div class="sol-given"><div class="sol-tex">${mathOrText(g)}</div></div>`;
+    const v = live && !g.latex ? varOf(g) : null;
+    const t = v ? givenTex(g, numTex(mark(v.name, v.decimals))) : g.latex ? fillTex(g.latex) : givenTex(g);
+    const slider = v ? `<input type="range" class="sol-slider" data-solv-in="${esc(v.name)}" min="${v.min}" max="${v.max}" step="${v.step}" value="${v.value}" aria-label="${esc(v.label)}">` : "";
+    return `<div class="sol-given${slider ? " live" : ""}"><div class="sol-tex">${T(t, false)}</div>${g.label ? `<span class="t f-body">${md(g.label)}</span>` : ""}${slider}</div>`;
+  };
   const n = 1 + steps.length + (hasAnswer ? 1 : 0); // enunciado · cada passo · resposta
-  const left = `<div class="sol-problem">${s.problem ? `<div class="sol-text t f-body">${md(s.problem)}</div>` : ""}
-    ${givens.length ? `<div class="sol-givens"><div class="sol-label t f-label">Dados</div>${givens.map((g) => `<div class="sol-given"><div class="sol-tex">${typeof g === "string" ? mathOrText(g) : tex(givenTex(g), false)}</div>${g.label ? `<span class="t f-body">${md(g.label)}</span>` : ""}</div>`).join("")}</div>` : ""}
+  const reset = live ? `<button type="button" class="sol-reset" data-solv-reset>Restaurar</button>` : "";
+  const left = `<div class="sol-problem">${s.problem ? `<div class="sol-text t f-body">${fillText(s.problem)}</div>` : ""}
+    ${givens.length ? `<div class="sol-givens"><div class="sol-label t f-label">Dados${reset}</div>${givens.map(givenHTML).join("")}</div>` : ""}
     ${s.find ? `<div class="sol-find"><span class="sol-label t f-label">Pede-se</span><div class="sol-tex">${mathOrText(s.find)}</div></div>` : ""}</div>`;
-  const stepHTML = (st, i, k) => `<article class="sol-step${i === k - 1 ? " now" : ""}"><span class="sol-n t f-label">${String(i + 1).padStart(2, "0")}</span><div class="sol-body">${st.text ? `<div class="sol-why t f-body">${md(st.text)}</div>` : ""}${st.latex ? `<div class="sol-math">${tex(st.latex)}</div>` : ""}${st.note ? `<div class="sol-note t f-body">${md(st.note)}</div>` : ""}</div></article>`;
-  const answer = hasAnswer ? (typeof s.answer === "string" ? { latex: s.answer } : s.answer) : null;
+  const stepTex = steps.map((st, i) => calcTex(st, `p${i}`));
+  const stepHTML = (st, i, k) => `<article class="sol-step${i === k - 1 ? " now" : ""}"><span class="sol-n t f-label">${String(i + 1).padStart(2, "0")}</span><div class="sol-body">${st.text ? `<div class="sol-why t f-body">${fillText(st.text)}</div>` : ""}${stepTex[i] ? `<div class="sol-math">${T(stepTex[i])}</div>` : ""}${calcError(`p${i}`)}${st.note ? `<div class="sol-note t f-body">${fillText(st.note)}</div>` : ""}</div></article>`;
+  const answerTex = answer ? calcTex(answer, "resp") : "";
   const frames = Array.from({ length: n }, (_, k) => {
     const done = Math.min(k, steps.length);
     const list = steps.slice(0, done).map((st, i) => stepHTML(st, i, done)).join("");
-    const final = hasAnswer && k === n - 1 ? `<div class="sol-answer"><span class="sol-label t f-label">${esc(answer.label || "Resposta")}</span>${answer.latex ? `<div class="sol-math">${tex(answer.latex)}</div>` : ""}${answer.text ? `<div class="t f-body">${md(answer.text)}</div>` : ""}</div>` : "";
+    const final = hasAnswer && k === n - 1 ? `<div class="sol-answer"><span class="sol-label t f-label">${esc(answer.label || "Resposta")}</span>${answerTex ? `<div class="sol-math">${T(answerTex)}</div>` : ""}${calcError("resp")}${answer.text ? `<div class="t f-body">${fillText(answer.text)}</div>` : ""}</div>` : "";
     const empty = k === 0 ? `<div class="sol-think t f-display">${md(s.prompt || "Por onde você começaria?")}</div>` : "";
     return panel(k, `<div class="sol-steps">${empty}${list}${final}</div>`);
   }).join("");
-  return `<div class="L-solution dyn" data-lesson="solution" data-lesson-count="${n}">${head(s)}<div class="sol-row">${left}<div class="dyn-frames">${frames}</div></div></div>`;
+  const payload = live ? `<script type="application/json" class="sol-model">${JSON.stringify({ ...m, marks }).replace(/</g, "\\u003c")}</script>` : "";
+  return `<div class="L-solution dyn" data-lesson="solution" data-lesson-count="${n}"${live ? " data-solution" : ""}>${head(s)}<div class="sol-row">${left}<div class="dyn-frames">${frames}</div></div>${payload}</div>`;
 }
 
 // ------------------------------------------------------------------------------------------------ calc

package/src/mcp/server.js

@@ -135,7 +135,7 @@ const TOOLS = [
     inputSchema: {
       type: "object",
       properties: {
-        so: { type: "array", items: { type: "string", enum: ["texto", "visao", "imagem", "pesquisa", "video"] }, description: "Só estes recursos (padrão: todos)" },
+        so: { type: "array", items: { type: "string", enum: ["texto", "visao", "imagem", "pesquisa", "video", "conferencia"] }, description: "Só estes recursos (padrão: todos)" },
         rapido: { type: "boolean", description: "Pula geração de imagem e vídeo (os lentos e cobrados)" },
         video_real: { type: "boolean", description: "Gera um clipe curto de verdade e confere o MP4 (cobrado; leva minutos)" },
       },

package/src/package.js

@@ -5,6 +5,7 @@
 //   <nome>.yaml          a apresentação (sem campos internos da máquina de quem salvou)
 //   imagens/, widgets/…  os arquivos, nos mesmos caminhos relativos do YAML
 //   assets/              arquivos que estavam FORA da pasta do deck (o YAML do pacote aponta para cá)
+//   .sagadeck/geracao.json  o pedido que originou a apresentação com IA, quando existe
 //   FALTANDO.txt         o que o deck usa mas não existia ao salvar
 //
 // Também abre um .zip comum com um .yaml dentro (versão sem manifesto).
@@ -93,6 +94,9 @@ export async function packDeck(spec, { baseDir, name = "apresentacao", generator
     if (size <= budget) { root.file(q.rel, fs.readFileSync(q.abs)); files.push(q.rel); budget -= size; }
     else skipped.push(q.rel);
   }
+  // o pedido que originou a apresentação (src/studio/generation-request.js) viaja junto, para auditar depois
+  const request = path.join(dir, ".sagadeck", "geracao.json");
+  if (fs.existsSync(request)) { root.file(".sagadeck/geracao.json", fs.readFileSync(request)); files.push(".sagadeck/geracao.json"); }
   for (const a of assets) {
     if (a.exists) { root.file(a.rel, fs.readFileSync(a.abs)); files.push(a.rel); }
     else missing.push(a.ref);

package/src/runtime/base.css

@@ -1303,6 +1303,9 @@ html[data-motion="subtle"] .lesson-panel.active{animation:lesson-soft .6s cubic-
 .sol-label{font-size:20px;color:var(--em);letter-spacing:.08em;white-space:nowrap}
 .sol-givens{display:flex;flex-direction:column;gap:10px}
 .sol-given{display:flex;align-items:baseline;gap:16px;font-size:28px}.sol-given .sol-tex{min-width:7em}.sol-given>span{font-size:22px;color:var(--muted)}
+.sol-given.live{flex-wrap:wrap;row-gap:4px}.sol-slider{flex:1 0 100%;height:30px;accent-color:var(--hi);cursor:pointer}
+.sol-reset{font:inherit;font-size:16px;letter-spacing:normal;color:var(--fg);background:transparent;border:1px solid var(--line);border-radius:8px;padding:4px 12px;margin-left:16px;cursor:pointer}.sol-reset:hover{border-color:var(--fg)}
+.sol-error{font-size:20px;margin-top:4px;padding:8px 14px;border-radius:12px}
 .sol-find{display:flex;align-items:baseline;gap:16px;font-size:30px;padding-top:14px;border-top:1px dashed var(--line)}
 .sol-steps{flex:1;display:flex;flex-direction:column;justify-content:flex-end;gap:10px;min-height:0;overflow:hidden;-webkit-mask:linear-gradient(to bottom,transparent 0,#000 60px);mask:linear-gradient(to bottom,transparent 0,#000 60px)}.sol-steps.sol-fit{-webkit-mask:none;mask:none}
 /* passos anteriores em tamanho menor só quando não cabem todos no normal (com 3 passos curtos, ficavam miúdos à toa) */

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
@@ -143,8 +146,9 @@ _${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 = takeMaterials(taskWorkspace, (Array.isArray(body.attachments) ? body.attachments : [])
+        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});
@@ -166,6 +170,8 @@ _${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,
@@ -185,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());
@@ -248,6 +255,8 @@ _${c.naoConfirmados.length} observação(ões) descartada(s): o trecho citado n
             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 || [])];
@@ -289,6 +298,40 @@ _${c.naoConfirmados.length} observação(ões) descartada(s): o trecho citado n
           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" };

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 };