sagadeck 1.7.1 → 1.9.0

package/src/ai/deck-ai.js

@@ -69,7 +69,7 @@ Siga ESTRITAMENTE a referência abaixo: use só layouts, elementos, campos e fig
 - ANTI-FEIJÃO-COM-ARROZ: varie os layouts de verdade; capa (cover) no início e encerramento (end) no fim quando fizer sentido. Regras duras: nunca 2 slides seguidos com o mesmo layout (salvo série intencional); em 6+ slides use 5+ layouts diferentes com 1 slide de impacto (headline, number, statement, full, image, question); no máximo 45% do deck em listas/cartões (cards, list, steps, stats, bento, agenda). Conteúdo manda no layout, não o contrário (ver o mapa em "Layouts válidos").
 - Slide denso (documentação, referência, números): feche com 1 takeaway em ==destaque== e use o elemento \`aviso\` (tipos: \`importante\`, \`atencao\`, \`dica\`, \`perigo\`) para o que não pode passar batido; grife ==palavras-chave== no texto corrido em vez de encher de negrito.
 - Escreva no idioma do pedido do usuário.
-- Layouts válidos (\`layout:\`): ${Object.keys(LAYOUTS).join(", ")}. Conteúdo → layout (use o que comunica, não o mais fácil): processo/fluxo/arquitetura/UML: layout \`diagram\` (Mermaid); itens em volta de uma ideia: layout \`infographic\`; gráfico: \`chart\` (fórmula/curva/3D: \`science\`); datas: \`calendar\` (grade) ou \`timeline\` (marcos); página densa estilo revista: \`poster\`; jornada+problema+solução+painel: \`onepage\`; status semanal: \`status\`; definição: \`definition\`; citação: \`quote\`; número gigante: \`number\`; KPIs: \`stats\`; A×B: \`compare\`; 2×2: \`matrix\`; pergunta à plateia: \`question\`/\`poll\`; código: \`code\`, guiado: \`codewalk\`; screenshot com foco: \`spotlight\`; API ao vivo: \`api\`; conta/calculadora: \`solution\`/\`calc\`; algoritmo animado: \`algo\`; redes/rotas: \`graphlab\`; código executável pelo aluno: \`codelab\`; experimento: \`playground\`; decisão: \`decisionlab\`; duelo/terminais/turnos: \`duel\`/\`terminals\`/\`turns\`; carrossel: \`carousel\`; funil/pirâmide/agenda: \`funnel\`/\`pyramid\`/\`agenda\`; grade/consulta: \`bento\`/\`mosaic\`/\`ribbon\`/\`dossier\`; tipografia em cena: \`kinetic\`; texto no cenário: \`scenography\`; caminhos com volta ao mapa: \`hub\`+\`goto\`/\`back\`/\`next\`; manchete: \`headline\`; imagem total: \`full\`/\`image\`. Diagramas simples (\`diagram: loop/flow/venn…\`) e gráficos também existem como ELEMENTOS, dentro de figure/content/side.
+- Layouts válidos (\`layout:\`): ${Object.keys(LAYOUTS).join(", ")}. Conteúdo → layout (use o que comunica, não o mais fácil): processo/fluxo/arquitetura/UML: layout \`diagram\` (Mermaid); itens em volta de uma ideia: layout \`infographic\`; gráfico: \`chart\` (fórmula/curva/3D: \`science\`); datas: \`calendar\` (grade) ou \`timeline\` (marcos); página densa estilo revista: \`poster\`; jornada+problema+solução+painel: \`onepage\`; status semanal: \`status\`; definição: \`definition\`; citação: \`quote\`; número gigante: \`number\`; KPIs: \`stats\`; A×B: \`compare\`; 2×2: \`matrix\`; pergunta à plateia: \`question\`/\`poll\`; código: \`code\`, guiado: \`codewalk\`; screenshot com foco: \`spotlight\`; API ao vivo: \`api\`; conta/calculadora: \`solution\`/\`calc\`; algoritmo animado: \`algo\`; redes/rotas: \`graphlab\`; código executável pelo aluno: \`codelab\`; experimento: \`playground\`; decisão: \`decisionlab\`; duelo/terminais/turnos: \`duel\`/\`terminals\`/\`turns\`; carrossel: \`carousel\`; funil/pirâmide/agenda: \`funnel\`/\`pyramid\`/\`agenda\`; grade/consulta: \`bento\`/\`mosaic\`/\`ribbon\`/\`dossier\`; caminhos com volta ao mapa: \`hub\`+\`goto\`/\`back\`/\`next\`; manchete: \`headline\`; imagem total: \`full\`/\`image\`. Diagramas simples (\`diagram: loop/flow/venn…\`) e gráficos também existem como ELEMENTOS, dentro de figure/content/side.
 - Temas disponíveis: ${themes}.
 - YAML: coloque entre aspas duplas todo texto que comece com marcação (\`**\`, \`*\`, \`==\`, \`^^\`, \`~~\`, \`[\`) ou que contenha ": ".
 - Em sequências inline ([{...}]): coloque entre aspas todo valor de texto com vírgula ("3,5 peixes por m³"). Sem aspas a vírgula parte o objeto e o dado sai truncado.
@@ -782,7 +782,7 @@ export function applyPatch(base, patch) {
 const STUDIO_KEYS = ["layout", "notes", "time", "id", "uid", "review", "original", "master", "visualEdits", "auto", "fiscalOk", "from", "image_prompt", "image_ref", "density", "deco", "theme", "palette", "tone",
   "bg", "fg", "background", "backgroundStyle", "footer", "header", "transition", "steps", "markStyle", "maxWords", "fit", "titleAs", "context"];
 const FREE_TEXT_KEYS = new Set(["code", "mermaid", "svg", "html", "request", "realtime", "body", "headers", "response", "notes", "consulta", "output", "json"]);
-const PATCH_WORDS = new Set(["slides", "insert", "delete", "edit", "deck", "variants", "test", "ver"]);
+const PATCH_WORDS = new Set(["slides", "insert", "delete", "edit", "deck", "variants", "test", "ver", "mapa"]);
 let knownKeysCache = null;
 function knownSlideKeys() {
   if (knownKeysCache) return knownKeysCache;
@@ -925,6 +925,13 @@ function parseEditText(text, base) {
   const raw = parseYaml(yaml);
   if (!raw || typeof raw !== "object") throw new Error("O bloco yaml precisa ser um objeto com deck/slides/insert/delete (ou variants).");
   if (raw.variants) return parseVariants(raw.variants, base, prose);
+  // mapa: [ações] → a IA precisa de dados geográficos (lugares, linhas, contornos, web, coordenadas); quem busca é o
+  // Studio (src/ai/map-data.js), que chama de novo com o que gravou
+  if (raw.mapa) {
+    const acoes = [].concat(raw.mapa?.acoes || raw.mapa).filter((a) => a && typeof a === "object" && a.tipo);
+    if (!acoes.length) throw new Error("mapa: mande a lista de ações (tipo: lugares | linhas | contorno | web | coordenadas).");
+    return { spec: base, prose, changed: [], geo: acoes.slice(0, 4) };
+  }
   // ver: [arquivos] → a IA quer OLHAR o material (recorte, página inteira) antes de responder; quem mostra é o Studio
   if (raw.ver || raw.look) {
     const files = [].concat(raw.ver || raw.look).map((f) => String(f || "").trim()).filter(Boolean);
@@ -974,7 +981,7 @@ function commandEnvNames(apiContext) {
 
 // Chat lateral do Studio: aplica um pedido em linguagem natural ao deck.
 export async function editDeck({ spec, instruction, targetSlide = null, issues = [], images = false, imageOptions = {}, history = [], onProgress,
-  visuals = [], renderNotes = [], apiContext = null, drawCheck = null, runCommand = null, materials = [], deferImages = false, maxImages, styles = null, signal, reviewCheck = null, reviewDepth = 0, repairSlides = null }) {
+  visuals = [], renderNotes = [], apiContext = null, drawCheck = null, runCommand = null, materials = [], deferImages = false, maxImages, styles = null, signal, reviewCheck = null, reviewDepth = 0, repairSlides = null, mapData = null }) {
   const deck = promptSpec(spec);
   const { slides: _slides, ...numbered } = deck;
   const slidesYaml = deck.slides.map((s, i) => `# ── slide ${i + 1} ──\n${YAML.stringify([s], { indent: 2 })}`).join("");
