sagadeck 1.2.0 → 1.3.0

package/src/ai/transform.js

@@ -106,6 +106,50 @@ function textOfProduced(slides) {
   slides.forEach((s) => walk(s));
   return acc.join("\n");
 }
+// Slides repetidos (o mesmo conteúdo escrito por dois itens do plano): assinatura normalizada de
+// conteúdo + mídias. Só vale para slide produzido sem decisão pendente (sem review e sem original);
+// par original/proposta e capa repetida de propósito ficam intactos.
+function slideSignature(s) {
+  const media = [];
+  const walk = (v) => {
+    if (Array.isArray(v)) return v.forEach(walk);
+    if (v && typeof v === "object") {
+      for (const [k, vv] of Object.entries(v)) {
+        if ((k === "image" || k === "image_prompt" || k === "image_ref" || k === "video") && typeof vv === "string" && vv) media.push(`${k}=${vv}`);
+        else walk(vv);
+      }
+    }
+  };
+  walk(s);
+  const text = textOfProduced([s]).toLowerCase().replace(/\s+/g, " ").trim();
+  return JSON.stringify({ layout: s.layout || "", title: (s.title || "").toLowerCase().trim(), text, media: [...new Set(media)].sort() });
+}
+export function dedupeSlides(slides) {
+  const seen = new Map(), out = [], dropped = [];
+  slides.forEach((s, i) => {
+    if (s?.review || s?.original) { out.push(s); return; }
+    const sig = slideSignature(s);
+    if (seen.has(sig)) { dropped.push({ index: i, title: s.title || "" }); return; }
+    seen.set(sig, true);
+    out.push(s);
+  });
+  return { slides: out, dropped };
+}
+export function hasImagePrompt(s) {
+  let found = false;
+  const walk = (v) => {
+    if (found) return;
+    if (Array.isArray(v)) return v.forEach(walk);
+    if (v && typeof v === "object") {
+      for (const [k, vv] of Object.entries(v)) {
+        if (k === "image_prompt" && typeof vv === "string" && vv.trim()) { found = true; return; }
+        walk(vv);
+      }
+    }
+  };
+  walk(s);
+  return found;
+}
 export function missingFacts(facts, slides) {
   const text = textOfProduced(slides);
   const nums = new Set((text.match(/\d+(?:[.,]\d+)*/g) || []).flatMap(numVals));
@@ -559,6 +603,10 @@ Todos os slides de 1 a ${originals.length} precisam aparecer em algum "de". Mant
           // dica, não erro: palavra certa também pode ser a do original com uma letra a menos ("estão" de "gestão")
           if (typos.length) hints.push(`ITEM ${k + 1}: confira a grafia (letra faltando ou sem acento?): ${typos.slice(0, 15).join(", ")}`);
         }
+        if (/imagem|foto|ilustra|realista|desenho|maquete|3d/i.test(request || job.request || "") && !produced.some(hasImagePrompt)) {
+          // dica, não erro: ilustrar de menos não carimba revisão, mas entra na correção quando há outra rodada
+          hints.push(`ITENS ${batch.map(({ k }) => k + 1).join(", ")}: o pedido pede imagens/ilustração e nenhum slide trouxe image_prompt — prefira ilustrar capa e conceitos onde a imagem explica melhor que ícone ou diagrama, com moderação`);
+        }
         for (const { j, img, f } of equationImages(produced)) {
           issues.push({ k: (produced[j]?.origem || batch[0].k + 1) - 1, kind: "desenho", text: `slide novo ${j + 1} (item ${produced[j]?.origem}): a imagem ${img} é uma EQUAÇÃO${f.dados ? ` (${clip(f.dados, 200)})` : ""}, não uma figura: escreva a fórmula em LaTeX ($…$ no texto, ou equations/latex) e tire a imagem; se o slide precisava de outra figura, use o arquivo certo` });
         }
@@ -677,7 +725,8 @@ Todos os slides de 1 a ${originals.length} precisam aparecer em algum "de". Mant
       return rv ? { ...s, review: rv } : s;
     }));
   });
-  const out = { ...deckBase, ...(mode === "melhorar" ? { import: spec.import, style: { name: style.name } } : { recreatedFrom: spec.import?.from || spec.title }), slides };
+  const dedup = dedupeSlides(slides);
+  const out = { ...deckBase, ...(mode === "melhorar" ? { import: spec.import, style: { name: style.name } } : { recreatedFrom: spec.import?.from || spec.title }), slides: dedup.slides };
   ensureUids(out);
   // mapa de cobertura: cada trecho do original e para onde foi
   const itemOfSlide = new Map();
@@ -701,7 +750,7 @@ Todos os slides de 1 a ${originals.length} precisam aparecer em algum "de". Mant
   const status = stop || missingItems ? "parcial" : report.pendentes.length || report.revisar.length ? "revisar" : "concluido";
   job.status = status; job.stage = "montado"; save();
   return {
-    spec: out, plan,
+    spec: out, plan, duplicados: dedup.dropped.length,
     report: { ...report, status, parou: stop ? stop.message : missingItems ? `${missingItems} item(ns) não saíram` : null, retomada: resumed, mode, textModel: T, visionModel: V, calls: job.calls, usage: job.usage, seconds: Math.round(job.spentMs / 1000), alertas: plan.alertas || [], cobertura: { trechos: coverage.length, localizados: literal, reescritos: coverage.length - literal, arquivo: `original/cobertura-${mode}.md` } },
   };
 }

package/src/diff.js

