terminal-smart-cli 0.97.30 → 0.97.41

package/lib/meta.js

@@ -11,8 +11,11 @@ const path = require('path');
 const cp = require('child_process');
 const crypto = require('crypto');
 const compactor = require('./compactor');
+const fileLock = require('./file-lock');
 const { api, ApiError } = require('./api');
 const keyring = require('./keyring');
+const toolRunner = require('./tools');
+const intelligence = require('./intelligence-core');
 // 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.
@@ -22,6 +25,15 @@ function _capGuard(res, j) {
 }
 const agent = require('./agent');
 
+// Uma chamada de Meta pode ir direto ao gateway (sem passar pelo loop de
+// agent.js). Preserve aqui o mesmo contrato: quando escolhemos um modelo
+// específico para planejar, revisar ou recuperar uma edição, o gateway não
+// pode trocar para outro sem avisar. IDs com prefixo de provedor normalizam.
+function modelWasSubstituted(requested, returned) {
+  if (!requested || !returned) return false;
+  return intelligence.normalizeModelId(requested) !== intelligence.normalizeModelId(returned);
+}
+
 const FILE = '.ts-meta.json';
 const MAX_ATTEMPTS_PER_ITEM = 2;
 const MAX_ESCALATIONS = 3;   // quantas vezes chamamos o modelo CARO "pensador"