@@ -1012,7 +1019,7 @@ Antes de responder, verifique (e siga as Regras de edição):
     : text;
   const convo = conversationFor(history);
   const messages = [
-    { role: "system", content: `${systemPrompt({ images, ...(maxImages ? { maxImages } : {}) })}\n\n${AUTOMATION_NOTES}\n\n${EDIT_RULES}\n\n${CONVERSATION_RULES}\n\n${PATCH_FORMAT}\n\n${VARIANTS_FORMAT}\n\n${API_RULES}\n\n${runCommand ? runCommand.description || `${COMMAND_RULES}\n${VIDEO_COMMAND_RULES}${commandEnvNames(apiContext)}` : "Comandos: indisponíveis aqui (só no Studio local, com a apresentação salva na biblioteca). Não peça run:."}` },
+    { role: "system", content: `${systemPrompt({ images, ...(maxImages ? { maxImages } : {}) })}\n\n${AUTOMATION_NOTES}\n\n${EDIT_RULES}\n\n${CONVERSATION_RULES}\n\n${PATCH_FORMAT}\n\n${VARIANTS_FORMAT}\n\n${API_RULES}\n\n${runCommand ? runCommand.description || `${COMMAND_RULES}\n${VIDEO_COMMAND_RULES}${commandEnvNames(apiContext)}` : "Comandos: indisponíveis aqui (só no Studio local, com a apresentação salva na biblioteca). Não peça run:."}${mapData ? `\n\n${mapData}` : ""}` },
     // a conversa deste deck: o que a pessoa disse lá atrás (compactado) + as últimas trocas inteiras
     ...(convo.memory ? [{ role: "user", content: convo.memory }, { role: "assistant", content: "Certo, levo isso em conta." }] : []),
     ...convo.recent,
@@ -1020,7 +1027,7 @@ Antes de responder, verifique (e siga as Regras de edição):
   ];
   let motifObjected = false;
   const drawWarned = new Set();
