primocode 9.6.0 → 9.7.0

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v9.6.0
+# PrimoCode v9.7.0
 
 Agente de engenharia brasileiro para o terminal, no estilo Claude Code.
 Cria arquivos de verdade, roda comandos, **controla o navegador e o desktop** —
@@ -9,7 +9,7 @@ OpenRouter, e cada apelido (`top`/`main`/`fast`) é uma **corrente**: se um mode
 está no limite de pedidos, o próximo atende. Você não vê o erro, e não paga nada.
 
 ```
- ▐▛███▜▌   Primo Code v9.6.0
+ ▐▛███▜▌   Primo Code v9.7.0
 ▝▜█████▛▘  Bem-vindo de volta, Joel
   ▘▘ ▝▝    ~/primocode  · /dir <pasta> muda
 ```

package/lib/act.js

@@ -429,12 +429,48 @@ function motivoDaParada({ voltas, voltasEmFalso, falhasPendentes, travou }) {
     return 'Parei sem concluir e sem explicação do modelo. Tente pedir de novo, em partes menores.';
 }
 
+/* ── O MAPA DO PROJETO ───────────────────────────────────────────────────
+ * "Continua o jogo" num projeto de vinte arquivos: o agente começava às
+ * cegas, gastava uma volta listando a pasta — ou, pior, escrevia um index.html
+ * novo por cima do que existia. Agora ele recebe, junto da memória, a lista dos
+ * arquivos do projeto (até 80, sem node_modules nem build), e sabe de saída
+ * onde está cada coisa. Só em pasta de projeto: a raiz ~/primocode lista
+ * outros projetos, não este. */
+const PULAR_NO_MAPA = new Set(['node_modules', '.git', 'dist', 'build', '.next', '.nuxt', 'out',
+    '.cache', 'coverage', '__pycache__', '.venv', 'venv', '.turbo', '.vercel', '.idea', '.vscode']);
+
+function mapaDoProjeto(dir, limite = 80) {
+    const path = require('path');
+    const fs = require('fs');
+    if (!dir || path.resolve(dir) === path.resolve(cfg.ROOT_DIR)) return '';
+    const achados = [];
+    const andar = (atual, fundo) => {
+        if (fundo > 4 || achados.length >= limite) return;
+        let itens = [];
+        try { itens = fs.readdirSync(atual, { withFileTypes: true }); } catch { return; }
+        itens.sort((a, b) => (a.isDirectory() === b.isDirectory() ? a.name.localeCompare(b.name) : a.isDirectory() ? 1 : -1));
+        for (const it of itens) {
+            if (achados.length >= limite) return;
+            if (PULAR_NO_MAPA.has(it.name) || (it.name.startsWith('.') && it.name !== '.env.example')) continue;
+            const cheio = path.join(atual, it.name);
+            if (it.isDirectory()) andar(cheio, fundo + 1);
+            else if (it.name !== 'memory.md') achados.push(path.relative(dir, cheio));
+        }
+    };
+    andar(dir, 0);
+    if (!achados.length) return '';
+    const mais = achados.length >= limite ? `\n… (mais arquivos — use glob para achar)` : '';
+    return `Arquivos que JÁ existem neste projeto (edite-os em vez de recriar):\n${achados.join('\n')}${mais}`;
+}
+
 function buildMemoryContext(projectDir, projectName) {
     const parts = [];
     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 || 'projeto'}/memory.md]\n${projeto}`);
+    const mapa = mapaDoProjeto(projectDir);
+    if (mapa) parts.push(`[${projectName || 'projeto'}/arquivos]\n${mapa}`);
     return parts.join('\n\n');
 }
 
@@ -460,6 +496,9 @@ async function runAct(userPrompt, opts) {
            Antes ela ia colada no texto, e a memória do projeto enchia de
            "[MODO VOZ] A sua resposta vai ser lida em voz alta…". */
         instrucao = '',
+        /* Quem abre a página para conferir antes do "pronto". Injetável pelo
+           mesmo motivo do `motor`: o teste mede a regra sem abrir um Chrome. */
+        medirPagina = (dir) => require('./pipeline.js').medirNoNavegador(dir),
     } = opts || {};
 
     // A pasta de projeto só nasce quando o agente for mesmo MEXER EM ARQUIVO.
@@ -481,6 +520,37 @@ async function runAct(userPrompt, opts) {
     };
     const falhasPendentes = [];
     let tentativasDeEncerrar = 0;
+    /* ── CONFERIR ANTES DE DIZER "PRONTO" ───────────────────────────────
+     * Mexeu em página (html, css, js) nesta tarefa? Antes de aceitar o
+     * `finish`, o PrimoCode abre a página num navegador invisível e olha: tela
+     * em branco, erro de JavaScript, recurso que não carregou. Achou problema,
+     * a tarefa volta para o agente com o relato — uma vez só, para não virar
+     * laço. É a diferença entre "pronto!" e "pronto, e abre". */
+    let mexeuNaPagina = false;       // mexeu desde a última conferência?
+    let conferencias = 0;            // até duas: entregar, e conferir o conserto
+    let avisoDaPagina = '';          // o que ainda estava quebrado na última
+    /* Abre a página e devolve o relato quando é para VOLTAR (achou problema e
+       ainda cabe uma volta); null quando é para entregar. O que ficar
+       quebrado na última conferência fica em `avisoDaPagina`, e a entrega sai
+       com ele — nunca "pronto" seco sobre uma página com erro. Vale para os
+       dois jeitos de terminar: a ferramenta finish e a resposta em texto. */
+    const conferirPagina = async () => {
+        if (subagent || !mexeuNaPagina || conferencias >= 2 || PARAR) return null;
+        conferencias++;
+        mexeuNaPagina = false;
+        let medida = null;
+        try {
+            fala.pensamento('abrindo a página para conferir antes de entregar', profundidade);
+            medida = await medirPagina(pastaAtual);
+        } catch { medida = null; }
+        if (!medida || !medida.testou) return null;
+        avisoDaPagina = medida.limpo ? ''
+            : String(medida.relato || '').split('\n').filter((l) => /·|BRANCO/.test(l)).slice(0, 3).join(' ');
+        if (medida.limpo) { fala.pensamento('a página abriu sem erro', profundidade); return null; }
+        return conferencias >= 2 ? null : medida.relato;
+    };
+    const comAviso = (texto) => (avisoDaPagina
+        ? `${texto}\n\nAtenção: abri a página e ela ainda tem problema — ${avisoDaPagina.trim()}` : texto);
     // Quem já foi chamado, e quantas vezes. Ver lib/repeticao.js.
     const jaChamado = repeticao.novo();
     /* O livro deste pedido: arquivos, comandos, links, testes e falhas. Sai
@@ -822,6 +892,21 @@ async function runAct(userPrompt, opts) {
                 finalText = '';
                 continue;
             }
+            // Terminou falando, sem chamar finish: confere a página do mesmo jeito.
+            if (finalText) {
+                const relato = await conferirPagina();
+                if (relato) {
+                    messages.push({ role: 'assistant', content: finalText });
+                    messages.push({
+                        role: 'user',
+                        content: `AINDA NÃO. Abri a página para conferir e ela tem problema:\n${relato}\n\n`
+                            + 'Conserte (leia o arquivo antes de editar) e finalize de novo.',
+                    });
+                    finalText = '';
+                    continue;
+                }
+                finalText = comAviso(finalText);
+            }
             if (!subagent) {
                 if (fluxo) fluxo.fechar();
                 else fala.resposta(finalText);
@@ -873,6 +958,18 @@ async function runAct(userPrompt, opts) {
 
         for (const tc of toolCalls) {
             if (PARAR) break;
+            if (tc.name === 'finish') {
+                const relato = await conferirPagina();
+                if (relato) {
+                    messages.push({
+                        role: 'tool',
+                        tool_call_id: tc.id,
+                        content: `AINDA NÃO. Abri a página para conferir e ela tem problema:\n${relato}\n\n`
+                            + 'Conserte (leia o arquivo antes de editar) e chame finish de novo.',
+                    });
+                    continue;
+                }
+            }
             if (tc.name === 'finish') {
                 // Encerrar com falha pendente é como o agente dizia "pronto!"
                 // sem ter mudado nada. Devolvemos a tarefa para ele.
@@ -887,7 +984,7 @@ async function runAct(userPrompt, opts) {
                     continue;
                 }
                 algoRodou = true;
-                finished = (tc.arguments && tc.arguments.summary) || 'Concluído.';
+                finished = comAviso((tc.arguments && tc.arguments.summary) || 'Concluído.');
                 messages.push({ role: 'tool', tool_call_id: tc.id, content: 'ok' });
                 continue;
             }
@@ -987,6 +1084,10 @@ async function runAct(userPrompt, opts) {
             // nasceu, mudou, rodou e falhou. Narrar sozinho não basta — numa
             // tarefa de trinta ações, a primeira já saiu da tela.
             registro.anotar(livro, tc.name, tc.arguments, result);
+            if (result && result.ok !== false && catalogo.criaProjeto(tc.name, tc.arguments)
+                && /\.(html?|css|m?jsx?|tsx?|vue|svelte)$/i.test(String((tc.arguments && tc.arguments.path) || ''))) {
+                mexeuNaPagina = true;
+            }
 
             // Uma escrita bem-sucedida limpa a dívida — mas só a do MESMO
             // arquivo. Escrever algo sem relação (ou um run_shell qualquer)

package/lib/cursor.js

@@ -39,10 +39,16 @@ function pythonComQuartz() {
     if (!py) return { py: null };
     try {
         execFileSync(py, ['-c', 'import Quartz, AppKit, PyObjCTools'], { stdio: 'ignore', timeout: 20000 });
-        return { py, tem: true };
     } catch {
         return { py, tem: false };
     }
+    // O Vision (ler a tela) é um extra: sem ele o mouse funciona igual.
+    try {
+        execFileSync(py, ['-c', 'import Vision'], { stdio: 'ignore', timeout: 20000 });
+        return { py, tem: true, vision: true };
+    } catch {
+        return { py, tem: true, vision: false };
+    }
 }
 
 /** Sobe o processo do cursor, instalando o PyObjC se faltar. Uma vez. */
@@ -54,8 +60,11 @@ function subir() {
         if (!py) { semCursor = 'sem Python 3'; return false; }
         if (!tem) {
             const voz = require('./voz.js');
-            const r = await voz.instalar(py, ['pyobjc-framework-Quartz', 'pyobjc-framework-Cocoa']);
+            const r = await voz.instalar(py, ['pyobjc-framework-Quartz', 'pyobjc-framework-Cocoa', 'pyobjc-framework-Vision']);
             if (!r.ok || !pythonComQuartz().tem) { semCursor = `não instalou o PyObjC: ${r.error || ''}`; return false; }
+        } else if (!pythonComQuartz().vision) {
+            // Falhar aqui não impede o cursor; só "clicar pelo texto" fica sem OCR.
+            await require('./voz.js').instalar(py, ['pyobjc-framework-Vision']).catch(() => {});
         }
         return await new Promise((resolve) => {
             proc = spawn(py, ['-m', 'primo_voz.cursor'], {

package/lib/tools.js

@@ -32,6 +32,14 @@ async function peloCursor(cmd, args, reserva) {
 
 function numero(v) { const n = Number(v); return Number.isFinite(n) ? n : null; }
 
+/** Os textos visíveis na tela, pelo OCR do cursor, no formato dos elementos. */
+async function textosDaTela() {
+    if (!cursor.disponivel()) return { ok: false, error: 'ler a tela é só no macOS' };
+    const r = await cursor.mandar('ler_tela', {}, 30000);
+    if (!r.ok) return { ok: false, error: r.error || 'não consegui ler a tela' };
+    return { ok: true, elementos: (r.textos || []).map((t) => ({ nome: t.texto, tipo: 'texto na tela', x: t.x, y: t.y })) };
+}
+
 async function clicarPeloCursor(x, y, { botao = 'left', duplo = false, rotulo } = {}) {
     const [nx, ny] = [numero(x), numero(y)];
     if (nx == null || ny == null) return { ok: false, error: `Coordenada inválida: x=${x}, y=${y}` };
@@ -643,8 +651,16 @@ async function despachar(name, args, ctx) {
                 return desktop.listWindows();
             case 'desktop_focus':
                 return desktop.focusWindow(args.window || args.title || '');
-            case 'desktop_elements':
-                return desktop.uiElements(args.window);
+            case 'desktop_elements': {
+                const lidos = desktop.uiElements(args.window);
+                if (!cursor.disponivel()) return lidos;
+                // No Mac, junto dos botões da acessibilidade vão os TEXTOS
+                // que aparecem na tela (OCR), com a posição de cada um.
+                const naTela = await textosDaTela();
+                if (!naTela.ok) return lidos.ok ? { ...lidos, telaIndisponivel: naTela.error } : lidos;
+                return { ...(lidos.ok ? lidos : { ok: true, elementos: [] }),
+                    textosNaTela: naTela.elementos.slice(0, 120).map((e) => ({ texto: e.nome, x: e.x, y: e.y })) };
+            }
             case 'desktop_click_element': {
                 if (!cursor.disponivel()) {
                     return desktop.clickElement(args.name || args.text || '', {
@@ -656,11 +672,21 @@ async function despachar(name, args, ctx) {
                 const pedido = String(args.name || args.text || '').trim();
                 if (!pedido) return { ok: false, error: 'Diga o nome do elemento (o texto do botão, ícone ou campo).' };
                 const lidos = desktop.uiElements(args.window);
-                if (!lidos.ok) return lidos;
-                const alvo = desktop.escolherElemento(lidos.elementos, pedido);
+                let alvo = lidos.ok ? desktop.escolherElemento(lidos.elementos, pedido) : null;
+                /* A acessibilidade não achou (ou o app não expõe botões): procura
+                   o TEXTO na tela, pelo OCR do cursor. É o que faz "clica em
+                   Salvar" funcionar em qualquer app, como no Jarvis. */
+                let naTela = null;
+                if (!alvo) {
+                    naTela = await textosDaTela();
+                    if (naTela.ok) alvo = desktop.escolherElemento(naTela.elementos, pedido);
+                }
                 if (!alvo) {
-                    return { ok: false, error: `Nenhum elemento parecido com "${pedido}" na janela "${lidos.janela}".`,
-                        elementosDisponiveis: lidos.elementos.slice(0, 40).map((e) => e.nome),
+                    return { ok: false,
+                        error: `Nenhum elemento parecido com "${pedido}"${lidos.ok ? ` na janela "${lidos.janela}"` : ''}, nem como texto na tela.`,
+                        elementosDisponiveis: [...(lidos.ok ? lidos.elementos : []), ...((naTela && naTela.ok) ? naTela.elementos : [])]
+                            .slice(0, 50).map((e) => e.nome),
+                        ...(naTela && !naTela.ok ? { telaIndisponivel: naTela.error } : {}),
                         comoCorrigir: 'Chame de novo com um nome de "elementosDisponiveis", copiado literalmente.' };
                 }
                 const r = await clicarPeloCursor(alvo.x, alvo.y, {

package/lib/voz.js

@@ -430,6 +430,7 @@ const OPCIONAIS = () => [
     ...(process.platform === 'darwin' ? [
         ['AppKit', 'pyobjc-framework-Cocoa', 'a orb transparente do macOS'],
         ['Quartz', 'pyobjc-framework-Quartz', 'o cursor do Primo na tela'],
+        ['Vision', 'pyobjc-framework-Vision', 'ler o texto da tela (clicar pelo nome em qualquer app)'],
     ] : []),
 ];
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "9.6.0",
+  "version": "9.7.0",
   "description": "PrimoCode — agente de engenharia com IA e cursor próprio. Requer conta Conecta Primo AI (Premium ou Super). 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/entrada.test.js && node test/transparencia.test.js && node test/permissao.test.js && node test/compatibilidade.test.js && node test/skills.test.js && node test/estudio.test.js && node test/voz.test.js && node test/modo.test.js && node test/pasta.test.js && node test/projeto.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/effort.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/pipeline.test.js && node test/app.test.js && node test/aplicativo.test.js && node test/conta.test.mjs && node test/nuvem.test.js && node test/prazo.test.js && node test/primeira-vez.test.js && node test/janela.test.js && node test/fala.test.js && node test/especialistas.test.js && node test/empurrao.test.js && node test/terminal-novo.test.js && node test/markdown.test.js && node test/coerencia.test.js"
+    "test": "node test/tools.test.js && node test/ui.test.js && node test/entrada.test.js && node test/transparencia.test.js && node test/permissao.test.js && node test/compatibilidade.test.js && node test/skills.test.js && node test/estudio.test.js && node test/voz.test.js && node test/modo.test.js && node test/pasta.test.js && node test/projeto.test.js && node test/conferir.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/effort.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/pipeline.test.js && node test/app.test.js && node test/aplicativo.test.js && node test/conta.test.mjs && node test/nuvem.test.js && node test/prazo.test.js && node test/primeira-vez.test.js && node test/janela.test.js && node test/fala.test.js && node test/especialistas.test.js && node test/empurrao.test.js && node test/terminal-novo.test.js && node test/markdown.test.js && node test/coerencia.test.js"
   },
   "engines": {
     "node": ">=18.17.0"

package/skills/projeto-no-github/SKILL.md

@@ -0,0 +1,32 @@
+---
+nome: Projeto no GitHub
+descricao: criar o repositório, subir o projeto e abrir pull request pelo gh
+quando: github, repositório, repositorio, repo, subir pro github, sobe pro github, pull request, pr, gh, versionar, push, clonar
+autor: PrimoCode
+---
+Tudo pelo `gh` (GitHub CLI) e pelo `git`, rodando no terminal do projeto.
+
+**Antes de tudo:** `gh auth status`. Sem login, diga à pessoa para rodar
+`gh auth login` e pare — NUNCA peça token ou senha no chat.
+
+**Projeto novo no GitHub:**
+1. Se não houver `.git`: `git init -b main`.
+2. `.gitignore` antes do primeiro commit (node_modules, dist, build, .env,
+   .DS_Store, __pycache__, .venv). Confira com `git status` que nenhum segredo
+   ou pasta pesada vai junto.
+3. README curto: o que é, como rodar.
+4. `git add -A` e `git commit -m "<o que o projeto é>"`.
+5. `gh repo create <nome-do-projeto> --private --source . --push` (privado
+   por padrão; público só se a pessoa pedir). Diga o link do repositório.
+
+**Mudança num repositório que já existe (pull request):**
+1. `git status` e `git pull` primeiro. Branch nova com nome que diz a
+   mudança: `git switch -c feat/<assunto>`.
+2. Rode o que o projeto roda (teste, lint, build) antes de commitar.
+3. Commit com a mensagem dizendo o que MUDA; `git push -u origin <branch>`.
+4. `gh pr create --fill` (ou `--title` e `--body` dizendo o que e por quê).
+   Diga o link do PR.
+
+**Nunca** faça `push --force` em `main`, nunca apague branch dos outros, nunca
+commite `.env`. Conflito: resolva lendo os dois lados, não escolhendo um às
+cegas.

package/skills/publicar-na-internet/SKILL.md

@@ -0,0 +1,36 @@
+---
+nome: Publicar na internet
+descricao: colocar o projeto no ar com um link público, conferido depois de subir
+quando: publicar, publica, deploy, colocar no ar, coloca no ar, no ar, subir o site, sobe o site, hospedar, hospedagem, link público, link publico, vercel, netlify, github pages, railway, dominio, domínio
+autor: PrimoCode
+---
+Publicar é terminar com um LINK que abre. Nada de "pronto, publicado" sem ter
+aberto o link.
+
+**1. Descubra o que é o projeto** (leia a pasta): página estática (index.html
+solto), app com build (package.json com `build`: Vite, React, Next) ou servidor
+(Express, Python). Rode o build antes (`npm install` e `npm run build`) e
+conserte o que quebrar — publicar build quebrado é publicar tela branca.
+
+**2. Escolha onde, nesta ordem, conferindo o login ANTES:**
+- **Vercel** (sites e Next): `npx --yes vercel whoami`. Logado →
+  `npx --yes vercel --prod --yes` na pasta do projeto. A URL de produção sai no
+  fim da saída.
+- **Netlify** (sites estáticos): `npx --yes netlify-cli status`. Logado →
+  `npx --yes netlify-cli deploy --prod --dir <pasta do build ou .>`.
+- **GitHub Pages** (só estático, sem build de servidor): `gh auth status`.
+  Logado → publique o repositório (ver a skill "Projeto no GitHub") e ligue o
+  Pages com `gh api -X POST repos/<dono>/<repo>/pages -f "source[branch]=main" -f "source[path]=/"`.
+- **Servidor** (API, backend): Railway (`npx --yes @railway/cli whoami`, depois
+  `railway up`) ou Render. Precisa de conta; não invente.
+
+**Sem login em nenhum:** NÃO peça senha nem token no chat. Diga à pessoa, em
+uma frase, o comando para ela entrar (ex.: `npx vercel login`) e pare ali. É
+ela quem entra na conta dela.
+
+**3. Confira:** abra a URL publicada com browser_open e leia a página. Só diga
+que está no ar se ela abriu com o conteúdo certo. Termine dizendo o LINK.
+
+**Nunca** publique `.env`, chave ou senha: confira se `.gitignore` e o
+`.vercelignore`/`.netlifyignore` os deixam de fora. Variáveis secretas vão no
+painel do serviço (ou `vercel env add`), não no código.

package/voz/primo_voz/cursor.py

@@ -171,6 +171,72 @@ def digitar(texto: str) -> None:
             time.sleep(0.008)
 
 
+# ── Ler a tela (OCR) ──────────────────────────────────────────────────────
+# "Clicar no texto X" em QUALQUER app, e não só nos que expõem botões pela
+# acessibilidade: fotografa a tela e reconhece o texto com o Vision do macOS
+# (o mesmo do Jarvis, motor/screen.py). Cada trecho volta com o CENTRO em
+# pontos da tela — a mesma unidade dos cliques.
+
+def tela_liberada() -> bool:
+    try:
+        return bool(Quartz.CGPreflightScreenCaptureAccess())
+    except Exception:
+        return True
+
+
+def ler_tela(largura: float, altura: float, arquivo: str = "") -> dict:
+    try:
+        import Vision
+    except Exception:
+        return {"ok": False, "error": "falta o pyobjc-framework-Vision para ler a tela"}
+    if arquivo:
+        # Só para o teste: lê uma imagem do disco em vez da tela.
+        from Foundation import NSURL
+        fonte = Quartz.CGImageSourceCreateWithURL(NSURL.fileURLWithPath_(arquivo), None)
+        img = Quartz.CGImageSourceCreateImageAtIndex(fonte, 0, None) if fonte else None
+    else:
+        if not tela_liberada():
+            try:
+                Quartz.CGRequestScreenCaptureAccess()
+            except Exception:
+                pass
+            return {"ok": False, "permissaoTela": False,
+                    "error": "o macOS não deixou ver a tela. Libere o Terminal (ou o app de onde você "
+                             "abriu o PrimoCode) em Ajustes do Sistema > Privacidade e Segurança > "
+                             "Gravação de Tela, e peça de novo."}
+        img = Quartz.CGWindowListCreateImage(Quartz.CGRectInfinite, Quartz.kCGWindowListOptionOnScreenOnly,
+                                             Quartz.kCGNullWindowID, Quartz.kCGWindowImageDefault)
+    if img is None:
+        return {"ok": False, "error": "não consegui fotografar a tela"}
+
+    pedido = Vision.VNRecognizeTextRequest.alloc().init()
+    pedido.setRecognitionLevel_(Vision.VNRequestTextRecognitionLevelAccurate)
+    pedido.setUsesLanguageCorrection_(True)
+    try:
+        pedido.setRecognitionLanguages_(["pt-BR", "en-US"])
+    except Exception:
+        pass
+    leitor = Vision.VNImageRequestHandler.alloc().initWithCGImage_options_(img, None)
+    ok, erro = leitor.performRequests_error_([pedido], None)
+    if not ok:
+        return {"ok": False, "error": f"o Vision não leu a tela: {erro}"}
+    textos = []
+    for obs in (pedido.results() or []):
+        candidatos = obs.topCandidates_(1)
+        if not candidatos:
+            continue
+        texto = str(candidatos[0].string()).strip()
+        if not texto:
+            continue
+        bb = obs.boundingBox()      # normalizado, origem embaixo à esquerda
+        cx = (bb.origin.x + bb.size.width / 2) * largura
+        cy = (1 - (bb.origin.y + bb.size.height / 2)) * altura
+        textos.append({"texto": texto, "x": round(cx), "y": round(cy),
+                       "confianca": round(float(candidatos[0].confidence()), 2)})
+    textos.sort(key=lambda t: (t["y"], t["x"]))
+    return {"ok": True, "textos": textos}
+
+
 # ── A janela do cursor ──────────────────────────────────────────────────────
 
 class VistaCursor(NSView):
@@ -431,6 +497,8 @@ def executar(cur: Cursor, msg: dict) -> dict:
         return {"ok": ok}
     if cmd == "tamanho":
         return {"ok": True, "largura": int(cur.largura), "altura": int(cur.altura)}
+    if cmd == "ler_tela":
+        return ler_tela(cur.largura, cur.altura, str(msg.get("arquivo") or ""))
     if cmd == "rotulo":
         cur._ui(rotulo=str(msg.get("texto") or "")[:48], visivel=True, x=posicao()[0], y=posicao()[1])
         return {"ok": True}