primocode 8.0.0 → 8.0.2

package/bin/primocode.js

@@ -24,6 +24,18 @@ const pasta = require('../lib/pasta');
 const catalogo = require('../lib/catalogo');
 const effort = require('../lib/effort');
 
+// Rede de segurança de último recurso: sem isto, uma exceção fora de um
+// try/catch (ex.: dentro de um callback de socket, como o parser de SSE) não
+// era pega por ninguém e derrubava o processo INTEIRO em silêncio — o usuário
+// via a resposta parar no meio e cair de volta pro shell, sem mensagem
+// nenhuma. Agora vira um erro visível, e o processo continua de pé.
+process.on('uncaughtException', (e) => {
+    console.log('\n' + c.err(ui.friendlyError(e)));
+});
+process.on('unhandledRejection', (e) => {
+    console.log('\n' + c.err(ui.friendlyError(e instanceof Error ? e : new Error(String(e)))));
+});
+
 // A pasta de onde o comando foi dado. Não é mais onde ele trabalha (o padrão é
 // ~/primocode), mas continua servindo de ponto de partida para achar pasta que
 // o usuário mencionar por nome relativo.

package/lib/act.js

@@ -165,7 +165,7 @@ function buildMemoryContext(projectDir, projectName) {
     const geral = cfg.readGeneralMemory();
     if (geral.trim()) parts.push(`[memory-geral.md]\n${geral}`);
     const projeto = cfg.readProjectMemory(projectDir);
-    if (projeto.trim()) parts.push(`[${projectName}/memory.md]\n${projeto}`);
+    if (projeto.trim()) parts.push(`[${projectName || 'projeto'}/memory.md]\n${projeto}`);
     return parts.join('\n\n');
 }
 
@@ -299,9 +299,19 @@ async function runAct(userPrompt, opts) {
             const result = await tools.execute(tc.name, tc.arguments, { projectDir: pastaAtual });
             logResult(tc.name, result, profundidade);
 
-            // Uma escrita bem-sucedida limpa a dívida: o agente se corrigiu.
-            if (result && result.ok === false) falhasPendentes.push(`${tc.name}(${tc.arguments?.path || ''}): ${result.error}`);
-            else if (['write_file', 'edit_file'].includes(tc.name)) falhasPendentes.length = 0;
+            // Uma escrita bem-sucedida limpa a dívida — mas só a do MESMO
+            // arquivo. Escrever algo sem relação (ou um run_shell qualquer)
+            // não corrige um teste quebrado noutro lugar; antes isto zerava
+            // a lista inteira e o agente conseguia dizer "concluído" com uma
+            // falha real ainda pendente.
+            if (result && result.ok === false) {
+                falhasPendentes.push(`${tc.name}(${tc.arguments?.path || ''}): ${result.error}`);
+            } else if (['write_file', 'edit_file'].includes(tc.name) && tc.arguments?.path) {
+                const alvo = tc.arguments.path;
+                const mantidas = falhasPendentes.filter((f) => !f.includes(`(${alvo})`));
+                falhasPendentes.length = 0;
+                falhasPendentes.push(...mantidas);
+            }
 
             messages.push({ role: 'tool', tool_call_id: tc.id, content: summarizeForModel(result) });
         }
@@ -332,7 +342,12 @@ async function runAct(userPrompt, opts) {
     // Nada de arquivo mexido = nada para lembrar. E grava em `pastaAtual`, não em
     // `projectDir`: quando a pasta do projeto nasceu no meio do caminho, a memória
     // precisa ir para ela, não para a raiz onde a sessão começou.
-    if (!subagent && projectName && temPasta) {
+    //
+    // `projectName` NÃO entra na condição: ele só rotula a memória no prompt
+    // (buildMemoryContext), e sessão sem projeto nomeado (ex.: primeiro pedido
+    // antes de /project) tem `projectName` undefined mesmo já tendo mexido em
+    // arquivo de verdade — a memória era descartada nesse caso, sempre.
+    if (!subagent && temPasta) {
         cfg.appendProjectMemory(pastaAtual, `**Pedido:** ${userPrompt.slice(0, 300)}\n**Resultado:** ${finalText.slice(0, 500)}`);
     }
 

package/lib/api.js

@@ -90,7 +90,19 @@ function requestStream(serverUrl, endpoint, payload, onEvent, token) {
                     if (!line.startsWith('data: ')) continue;
                     let evt;
                     try { evt = JSON.parse(line.slice(6)); } catch { continue; }
-                    onEvent(evt);
+                    // onEvent roda dentro de um callback de socket, fora de
+                    // qualquer try/catch de quem chamou requestStream. Uma
+                    // exceção aqui não seria pega por ninguém — sem process.on
+                    // ('uncaughtException') no CLI, isso derrubava o processo
+                    // inteiro em silêncio (era o "cai fora" sem mensagem
+                    // nenhuma). Agora vira rejeição normal da Promise.
+                    try {
+                        onEvent(evt);
+                    } catch (e) {
+                        settled = true;
+                        reject(e);
+                        return;
+                    }
                     if (evt.done) finish();
                 }
             });