-  const { spec: edited, prose, attempts, changed = [], talk, options = [], variants, imagesDropped, visionRouted, test = [], commands = [], transform, style, review, look } =
+  const { spec: edited, prose, attempts, changed = [], talk, options = [], variants, imagesDropped, visionRouted, test = [], commands = [], transform, style, review, look, geo } =
     await askUntilValid(messages, async (t) => {
       const parsed = parseEditText(t, spec);
       if (repairSlides && (parsed.spec.slides.length !== spec.slides.length || parsed.changed?.some(i => !repairSlides.includes(i)))) throw new Error('A revisão só pode corrigir os slides indicados, sem inserir, excluir ou alterar outros slides.');
@@ -1043,6 +1050,8 @@ Antes de responder, verifique (e siga as Regras de edição):
   if (transform) return { reply: prose || "Vou transformar a apresentação.", spec, actions, targetSlide, transform };
   // quer ver o material antes de responder: o Studio mostra as imagens e chama de novo (src/studio/ai-chat-route.js)
   if (look) return { reply: prose || "Vou olhar o material.", spec, actions, targetSlide, look };
+  // precisa de dados para o mapa: o Studio busca e chama de novo (src/studio/ai-chat-route.js)
+  if (geo) return { reply: prose || "Vou buscar os dados para o mapa.", spec, actions, targetSlide, geo };
   // estilo (Brand Kit): quem aplica/salva é o servidor, com a biblioteca
   if (style) return { reply: prose || "Certo.", spec, actions, targetSlide, style };
   // versões para escolher: nada muda até a pessoa escolher uma

package/src/ai/ia-check.js

@@ -0,0 +1,127 @@
+// Diagnóstico da IA configurada, sem tela: cada recurso (texto, visão, imagem, pesquisa, vídeo) com uma chamada de
+// verdade ao provedor, todos ao mesmo tempo, cada resultado avisado assim que chega. Para quem configura e para agentes
+// (Copilot, Claude) saberem em segundos o que funciona, sem abrir o Studio. `sagadeck ia-check`, a ferramenta
+// sagadeck_ia_check do MCP e POST /api/ia/check usam esta mesma função.
+//
+// Vídeo: por padrão só confere a chave e o modelo no catálogo, sem custo; com videoReal: true gera um clipe curto de
+// verdade, baixa e confere que é um MP4 (é o único jeito de provar; nem todo provedor tem catálogo).
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import zlib from "node:zlib";
+import { chat, generateImage, llmConfig, llmConfigured } from "./llm.js";
+import { videoOperation, videoCatalog, videoSetup } from "./video-generation.js";
+
+export const CHECKS = { texto: "Texto", visao: "Visão", imagem: "Geração de imagem", pesquisa: "Pesquisa na web", video: "Geração de vídeo" };
+// prazo de cada um (s): um modelo travado não segura os outros
+const PRAZO = { texto: 30, visao: 45, imagem: 120, pesquisa: 60 };
+
+// ---- a imagem do teste de visão: duas faixas de cor, desenhada aqui mesmo (PNG mínimo, sem navegador)
+const CORES = { vermelho: [229, 57, 53], azul: [30, 99, 233], verde: [46, 158, 68], amarelo: [245, 197, 24] };
+const SINONIMOS = { vermelho: /vermelh|\bred\b/, azul: /\bazul|\bblue\b/, verde: /\bverde|\bgreen\b/, amarelo: /amarel|\byellow\b/ };
+export function twoColorPNG(left, right, w = 96, h = 48) {
+  const row = Buffer.alloc(1 + w * 3);
+  for (let x = 0; x < w; x++) row.set(CORES[x < w / 2 ? left : right], 1 + x * 3);
+  const chunk = (type, data) => {
+    const body = Buffer.concat([Buffer.from(type, "ascii"), data]);
+    const len = Buffer.alloc(4); len.writeUInt32BE(data.length);
+    const crc = Buffer.alloc(4); crc.writeUInt32BE(zlib.crc32(body));
+    return Buffer.concat([len, body, crc]);
+  };
+  const ihdr = Buffer.alloc(13); ihdr.writeUInt32BE(w, 0); ihdr.writeUInt32BE(h, 4); ihdr[8] = 8; ihdr[9] = 2;
+  return Buffer.concat([Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]), chunk("IHDR", ihdr),
+    chunk("IDAT", zlib.deflateSync(Buffer.concat(Array.from({ length: h }, () => row)))), chunk("IEND", Buffer.alloc(0))]);
+}
+// as duas cores: sorteadas (um palpite certo por acaso é improvável) ou fixas pelo seed (testes)
+export function colorsFor(seed) {
+  const nomes = Object.keys(CORES), i = seed == null ? Math.floor(Math.random() * 12) : Number(seed) % 12;
+  const a = Math.floor(i / 3), b = (a + 1 + (i % 3)) % 4;
+  return [nomes[a], nomes[b]];
+}
+const IMG_MAGIC = [["image/png", "89504e47"], ["image/jpeg", "ffd8ff"], ["image/webp", "52494646"], ["image/gif", "47494638"]];
+const today = (offsetH = -3) => new Date(Date.now() + offsetH * 3600_000).toISOString().slice(0, 10);
+const quick = (cfg, s) => ({ ...cfg, timeoutMs: s * 1000, firstTimeoutMs: s * 1000 });
+const ask = (cfg, model, content, s) => chat([{ role: "user", content }], { cfg: quick(cfg, s), model, think: false, temperature: 0, maxTokens: 80, allowTruncated: true, retries: 0 });
+const said = (t) => `respondeu "${String(t || "").trim().replace(/\s+/g, " ").slice(0, 80)}"`;
+
+const RUN = {
+  async texto({ cfg }) {
+    const r = await ask(cfg, cfg.textModel, "Responda só com a palavra: pronto", PRAZO.texto);
+    return /pronto/i.test(r.text) ? { status: "ok", modelo: cfg.textModel, detalhe: said(r.text) } : { status: "falhou", modelo: cfg.textModel, detalhe: `${said(r.text)} (esperado: pronto)` };
+  },
+  async visao({ cfg, seed }) {
+    const [esq, dir] = colorsFor(seed);
+    const url = `data:image/png;base64,${twoColorPNG(esq, dir).toString("base64")}`;
+    const r = await ask(cfg, cfg.visionModel, [{ type: "text", text: "A imagem tem duas faixas verticais de cor. Quais são as cores, da esquerda para a direita? Responda só as duas cores, em português, separadas por vírgula." }, { type: "image_url", image_url: { url } }], PRAZO.visao);
+    const modelo = r.visionRouted || cfg.visionModel;
+    if (r.imagesDropped) return { status: "falhou", modelo, detalhe: "o modelo não aceitou a imagem: respondeu sem vê-la. Escolha em Configurar IA um modelo de visão que aceite imagem." };
+    const t = String(r.text || "").toLowerCase(), m = (c) => t.search(SINONIMOS[c]);
+    const ok = m(esq) >= 0 && m(dir) >= 0 && m(esq) < m(dir);
+    return { status: ok ? "ok" : "falhou", modelo, detalhe: `${said(r.text)}${ok ? "" : ` (a imagem era ${esq}, ${dir})`}` };
+  },
+  async imagem({ cfg, outDir }) {
+    const img = await Promise.race([generateImage("a single red circle centered on a plain white background, flat, minimal", { cfg: quick(cfg, PRAZO.imagem) }),
+      new Promise((_, no) => setTimeout(() => no(new Error(`passou de ${PRAZO.imagem} s sem devolver a imagem`)), PRAZO.imagem * 1000).unref())]);
+    const hex = img.data.subarray(0, 4).toString("hex"), tipo = IMG_MAGIC.find(([, m]) => hex.startsWith(m))?.[0];
+    if (!tipo || img.data.length < 60) return { status: "falhou", modelo: cfg.imageModel, detalhe: `o que voltou não é uma imagem (${img.data.length} bytes)` };
+    const arquivo = path.join(outDir(), `imagem${tipo === "image/jpeg" ? ".jpg" : "." + tipo.split("/")[1]}`);
+    fs.writeFileSync(arquivo, img.data);
+    return { status: "ok", modelo: cfg.imageModel, detalhe: `${tipo}, ${Math.round(img.data.length / 1024)} KB`, arquivo };
+  },
+  async pesquisa({ cfg }) {
+    if (!cfg.searchModel) return { status: "nao_configurado", detalhe: "sem modelo de pesquisa (opcional: sem ele, a pesquisa usa os buscadores diretos)" };
+    const r = await ask(cfg, cfg.searchModel, "Pesquise na web: qual é a data de hoje no horário de Brasília? Responda só no formato AAAA-MM-DD.", PRAZO.pesquisa);
+    const d = String(r.text || "").match(/(\d{4})-(\d{2})-(\d{2})/)?.[0];
+    const dias = d ? Math.abs(Date.parse(d) - Date.parse(today())) / 86400_000 : Infinity;
+    return dias <= 1 ? { status: "ok", modelo: cfg.searchModel, detalhe: said(r.text) }
+      : { status: "falhou", modelo: cfg.searchModel, detalhe: `${said(r.text)}; hoje é ${today()} (não parece ter pesquisado)` };
+  },
+  // o mesmo caminho do produto (videoSetup): o modelo de vídeo do Configurar IA, com a chave e o adaptador de lá, ou as
+  // variáveis SAGADECK_VIDEO_KEY / OPENROUTER_API_KEY para quem já usava assim
+  async video({ cfg, env, fetcher, videoReal, videoTimeoutS, videoPollMs, outDir }) {
+    const setup = videoSetup({ env, cfg }), modelo = setup.model, de = ` (via ${setup.origem})`;
+    if (!setup.key && !setup.adaptador) return { status: "nao_configurado", modelo, detalhe: "ponha um modelo de vídeo em Configurar IA (usa a chave de lá) ou defina SAGADECK_VIDEO_KEY / OPENROUTER_API_KEY" };
+    const net = { setup, ...(fetcher !== fetch ? { fetcher } : {}) };
+    if (!videoReal) {
+      const cat = await videoCatalog(net);
+      if (!cat.ok) return { status: "sem_prova", modelo, detalhe: `${cat.motivo}; só o teste real prova: --video-real${de}` };
+      const meta = cat.models.find((m) => m.id === modelo || m.canonical_slug === modelo);
+      return meta ? { status: "sem_prova", modelo, detalhe: `o modelo está no catálogo, mas a chave e a geração só se provam gerando: --video-real (é cobrado)${de}` }
+        : { status: "falhou", modelo, detalhe: `o modelo não está no catálogo do provedor (${cat.models.length} modelos)` };
+    }
+    const cwd = outDir();
+    const sub = await videoOperation({ action: "submit", model: modelo, prompt: "a small red ball rolling slowly across a plain white table", duration: "min", resolution: "min", out: "video.mp4" }, { cwd, ...net });
+    const limite = Date.now() + videoTimeoutS * 1000;
+    let st = { status: sub.status };
+    while (!["completed", "failed", "error", "cancelled"].includes(st.status)) {
+      if (Date.now() > limite) return { status: "falhou", modelo, detalhe: `o clipe não ficou pronto em ${videoTimeoutS} s (job ${sub.id}, último estado: ${st.status || "?"})` };
+      await new Promise((r) => setTimeout(r, videoPollMs));
+      st = await videoOperation({ action: "status", id: sub.id }, { cwd, ...net });
+    }
+    if (st.status !== "completed") return { status: "falhou", modelo, detalhe: `o provedor encerrou com ${st.status}${st.error ? `: ${typeof st.error === "string" ? st.error : JSON.stringify(st.error)}` : ""}` };
+    const dl = await videoOperation({ action: "download", id: sub.id }, { cwd, ...net });
+    return { status: "ok", modelo, detalhe: `MP4 de ${Math.round(dl.bytes / 1024)} KB${dl.cost != null ? `, custou $${Number(dl.cost).toFixed(2)}` : ""}${de}`, arquivo: path.join(cwd, dl.video) };
+  },
+};
+
+const NEEDS_LLM = new Set(["texto", "visao", "imagem", "pesquisa"]);
+// only: lista de ids (padrão: todos); rapido: sem imagem e vídeo (os lentos e cobrados); videoReal: gera um clipe
+export async function iaCheck({ only, rapido = false, videoReal = false, videoTimeoutS = 600, videoPollMs = 5000, cfg = llmConfig(), env = process.env, fetcher = fetch, seed, outDir, onResult = () => {} } = {}) {
+  const ids = (only?.length ? only : Object.keys(CHECKS)).filter((id) => CHECKS[id] && !(rapido && (id === "imagem" || id === "video")));
+  let dir = outDir;
+  const out = () => (dir ||= fs.mkdtempSync(path.join(os.tmpdir(), "sagadeck-ia-check-")));
+  const t0 = Date.now();
+  const resultados = await Promise.all(ids.map(async (id) => {
+    const start = Date.now();
+    let r;
+    if (NEEDS_LLM.has(id) && !llmConfigured(cfg)) r = { status: "nao_configurado", detalhe: cfg.problem || "a IA não está configurada (Configurar IA, no Studio, ou ~/.sagadeck/ia.json)" };
+    else {
+      try { r = await RUN[id]({ cfg, env, fetcher, seed, videoReal, videoTimeoutS, videoPollMs, outDir: out }); }
+      catch (e) { r = { status: "falhou", detalhe: e?.message || String(e) }; }
+    }
+    const res = { id, nome: CHECKS[id], ms: Date.now() - start, ...r };
+    onResult(res);
+    return res;
+  }));
+  return { ok: resultados.every((r) => r.status !== "falhou"), ms: Date.now() - t0, provedor: cfg.url || cfg.adaptador || "", resultados };
+}

