primocode 8.14.0 → 8.16.0

package/bin/primocode.js

@@ -142,142 +142,6 @@ function completarSlash(line) {
 // O layout sai em texto PLANO, com as marcas de onde pintar. Assim os dois
 // pintores (o normal e o do ultracode animado) desenham exatamente a mesma
 // régua — sem duas contas de posição para manter em sincronia.
-function layoutEffort(idx) {
-    const cols = Math.max(52, Math.min(process.stdout.columns || 100, 104));
-    const rotulos = effort.NOMES;
-    const larguras = rotulos.map((n) => Math.max(n.length + 3, 9));
-    const posicoes = [];
-    let x = 23;   // recuo da régua, igual ao do mockup
-    for (let i = 0; i < rotulos.length; i++) {
-        posicoes.push(x + Math.floor(larguras[i] / 2));
-        x += larguras[i];
-    }
-    const fimRegua = x;
-    const marca = posicoes[idx];
-
-    let trilha = '';
-    for (let k = 23; k < fimRegua; k++) {
-        if (k === marca) trilha += '▲';
-        else if (k === fimRegua - 12) trilha += '┆';   // ultracode é um degrau à parte
-        else trilha += '─';
-    }
-
-    let nomes = ' '.repeat(23);
-    let deNome = 0, ateNome = 0;
-    for (let i = 0; i < rotulos.length; i++) {
-        const nome = rotulos[i];
-        const pad = Math.floor((larguras[i] - nome.length) / 2);
-        if (i === idx) { deNome = nomes.length + pad; ateNome = deNome + nome.length; }
-        nomes += ' '.repeat(pad) + nome + ' '.repeat(larguras[i] - nome.length - pad);
-    }
-
-    const nivel = effort.nivelDe(rotulos[idx]);
-    const vaoExtremos = Math.max(1, fimRegua - 23 - 6 - 7);
-
-    return {
-        cols,
-        marca,
-        destaque: { de: deNome, ate: ateNome },
-        linhas: [
-            { tipo: 'regua',    texto: '▔'.repeat(cols) },
-            { tipo: 'titulo',   texto: '   Effort' },
-            { tipo: 'vazio',    texto: '' },
-            { tipo: 'extremos', texto: ' '.repeat(23) + 'Faster' + ' '.repeat(vaoExtremos) + 'Smarter' },
-            { tipo: 'trilha',   texto: ' '.repeat(23) + trilha },
-            { tipo: 'nomes',    texto: nomes },
-            { tipo: 'resumo',   texto: ' '.repeat(23) + nivel.resumo },
-            { tipo: 'vazio',    texto: '' },
-            { tipo: 'ajuda',    texto: '   ←/→ ajusta · Enter confirma · Esc cancela' },
-        ],
-    };
-}
-
-// ── O brilho do ultracode ────────────────────────────────────────────────
-// No nível máximo o painel inteiro ganha um fundo roxo que ondula, como no
-// Claude Code. São faixas verticais de roxo em brilhos diferentes; a onda
-// anda para o lado a cada quadro, e o texto fica branco por cima.
-//
-// Roxos do cubo de 256 cores, ordenados pelo brilho REAL (luminância), do
-// mais escuro ao mais claro — a onda escolhe um deles por faixa. Fora da
-// lista ficaram os roxos escuros que puxam para o vinho (53-56): quebravam a
-// família violeta. Só 256 cores (não truecolor): funciona em qualquer
-// terminal, inclusive no Terminal.app do macOS.
-const ROXOS = [57, 92, 93, 63, 98, 99, 105, 141];
-
-function fundoRoxo(x, fase) {
-    // Duas ondas de períodos diferentes: o encontro delas dá o desenho
-    // irregular de faixas, em vez de listras repetidas e óbvias.
-    const faixa = Math.floor(x / 2);
-    const onda = Math.sin(faixa * 0.55 + fase) * 0.6 + Math.sin(faixa * 0.17 - fase * 0.7) * 0.4;
-    const i = Math.round((onda + 1) / 2 * (ROXOS.length - 1));
-    return ROXOS[Math.max(0, Math.min(ROXOS.length - 1, i))];
-}
-
-// Pinta a linha inteira (até a largura do painel) com a onda por baixo.
-// `destaque` é o trecho que fica branco e forte (o nível escolhido); o resto
-// da linha sai num lilás claro, para o escolhido saltar aos olhos.
-function pintarLinhaUltra(texto, largura, fase, opts = {}) {
-    const base = opts.base || 231;      // branco
-    const apagado = opts.apagado || base;
-    const destaque = opts.destaque;
-    let saida = '';
-    let corFundo = -1;
-    let corTexto = -1;
-    let forte = null;
-
-    for (let x = 0; x < largura; x++) {
-        const fundo = fundoRoxo(x, fase);
-        if (fundo !== corFundo) { saida += `\x1b[48;5;${fundo}m`; corFundo = fundo; }
-
-        const dentro = destaque && x >= destaque.de && x < destaque.ate;
-        const querForte = opts.negrito || dentro;
-        const querCor = dentro ? base : apagado;
-        if (querForte !== forte) { saida += querForte ? '\x1b[1m' : '\x1b[22m'; forte = querForte; }
-        if (querCor !== corTexto) { saida += `\x1b[38;5;${querCor}m`; corTexto = querCor; }
-
-        saida += texto[x] || ' ';
-    }
-    return saida + '\x1b[0m';
-}
-
-function desenharEffort(idx, fase) {
-    const L = layoutEffort(idx);
-    const ultra = effort.NOMES[idx] === 'ultracode';
-
-    if (ultra) {
-        // No ultracode o painel todo vira fundo animado. Cada linha é pintada
-        // com a MESMA onda, então as faixas ficam alinhadas de cima a baixo.
-        const LILAS = 189;   // lilás bem claro, para o que não é o escolhido
-        return L.linhas.map((l) => {
-            if (l.tipo === 'titulo') return pintarLinhaUltra(l.texto, L.cols, fase, { negrito: true });
-            if (l.tipo === 'nomes') return pintarLinhaUltra(l.texto, L.cols, fase, { destaque: L.destaque, apagado: LILAS });
-            if (l.tipo === 'resumo' || l.tipo === 'extremos') return pintarLinhaUltra(l.texto, L.cols, fase, { base: LILAS, apagado: LILAS });
-            return pintarLinhaUltra(l.texto, L.cols, fase, {});
-        }).join('\n');
-    }
-
-    return L.linhas.map((l) => {
-        const t = l.texto;
-        switch (l.tipo) {
-            case 'regua': return c.dim(t);
-            case 'titulo': return c.bold(c.white(t));
-            case 'extremos': return c.muted(t);
-            case 'trilha': {
-                // O marcador aceso, o resto da trilha recuada.
-                const antes = t.slice(0, L.marca);
-                const depois = t.slice(L.marca + 1);
-                return c.dim(antes) + c.brand('▲') + c.dim(depois);
-            }
-            case 'nomes': {
-                const { de, ate } = L.destaque;
-                return c.muted(t.slice(0, de)) + c.bold(c.brand(t.slice(de, ate))) + c.muted(t.slice(ate));
-            }
-            case 'resumo': return c.dim(t);
-            case 'ajuda': return c.muted(t);
-            default: return t;
-        }
-    }).join('\n');
-}
 
 // Desenha, escuta as setas, e devolve o nome escolhido (ou null se cancelou).
 function sliderEffort(atual) {
@@ -293,7 +157,7 @@ function sliderEffort(atual) {
 
         const pintar = (primeira) => {
             if (!primeira) process.stdout.write(`\x1b[${ALTURA}A\r`);
-            process.stdout.write(desenharEffort(idx, fase).split('\n').map((l) => '\x1b[2K' + l).join('\n') + '\n');
+            process.stdout.write(effort.desenharEffort(idx, fase).split('\n').map((l) => '\x1b[2K' + l).join('\n') + '\n');
         };
 
         // O fundo do ultracode ondula; sair dele apaga a animação na hora, para
@@ -425,10 +289,28 @@ function pastaSegura(dir) {
 //      memory.md dele não carrega neste turno.
 //   3. projeto novo — fica PENDENTE: age em ~/primocode e só cria a pasta se o
 //      agente for mexer em arquivo. Pedir para abrir o Chrome não cria projeto.
+// Pedido que se resolve DENTRO do estúdio: vídeo, slides, arte, documento,
+// planilha, diagrama. O que sai dali já é guardado pelo próprio estúdio, em
+// ~/.primocode/studio/arquivos — não precisa (e não deve) virar pasta de
+// código em ~/primocode, cheia de memory.md sobre um vídeo.
+const PEDIDO_DE_ESTUDIO = /\b(v[íi]deo|reels?|anima[çc][ãa]o|slides?|apresenta[çc][ãa]o|deck|post|banner|capa|thumbnail|arte|cartaz|planilha|documento|relat[óo]rio|diagrama|fluxograma|narra[çc][ãa]o|est[úu]dio)\b/i;
+// ...a menos que ele também peça código ou página: aí é projeto de verdade.
+const PEDIDO_DE_CODIGO = /\b(html|css|javascript|js|react|next|python|api|site|p[áa]gina|app|aplicativo|script|reposit[óo]rio|c[óo]digo|programa|servidor|banco de dados)\b/i;
+
+function ehSoEstudio(texto) {
+    const t = String(texto || '');
+    return PEDIDO_DE_ESTUDIO.test(t) && !PEDIDO_DE_CODIGO.test(t);
+}
+
 function planWorkDir(userText) {
     if (['/dir', 'detectada', 'projeto'].includes(state.workDirOrigem)) {
         return { dir: state.workDir, pending: false, name: state.currentProject };
     }
+    // "Quando eu peço um vídeo, não é pra ficar com projeto. Só vai criar
+    // projeto quando tiver um HTML, quando tiver um código."
+    if (ehSoEstudio(userText)) {
+        return { dir: cfg.ROOT_DIR, pending: false, name: state.currentProject, estudio: true };
+    }
     const proposto = deriveProjectName(userText);
     const parecido = cfg.findSimilarProject(proposto);
     if (parecido) return { dir: parecido.dir, pending: false, name: parecido.name, similar: true };

package/lib/act.js

@@ -668,6 +668,23 @@ async function runAct(userPrompt, opts) {
         cfg.appendProjectMemory(pastaAtual, `**Pedido:** ${userPrompt.slice(0, 300)}\n**Resultado:** ${finalText.slice(0, 500)}`);
     }
 
+    // A memória GERAL é gravada sempre, tenha havido pasta ou não.
+    //
+    // Antes ela só era escrita se o agente chamasse `remember_general` — e ele
+    // quase nunca chamava. Pior: a memória de projeto acima depende de
+    // `temPasta`, e tarefa de estúdio (vídeo, slides) não cria pasta nenhuma.
+    // Resultado prático: quem só fazia vídeo NUNCA teve memória gravada, de
+    // tipo nenhum. O usuário notou: "nunca atualiza os arquivos de memória, e
+    // ela deve atualizar independente do projeto".
+    //
+    // Fica curto de propósito — isto entra em todo pedido seguinte. Uma linha
+    // por tarefa concluída, e podada por config.js quando passa do limite.
+    if (!subagent && concluiu && finalText.trim()) {
+        const pedido = userPrompt.replace(/\s+/g, ' ').trim().slice(0, 160);
+        const feito = finalText.replace(/\s+/g, ' ').trim().slice(0, 240);
+        cfg.appendGeneralMemory(`- **${pedido}** → ${feito}`);
+    }
+
     return {
         userMessage: { role: 'user', content: userPrompt },
         assistantMessage: { role: 'assistant', content: finalText },

package/lib/config.js

@@ -165,6 +165,30 @@ function appendGeneralMemory(entry) {
     try {
         ensureStructure();
         fs.appendFileSync(GENERAL_MEMORY, `\n### ${today()}\n${entry}\n`, 'utf-8');
+        podarMemoriaGeral();
+    } catch {}
+}
+
+// A memória geral entra em TODO pedido, então tamanho aqui é custo por
+// chamada. Sem poda ela cresceria para sempre e, ironicamente, seria cortada
+// no meio pelo orçamento de tokens — perdendo justo o mais recente. Podando
+// pelo fim, o que sobrevive é o que vale: o começo escrito à mão pelo usuário
+// e as últimas coisas aprendidas.
+const LIMITE_MEMORIA_GERAL = 12000;
+
+function podarMemoriaGeral() {
+    try {
+        const texto = fs.readFileSync(GENERAL_MEMORY, 'utf-8');
+        if (texto.length <= LIMITE_MEMORIA_GERAL) return;
+        const blocos = texto.split(/\n(?=### )/);
+        const cabeca = blocos.shift() || '';       // o template e o que o usuário escreveu
+        let corpo = '';
+        // De trás para frente: os mais novos entram primeiro e ficam.
+        for (let i = blocos.length - 1; i >= 0; i--) {
+            if (cabeca.length + corpo.length + blocos[i].length > LIMITE_MEMORIA_GERAL) break;
+            corpo = '\n' + blocos[i] + corpo;
+        }
+        fs.writeFileSync(GENERAL_MEMORY, cabeca + corpo, 'utf-8');
     } catch {}
 }
 

package/lib/effort.js

@@ -48,4 +48,181 @@ function pesquisaDe(nome) {
     return nivelDe(nome).pesquisa;
 }
 
-module.exports = { NIVEIS, NOMES, normalizar, nivelDe, indiceDe, modeloDe, pesquisaDe };
+
+const { c } = require('./ui.js');
+
+/* ═══════════════════════════════════════════════════════════════════════
+   O painel do /effort — e o fundo que ondula no ultracode.
+
+   Isto morava dentro do bin/, junto com o loop do programa. Lá não dava
+   para desenhar um quadro e OLHAR: o bin sobe o CLI inteiro quando é
+   carregado. Aqui é função pura — recebe o índice e a fase, devolve texto
+   com cor. Dá para renderizar quadro a quadro num teste, que é como a
+   animação foi conferida.
+   ═══════════════════════════════════════════════════════════════════════ */
+
+function layoutEffort(idx) {
+    // Sem teto de largura: o fundo do ultracode preenche o terminal inteiro.
+    // Travado em 104 colunas, o painel parava no meio de uma tela larga e o
+    // bloco roxo ficava com um degrau escuro do lado — parecia recorte, não
+    // fundo. A régua e os rótulos continuam no mesmo lugar; só o pano cresce.
+    const cols = Math.max(52, process.stdout.columns || 100);
+    const rotulos = NOMES;
+    const larguras = rotulos.map((n) => Math.max(n.length + 3, 9));
+    const posicoes = [];
+    let x = 23;   // recuo da régua, igual ao do mockup
+    for (let i = 0; i < rotulos.length; i++) {
+        posicoes.push(x + Math.floor(larguras[i] / 2));
+        x += larguras[i];
+    }
+    const fimRegua = x;
+    const marca = posicoes[idx];
+
+    let trilha = '';
+    for (let k = 23; k < fimRegua; k++) {
+        if (k === marca) trilha += '▲';
+        else if (k === fimRegua - 12) trilha += '┆';   // ultracode é um degrau à parte
+        else trilha += '─';
+    }
+
+    let nomes = ' '.repeat(23);
+    let deNome = 0, ateNome = 0;
+    for (let i = 0; i < rotulos.length; i++) {
+        const nome = rotulos[i];
+        const pad = Math.floor((larguras[i] - nome.length) / 2);
+        if (i === idx) { deNome = nomes.length + pad; ateNome = deNome + nome.length; }
+        nomes += ' '.repeat(pad) + nome + ' '.repeat(larguras[i] - nome.length - pad);
+    }
+
+    const nivel = nivelDe(rotulos[idx]);
+    const vaoExtremos = Math.max(1, fimRegua - 23 - 6 - 7);
+
+    return {
+        cols,
+        marca,
+        destaque: { de: deNome, ate: ateNome },
+        linhas: [
+            { tipo: 'regua',    texto: '▔'.repeat(cols) },
+            { tipo: 'titulo',   texto: '   Effort' },
+            { tipo: 'vazio',    texto: '' },
+            { tipo: 'extremos', texto: ' '.repeat(23) + 'Faster' + ' '.repeat(vaoExtremos) + 'Smarter' },
+            { tipo: 'trilha',   texto: ' '.repeat(23) + trilha },
+            { tipo: 'nomes',    texto: nomes },
+            { tipo: 'resumo',   texto: ' '.repeat(23) + nivel.resumo },
+            { tipo: 'vazio',    texto: '' },
+            { tipo: 'ajuda',    texto: '   ←/→ ajusta · Enter confirma · Esc cancela' },
+        ],
+    };
+}
+
+// ── O brilho do ultracode ────────────────────────────────────────────────
+// No nível máximo o painel inteiro ganha um fundo roxo que ondula, como no
+// Claude Code. São faixas verticais de roxo em brilhos diferentes; a onda
+// anda para o lado a cada quadro, e o texto fica branco por cima.
+//
+// Roxos do cubo de 256 cores, ordenados pelo brilho REAL (luminância), do
+// mais escuro ao mais claro — a onda escolhe um deles por faixa. Fora da
+// lista ficaram os roxos escuros que puxam para o vinho (53-56): quebravam a
+// família violeta. Só 256 cores (não truecolor): funciona em qualquer
+// terminal, inclusive no Terminal.app do macOS.
+// A rampa é ESTREITA de propósito: só violetas vizinhos, do escuro ao médio.
+//
+// A lista antiga ia de 57 a 141 e passava por 63 (azul) e 92 (magenta
+// escuro). Vizinhas na tela, essas cores não leem como uma superfície só:
+// leem como listras — e listra clara demais apaga o texto branco por cima.
+// O fundo tem de parecer um pano roxo respirando atrás do painel, não uma
+// bandeira. Os tons claros ficam de fora por isso.
+const ROXOS = [54, 55, 56, 57, 57, 93, 93, 99, 98, 92, 56, 55];
+
+function fundoRoxo(x, fase) {
+    // Duas ondas de períodos diferentes: o encontro delas dá o desenho
+    // irregular de faixas, em vez de listras repetidas e óbvias.
+    //
+    // As frequências caíram (0.55 → 0.13) porque as faixas tinham três
+    // colunas de largura: de longe aquilo não era um fundo ondulando, era
+    // chuviscado. Faixa larga anda devagar pela tela, que é o movimento que
+    // se quer ver — o painel respira em vez de piscar.
+    const faixa = x / 2;
+    const onda = Math.sin(faixa * 0.13 + fase) * 0.62 + Math.sin(faixa * 0.041 - fase * 0.55) * 0.38;
+    // A curva ³ empurra os valores para o MEIO da rampa: os extremos (o mais
+    // escuro e o mais claro) só aparecem no pico da onda, e o painel passa a
+    // maior parte do tempo num roxo médio, onde o texto branco se lê.
+    const suave = Math.pow(onda, 3) * 0.55 + onda * 0.45;
+    const i = Math.round((suave + 1) / 2 * (ROXOS.length - 1));
+    return ROXOS[Math.max(0, Math.min(ROXOS.length - 1, i))];
+}
+
+// Pinta a linha inteira (até a largura do painel) com a onda por baixo.
+// `destaque` é o trecho que fica branco e forte (o nível escolhido); o resto
+// da linha sai num lilás claro, para o escolhido saltar aos olhos.
+function pintarLinhaUltra(texto, largura, fase, opts = {}) {
+    const base = opts.base || 231;      // branco
+    const apagado = opts.apagado || base;
+    const destaque = opts.destaque;
+    let saida = '';
+    let corFundo = -1;
+    let corTexto = -1;
+    let forte = null;
+
+    for (let x = 0; x < largura; x++) {
+        const fundo = fundoRoxo(x, fase);
+        if (fundo !== corFundo) { saida += `\x1b[48;5;${fundo}m`; corFundo = fundo; }
+
+        const dentro = destaque && x >= destaque.de && x < destaque.ate;
+        const querForte = opts.negrito || dentro;
+        const querCor = dentro ? base : apagado;
+        if (querForte !== forte) { saida += querForte ? '\x1b[1m' : '\x1b[22m'; forte = querForte; }
+        if (querCor !== corTexto) { saida += `\x1b[38;5;${querCor}m`; corTexto = querCor; }
+
+        saida += texto[x] || ' ';
+    }
+    return saida + '\x1b[0m';
+}
+
+function desenharEffort(idx, fase) {
+    const L = layoutEffort(idx);
+    const ultra = NOMES[idx] === 'ultracode';
+
+    if (ultra) {
+        // No ultracode o painel todo vira fundo animado. Cada linha é pintada
+        // com a MESMA onda, então as faixas ficam alinhadas de cima a baixo.
+        const LILAS = 189;   // lilás bem claro, para o que não é o escolhido
+        return L.linhas.map((l) => {
+            // A régua é uma fileira de "▔". Sobre o roxo ela virava uma
+            // listra clara atravessando o topo e cortava o bloco em dois.
+            // No ultra ela some e vira fundo liso: a borda de cima do painel
+            // passa a ser o próprio degradê, que é o que se quer ver.
+            if (l.tipo === 'regua') return pintarLinhaUltra('', L.cols, fase, {});
+            if (l.tipo === 'titulo') return pintarLinhaUltra(l.texto, L.cols, fase, { negrito: true });
+            if (l.tipo === 'nomes') return pintarLinhaUltra(l.texto, L.cols, fase, { destaque: L.destaque, apagado: LILAS });
+            if (l.tipo === 'resumo' || l.tipo === 'extremos') return pintarLinhaUltra(l.texto, L.cols, fase, { base: LILAS, apagado: LILAS });
+            return pintarLinhaUltra(l.texto, L.cols, fase, {});
+        }).join('\n');
+    }
+
+    return L.linhas.map((l) => {
+        const t = l.texto;
+        switch (l.tipo) {
+            case 'regua': return c.dim(t);
+            case 'titulo': return c.bold(c.white(t));
+            case 'extremos': return c.muted(t);
+            case 'trilha': {
+                // O marcador aceso, o resto da trilha recuada.
+                const antes = t.slice(0, L.marca);
+                const depois = t.slice(L.marca + 1);
+                return c.dim(antes) + c.brand('▲') + c.dim(depois);
+            }
+            case 'nomes': {
+                const { de, ate } = L.destaque;
+                return c.muted(t.slice(0, de)) + c.bold(c.brand(t.slice(de, ate))) + c.muted(t.slice(ate));
+            }
+            case 'resumo': return c.dim(t);
+            case 'ajuda': return c.muted(t);
+            default: return t;
+        }
+    }).join('\n');
+}
+
+module.exports = { NIVEIS, NOMES, normalizar, nivelDe, indiceDe, modeloDe, pesquisaDe,
+    layoutEffort, fundoRoxo, pintarLinhaUltra, desenharEffort, ROXOS };
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "8.14.0",
+  "version": "8.16.0",
   "description": "PrimoCode — agente de engenharia com IA e cursor próprio. Modelos grátis. Cria arquivos, roda comandos, controla navegador e desktop: abre apps, clica em botões e ícones pelo nome, digita e usa atalhos.",
   "main": "bin/primocode.js",
   "bin": {
@@ -8,7 +8,7 @@
   },
   "scripts": {
     "start": "node bin/primocode.js",
-    "test": "node test/tools.test.js && node test/ui.test.js && node test/modo.test.js && node test/pasta.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/effort.test.js && node test/claude-engine.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/referencia.test.js && node test/parar.test.js && node test/continuar.test.js && node test/studio-spec.test.js && node test/studio-versoes.test.js && node test/voz.test.js && node test/editor.test.js"
+    "test": "node test/tools.test.js && node test/ui.test.js && node test/modo.test.js && node test/pasta.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/effort.test.js && node test/claude-engine.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/referencia.test.js && node test/parar.test.js && node test/continuar.test.js && node test/studio-spec.test.js && node test/studio-versoes.test.js && node test/voz.test.js && node test/editor.test.js && node test/estudio-projeto.test.js"
   },
   "engines": {
     "node": ">=18.17.0"

package/studio/server.py

@@ -649,9 +649,16 @@ def validar_doc(modelo, doc):
             if problema:
                 return problema
             dur = c.get("duracao")
-            if dur is not None and not isinstance(dur, (int, float)):
+            if dur is not None and (isinstance(dur, bool) or not isinstance(dur, (int, float))):
                 return ('cena %d com "duracao" que não é número (veio %r). Use número de segundos: '
                         '"duracao": 3' % (i + 1, dur))
+            # Duração zero passava: era número, afinal. E um vídeo cujas cenas
+            # somam zero é o "vídeo de 0 segundos" que o usuário viu mais de
+            # uma vez — arquivo válido, conteúdo inalcançável.
+            if isinstance(dur, (int, float)) and not isinstance(dur, bool) and dur <= 0:
+                return ('cena %d tem "duracao": %r. Zero (ou negativo) faz o vídeo inteiro durar '
+                        'nada — foi assim que saiu um vídeo de 0 segundos. Use pelo menos 1.'
+                        % (i + 1, dur))
             for j, e in enumerate(els):
                 if not isinstance(e, dict) or not e.get("tipo"):
                     return 'elemento %d da cena %d sem "tipo" (texto, imagem, lista, numeros, forma...)' % (j + 1, i + 1)
@@ -1265,7 +1272,21 @@ class Handler(SimpleHTTPRequestHandler):
                 problema = validar_doc(
                     POR_SLUG.get(a.get("ferramenta"), {}).get("modelo"), novo)
                 if problema:
-                    return self.js({"erro": problema}, 400)
+                    # As frases de validar_doc foram escritas para a CRIAÇÃO:
+                    # elas terminam em "crie de novo" e "refaça". Devolver isso
+                    # numa ATUALIZAÇÃO manda o agente fazer exatamente a coisa
+                    # errada — e foi o que aconteceu: ele recebia o erro, jogava
+                    # fora o vídeo pronto e recomeçava do zero, às vezes saindo
+                    # pior. Aqui a instrução é a oposta, e vem por último para
+                    # ser a última coisa que ele lê.
+                    problema = re.sub(r"(crie de novo|e refaça)\.?", "", problema).strip()
+                    return self.js({
+                        "erro": problema
+                        + ' Isto é uma ATUALIZAÇÃO: NÃO crie outro arquivo e NÃO recomece do zero. '
+                          'Corrija só o que está errado acima e chame studio_atualizar de novo '
+                          'com o MESMO id "%s". O arquivo continua intacto — nada foi perdido.' % a["id"],
+                        "id": a["id"],
+                    }, 400)
 
         preparar_voz(novo)
         versao = guardar_versao(a)