@@ -0,0 +1,44 @@
+// diff de decks por uid (cai para o índice quando não há uid): o que entrou,
+// saiu, mudou de conteúdo e mudou de lugar. Base para `sagadeck diff`.
+export function slideKey(s, i) {
+  return s && s.uid ? String(s.uid) : `#${i}`;
+}
+
+function changedFields(a, b) {
+  const out = [];
+  for (const k of new Set([...Object.keys(a || {}), ...Object.keys(b || {})])) {
+    if (k === "uid" || k === "auto") continue;
+    if (JSON.stringify(a?.[k]) !== JSON.stringify(b?.[k])) out.push(k);
+  }
+  return out;
+}
+
+export function diffDecks(a = {}, b = {}) {
+  const A = Array.isArray(a.slides) ? a.slides : [];
+  const B = Array.isArray(b.slides) ? b.slides : [];
+  const am = new Map(), bm = new Map();
+  A.forEach((s, i) => am.set(slideKey(s, i), { s, i }));
+  B.forEach((s, i) => bm.set(slideKey(s, i), { s, i }));
+  const added = [], removed = [], changed = [], moved = [];
+  for (const [k, { s, i }] of am) {
+    const o = bm.get(k);
+    if (!o) { removed.push({ index: i, title: s?.title || "" }); continue; }
+    if (o.i !== i) moved.push({ key: k, title: o.s?.title || s?.title || "", from: i, to: o.i });
+    const fields = changedFields(s, o.s);
+    if (fields.length) changed.push({ index: o.i, key: k, title: o.s?.title || s?.title || "", fields });
+  }
+  for (const [k, { s, i }] of bm) {
+    if (!am.has(k)) added.push({ index: i, title: s?.title || "" });
+  }
+  return { added, removed, changed, moved, same: !added.length && !removed.length && !changed.length && !moved.length };
+}
+
+export function formatDiff(d, { aName = "a", bName = "b" } = {}) {
+  if (d.same) return "iguais: nenhum slide entrou, saiu, mudou ou andou.";
+  const L = [];
+  for (const r of d.removed) L.push(`- slide ${r.index + 1}${r.title ? ` "${r.title}"` : ""} (só em ${aName})`);
+  for (const a of d.added) L.push(`+ slide ${a.index + 1}${a.title ? ` "${a.title}"` : ""} (só em ${bName})`);
+  for (const m of d.moved) L.push(`> "${m.title || m.key}" andou: ${m.from + 1} → ${m.to + 1}`);
+  for (const c of d.changed) L.push(`~ slide ${c.index + 1}${c.title ? ` "${c.title}"` : ""}: ${c.fields.join(", ")}`);
+  return L.join("\n");
+}

package/src/export/pptx.js

@@ -10,7 +10,7 @@ import fs from "node:fs";
 import PptxGenJS from "pptxgenjs";
 import JSZip from "jszip";
 import { openDeck } from "./browser.js";
-import { pptxFontMap } from "../themes.js";
+import { pptxFontMap, macFallbackFace } from "../themes.js";
 import { notesPlain } from "../markup.js";
 
 const PX = 1 / 144; // 1920 px = 13,333 in
@@ -247,11 +247,12 @@ const VARIABLE = {
   },
 };
 const near = (arr, v) => arr.reduce((a, b) => (Math.abs(b - v) < Math.abs(a - v) ? b : a));