package/src/ai/ia-config.js

@@ -17,10 +17,10 @@ export const PROVIDERS = {
 // responde, o problema é o ambiente (rede, chave), não o modelo escolhido. Depois, cada um põe o modelo que quiser.
 export const RECOMMENDED = {
   provider: "openrouter",
-  models: { text: "deepseek/deepseek-v4.1-flash", vision: "deepseek/deepseek-v4.1-flash", image: "google/gemini-3.1-flash-image", search: "deepseek/deepseek-v4.1-flash:online" },
+  models: { text: "deepseek/deepseek-v4.1-flash", vision: "deepseek/deepseek-v4.1-flash", image: "google/gemini-3.1-flash-image", search: "deepseek/deepseek-v4.1-flash:online", video: "google/veo-3.1-lite" },
 };
 // os papéis que o sagadeck usa; cada um aponta para um modelo do provedor
-export const ROLES = ["text", "vision", "image", "search"];
+export const ROLES = ["text", "vision", "image", "search", "video"];
 
 export function iaFile(env = process.env, home = os.homedir()) {
   return env.SAGADECK_IA || path.join(home, ".sagadeck", "ia.json");

package/src/ai/llm.js

@@ -48,6 +48,8 @@ export function llmConfig(env = process.env) {
     visionModel: env.SAGADECK_VISION_MODEL || m.vision || m.text || "vision",
     // busca na web pelo modelo (no OpenRouter, um modelo ":online"); sem ele, a pesquisa usa os buscadores diretos
     searchModel: env.SAGADECK_SEARCH_MODEL || m.search || (fromEnv ? "search" : ""),
+    // vídeo (opcional): com ele, a geração de vídeo usa esta mesma camada (src/ai/video-generation.js, videoSetup)
+    videoModel: env.SAGADECK_VIDEO_MODEL || m.video || "",
     headers: ia?.headers || {},
     adaptador: ia?.adaptador || "",
     source: fromEnv ? "variável" : ia ? "arquivo" : "nenhuma",
@@ -61,7 +63,7 @@ export const llmConfigured = (cfg = llmConfig()) => !!(cfg.url || cfg.adaptador)
 
 // o papel (text, vision, image, search) vira o modelo configurado; outro nome passa como veio
 export function resolveModel(cfg, name) {
-  const roles = { text: cfg.textModel, vision: cfg.visionModel, image: cfg.imageModel, search: cfg.searchModel };
+  const roles = { text: cfg.textModel, vision: cfg.visionModel, image: cfg.imageModel, search: cfg.searchModel, video: cfg.videoModel };
   return roles[name] || name;
 }
 
@@ -74,6 +76,8 @@ function headers(cfg) {
 // Adaptador (opcional, da pessoa): um .mjs cujo default é (url, init) => Response. Serve para o que não é compatível
 // com a API da OpenAI (outro jeito de autenticar, outro endereço) sem mexer no sagadeck. Sem ele, o fetch normal.
 const adapters = new Map();
+// (exportado: a geração de vídeo manda pelo mesmo caminho, com o mesmo adaptador)
+export const providerFetch = (cfg, url, init) => send(cfg, url, init);
 async function send(cfg, url, init) {
   if (!cfg.adaptador) return fetch(url, init);
   if (!adapters.has(cfg.adaptador)) adapters.set(cfg.adaptador, import(pathToFileURL(path.resolve(cfg.adaptador)).href).then((mod) => mod.default));

package/src/ai/map-analysis-run.js

@@ -0,0 +1,119 @@
+// Análises do mapa pedidas pela IA no bloco `mapa:` (entrega 5): o código calcula, grava o resultado no projeto e
+// devolve números para a IA narrar. mais_proximo, contar (em raio ou em área), faixa em volta de uma linha, sugerir
+// onde instalar, rota com tempo, área alcançável e encaixar um rastro de GPS nas ruas. Lê as camadas do projeto (CSV
+// de pontos, GeoJSON, GPX, KML). Quem chama é runMapData (src/ai/map-data.js), que já cuidou do serviço bloqueado.
+import fs from "node:fs";
+import * as Project from "../studio/project.js";
+import { parseCSV } from "../csv.js";
+import { pointsFromRows, fromGPX, fromKML } from "../map.js";
+import { geocodeOne } from "../map-services.js";
+import { nearest, withinRadius, inPolygon, pointLine, circle, lineBuffer, suggestSites, fmtMetros } from "../map-analysis.js";
+import { route, isochrone, matchTrace, MODOS } from "../map-routing.js";
+
+export const ANALYSES = new Set(["mais_proximo", "contar", "faixa", "sugerir", "rota", "alcance", "encaixar"]);
+
+const okFile = (f, ext) => typeof f === "string" && /^contexto\/[\w\-. /]+$/.test(f) && f.toLowerCase().endsWith(ext) && !f.includes("..");
+const nameOf = (props, i) => props?.nome || props?.name || props?.titulo || `item ${i + 1}`;
+const fc = (features) => JSON.stringify({ type: "FeatureCollection", features });
+
+async function readPoints(P, file) {
+  const { rows } = parseCSV(fs.readFileSync(Project.resolveIn(P, file), "utf8"));
+  const head = (rows[0] || []).map((h) => String(h).trim());
+  return pointsFromRows(head, rows.slice(1)).features.map((f) => ({ lat: f.geometry.coordinates[1], lon: f.geometry.coordinates[0], props: f.properties }));
+}
+function readShapes(P, file) {
+  const text = fs.readFileSync(Project.resolveIn(P, file), "utf8");
+  if (/\.gpx$/i.test(file)) return fromGPX(text);
+  if (/\.kml$/i.test(file)) return fromKML(text);
+  const j = JSON.parse(text);
+  return j.type === "FeatureCollection" ? j.features : j.type === "Feature" ? [j] : [{ type: "Feature", properties: {}, geometry: j }];
+}
+async function placeOf(x, cfg) {
+  if (Array.isArray(x) && x.length === 2) return [Number(x[0]), Number(x[1])];
+  const hit = await geocodeOne(String(x), { cfg });
+  if (!hit) throw new Error(`não achei "${x}" no mapa`);
+  return [hit.lat, hit.lon];
+}
+
+export async function runAnalysis(a, { P, cfg, onProgress = () => {} }) {
+  if (a.tipo === "mais_proximo") {
+    const A = await readPoints(P, a.de), B = await readPoints(P, a.ate);
+    if (!A.length || !B.length) throw new Error("as planilhas precisam de pontos com posição");
+    const res = nearest(A.map((p) => [p.lat, p.lon]), B.map((p) => [p.lat, p.lon]));
+    const arquivo = okFile(a.arquivo, ".csv") ? a.arquivo : `${a.de.replace(/\.csv$/i, "")}-mais-proximo.csv`;
+    const cols = Object.keys(A[0].props).filter((c) => !c.startsWith("_"));
+    const rows = [[...cols, "latitude", "longitude", "mais_proximo", "distancia_m"],
+      ...A.map((p, i) => [...cols.map((c) => p.props[c] ?? ""), String(p.lat), String(p.lon), nameOf(B[res[i].j]?.props, res[i].j), String(Math.round(res[i].metros))])];
+    Project.writeSheet(P, arquivo, rows);
+    const media = res.reduce((s, r) => s + r.metros, 0) / res.length, far = res.reduce((m, r) => (r.metros > m.metros ? r : m), res[0]);
+    return { tipo: a.tipo, arquivo, linhas: A.length, oque: `distância de cada item de ${a.de} até o mais próximo de ${a.ate}: média ${fmtMetros(media)}, maior ${fmtMetros(far.metros)} (${nameOf(A[far.i].props, far.i)} até ${nameOf(B[far.j].props, far.j)})` };
+  }
+  if (a.tipo === "contar") {
+    const pts = await readPoints(P, a.pontos);
+    if (a.area) {
+      const areas = readShapes(P, a.area).filter((f) => /Polygon/.test(f.geometry?.type || ""));
+      const counts = areas.map((f, k) => ({ nome: nameOf(f.properties, k), n: pts.filter((p) => inPolygon([p.lat, p.lon], f.geometry)).length }));
+      return { tipo: a.tipo, arquivo: a.area, linhas: counts.length, oque: `pontos de ${a.pontos} dentro de cada área: ${counts.map((c) => `${c.nome}: ${c.n}`).join("; ")}` };
+    }
+    const centro = await placeOf(a.centro, cfg), metros = Number(a.metros) || 1000;
+    const dentro = withinRadius(pts.map((p) => [p.lat, p.lon]), centro, metros);
+    const arquivo = okFile(a.arquivo, ".geojson") ? a.arquivo : `contexto/raio-${Math.round(metros)}m.geojson`;
+    Project.writeText(P, arquivo, fc([{ type: "Feature", properties: { nome: `raio de ${fmtMetros(metros)}`, dentro: dentro.length }, geometry: circle(centro, metros) }]));
+    const nomes = dentro.slice(0, 8).map((i) => nameOf(pts[i].props, i)).join(", ");
+    return { tipo: a.tipo, arquivo, linhas: dentro.length, oque: `${dentro.length} de ${pts.length} pontos de ${a.pontos} ficam a até ${fmtMetros(metros)}${nomes ? ` (${nomes}${dentro.length > 8 ? "…" : ""})` : ""}; o círculo foi gravado` };
+  }
+  if (a.tipo === "faixa") {
+    const metros = Number(a.metros) || 50;
+    const lines = readShapes(P, a.linha).filter((f) => /LineString/.test(f.geometry?.type || ""));
+    if (!lines.length) throw new Error(`${a.linha} não tem linhas`);
+    const arquivo = okFile(a.arquivo, ".geojson") ? a.arquivo : `${a.linha.replace(/\.[^.]+$/, "")}-faixa-${Math.round(metros)}m.geojson`;
+    Project.writeText(P, arquivo, fc(lines.map((f, k) => ({ type: "Feature", properties: { nome: `${nameOf(f.properties, k)} (faixa de ${fmtMetros(metros)})`, _faixa: true }, geometry: lineBuffer(f.geometry, metros) }))));
+    let extra = "";
+    if (a.pontos) {
+      const pts = await readPoints(P, a.pontos);
+      const perto = pts.filter((p) => lines.some((f) => pointLine([p.lat, p.lon], f.geometry) <= metros));
+      extra = `; ${perto.length} de ${pts.length} pontos de ${a.pontos} ficam a até ${fmtMetros(metros)} da linha${perto.length ? ` (${perto.slice(0, 8).map((p, i) => nameOf(p.props, i)).join(", ")}${perto.length > 8 ? "…" : ""})` : ""}`;
+    }
+    return { tipo: a.tipo, arquivo, linhas: lines.length, oque: `faixa de ${fmtMetros(metros)} em volta de ${a.linha}${extra}` };
+  }
+  if (a.tipo === "sugerir") {
+    const pts = await readPoints(P, a.existentes);
+    const area = a.area ? readShapes(P, a.area).find((f) => /Polygon/.test(f.geometry?.type || ""))?.geometry : null;
+    const sug = suggestSites(pts.map((p) => [p.lat, p.lon]), { area, quantos: Math.min(Number(a.quantos) || 3, 10) });
+    const arquivo = okFile(a.arquivo, ".csv") ? a.arquivo : "contexto/sugestoes.csv";
+    Project.writeSheet(P, arquivo, [["nome", "latitude", "longitude", "distancia_m"], ...sug.map((s, k) => [`Sugestão ${k + 1}`, s.lat.toFixed(6), s.lon.toFixed(6), String(Math.round(s.metros ?? 0))])]);
+    return { tipo: a.tipo, arquivo, linhas: sug.length, oque: `lugares mais longe dos existentes em ${a.existentes}${a.area ? ` dentro de ${a.area}` : ""}: ${sug.map((s, k) => `Sugestão ${k + 1} a ${fmtMetros(s.metros)} do mais próximo`).join("; ")} (sugestão geométrica: confira acesso, terreno e regras antes)` };
+  }
+  if (a.tipo === "rota") {
+    onProgress("calculando a rota…");
+    const de = await placeOf(a.de, cfg), para = await placeOf(a.para, cfg);
+    const r = await route([de, para], { modo: a.modo, cfg });
+    const arquivo = okFile(a.arquivo, ".geojson") ? a.arquivo : "contexto/rota.geojson";
+    Project.writeText(P, arquivo, fc([{ type: "Feature", properties: { nome: `${typeof a.de === "string" ? a.de : "origem"} até ${typeof a.para === "string" ? a.para : "destino"}`, distancia_m: Math.round(r.distancia), minutos: Math.round(r.duracao / 60), modo: MODOS[r.modo] }, geometry: { type: "LineString", coordinates: r.coords } }]));
+    return { tipo: a.tipo, arquivo, linhas: 1, oque: `rota ${MODOS[r.modo]}: ${fmtMetros(r.distancia)}, cerca de ${Math.round(r.duracao / 60)} min` };
+  }
+  if (a.tipo === "alcance") {
+    onProgress("calculando a área alcançável…");
+    const minutos = Math.min(Math.max(Number(a.minutos) || 10, 1), 60);
+    const origens = typeof a.de === "string" && /\.csv$/i.test(a.de)
+      ? (await readPoints(P, a.de)).slice(0, 8).map((p, i) => ({ at: [p.lat, p.lon], nome: nameOf(p.props, i) }))
+      : [{ at: await placeOf(a.de, cfg), nome: String(a.de) }];
+    const feats = [];
+    for (const o of origens) feats.push({ type: "Feature", properties: { nome: `${o.nome}: ${minutos} min ${MODOS[a.modo] || "a pé"}` }, geometry: await isochrone(o.at, minutos, { modo: a.modo, cfg }) });
+    const arquivo = okFile(a.arquivo, ".geojson") ? a.arquivo : `contexto/alcance-${minutos}min.geojson`;
+    Project.writeText(P, arquivo, fc(feats));
+    return { tipo: a.tipo, arquivo, linhas: feats.length, oque: `área alcançável em ${minutos} min ${MODOS[a.modo] || "a pé"} a partir de ${origens.length} ${origens.length === 1 ? "ponto" : "pontos"}` };
+  }
+  if (a.tipo === "encaixar") {
+    onProgress("encaixando o rastro nas ruas…");
+    const f = readShapes(P, a.trilha).find((x) => /LineString/.test(x.geometry?.type || ""));
+    if (!f) throw new Error(`${a.trilha} não tem um rastro (linha)`);
+    const coords = f.geometry.type === "LineString" ? f.geometry.coordinates : f.geometry.coordinates.flat();
+    const step = Math.max(1, Math.ceil(coords.length / 100)); // o serviço aceita até 100 pontos: amostra o rastro
+    const out = await matchTrace(coords.filter((_, i) => i % step === 0).map(([lon, lat]) => [lat, lon]), { modo: a.modo, cfg });
+    const arquivo = okFile(a.arquivo, ".geojson") ? a.arquivo : `${a.trilha.replace(/\.[^.]+$/, "")}-nas-ruas.geojson`;
+    Project.writeText(P, arquivo, fc([{ type: "Feature", properties: { nome: `${nameOf(f.properties, 0)} (nas ruas)` }, geometry: { type: "LineString", coordinates: out } }]));
+    return { tipo: a.tipo, arquivo, linhas: 1, oque: `rastro de ${a.trilha} encaixado nas ruas (${out.length} pontos)` };
+  }
+  throw new Error(`análise desconhecida: ${a.tipo}`);
+}

package/src/ai/map-data.js

@@ -0,0 +1,221 @@
+// A IA busca dados geográficos para o mapa (entrega 4), no mesmo molde do "ver o material": a IA que edita o deck,
+// quando precisa de dados de fora, responde um bloco `mapa:` com as ações (lugares do OpenStreetMap, linhas, contornos,
+// uma tabela da web, coordenadas de uma planilha da pessoa). O código executa, grava planilha ou GeoJSON no projeto
+// com a FONTE de cada linha e chama a IA de novo com o que gravou; ela monta o slide. Regras:
+//  - a decisão é do modelo (prompt), com o estado de cada serviço à vista; o código recusa, sem pedido de rede, o
+//    serviço bloqueado nesta execução (uma tentativa e para);
+//  - dados da pessoa (endereços de uma planilha dela) só saem com o sim dela: sem confirmação na conversa, o código
+//    não envia e a resposta pergunta (quantos, para qual serviço, quanto tempo);
+//  - geometria nunca inventada: vem do OpenStreetMap, da web com fonte, ou dos arquivos.
+import fs from "node:fs";
+import path from "node:path";
+import { loadMapConfig, mapaFile } from "../map-config.js";
+import { callService, serviceState, geocodeOne, geocodeInterval, ServiceBlocked, SERVICES } from "../map-services.js";
+import * as Project from "../studio/project.js";
+import { addressPlan } from "../studio/geo-routes.js";
+import { chat } from "./llm.js";
+import { jsonOf, runResearch, defaultWeb } from "../research/research.js";
+import { runAnalysis } from "./map-analysis-run.js";
+
+// tabela da web: a pesquisa que já existe (busca, lê, anota com a URL) e uma extração que só usa o que leu
+export async function webResearchDefault(pergunta, { saveDir = null } = {}) {
+  const r = await runResearch({ pesquisar: true, motivo: pergunta, buscas: [pergunta], academico: false }, { briefing: pergunta, web: defaultWeb, saveDir, maxSources: 5 });
+  return r.materials;
+}
+export async function extractTableDefault(pergunta, cols, docs) {
+  if (!docs.length) return [];
+  const fontes = docs.map((d) => `${d.name}\n${d.detail || ""}\n${clip(d.text, 6000)}`).join("\n\n---\n\n");
+  const r = await chat([{ role: "user", content: `Monte a tabela pedida SÓ com o que está nas fontes abaixo. Pedido: ${pergunta}
+Colunas: ${cols.join(", ")}. Cada linha leva também "fonte": a URL da fonte de onde ela saiu (está no detalhe de cada fonte).
+Não invente linhas, nomes nem endereços; o que a fonte não diz fica vazio. Responda só JSON: {"linhas": [{${cols.map((c) => `"${c}": "…"`).join(", ")}, "fonte": "https://…"}]}
+
+Fontes:
+${fontes}` }], { maxTokens: 6000, think: false, allowTruncated: true, retries: 0 });
+  const j = jsonOf(r.text) || {};
+  return (Array.isArray(j.linhas) ? j.linhas : []).filter((x) => x && typeof x === "object");
+}
+
+const clip = (s, n) => (String(s ?? "").length > n ? `${String(s).slice(0, n)}…` : String(s ?? ""));
+const slug = (s) => String(s || "dados").normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40) || "dados";
+const okFile = (f, ext) => typeof f === "string" && /^contexto\/[\w\-. /]+$/.test(f) && f.toLowerCase().endsWith(ext) && !f.includes("..");
+
+const stateLine = (st) => Object.entries(st).map(([k, v]) => `- ${SERVICES[k]}: ${v.status === "bloqueado" ? `BLOQUEADO nesta rede (${v.motivo}); não peça` : v.status === "ok" ? "funcionando" : "ainda não usado (deve funcionar)"}`).join("\n");
+
+// ---- 1. o que a IA principal sabe (vai no prompt de src/ai/deck-ai.js quando há projeto) --------------------------
+// Quem decide é a IA que edita o deck: quando precisa de dados geográficos, ela responde um bloco `mapa:` com as
+// ações (como o `ver:` do material); o Studio executa (runMapData) e chama de novo com o resultado. Sem pedido de
+// mapa, nenhuma chamada a mais.
+export function mapDataPrompt() {
+  return `DADOS PARA O MAPA (slide layout: map): quando a pessoa pedir para mostrar no mapa algo que ela NÃO deu (lugares de um
+tipo, linhas como ciclovias ou rios, o contorno de um lugar com nome, uma lista que só existe na web, ou as coordenadas
+dos endereços de uma planilha dela), NÃO invente coordenadas nem geometria: responda uma frase e um bloco yaml só com
+\`\`\`yaml
+mapa:
+  - { tipo: lugares, oque: cinemas, filtro_osm: '["amenity"="cinema"]', perto_de: "Centro, Campinas, SP, Brasil", raio_km: 5, arquivo: contexto/cinemas.csv }
+  - { tipo: linhas, oque: ciclovias, filtro_osm: '["highway"="cycleway"]', perto_de: "…", raio_km: 3, arquivo: contexto/ciclovias.geojson }
+  - { tipo: contorno, nome: "Centro, Campinas, SP, Brasil", arquivo: contexto/centro.geojson }
+  - { tipo: web, pergunta: "unidades do INSS em Pernambuco com endereço", colunas: [nome, endereco, cidade], arquivo: contexto/inss-pe.csv }
+  - { tipo: coordenadas, planilha: contexto/unidades.csv, confirmado: false }
+\`\`\`
+O Studio busca (OpenStreetMap, web), grava os arquivos com a fonte de cada linha e te devolve o que gravou; aí você monta o
+slide com points:/geojson: e a fonte. filtro_osm são as tags do OpenStreetMap do tipo de lugar. Até 4 ações. Dados que já
+estão nas planilhas do projeto com latitude e longitude não precisam de busca.
+ANÁLISES (contas que o Studio faz sobre os arquivos do projeto; você só narra os números que ele devolver, nunca calcule
+distância, contagem ou tempo de cabeça), no mesmo bloco mapa:
+  - { tipo: mais_proximo, de: contexto/pedidos.csv, ate: contexto/lojas.csv }          # cada ponto de "de" com o mais próximo de "ate" e a distância
+  - { tipo: contar, pontos: contexto/sensores.csv, area: contexto/bairros.geojson }    # quantos em cada área (ou centro: [lat, lon] ou "endereço", metros: 500)
+  - { tipo: faixa, linha: contexto/rede.geojson, metros: 50, pontos: contexto/imoveis.csv }  # faixa em volta da linha e quantos pontos dentro
+  - { tipo: sugerir, existentes: contexto/sensores.csv, area: contexto/area.geojson, quantos: 3 }  # onde instalar: os lugares mais longe dos existentes
+  - { tipo: rota, de: "Rua A, 10, Recife", para: [-8.06, -34.9], modo: pe }           # rota pelas ruas com distância e tempo (pe, carro, bicicleta)
+  - { tipo: alcance, de: contexto/unidades.csv, minutos: 10, modo: pe }               # área alcançável em X minutos (precisa do OpenRouteService)
+  - { tipo: encaixar, trilha: contexto/percurso.gpx, modo: carro }                    # rastro de GPS tremido encaixado nas ruas
+Depois, ponha o resultado no slide (a camada gravada e uma frase com o número) e diga a fonte e o limite da conta.
+Mandar endereços de uma planilha DA PESSOA para um serviço de fora (tipo coordenadas) só com o sim explícito dela nesta
+conversa, dado depois de você dizer quantos endereços, para qual serviço e quanto tempo leva; sem esse sim,
+confirmado: false (o Studio pergunta por você). Dados públicos (lugares, contornos, web) não precisam perguntar.
+Serviços do mapa nesta máquina:
+${stateLine(serviceState())}
+Nunca peça um serviço BLOQUEADO: diga à pessoa o que não está disponível e ofereça a alternativa (planilha com
+coordenadas, os contornos embutidos de estados e países, a planilha do projeto).`;
+}
+
+
+// ---- 2. executar -------------------------------------------------------------------------------------------------
+// serviços que cada ação usa (as análises sem rede não usam nenhum; rota com endereço em texto usa o geocoder também)
+const NEEDS = { lugares: ["geocoder", "busca"], linhas: ["geocoder", "busca"], contorno: ["geocoder"], web: ["geocoder"], coordenadas: ["geocoder"],
+  mais_proximo: [], contar: [], faixa: [], sugerir: [], rota: ["rotas"], alcance: ["rotas"], encaixar: ["rotas"] };
+const ANALYSES = new Set(["mais_proximo", "contar", "faixa", "sugerir", "rota", "alcance", "encaixar"]); // src/ai/map-analysis-run.js
+
+async function centerOf(where, cfg) {
+  const hit = await geocodeOne(where, { cfg });
+  if (!hit) throw new Error(`não achei "${where}" no mapa`);
+  return hit;
+}
+
+async function overpass(query, cfg) {
+  const res = await callService("busca", cfg.busca.url, { method: "POST", cfg, headers: { "Content-Type": "application/x-www-form-urlencoded" }, body: `data=${encodeURIComponent(query)}`, timeoutMs: 40000 });
+  return (await res.json()).elements || [];
+}
+
+const tagAddress = (t) => [t["addr:street"] && `${t["addr:street"]}${t["addr:housenumber"] ? `, ${t["addr:housenumber"]}` : ""}`, t["addr:suburb"], t["addr:city"]].filter(Boolean).join(" - ");
+
+export async function runMapData(acoes, { P, cfg = loadMapConfig(mapaFile()), onProgress = () => {}, webResearch = (q) => webResearchDefault(q, { saveDir: P?.dir }), extractTable = extractTableDefault } = {}) {
+  const feitos = [], perguntas = [], falhas = [];
+  Project.ensureMeta(P); // contexto/ existe antes de gravar (writeSheet não cria a pasta)
+  for (const a of acoes) {
+    if (!NEEDS[a.tipo]) { falhas.push(`${a.tipo}: ação desconhecida`); continue; }
+    const blocked = NEEDS[a.tipo].map((s) => serviceState()[s]).find((s) => s.status === "bloqueado");
+    if (blocked) { falhas.push(`${a.tipo}${a.oque || a.nome ? ` (${a.oque || a.nome})` : ""}: serviço bloqueado nesta rede (${blocked.motivo}); não tentei`); continue; }
+    try {
+      if (a.tipo === "lugares" || a.tipo === "linhas") {
+        const arquivo = okFile(a.arquivo, a.tipo === "lugares" ? ".csv" : ".geojson") ? a.arquivo : `contexto/${slug(a.oque)}.${a.tipo === "lugares" ? "csv" : "geojson"}`;
+        const filtro = String(a.filtro_osm || "").replace(/[;(){}]/g, "");
+        if (!/^(\[[^\]]+\])+$/.test(filtro)) throw new Error(`filtro do OpenStreetMap inválido: ${filtro}`);
+        onProgress(`procurando ${a.oque || a.tipo} perto de ${a.perto_de}…`);
+        const c = await centerOf(a.perto_de, cfg);
+        const r = Math.round(Math.min(Math.max(Number(a.raio_km) || 3, 0.2), 30) * 1000);
+        if (a.tipo === "lugares") {
+          const els = await overpass(`[out:json][timeout:30];(node${filtro}(around:${r},${c.lat},${c.lon});way${filtro}(around:${r},${c.lat},${c.lon}););out center tags 300;`, cfg);
+          const rows = [["nome", "endereco", "latitude", "longitude", "fonte"]];
+          for (const e of els) {
+            const lat = e.lat ?? e.center?.lat, lon = e.lon ?? e.center?.lon;
+            if (lat == null || lon == null) continue;
+            rows.push([e.tags?.name || "(sem nome)", tagAddress(e.tags || {}), String(lat), String(lon), `https://www.openstreetmap.org/${e.type}/${e.id}`]);
+          }
+          Project.writeSheet(P, arquivo, rows);
+          feitos.push({ tipo: a.tipo, arquivo, linhas: rows.length - 1, oque: a.oque, perto_de: a.perto_de, fonte: "OpenStreetMap (© colaboradores do OpenStreetMap)" });
+        } else {
+          const els = await overpass(`[out:json][timeout:30];way${filtro}(around:${r},${c.lat},${c.lon});out geom tags 300;`, cfg);
+          const features = els.filter((e) => Array.isArray(e.geometry) && e.geometry.length > 1).map((e) => ({ type: "Feature", properties: { nome: e.tags?.name || "(sem nome)", fonte: `https://www.openstreetmap.org/way/${e.id}` }, geometry: { type: "LineString", coordinates: e.geometry.map((g) => [g.lon, g.lat]) } }));
+          Project.writeText(P, arquivo, JSON.stringify({ type: "FeatureCollection", features }));
+          feitos.push({ tipo: a.tipo, arquivo, linhas: features.length, oque: a.oque, perto_de: a.perto_de, fonte: "OpenStreetMap (© colaboradores do OpenStreetMap)" });
+        }
+      } else if (a.tipo === "contorno") {
+        const arquivo = okFile(a.arquivo, ".geojson") ? a.arquivo : `contexto/${slug(a.nome)}.geojson`;
+        onProgress(`procurando o contorno de ${a.nome}…`);
+        const g = cfg.geocoder;
+        const res = await callService("geocoder", `${g.url.replace(/\/+$/, "")}/search?format=jsonv2&limit=1&polygon_geojson=1&polygon_threshold=0.0005&q=${encodeURIComponent(a.nome)}`, { cfg });
+        const hit = (await res.json())?.[0];
+        if (!hit?.geojson || !/Polygon/.test(hit.geojson.type)) throw new Error(`não achei o contorno de "${a.nome}"`);
+        Project.writeText(P, arquivo, JSON.stringify({ type: "FeatureCollection", features: [{ type: "Feature", properties: { nome: a.nome, fonte: `https://www.openstreetmap.org/${hit.osm_type}/${hit.osm_id}` }, geometry: hit.geojson }] }));
+        feitos.push({ tipo: a.tipo, arquivo, linhas: 1, oque: a.nome, fonte: "OpenStreetMap (© colaboradores do OpenStreetMap)" });
+      } else if (a.tipo === "web") {
+        if (!webResearch || !extractTable) throw new Error("pesquisa na web indisponível");
+        const arquivo = okFile(a.arquivo, ".csv") ? a.arquivo : `contexto/${slug(a.pergunta)}.csv`;
+        onProgress(`pesquisando na web: ${a.pergunta}…`);
+        const docs = await webResearch(a.pergunta);
+        const cols = (Array.isArray(a.colunas) && a.colunas.length ? a.colunas : ["nome", "endereco"]).map(String).slice(0, 8);
+        const table = await extractTable(a.pergunta, cols, docs); // [{…colunas, fonte}]
+        const rows = [[...cols, "latitude", "longitude", "fonte"]];
+        const wait = geocodeInterval(cfg);
+        let last = 0;
+        for (const t of table.slice(0, 200)) {
+          const q = [t.endereco, t.cidade, t.uf].filter(Boolean).join(", ") || t.nome;
+          let hit = null;
+          if (q) { const pause = last + wait - Date.now(); if (pause > 0) await new Promise((r) => setTimeout(r, pause)); last = Date.now(); hit = await geocodeOne(q, { cfg }).catch((e) => { if (e instanceof ServiceBlocked) throw e; return null; }); }
+          rows.push([...cols.map((c) => String(t[c] ?? "")), hit ? String(hit.lat) : "", hit ? String(hit.lon) : "", String(t.fonte || "")]);
+        }
+        Project.writeSheet(P, arquivo, rows);
+        feitos.push({ tipo: a.tipo, arquivo, linhas: rows.length - 1, oque: a.pergunta, fonte: "web (a coluna fonte de cada linha diz de onde veio; revise antes de apresentar)" });
+      } else if (ANALYSES.has(a.tipo)) {
+        feitos.push(await runAnalysis(a, { P, cfg, onProgress }));
+      } else if (a.tipo === "coordenadas") {
+        const abs = Project.resolveIn(P, a.planilha);
+        const sheet = (await Project.readSheet(abs)).sheets[0];
+        const pl = addressPlan(sheet.rows, a.coluna);
+        if (pl.error) throw new Error(pl.error);
+        if (!pl.items.length) { feitos.push({ tipo: a.tipo, arquivo: a.planilha, linhas: 0, oque: "todas já tinham coordenadas" }); continue; }
+        if (a.confirmado !== true) {
+          const host = (() => { try { return new URL(cfg.geocoder.url).host; } catch { return cfg.geocoder.url; } })();
+          perguntas.push(`Para pôr no mapa, preciso achar as coordenadas de ${pl.items.length} endereço${pl.items.length === 1 ? "" : "s"} da planilha ${a.planilha} (coluna ${pl.column}). Isso envia esses endereços ao serviço ${host} e leva cerca de ${Math.max(1, Math.ceil((pl.items.length * geocodeInterval(cfg)) / 60000))} min. Posso enviar? (Também dá para fazer pela planilha, no botão Achar coordenadas.)`);
+          continue;
+        }
+        onProgress(`achando as coordenadas de ${pl.items.length} endereços…`);
+        const rows = sheet.rows.map((r) => [...r]);
+        let { iLat, iLon } = pl;
+        if (iLat < 0 || iLon < 0) { rows[0].push("latitude", "longitude"); iLat = rows[0].length - 2; iLon = rows[0].length - 1; }
+        const wait = geocodeInterval(cfg);
+        let ok = 0, last = 0;
+        for (const it of pl.items) {
+          const pause = last + wait - Date.now(); if (pause > 0) await new Promise((r) => setTimeout(r, pause)); last = Date.now();
+          const hit = await geocodeOne(it.q, { cfg });
+          if (hit) { ok++; const r = rows[it.row]; while (r.length < rows[0].length) r.push(""); r[iLat] = String(hit.lat); r[iLon] = String(hit.lon); }
+        }
+        const out = /\.(csv|tsv)$/i.test(a.planilha) ? a.planilha : a.planilha.replace(/\.[^.]+$/, "") + ".csv";
+        Project.writeSheet(P, out, rows);
+        feitos.push({ tipo: a.tipo, arquivo: out, linhas: ok, oque: `coordenadas de ${ok} de ${pl.items.length} endereços` });
+      }
+    } catch (e) {
+      falhas.push(`${a.tipo}${a.oque || a.nome ? ` (${a.oque || a.nome})` : ""}: ${e.message}`);
+      if (e instanceof ServiceBlocked) continue;
+    }
+  }
+  return { feitos, perguntas, falhas };
+}
+
+// o que a IA recebe junto do pedido: o que foi gravado (para usar no slide) e o que falhou (para dizer à pessoa)
+export function mapDataInstruction({ feitos, falhas }) {
+  if (!feitos.length && !falhas.length) return "";
+  const lines = feitos.map((f) => `- ${f.arquivo}: ${f.linhas} ${f.tipo === "contorno" ? "contorno" : f.tipo === "linhas" ? "linhas" : "linhas"} (${f.oque}${f.perto_de ? `, perto de ${f.perto_de}` : ""}); fonte: ${f.fonte || "planilha da pessoa"}`);
+  const vazios = feitos.filter((f) => (f.tipo === "lugares" || f.tipo === "linhas") && !f.linhas);
+  return `[Dados geográficos buscados pelo sagadeck agora]\n${lines.join("\n")}${vazios.length ? `\nA busca não achou nada em ${vazios.map((f) => f.oque).join(", ")} nesse raio: diga isso e ofereça buscar num raio maior (ou outro lugar), sem montar mapa vazio.` : ""}${falhas.length ? `\nNão deu: ${falhas.join("; ")}. Diga isso à pessoa sem inventar o que faltou.` : ""}
+Use esses arquivos no slide de mapa (points: para .csv, geojson: para .geojson), com a fonte numa nota ou em source: ("Fonte: OpenStreetMap"). Dado da web: avise que vale revisar.`;
+}
+
+// planilhas do projeto, para a decisão saber o que já existe
+export async function projectSheets(P) {
+  const out = [];
+  const dir = path.join(P.dir, "contexto");
+  const walk = (d) => { for (const e of fs.existsSync(d) ? fs.readdirSync(d, { withFileTypes: true }) : []) { const f = path.join(d, e.name); if (e.isDirectory()) walk(f); else if (/\.(csv|tsv|xlsx)$/i.test(e.name)) out.push(f); } };
+  walk(dir);
+  const sheets = [];
+  for (const f of out.slice(0, 12)) {
+    try {
+      const rows = (await Project.readSheet(f)).sheets[0].rows;
+      const rel = path.relative(P.dir, f).split(path.sep).join("/");
+      const pl = addressPlan(rows);
+      sheets.push({ path: rel, columns: (rows[0] || []).map(String).slice(0, 12), rows: Math.max(0, rows.length - 1), semPosicao: pl.error ? 0 : pl.items.length });
+    } catch { /* planilha que não abre: fica de fora */ }
+  }
+  return sheets;
+}

package/src/ai/quality.js

@@ -51,7 +51,7 @@ export function auditText(spec, indices, { briefing = '', render = null } = {})
   // título; o layout da figura já reserva a área. Vale para os layouts com cabeçalho comum (não capa/seção/manchete).
   for (const index of indices) {
     const s = slides[index];
-    if (!s || !Number.isFinite(Number(s.titleSize)) || ONE_LINER.has(s.layout) || ['cover', 'section', 'end', 'kinetic', 'scenography', 'full'].includes(s.layout)) continue;
+    if (!s || !Number.isFinite(Number(s.titleSize)) || ONE_LINER.has(s.layout) || ['cover', 'section', 'end', 'full'].includes(s.layout)) continue;
     if (Number(s.titleSize) < 60) issues.push({ slide: index + 1, text: `Título com titleSize ${s.titleSize}, bem menor que o dos outros slides: a hierarquia do deck fica desigual. Tire o titleSize (o layout já dá a área da figura); se o título não couber, encurte o texto.` });
   }
   // muitas telas de frase solta: a partir da terceira (ou de 15% do deck), cada uma precisa justificar o lugar