terminal-smart-cli 0.32.0

package/lib/meta.js

@@ -0,0 +1,1199 @@
+// ts meta — MISSÃO: objetivo grande rodando em rodadas até terminar (modo noturno).
+// Receita do artigo de harnesses da Anthropic (a mesma do /meta do app):
+//   1) o objetivo vira um CHECKLIST de itens verificáveis persistido em .ts-meta.json
+//   2) cada rodada roda o agente local com CONTEXTO ZERADO atacando 1 item
+//   3) um marcador barato (flash-lite) só aprova item com EVIDÊNCIA no resultado
+//   4) "terminou" é MECÂNICO: todos os itens passaram — nunca opinião do modelo
+// Sobrevive a queda (estado em arquivo, `ts meta` retoma), respeita teto de
+// créditos/rodadas, e nunca trava: item que falha 2x é marcado como bloqueado.
+const fs = require('fs');
+const path = require('path');
+const cp = require('child_process');
+const compactor = require('./compactor');
+const { api, ApiError } = require('./api');
+// Teto de IA estourado (free/plano) no gateway → 402 (ou 429 com type cost_cap). Os helpers de
+// IA da missão DEVEM lançar (não retornar vazio em silêncio), senão a missão desperdiça rodadas
+// fingindo trabalhar. O run() pausa (estado salvo = resumível) e mostra CTA de upgrade.
+function _capGuard(res, j) {
+  const cap = res.status === 402 || (res.status === 429 && /cost_cap|tenant_cost|teto|insufficient|quota|no_credits/i.test(JSON.stringify((j && j.error) || j || '')));
+  if (cap) throw new ApiError((j && (j.error?.message || j.message)) || 'no_credits', { status: res.status, code: 'no_credits' });
+}
+const agent = require('./agent');
+
+const FILE = '.ts-meta.json';
+const MAX_ATTEMPTS_PER_ITEM = 2;
+const MAX_ESCALATIONS = 3;   // quantas vezes chamamos o modelo CARO "pensador"
+const STAGNATION_LIMIT = 3;  // rodadas SEM nenhum progresso → watchdog corta
+const MAX_VISUAL_FIXES = 5;  // rodadas de polimento VISUAL (o olho crítico) — evita perfeccionismo infinito
+const MAX_VISUAL_FIXES_FLUTTER = 3; // Flutter: rebuild é MUITO mais pesado/lento → teto menor de polimento (economia)
+const VISUAL_ESCALATE_AT = 2; // após N reprovações visuais, a MÃO do fix vira o modelo forte (grok) — o deepseek erra layout complexo
+const MAX_BUILD_FIXES = 12; // rodadas extras de correção de build antes de desistir
+
+// Detecta se o projeto é COMPILÁVEL e devolve como compilar + como saber que passou.
+// Procura recursivamente (modelos costumam aninhar em uma subpasta tipo MultiApps/).
+function detectBuild(root, depth = 0) {
+  let list; try { list = fs.readdirSync(root, { withFileTypes: true }); } catch (_) { return null; }
+  const has = (n) => list.some(e => e.name === n);
+  if (has('gradlew.bat') || has('gradlew') || has('settings.gradle') || has('settings.gradle.kts')) {
+    const gw = process.platform === 'win32' ? '"' + path.join(root, 'gradlew.bat') + '"' : path.join(root, 'gradlew');
+    return { cwd: root, cmd: gw + ' assembleDebug --no-daemon', artifact: 'app/build/outputs/apk/debug/app-debug.apk', kind: 'android' };
+  }
+  if (has('pubspec.yaml')) return { cwd: root, cmd: 'flutter build apk --debug', artifact: 'build/app/outputs/flutter-apk/app-debug.apk', kind: 'flutter' };
+  if (has('package.json')) {
+    try {
+      const pj = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+      const sc = pj.scripts || {};
+      if (sc.build) return { cwd: root, cmd: 'npm run build', artifact: null, kind: 'node' };
+      // projeto WEB (server sem compilação): tem start/dev OU um server.js/app.js/index.js → gate WEB
+      const serverFile = ['server.js', 'app.js', 'index.js', 'src/server.js', 'src/index.js', 'src/app.js'].find(f => has(f) || fs.existsSync(path.join(root, f)));
+      if (sc.start || sc.dev || serverFile) {
+        const startCmd = sc.start ? 'npm start' : sc.dev ? 'npm run dev' : 'node ' + serverFile;
+        return { cwd: root, cmd: startCmd, artifact: null, kind: 'web', startCmd, port: _detectPort(root, serverFile) };
+      }
+    } catch (_) {}
+  }
+  if (depth < 3) for (const e of list) if (e.isDirectory() && !['build', '.gradle', 'node_modules', '.git'].includes(e.name)) { const r = detectBuild(path.join(root, e.name), depth + 1); if (r) return r; }
+  return null;
+}
+
+// O HARNESS é dono da toolchain: modelos fazem o CÓDIGO mas não provisionam o
+// gradle-wrapper.jar (binário) nem lidam com Java novo demais. Antes de compilar,
+// garante wrapper + gradlew + JDK compatível — assim o build depende só do código.
+function _findJdk(maxMajor) {
+  const os = require('os');
+  const cands = [
+    'C:/Program Files/Android/Android Studio/jbr',
+    'C:/Program Files/Android/Android Studio/jre',
+    process.env.JAVA_HOME_17, process.env.JAVA_HOME_21,
+  ].filter(Boolean);
+  for (const p of cands) { try { if (fs.existsSync(path.join(p, 'bin', 'java.exe')) || fs.existsSync(path.join(p, 'bin', 'java'))) return p; } catch (_) {} }
+  return null;
+}
+function _download(url, dest) {
+  try { cp.execSync(`powershell -NoProfile -Command "Invoke-WebRequest -Uri '${url}' -OutFile '${dest}' -UseBasicParsing"`, { stdio: 'ignore', timeout: 60000 }); return fs.existsSync(dest) && fs.statSync(dest).size > 5000; }
+  catch (_) { try { cp.execSync(`curl -fsSL "${url}" -o "${dest}"`, { stdio: 'ignore', timeout: 60000 }); return fs.existsSync(dest); } catch (__) { return false; } }
+}
+// Acha o flutter.bat instalado (PATH ou locais comuns) ou null.
+function _findFlutter() {
+  const home = require('os').homedir();
+  const cands = ['C:/flutter/bin/flutter.bat', 'C:/src/flutter/bin/flutter.bat', path.join(home, 'flutter/bin/flutter.bat'), path.join(home, 'AppData/Local/flutter/bin/flutter.bat')];
+  for (const c of cands) if (fs.existsSync(c)) return c;
+  try { const w = cp.execSync('where flutter', { encoding: 'utf8', timeout: 8000 }).split('\n')[0].trim(); if (w && fs.existsSync(w)) return w; } catch (_) {}
+  return null;
+}
+// Garante o Flutter SDK: se não achar, INSTALA (git clone stable) — o harness provisiona.
+function ensureFlutter(b, onAlert) {
+  let fb = _findFlutter();
+  if (!fb) {
+    const target = 'C:/flutter';
+    try {
+      if (onAlert) onAlert({ type: 'setup', text: '📥 ts: Flutter SDK não encontrado — instalando (git clone stable, ~1GB, pode levar alguns minutos)…' });
+      cp.execSync(`git clone https://github.com/flutter/flutter.git -b stable --depth 1 "${target}"`, { stdio: 'ignore', timeout: 900000 });
+      fb = path.join(target, 'bin', 'flutter.bat');
+    } catch (_) {}
+  }
+  if (fb && fs.existsSync(fb)) {
+    try { cp.execSync(`"${fb}" --version`, { stdio: 'ignore', timeout: 300000 }); } catch (_) {} // 1º run baixa o dart sdk
+    b.cmd = `"${fb}" build apk --debug`;
+    b.artifact = 'build/app/outputs/flutter-apk/app-debug.apk';
+    return true;
+  }
+  return false;
+}
+function ensureToolchain(b, onAlert) {
+  if (b.kind === 'flutter') { ensureFlutter(b, onAlert); return; }
+  if (b.kind !== 'android') return;
+  const root = b.cwd, GV = '8.10.2';
+  try {
+    // 1) wrapper properties
+    const wdir = path.join(root, 'gradle', 'wrapper');
+    fs.mkdirSync(wdir, { recursive: true });
+    const props = path.join(wdir, 'gradle-wrapper.properties');
+    if (!fs.existsSync(props)) fs.writeFileSync(props, `distributionBase=GRADLE_USER_HOME\ndistributionPath=wrapper/dists\ndistributionUrl=https\\://services.gradle.org/distributions/gradle-${GV}-bin.zip\nzipStoreBase=GRADLE_USER_HOME\nzipStorePath=wrapper/dists\n`);
+    // 2) wrapper jar (binário — baixa se faltar ou for inválido)
+    const jar = path.join(wdir, 'gradle-wrapper.jar');
+    if (!fs.existsSync(jar) || fs.statSync(jar).size < 10000) _download(`https://raw.githubusercontent.com/gradle/gradle/v${GV}/gradle/wrapper/gradle-wrapper.jar`, jar);
+    // 3) gradlew.bat (texto — baixa se faltar)
+    const gwbat = path.join(root, 'gradlew.bat');
+    if (!fs.existsSync(gwbat)) _download(`https://raw.githubusercontent.com/gradle/gradle/v${GV}/gradlew.bat`, gwbat);
+    // 4) local.properties com sdk.dir em BARRA NORMAL (armadilha clássica: barra
+    //    invertida simples em .properties é escape → "sintaxe do nome incorreta").
+    const sdk = (process.env.ANDROID_HOME || process.env.ANDROID_SDK_ROOT || path.join(require('os').homedir(), 'AppData', 'Local', 'Android', 'Sdk')).replace(/\\/g, '/');
+    const lp = path.join(root, 'local.properties');
+    let needSdk = true;
+    try { if (fs.existsSync(lp)) { const cur = fs.readFileSync(lp, 'utf8'); const m = cur.match(/^sdk\.dir=(.+)$/m); if (m && !m[1].includes('\\') && fs.existsSync(m[1].trim())) needSdk = false; } } catch (_) {}
+    if (needSdk && fs.existsSync(sdk)) fs.writeFileSync(lp, 'sdk.dir=' + sdk + '\n');
+    // 5) JDK compatível: Gradle 8.10 não roda em Java muito novo. Considera SÓ linha
+    //    ATIVA de org.gradle.java.home (ignora comentada com #).
+    const gp = path.join(root, 'gradle.properties');
+    let g = fs.existsSync(gp) ? fs.readFileSync(gp, 'utf8') : '';
+    const hasActiveJava = /^\s*org\.gradle\.java\.home\s*=/m.test(g);
+    if (!hasActiveJava) { const jdk = _findJdk(); if (jdk) { g += `\norg.gradle.java.home=${jdk.replace(/\\/g, '/')}\n`; fs.writeFileSync(gp, g); g = fs.readFileSync(gp, 'utf8'); } }
+    if (!/android\.useAndroidX\s*=\s*true/.test(g)) fs.appendFileSync(gp, 'android.useAndroidX=true\n');
+    // recomputa o cmd com o gradlew agora garantido
+    b.cmd = (process.platform === 'win32' ? '"' + gwbat + '"' : path.join(root, 'gradlew')) + ' assembleDebug --no-daemon';
+  } catch (_) {}
+}
+
+// Roda o build de verdade e devolve {ok, out} — out compactado pro contexto.
+// IMPORTANTE: o gradlew.bat chamado com aspas via cmd às vezes retorna EXIT 0 mesmo
+// falhando (armadilha de batch no Windows). Por isso a falha é detectada pela SAÍDA
+// (BUILD FAILED / error:) e pela existência do artefato — nunca só pelo exit code.
+function runBuild(b) {
+  if (b.kind === 'web') return { ok: true, out: 'WEB (sem compilação — verificado pelo gate web)' }; // web não compila; o gate web sobe o servidor
+  let out = '', threw = false;
+  // 2>&1: mescla stderr no stdout — os erros do aapt2 vão pro stderr, e como o batch
+  // pode retornar exit 0 mesmo falhando, sem isso perderíamos os erros reais.
+  try { out = cp.execSync(b.cmd + ' 2>&1', { cwd: b.cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], maxBuffer: 6e7, timeout: 360000 }); }
+  catch (e) { threw = true; out = (e.stdout || '') + '\n' + (e.stderr || ''); }
+  const failedByText = /BUILD FAILED|FAILURE:|^\s*error:|^e: |does not contain a Gradle build|resource .* not found/m.test(out);
+  const apkExists = b.artifact ? fs.existsSync(path.join(b.cwd, b.artifact)) : true;
+  if (!threw && !failedByText && apkExists) return { ok: true, out: 'BUILD OK' };
+  const errs = out.split('\n').filter(l => /error:|^e: |resource .* not found|Unresolved|Caused by|What went wrong|does not contain|FAILURE|cannot find|BUILD FAILED/i.test(l)).slice(0, 40).join('\n');
+  return { ok: false, out: compactor.stripAnsi(errs || out || 'build falhou sem saída legível').slice(0, 3000) };
+}
+
+// Descobre a porta que o servidor web escuta (procura listen(NNNN) nos arquivos de entrada).
+function _detectPort(root, serverFile) {
+  const files = [serverFile, 'server.js', 'app.js', 'index.js', 'src/server.js', 'src/index.js', 'src/app.js', '.env'].filter(Boolean).map(f => path.join(root, f));
+  for (const f of files) {
+    try {
+      const t = fs.readFileSync(f, 'utf8');
+      // pega '.listen(3777' | '.listen(process.env.PORT || 3777' | 'PORT = 3777' | 'PORT = process.env.PORT || 3777' | 'PORT=3777' (.env)
+      const m = t.match(/\.listen\s*\(\s*(?:process\.env\.\w+\s*\|\|\s*)?['"`]?(\d{2,5})/)
+        || t.match(/(?:const|let|var)?\s*PORTA?\s*[=:]\s*(?:process\.env\.\w+\s*\|\|\s*)?['"`]?(\d{2,5})/i)
+        || t.match(/\bPORTA?\s*=\s*(\d{2,5})/i);
+      if (m) return +m[1];
+    } catch (_) {}
+  }
+  return 3000;
+}
+function _findChrome() {
+  const home = require('os').homedir();
+  const cands = ['C:/Program Files/Google/Chrome/Application/chrome.exe', 'C:/Program Files (x86)/Google/Chrome/Application/chrome.exe', path.join(home, 'AppData/Local/Google/Chrome/Application/chrome.exe'), '/usr/bin/google-chrome', '/usr/bin/chromium-browser', '/usr/bin/chromium', '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome'];
+  for (const c of cands) { try { if (fs.existsSync(c)) return c; } catch (_) {} }
+  return null;
+}
+
+// Extrai credenciais do SEED direto do código (o seed cria um usuário demo com email+senha
+// EM TEXTO no script). Serve pro gate web LOGAR e verificar as telas autenticadas. Heurística:
+// acha um email quotado (prefere demo/teste/admin) e uma senha quotada por perto.
+function _seedCreds(cwd) {
+  const cands = ['server.js', 'app.js', 'index.js', 'seed.js', 'init.js', 'init_db.js', 'seed_db.js',
+    'database/seed.js', 'database/init.js', 'database/database.js', 'database/models.js',
+    'db/seed.js', 'db/init.js', 'src/server.js', 'src/seed.js', 'src/index.js', 'src/app.js'];
+  let txt = '';
+  for (const f of cands) { try { const p = path.join(cwd, f); if (fs.existsSync(p)) txt += '\n/*' + f + '*/\n' + fs.readFileSync(p, 'utf8'); } catch (_) {} }
+  if (!txt) return null;
+  const emails = [...txt.matchAll(/['"`]([a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,})['"`]/gi)].map(m => m[1]);
+  if (!emails.length) return null;
+  const email = emails.find(e => /demo|teste|test|admin|exemplo|user/i.test(e)) || emails[0];
+  const idx = txt.indexOf(email);
+  const near = txt.slice(Math.max(0, idx - 200), idx + 260);
+  const bad = s => s === email || /@/.test(s) || /\.(js|css|html|db|png|json|sqlite)$/i.test(s) || /^https?:/i.test(s) || /^[A-Z_]{6,}$/.test(s) || s.includes('/') || s.includes('\\');
+  const pool = [...near.matchAll(/['"`]([^'"`\s]{4,40})['"`]/g)].map(m => m[1]).filter(s => !bad(s));
+  // prefere algo com dígito (senhas costumam ter), depois curto
+  const senha = pool.find(s => /\d/.test(s)) || pool.find(s => s.length <= 24) || pool[0];
+  return (email && senha) ? { email, senha } : null;
+}
+
+// ── GATE WEB (novo, pra portais/APIs Node): sobe o servidor DE VERDADE, checa se a porta
+// responde (senão = erro de inicialização) e — com Chrome headless (puppeteer-core) — carrega
+// a página, captura ERROS DE CONSOLE (ex: "Invalid Date") e tira PRINT pro olho criticar o
+// visual. Se a home for uma TELA DE LOGIN, LOGA com o seed e verifica as telas AUTENTICADAS
+// (senão dashboard/kanban quebrados passariam batido). Dá pra web a MESMA verificação real que apps têm.
+async function webRunGate(b) {
+  const cwd = b.cwd, port = b.port || 3000, url = 'http://localhost:' + port + '/';
+  // instala deps se faltarem
+  try { if (!fs.existsSync(path.join(cwd, 'node_modules'))) { try { cp.execSync('npm install', { cwd, stdio: 'ignore', timeout: 240000 }); } catch (_) {} } } catch (_) {}
+  // sobe o servidor (shell:true resolve npm.cmd no Windows; detached pra matar a árvore)
+  let srv, srvlog = '';
+  try {
+    srv = cp.spawn(b.startCmd, { cwd, detached: process.platform !== 'win32', shell: true, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
+    srv.stdout && srv.stdout.on('data', d => { srvlog += d.toString(); });
+    srv.stderr && srv.stderr.on('data', d => { srvlog += d.toString(); });
+  } catch (e) { return { ok: false, crash: 'não consegui iniciar o servidor: ' + e.message }; }
+  const kill = () => { try { if (process.platform === 'win32') cp.execSync('taskkill /F /T /PID ' + srv.pid, { stdio: 'ignore' }); else { try { process.kill(-srv.pid); } catch (_) { process.kill(srv.pid); } } } catch (_) {} };
+  // checa a porta com o módulo http (sem curl — evita quoting de %{http_code} no cmd)
+  const http = require('http');
+  const ping = () => new Promise(res => { const rq = http.get({ host: '127.0.0.1', port, path: '/', timeout: 3000 }, r => { r.resume(); res(r.statusCode || 0); }); rq.on('error', () => res(0)); rq.on('timeout', () => { rq.destroy(); res(0); }); });
+  let up = false;
+  for (let i = 0; i < 20; i++) {
+    await new Promise(r => setTimeout(r, 1000));
+    const code = await ping();
+    if (code && code < 500) { up = true; break; }
+    if (/error:|throw |cannot find module|EADDRINUSE|listen EACCES|SyntaxError|ReferenceError/i.test(srvlog)) break;
+  }
+  if (!up) { kill(); return { ok: false, crash: 'O servidor web NÃO subiu (a porta ' + port + ' não respondeu). Corrija a inicialização/dependências. Saída do servidor:\n' + srvlog.slice(-1600) }; }
+  // Chrome headless: carrega a página, captura console/pageerror + print + texto quebrado
+  const chrome = _findChrome();
+  let shotFile = null;
+  if (chrome) {
+    try {
+      const puppeteer = require('puppeteer-core');
+      const browser = await puppeteer.launch({ executablePath: chrome, headless: 'new', args: ['--no-sandbox', '--disable-gpu', '--disable-dev-shm-usage'] });
+      const page = await browser.newPage();
+      await page.setViewport({ width: 1280, height: 850 });
+      const errs = [];
+      const _benign = (u) => /favicon\.ico|\.ico(\?|$)|apple-touch-icon|robots\.txt|\/sw\.js|manifest\.json/i.test(String(u || ''));
+      // ERRO DE JS (pageerror) = sempre real. "Failed to load resource" genérico é ignorado
+      // (não traz URL) — quem julga recurso é o response listener, que sabe a URL.
+      page.on('pageerror', e => errs.push('erro de JS: ' + String(e && e.message).slice(0, 200)));
+      page.on('console', m => { const t = m.text(); if (m.type() === 'error' && !/Failed to load resource/i.test(t)) errs.push(t.slice(0, 200)); });
+      // 401/403 = desafio de auth NORMAL (a SPA chama rota protegida antes de logar) — não é bug.
+      // 500+ = erro de servidor REAL; 404 = rota/recurso faltando. Só esses reprovam.
+      page.on('response', r => { const s = r.status(); const u = r.url(); if ((s >= 500 || s === 404) && !_benign(u)) errs.push(`HTTP ${s} em ${u.replace(/^https?:\/\/[^/]+/, '').slice(0, 100)}`); });
+      await page.goto(url, { waitUntil: 'networkidle2', timeout: 20000 }).catch(() => {});
+      await new Promise(r => setTimeout(r, 1800));
+
+      // GATE AUTENTICADO: se a home tem campo de senha (=tela de login), LOGA com o seed e deixa
+      // a SPA carregar as telas internas (dashboard/kanban) — aí os checks abaixo pegam erro
+      // de backend (ex: dashboard 500) ou "Invalid Date" nas telas autenticadas, não só no login.
+      let authed = false, hasLogin = false, creds = null;
+      try {
+        // campo de senha VISÍVEL = tela de login (apps vanilla deixam o form escondido no DOM
+        // depois de logar, então "existe input" daria falso-positivo — usa offsetParent).
+        hasLogin = await page.evaluate(() => { const p = document.querySelector('input[type=password]'); return !!p && p.offsetParent !== null; });
+        creds = hasLogin ? _seedCreds(cwd) : null;
+        if (hasLogin && creds) {
+          const filled = await page.evaluate((email, senha) => {
+            const q = sels => { for (const s of sels) { const el = document.querySelector(s); if (el) return el; } return null; };
+            const ei = q(['input[type=email]', 'input[name*=email i]', 'input[id*=email i]', 'input[placeholder*=mail i]', 'input[type=text]']);
+            const pi = document.querySelector('input[type=password]');
+            if (!ei || !pi) return false;
+            const set = (el, v) => { const d = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(el), 'value'); d && d.set ? d.set.call(el, v) : (el.value = v); el.dispatchEvent(new Event('input', { bubbles: true })); el.dispatchEvent(new Event('change', { bubbles: true })); };
+            set(ei, email); set(pi, senha);
+            const form = pi.closest('form');
+            const btn = (form && form.querySelector('button[type=submit], button')) || q(['button[type=submit]', 'button']);
+            if (btn) btn.click(); else if (form) (form.requestSubmit ? form.requestSubmit() : form.submit());
+            return true;
+          }, creds.email, creds.senha);
+          if (filled) {
+            await page.waitForNetworkIdle({ idleTime: 800, timeout: 8000 }).catch(() => {});
+            await new Promise(r => setTimeout(r, 1500));
+            // logou = o campo de senha sumiu OU ficou invisível (a SPA trocou pra tela interna)
+            authed = await page.evaluate(() => { const p = document.querySelector('input[type=password]'); return !p || p.offsetParent === null; });
+          }
+        }
+      } catch (_) {}
+
+      shotFile = path.join(_os.tmpdir(), 'ts-web-' + port + '.png');
+      try { await page.screenshot({ path: shotFile, fullPage: false }); } catch (_) { shotFile = null; }
+      let bodyText = ''; try { bodyText = await page.evaluate(() => (document.body ? document.body.innerText : '')); } catch (_) {}
+      const bad = [...new Set((bodyText.match(/Invalid Date|\bNaN\b|\bundefined\b|\[object Object\]|Cannot GET|Error:|TypeError|ReferenceError/g) || []))];
+      await browser.close().catch(() => {});
+      // Tela de login que o gate NÃO conseguiu atravessar = seed ausente / senha errada / login
+      // quebrado → as telas internas não têm como ser verificadas. É um problema REAL (o app
+      // precisa de um usuário de SEED funcional pra ser testável de ponta a ponta).
+      const authProblem = (hasLogin && !authed)
+        ? 'Há uma TELA DE LOGIN mas o gate NÃO conseguiu ENTRAR' + (creds ? ' com o usuário de seed "' + creds.email + '"' : ' (nenhum usuário de SEED encontrado no código)') + '. Crie no seed um usuário demo FUNCIONAL (email+senha em texto no script) e garanta que o login aceita ele — senão dashboard/kanban e o resto ficam sem verificação.'
+        : '';
+      if (errs.length || bad.length || authProblem) {
+        kill();
+        return { ok: false, shot: shotFile, authed, crash: 'A verificação web falhou' + (authed ? ' (APÓS LOGIN, nas telas autenticadas)' : '') + ' (Chrome headless — corrija a CAUSA-RAIZ no código):\n'
+          + (errs.length ? 'Console/erros: ' + errs.slice(0, 8).join(' | ') + '\n' : '')
+          + (bad.length ? 'Texto quebrado VISÍVEL na tela: ' + bad.join(', ') + ' (ex: data não formatada, valor undefined/NaN)\n' : '')
+          + (authProblem || '') };
+      }
+      kill();
+      return { ok: true, shot: shotFile, authed };
+    } catch (_) { /* puppeteer falhou → segue só com a verificação do servidor */ }
+  }
+  kill();
+  return { ok: true, shot: shotFile };
+}
+
+// ── ANÁLISE ESTÁTICA (economia, ideia do Codex): roda um checador RÁPIDO e BARATO
+// ANTES do build pesado — pega erro de código de graça (flutter analyze ~8s vs build ~60s+;
+// tsc/node --check pra JS/TS). Se achar erro, o executor corrige sem gastar o build inteiro.
+function staticCheck(b) {
+  try {
+    if (b.kind === 'flutter') {
+      const fb = _findFlutter(); if (!fb) return null;
+      let out = ''; try { out = cp.execSync(`"${fb}" analyze --no-pub 2>&1`, { cwd: b.cwd, encoding: 'utf8', timeout: 120000, maxBuffer: 3e7 }); }
+      catch (e) { out = (e.stdout || '') + (e.stderr || ''); }
+      const errs = out.split('\n').filter(l => /^\s*error\b|^\s*error •/i.test(l)).slice(0, 30);
+      if (errs.length) return { ok: false, out: 'flutter analyze achou erros (corrija ANTES de compilar):\n' + errs.join('\n').slice(0, 2500) };
+      return { ok: true };
+    }
+    if (b.kind === 'node') {
+      // tsc --noEmit se for TS; senão node --check em cada .js do projeto (rápido)
+      const hasTs = fs.existsSync(path.join(b.cwd, 'tsconfig.json'));
+      if (hasTs) {
+        let out = ''; try { cp.execSync('npx -y tsc --noEmit 2>&1', { cwd: b.cwd, encoding: 'utf8', timeout: 120000, maxBuffer: 3e7 }); }
+        catch (e) { out = (e.stdout || '') + (e.stderr || ''); }
+        const errs = out.split('\n').filter(l => /error TS\d+/.test(l)).slice(0, 30);
+        if (errs.length) return { ok: false, out: 'tsc achou erros de tipo (corrija ANTES de rodar):\n' + errs.join('\n').slice(0, 2500) };
+      }
+      return { ok: true };
+    }
+  } catch (_) {}
+  return null; // sem checador barato pra esse kind (android puro: o build é o check)
+}
+
+// ── FASE DE VIABILIDADE (ideia do Codex): antes de codar app AMBICIOSO, avalia o que é
+// tecnicamente POSSÍVEL e escopa com honestidade — evita gastar rodadas tentando o impossível
+// (ex: "abrir 5 WhatsApp nativos" no Android não dá; a versão real é WebView isolado).
+async function feasibilityPhase(goal, model, token) {
+  const sys = 'Você é um ARQUITETO SÊNIOR pragmático. Dado o objetivo do app, faça uma AVALIAÇÃO DE VIABILIDADE curta e HONESTA:\n'
+    + '1) O que é 100% possível com as APIs/plataforma normais.\n'
+    + '2) O que NÃO é possível (limite técnico/da plataforma/legal) e POR QUÊ — seja específico.\n'
+    + '3) A VERSÃO REALISTA de cada parte impossível (o que dá pra entregar de fato que resolve a intenção do usuário).\n'
+    + '4) 1 recomendação de arquitetura pra viabilizar o núcleo.\n'
+    + 'Direto, sem enrolação, máx ~350 palavras. Se TUDO for viável, diga isso em 1 linha.';
+  const r = await _llmText({ token, model, system: sys, user: `OBJETIVO:\n${String(goal).slice(0, 2000)}`, maxTokens: 900 });
+  return { brief: r.text, credits: r.credits };
+}
+
+// ── SCAFFOLD (ideia do Codex): pra projeto NOVO de tipo conhecido, usa o gerador OFICIAL
+// (flutter create / npm init) pra a base — código boilerplate correto de fábrica = menos
+// erro de build. O modelo edita em cima, não escreve tudo do zero.
+function scaffold(goal, dir, onAlert) {
+  try {
+    const g = String(goal).toLowerCase();
+    const empty = (() => { try { return fs.readdirSync(dir).filter(f => f !== '.ts-meta.json' && !f.startsWith('_') && !f.endsWith('.md') && !f.endsWith('.txt')).length === 0; } catch (_) { return true; } })();
+    if (!empty) return null; // já tem código — não scaffolda
+    if (/\bflutter\b/.test(g)) {
+      const fb = _findFlutter(); if (!fb) return null;
+      const name = (g.match(/chamado\s+([a-z][\w]*)/i) || [])[1] || 'app';
+      if (onAlert) onAlert({ type: 'setup', text: `🏗 ts: criando a base Flutter com o gerador oficial (flutter create) — base limpa, menos erro de build.` });
+      cp.execSync(`"${fb}" create --platforms=android --project-name ${name.toLowerCase()} "${dir}"`, { stdio: 'ignore', timeout: 180000 });
+      return { kind: 'flutter', name };
+    }
+    if (/\b(express|node\.?js|api rest|servidor node|portal web|site)\b/.test(g) && !/\bflutter\b|\bandroid\b|\bkotlin\b/.test(g)) {
+      if (onAlert) onAlert({ type: 'setup', text: `🏗 ts: iniciando projeto Node (npm init) — base limpa.` });
+      try { cp.execSync('npm init -y', { cwd: dir, stdio: 'ignore', timeout: 30000 }); } catch (_) {}
+      return { kind: 'node' };
+    }
+  } catch (_) {}
+  return null;
+}
+
+// ── RUN GATE: instala o APK num emulador/aparelho, ABRE o app de verdade e lê o
+// logcat pra pegar CRASH DE RUNTIME (o build gate só pega erro de compilação; um
+// app pode compilar e crashar ao abrir). Precisa de adb + 1 device online.
+function _adb() { const p = path.join(process.env.ANDROID_HOME || process.env.ANDROID_SDK_ROOT || path.join(require('os').homedir(), 'AppData/Local/Android/Sdk'), 'platform-tools', 'adb.exe'); return fs.existsSync(p) ? p : 'adb'; }
+function _appId(projRoot) {
+  // acha o applicationId/namespace do app (pra instalar/abrir/filtrar o logcat).
+  // Android puro: app/build.gradle; Flutter: android/app/build.gradle.
+  for (const f of ['app/build.gradle.kts', 'app/build.gradle', 'android/app/build.gradle.kts', 'android/app/build.gradle']) {
+    try { const t = fs.readFileSync(path.join(projRoot, f), 'utf8'); const m = t.match(/applicationId\s*=?\s*["']([\w.]+)["']/) || t.match(/namespace\s*=?\s*["']([\w.]+)["']/); if (m) return m[1]; } catch (_) {}
+  }
+  return null;
+}
+// ── EMULADOR: o harness garante um device Android online (autonomia de ambiente).
+// Se não houver device: liga o primeiro AVD existente; se NÃO existir nenhum AVD,
+// baixa a system image (sdkmanager) e CRIA um (avdmanager) — o modelo nunca faz isso.
+function _sdkRoot() { return process.env.ANDROID_HOME || process.env.ANDROID_SDK_ROOT || path.join(require('os').homedir(), 'AppData/Local/Android/Sdk'); }
+function _deviceOnline() {
+  try { const d = cp.execSync(`"${_adb()}" devices`, { encoding: 'utf8', timeout: 15000 }); return d.split('\n').slice(1).some(l => /\tdevice\s*$/.test(l)); } catch (_) { return false; }
+}
+function ensureEmulator(onAlert) {
+  if (_deviceOnline()) return { ok: true, already: true };
+  const sdk = _sdkRoot();
+  const emu = path.join(sdk, 'emulator', 'emulator.exe');
+  if (!fs.existsSync(emu)) return { ok: false, reason: 'emulator não instalado no Android SDK' };
+  let avds = [];
+  try { avds = cp.execSync(`"${emu}" -list-avds`, { encoding: 'utf8', timeout: 30000 }).split(/\r?\n/).map(s => s.trim()).filter(s => s && !/^INFO/.test(s)); } catch (_) {}
+  if (!avds.length) {
+    // nenhum AVD → cria um do zero (baixa a system image; pode levar vários minutos)
+    const sdkm = path.join(sdk, 'cmdline-tools', 'latest', 'bin', 'sdkmanager.bat');
+    const avdm = path.join(sdk, 'cmdline-tools', 'latest', 'bin', 'avdmanager.bat');
+    if (!fs.existsSync(sdkm) || !fs.existsSync(avdm)) return { ok: false, reason: 'cmdline-tools ausentes — não consigo criar AVD' };
+    try {
+      if (onAlert) onAlert({ type: 'setup', text: '📥 ts: nenhum emulador (AVD) — baixando system image e criando um (pode levar vários minutos)…' });
+      cp.execSync(`echo y| "${sdkm}" "system-images;android-34;google_apis;x86_64"`, { stdio: 'ignore', timeout: 1500000 });
+      cp.execSync(`echo no| "${avdm}" create avd -n ts_emulador -k "system-images;android-34;google_apis;x86_64" -d pixel_6`, { stdio: 'ignore', timeout: 120000 });
+      avds = ['ts_emulador'];
+    } catch (e) { return { ok: false, reason: 'falha ao criar AVD: ' + String(e.message).slice(0, 80) }; }
+  }
+  if (onAlert) onAlert({ type: 'setup', text: `▶ ts: ligando o emulador ${avds[0]} pra testar o app de verdade…` });
+  try { cp.spawn(emu, ['-avd', avds[0], '-no-snapshot-save', '-no-boot-anim'], { detached: true, stdio: 'ignore' }).unref(); } catch (e) { return { ok: false, reason: 'falha ao iniciar o emulador: ' + String(e.message).slice(0, 80) }; }
+  // espera o boot completar (até ~4 min)
+  for (let i = 0; i < 48; i++) {
+    _wait(5);
+    try { if (cp.execSync(`"${_adb()}" shell getprop sys.boot_completed`, { encoding: 'utf8', timeout: 10000 }).trim() === '1') { _wait(5); return { ok: true, booted: true }; } } catch (_) {}
+  }
+  return { ok: false, reason: 'o emulador não terminou o boot a tempo' };
+}
+function runApp(b, projRoot, onAlert) {
+  const adb = _adb();
+  if (!_deviceOnline()) {
+    const em = ensureEmulator(onAlert); // liga (ou cria) o emulador sozinho
+    if (!em.ok) return { skipped: true, reason: 'sem emulador/aparelho online (' + em.reason + ')' };
+  }
+  const apk = path.join(b.cwd, b.artifact);
+  const pkg = _appId(projRoot) || _appId(b.cwd);
+  if (!fs.existsSync(apk) || !pkg) return { skipped: true, reason: 'apk ou packageId não encontrado' };
+  try {
+    cp.execSync(`"${adb}" install -r -g "${apk}"`, { encoding: 'utf8', timeout: 120000, stdio: ['ignore', 'pipe', 'pipe'] });
+    cp.execSync(`"${adb}" logcat -c`, { timeout: 15000 });
+    cp.execSync(`"${adb}" shell monkey -p ${pkg} -c android.intent.category.LAUNCHER 1`, { timeout: 30000, stdio: ['ignore', 'pipe', 'pipe'] });
+    cp.execSync('ping -n 6 127.0.0.1 > nul', { shell: true, timeout: 10000 }); // ~5s pra o app subir/crashar
+    const log = cp.execSync(`"${adb}" logcat -d -v brief`, { encoding: 'utf8', timeout: 20000, maxBuffer: 3e7 });
+    // procura o crash (FATAL EXCEPTION / AndroidRuntime) referente ao nosso pacote.
+    // TAMBÉM pega exceção do FLUTTER (a "tela vermelha"): o processo NÃO morre, mas o
+    // logcat mostra "Unhandled Exception"/"EXCEPTION CAUGHT BY" — bug real de produção
+    // (HiveError virava tela vermelha/preta e o gate antigo aprovava porque o pid vivia).
+    const lines = log.split('\n');
+    const fatalIdx = lines.findIndex(l => /FATAL EXCEPTION|AndroidRuntime.*(FATAL|Exception)|E AndroidRuntime|Unhandled Exception|EXCEPTION CAUGHT BY/i.test(l));
+    if (fatalIdx >= 0) {
+      const crash = lines.slice(fatalIdx, fatalIdx + 30).filter(l => /AndroidRuntime|Exception|Error|at [\w.$#]+|Caused by|E \/|flutter/i.test(l)).slice(0, 24).join('\n');
+      return { ok: false, crash: ('ERRO DE RUNTIME (o app pode ter mostrado TELA VERMELHA/PRETA — exceção não tratada):\n' + crash).slice(0, 3000) };
+    }
+    // sem FATAL: confere se o processo do app está de pé (não morreu)
+    let ps = ''; try { ps = cp.execSync(`"${adb}" shell pidof ${pkg}`, { encoding: 'utf8', timeout: 15000 }); } catch (_) {}
+    if (ps.trim()) return { ok: true };
+    return { ok: false, crash: 'O app abriu e FECHOU sozinho (processo não está mais rodando), mas sem FATAL EXCEPTION no logcat. Verifique inicialização (onCreate, Room, tema, permissões) e binding de views.' };
+  } catch (e) { return { skipped: true, reason: 'falha ao instalar/abrir: ' + String(e.message).slice(0, 100) }; }
+}
+
+// ── VISUAL GATE: tira um PRINT do app rodando e um modelo com VISÃO (o "olho",
+// default grok-4.5) critica o layout (nav torta, gráfico cortado, sobreposição).
+// A crítica volta pro executor melhorar o visual. É o gate de APARÊNCIA.
+async function _llmVision({ token, model, text, imageB64, images, maxTokens = 700 }) {
+  if (!_key) _key = await api('/api/ai/key?feature=cli_agent', { token, timeoutMs: 20000 });
+  // aceita 1 imagem (imageB64) ou VÁRIAS (images[]) na MESMA chamada de visão — 1 crítica cobre N telas
+  const imgs = (images && images.length ? images : [imageB64]).filter(Boolean);
+  const content = [{ type: 'text', text }].concat(imgs.map(b64 => ({ type: 'image_url', image_url: { url: 'data:image/png;base64,' + b64 } })));
+  let res; try {
+    res = await fetch(String(_key.baseUrl).replace(/\/+$/, '') + '/chat/completions', {
+      method: 'POST', headers: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + _key.key },
+      // VISÃO: NÃO envia limite de tokens NENHUM. Com imagem, o z.ai (glm) TRUNCA em ~80
+      // tokens se vier max_tokens OU max_completion_tokens; sem limite devolve a crítica
+      // inteira (508 tok). O grok é naturalmente lacônico em visão de qualquer jeito.
+      // (a crítica do olho é curta por natureza — não precisa de teto.)
+      body: JSON.stringify({ model, messages: [{ role: 'user', content }] }),
+    });
+  } catch (_) { return { text: '', credits: 0 }; }
+  const j = await res.json().catch(() => null);
+  if (!res.ok) _capGuard(res, j);
+  const u = j?.usage || {};
+  let credits = 0;
+  if (u.prompt_tokens) { try { const c = await api('/api/credit/charge', { method: 'POST', token, body: { model, inTok: u.prompt_tokens || 0, outTok: u.completion_tokens || 0 } }); credits = (c && c.charged) || 0; } catch (_) {} }
+  return { text: String(j?.choices?.[0]?.message?.content || '').trim(), credits };
+}
+const _os = require('os');
+function _screenshot(saveTo) {
+  try {
+    const adb = _adb();
+    const png = cp.execSync(`"${adb}" exec-out screencap -p`, { encoding: 'buffer', maxBuffer: 3e7, timeout: 20000 });
+    if (png && png.length > 5000) { if (saveTo) { try { fs.writeFileSync(saveTo, png); } catch (_) {} } return png.toString('base64'); }
+  } catch (_) {}
+  return null;
+}
+// Heurística barata: a tela ainda está CARREGANDO/quase vazia? (PNG pequeno = pouca
+// variação de cor). Se sim, o print não vale a crítica — espera mais.
+function _looksLoading(b64) { return !b64 || b64.length < 60000; }
+// Print ESTÁVEL: pra app de REDE (feed que carrega por HTTP), o conteúdo aparece com
+// atraso — se o print sai cedo, o olho vê "cards vazios" (falso-positivo). Tira prints
+// em sequência e só retorna quando 2 seguidos ficam estáveis (tamanho do PNG ~igual) e
+// não parecem loading. Espera até ~19s. Assim o olho critica a tela JÁ carregada.
+function _stableShot(saveTo) {
+  let prev = _screenshot(saveTo);
+  for (let i = 0; i < 5; i++) {
+    _wait(3);
+    const cur = _screenshot(saveTo);
+    if (!cur) return prev;
+    if (prev && !_looksLoading(cur) && Math.abs(cur.length - prev.length) / Math.max(cur.length, 1) < 0.04) return cur;
+    prev = cur;
+  }
+  return prev;
+}
+function _wait(secs) { try { cp.execSync(`ping -n ${Math.max(2, Math.round(secs) + 1)} 127.0.0.1 > nul`, { shell: true, timeout: (secs + 3) * 1000 }); } catch (_) {} }
+function _screenSize() {
+  try { const o = cp.execSync(`"${_adb()}" shell wm size`, { encoding: 'utf8', timeout: 15000 }); const m = o.match(/Override size:\s*(\d+)x(\d+)/) || o.match(/Physical size:\s*(\d+)x(\d+)/); if (m) return { w: +m[1], h: +m[2] }; } catch (_) {}
+  return { w: 1080, h: 2400 };
+}
+function _tap(x, y) { try { cp.execSync(`"${_adb()}" shell input tap ${Math.round(x)} ${Math.round(y)}`, { timeout: 15000, stdio: 'ignore' }); } catch (_) {} }
+function _back() { try { cp.execSync(`"${_adb()}" shell input keyevent 4`, { timeout: 15000, stdio: 'ignore' }); } catch (_) {} }
+// Explora o app pra ver telas ALÉM da inicial: abre o diálogo/tela de "adicionar" (FAB).
+// O FAB pode estar em QUALQUER canto inferior (o executor pode movê-lo) — tenta direita E
+// esquerda e fica com a tela que MAIS difere da Home (dialog muda muito o tamanho do PNG).
+// Comparar base64 por igualdade exata NÃO serve (relógio/antialias mudam sempre) → usa a
+// diferença relativa de tamanho do PNG como sinal barato de "tela nova".
+function _explore(pkg, homeB64) {
+  const shots = [];
+  let navDead = false, blackAfterBack = false;
+  const homeLen = homeB64.length;
+  const _alive = () => { try { return !!cp.execSync(`"${_adb()}" shell pidof ${pkg}`, { encoding: 'utf8', timeout: 10000 }).trim(); } catch (_) { return false; } };
+  const _launch = () => { try { cp.execSync(`"${_adb()}" shell monkey -p ${pkg} -c android.intent.category.LAUNCHER 1`, { stdio: 'ignore', timeout: 15000 }); } catch (_) {} };
+  try {
+    const { w, h } = _screenSize();
+    const cands = [[w * 0.89, h * 0.865], [w * 0.11, h * 0.865]]; // canto inf-direito e inf-esquerdo
+    let best = null, bestDiff = 0.05; // exige >5% de diferença de tamanho pra contar como tela realmente nova
+    for (const [x, y] of cands) {
+      _tap(x, y); _wait(2);
+      const shot = _screenshot(null);
+      _back(); _wait(1); // fecha (dialog/tela) pra não deixar o app sujo antes do próximo candidato
+      if (shot && !_looksLoading(shot)) {
+        const diff = Math.abs(shot.length - homeLen) / homeLen;
+        if (diff > bestDiff) { best = shot; bestDiff = diff; }
+      }
+    }
+    if (best) shots.push({ label: 'tela de adicionar/diálogo (FAB)', b64: best });
+    // ── TESTE DO BOTÃO VOLTAR (bug real de produção: voltar SAÍA do app / tela preta) ──
+    // Troca de aba (toque no meio da bottom nav); se a tela MUDOU, aperta VOLTAR:
+    // o app deve continuar vivo e sem tela preta. Só testa se o toque mudou a tela
+    // (senão o app nem tem nav ali e VOLTAR na raiz sai legitimamente).
+    if (!_alive()) _launch(); _wait(2); // garante o app de pé (os probes acima podem tê-lo fechado)
+    const before = _screenshot(null);
+    _tap(w * 0.5, h * 0.955); _wait(1.5);
+    const after1 = _screenshot(null);
+    const changed = before && after1 && Math.abs(after1.length - before.length) / before.length > 0.02;
+    if (changed) {
+      _back(); _wait(1.5);
+      if (!_alive()) navDead = true;
+      else { const shot2 = _screenshot(null); if (shot2 && _looksLoading(shot2)) { blackAfterBack = true; shots.push({ label: 'tela após apertar VOLTAR (possível tela preta/vazia)', b64: shot2 }); } }
+    }
+  } catch (_) {}
+  return { shots, navDead, blackAfterBack };
+}
+async function visualGate(b, projRoot, eye, token, designBrief, mockupB64) {
+  const pkg = _appId(projRoot) || _appId(b.cwd);
+  try { cp.execSync(`"${_adb()}" shell monkey -p ${pkg} -c android.intent.category.LAUNCHER 1`, { stdio: 'ignore', timeout: 20000 }); } catch (_) {}
+  // (a) ESPERA a tela assentar (inclui carregamento de REDE) — só critica o print estável
+  _wait(3);
+  const shotFile = path.join(_os.tmpdir(), 'ts-visual-' + pkg + '.png');
+  let home = _stableShot(shotFile);
+  if (!home) return { skipped: true, reason: 'não consegui o print' };
+  // (b) EXPLORA: além da Home, abre o diálogo/tela do FAB (onde ficam seletores de ícone/cor
+  // que a Home não mostra) e testa o BOTÃO VOLTAR (bug real: voltar saía do app / tela preta).
+  try { cp.execSync(`"${_adb()}" logcat -c`, { timeout: 15000 }); } catch (_) {} // zera o log pra atribuir exceções às interações abaixo
+  const ex = _explore(pkg, home);
+  // TELA VERMELHA nas interações (exceção Flutter não tratada) → reprovação DETERMINÍSTICA (grátis)
+  try {
+    const lg = cp.execSync(`"${_adb()}" logcat -d -v brief`, { encoding: 'utf8', timeout: 20000, maxBuffer: 3e7 });
+    const li = lg.split('\n'); const xi = li.findIndex(l => /Unhandled Exception|EXCEPTION CAUGHT BY|HiveError/i.test(l));
+    if (xi >= 0) {
+      const exc = li.slice(xi, xi + 20).filter(l => /Exception|Error|flutter|at [\w.$#]+/i.test(l)).slice(0, 14).join('\n');
+      return { ok: false, severity: 'estrutural', credits: 0, shot: shotFile, screens: 1,
+        critique: 'ERRO FUNCIONAL REAL (detectado ao INTERAGIR com o app — tela vermelha/exceção não tratada): ao tocar em elementos da interface o Flutter lançou exceção. Corrija a CAUSA-RAIZ no código (não é estética):\n' + exc };
+    }
+  } catch (_) {}
+  // VOLTAR matou o app → reprovação DETERMINÍSTICA (grátis — nem gasta o olho)
+  if (ex.navDead) {
+    return { ok: false, severity: 'estrutural', credits: 0, shot: shotFile, screens: 1,
+      critique: 'BUG ESTRUTURAL DE NAVEGAÇÃO (detectado por teste real, não por opinião): ao trocar de aba e apertar o botão VOLTAR do sistema, o app FECHOU (processo morreu). O botão voltar NUNCA pode sair do app a partir de uma tela/aba interna — deve voltar pra aba/tela anterior. Fix: use rotas aninhadas (go_router StatefulShellRoute/ShellRoute) com PopScope tratando o back do sistema: se não estiver na aba inicial, volte pra ela; só saia do app se já estiver na raiz. Garanta também que a seta de voltar da AppBar usa pop() da MESMA pilha (nunca push de nova tela nem tela preta).' };
+  }
+  const shots = [{ label: 'tela inicial (Home)', b64: home }].concat(ex.shots);
+  // re-abre a Home pra deixar o app num estado limpo pro próximo ciclo
+  try { cp.execSync(`"${_adb()}" shell monkey -p ${pkg} -c android.intent.category.LAUNCHER 1`, { stdio: 'ignore', timeout: 15000 }); } catch (_) {}
+  // (c) OLHO rígido, mas com SEVERIDADE: só reprova em defeito ESTRUTURAL. Nitpick cosmético
+  // NÃO reprova (economia: o loop de polimento com modelo forte é caro; não vale queimar rodada
+  // com implicância que não quebra usabilidade nem o layout).
+  const mockPrefix = mockupB64
+    ? 'A PRIMEIRA imagem é um MOCKUP DE REFERÊNCIA (o ALVO desenhado — NÃO é o app). As telas seguintes são o APP REAL. Além dos checkpoints, COMPARE o app com o mockup: divergência GRANDE de estrutura/paleta/componentes em relação ao mockup é ESTRUTURAL; diferença sutil de tom/espacamento é COSMÉTICO. '
+    : '';
+  const prompt = 'Você é um DIRETOR DE ARTE revisando PRINTS REAIS de um app Android rodando. ' + mockPrefix
+    + 'Vou te enviar ' + shots.length + ' tela(s) do app, NESTA ordem: ' + shots.map((s, i) => `(${i + 1}) ${s.label}`).join('; ') + '. '
+    + 'Analise cada tela e classifique os problemas em DUAS categorias:\n'
+    + 'ESTRUTURAL (grave — quebra o layout ou a usabilidade): elemento CORTADO/incompleto (card/lista/gráfico/anel cortado pela borda ou por outro componente), item de lista horizontal cortado nas pontas (falta scroll+padding), SOBREPOSIÇÃO (texto sobre ícone, componente cobrindo outro), texto TRUNCADO importante, bottom nav com indicador cobrindo só metade/desalinhado ou ícone/label faltando, conteúdo ILEGÍVEL, tela quebrada/vazia/preta sem motivo, e SAFE AREA: qualquer elemento INTERATIVO (FAB, botão, item de nav) COLADO na borda inferior ou superior da tela (a barra de gestos/navegação do sistema sobrepõe — precisa de SafeArea/margem ≥16-24dp).\n'
+    + 'COSMÉTICO (nitpick — não quebra nada): concordância de plural ("1 hábitos"), contraste levemente fraco mas legível, micro-espaçamento, sombra/opacidade sutil, preferência de cor/estilo. NÃO trate cosmético como grave.\n'
+    + 'CHECKPOINTS a verificar: bottom nav (indicador equilibrado e consistente, ícone acima do label); listas/carrosséis horizontais (1º e último item INTEIROS, com scroll por toque); gráficos/anéis completos; nada cortado/sobreposto; conteúdo carregado (não confunda skeleton/shimmer de loading com tela vazia).\n'
+    + 'Liste os problemas ESTRUTURAIS (se houver) com QUAL tela, ONDE e o FIX TÉCNICO exato (widget/atributo). Depois liste os COSMÉTICOS à parte.\n'
+    + 'TERMINE a resposta com UMA linha, exatamente um destes veredictos:\n'
+    + '"VEREDITO: OK" — se estiver impecável (nenhum problema).\n'
+    + '"VEREDITO: RESSALVAS" — se só houver problemas COSMÉTICOS (nenhum estrutural). Isto APROVA o app.\n'
+    + '"VEREDITO: REPROVADO" — se houver QUALQUER problema ESTRUTURAL.'
+    + (designBrief ? '\n\nO app DEVE seguir este design system:\n' + String(designBrief).slice(0, 1400) : '');
+  const imgs = (mockupB64 ? [mockupB64] : []).concat(shots.map(s => s.b64));
+  const r = await _llmVision({ token, model: eye, text: prompt, images: imgs, maxTokens: 1100 });
+  const txt = String(r.text || '');
+  // veredito explícito manda; fallback pro comportamento antigo se o olho não emitir a linha.
+  let severity, ok;
+  if (/VEREDITO:\s*REPROVAD/i.test(txt)) { severity = 'estrutural'; ok = false; }
+  else if (/VEREDITO:\s*RESSALV/i.test(txt)) { severity = 'ressalvas'; ok = true; }
+  else if (/VEREDITO:\s*OK/i.test(txt)) { severity = 'ok'; ok = true; }
+  else { ok = /^\s*VISUAL OK\s*$/i.test(txt.trim()) || txt.length < 12; severity = ok ? 'ok' : 'estrutural'; }
+  return { ok, severity, critique: txt, credits: r.credits, shot: shotFile, screens: shots.length };
+}
+
+function stateFile(dir) { return path.join(dir || process.cwd(), FILE); }
+
+// Mapa compacto dos arquivos do projeto (grátis) — injetado no contexto de cada
+// rodada pra o agente NÃO precisar relistar/rebuscar o projeto toda vez (era o
+// maior vilão de custo: ~5-6 tool calls de exploração por rodada). Ignora ruído.
+const _SKIP = new Set(['.git', 'node_modules', 'build', '.gradle', '.idea', 'dist', '.ts-meta.json']);
+function projectMap(dir, max = 120) {
+  const out = [];
+  const walk = (d, rel, depth) => {
+    if (depth > 6 || out.length >= max) return;
+    let list; try { list = fs.readdirSync(d, { withFileTypes: true }); } catch (_) { return; }
+    for (const e of list) {
+      if (out.length >= max) return;
+      if (_SKIP.has(e.name) || e.name.startsWith('.')) continue;
+      const r = rel ? rel + '/' + e.name : e.name;
+      if (e.isDirectory()) walk(path.join(d, e.name), r, depth + 1);
+      else out.push(r);
+    }
+  };
+  try { walk(dir, '', 0); } catch (_) {}
+  return out;
+}
+function load(dir) {
+  try { return JSON.parse(fs.readFileSync(stateFile(dir), 'utf8')); } catch (_) { return null; }
+}
+// Escrita ATÔMICA (tmp + rename): uma queda no meio do write não corrompe o
+// .ts-meta.json — sem isso, load() devolveria null e a missão recomeçaria do zero.
+function save(st, dir) {
+  const f = stateFile(dir), tmp = f + '.tmp';
+  try {
+    fs.writeFileSync(tmp, JSON.stringify(st, null, 2));
+    fs.renameSync(tmp, f);
+  } catch (_) {
+    try { fs.writeFileSync(f, JSON.stringify(st, null, 2)); } catch (_) {} // fallback direto
+  }
+}
+
+// Chamada JSON barata (flash-lite via CDC, chave sk-hub do usuário) + cobrança
+let _key = null;
+async function _llmJson({ token, system, user, maxTokens = 900 }) {
+  if (!_key) _key = await api('/api/ai/key?feature=cli_agent', { token, timeoutMs: 20000 });
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), 60000);
+  let res;
+  try {
+    res = await fetch(String(_key.baseUrl).replace(/\/+$/, '') + '/chat/completions', {
+      method: 'POST', signal: ctrl.signal,
+      headers: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + _key.key },
+      body: JSON.stringify({ model: 'gemini-2.5-flash-lite', stream: false, max_completion_tokens: maxTokens,
+        messages: [{ role: 'system', content: system }, { role: 'user', content: user }] }),
+    });
+  } finally { clearTimeout(timer); }
+  const j = await res.json().catch(() => null);
+  if (!res.ok) _capGuard(res, j);
+  const u = j?.usage || {};
+  let credits = 0;
+  if (u.prompt_tokens) {
+    try { const c = await api('/api/credit/charge', { method: 'POST', token, body: { model: 'gemini-2.5-flash-lite', inTok: u.prompt_tokens || 0, outTok: u.completion_tokens || 0 } }); credits = (c && c.charged) || 0; } catch (_) {}
+  }
+  return { json: _tolerantJson(String(j?.choices?.[0]?.message?.content || '')), credits };
+}
+
+// Chamada de TEXTO com modelo arbitrário — usada pelo PENSADOR (escalonamento).
+async function _llmText({ token, model, system, user, maxTokens = 1200 }) {
+  if (!_key) _key = await api('/api/ai/key?feature=cli_agent', { token, timeoutMs: 20000 });
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), 120000);
+  let res;
+  try {
+    res = await fetch(String(_key.baseUrl).replace(/\/+$/, '') + '/chat/completions', {
+      method: 'POST', signal: ctrl.signal,
+      headers: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + _key.key },
+      body: JSON.stringify({ model, stream: false, max_completion_tokens: maxTokens, messages: [{ role: 'system', content: system }, { role: 'user', content: user }] }),
+    });
+  } finally { clearTimeout(timer); }
+  const j = await res.json().catch(() => null);
+  if (!res.ok) _capGuard(res, j);
+  const u = j?.usage || {};
+  let credits = 0;
+  if (u.prompt_tokens) { try { const c = await api('/api/credit/charge', { method: 'POST', token, body: { model, inTok: u.prompt_tokens || 0, outTok: u.completion_tokens || 0 } }); credits = (c && c.charged) || 0; } catch (_) {} }
+  return { text: String(j?.choices?.[0]?.message?.content || '').trim(), credits };
+}
+
+// ESCALONAMENTO: o executor barato travou no mesmo erro. Chama o modelo CARO
+// "pensador" numa análise FOCADA (sem ferramentas, sem loop) com o erro + o código
+// dos arquivos citados, e devolve um diagnóstico + fix EXATO pro executor aplicar.
+async function escalate(buildErr, projDir, thinker, token) {
+  const files = [...new Set([...String(buildErr).matchAll(/([A-Za-z]:[\\/][^\s:*?"<>|]+\.(?:kt|kts|xml|gradle|java|properties))/g)].map(m => m[1].replace(/\//g, path.sep)))].slice(0, 4);
+  let ctx = '';
+  for (const f of files) { try { const t = fs.readFileSync(f, 'utf8'); ctx += `\n----- ${f.split(path.sep).slice(-2).join('/')} -----\n` + t.split('\n').slice(0, 220).join('\n') + '\n'; } catch (_) {} }
+  const sys = 'Você é um engenheiro sênior de DEBUG. Recebe o ERRO REAL de um build e o código dos arquivos citados. '
+    + 'Diga a CAUSA-RAIZ em 1-2 linhas e depois o FIX EXATO e mínimo: em QUAL arquivo, QUAL linha/trecho, e o QUE trocar (mostre o antes→depois curto). '
+    + 'NÃO reescreva o app inteiro, só o necessário pra compilar. Seja preciso e direto.';
+  const r = await _llmText({ token, model: thinker, system: sys, user: `ERRO DO BUILD:\n${String(buildErr).slice(0, 2500)}\n\nCÓDIGO RELEVANTE:${ctx.slice(0, 6000)}`, maxTokens: 1200 });
+  return { hint: r.text, credits: r.credits };
+}
+
+// O objetivo parece um app/UI visual? (aí vale rodar a FASE DE DESIGN antes de codar)
+function looksVisual(goal) {
+  return /\b(app|aplicativo|tela|telas|screen|ui|interface|site|p[áa]gina|dashboard|bonito|visual|design|android|flutter|ios|mobile|react|frontend|landing|layout)\b/i.test(String(goal || ''));
+}
+
+// REGRAS DE VIDA EVOLUTIVAS: lições aprendidas com feedback real do usuário, num arquivo
+// que cresce sem mudar código — ~/.ts/regras.md (global, todas as missões) + .ts-regras.md
+// (por projeto). Injetadas na fase de design E em toda rodada do executor.
+function loadRules(dir) {
+  let out = '';
+  for (const f of [path.join(require('os').homedir(), '.ts', 'regras.md'), path.join(dir || process.cwd(), '.ts-regras.md')]) {
+    try { const t = fs.readFileSync(f, 'utf8').trim(); if (t) out += (out ? '\n' : '') + t; } catch (_) {}
+  }
+  return out.slice(0, 3000);
+}
+
+// FASE DE ARQUITETURA (3º pilar): pra app COMPLEXO, o ARQUITETO (pensador forte) escreve
+// um CONTRATO antes de codar — componentes, arquivos com caminho exato e, principalmente,
+// NOMES/ASSINATURAS EXATOS que todos os arquivos devem usar. Mata a maior causa de build-fix
+// do executor barato: inconsistência entre arquivos gerados em rodadas separadas (contexto zerado).
+// Inspiração: planejar a arquitetura ANTES de codar (padrão Archify/diagrama-primeiro).
+function looksComplex(goal) {
+  const g = String(goal || '');
+  const hits = (g.match(/\b(api|banco|integra\w*|fila|webhook|websocket|rss|sync|servidor|backend|tempo real|notifica\w*|pagamento|login|auth|nuvem|cloud|multi\w*)\b/gi) || []).length;
+  return g.length > 1500 || hits >= 3;
+}
+async function archPhase(goal, architect, token, opts = {}) {
+  const rules = loadRules(opts.dir);
+  const sys = 'Você é um ARQUITETO DE SOFTWARE SÊNIOR. Dado o objetivo, produza um CONTRATO DE ARQUITETURA curto e IMPLEMENTÁVEL, que vários programadores implementarão em rodadas separadas SEM conversar entre si — o contrato é a única fonte da verdade. Inclua:\n'
+    + '1) COMPONENTES/módulos (responsabilidade única, 1 linha cada).\n'
+    + '2) ARQUIVOS principais com CAMINHO EXATO por componente.\n'
+    + '3) CONTRATOS EXATOS entre as partes: nomes de classes/funções com ASSINATURAS (parâmetros e retorno), nomes de tabelas/boxes/chaves de storage, rotas/endpoints — os nomes LITERAIS que todos os arquivos devem usar (isto evita referência quebrada entre arquivos).\n'
+    + '4) FLUXO DE DADOS: quem chama quem, em que ordem (A → B → C), incluindo o caminho de erro.\n'
+    + '5) INTEGRAÇÕES externas e onde entram no fluxo.\n'
+    + '6) RISCOS prováveis (3 itens, com a prevenção).\n'
+    + 'Direto e concreto, máx ~700 palavras. NADA genérico.';
+  const user = `OBJETIVO:\n${String(goal).slice(0, 2500)}` + (rules ? `\n\nREGRAS DO USUÁRIO (respeite no desenho):\n${rules.slice(0, 1200)}` : '');
+  const r = await _llmText({ token, model: architect, system: sys, user, maxTokens: 2000 });
+  return { brief: r.text, credits: r.credits };
+}
+
+// FASE DE DESIGN: antes de codar, o DESIGNER (modelo forte) projeta um DESIGN SYSTEM
+// concreto e implementável. O executor barato segue à risca → apps saem BONITOS de
+// fábrica, não no padrão genérico. Uma chamada só, barata; resolve a qualidade visual.
+// Se houver MOCKUP (imagem de referência, ex: gerada no Google AI Studio), o designer
+// VÊ a imagem e projeta o design system a partir dela (grok-4.5 tem visão).
+// Tipo de projeto pro design/regras: 'web' (Node/Express/HTML) vs 'mobile' (Flutter/Android).
+// Usa o build detectado; se ainda não dá (pré-scaffold), infere do objetivo (sinal mobile manda).
+function _projKind(goal, dir) {
+  try { const b = detectBuild(dir); if (b && (b.kind === 'web' || b.kind === 'node')) return 'web'; if (b && (b.kind === 'flutter' || b.kind === 'android')) return 'mobile'; } catch (_) {}
+  const g = String(goal || '');
+  if (/\b(flutter|android|kotlin|apk|ios|swift|react\s?native|jetpack|compose)\b/i.test(g)) return 'mobile';
+  if (/\b(web|express|node\.?js|html|css|portal|painel|dashboard|site|front-?end|back-?end|api\s?rest|sqlite|better-sqlite3|servidor)\b/i.test(g)) return 'web';
+  return 'mobile'; // default histórico do ts (mobile-first)
+}
+
+async function designPhase(goal, designer, token, opts = {}) {
+  const web = opts.kind === 'web';
+  const sys = web
+    ? ('Você é um DESIGNER DE PRODUTO WEB SÊNIOR, especialista em interfaces web bonitas, modernas e RESPONSIVAS (dark ou claro conforme o objetivo). '
+      + 'Dado o objetivo, produza um DESIGN SYSTEM CONCRETO E IMPLEMENTÁVEL EM CSS (valores reais, nunca genérico). Inclua:\n'
+      + '1) PALETA exata (hex) com papéis: fundo, superfície, superfície-elevada, primária, secundária, gradiente (2 hex), texto-primário, texto-secundário, sucesso, erro, aviso, borda/divisor.\n'
+      + '2) TIPOGRAFIA: família (web-safe ou Google Font), escala em rem/px e peso para h1/h2/h3/corpo/legenda; line-height.\n'
+      + '3) TOKENS: espaçamentos (px), raios (px), sombras (box-shadow), transições.\n'
+      + '4) COMPONENTES com specs EXATAS em CSS: cards, botões (primário/secundário/texto: cor, HOVER, FOCUS, disabled, raio), inputs (com foco/erro), a NAVEGAÇÃO (top bar OU sidebar — cor, item ATIVO vs inativo, hover), badges/selos, tabelas/listas, modais.\n'
+      + '5) Por TELA: notas de layout (grid/flex, largura máx do container, comportamento responsivo).\n'
+      + '6) REGRAS DE VIDA WEB (inegociáveis — bugs reais): \n'
+      + '   a. RESPONSIVO: nada quebra/estoura de 360px a 1440px; SEM scroll horizontal acidental.\n'
+      + '   b. ESTADOS: todo interativo tem :hover E :focus-visible visíveis (acessibilidade + teclado).\n'
+      + '   c. CONTRASTE: texto atinge contraste AA sobre o fundo.\n'
+      + '   d. Nada de "Invalid Date"/"undefined"/"NaN"/"[object Object]" na tela — formate datas e valores sempre.\n'
+      + 'Seja específico, elegante e coeso. Markdown limpo (máx ~750 palavras). É WEB (CSS) — NÃO use termos de Android (sp/dp/XML/BottomNavigationView/FAB/elevation em dp).')
+    : ('Você é um DESIGNER DE PRODUTO SÊNIOR, especialista em apps mobile bonitos, modernos e com acabamento profissional. '
+      + 'Dado o objetivo do app, produza um DESIGN SYSTEM CONCRETO E IMPLEMENTÁVEL (valores reais, nunca genérico) para um app Android PREMIUM. Inclua:\n'
+      + '1) PALETA exata (hex) com papéis: fundo, superfície, superfície-elevada, primária, secundária, gradiente (2 hex), texto-primário, texto-secundário, sucesso, erro, divisor.\n'
+      + '2) TIPOGRAFIA: escala em sp e peso para display/título/subtítulo/corpo/legenda.\n'
+      + '3) TOKENS: espaçamentos (dp), raios de canto (dp), elevações.\n'
+      + '4) COMPONENTES com specs EXATAS: cards (raio/padding/elevação/cor), botões (primário/secundário/texto: cor, estado, raio), FAB, campos de texto, e ESPECIALMENTE a BOTTOM NAVIGATION — cor de fundo, item SELECIONADO vs NÃO-selecionado (cor de ícone E label), cor do indicador, e como o label se comporta (sempre visível, sem sobrepor). Dê o XML/estilo essencial quando ajudar.\n'
+      + '5) Por TELA: notas curtas de layout e hierarquia visual.\n'
+      + '6) REGRAS DE VIDA (obrigatórias, inegociáveis — bugs reais de produção):\n'
+      + '   a. SAFE AREA: NENHUM elemento interativo (FAB, botão, item de nav) a menos de 24dp das bordas superior/inferior da tela — a barra de gestos/navegação do sistema sobrepõe. Sempre SafeArea/insets.\n'
+      + '   b. BOTÃO VOLTAR do sistema: de uma tela/aba interna, VOLTAR deve voltar uma tela (nunca fechar o app, nunca tela preta). Rotas aninhadas/PopScope corretos.\n'
+      + '   c. BOOT RÁPIDO: primeira tela renderiza em <2s; inicialização pesada (banco/scan/IO) é assíncrona DEPOIS do primeiro frame, com skeleton — e storages (ex: Hive) inicializados/abertos ANTES de qualquer uso.\n'
+      + 'Seja específico, elegante e coeso. Markdown limpo e direto (máx ~750 palavras).');
+  const rules = loadRules(opts.dir);
+  const userMsg = `OBJETIVO DO APP:\n${String(goal).slice(0, 2000)}`
+    + (rules ? `\n\nREGRAS DO USUÁRIO (lições de projetos anteriores — respeite TODAS no design):\n${rules}` : '')
+    + (opts.mockupB64 ? '\n\nHÁ UM MOCKUP DE REFERÊNCIA em anexo: o design system deve REPRODUZIR fielmente esse mockup (paleta, estrutura, componentes, espaçamentos). Descreva-o com precisão.' : '');
+  const r = opts.mockupB64
+    ? await _llmVision({ token, model: designer, text: sys + '\n\n' + userMsg, imageB64: opts.mockupB64, maxTokens: 2000 })
+    : await _llmText({ token, model: designer, system: sys, user: userMsg, maxTokens: 2000 });
+  return { brief: r.text, credits: r.credits };
+}
+
+// Parser tolerante: modelos pequenos às vezes devolvem JSON com fence, vírgula
+// sobrando, ou TRUNCADO no meio (max_tokens acabou). Recupera o máximo possível.
+function _tolerantJson(text) {
+  let s = String(text).replace(/```(?:json)?/gi, '').trim();
+  const open = s.indexOf('{');
+  if (open >= 0) s = s.slice(open);
+  try { return JSON.parse(s); } catch (_) {}
+  // 1) tenta fechar chaves/colchetes abertos (JSON truncado) + tira vírgula sobrando
+  try {
+    let t = s.replace(/,\s*([}\]])/g, '$1');
+    const opens = (t.match(/[{[]/g) || []).length, closes = (t.match(/[}\]]/g) || []).length;
+    // corta um eventual objeto pela metade no fim, depois fecha
+    if (opens > closes) { t = t.replace(/,\s*\{[^{}]*$/, ''); t += ']'.repeat(0); }
+    // fecha na ordem certa contando o que abriu
+    const stack = [];
+    for (const ch of t) { if (ch === '{') stack.push('}'); else if (ch === '[') stack.push(']'); else if (ch === '}' || ch === ']') stack.pop(); }
+    while (stack.length) t += stack.pop();
+    t = t.replace(/,\s*([}\]])/g, '$1');
+    return JSON.parse(t);
+  } catch (_) {}
+  // 2) último recurso: extrai as descrições por regex (ignora o item cortado)
+  const descs = [...s.matchAll(/"desc"\s*:\s*"((?:[^"\\]|\\.)*)"/g)].map(m => m[1].replace(/\\"/g, '"'));
+  if (descs.length) return { itens: descs.map((d, i) => ({ id: 'i' + (i + 1), desc: d })) };
+  return null;
+}
+
+const CHECKLIST_SYS = 'Quebre o OBJETIVO em itens VERIFICÁVEIS de entrega (3 a 15). Cada item deve ser '
+  + 'concreto e conferível (arquivo criado, comando executado com sucesso, seção escrita) — nada vago tipo "melhorar". '
+  + 'Responda APENAS JSON: {"itens":[{"id":"i1","desc":"..."},...]}. Ordene na sequência lógica de execução.';
+
+// Pergunta BINÁRIA sobre o item alvo (modelo pequeno erra listas, mas acerta sim/não).
+const MARK_SYS = 'Você é o VERIFICADOR de uma missão. Recebe UM item do checklist e o RESULTADO da rodada que tentou executá-lo. '
+  + 'Responda APENAS JSON: {"passou":true|false,"tambem_concluidos":["ids de OUTROS itens do checklist que o resultado comprova, se houver"],"reason":"1 linha"}. '
+  + 'passou=true SÓ com EVIDÊNCIA no resultado (arquivo com caminho, saída de comando, confirmação explícita do que o item pede) — na dúvida, passou=false.';
+
+const fmtChecklist = (itens) => itens.map(it => `[${it.passes ? 'x' : it.blocked ? '!' : ' '}] (${it.id}) ${it.desc}`).join('\n');
+
+async function makeChecklist(goal, token) {
+  const r = await _llmJson({ token, system: CHECKLIST_SYS, user: 'OBJETIVO:\n' + goal, maxTokens: 1600 });
+  const itens = (Array.isArray(r.json?.itens) ? r.json.itens : []).slice(0, 15)
+    .map((it, i) => ({ id: String(it.id || 'i' + (i + 1)), desc: String(it.desc || '').slice(0, 300), passes: false, attempts: 0 }))
+    .filter(it => it.desc);
+  return { itens: itens.length ? itens : [{ id: 'i1', desc: String(goal).slice(0, 300), passes: false, attempts: 0 }], credits: r.credits };
+}
+
+/**
+ * Roda (ou retoma) a missão do diretório atual.
+ * opts: token, lang, yes, budget, maxRounds, dir,
+ *       onChecklist(itens), onRound({n,item}), onRoundDone({marks,credits}),
+ *       onStep/askApprove/onRemote (repassados pro agente)
+ * Retorna o estado final {status: done|paused, ...}.
+ */
+async function run(goal, opts = {}) {
+  const { token, lang = 'pt', yes = false, budget = 400, maxRounds = 20, dir = process.cwd(), model = null, thinker = null, maxMinutes = 0, designer = null, design = 'auto', runGate = true, eye = null, visualLadder = true } = opts;
+  const onChecklist = opts.onChecklist || (() => {});
+  const onRound = opts.onRound || (() => {});
+  const onRoundDone = opts.onRoundDone || (() => {});
+  const onAlert = opts.onAlert || (() => {}); // avisos (escalonei / preciso de você / travei)
+  const startMs = Date.now();
+
+  let st = load(dir);
+  if (!st || st.status === 'done') {
+    if (!goal) return null; // nada pra retomar
+    // SCAFFOLD (base oficial): projeto novo de tipo conhecido nasce do gerador oficial
+    let scaffoldCred = 0;
+    try { const sc = scaffold(goal, dir, onAlert); if (sc) onAlert({ type: 'setup', text: `🏗 ts: base ${sc.kind} criada pelo gerador oficial (menos erro de build).` }); } catch (_) {}
+    // FASE DE VIABILIDADE: avalia o POSSÍVEL e escopa honesto antes de codar app ambicioso
+    let feasBrief = null, feasCred = 0;
+    const feasMode = opts.feasibility === undefined ? 'auto' : opts.feasibility;
+    const feasModel = thinker || 'grok-4.5';
+    if (feasMode === true || (feasMode === 'auto' && looksComplex(goal))) {
+      onRound({ n: 0, item: (lang === 'en' ? `Checking feasibility with ${feasModel}…` : `Avaliando viabilidade com ${feasModel}…`), attempt: 1 });
+      try { const fe = await feasibilityPhase(goal, feasModel, token); feasBrief = fe.brief; feasCred = fe.credits || 0; try { fs.writeFileSync(path.join(dir, 'VIABILIDADE.md'), feasBrief); } catch (_) {} onAlert({ type: 'design', text: `🔎 ts: viabilidade avaliada (${feasModel}, ${feasCred} créditos) — o que dá e o que não dá está fixado. Salvo em VIABILIDADE.md.` }); } catch (_e) { if (_e && _e.code === 'no_credits') throw _e; }
+    }
+    // FASE DE DESIGN (nova missão visual): o designer forte projeta o design system
+    // ANTES do checklist e do código, pra o app sair bonito de fábrica.
+    let designBrief = null, designCred = 0;
+    const wantDesign = design === true || (design === 'auto' && looksVisual(goal));
+    if (wantDesign && designer) {
+      onRound({ n: 0, item: (lang === 'en' ? `Designing the visual with ${designer}…` : `Projetando o visual com ${designer}…`), attempt: 1 });
+      let mockupB64 = null;
+      if (opts.mockup) { try { mockupB64 = fs.readFileSync(opts.mockup).toString('base64'); onAlert({ type: 'design', text: `🖼 ts: mockup de referência carregado (${path.basename(opts.mockup)}) — o designer vai projetar a partir dele e o olho vai cobrar fidelidade.` }); } catch (_) { onAlert({ type: 'design', text: `⚠ ts: não consegui ler o mockup ${opts.mockup} — seguindo sem ele.` }); } }
+      try { const d = await designPhase(goal, designer, token, { dir, mockupB64, kind: _projKind(goal, dir) }); designBrief = d.brief; designCred = d.credits || 0; try { fs.writeFileSync(path.join(dir, 'DESIGN.md'), designBrief); } catch (_) {} onAlert({ type: 'design', text: `🎨 ts: design system criado pelo ${designer} (${designCred} créditos) — o app vai seguir esse visual. Salvo em DESIGN.md.` }); } catch (_e) { if (_e && _e.code === 'no_credits') throw _e; }
+    }
+    // FASE DE ARQUITETURA (3º pilar): app complexo ganha um CONTRATO antes do checklist
+    let archBrief = null, archCred = 0;
+    const archMode = opts.arch === undefined ? 'auto' : opts.arch;
+    const archModel = thinker || 'grok-4.5';
+    if (archMode === true || (archMode === 'auto' && looksComplex(goal))) {
+      onRound({ n: 0, item: (lang === 'en' ? `Designing the architecture with ${archModel}…` : `Projetando a arquitetura com ${archModel}…`), attempt: 1 });
+      try { const a = await archPhase(goal, archModel, token, { dir }); archBrief = a.brief; archCred = a.credits || 0; try { fs.writeFileSync(path.join(dir, 'ARQUITETURA.md'), archBrief); } catch (_) {} onAlert({ type: 'design', text: `📐 ts: contrato de arquitetura criado pelo ${archModel} (${archCred} créditos) — componentes, arquivos e assinaturas fixados. Salvo em ARQUITETURA.md.` }); } catch (_e) { if (_e && _e.code === 'no_credits') throw _e; }
+    }
+    const mk = await makeChecklist(goal + (designBrief ? '\n\n[Há um DESIGN SYSTEM definido — o checklist deve refletir a aplicação desse visual]' : '') + (archBrief ? '\n\n[Há um CONTRATO DE ARQUITETURA definido — os itens devem seguir os componentes/arquivos dele]' : ''), token);
+    st = { goal: String(goal).slice(0, 4000), mockup: opts.mockup || null, archBrief, feasBrief, checklist: mk.itens, rounds: [], creditsSpent: (mk.credits || 0) + designCred + archCred + feasCred,
+      budget, maxRounds, status: 'running', model: model || null, designBrief: designBrief || null, created_at: new Date().toISOString() };
+    save(st, dir);
+  } else {
+    st.status = 'running';
+    if (opts.addBudget) st.budget += opts.addBudget;
+    else if (st.creditsSpent >= st.budget) st.budget = st.creditsSpent + budget; // nova janela ao retomar
+  }
+  const useModel = model || st.model || null; // executor fixo persiste entre retomadas
+  const useThinker = thinker || st.thinker || null; // modelo caro "pensador" (escalonamento)
+  if (thinker && !st.thinker) { st.thinker = thinker; save(st, dir); }
+  onChecklist(st.checklist);
+
+  const _sig = (s) => String(s || '').replace(/[0-9]/g, '#').slice(0, 200); // assinatura do erro (ignora números de linha)
+
+  for (;;) {
+    // ── FREIO DE RELÓGIO (watchdog): encerra se passar do tempo máximo ──
+    if (maxMinutes > 0 && (Date.now() - startMs) > maxMinutes * 60000) {
+      st.status = 'paused'; st.pause_reason = 'timeout'; save(st, dir);
+      onAlert({ type: 'timeout', text: `⏱ ts: missão pausada por tempo (${maxMinutes} min). Retome com "ts meta".` });
+      return st;
+    }
+    let pend = st.checklist.filter(it => !it.passes && !it.blocked);
+    // PORTÃO DE BUILD/RUN/VISUAL: projeto compilável só termina quando compila DE VERDADE,
+    // ABRE sem crashar E o "olho" aprova o layout. O portão REENTRA enquanto o visual não passa.
+    if (!pend.length) {
+      const b = detectBuild(dir);
+      const buildCapLeft  = (st.buildFixes  || 0) < MAX_BUILD_FIXES;
+      // teto de polimento visual: menor pra Flutter (rebuild caro/lento) que pra Android
+      const visualCap = (b && b.kind === 'flutter') ? MAX_VISUAL_FIXES_FLUTTER : MAX_VISUAL_FIXES;
+      const visualCapLeft = !!eye && (st.visualFixes || 0) < visualCap;
+      // Roda o portão se: (a) ainda não compilou de verdade, OU (b) compilou/abriu mas o VISUAL ainda não foi aprovado.
+      const gateNeeded = b && ((!st.buildVerified && buildCapLeft) || (st.buildVerified && !st.visualOk && visualCapLeft));
+      if (gateNeeded) {
+        let errText = null;   // preenchido só em erro REAL de build/crash (dispara escalonamento); visual usa outro caminho
+        onRound({ n: st.rounds.length + 1, item: (lang === 'en' ? 'Compiling for real (build gate)…' : 'Compilando de verdade (portão de build)…'), attempt: 1 });
+        ensureToolchain(b, onAlert);
+        // ANÁLISE ESTÁTICA (barata) ANTES do build pesado — pega erro de código de graça
+        let r = null;
+        if (!st.buildVerified) {
+          const sc = staticCheck(b);
+          if (sc && !sc.ok) { onRound({ n: st.rounds.length + 1, item: (lang === 'en' ? 'Static analysis found errors (fixing before the heavy build)…' : 'Análise estática achou erros (corrigindo antes do build pesado)…'), attempt: 1 }); r = { ok: false, out: sc.out }; }
+        }
+        if (!r) r = runBuild(b);
+        if (r.ok) {
+          // ── RUN GATE: compilou → ABRE o app de verdade e vê se crasha (só se houver
+          // emulador/aparelho e o gate estiver ligado). Crash de runtime vira "erro" pro executor.
+          // Vale pra Android (Gradle) E Flutter — ambos geram APK instalável no emulador.
+          if (runGate && (b.kind === 'android' || b.kind === 'flutter')) {
+            onRound({ n: st.rounds.length + 1, item: (lang === 'en' ? 'Launching the app on the emulator (run gate)…' : 'Abrindo o app no emulador (run gate)…'), attempt: 1 });
+            const rg = runApp(b, dir, onAlert);
+            if (rg.skipped) { st.buildVerified = true; st.visualOk = true; st.status = 'done'; st.runNote = 'run gate pulado: ' + rg.reason; st.finished_at = new Date().toISOString(); save(st, dir); onRoundDone({ checklist: st.checklist, spent: st.creditsSpent }); return st; }
+            if (rg.ok) {
+              st.buildVerified = true; st.runVerified = true;
+              // ── VISUAL GATE: app abre → tira print e o "olho" critica o layout.
+              // Reprovou → vira "erro" pro executor melhorar; portão REENTRA (rebuild+print) até aprovar ou estourar o teto.
+              if (visualCapLeft) {
+                onRound({ n: st.rounds.length + 1, item: (lang === 'en' ? `Reviewing the visual with ${eye} (visual gate)…` : `Avaliando o visual com ${eye} (visual gate)…`), attempt: 1 });
+                let vg = { ok: true };
+                let mockB64 = null; if (st.mockup) { try { mockB64 = fs.readFileSync(st.mockup).toString('base64'); } catch (_) {} }
+                try { vg = await visualGate(b, dir, eye, token, st.designBrief, mockB64); } catch (_) {}
+                st.creditsSpent += vg.credits || 0;
+                if (!vg.ok && !vg.skipped && vg.critique) {
+                  st.visualFixes = (st.visualFixes || 0) + 1;
+                  st.buildError = 'O app compila e ABRE, mas o VISUAL foi REPROVADO por um diretor de arte rigoroso (print real do app rodando). Corrija EXATAMENTE os pontos abaixo editando os XML de layout/tema/drawables — não invente APIs, garanta que o XML compila, e capriche pra ficar UAU:\n' + vg.critique;
+                  onAlert({ type: 'design', text: `👁 ts: revisão visual (${eye}) achou defeito ESTRUTURAL no layout (${st.visualFixes}/${visualCap}). Mandando o executor corrigir e vou reavaliar.` });
+                  // vira item de correção (loop igual ao build); NÃO dispara escalonamento de build
+                  let vfix = st.checklist.find(it => it.id === 'visual_fix');
+                  if (!vfix) { vfix = { id: 'visual_fix', desc: (lang === 'en' ? 'Polish the layout until the art director approves the visual' : 'Polir o layout até o diretor de arte aprovar o visual'), passes: false, attempts: 0, isBuild: true }; st.checklist.push(vfix); }
+                  vfix.passes = false; vfix.blocked = false; vfix.attempts = 0;
+                  save(st, dir);
+                  onRoundDone({ checklist: st.checklist, spent: st.creditsSpent, buildFailed: true });
+                  pend = [vfix];
+                } else {
+                  // Aprovado: impecável OU só com nitpicks cosméticos (não vale queimar rodada cara).
+                  st.visualOk = true;
+                  if (vg.severity === 'ressalvas') { st.runNote = (st.runNote || '') + ' visual aprovado com ressalvas cosméticas (sem defeito estrutural)'; onAlert({ type: 'design', text: `👁 ts: visual APROVADO — sobrou só nitpick cosmético (sem defeito estrutural). Não vou gastar polimento caro à toa.` }); }
+                  st.status = 'done'; st.finished_at = new Date().toISOString(); save(st, dir); onRoundDone({ checklist: st.checklist, spent: st.creditsSpent }); return st;
+                }
+              } else { st.visualOk = true; st.status = 'done'; st.finished_at = new Date().toISOString(); save(st, dir); onRoundDone({ checklist: st.checklist, spent: st.creditsSpent }); return st; }
+            } else {
+              // CRASHOU ao abrir → trata como erro pro executor corrigir (loop igual ao build)
+              st.buildFixes = (st.buildFixes || 0) + 1;
+              errText = 'CRASH DE RUNTIME (o app compila mas FECHA ao abrir). Corrija a CAUSA-RAIZ no código (não é erro de build):\n' + rg.crash;
+              st.buildError = errText;
+            }
+          } else if (runGate && b.kind === 'web') {
+            // ── GATE WEB: sobe o servidor de verdade + Chrome headless (console/erros/print).
+            onRound({ n: st.rounds.length + 1, item: (lang === 'en' ? 'Starting the web server and testing in the browser (web gate)…' : 'Subindo o servidor web e testando no navegador (gate web)…'), attempt: 1 });
+            let wg = { ok: true }; try { wg = await webRunGate(b); } catch (_) {}
+            if (wg.ok) {
+              st.buildVerified = true; st.runVerified = true; st.visualOk = true;
+              if (wg.shot) st.webShot = wg.shot;
+              st.status = 'done'; st.finished_at = new Date().toISOString(); save(st, dir); onRoundDone({ checklist: st.checklist, spent: st.creditsSpent }); return st;
+            } else {
+              st.buildFixes = (st.buildFixes || 0) + 1;
+              errText = 'GATE WEB — o servidor precisa SUBIR e a página abrir SEM erro de console/runtime. Corrija a CAUSA-RAIZ (backend ou frontend):\n' + wg.crash;
+              st.buildError = errText;
+            }
+          } else {
+            st.buildVerified = true; st.visualOk = true; st.status = 'done'; st.finished_at = new Date().toISOString(); save(st, dir); onRoundDone({ checklist: st.checklist, spent: st.creditsSpent }); return st;
+          }
+        } else { st.buildFixes = (st.buildFixes || 0) + 1; errText = r.out; st.buildError = r.out; }
+        // ── ESCALONAMENTO: só em erro REAL de build/crash. Mesmo erro de novo → PENSADOR caro diagnostica ──
+        if (errText) {
+          const sig = _sig(st.buildError);
+          st.escalationHint = null;
+          if (useThinker && sig === st.lastBuildSig && (st.escalations || 0) < MAX_ESCALATIONS) {
+            onRound({ n: st.rounds.length + 1, item: (lang === 'en' ? `Stuck — escalating to ${useThinker} to diagnose…` : `Travado — escalando pro ${useThinker} diagnosticar…`), attempt: 1 });
+            try {
+              const e = await escalate(errText, dir, useThinker, token);
+              st.escalations = (st.escalations || 0) + 1; st.creditsSpent += e.credits || 0; st.escalationHint = e.hint;
+              onAlert({ type: 'escalate', text: `🧠 ts: travei num erro, escalei pro ${useThinker} (${st.escalations}/${MAX_ESCALATIONS}). Aplicando o diagnóstico.` });
+            } catch (_) {}
+          }
+          st.lastBuildSig = sig;
+          let fixItem = st.checklist.find(it => it.id === 'build_fix');
+          if (!fixItem) { fixItem = { id: 'build_fix', desc: (lang === 'en' ? 'Fix compile errors until the build succeeds and the APK is generated' : 'Corrigir os erros de compilação até o build passar e o APK ser gerado'), passes: false, attempts: 0, isBuild: true }; st.checklist.push(fixItem); }
+          fixItem.passes = false; fixItem.blocked = false;
+          save(st, dir);
+          onRoundDone({ checklist: st.checklist, spent: st.creditsSpent, buildFailed: true });
+          pend = [fixItem];
+        }
+      } else if (!st.buildVerified || (eye && !st.visualOk)) {
+        // Portão precisava rodar mas estourou o teto (build ou visual): encerra registrando a limitação.
+        st.buildVerified = true; st.visualOk = true;
+        st.status = 'done'; st.finished_at = new Date().toISOString();
+        st.runNote = (st.runNote || '') + (visualCapLeft ? '' : ' visual: teto de polimentos atingido');
+        save(st, dir); onRoundDone({ checklist: st.checklist, spent: st.creditsSpent }); return st;
+      } else {
+        st.status = 'done'; st.finished_at = new Date().toISOString(); save(st, dir);
+        return st;
+      }
+    }
+    if (st.rounds.length >= st.maxRounds) { st.status = 'paused'; st.pause_reason = 'max_rounds'; save(st, dir); return st; }
+    if (st.creditsSpent >= st.budget) { st.status = 'paused'; st.pause_reason = 'budget'; save(st, dir); onAlert({ type: 'budget', text: `💳 ts: teto de créditos (${st.budget}) atingido. Retome com "ts meta".` }); return st; }
+    // ── WATCHDOG DE ESTAGNAÇÃO: girando no mesmo lugar (0 item novo + mesmo erro) → corta ──
+    // inclui visualFixes: cada polimento visual conta como progresso (senão o loop visual, que faz o item oscilar
+    // com o mesmo lastBuildSig, dispararia estagnação falsa). NÃO inclui buildFixes — senão mascararia a estagnação real de build.
+    const fp = st.checklist.filter(i => i.passes).length + '|' + (st.lastBuildSig || '') + '|v' + (st.visualFixes || 0);
+    if (fp === st.lastFp) { st.stagnant = (st.stagnant || 0) + 1; } else { st.stagnant = 0; st.lastFp = fp; }
+    if (st.stagnant >= STAGNATION_LIMIT) {
+      st.status = 'paused'; st.pause_reason = 'stagnated'; save(st, dir);
+      onAlert({ type: 'stagnated', text: `🛑 ts: a missão travou (sem progresso em ${STAGNATION_LIMIT} rodadas). Parei pra não desperdiçar créditos. Precisa de você: "${st.buildError ? String(st.buildError).replace(/\s+/g, ' ').slice(0, 140) : st.goal.slice(0, 100)}"` });
+      return st;
+    }
+
+    const item = pend[0];
+    item.attempts = (item.attempts || 0) + 1;
+    onRound({ n: st.rounds.length + 1, item: item.desc, attempt: item.attempts });
+
+    // Rodada com CONTEXTO ZERADO: o agente recebe só o essencial (objetivo resumido +
+    // estado do checklist + resultado da rodada anterior) — nunca o histórico inteiro.
+    const last = st.rounds[st.rounds.length - 1];
+    const files = projectMap(dir);
+    const mapBlock = files.length
+      ? (lang === 'en' ? `\nPROJECT FILES (already exist — go straight to the one you need, do NOT list/search dirs):\n` : `\nARQUIVOS DO PROJETO (já existem — vá direto ao que precisa, NÃO liste/busque diretórios):\n`) + files.join('\n') + '\n'
+      : '';
+    // DESIGN SYSTEM: injeta o brief do designer em TODA rodada — o executor implementa
+    // exatamente esse visual (cores/tokens/componentes), sem cair no Material padrão.
+    const designBlock = st.designBrief
+      ? (lang === 'en' ? `\nDESIGN SYSTEM (a senior designer defined this — FOLLOW IT EXACTLY: colors, tokens, component specs, especially the bottom navigation):\n${String(st.designBrief).slice(0, 3500)}\n` : `\nDESIGN SYSTEM (um designer sênior definiu isto — SIGA À RISCA: cores, tokens, specs de cada componente, especialmente a bottom navigation):\n${String(st.designBrief).slice(0, 3500)}\n`)
+      : '';
+    // REGRAS DE VIDA do usuário (~/.ts/regras.md + .ts-regras.md): lições que valem em TODA rodada
+    const rulesTxt = loadRules(dir);
+    const rulesBlock = rulesTxt ? `\nREGRAS DO USUÁRIO (lições de projetos anteriores — OBRIGATÓRIAS):\n${rulesTxt}\n` : '';
+    // CONTRATO DE ARQUITETURA: nomes/assinaturas/arquivos EXATOS — evita referência quebrada entre rodadas
+    const archBlock = st.archBrief
+      ? `\nCONTRATO DE ARQUITETURA (um arquiteto sênior fixou isto — USE OS NOMES, ASSINATURAS E CAMINHOS LITERALMENTE, nunca invente variações):\n${String(st.archBrief).slice(0, 2500)}\n`
+      : '';
+    // VIABILIDADE: o que dá e o que NÃO dá — implemente a versão realista, não tente o impossível
+    const feasBlock = st.feasBrief
+      ? `\nVIABILIDADE (respeite os limites técnicos — implemente a VERSÃO REALISTA das partes impossíveis, não perca rodadas tentando o que a plataforma não permite):\n${String(st.feasBrief).slice(0, 1200)}\n`
+      : '';
+    // SEED (app web com login): o gate web VERIFICA logando com um usuário de seed. Sem um seed
+    // funcional de credenciais FIXAS, as telas internas ficam sem teste. Regra injetada só em web.
+    const seedBlock = _projKind(st.goal, dir) === 'web'
+      ? (lang === 'en'
+        ? `\nIF THE APP HAS LOGIN/AUTH: in the initial seed, create a DEMO user with FIXED, KNOWN credentials in PLAINTEXT in the code (e.g. email "demo@demo.com" / password "demo1234"), already with some sample data, and make sure login works with it. The system VERIFIES the app by LOGGING IN with that user — without a working seed the internal screens (dashboard etc.) cannot be tested.\n`
+        : `\nSE O APP TIVER LOGIN/AUTENTICAÇÃO: no seed inicial, crie um usuário DEMO com credenciais FIXAS e conhecidas em TEXTO no código (ex: email "demo@demo.com" / senha "demo1234"), já com alguns dados de exemplo, e garanta que o login funciona com ele. O sistema VERIFICA o app LOGANDO com esse usuário — sem um seed funcional as telas internas (dashboard etc.) não têm como ser testadas.\n`)
+      : '';
+    // CÓDIGO MÍNIMO (anti-overengineering, estilo "programador preguiçoso" — ideia da skill
+    // Ponytail): escada de perguntas ANTES de codar → menos código = menos tokens = menos
+    // bugs = mais barato. Reportado na origem: -54% de código e -20% de custo, mesmo resultado.
+    const minimalBlock = (lang === 'en'
+      ? `\nMINIMAL-CODE RULES (economy — mandatory, think like a pragmatic lazy senior):\n1) Does this really need to exist? If not, don't build it.\n2) Does it already exist in this project? If yes, REUSE it — never rewrite a second version.\n3) Does the language/platform/browser already do it natively? If yes, use the native thing (e.g. <input type="date"> instead of a datepicker lib; fetch instead of axios; CSS instead of a JS animation lib).\n4) Only then write code — the MINIMUM that solves the item. NO extra library without real need, no gratuitous abstractions/wrappers, no speculative "future-proofing".\n`
+      : `\nREGRAS DE CÓDIGO MÍNIMO (economia — obrigatórias; pense como um sênior pragmático e "preguiçoso"):\n1) Isso precisa mesmo existir? Se não precisa, NÃO construa.\n2) Já existe neste projeto? Se sim, REUSE — nunca escreva uma segunda versão.\n3) A linguagem/plataforma/navegador já faz isso nativo? Se sim, use o nativo (ex: <input type="date"> em vez de lib de datepicker; fetch em vez de axios; CSS em vez de lib JS de animação).\n4) Só então escreva código — o MÍNIMO que resolve o item. SEM biblioteca extra sem necessidade real, sem abstração/wrapper gratuito, sem "preparar pro futuro" especulativo.\n`);
+    const task = feasBlock + archBlock + designBlock + seedBlock + rulesBlock + minimalBlock + (lang === 'en'
+      ? `Bigger goal (context — do NOT do everything now):\n${st.goal.slice(0, 800)}\n\nCHECKLIST (state):\n${fmtChecklist(st.checklist)}\n${mapBlock}`
+      : `Objetivo maior (contexto — NÃO faça tudo agora):\n${st.goal.slice(0, 800)}\n\nCHECKLIST (estado):\n${fmtChecklist(st.checklist)}\n${mapBlock}`)
+      + (last ? `\n${lang === 'en' ? 'Previous round' : 'Rodada anterior'}: ${String(last.result || '').slice(0, 600)}\n` : '')
+      + (item.attempts > 1
+        ? (lang === 'en' ? `\nPREVIOUS ATTEMPT at this item FAILED — use a DIFFERENT approach now.\n` : `\nA tentativa ANTERIOR deste item FALHOU — use uma abordagem DIFERENTE agora.\n`)
+        : '')
+      + (item.id === 'visual_fix' && st.buildError
+        ? (lang === 'en' ? `\nAn ART DIRECTOR reviewed REAL screenshots and REJECTED the layout. Fix ONLY the points below by editing the layout/theme/drawable XML. RULES: fix the exact issue, do NOT redesign or add decorative backgrounds/blobs/ellipses behind rows (that makes it uglier); for clipped horizontal rows use a real HorizontalScrollView/RecyclerView with android:clipToPadding="false" and equal start/end padding so first AND last items show fully; keep it clean and minimal. Do NOT run the build yourself (the system re-checks and re-screenshots automatically):\n${st.buildError}\n` : `\nUm DIRETOR DE ARTE revisou PRINTS REAIS e REPROVOU o layout. Corrija APENAS os pontos abaixo editando os XML de layout/tema/drawable. REGRAS: conserte exatamente o problema, NÃO redesenhe nem adicione fundos/blobs/elipses decorativos atrás das fileiras (fica mais feio); pra fileira horizontal cortada use um HorizontalScrollView/RecyclerView de verdade com android:clipToPadding="false" e padding start/end IGUAIS pra o 1º E o último item aparecerem inteiros; mantenha limpo e minimalista. NÃO rode o build você mesmo (o sistema recompila e reprinta sozinho):\n${st.buildError}\n`)
+        : '')
+      + (item.isBuild && item.id !== 'visual_fix' && st.buildError
+        ? (lang === 'en' ? `\nThe REAL build just FAILED with these errors — fix the ROOT CAUSE (missing resource/import/file, wrong reference, version). Edit the files, do NOT re-run the build yourself (the system re-checks automatically):\n${st.buildError}\n` : `\nO build REAL acabou de FALHAR com estes erros — corrija a CAUSA-RAIZ (recurso/import/arquivo faltando, referência errada, versão). EDITE os arquivos; NÃO rode o build você mesmo (o sistema recompila sozinho):\n${st.buildError}\n`)
+        : '')
+      + (item.isBuild && st.escalationHint
+        ? (lang === 'en' ? `\nA SENIOR ENGINEER diagnosed the root cause and the exact fix — APPLY IT precisely:\n${st.escalationHint}\n` : `\nUm ENGENHEIRO SÊNIOR diagnosticou a causa-raiz e o fix exato — APLIQUE EXATAMENTE isto:\n${st.escalationHint}\n`)
+        : '')
+      + (lang === 'en'
+        ? `\nExecute NOW only this item: ${item.desc}\nBe DIRECT: do the item and stop — do NOT re-read or re-verify the whole project (wastes credits). At the end, state the full path of each file you created/changed.`
+        : `\nExecute AGORA apenas este item: ${item.desc}\nSeja DIRETO: faça o item e pare — NÃO releia nem revise o projeto inteiro (gasta créditos à toa). NUNCA use a ferramenta preciso_de_voce pra: pedir TESTE/instalação (o SISTEMA compila/instala/abre/testa sozinho a cada rodada), pedir CAMINHO DO SDK/Flutter/toolchain (o sistema provisiona sozinho — o SDK está no objetivo e o build gate cuida do local.properties), nem pedir QUALQUER informação que já esteja no objetivo. Se um caminho/valor está no objetivo, USE-O; não pergunte. A ferramenta preciso_de_voce é SÓ pra ação externa impossível pro agente (chave de API paga, criar conta, pagamento). Na dúvida, AJA com o que tem — não pare pra perguntar. No final, informe o caminho completo de cada arquivo criado/alterado.`);
+
+    // RESILIÊNCIA: um blip de rede (conn) NÃO pode matar a missão inteira (crítico pra
+    // rodar a noite). Retenta a rodada até 3x com espera crescente; se persistir, PAUSA
+    // resumível (o estado e os arquivos ficam salvos; "ts meta" continua).
+    // ── ESCADA VISUAL: o deepseek (barato) VÊ certo mas ERRA o fix de layout complexo
+    // (achado real: envolveu ícones num "ovo" roxo, cores continuaram cortadas). Depois de
+    // VISUAL_ESCALATE_AT reprovações do olho no MESMO item de layout, a MÃO do fix passa a
+    // ser o modelo forte (o pensador/olho, grok-4.5) — que sabe compor layout. Volta ao
+    // barato assim que o olho aprovar (visual_fix some do checklist). Só nas rodadas visuais.
+    let roundModel = useModel;
+    if (visualLadder && item.id === 'visual_fix' && (st.visualFixes || 0) >= VISUAL_ESCALATE_AT && (useThinker || eye)) {
+      roundModel = useThinker || eye;
+      onAlert({ type: 'escalate', text: `🎨 ts: o olho reprovou o layout ${st.visualFixes}x — passando a MÃO do fix visual pro ${roundModel} (mais forte em layout) até aprovar.` });
+    }
+    let out = null, connErr = null;
+    for (let att = 0; att < 3 && !out; att++) {
+      try { out = await agent.run(task, { token, lang, yes, model: roundModel, confineDir: dir, skipSessionStart: true, onStep: opts.onStep, askApprove: opts.askApprove, onRemote: opts.onRemote, onThinking: opts.onThinking }); }
+      catch (e) {
+        connErr = e;
+        // teto de IA estourado → PAUSA limpa e resumível com CTA de upgrade (nunca segue em silêncio)
+        if (e && e.code === 'no_credits') {
+          st.status = 'paused'; st.pause_reason = 'no_credits'; save(st, dir);
+          onAlert({ type: 'no_credits', text: `💳 ts: seu limite de IA acabou — a missão foi PAUSADA e salva. Assine um plano em terminalsmart.com.br/planos e retome com "ts meta".` });
+          return st;
+        }
+        if (e && (e.code === 'conn' || String(e.message).includes('fetch') || String(e.message).includes('network'))) { onAlert({ type: 'retry', text: `📡 ts: falha de conexão na rodada — tentando de novo (${att + 1}/3)…` }); await new Promise(r => setTimeout(r, 4000 * (att + 1))); }
+        else throw e; // erro não-transitório: sobe
+      }
+    }
+    if (!out) { st.status = 'paused'; st.pause_reason = 'connection'; save(st, dir); onAlert({ type: 'conn', text: `📡 ts: sem conexão com o servidor após 3 tentativas. Missão PAUSADA e salva. Retome com "ts meta" quando a internet voltar.` }); return st; }
+    st.creditsSpent += out.credits || 0;
+
+    // ── BLOQUEIO HUMANO: o agente pediu uma ação externa que só o usuário faz ──
+    // A missão PAUSA (gasto zero enquanto espera) e chama o usuário. Retoma com "ts meta".
+    if (out.needHuman) {
+      st.status = 'paused'; st.pause_reason = 'awaiting_human';
+      st.humanRequest = { motivo: out.needHuman.motivo, o_que_fazer: out.needHuman.o_que_fazer, at: new Date().toISOString() };
+      st.rounds.push({ item: item.desc, id: item.id, result: '[aguardando ação humana] ' + out.needHuman.motivo, credits: out.credits || 0, steps: out.steps || 0, at: new Date().toISOString() });
+      save(st, dir);
+      onAlert({ type: 'human', text: `🙋 ts precisa de você:\n${out.needHuman.motivo}\n\nO que fazer:\n${out.needHuman.o_que_fazer}\n\nQuando terminar, rode "ts meta" pra continuar.` });
+      onRoundDone({ checklist: st.checklist, spent: st.creditsSpent, needHuman: true });
+      return st;
+    }
+
+    // MARCAÇÃO — evidência OBJETIVA primeiro (grátis, à prova de falso-negativo do modelo):
+    // se o item pede um arquivo e a rodada gravou um arquivo com esse nome, PASSA direto.
+    // (Bug real do teste MultiApps: flash-lite bloqueou itens cujos arquivos existiam no disco.)
+    let marks = [];
+    const written = (out.actions || []).filter(a => a.name === 'escrever_arquivo' || a.name === 'editar_arquivo').map(a => String(a.target || ''));
+    const ranOk = (out.actions || []).some(a => a.name === 'executar_comando');
+    const _basename = (p) => String(p).replace(/\\/g, '/').split('/').pop().toLowerCase();
+    const _fileHints = (txt) => (String(txt).match(/[\w.\-]+\.(kt|java|xml|gradle|json|md|txt|kts|properties|pro|png|webp|py|js|ts|html|css|sh)\b/gi) || []).map(s => s.toLowerCase());
+    const itemFiles = _fileHints(item.desc);
+    const wroteForItem = itemFiles.length
+      ? itemFiles.some(f => written.some(w => _basename(w) === f))
+      : written.length > 0; // item sem nome de arquivo explícito mas a rodada produziu algo
+    if (wroteForItem || (ranOk && !itemFiles.length)) marks.push(item.id);
+
+    // Item de correção de build: NÃO usa marcador — o PORTÃO DE BUILD é a única
+    // autoridade (recompila de verdade). Marca provisório pra reabrir o gate; se o
+    // build ainda falhar, o gate reabre o item automaticamente.
+    if (item.isBuild) {
+      marks = [item.id];
+      for (const it of st.checklist) if (marks.includes(it.id)) it.passes = true;
+      if (!item.passes && item.attempts >= 99) item.blocked = true; // nunca bloqueia por tentativas — o gate controla
+      st.rounds.push({ item: item.desc, id: item.id, result: String(out.text || '').slice(0, 1500), credits: out.credits || 0, steps: out.steps || 0, at: new Date().toISOString() });
+      save(st, dir);
+      onRoundDone({ marks, credits: out.credits || 0, checklist: st.checklist, spent: st.creditsSpent });
+      continue;
+    }
+
+    // Marcador IA como REFORÇO: confirma o alvo se a evidência objetiva não pegou, e
+    // credita OUTROS itens do checklist que a rodada também concluiu.
+    try {
+      const evid = written.length ? '\n\nARQUIVOS REALMENTE GRAVADOS nesta rodada (evidência objetiva):\n' + written.map(_basename).join(', ') : '';
+      const mk = await _llmJson({ token, system: MARK_SYS,
+        user: `OBJETIVO:\n${st.goal.slice(0, 600)}\n\nCHECKLIST (contexto):\n${fmtChecklist(st.checklist)}\n\nITEM ALVO: (${item.id}) ${item.desc}\n\nRESULTADO DA RODADA:\n${String(out.text || '').slice(0, 2000)}${evid}` });
+      st.creditsSpent += mk.credits || 0;
+      if (mk.json && mk.json.passou === true) marks.push(item.id);
+      if (Array.isArray(mk.json?.tambem_concluidos)) marks.push(...mk.json.tambem_concluidos.map(String));
+    } catch (_) {}
+    marks = [...new Set(marks)];
+    for (const it of st.checklist) if (marks.includes(it.id)) it.passes = true;
+    // anti-travamento: item que já tentou 2x sem passar é BLOQUEADO (relatado no fim)
+    if (!item.passes && item.attempts >= MAX_ATTEMPTS_PER_ITEM) item.blocked = true;
+
+    st.rounds.push({ item: item.desc, id: item.id, result: String(out.text || '').slice(0, 1500), credits: out.credits || 0, steps: out.steps || 0, at: new Date().toISOString() });
+    save(st, dir);
+    onRoundDone({ marks, credits: out.credits || 0, checklist: st.checklist, spent: st.creditsSpent });
+  }
+}
+
+// Notificação no Telegram do dono (best-effort — sem canal, segue em silêncio)
+async function notify(token, text) {
+  try { await api('/api/cli/notify', { method: 'POST', token, body: { text }, timeoutMs: 15000 }); } catch (_) {}
+}
+
+module.exports = { webRunGate, run, load, notify, stateFile, detectBuild, ensureToolchain, runBuild, escalate, designPhase, archPhase, looksVisual, looksComplex, runApp, visualGate, ensureEmulator, _projKind };