-function fontFor(run, fmap, aliases = {}) {
+function fontFor(run, fmap, aliases = {}, fallback) {
   const fam = aliases[run.family] || run.family;
   if (VARIABLE[fam]) {
     const V = VARIABLE[fam];
     const r = V.name(near(V.weights, run.weight), near(V.widths, run.stretch || 100));
+    if (fallback === "mac") return { face: macFallbackFace(r.face), bold: r.bold, italic: run.italic };
     return { face: r.face, bold: r.bold, italic: run.italic };
   }
   const m = fmap[run.role];
@@ -261,6 +262,7 @@ function fontFor(run, fmap, aliases = {}) {
     const f = extraBold ? m.bold : m.regular;
     face = f.face; bold = !!f.bold; italic = !!f.italic || (run.italic && !run.baseItalic);
   }
+  if (fallback === "mac") face = macFallbackFace(face);
   return { face, bold, italic };
 }
 
@@ -325,7 +327,7 @@ function materializePseudos() {
 }
 
 // notes: false tira as notas do apresentador (mandar a apresentação para alguém sem a "cola")
-export async function exportPptx(htmlFile, outFile, { theme, meta, nativeCharts = false, notes = true, log = () => {} } = {}) {
+export async function exportPptx(htmlFile, outFile, { theme, meta, nativeCharts = false, notes = true, fontFallback, log = () => {} } = {}) {
   const notesOpt = notes !== false;
   const { browser, page, errors } = await openDeck(htmlFile, { scale: 2 });
   try {
@@ -336,7 +338,7 @@ export async function exportPptx(htmlFile, outFile, { theme, meta, nativeCharts
     html.solo *{visibility:hidden!important}
     html.solo .solo-t,html.solo .solo-t *{visibility:visible!important}
     html.solo .solo-t.solo-bg *{visibility:hidden!important}` });
-  const fmap = pptxFontMap(theme);
+  const fmap = pptxFontMap(theme, { fallback: fontFallback });
   // apelidos CSS (ex.: SagaDIN -> Bahnschrift) declarados em fontFaces do tema
   const aliases = Object.fromEntries((theme.fontFaces || []).map((f) => [f.family, (f.src.match(/local\(['"]?([^'")]+)/) || [])[1]]).filter((x) => x[1]));
   const pres = new PptxGenJS();
@@ -371,7 +373,7 @@ export async function exportPptx(htmlFile, outFile, { theme, meta, nativeCharts
       } else if (it.kind === "text") {
         const runs = [];
         it.paras.forEach((p, pi) => p.forEach((r, ri) => {
-          const f = fontFor(r, fmap, aliases);
+          const f = fontFor(r, fmap, aliases, fontFallback);
           const o = { fontFace: f.face, fontSize: +(r.size * PT).toFixed(2), bold: f.bold, italic: f.italic, color: r.color };
           const tr = Math.round((1 - r.alpha * alpha) * 100); if (tr > 0) o.transparency = tr;
           if (r.spacing) o.charSpacing = +(r.spacing * PT).toFixed(2);
@@ -411,7 +413,7 @@ export async function exportPptx(htmlFile, outFile, { theme, meta, nativeCharts
         anims.push({ name, step: it.step, exit: it.exit, isSp: false });
       } else if (it.kind === "table") {
         const rows = it.rows.map((r) => r.map((c) => {
-          const f = fontFor(c.run, fmap, aliases);
+          const f = fontFor(c.run, fmap, aliases, fontFallback);
           const o = { fontFace: f.face, bold: f.bold, italic: f.italic, fontSize: +(c.size * PT).toFixed(2), color: c.color, align: c.align, valign: "middle", margin: c.pad.map((v) => +(v * PT).toFixed(2)) };
           o.fill = c.fill ? { color: c.fill, transparency: Math.round((1 - c.fillA * alpha) * 100) } : { type: "none" };
           const none = { type: "none" };

package/src/figures/charts.js

@@ -34,11 +34,13 @@ const grouped = (o) => !Array.isArray(o.data) && Array.isArray(o.labels) && Arra
 const axisTitles = (o, W, H, left = 0) => `${o.xLabel ? `<text x="${left + (W - left) / 2}" y="${H - 6}" text-anchor="middle" class="ch-axis f-label" font-size="22" style="fill:var(--muted)">${esc(o.xLabel)}</text>` : ""}${o.yLabel ? `<text x="0" y="0" transform="translate(22 ${H / 2}) rotate(-90)" text-anchor="middle" class="ch-axis f-label" font-size="22" style="fill:var(--muted)">${esc(o.yLabel)}</text>` : ""}`;
 const seriesColor = (s, i) => (s.color ? cvar(s.color) : `var(--s${(i % 5) + 1})`);
 function legendSVG(series, W, y = 30) {
+  // f-label renderiza em maiúsculas espaçadas em todo tema (ver faces em themes.js):
+  // medir sempre com EM.caps, senão o texto estoura por baixo do quadrado vizinho
   let x = W, g = "";
   [...series].reverse().forEach((s, ri) => {
     const i = series.length - 1 - ri, name = String(s.name || `Série ${i + 1}`);
-    x -= textW(name, 24) + 60;
-    g += `<rect x="${x}" y="${y - 20}" width="24" height="24" rx="5" style="fill:${seriesColor(s, i)}"/><text x="${x + 34}" y="${y}" class="f-label" font-size="24" style="fill:var(--muted)">${esc(name)}</text>`;
+    x -= textW(name, 24, EM.caps) + 60;
+    g += `<rect class="ch-leg" x="${x}" y="${y - 20}" width="24" height="24" rx="5" style="fill:${seriesColor(s, i)}"/><text class="ch-leg" x="${x + 34}" y="${y}" class="f-label" font-size="24" style="fill:var(--muted)">${esc(name)}</text>`;
   });
   return g;
 }

package/src/figures/diagrams.js

@@ -1,7 +1,7 @@
 // Diagramas gerados em SVG.
 //   { diagram: loop, nodes: [dados, modelo, decisão, ação], actor: in|on|out|none, at: 3 }
 //   { diagram: spectrum, stops: [HITL, HOTL, HOOTL], at: 1, left: "humano decide", right: "máquina decide" }
-//   { diagram: flow, steps: [a, b, c], highlight: 1 }
+//   { diagram: flow, steps: [a, b, c], highlight: 1, cols: 5 } (fila longa desce em serpentina)
 //   { diagram: venn, a: "…", b: "…", both: "…" }
 import { esc } from "../markup.js";
 import { humanBody } from "./pictos.js";
@@ -84,18 +84,46 @@ export function spectrum(o = {}) {
 
 export function flow(o = {}) {
   const steps = o.steps || [];
-  const n = steps.length, bw = 300, gap = 90, bh = 150;
-  const W = n * bw + (n - 1) * gap;
+  const n = steps.length, bw = 300, gap = 90, bh = 150, vgap = 130;
+  const perRow = Math.max(1, o.cols || 5);
+  const rows = Math.max(1, Math.ceil(n / perRow));
   const id = `ar${++uid}`;
+  const box = (x, y, s, hl) =>
+    `<rect x="${x}" y="${y}" width="${bw}" height="${bh}" rx="18" style="fill:var(${hl ? "--hi" : "--surface"});stroke:var(--fg)" stroke-width="${hl ? 0 : 4}"/>` +
+    `<foreignObject x="${x + 16}" y="${y + 10}" width="${bw - 32}" height="${bh - 20}"><div xmlns="http://www.w3.org/1999/xhtml" class="f-heading" style="height:100%;display:flex;align-items:center;justify-content:center;text-align:center;font-size:36px;color:var(${hl ? "--on-hi" : "--fg"})">${esc(s)}</div></foreignObject>`;
+  const arrow = (x1, y1, x2, y2) =>
+    `<line x1="${x1}" y1="${y1}" x2="${x2}" y2="${y2}" style="stroke:var(--fg)" stroke-width="8" marker-end="url(#${id})"/>`;
   let g = arrowDefs(id);
+  if (rows === 1) {
+    const W = n * bw + (n - 1) * gap;
+    steps.forEach((s, i) => {
+      const x = i * (bw + gap);
+      g += box(x, 0, s, o.highlight === i);
+      if (i < n - 1) g += arrow(x + bw + 12, bh / 2, x + bw + gap - 20, bh / 2);
+    });
+    return wrap([-4, -4, W + 8, bh + 8], g, "flow");
+  }
+  // fila longa (10 a 12 caixas): serpentina em fileiras, ida e volta — a letra continua legível
+  const W = perRow * bw + (perRow - 1) * gap;
+  const at = (i) => {
+    const r = Math.floor(i / perRow), k = i % perRow;
+    const y = r * (bh + vgap);
+    return { x: r % 2 === 0 ? k * (bw + gap) : W - bw - k * (bw + gap), y };
+  };
   steps.forEach((s, i) => {
-    const x = i * (bw + gap);
-    const hl = o.highlight === i;
-    g += `<rect x="${x}" y="0" width="${bw}" height="${bh}" rx="18" style="fill:var(${hl ? "--hi" : "--surface"});stroke:var(--fg)" stroke-width="${hl ? 0 : 4}"/>`;
-    g += `<foreignObject x="${x + 16}" y="10" width="${bw - 32}" height="${bh - 20}"><div xmlns="http://www.w3.org/1999/xhtml" class="f-heading" style="height:100%;display:flex;align-items:center;justify-content:center;text-align:center;font-size:36px;color:var(${hl ? "--on-hi" : "--fg"})">${esc(s)}</div></foreignObject>`;
-    if (i < n - 1) g += `<line x1="${x + bw + 12}" y1="${bh / 2}" x2="${x + bw + gap - 20}" y2="${bh / 2}" style="stroke:var(--fg)" stroke-width="8" marker-end="url(#${id})"/>`;
+    const { x, y } = at(i);
+    g += box(x, y, s, o.highlight === i);
+    if (i >= n - 1) return;
+    const a = at(i), b = at(i + 1);
+    if (a.y === b.y) {
+      const dir = b.x > a.x ? 1 : -1;
+      g += arrow(a.x + (dir > 0 ? bw + 12 : -12), a.y + bh / 2, b.x + (dir > 0 ? -20 : bw + 20), b.y + bh / 2);
+    } else {
+      const cx1 = a.x + bw / 2, cx2 = b.x + bw / 2, my = a.y + bh + vgap / 2;
+      g += `<path d="M${cx1} ${a.y + bh} V${my} H${cx2} V${b.y}" fill="none" style="stroke:var(--fg)" stroke-width="8" marker-end="url(#${id})"/>`;
+    }
   });
-  return wrap([-4, -4, W + 8, bh + 8], g, "flow");
+  return wrap([-4, -4, W + 8, rows * bh + (rows - 1) * vgap + 8], g, "flow");
 }
 
 export function venn(o = {}) {

package/src/fiscal/autofix.js

@@ -360,7 +360,7 @@ export function autofixDeck(spec, issuesReport = []) {
   };
 }
 
-function countSlideWords(s) {
+export function countSlideWords(s) {
   const txt = [];
   const walk = (v, k) => {
     if (k === "notes" || k === "source" || k === "id" || k === "layout" || k === "tone") return;

package/src/fiscal/enxugar.js

@@ -0,0 +1,22 @@
+// enxugar: relatório de palavras por slide contra o limite do material
+// (a mesma conta e o mesmo limite do fiscal anti-sono do autofix).
+// Base para `sagadeck enxugar deck.yaml [--fix]`.
+import { countSlideWords } from "./autofix.js";
+import { wordLimit } from "../purpose.js";
+
+export function enxugarReport(spec = {}) {
+  const slides = Array.isArray(spec.slides) ? spec.slides : [];
+  return slides.map((s, i) => {
+    const words = countSlideWords(s || {});
+    const limit = wordLimit(s || {}, spec);
+    return { index: i, layout: s?.layout || "blocks", title: s?.title || "", words, limit, over: Math.max(0, words - limit) };
+  });
+}
+
+export function formatEnxugar(rows) {
+  const over = rows.filter((r) => r.over > 0);
+  if (!over.length) return `ok: ${rows.length} slide(s), todos dentro do limite.`;
+  return [`${over.length} de ${rows.length} slide(s) acima do limite:`,
+    ...over.map((r) => `  slide ${r.index + 1}${r.title ? ` "${r.title}"` : ""} [${r.layout}]: ${r.words} palavras (limite ${r.limit}, +${r.over})`),
+  ].join("\n");
+}

package/src/library.js

@@ -249,9 +249,80 @@ export function openLibrary(root) {
     return idOf(yaml);
   }
 
+  // ---- geração em andamento (invisível): a IA trabalha numa pasta oculta do tópico e a apresentação
+  // só aparece na biblioteca quando pronta (publicada com o título final, num renomear atômico). Nada a meio
+  // fazer fica visível — nem pode ser apagado sem querer no meio da geração. Interrompida: vai para a lixeira
+  // (recuperável, como qualquer exclusão), nunca apagada direto; órfãs vão para a lixeira na subida do Studio.
+  const STAGING = ".gerando";
+  function stagingRoot(topic) {
+    const base = topicDir(topic || ensureTopic("Sem tópico"));
+    const stage = path.join(base, STAGING);
+    fs.mkdirSync(stage, { recursive: true });
+    return { base, stage };
+  }
+  function createStagingDeck(topic) {
+    const { stage } = stagingRoot(topic);
+    const dir = uniquePath(stage, String(Date.now()));
+    fs.mkdirSync(dir, { recursive: true });
+    const file = path.join(dir, "deck.yaml");
+    writeDeckFile(file, { title: "Gerando…", slides: [{ layout: "cover", title: "Gerando…" }] });
+    return { dir, file };
+  }
+  function stagingOf(topic, dir) {
+    const { base } = stagingRoot(topic);
+    const abs = path.resolve(dir);
+    const rel = path.relative(base, abs);
+    if (!rel || rel.startsWith("..") || path.isAbsolute(rel) || path.dirname(rel) !== STAGING) throw new Error("pasta temporária inválida");
+    return { base, abs };
+  }
+  // publica: confere o .yaml ANTES de mover; o renomear é atômico (mesmo disco) e o .yaml acompanha a pasta
+  function publishStagedDeck(topic, dir, title) {
+    const { base, abs } = stagingOf(topic, dir);
+    const yaml = path.join(abs, "deck.yaml");
+    const spec = YAML.parse(fs.readFileSync(yaml, "utf8")) || {};
+    if (!Array.isArray(spec.slides) || !spec.slides.length) throw new Error("a geração não produziu slides: nada foi publicado");
+    const dest = uniquePath(base, safeName(title || spec.title || "Nova apresentação"));
+    spec.title = title || spec.title || path.basename(dest);
+    fs.renameSync(abs, dest);
+    const final = path.join(dest, path.basename(dest) + ".yaml");
+    fs.renameSync(path.join(dest, "deck.yaml"), final);
+    writeDeckFile(final, spec); // só o título muda no arquivo
+    return idOf(final);
+  }
+  // descarta com cuidado: lixeira (visível e restaurável), nunca rm direto — pode ter material da pessoa lá dentro
+  function discardStaging(topic, dir, reason = "Geração interrompida") {
+    const { abs } = stagingOf(topic, dir);
+    const tdir = path.join(root, TRASH);
+    fs.mkdirSync(tdir, { recursive: true });
+    const slot = path.join(tdir, `${Date.now()}-${STAGING}`);
+    fs.mkdirSync(slot);
+    fs.renameSync(abs, path.join(slot, path.basename(abs)));
+    const yaml = path.join(slot, path.basename(abs), "deck.yaml");
+    let slides = 0, title = reason;
+    try { const spec = YAML.parse(fs.readFileSync(yaml, "utf8")) || {}; slides = Array.isArray(spec.slides) ? spec.slides.length : 0; if (spec.title && spec.title !== "Gerando…") title = spec.title; } catch {}
+    fs.writeFileSync(path.join(slot, ".origem.json"), JSON.stringify({
+      topic, title, deleted: Date.now(), yaml: "deck.yaml",
+      unit: path.basename(abs), slides, staging: true,
+    }));
+    return path.basename(slot);
+  }
+  // na subida: toda pasta temporária é órfã (a geração morreu com o processo) — vai para a lixeira, nunca some
+  function recoverStaging() {
+    const moved = [];
+    for (const e of fs.readdirSync(root, { withFileTypes: true })) {
+      if (!e.isDirectory() || hidden(e.name)) continue;
+      const stage = path.join(root, e.name, STAGING);
+      if (!fs.existsSync(stage)) continue;
+      for (const s of fs.readdirSync(stage, { withFileTypes: true })) {
+        if (!s.isDirectory()) continue;
+        try { moved.push(discardStaging(e.name, path.join(stage, s.name), "Geração interrompida (Studio reiniciado)")); } catch {}
+      }
+    }
+    return moved;
+  }
+
   // ---- lixeira ----
-  function trashDeck(id) {
-    const { file, unit, info } = unitOf(id);
+  function trashDeck(id) {    const { file, unit, info } = unitOf(id);
     const tdir = path.join(root, TRASH);
     fs.mkdirSync(tdir, { recursive: true });
     const slot = path.join(tdir, `${Date.now()}-${path.basename(unit)}`);
@@ -393,6 +464,7 @@ export function openLibrary(root) {
     root, list, resolveId, idOf,
     createTopic, updateTopic, deleteTopic,
     createDeck, moveDeck, renameDeck, duplicateDeck,
+    createStagingDeck, publishStagedDeck, discardStaging, recoverStaging,
     trashDeck, restoreDeck, purgeDeck, purgeOld, listTrash, emptyTrash,
     importPackage,
   };

package/src/motion.js

@@ -26,7 +26,7 @@ function scene(o){
  const message=(kind)=>parent.postMessage({sagaMotion:kind},'*');
  const chat=document.querySelector('.chat'),input=document.querySelector('.input'),thread=document.querySelector('.thread'),status=document.querySelector('.status');
  function reset(){started=false;phase='idle';elapsed=0;chat.hidden=true;input.textContent='';thread.replaceChildren();status.textContent='';}
- window.addEventListener('message',e=>{if(e.source!==parent)return;if(e.data?.sagaMotion==='poster'){reduced=true;if(o.type==='terminal')document.querySelector('.feed').textContent=o.lines.join('\n');}if(e.data?.sagaMotion==='active')active=!!e.data.active;if(e.data?.sagaMotion==='reset')reset();if(e.data?.sagaMotion==='start'){reset();started=true;active=true;phase='recognize';chat.hidden=false;}});
+ message('ready');window.addEventListener('message',e=>{if(e.source!==parent)return;if(e.data?.sagaMotion==='poster'){reduced=true;if(o.type==='terminal')document.querySelector('.feed').textContent=o.lines.join('\n');}if(e.data?.sagaMotion==='active')active=!!e.data.active;if(e.data?.sagaMotion==='reset')reset();if(e.data?.sagaMotion==='start'){reset();started=true;active=true;phase='recognize';chat.hidden=false;}});
  if(o.type==='chat'&&o.manual){const request=e=>{if(!active)return;if(e.type==='keydown'&&![' ','Enter','ArrowRight','PageDown'].includes(e.key))return;e.preventDefault();message('start-request');};document.addEventListener('click',request);document.addEventListener('keydown',request);}
  if(o.type==='chat'&&!o.manual){started=true;phase='recognize';chat.hidden=false;}
  function bubble(text,kind){const el=document.createElement('div');el.className='bubble '+kind;el.textContent=text;thread.append(el);return el;}

package/src/package.js

@@ -78,6 +78,21 @@ export async function packDeck(spec, { baseDir, name = "apresentacao", generator
     created: new Date().toISOString(), generator }, null, 2));
   root.file(main, YAML.stringify(packagedSpec(spec, assets), { indent: 2, lineWidth: 0 }));
   const files = [], missing = [];
+  const pesquisa = [];
+  try {
+    const pdir = path.join(dir, "contexto", "pesquisa");
+    for (const f of fs.readdirSync(pdir)) {
+      const abs = path.join(pdir, f);
+      if (fs.statSync(abs).isFile()) pesquisa.push({ rel: `contexto/pesquisa/${f}`, abs });
+    }
+  } catch {}
+  let budget = 2 * 1024 * 1024; // a pesquisa viaja junto, sem estourar o pacote
+  const skipped = [];
+  for (const q of pesquisa) {
+    const size = fs.statSync(q.abs).size;
+    if (size <= budget) { root.file(q.rel, fs.readFileSync(q.abs)); files.push(q.rel); budget -= size; }
+    else skipped.push(q.rel);
+  }
   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);
@@ -86,7 +101,7 @@ export async function packDeck(spec, { baseDir, name = "apresentacao", generator
     root.file("FALTANDO.txt", `Estes arquivos são usados pela apresentação, mas não foram encontrados em ${dir}:\n\n` +
       missing.map((m) => `- ${m}`).join("\n") + "\n\nColoque-os nesta pasta (mesmo caminho) para a apresentação ficar completa.\n");
   }
-  return { zip: await zip.generateAsync({ type: "nodebuffer", compression: "DEFLATE" }), files, missing };
+  return { zip: await zip.generateAsync({ type: "nodebuffer", compression: "DEFLATE" }), files, missing, pesquisaSkipped: skipped };
 }
 
 // Extrai um pacote numa pasta nova (nunca sobrescreve) e devolve o .yaml principal.

package/src/research/brave.js

@@ -0,0 +1,12 @@
+// Buscador com chave (fase 3): Brave Search API. Só entra na cadeia com BRAVE_SEARCH_KEY
+// (sem chave, é pulado em silêncio — nunca trava a pesquisa por falta de configuração).
+export async function searchBrave(query, { limit = 8, timeoutMs = 12000, key = process.env.BRAVE_SEARCH_KEY } = {}) {
+  if (!key) return [];
+  const url = `https://api.search.brave.com/res/v1/web/search?q=${encodeURIComponent(query)}&count=${Math.min(limit, 20)}&text_decorations=0`;
+  const res = await fetch(url, { signal: AbortSignal.timeout(timeoutMs), headers: { "X-Subscription-Token": key, "Accept": "application/json" } });
+  if (!res.ok) throw new Error(`Brave respondeu HTTP ${res.status}`);
+  const j = await res.json();
+  return ((j.web && j.web.results) || []).slice(0, limit)
+    .map((r) => ({ title: String(r.title || r.url), url: String(r.url || ""), snippet: String(r.description || "").slice(0, 300), date: String(r.age || "") }))
+    .filter((r) => /^https?:\/\//.test(r.url));
+}

package/src/research/chat-research.js

@@ -0,0 +1,29 @@
+// Pesquisa web no chat de um deck aberto (fase 2): a mesma decisão do `new`
+// (a IA diz se o que ela sabe basta), mas com o pedido da mensagem.
+// Se precisar, busca, lê e anota; os materiais [F1]… entram no prompt junto
+// com a instrução de citação, e tudo fica em contexto/pesquisa/ do deck.
+// Sem internet (SAGADECK_WEB=0, a rede do banco): avisa e segue sem inventar.
+// Falhou: segue com o que a IA sabe (o chat nunca trava por causa da pesquisa).
+import { decideResearch, runResearch, researchInstruction, defaultWeb } from "./research.js";
+
+const today = () => new Date().toISOString().slice(0, 10);
+
+export async function maybeResearch({ prompt, materials = [], saveDir = null, onProgress = () => {}, web = null } = {}) {
+  try {
+    const plan = await decideResearch(prompt, { materials });
+    if (!plan.pesquisar) return { materials, report: { pesquisou: false, motivo: plan.motivo }, instruction: "" };
+    onProgress(`vou pesquisar: ${plan.motivo}`);
+    if (process.env.SAGADECK_WEB === "0") {
+      const report = { pesquisou: true, motivo: plan.motivo, buscas: plan.buscas, fontes: [], falhas: ["web desligada"], offline: true, data: today() };
+      return { materials, report, instruction: researchInstruction(report) };
+    }
+    const r = await runResearch(plan, { briefing: prompt, web: web || defaultWeb, onProgress, saveDir });
+    onProgress(r.materials.length
+      ? `pesquisa: ${r.materials.length} fonte(s) lida(s) (${r.report.fontes.map((f) => f.site).join(", ")})`
+      : "a pesquisa não achou fonte que desse para ler; sigo com o que eu sei, sem inventar dado recente.");
+    return { materials: [...materials, ...r.materials], report: r.report, instruction: researchInstruction(r.report) };
+  } catch (e) {
+    onProgress(`a pesquisa falhou (${e.message}); sigo com o que eu sei`);
+    return { materials, report: null, instruction: "" };
+  }
+}

package/src/research/links.js

@@ -0,0 +1,37 @@
+// Checagem de links das fontes da pesquisa: a URL continua de pé?
+// Base para `sagadeck links deck.yaml` (lê contexto/pesquisa/fontes.json ao lado do deck).
+import fs from "node:fs";
+import path from "node:path";
+
+export function linksOfDeck(deckDir) {
+  try {
+    const report = JSON.parse(fs.readFileSync(path.join(deckDir, "contexto", "pesquisa", "fontes.json"), "utf8"));
+    const urls = [...new Set((report.fontes || []).map((f) => f?.url).filter((u) => typeof u === "string" && /^https?:/i.test(u)))];
+    return urls;
+  } catch { return []; }
+}
+
+export async function checkLinks(urls, { fetchFn = fetch, timeoutMs = 15000 } = {}) {
+  const out = [];
+  for (const url of urls || []) {
+    try {
+      const ctrl = new AbortController();
+      const t = setTimeout(() => ctrl.abort(), timeoutMs);
+      try {
+        const r = await fetchFn(url, { redirect: "follow", signal: ctrl.signal });
+        out.push({ url, ok: !!r.ok, status: r.status });
+      } finally { clearTimeout(t); }
+    } catch (e) {
+      out.push({ url, ok: false, status: 0, erro: e?.name === "AbortError" ? "tempo esgotado" : String(e?.message || e).slice(0, 120) });
+    }
+  }
+  return out;
+}
+
+export function formatLinks(rows) {
+  if (!rows.length) return "sem links para conferir.";
+  const bad = rows.filter((r) => !r.ok);
+  return [`${rows.length - bad.length} de ${rows.length} links respondendo:`,
+    ...rows.map((r) => `  ${r.ok ? "ok " : "QUEBROU"} ${r.status || "-"} ${r.url}${r.erro ? ` (${r.erro})` : ""}`),
+  ].join("\n");
+}

package/src/research/research.js

@@ -14,6 +14,8 @@ import path from "node:path";
 import { chat } from "../ai/llm.js";
 import { fetchUrlDoc } from "../ai/context.js";
 import { searchDuckDuckGo } from "./duckduckgo.js";
+import { searchWikipedia } from "./wikipedia.js";
+import { searchBrave } from "./brave.js";
 
 const today = () => new Date().toISOString().slice(0, 10);
 const clip = (s, n) => (String(s ?? "").length > n ? String(s).slice(0, n - 1) + "…" : String(s ?? ""));
@@ -73,10 +75,21 @@ export async function llmSearch(q, { limit = 8 } = {}) {
   const t = r.text || "", m = t.match(/```(?:json)?\s*([\s\S]*?)```/), raw = m ? m[1] : t.slice(t.indexOf("["), t.lastIndexOf("]") + 1);
   return (JSON.parse(raw) || []).filter((x) => /^https?:\/\//.test(x?.url || "")).slice(0, limit).map((x) => ({ title: String(x.title || x.url), url: String(x.url), snippet: String(x.snippet || ""), date: String(x.date || "") }));
 }
+const BACKENDS = {
+  llm: (q) => llmSearch(q),
+  duckduckgo: (q) => searchDuckDuckGo(q, { limit: 8, timeoutMs: 12000 }),
+  brave: (q) => searchBrave(q),
+  wikipedia: (q) => searchWikipedia(q),
+};
+// cadeia configurável: SAGADECK_SEARCH_BACKENDS="brave,llm,duckduckgo" (nomes desconhecidos são ignorados)
+export function searchChain() {
+  const names = String(process.env.SAGADECK_SEARCH_BACKENDS || "llm,duckduckgo,wikipedia").split(",").map((s) => s.trim()).filter(Boolean);
+  return names.filter((n) => BACKENDS[n]);
+}
 async function searchAny(q) {
   const errors = [];
-  for (const f of [() => llmSearch(q), () => searchDuckDuckGo(q, { limit: 8, timeoutMs: 12000 })]) {
-    try { const r = await f(); if (r.length) return r; errors.push("nenhum resultado"); } catch (e) { errors.push(e.message); }
+  for (const name of searchChain()) {
+    try { const r = await BACKENDS[name](q); if (r.length) return r; errors.push(`${name}: nenhum resultado`); } catch (e) { errors.push(`${name}: ${e.message}`); }
   }
   throw new Error(`nenhum buscador respondeu (${errors.join("; ")})`);
 }
@@ -109,11 +122,38 @@ Responda só JSON: {"pesquisar": true|false, "externalAuthorized": true|false, "
   return { pesquisar: !!r.pesquisar && (!materials.some(m=>m.kind !== 'pesquisa') || r.externalAuthorized === true), motivo: String(r.motivo || ""), academico: !!r.academico, buscas: (Array.isArray(r.buscas) ? r.buscas : []).map(String).filter(Boolean).slice(0, 5) };
 }
 
+// ---- cache de busca: a mesma pergunta não paga o buscador duas vezes (TTL em dias) -------------------------------
+const cacheFile = (saveDir) => (saveDir ? path.join(saveDir, "contexto", "pesquisa", "busca-cache.json") : null);
+const cacheDays = () => Number(process.env.SAGADECK_SEARCH_CACHE_DIAS || 7);
+function readSearchCache(saveDir) {
+  try { return JSON.parse(fs.readFileSync(cacheFile(saveDir), "utf8")); } catch { return {}; }
+}
+function writeSearchCache(saveDir, cache) {
+  fs.mkdirSync(path.dirname(cacheFile(saveDir)), { recursive: true });
+  fs.writeFileSync(cacheFile(saveDir), JSON.stringify(cache));
+}
+export function cachedWeb(web, saveDir) {
+  if (!saveDir) return web;
+  const memo = async (kind, q, fn) => {
+    const key = `${kind}:${String(q).trim().toLowerCase()}`;
+    const hit = readSearchCache(saveDir)[key];
+    if (hit && Array.isArray(hit.resultados) && Date.now() - hit.quando < cacheDays() * 864e5) return hit.resultados;
+    const r = await fn(q);
+    try { const c = readSearchCache(saveDir); c[key] = { quando: Date.now(), resultados: r }; writeSearchCache(saveDir, c); } catch {}
+    return r;
+  };
+  return { ...web,
+    search: (q) => memo("web", q, (x) => web.search(x)),
+    ...(web.arxiv ? { arxiv: (q) => memo("arxiv", q, (x) => web.arxiv(x)) } : {}),
+  };
+}
+
 // ---- 2 a 5 -------------------------------------------------------------------------------------------------------
 const siteOf = (u) => { try { return new URL(u).hostname.replace(/^www\./, ""); } catch { return ""; } };
 const isArxiv = (u) => /arxiv\.org\/(abs|pdf)\//.test(u);
 
 export async function runResearch(plan, { briefing = "", web = defaultWeb, onProgress = () => {}, saveDir = null, maxSources = 8, annotationTimeoutMs = 45000 } = {}) {
+  web = cachedWeb(web, saveDir);
   const report = { pesquisou: true, motivo: plan.motivo, buscas: plan.buscas, fontes: [], descartadas: 0, falhas: [], offline: false, data: today() };
   // 2. buscar
   onProgress(`Pesquisando: ${plan.buscas.join(" · ")}`);

package/src/research/wikipedia.js

@@ -0,0 +1,15 @@
+// Buscador sem chave (fase 3): Wikipedia via OpenSearch. Cobre o caso "referência estável"
+// quando o LLM e o DuckDuckGo falham; sem snippet longo, mas com URL exata e descrição curta.
+export async function searchWikipedia(query, { limit = 5, lang = "pt", timeoutMs = 10000 } = {}) {
+  const attempt = async (wiki) => {
+    const url = `https://${wiki}.wikipedia.org/w/api.php?action=opensearch&search=${encodeURIComponent(query)}&limit=${limit}&namespace=0&format=json`;
+    const res = await fetch(url, { signal: AbortSignal.timeout(timeoutMs), headers: { "user-agent": "sagadeck/1.0 (pesquisa para apresentação)" } });
+    if (!res.ok) throw new Error(`Wikipedia (${wiki}) respondeu HTTP ${res.status}`);
+    const [, titles = [], descs = [], links = []] = await res.json();
+    return titles.map((title, i) => ({ title, url: links[i] || "", snippet: (descs[i] || "").slice(0, 300), date: "" })).filter((r) => /^https?:\/\//.test(r.url));
+  };
+  const pt = await attempt(lang).catch(() => []);
+  if (pt.length || lang === "en") return pt.slice(0, limit);
+  const en = await attempt("en").catch(() => []);
+  return [...pt, ...en].slice(0, limit);
+}

package/src/runtime/base.css

@@ -137,8 +137,8 @@ body{-webkit-font-smoothing:antialiased;text-rendering:optimizeLegibility;font-k
 .muted{color:var(--muted)}
 .em{color:var(--em)}
 .t a{color:inherit;text-decoration-thickness:.06em;text-underline-offset:.14em}
-mark{color:var(--on-hi);background:linear-gradient(var(--hi),var(--hi)) no-repeat 0 55%/0% 92%;padding:0 .1em;margin:0 -.04em;-webkit-box-decoration-break:clone;box-decoration-break:clone;transition:background-size .8s var(--ease-out) .25s}
-mark.play{background-size:100% 92%}
+mark{color:var(--on-hi);background:linear-gradient(var(--hi),var(--hi)) no-repeat 0 58%/0% 84%;padding:0 .1em;margin:0 -.04em;-webkit-box-decoration-break:clone;box-decoration-break:clone;transition:background-size .8s var(--ease-out) .25s}
+mark.play{background-size:100% 84%}
 /* estilos alternativos do ==destaque== (markStyle) */
 .ms-sublinhado mark{background:none;color:inherit;padding:0;margin:0;text-decoration:underline;text-decoration-color:var(--hi);text-decoration-thickness:.12em;text-underline-offset:.16em}
 .ms-cor mark{background:none;color:var(--em);padding:0;margin:0}