@@ -51,6 +63,23 @@ function artifactForMetaItem(item, st, dir = '') {
   const criteria = Array.isArray(st && st.criteria) ? st.criteria : [];
   const namedCriterion = criteria.find(c => c && c.path && d.includes(path.basename(String(c.path)).toLowerCase()));
   if (namedCriterion) return String(namedCriterion.path);
+  // Electron não usa index.html como artefato principal para o estado local.
+  // Associar a persistência ao módulo real impede que a rodada seja marcada
+  // sem prova ou que procure o fallback genérico artifacts/iN.md.
+  const electronProject = dir && fs.existsSync(path.join(dir, 'package.json'))
+    && /electron/i.test(String(fs.readFileSync(path.join(dir, 'package.json'), 'utf8')));
+  if (electronProject && /persist[êe]ncia|electron-store|salvar.*carregar|carregar.*salvar|armazenamento local/.test(d)) return 'src/store.js';
+  // Um checklist Electron precisa sempre apontar para o produto executável, nunca
+  // para o fallback artifacts/iN.md. Caso contrário o agente pode gastar uma
+  // rodada inteira escrevendo documentação sem mover o aplicativo adiante.
+  if (electronProject && /modelo de dados|filme.*s[ée]rie.*livro|estado.*nota|nota.*coment[áa]rio|tags.*progresso/.test(d)) return 'src/model.js';
+  if (electronProject && /transi[çc][ãa]o de estado|busca.*filtro|filtro.*busca/.test(d)) return 'src/model.js';
+  if (electronProject && /exporta[çc][ãa]o|importa[çc][ãa]o|backup/.test(d)) return 'src/store.js';
+  if (electronProject && /teste|verifica[çc][ãa]o automatizada|npm test/.test(d)) return 'test/core.test.js';
+  if (electronProject && /readme|instru[çc][õo]es/.test(d)) return 'README.md';
+  if (electronProject && /integra[çc][õo]es futuras|tmdb|google books/.test(d)) return 'INTEGRACOES-FUTURAS.md';
+  if (electronProject && /modelo de neg[óo]cio|freemium|privacidade|an[uú]ncio/.test(d)) return 'MODELO-DE-NEGOCIO.md';
+  if (electronProject && /interface|tela|biblioteca|descobrir|cole[çc][ãa]o demo|limpar demo/.test(d)) return 'src/index.html';
   const splitWebProject = dir && fs.existsSync(path.join(dir, 'index.html')) && fs.existsSync(path.join(dir, 'src', 'game.js'));
   // In an existing browser game, UI/HUD requests are implementation work.
   // The generic UI-spec fallback below is only for greenfield design projects.
@@ -84,6 +113,72 @@ function artifactHash(file) {
   catch (_) { return null; }
 }
 
+// A retomada não deve reabrir uma investigação inteira apenas para descobrir
+// onde fazer um ajuste já conhecido. Entregamos um recorte determinístico do
+// artefato-alvo, com números de linha, para que o executor tenha uma âncora
+// exata de edição. Isso é contexto local verificável, não uma conclusão da IA.
+function recoveryTargetExcerpt(file, item, maxChars = 7000) {
+  if (!file || !fs.existsSync(file)) return '';
+  let source;
+  try { source = fs.readFileSync(file, 'utf8'); }
+  catch (_) { return ''; }
+  const fold = value => String(value || '').normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase();
+  const ignored = new Set(['implementar', 'criar', 'fazer', 'para', 'como', 'com', 'sem', 'uma', 'este', 'esta', 'item', 'dados']);
+  const terms = [...new Set(fold(item && item.desc).match(/[a-z0-9_-]{4,}/g) || [])]
+    .filter(term => !ignored.has(term));
+  if (!terms.length) return '';
+  const lines = source.split(/\r?\n/);
+  const ranked = lines.map((line, index) => ({
+    index,
+    score: terms.reduce((total, term) => total + (fold(line).includes(term) ? 1 : 0), 0),
+  })).filter(row => row.score > 0).sort((a, b) => b.score - a.score || a.index - b.index).slice(0, 5);
+  if (!ranked.length) return '';
+  const selected = new Set();
+  for (const row of ranked) {
+    for (let index = Math.max(0, row.index - 4); index <= Math.min(lines.length - 1, row.index + 4); index++) selected.add(index);
+  }
+  const excerpt = [...selected].sort((a, b) => a - b)
+    .map(index => `${String(index + 1).padStart(5, ' ')} | ${lines[index]}`).join('\n');
+  return excerpt.slice(0, maxChars);
+}
+
+// Recuperação de microedição: quando o próprio Meta já tem a prova local e a
+// âncora exata, não delegamos de novo a escolha de ferramentas ao loop geral.
+// O DeepSeek Pro propõe exclusivamente a troca literal; o harness a aplica com
+// editar_arquivo, que exige âncora única e faz backup. Assim a IA não consegue
+// gastar a janela tentando pesquisar o mesmo arquivo pela quarta vez.
+async function anchoredRecoveryEdit({ token, dir, expectedArtifact, expectedOnDisk, recoveryExcerpt, previousItemFacts, lang }) {
+  const localized = lang === 'en';
+  const system = localized
+    ? 'You are the DeepSeek Pro code executor. Return ONLY valid JSON: {"buscar":"exact existing text from the excerpt","substituir":"replacement text","resumo":"short factual summary"}. Make one minimal edit that fulfills the requested checklist item. Do not explain, do not use Markdown, do not propose a plan.'
+    : 'Você é o executor de código DeepSeek Pro. Responda SOMENTE JSON válido: {"buscar":"trecho existente EXATO do recorte","substituir":"texto substituto","resumo":"resumo factual curto"}. Faça uma única edição mínima que cumpra o item do checklist. Não explique, não use Markdown, não proponha plano.';
+  const user = localized
+    ? `CHECKLIST ITEM: ${String(expectedArtifact || '')}\nPREVIOUS FACTS:\n${previousItemFacts}\n\nTARGET SOURCE EXCERPT:\n${recoveryExcerpt}`
+    : `ITEM DO CHECKLIST: ${String(expectedArtifact || '')}\nFATOS ANTERIORES:\n${previousItemFacts}\n\nTRECHO DO ARTEFATO-ALVO:\n${recoveryExcerpt}`;
+  const proposal = await _llmJson({ token, model: 'deepseek-v4-pro', system, user, maxTokens: 2200 });
+  const patch = proposal && proposal.json || {};
+  const buscar = String(patch.buscar || '');
+  const substituir = String(patch.substituir || '');
+  if (!buscar || !substituir || buscar === substituir) throw new Error('RECOVERY_PATCH_INVALID: o executor não devolveu uma substituição válida');
+  const target = path.resolve(expectedOnDisk || path.join(dir, expectedArtifact || ''));
+  const confined = path.resolve(dir);
+  if (target !== confined && !target.startsWith(confined + path.sep)) throw new Error('RECOVERY_PATCH_SCOPE: artefato fora do projeto');
+  const result = await toolRunner.execute('editar_arquivo', { caminho: target, buscar, substituir }, {
+    confineDir: dir, baseDir: dir, allowedTools: ['editar_arquivo'],
+  });
+  if (!result || result.erro || !result.ok) throw new Error('RECOVERY_PATCH_FAILED: ' + String(result && (result.erro || result.stderr) || 'edição não confirmada'));
+  return {
+    text: String(patch.resumo || (localized ? 'Anchored recovery edit persisted.' : 'Edição de recuperação por âncora persistida.')),
+    steps: 1,
+    credits: Number(proposal.credits || 0),
+    tokens: { inTok: 0, outTok: 0, cachedTok: 0 },
+    model: 'deepseek-v4-pro',
+    actions: [{ name: 'editar_arquivo', target, result }],
+    toolErrors: [],
+    completion: { ok: true, reason: 'anchored_recovery_edit' },
+  };
+}
+
 function normalizeMetaArtifact(relativePath, raw) {
   let text = String(raw || '').trim().replace(/^```(?:json|gdscript|markdown|md)?\s*/i, '').replace(/\s*```\s*$/i, '').trim();
   if (/\.json$/i.test(relativePath)) {
@@ -912,48 +1007,79 @@ function save(st, dir) {
   }
 }
 
-// Chamada JSON barata (flash-lite via CDC, chave sk-hub do usuário) + cobrança
+// Chamada JSON do planejador/verificador. Nunca fixa Flash: o papel que chama
+// escolhe o modelo conforme o contrato oficial e o plano do usuário.
 let _key = null;
 let _keyNuvem = null;   // credencial do GATEWAY (visão) — separada da BYOK
-async function _llmJson({ token, system, user, maxTokens = 900 }) {
+async function _llmJson({ token, system, user, maxTokens = 900, model = 'gpt-5.6-luna' }) {
   if (!_key) _key = await keyring.resolve(token, { feature: 'cli_agent' });
   const ctrl = new AbortController();
-  const timer = setTimeout(() => ctrl.abort(), 60000);
+  let timer;
   let res;
   try {
-    res = await fetch(String(_key.baseUrl).replace(/\/+$/, '') + '/chat/completions', {
+    const request = 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: keyring.modeloPara(_key, 'gemini-2.5-flash-lite'), stream: false, max_completion_tokens: maxTokens,
+      body: JSON.stringify({ model: keyring.modeloPara(_key, model), stream: false, max_completion_tokens: maxTokens,
         messages: [{ role: 'system', content: system }, { role: 'user', content: user }] }),
     });
+    // Alguns gateways não encerram o socket imediatamente após abort(). A
+    // corrida garante que o Meta devolva uma falha tratável em até 60 s, em
+    // vez de deixar a missão presa em "pensando" indefinidamente.
+    const deadline = new Promise((_, reject) => {
+      timer = setTimeout(() => { ctrl.abort(); reject(new Error('META_MODEL_TIMEOUT')); }, 60000);
+    });
+    res = await Promise.race([request, deadline]);
   } finally { clearTimeout(timer); }
   const j = await res.json().catch(() => null);
   if (!res.ok) _capGuard(res, j);
+  if (modelWasSubstituted(model, j && j.model)) {
+    throw new ApiError(`Modelo exigido não foi respeitado: solicitado "${model}", recebido "${j.model}".`, {
+      status: 409, code: 'model_substituted',
+    });
+  }
+  const content = String(j?.choices?.[0]?.message?.content || '').trim();
+  if (!content) {
+    const providerMessage = String(j?.error?.message || j?.message || '').trim();
+    throw new ApiError(`O modelo ${model || 'selecionado'} retornou um JSON vazio${providerMessage ? ': ' + providerMessage : '.'}`, {
+      status: 502, code: 'empty_model_response',
+    });
+  }
   const u = j?.usage || {};
   let credits = (j?.ts_billing && j.ts_billing.charged) || 0;
   if (u.prompt_tokens) {
-    if (!_key.billingAuthoritative) { 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 (_) {} }
+    if (!_key.billingAuthoritative) { 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 { json: _tolerantJson(String(j?.choices?.[0]?.message?.content || '')), credits };
+  return { json: _tolerantJson(content), credits };
 }
 
 // Chamada de TEXTO com modelo arbitrário — usada pelo PENSADOR (escalonamento).
 async function _llmText({ token, model, system, user, maxTokens = 1200, creditBudget = null }) {
   if (!_key) _key = await keyring.resolve(token, { feature: 'cli_agent' });
   const ctrl = new AbortController();
-  const timer = setTimeout(() => ctrl.abort(), 120000);
+  let timer;
   let res;
   try {
-    res = await fetch(String(_key.baseUrl).replace(/\/+$/, '') + '/chat/completions', {
+    const request = fetch(String(_key.baseUrl).replace(/\/+$/, '') + '/chat/completions', {
       method: 'POST', signal: ctrl.signal,
       headers: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + _key.key,
         ...(Number.isFinite(Number(creditBudget)) && Number(creditBudget) > 0 ? { 'X-TS-Credit-Budget': String(Math.floor(Number(creditBudget))) } : {}) },
       body: JSON.stringify({ model: keyring.modeloPara(_key, model), stream: false, max_completion_tokens: maxTokens, messages: [{ role: 'system', content: system }, { role: 'user', content: user }] }),
     });
+    // Idem ao fluxo do agente: o prazo deve vencer mesmo se o proxy mantiver
+    // a conexão aberta depois do abort, permitindo pausar/retomar com estado.
+    const deadline = new Promise((_, reject) => {
+      timer = setTimeout(() => { ctrl.abort(); reject(new Error('META_MODEL_TIMEOUT')); }, 120000);
+    });
+    res = await Promise.race([request, deadline]);
   } finally { clearTimeout(timer); }
   const j = await res.json().catch(() => null);
   if (!res.ok) _capGuard(res, j);
+  if (modelWasSubstituted(model, j && j.model)) {
+    throw new ApiError(`Modelo exigido não foi respeitado: solicitado "${model}", recebido "${j.model}".`, {
+      status: 409, code: 'model_substituted',
+    });
+  }
   const u = j?.usage || {};
   let credits = (j?.ts_billing && j.ts_billing.charged) || 0;
   if (u.prompt_tokens && !_key.billingAuthoritative) { 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 (_) {} }
@@ -1134,15 +1260,44 @@ const MARK_SYS = 'Você é o VERIFICADOR de uma missão. Recebe UM item do check
 
 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: 1800 });
-  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);
-  // Critérios propostos pelo planner → VALIDADOS pelo compilador (formato conhecido; malformados caem fora).
-  let criteria = [];
-  try { criteria = require('./verify').compileCriteria(r.json?.criterios || []).criteria.slice(0, 6); } catch (_) {}
-  return { itens: itens.length ? itens : [{ id: 'i1', desc: String(goal).slice(0, 300), passes: false, attempts: 0 }], criteria, credits: r.credits };
+async function makeChecklist(goal, token, plannerModel = 'gpt-5.6-luna') {
+  // Plano vazio ou malformado nunca vira uma etapa com o objetivo inteiro: isso
+  // autorizava uma execução cega. Repetimos Luna uma vez e só então usamos
+  // DeepSeek Pro como fallback objetivo, limitado a uma tentativa.
+  const attempts = [plannerModel, plannerModel];
+  if (plannerModel !== 'deepseek-v4-pro') attempts.push('deepseek-v4-pro');
+  let credits = 0, lastError = null;
+  for (const model of attempts) {
+    try {
+      const r = await _llmJson({ token, model, system: CHECKLIST_SYS, user: 'OBJETIVO:\n' + goal, maxTokens: 1800 });
+      credits += r.credits || 0;
+      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 && it.desc.length >= 8);
+      if (!itens.length) { lastError = new Error(`planner ${model} não definiu etapas executáveis`); continue; }
+      // Critérios propostos pelo planner → VALIDADOS pelo compilador (formato conhecido; malformados caem fora).
+      let criteria = [];
+      try { criteria = require('./verify').compileCriteria(r.json?.criterios || []).criteria.slice(0, 6); } catch (_) {}
+      return { itens, criteria, credits, plannerModel: model, fallback: model !== plannerModel };
+    } catch (e) { lastError = e; }
+  }
+  const err = new ApiError('Não foi possível obter um plano válido; nenhuma etapa foi executada. Tente novamente em instantes.', {
+    status: 502, code: 'planner_invalid',
+  });
+  err.credits = credits;
+  err.cause = lastError;
+  throw err;
+}
+
+// Missões antigas podiam ter salvo aliases de UI como "smart" em `st.model`.
+// Esse estado não é uma escolha explícita do usuário e nunca pode substituir o
+// executor oficial de uma tarefa Meta.
+function officialExecutorModel(explicitModel, persistedModel) {
+  if (explicitModel) return explicitModel;
+  const normalized = String(persistedModel || '').trim().toLowerCase();
+  return ['deepseek-v4-pro', 'deepseek/deepseek-v4-pro'].includes(normalized)
+    ? 'deepseek-v4-pro'
+    : 'deepseek-v4-pro';
 }
 
 /**
@@ -1189,6 +1344,17 @@ async function run(goal, opts = {}) {
   const onAlert = opts.onAlert || (() => {}); // avisos (escalonei / preciso de você / travei)
   const startMs = Date.now();
 
+  // Uma missão Meta persiste o mesmo .ts-meta.json em várias etapas. Duas
+  // execuções concorrentes podem sobrescrever checklist, créditos e provas;
+  // portanto cada projeto aceita somente uma rodada ativa por vez.
+  const runLock = fileLock.acquire(stateFile(dir), { staleMs: 30 * 60 * 1000 });
+  if (!runLock) {
+    const current = load(dir) || {};
+    onAlert({ type: 'busy', text: 'Outra missão Meta já está em execução neste projeto. Aguarde ela terminar antes de retomar.' });
+    return Object.assign({}, current, { status: 'busy', busy: true });
+  }
+  try {
+
   let st = load(dir);
   if (!st || st.status === 'done') {
     if (!goal) return null; // nada pra retomar
@@ -1198,7 +1364,7 @@ async function run(goal, opts = {}) {
     // 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';
+    const feasModel = thinker || 'gpt-5.6-luna';
     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; onAlert({ type: 'phase_error', text: `⚠ ts: viabilidade não concluída: ${String(_e && _e.message || _e).slice(0, 220)}` }); }
@@ -1216,12 +1382,12 @@ async function run(goal, opts = {}) {
     // 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';
+    const archModel = thinker || 'gpt-5.6-luna';
     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; onAlert({ type: 'phase_error', text: `⚠ ts: arquitetura não concluída: ${String(_e && _e.message || _e).slice(0, 220)}` }); }
     }
-    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);
+    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, thinker || 'gpt-5.6-luna');
     // CRITÉRIOS (TaskSpec): usuário (--criterios) manda; senão, com --provar, combina o que o
     // PLANNER propôs (mk.criteria, já validado) + os TESTES da stack — tudo recompilado.
     // Mesmo sem --provar, critérios determinísticos derivados da stack rodam por padrão;
@@ -1232,7 +1398,10 @@ async function run(goal, opts = {}) {
     else if (prove) _criteria = _V.compileCriteria([..._V.deriveFromStack(dir), ..._planned]).criteria.slice(0, 8);
     else _criteria = _V.compileCriteria(_V.deriveFromStack(dir)).criteria.slice(0, 8);
     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, criteria: _criteria, plannedCriteria: _planned, created_at: new Date().toISOString() };
+      // Missões locais pagas nunca devem cair no alias genérico `gateway`, que
+      // pode apontar para Flash ou para um provedor sem ferramentas. DeepSeek
+      // Pro é o executor oficial; uma escolha explícita do usuário ainda vence.
+      budget, maxRounds, status: 'running', model: model || 'deepseek-v4-pro', designBrief: designBrief || null, criteria: _criteria, plannedCriteria: _planned, created_at: new Date().toISOString() };
     save(st, dir);
   } else {
     st.status = 'running';
@@ -1246,7 +1415,10 @@ async function run(goal, opts = {}) {
     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 useModel = officialExecutorModel(model, st.model);
+  // Corrige o checkpoint legado para que a próxima retomada também fique no
+  // contrato Luna (planner) + DeepSeek Pro (executor), sem depender da UI.
+  if (!model && st.model !== useModel) { st.model = useModel; save(st, dir); }
   const useThinker = thinker || st.thinker || null; // modelo caro "pensador" (escalonamento)
   if (thinker && !st.thinker) { st.thinker = thinker; save(st, dir); }
   onChecklist(st.checklist);
@@ -1426,7 +1598,7 @@ async function run(goal, opts = {}) {
     }
     if (!item.directArtifact && (item.attempts || 0) > 0 && expectedOnDisk && !fs.existsSync(expectedOnDisk)) {
       item.directArtifact = true;
-      item.directModel = item.directModel || 'glm-5.2';
+      item.directModel = item.directModel || 'deepseek-v4-pro';
       item.attempts = Math.max(0, item.attempts - 1);
     }
     item.attempts = (item.attempts || 0) + 1;
@@ -1436,7 +1608,7 @@ async function run(goal, opts = {}) {
     // generated in validated batches from the start (classes/maps/quests/monsters).
     if (!item.directArtifact && directArtifactPlan(item)) {
       item.directArtifact = true;
-      item.directModel = 'glm-5.2';
+      item.directModel = 'deepseek-v4-pro';
     }
 
     // Some providers can generate a large document but refuse to place that
@@ -1448,7 +1620,7 @@ async function run(goal, opts = {}) {
       save(st, dir);
     }
     if (item.directArtifact) {
-      const directModel = item.directModel || 'glm-5.2';
+      const directModel = item.directModel || 'deepseek-v4-pro';
       const plan = directArtifactPlan(item);
       let totalCredits = 0, finalText = '';
       if (plan) {
@@ -1572,14 +1744,25 @@ async function run(goal, opts = {}) {
       ? `\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 artifactBlock = lang === 'en'
-      ? `\nMANDATORY PROOF ARTIFACT FOR THIS ITEM: ${expectedArtifact}\nYou MUST call escrever_arquivo or editar_arquivo and persist the deliverable at exactly this relative path. A text-only answer does NOT complete the item. Create parent directories through the file tool as needed.\n`
-      : `\nARTEFATO DE PROVA OBRIGATORIO DESTE ITEM: ${expectedArtifact}\nVoce DEVE chamar escrever_arquivo ou editar_arquivo e persistir a entrega exatamente nesse caminho relativo. Resposta apenas em texto NAO conclui o item. Crie os diretorios-pai pela ferramenta de arquivo quando necessario.\n`;
-    const task = feasBlock + archBlock + designBlock + seedBlock + rulesBlock + minimalBlock + artifactBlock + (lang === 'en'
+      ? `\nMANDATORY PROOF ARTIFACT FOR THIS ITEM: ${expectedArtifact}\nYou MUST call escrever_arquivo or editar_arquivo and persist the deliverable at exactly this relative path. A text-only answer does NOT complete the item. Create parent directories through the file tool as needed. For an existing HTML/CSS/JS file, prefer editar_arquivo with an exact anchor. Create a temporary patch script only as a last resort; validate it first (Python: python -m py_compile <file>) before executing it.\n`
+      : `\nARTEFATO DE PROVA OBRIGATORIO DESTE ITEM: ${expectedArtifact}\nVoce DEVE chamar escrever_arquivo ou editar_arquivo e persistir a entrega exatamente nesse caminho relativo. Resposta apenas em texto NAO conclui o item. Crie os diretorios-pai pela ferramenta de arquivo quando necessario. Para HTML/CSS/JS existente, prefira editar_arquivo com ancora exata. Crie script temporario de patch somente em ultimo caso; antes de executa-lo, valide-o (Python: python -m py_compile <arquivo>). Use no maximo UM script temporario por item: se ele falhar, corrija o MESMO arquivo com editar_arquivo e valide de novo; nao crie outro script de patch.\n`;
+    const previousItemFacts = item.lastAttempt && item.lastAttempt.result
+      ? String(item.lastAttempt.result).slice(0, 1400)
+      : '';
+    const recoveryExcerpt = previousItemFacts && expectedOnDisk
+      ? recoveryTargetExcerpt(expectedOnDisk, item)
+      : '';
+    const recoveryBlock = previousItemFacts
+      ? (lang === 'en'
+        ? `\nRECOVERY FACTS (already verified in the previous attempt; DO NOT rediscover them):\n${previousItemFacts}${recoveryExcerpt ? `\n\nTARGET SOURCE EXCERPT (deterministic local evidence; use these numbered lines as the exact edit anchor — do NOT search, reread or run commands):\n${recoveryExcerpt}` : ''}\n\nRECOVERY RULE: make the concrete edit in ${expectedArtifact} now. ${recoveryExcerpt ? 'Your first tool call MUST edit/write the target using this excerpt. Persist only the change; the harness runs objective proof after your edit.' : 'You may inspect ONLY that target once for an exact anchor. Your next tool call after that must edit/write the target, then run one objective proof.'}\n`
+        : `\nFATOS DA TENTATIVA ANTERIOR (já verificados; NÃO os redescubra):\n${previousItemFacts}${recoveryExcerpt ? `\n\nTRECHO DO ARTEFATO-ALVO (prova local determinística; use as linhas numeradas como âncora exata da edição — NÃO pesquise, releia nem rode comandos):\n${recoveryExcerpt}` : ''}\n\nREGRA DE RECUPERAÇÃO: faça agora a edição concreta em ${expectedArtifact}. ${recoveryExcerpt ? 'Sua primeira chamada de ferramenta DEVE editar/escrever o alvo usando este trecho. Apenas persista a mudança; o harness roda a prova objetiva depois da edição.' : 'Você pode inspecionar SOMENTE esse alvo uma vez para obter a âncora exata. A próxima chamada de ferramenta deve editar/escrever o alvo e depois rodar uma prova objetiva.'}\n`)
+      : '';
+    const task = feasBlock + archBlock + designBlock + seedBlock + rulesBlock + minimalBlock + artifactBlock + recoveryBlock + (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.attempts > 1 || item.lastAttempt)
+        ? (lang === 'en' ? `\nPREVIOUS ATTEMPT at this item FAILED. RECOVERY MODE: inspect ONLY the mandatory artifact once (a focused range), then edit it directly. Do not use ler_arquivos/buscar_arquivos, do not reread the project, and do not create any patch script. Persist one concrete fix and run one objective proof.\n` : `\nA tentativa ANTERIOR deste item FALHOU. MODO DE RECUPERAÇÃO: inspecione APENAS o artefato obrigatório uma única vez (faixa focada) e depois edite-o diretamente. Não use ler_arquivos/buscar_arquivos, não releia o projeto e não crie script de patch. Persista um único ajuste concreto e rode uma prova objetiva.\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`)
@@ -1607,7 +1790,7 @@ async function run(goal, opts = {}) {
     // spend three HTTP retries on it again for every checklist item. Keep the
     // cooldown mission-local and short so normal routing recovers naturally.
     if (!model && Number(st.autoExecutorDegradedUntil || 0) > Date.now()) {
-      roundModel = 'glm-5.2';
+      roundModel = 'gpt-5.6-luna';
     }
     // A model that answered with promises but executed zero tools is avoided
     // for this item on the next window. This is a capability failure, not a
@@ -1617,7 +1800,7 @@ async function run(goal, opts = {}) {
       // Use only model ids currently exposed by the CDC. Haiku remains in the
       // intelligence catalog for pricing/history, but it is not a callable CDC
       // id and must never be selected as the mission recovery executor.
-      const candidates = ['glm-5.2', 'gpt-5.6-luna', 'deepseek-v4-pro'];
+      const candidates = ['deepseek-v4-pro', 'gpt-5.6-luna'];
       roundModel = candidates.find(c => !avoid.some(a => a.includes(c) || c.includes(a))) || roundModel;
     }
     if (visualLadder && item.id === 'visual_fix' && (st.visualFixes || 0) >= VISUAL_ESCALATE_AT && (useThinker || eye)) {
@@ -1631,11 +1814,41 @@ async function run(goal, opts = {}) {
         // can have a minimum context larger than that, so use the remaining
         // window budget while preserving the mission-wide ceiling.
         const roundCreditBudget = Math.max(1, Math.min(5000, Math.floor(st.budget - st.creditsSpent)));
-        const roundAllowedTools = Array.isArray(opts.allowedTools) ? opts.allowedTools : toolsForMetaItem(item, st.goal);
-        out = await agent.run(task, { token, lang, yes, autoAll, model: roundModel, maxCredits: roundCreditBudget, allowedTools: roundAllowedTools, confineDir: dir, skipSessionStart: true, onStep: opts.onStep, onStepDone: opts.onStepDone, askApprove: opts.askApprove, onRemote: opts.onRemote, onThinking: opts.onThinking });
+        let roundAllowedTools = Array.isArray(opts.allowedTools) ? opts.allowedTools : toolsForMetaItem(item, st.goal);
+        // Com a âncora local já fornecida, a única responsabilidade do agente
+        // nesta janela é persistir a correção. A prova é executada pelo
+        // harness depois da edição; deixar comandos/leitura disponíveis fazia
+        // o modelo gastar esta janela pesquisando de novo em vez de corrigir.
+        if (recoveryExcerpt && Array.isArray(roundAllowedTools)) {
+          const recoveryEditTools = new Set(['editar_arquivo', 'escrever_arquivo']);
+          roundAllowedTools = roundAllowedTools.filter(name => recoveryEditTools.has(name));
+        }
+        // Cada item é uma janela independente. Sem este teto, uma resposta de
+        // provedor que mantém o socket aberto deixa a missão em "running" por
+        // muitos minutos, sem checkpoint nem retorno visual. Ao expirar, o
+        // agente devolve uma pausa honesta e `ts meta` retoma do item salvo.
+        const roundMaxDurationMs = Math.max(60000, Number(opts.roundMaxDurationMs) || 180000);
+        out = recoveryExcerpt
+          ? await anchoredRecoveryEdit({ token, dir, expectedArtifact, expectedOnDisk, recoveryExcerpt, previousItemFacts, lang })
+          : await agent.run(task, { token, lang, yes, autoAll, model: roundModel, plannerModel: st.thinker || 'gpt-5.6-luna', atomicMetaItem: true, recoveryMode: !!previousItemFacts, recoveryHasExcerpt: !!recoveryExcerpt, skipPlanner: !!recoveryExcerpt, maxCredits: roundCreditBudget, maxDurationMs: roundMaxDurationMs, allowedTools: roundAllowedTools, confineDir: dir, skipSessionStart: true, onStep: opts.onStep, onStepDone: opts.onStepDone, askApprove: opts.askApprove, onRemote: opts.onRemote, onThinking: opts.onThinking });
       }
       catch (e) {
         connErr = e;
+        // A microrecuperação tem uma única responsabilidade e uma âncora
+        // local. Se o provedor expirar ou devolver um patch inválido, isso não
+        // pode escapar do Meta e deixar o usuário em "Pensando…" sem estado.
+        // Persistimos a falha objetiva; a próxima rodada pode retomar sem
+        // inventar que a edição ocorreu.
+        if (recoveryExcerpt) {
+          const evidence = String(e && (e.message || e.code) || 'falha desconhecida').replace(/\s+/g, ' ').slice(0, 500);
+          out = {
+            text: `Recuperação por âncora não foi concluída: ${evidence}. Nenhum artefato foi marcado como pronto.`,
+            steps: 0, credits: 0, tokens: { inTok: 0, outTok: 0, cachedTok: 0 }, model: 'deepseek-v4-pro', actions: [],
+            toolErrors: [{ tool: 'recuperacao_por_ancora', class: 'anchored_recovery_failed', retryable: /TIMEOUT|timeout|temporar|network/i.test(evidence), evidence }],
+            completion: { ok: false, reason: 'anchored_recovery_failed' },
+          };
+          break;
+        }
         // 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);
@@ -1649,7 +1862,7 @@ async function run(goal, opts = {}) {
           // retries, switch to another tool-capable model before pausing.
           // Change provider family first: if Flash is down, Pro from the same
           // family is likely affected too. GLM is the economical independent fallback.
-          const fallbacks = ['glm-5.2', 'deepseek-v4-pro', 'gpt-5.6-luna'];
+          const fallbacks = ['deepseek-v4-pro', 'gpt-5.6-luna'];
           if (!model && att === 0 && !roundModel) {
             st.autoExecutorDegradedUntil = Date.now() + (10 * 60 * 1000);
             save(st, dir);
@@ -1678,6 +1891,25 @@ async function run(goal, opts = {}) {
     }
 
     const expectedNow = String(expectedArtifact || '').replace(/\\/g, '/').toLowerCase();
+    // Uma mutação parcial não é entrega. O agente já produz um veredito
+    // determinístico que considera loop, limite, ausência de ação e provas;
+    // ignorá-lo aqui fazia o Meta marcar um item como concluído apenas porque
+    // algum arquivo foi tocado antes de um comando/teste falhar.
+    if (out.completion && out.completion.ok === false) {
+      item.lastAttempt = {
+        at: new Date().toISOString(),
+        model: String(out.model || roundModel || 'automatico'),
+        steps: Number(out.steps || 0),
+        completion: out.completion.reason || 'unverified',
+        guard: out.guard && out.guard.kind || '',
+        toolErrors: Array.isArray(out.toolErrors) ? out.toolErrors.slice(-6) : [],
+        result: String(out.text || '').slice(0, 1200),
+      };
+      st.status = 'paused'; st.pause_reason = 'execution_unverified';
+      save(st, dir);
+      onAlert({ type: 'verification', text: `A execução não foi comprovada (${out.completion.reason || 'sem veredito válido'}). O item ficou aberto; nenhuma alteração parcial foi tratada como entrega.` });
+      return st;
+    }
     const expectedAfterHash = expectedOnDisk ? artifactHash(expectedOnDisk) : null;
     const expectedChangedNow = !!expectedAfterHash && expectedAfterHash !== expectedBeforeHash;
     const expectedChangedSinceBaseline = !!expectedAfterHash && !!item.artifactBaselineHash
@@ -1691,19 +1923,40 @@ async function run(goal, opts = {}) {
     // several tool steps exploring the project and still fail to create the
     // promised deliverable; treat that exactly like a zero-tool promise.
     if (expectedNow && !wroteExpectedNow) {
-      item.attempts = Math.max(0, (item.attempts || 1) - 1);
-      item.avoidModels = [...new Set([...(item.avoidModels || []), String(out.model || roundModel || 'automatico')])];
+      // CAPABILITY_DENIED é bloqueio do harness, não incapacidade do modelo.
+      // Já ignorar o gate explícito de execução, por outro lado, é uma prova
+      // objetiva de que este executor não avançou: a próxima rodada pode usar
+      // o fallback do plano, sem mascarar a falha como "problema do harness".
+      const ignoredExecutionGate = Array.isArray(out.toolErrors)
+        && out.toolErrors.some(e => e && e.class === 'inspection_phase_ignored');
+      const harnessBlocked = /CAPABILITY_DENIED/i.test(JSON.stringify(out || {}))
+        || (!ignoredExecutionGate && /inspection_phase_ignored/i.test(JSON.stringify(out || {})));
+      if (!harnessBlocked) item.avoidModels = [...new Set([...(item.avoidModels || []), String(out.model || roundModel || 'automatico')])];
       const expectedTarget = path.isAbsolute(expectedArtifact) ? expectedArtifact : path.resolve(dir, expectedArtifact);
       // Conteúdo direto é seguro para um artefato NOVO. Para código existente ele poderia
       // substituir o projeto inteiro por uma resposta parcial do item; nesse caso troque o
       // executor e obrigue uma edição real, preservando o arquivo atual.
       item.directArtifact = !fs.existsSync(expectedTarget);
-      const failedModel = String(out.model || roundModel || 'glm-5.2');
-      if (item.directArtifact) item.directModel = /glm/i.test(failedModel) ? 'glm-5.2' : failedModel;
+      // Conteúdo direto é uma recuperação controlada: mantenha o executor
+      // oficial, nunca transforme um alias/Flash/GLM em política automática.
+      if (item.directArtifact) item.directModel = 'deepseek-v4-pro';
+      // Diagnóstico resumido e persistente: o próximo operador (ou o próprio
+      // harness) consegue saber se faltou ferramenta, prova, tempo ou resposta
+      // do modelo sem depender do console que já fechou.
+      item.lastAttempt = {
+        at: new Date().toISOString(),
+        model: String(out.model || roundModel || 'automatico'),
+        steps: Number(out.steps || 0),
+        completion: out.completion && out.completion.reason || '',
+        guard: out.guard && out.guard.kind || '',
+        toolErrors: Array.isArray(out.toolErrors) ? out.toolErrors.slice(-4) : [],
+        result: String(out.text || '').slice(0, 1200),
+      };
       st.status = 'paused'; st.pause_reason = 'model_no_action';
-      st.budget = st.creditsSpent;
       save(st, dir);
-      onAlert({ type: 'retry', text: `O modelo ${out.model || roundModel || 'automatico'} não persistiu o artefato esperado. Não marquei o item como concluído; a retomada usará outro executor sem substituir código existente.` });
+      onAlert({ type: 'retry', text: harnessBlocked
+        ? `O harness bloqueou uma operação antes de o modelo persistir o artefato. Não marquei o item como concluído nem culpei o executor; a retomada repetirá o papel oficial após a correção local.`
+        : `O modelo ${out.model || roundModel || 'automatico'} não persistiu o artefato esperado. Não marquei o item como concluído; a retomada usará outro executor sem substituir código existente.` });
       return st;
     }
 
@@ -1774,7 +2027,7 @@ async function run(goal, opts = {}) {
     // narrativa de uma rodada não é evidência suficiente para concluir itens não executados.
     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,
+      const mk = await _llmJson({ token, model: 'gpt-5.6-luna', 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 && wroteExpectedArtifact) marks.push(item.id);
@@ -1788,6 +2041,9 @@ async function run(goal, opts = {}) {
     save(st, dir);
     onRoundDone({ marks, credits: out.credits || 0, checklist: st.checklist, spent: st.creditsSpent });
   }
+  } finally {
+    runLock.release();
+  }
 }
 
 // Notificação no Telegram do dono (best-effort — sem canal, segue em silêncio)
@@ -1839,4 +2095,4 @@ function trailSummary(st, lang) {
   };
 }
 
-module.exports = { webRunGate, run, load, notify, stateFile, detectBuild, ensureToolchain, runBuild, escalate, designPhase, archPhase, looksVisual, looksComplex, runApp, visualGate, ensureEmulator, _projKind, _llmVision, toolsForMetaItem, artifactForMetaItem, normalizeMetaArtifact, persistMetaArtifact, directArtifactPlan, canGenerateDirectArtifact, verificationLabel, _checkCriteria, trailSummary };
+module.exports = { webRunGate, run, load, notify, stateFile, detectBuild, ensureToolchain, runBuild, escalate, designPhase, archPhase, looksVisual, looksComplex, runApp, visualGate, ensureEmulator, _projKind, _llmVision, toolsForMetaItem, artifactForMetaItem, recoveryTargetExcerpt, anchoredRecoveryEdit, normalizeMetaArtifact, persistMetaArtifact, directArtifactPlan, canGenerateDirectArtifact, verificationLabel, _checkCriteria, trailSummary, officialExecutorModel, modelWasSubstituted };