package/lib/catalogo.js

@@ -91,6 +91,11 @@ const GRUPOS = [
         itens: [
             { tool: 'write_todos', escreve: false, faz: 'monta o plano e vai marcando o que terminou' },
             { tool: 'pesquisar_referencia', escreve: false, faz: 'lê docs e exemplos antes de escrever — sobe a qualidade' },
+            // Vai para memory-geral.md, FORA da pasta do projeto — por isso não
+            // é write_file/edit_file (a sandbox de resolveInProject bloqueia
+            // qualquer caminho fora do projeto, e é assim mesmo que tem que
+            // ser para os outros casos). Esta tool é a única porta pra lá.
+            { tool: 'remember_general', escreve: false, faz: 'grava algo sobre o usuário que vale para todo projeto (memory-geral.md)' },
             // Estas duas o loop do agente atende (lib/act.js), não o tools.execute.
             { tool: 'spawn_agent', escreve: false, faz: 'chama um subagente para uma parte da tarefa', noLoop: true },
             { tool: 'finish',      escreve: false, faz: 'encerra dizendo o que fez', noLoop: true },

package/lib/config.js

@@ -151,6 +151,18 @@ function appendProjectMemory(dir, entry) {
     } catch {}
 }
 
+// A contraparte de appendProjectMemory, para o que vale em TODOS os projetos
+// (nome do usuário, preferência, decisão de longo prazo). Existia a promessa
+// no prompt — "escreve aqui o que descobrir sobre você" — mas nenhuma função
+// gravava de fato: só ensureStructure() criava o template uma vez.
+function appendGeneralMemory(entry) {
+    if (!entry) return;
+    try {
+        ensureStructure();
+        fs.appendFileSync(GENERAL_MEMORY, `\n### ${today()}\n${entry}\n`, 'utf-8');
+    } catch {}
+}
+
 function loadConfig() {
     ensureStructure();
     let file = {};
@@ -198,5 +210,5 @@ module.exports = {
     CONFIG_DIR, CONFIG_FILE, HISTORY_FILE, ROOT_DIR, GENERAL_MEMORY,
     ensureStructure, slugify,
     createProjectDir, getProjectDir, listProjects, findSimilarProject,
-    readGeneralMemory, readProjectMemory, appendProjectMemory,
+    readGeneralMemory, readProjectMemory, appendProjectMemory, appendGeneralMemory,
 };

package/lib/desktop.js

@@ -19,7 +19,9 @@ const os = require('os');
 const PLATFORM = os.platform();
 
 function hasCmd(cmd) {
-    try { execSync(`which ${cmd} || where ${cmd}`, { stdio: 'ignore' }); return true; } catch { return false; }
+    // cmd pode vir de texto do usuário (desktop_open_app com nome sem alias
+    // conhecido) — sem aspas aqui, um ";"/"&&" no meio vira comando extra.
+    try { execSync(`which ${sh1(cmd)} || where ${sh1(cmd)}`, { stdio: 'ignore' }); return true; } catch { return false; }
 }
 
 // Detectar ferramenta disponível

package/lib/modo.js

@@ -37,6 +37,13 @@ const VERBOS = [
 ];
 const RE_VERBO = new RegExp(`(^|\\s)(${VERBOS.join('|')})\\b`, 'i');
 
+// Pedido sem verbo de comando, só desejo: "quero um jogo da velha", "preciso
+// de uma landing page". Muito comum em português — e sem isto caía direto no
+// "sem pista de tarefa" porque não tem 'criar'/'fazer' escrito. A diferença
+// para RE_CONCEITUAL é que aqui não vem pergunta ("como", "por que", "o que
+// é") — só o pedido do que a pessoa quer que exista.
+const RE_DESEJO = /\b(quero|queria|querendo|gostaria de|necessito de|precis[ao] de|precisava de)\b/i;
+
 // Coisas que só existem quando há trabalho de arquivo/máquina envolvido.
 const RE_ARTEFATO = /\.(js|ts|tsx|jsx|html|css|json|md|py|sh|yml|yaml|txt|csv|env)\b|[\w-]+\/[\w-]/i;
 const RE_FERRAMENTA = /\b(navegador|browser|desktop|terminal|shell|git|npm|node|deploy|servidor|localhost|porta \d+|screenshot|print da tela|mouse|teclado|janela|[áa]rea de trabalho|aplicativo|[íi]cone)\b/i;
@@ -65,6 +72,7 @@ function escolherModo(texto) {
 
     if (RE_ARTEFATO.test(t)) return { modo: 'primocode', motivo: 'cita arquivo ou caminho' };
     if (RE_VERBO.test(t)) return { modo: 'primocode', motivo: 'pede uma ação' };
+    if (RE_DESEJO.test(t)) return { modo: 'primocode', motivo: 'expressa o que quer que exista' };
     if (RE_FERRAMENTA.test(t)) return { modo: 'primocode', motivo: 'menciona ferramenta ou máquina' };
     if (RE_PASTA.test(t)) return { modo: 'primocode', motivo: 'fala de arquivo ou projeto' };
 

package/lib/referencia.js

@@ -64,11 +64,15 @@ function viaProxy(alvo, { timeout }) {
     });
 }
 
-function pegar(url, { timeout = TIMEOUT_MS } = {}) {
+function pegar(url, { timeout = TIMEOUT_MS, saltos = 0 } = {}) {
     return new Promise((resolve) => {
         let req;
         const alvo = (() => { try { return new URL(url); } catch { return null; } })();
         if (!alvo) return resolve(null);
+        // 5 saltos cobre qualquer doc real; sem teto, um redirect em loop
+        // (A→B→A→...) trava essa fonte — e a pesquisa inteira — para sempre.
+        if (saltos > 5) return resolve(null);
+        const cliente = alvo.protocol === 'http:' ? http : https;
 
         const opcoes = {
             headers: {
@@ -88,12 +92,12 @@ function pegar(url, { timeout = TIMEOUT_MS } = {}) {
         abrir.then((cfg) => {
             if (!cfg) return resolve(null);
             try {
-                req = https.get(url, cfg, (res) => {
-                // Redirecionamento: segue uma vez, o suficiente para docs.
+                req = cliente.get(url, cfg, (res) => {
+                // Redirecionamento: segue até o teto de saltos acima.
                 if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
                     res.resume();
                     const destino = new URL(res.headers.location, url).href;
-                    return pegar(destino, { timeout }).then(resolve);
+                    return pegar(destino, { timeout, saltos: saltos + 1 }).then(resolve);
                 }
                 if (res.statusCode !== 200) { res.resume(); return resolve(null); }
                 let corpo = '';

package/lib/tools.js

@@ -15,6 +15,7 @@ const browser = require('./browser');
 const desktop = require('./desktop');
 const referencia = require('./referencia');
 const studio = require('./studio');
+const cfg = require('./config');
 
 const IGNORAR = new Set(['node_modules', '.git', 'dist', 'build', '.next', 'coverage', '.cache', 'vendor']);
 const MAX_ARQUIVOS_VARREDURA = 5000;
@@ -289,7 +290,7 @@ function multiEdit({ path: rawPath, edits }, projectDir) {
         if (ocorrencias > 1 && !replace_all) {
             return { ok: false, error: `edit ${i + 1}: trecho aparece ${ocorrencias}x — use replace_all ou inclua mais contexto para torná-lo único` };
         }
-        conteudo = replace_all ? conteudo.split(old_string).join(new_string) : conteudo.replace(old_string, new_string);
+        conteudo = replace_all ? conteudo.split(old_string).join(new_string ?? '') : conteudo.replace(old_string, new_string ?? '');
         substituicoes++;
     }
 
@@ -399,6 +400,16 @@ async function despachar(name, args, ctx) {
                     paginas: Math.max(1, Math.min(5, Number(args.paginas) || 3)),
                 });
 
+            // memory-geral.md fica FORA da pasta do projeto — write_file/edit_file
+            // não alcançam por design (resolveInProject bloqueia ../ de propósito).
+            // Esta é a única porta para lá, sem reabrir a sandbox.
+            case 'remember_general': {
+                const entry = String(args.fato || args.entry || '').trim();
+                if (!entry) return { ok: false, error: 'Diga o que lembrar (fato).' };
+                cfg.appendGeneralMemory(entry);
+                return { ok: true, gravado: entry };
+            }
+
             // ── Navegador controlado (CDP) — o agente age numa página real ──
             case 'browser_open': {
                 const alvo = /^https?:\/\//i.test(args.url || '')
@@ -422,7 +433,10 @@ async function despachar(name, args, ctx) {
                 return texto == null ? { ok: false, error: 'nada na página (ou seletor não encontrado)' } : { ok: true, text: texto };
             }
             case 'browser_screenshot':
-                return browser.screenshot(args.path ? resolveInProject(args.path, projectDir) : undefined);
+                // Sem path, cai num nome-padrão — mas SEMPRE dentro do projeto: sem
+                // isso o arquivo ia para o cwd real do processo, não para a pasta
+                // virtual que o CLI mostra ao usuário (o processo nunca faz chdir).
+                return browser.screenshot(resolveInProject(args.path || `screenshot-${Date.now()}.png`, projectDir));
             case 'browser_scroll':
                 return browser.scroll(args.dy != null ? args.dy : 600);
             case 'browser_wait':
@@ -432,7 +446,9 @@ async function despachar(name, args, ctx) {
 
             // ── Desktop físico — mouse, teclado e tela do usuário ───────────
             case 'desktop_screenshot':
-                return desktop.screenshot(args.path ? resolveInProject(args.path, projectDir) : undefined);
+                // Mesmo motivo do browser_screenshot: nome-padrão também precisa
+                // resolver dentro do projeto, não do cwd real do processo.
+                return desktop.screenshot(resolveInProject(args.path || `desktop-${Date.now()}.png`, projectDir));
             case 'desktop_click':
                 return desktop.click(args.x, args.y, args.button || 'left');
             case 'desktop_move':
@@ -484,24 +500,6 @@ async function despachar(name, args, ctx) {
     }
 }
 
-function applyCodeBlocks(response) {
-    const regex = /```[\w]*\n([\s\S]*?)```/g;
-    const applied = [];
-    let match;
-    while ((match = regex.exec(response || '')) !== null) {
-        const block = match[1];
-        const nome = block.match(/\/\/\s*filename:\s*(.+)/);
-        if (!nome) continue;
-        const filename = nome[1].trim();
-        const content = block.replace(/\/\/\s*filename:.+\n?/, '');
-        const created = !fs.existsSync(filename);
-        fs.mkdirSync(path.dirname(filename), { recursive: true });
-        fs.writeFileSync(filename, content, 'utf-8');
-        applied.push({ path: filename, created });
-    }
-    return applied;
-}
-
 async function uninstall() {
     const configDir = path.join(os.homedir(), '.primocode');
     console.log('Removendo PrimoCode…');
@@ -519,7 +517,7 @@ async function uninstall() {
 }
 
 module.exports = {
-    fmtBytes, treeDir, applyCodeBlocks, runShell, openInBrowser, runInNewTerminal,
+    fmtBytes, treeDir, runShell, openInBrowser, runInNewTerminal,
     execute, uninstall, resolveInProject, globToRegex, globFiles, grepFiles, editFile,
     multiEdit, writeTodos, getTodos,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "8.0.0",
+  "version": "8.0.2",
   "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": {

package/studio/server.py

@@ -9,6 +9,7 @@ Só biblioteca padrão do Python. Nada para instalar.
 """
 
 import base64
+import functools
 import json
 import mimetypes
 import os
@@ -98,10 +99,17 @@ POR_SLUG = {f["slug"]: f for f in FERRAMENTAS_INFO}
 
 # -------------------------------------------------------------- utilidades --
 
-def slugify(texto):
+def _normaliza(texto, tamanho):
+    """NFKD → ASCII → não-alfanumérico vira hífen → minúsculo → corta.
+    Compartilhada por slugify() e nome_seguro(), que faziam a mesma conta
+    com um corte de tamanho diferente cada uma."""
     texto = unicodedata.normalize("NFKD", texto or "").encode("ascii", "ignore").decode()
     texto = re.sub(r"[^a-zA-Z0-9]+", "-", texto).strip("-").lower()
-    return (texto or "arquivo")[:40]
+    return (texto or "arquivo")[:tamanho]
+
+
+def slugify(texto):
+    return _normaliza(texto, 40)
 
 
 def caminho(arq_id):
@@ -163,10 +171,7 @@ mimetypes.add_type("audio/mp4", ".m4a")
 
 def nome_seguro(nome):
     base, ext = os.path.splitext(nome or "arquivo")
-    ext = ext.lower()
-    base = unicodedata.normalize("NFKD", base).encode("ascii", "ignore").decode()
-    base = re.sub(r"[^a-zA-Z0-9]+", "-", base).strip("-").lower()[:48] or "arquivo"
-    return base, ext
+    return _normaliza(base, 48), ext.lower()
 
 
 def listar_midia():
@@ -218,16 +223,31 @@ def guardar_midia(dados):
 
 
 def criar(dados):
-    ferramenta = (dados.get("ferramenta") or "prisma").lower()
+    # O cliente é um agente de IA falando JSON cru — um tipo errado aqui
+    # (titulo como lista, por exemplo) não pode virar AttributeError sem
+    # resposta HTTP nenhuma; melhor um 400 com o motivo.
+    ferramenta_bruta = dados.get("ferramenta")
+    if ferramenta_bruta is not None and not isinstance(ferramenta_bruta, str):
+        raise ValueError("ferramenta precisa ser texto")
+    ferramenta = (ferramenta_bruta or "prisma").lower()
     if ferramenta not in POR_SLUG:
         return None
-    titulo = (dados.get("titulo") or "Sem título").strip()
+
+    titulo_bruto = dados.get("titulo")
+    if titulo_bruto is not None and not isinstance(titulo_bruto, str):
+        raise ValueError("titulo precisa ser texto")
+    titulo = (titulo_bruto or "Sem título").strip()
+
+    doc = dados.get("doc")
+    if doc is not None and not isinstance(doc, dict):
+        raise ValueError("doc precisa ser um objeto")
+
     arq_id = ferramenta + "-" + slugify(titulo) + "-" + uuid.uuid4().hex[:5]
     return gravar({
         "id": arq_id,
         "ferramenta": ferramenta,
         "titulo": titulo,
-        "doc": dados.get("doc") or exemplo(ferramenta),
+        "doc": doc or exemplo(ferramenta),
     })
 
 
@@ -311,6 +331,23 @@ def manual():
 
 # ----------------------------------------------------------------- handler --
 
+def seguro(metodo):
+    """Qualquer exceção não prevista na rota vira 500 em JSON, não conexão
+    fechada sem resposta nenhuma — era o comportamento padrão do
+    BaseHTTPRequestHandler para exceção não tratada num do_*, e o cliente (o
+    agente de IA) não tem como interpretar uma conexão que só morre."""
+    @functools.wraps(metodo)
+    def envolto(self, *a, **kw):
+        try:
+            return metodo(self, *a, **kw)
+        except Exception as e:
+            try:
+                self.js({"erro": "erro interno: %s" % e}, 500)
+            except Exception:
+                pass
+    return envolto
+
+
 class Handler(SimpleHTTPRequestHandler):
     server_version = "PrimoCode/1.0"
 
@@ -360,6 +397,7 @@ class Handler(SimpleHTTPRequestHandler):
 
     # -------------------------------------------------------------- rotas --
 
+    @seguro
     def do_GET(self):
         p = urlparse(self.path).path
 
@@ -426,10 +464,17 @@ class Handler(SimpleHTTPRequestHandler):
         if faixa:
             m = re.match(r"bytes=(\d*)-(\d*)", faixa)
             if m:
-                if m.group(1):
-                    inicio = int(m.group(1))
-                if m.group(2):
-                    fim = min(int(m.group(2)), tamanho - 1)
+                if not m.group(1) and m.group(2):
+                    # "bytes=-500" é sufixo HTTP válido: os ÚLTIMOS 500 bytes,
+                    # não os primeiros 500 — sem este caso à parte, group(2)
+                    # virava fim absoluto e o pedido servia o pedaço errado.
+                    inicio = max(0, tamanho - int(m.group(2)))
+                    fim = tamanho - 1
+                else:
+                    if m.group(1):
+                        inicio = int(m.group(1))
+                    if m.group(2):
+                        fim = min(int(m.group(2)), tamanho - 1)
                 if inicio > fim or inicio >= tamanho:
                     self.send_response(416)
                     self.send_header("Content-Range", "bytes */%d" % tamanho)
@@ -455,13 +500,18 @@ class Handler(SimpleHTTPRequestHandler):
                 self.wfile.write(pedaco)
                 restante -= len(pedaco)
 
+    @seguro
     def do_POST(self):
-        if urlparse(self.path).path == "/api/midia":
+        rota = urlparse(self.path).path
+        if rota == "/api/midia":
             corpo, status = guardar_midia(self.corpo())
             return self.js(corpo, status)
 
-        if urlparse(self.path).path == "/api/arquivos":
-            a = criar(self.corpo())
+        if rota == "/api/arquivos":
+            try:
+                a = criar(self.corpo())
+            except ValueError as e:
+                return self.js({"erro": str(e)}, 400)
             if not a:
                 return self.js({"erro": "ferramenta inválida",
                                 "validas": list(POR_SLUG)}, 400)
@@ -475,6 +525,7 @@ class Handler(SimpleHTTPRequestHandler):
             }, 201)
         return self.js({"erro": "não encontrado"}, 404)
 
+    @seguro
     def do_PUT(self):
         m = re.fullmatch(r"/api/arquivos/([^/]+)", urlparse(self.path).path)
         if not m:
@@ -483,13 +534,21 @@ class Handler(SimpleHTTPRequestHandler):
         if not a:
             return self.js({"erro": "não encontrado"}, 404)
         dados = self.corpo()
+        # Mesma validação de criar(): sem isso, um PUT com titulo/doc do tipo
+        # errado grava sujeira que só quebra depois, no consumo (export etc).
+        if "titulo" in dados and dados["titulo"] is not None and not isinstance(dados["titulo"], str):
+            return self.js({"erro": "titulo precisa ser texto"}, 400)
+        if "doc" in dados and dados["doc"] is not None and not isinstance(dados["doc"], dict):
+            return self.js({"erro": "doc precisa ser um objeto"}, 400)
         for chave in ("titulo", "doc"):
             if chave in dados:
                 a[chave] = dados[chave]
         return self.js(gravar(a))
 
+    @seguro
     def do_DELETE(self):
-        m = re.fullmatch(r"/api/midia/([^/]+)", urlparse(self.path).path)
+        rota = urlparse(self.path).path
+        m = re.fullmatch(r"/api/midia/([^/]+)", rota)
         if m:
             nome = unquote(m.group(1))
             alvo = os.path.join(MIDIA, nome)
@@ -498,7 +557,7 @@ class Handler(SimpleHTTPRequestHandler):
                 return self.js({"ok": True})
             return self.js({"erro": "não encontrado"}, 404)
 
-        m = re.fullmatch(r"/api/arquivos/([^/]+)", urlparse(self.path).path)
+        m = re.fullmatch(r"/api/arquivos/([^/]+)", rota)
         c = caminho(m.group(1)) if m else None
         if c and os.path.exists(c):
             os.remove(c)
@@ -535,7 +594,7 @@ def csv_celula(valor):
         if valor == int(valor):
             valor = int(valor)
     s = "" if valor is None else str(valor)
-    return '"%s"' % s.replace('"', '""') if re.search(r'[",\n]', s) else s
+    return '"%s"' % s.replace('"', '""') if re.search(r'[",\n\r]', s) else s
 
 
 # ------------------------------------------------- fórmulas (espelha o JS) --
@@ -602,7 +661,11 @@ def calcular_aba(aba):
     linhas = [list(l) for l in aba.get("linhas", [])]
 
     def celula(c, l, prof):
-        if prof > 24 or l >= len(linhas) or c >= len(linhas[l]):
+        # l/c negativos (referência tipo "A0", que vira índice -1) não podem
+        # passar: índice negativo do Python "funciona" contando do fim da
+        # lista, e a última linha da planilha aparecia como resposta de uma
+        # referência inválida em vez de virar 0.
+        if prof > 24 or l < 0 or c < 0 or l >= len(linhas) or c >= len(linhas[l]):
             return 0
         bruto = linhas[l][c]
         if isinstance(bruto, str) and bruto.startswith("="):
@@ -642,7 +705,14 @@ def calcular_aba(aba):
                 elif parte:
                     # qualquer outro argumento é uma expressão: resolve antes
                     vals.append(_num(avaliar(parte, prof)))
-            return repr(f(vals))
+            try:
+                # MAIOR/MENOR estouram IndexError com k maior que o intervalo;
+                # POT estoura OverflowError com base/expoente grandes demais.
+                # Uma fórmula ruim vira "#ERRO" NESSA célula, não derruba a
+                # exportação inteira (mesma regra do eval() logo abaixo).
+                return repr(f(vals))
+            except Exception:
+                return "#ERRO"
 
         # repete até esgotar: resolve de dentro para fora em fórmula aninhada
         e, voltas = expr, 0