terminal-smart-cli 0.97.31 → 0.97.41

package/bin/ts.js

@@ -200,7 +200,7 @@ async function login() {
     let p;
     try { p = await api('/api/cli/pair/poll', { method: 'POST', body: { poll: r.poll } }); } catch (_) { continue; }
     if (p && p.status === 'ok') {
-      cfg = config.save({ token: p.token, username: p.username, plan: p.plan, convId: undefined });
+      cfg = config.save({ token: p.token, username: p.username, plan: p.plan, convId: undefined, convScopes: undefined });
       sp.stop(ui.okLine(C.bold(T.login_ok(p.username))));
       return;
     }
@@ -211,15 +211,26 @@ async function login() {
 async function logout() {
   if (!cfg.token) { console.log(ui.infoLine(T.logout_none)); return; }
   try { await api('/api/logout', { method: 'POST', token: cfg.token }); } catch (_) {}
-  config.save({ token: undefined, username: undefined, plan: undefined, convId: undefined });
+  config.save({ token: undefined, username: undefined, plan: undefined, convId: undefined, convScopes: undefined });
   console.log(ui.okLine(T.logout_ok));
 }
 
 // ── Chat ─────────────────────────────────────────────────────────────────────
-async function ensureConv(token) {
-  if (cfg.convId) return cfg.convId;
-  const r = await api('/api/conversations', { method: 'POST', token, body: { title: 'CLI' } });
-  cfg = config.save({ convId: r.id });
+// A conversa é isolada por pasta de trabalho. Assim o contexto continua quando
+// alguém conversa no mesmo projeto, mas não vaza de um projeto para outro.
+const conversationScope = require('../lib/conversation-scope');
+function _convScope(kind = 'chat', cwd = process.cwd()) {
+  return conversationScope.workspaceScope(cwd, kind);
+}
+async function ensureConv(token, kind = 'chat', cwd = process.cwd(), forceNew = false) {
+  const scope = _convScope(kind, cwd);
+  const scopes = Object.assign({}, cfg.convScopes || {});
+  if (!forceNew && scopes[scope]) return scopes[scope];
+  const r = await api('/api/conversations', { method: 'POST', token, body: { title: conversationScope.conversationTitle(cwd, 'CLI') } });
+  scopes[scope] = r.id;
+  // convId permanece como ponte de compatibilidade para instalações antigas;
+  // toda nova leitura usa convScopes, nunca o id global legado.
+  cfg = config.save({ convId: r.id, convScopes: scopes });
   return r.id;
 }
 
@@ -415,7 +426,12 @@ async function sendMessage(token, content) {
   let convId = await ensureConv(token);
   try { return await doStream(convId); }
   catch (e) {
-    if (e instanceof ApiError && e.status === 404) { cfg = config.save({ convId: undefined }); convId = await ensureConv(token); return doStream(convId); }
+    if (e instanceof ApiError && e.status === 404) {
+      const scope = _convScope('chat');
+      const scopes = Object.assign({}, cfg.convScopes || {}); delete scopes[scope];
+      cfg = config.save({ convId: undefined, convScopes: scopes });
+      convId = await ensureConv(token); return doStream(convId);
+    }
     throw e;
   }
 }
@@ -927,8 +943,7 @@ async function chatRepl() {
     if (['sair', 'exit', 'quit', '/sair', '/exit'].includes(low)) break;
     try {
       if (['/nova', '/new'].includes(low)) {
-        const r = await api('/api/conversations', { method: 'POST', token, body: { title: 'CLI' } });
-        cfg = config.save({ convId: r.id });
+        await ensureConv(token, 'chat', process.cwd(), true);
         console.log(ui.okLine(T.new_conv) + '\n');
       } else if (['/ajuda', '/help', '/?'].includes(low)) {
         const w = Math.max(...T.repl_help.map(i => i[0].length)) + 3;
@@ -1831,13 +1846,13 @@ async function metaCmd() {
   const budget = flagNum('--budget', 400);
   const maxRounds = flagNum('--rodadas', flagNum('--rounds', 20));
   const forcedModel = flagStr('--modelo') || flagStr('--model'); // executor fixo (bake-off de modelos)
-  const thinker = flagStr('--pensador') || flagStr('--thinker') || 'grok-4.5'; // modelo caro que só PENSA quando trava
+  const thinker = flagStr('--pensador') || flagStr('--thinker') || 'gpt-5.6-luna'; // planejador/diagnóstico dentro da equipe oficial
   const maxMinutes = flagNum('--maxmin', 0); // freio de relógio (0 = sem limite)
-  const designer = flagStr('--designer') || 'grok-4.5'; // modelo forte que projeta o VISUAL antes de codar
+  const mockup = flagStr('--mockup'); // imagem de referência (ex: mockup do Google AI Studio)
+  const designer = flagStr('--designer') || (mockup ? 'mimo-v2.5' : 'gpt-5.6-luna');
   const design = FLAGS.has('--sem-design') ? false : (flagStr('--design') || 'auto'); // auto = liga em app visual
-  const eye = FLAGS.has('--sem-olho') ? null : (flagStr('--olho') || flagStr('--eye') || 'grok-4.5'); // "olho" que critica o print do app
-  const visualLadder = !FLAGS.has('--sem-escada') && !FLAGS.has('--barato'); // escada visual: fix visual escala pro modelo forte (caro). --sem-escada/--barato deixa no executor barato
-  const mockup = flagStr('--mockup'); // imagem de referência (ex: mockup do Google AI Studio) — designer projeta a partir dela e o olho cobra fidelidade
+  const eye = FLAGS.has('--sem-olho') ? null : (flagStr('--olho') || flagStr('--eye') || 'mimo-v2.5'); // revisão visual multimodal
+  const visualLadder = !FLAGS.has('--sem-escada') && !FLAGS.has('--barato'); // após reprovação objetiva, Luna orienta a correção
   const arch = FLAGS.has('--sem-arch') ? false : (FLAGS.has('--arch') || FLAGS.has('--arquitetura') ? true : 'auto'); // contrato de arquitetura antes de codar (auto = liga em app complexo)
   // ── MODO NOTURNO (auto-continuação por orçamento): retoma sozinho quando o teto
   // de crédito da janela estoura, até a missão terminar OU bater um teto TOTAL. ──
@@ -3182,8 +3197,7 @@ function idioma(l) {
 
 async function nova() {
   const token = needToken();
-  const r = await api('/api/conversations', { method: 'POST', token, body: { title: 'CLI' } });
-  cfg = config.save({ convId: r.id });
+  await ensureConv(token, 'chat', process.cwd(), true);
   console.log(ui.okLine(T.new_conv));
 }
 
@@ -3293,6 +3307,18 @@ function recallCmd(args) {
       // one-shot em TTY também passa pelo roteador ("ts crie um arquivo..." age);
       // pipe/--json ficam determinísticos no chat (scripts não levam surpresa)
       const text = POS.join(' ');
+      // `--modelo` é uma escolha explícita, não uma sugestão. Antes, um one-shot
+      // como `ts "responda OK" --modelo deepseek-v4-pro` caía no chat simples,
+      // que não recebe esse campo e usava o roteador padrão (frequentemente Flash).
+      // Isso fazia a telemetria parecer honesta, mas quebrava o contrato do usuário.
+      // Direcionamos qualquer one-shot com modelo forçado para o agente: ele propaga
+      // a escolha ao gateway e bloqueia a missão se o provedor devolver outro modelo.
+      if (rawArgs.includes('--modelo') || rawArgs.includes('--model')) {
+        // Passe os posicionais separados: agentCmd remove os valores das flags
+        // (modelo, orçamento, tempo) antes de montar a tarefa. Um único texto
+        // manteria esses números na pergunta exibida ao modelo.
+        return agentCmd(POS);
+      }
       if (process.stdin.isTTY && !JSON_OUT && cfg.token) {
         if (/^\s*(?:(?:quero|preciso)\s+(?:que\s+)?(?:voc[eê]\s+)?|(?:por favor[,\s]+)?)?(?:gere|gerar|crie|criar|fa[çc]a|produza|desenhe|ilustre|edite)\s+(?:uma|a|minha)?\s*(?:imagem|foto|ilustra[çc][aã]o|arte|banner|capa|mockup)\b/i.test(text)) {
           return imageCmd([text]);

package/lib/agent.js

@@ -218,7 +218,18 @@ function materialDecisionPreflight(task) {
 }
 
 function actionExpectedForTask(task) {
-  return /\b(?:cri|fa[cç]|implemente|corrija|edite|altere|instale|execute|rode|deploy|publique|remova|apague|delete|escreva|salve|envie|enviar|mande|mandar|dispare|disparar|encaminhe|encaminhar|responda|responder|send|forward|reply)\w*/i.test(String(task || ''));
+  const text = String(task || '');
+  // "Responda exatamente: OK" é um pedido de texto, não uma ação externa. Só
+  // exigimos prova de ação para responder/encaminhar uma mensagem identificável.
+  // Sem essa distinção, perguntas curtas ganhavam um aviso falso de missão não
+  // concluída mesmo quando o modelo tinha respondido corretamente.
+  if (/\b(?:responda|responder|reply|forward)\b[\s\S]{0,80}\b(?:e-?mail|email|mensagem|message|outlook|gmail|destinat[aá]rio)\b/i.test(text)) return true;
+  // "Retorne somente código" pede uma resposta no chat, ainda que o código use
+  // verbos como "implemente". Não force uma mutação local fictícia nem polua a
+  // entrega com aviso de evidência ausente.
+  if (/\b(?:retorne|responda|mostre)\b[\s\S]{0,60}\b(?:somente|apenas)\b/i.test(text)
+      && !/\b(?:arquivo|pasta|projeto|diret[oó]rio|salve|grave|crie\s+(?:um\s+)?(?:app|aplicativo|site))\b/i.test(text)) return false;
+  return /\b(?:cri|fa[cç]|implemente|corrija|edite|altere|instale|execute|rode|deploy|publique|remova|apague|delete|escreva|salve|envie|enviar|mande|mandar|dispare|disparar|encaminhe|encaminhar|send)\w*/i.test(text);
 }
 
 // Uma auditoria ou investigação solicitada explicitamente em modo somente
@@ -417,7 +428,15 @@ function explicitTaskWorkdir(taskText, exists = fs.existsSync) {
 // seja silenciosamente rebaixada para `status` nem dispare uma investigação.
 function restrictedGatewayDecision(taskText, entries = gateways.list()) {
   const text = gateways.normalized(taskText);
-  const gateway = gateways.findInText(text, entries);
+  // O identificador interno pode ser genérico (por exemplo, "producao").
+  // Nunca o use sozinho para desviar uma tarefa local: um objetivo de produto
+  // pode falar em "produção" sem ter qualquer relação com o gateway SSH.
+  // Para uma operação privilegiada exigimos o alias ou o rótulo completo,
+  // ambos termos que o usuário/configuração realmente reconhecem.
+  const gateway = entries.find(entry => [entry.label, entry.sshAlias]
+    .map(gateways.normalized)
+    .filter(Boolean)
+    .some(term => text.includes(term))) || null;
   if (!gateway) return null;
   // O alias pode conter palavras de operação (ex.: "...-deploy"); elas não
   // representam intenção do usuário. Classificamos somente o restante do texto.
@@ -562,6 +581,20 @@ function parseTextToolCalls(content) {
   const xml = /<(?:tool_call|invoke)\s+name=["']([a-zA-Z_][a-zA-Z0-9_.]*)["']>([\s\S]*?)<\/(?:tool_call|invoke)>/g;
   while ((m = xml.exec(src))) add(m[1], paramsFrom(m[2]));
 
+  // DeepSeek V4 pode devolver chamadas como texto no dialeto DSML, em vez do
+  // campo OpenAI `tool_calls`. O gateway continua válido; o harness precisa
+  // apenas normalizar esse envelope para não transformar uma ação real em
+  // "resposta vazia". Aceitamos somente nome/argumentos com a mesma validação
+  // estrita usada nos demais formatos.
+  const dsml = /<｜DSML｜invoke\s+name=["']([a-zA-Z_][a-zA-Z0-9_.]*)["'][^>]*>([\s\S]*?)<\/｜DSML｜invoke>/g;
+  while ((m = dsml.exec(src))) {
+    const args = {};
+    const params = /<｜DSML｜parameter\s+name=["']([a-zA-Z_][a-zA-Z0-9_]*)["'][^>]*>([\s\S]*?)<\/｜DSML｜parameter>/g;
+    let p;
+    while ((p = params.exec(m[2]))) args[p[1]] = scalar(p[2]);
+    add(m[1], args);
+  }
+
   // Responses/Codex textual envelope used by some OpenAI-compatible transports.
   const codexHead = /(?:^|\n)\s*to=functions\.([a-zA-Z_][a-zA-Z0-9_]*)\s+code:\s*\n\s*/g;
   while ((m = codexHead.exec(src))) {
@@ -611,7 +644,31 @@ function untrustedToolEnvelope(name, content, lang = 'pt') {
 function isRemoteDeployCommand(command) {
   return /\b(?:docker\s+(?:compose\s+)?(?:up|deploy|restart)|kubectl\s+(?:apply|rollout|set\s+image)|helm\s+(?:upgrade|install)|systemctl\s+(?:restart|start)|pm2\s+(?:restart|start|reload)|git\s+push|npm\s+run\s+deploy|vercel\s+(?:--prod|deploy)|netlify\s+deploy)\b/i.test(String(command || ''));
 }
-async function llm({ baseUrl, key, messages, model, signalMs = 180000, noTools = false, toolsOverride = null, onRetry = null, creditBudget = null, tries = 4 }) {
+
+// Navegador é só-leitura até haver ação que pode alterar uma conta, disparar
+// uma compra/publicação ou enviar dados para um provedor visual. A página não
+// é confiável e o modelo não pode transformar "auto" em autorização humana.
+function browserApprovalRequest(input = {}) {
+  const action = String(input.acao || '').toLowerCase();
+  const ref = String(input.ref || '?').replace(/[^e0-9]/g, '').slice(0, 12) || '?';
+  if (action === 'clicar') return {
+    kind: 'browser_action',
+    cmd: `NAVEGADOR → clicar no elemento ${ref}`,
+    warning: 'Este clique pode enviar formulário, publicar, comprar ou alterar dados em um site externo.',
+  };
+  if (action === 'digitar') return {
+    kind: 'browser_action',
+    cmd: `NAVEGADOR → digitar ${String(input.texto || '').length} caractere(s) no elemento ${ref}`,
+    warning: 'O texto será enviado para uma página externa. Revise e confirme antes de continuar.',
+  };
+  if (action === 'print' && String(input.pergunta || '').trim()) return {
+    kind: 'browser_visual_analysis',
+    cmd: 'NAVEGADOR → analisar captura de tela com IA de visão',
+    warning: 'A captura da página será enviada ao modelo de visão para análise. Não use em páginas com dados sensíveis sem sua confirmação.',
+  };
+  return null;
+}
+async function llm({ baseUrl, key, messages, model, signalMs = 180000, noTools = false, toolsOverride = null, onRetry = null, creditBudget = null, maxCompletionTokens = null, tries = 4 }) {
   // RESILIÊNCIA: o gateway CDC pode reiniciar/oscilar no meio de uma missão longa.
   // withRetry cobre conn/timeout/5xx (backoff+jitter); NUNCA re-tenta no_credits/auth.
   return withRetry(async () => {
@@ -628,7 +685,11 @@ async function llm({ baseUrl, key, messages, model, signalMs = 180000, noTools =
             ? { 'X-TS-Credit-Budget': String(Math.floor(Number(creditBudget))) }
             : {}),
         },
-        body: JSON.stringify({ model: model || DEFAULT_EXECUTOR, messages, ...(noTools ? {} : { tools: toolsOverride || tools.DEFS, tool_choice: 'auto' }), stream: false }),
+        body: JSON.stringify({ model: model || DEFAULT_EXECUTOR, messages,
+          ...(Number.isFinite(Number(maxCompletionTokens)) && Number(maxCompletionTokens) > 0
+            ? { max_completion_tokens: Math.max(32, Math.min(Math.floor(Number(maxCompletionTokens)), 16000)) }
+            : {}),
+          ...(noTools ? {} : { tools: toolsOverride || tools.DEFS, tool_choice: 'auto' }), stream: false }),
       });
       // Alguns proxies mantem o socket aberto mesmo apos AbortController.abort().
       // A corrida garante que a missao receba um timeout tipado no prazo e possa
@@ -1023,6 +1084,10 @@ async function run(task, opts = {}) {
     ? ((lang === 'en' ? '\n\nINSTALLED SKILLS (from the user, in ~/.ts/skills). If ONE of them fits this task, READ its file with ler_arquivo and FOLLOW its instructions:\n' : '\n\nSKILLS INSTALADAS (do usuário, em ~/.ts/skills). Se UMA delas servir pra esta tarefa, LEIA o arquivo dela com ler_arquivo e SIGA as instruções:\n')
        + _sk.map(s => `- ${s.name} (${s.slug}): ${s.description || 'skill'} → ${s.path}`).join('\n'))
     : '';
+  // Caminhos das skills que o próprio harness anunciou ao modelo nesta rodada.
+  // São permitidos SOMENTE para leitura: toda escrita continua confinada ao
+  // projeto ativo, inclusive em missões automáticas.
+  const _trustedSkillPaths = _sk.map(s => s && s.path).filter(Boolean);
   // DESCOBERTA DETERMINÍSTICA: busca a TAREFA no índice de skills disponíveis e injeta as
   // que passaram do limiar. Não depende do modelo lembrar de procurar — o harness procura.
   // Sem match, `sugestaoBlock` é '' e o custo em token é zero. Só nome/descrição entram:
@@ -1172,6 +1237,13 @@ async function run(task, opts = {}) {
   const _mcpSeen = new Set(); // servidores MCP já autorizados NESTA sessão (1ª chamada pede OK)
   const actions = []; // ações REAIS bem-sucedidas (evidência objetiva pro marcador do meta)
   let _inspectionCalls = 0;
+  // A trava de inspeção deve cortar reler o mesmo material, não impedir que o
+  // executor veja o último arquivo de ligação de uma alteração concreta. Uma
+  // única leitura nova, focada, é aceita depois do teto; a segunda volta a ser
+  // loop. Isso evita tanto a investigação infinita quanto o falso bloqueio de
+  // itens pequenos que cruzam estado + interface + prova.
+  const _inspectionSignatures = new Set();
+  let _lateFocusedInspectionUsed = false;
   const _hasExecution = () => actions.some(a => ['escrever_arquivo', 'editar_arquivo', 'editar_documento', 'editar_planilha'].includes(a.name)
     || (a.name === 'executar_comando' && !isInspectionCommand(a.target)));
   const _toolErrs = []; // erros de ferramenta TIPADOS na run (core.classifyToolResult) — sinal duro anti-done-falso
@@ -1191,10 +1263,30 @@ async function run(task, opts = {}) {
   let _incompleteRecoveryAttempts = 0;
   let _inspectionPhaseClosed = false;
   const _actionExpected = requiresActionEvidence(taskText, roMode);
+  // As rodadas de /meta já chegam com um artefato-alvo obrigatório. Ainda assim,
+  // em código existente o executor normalmente precisa ver o layout, o modelo e
+  // um ponto de ligação antes de editar com segurança. Quatro inspeções é um
+  // teto finito que preserva a maior parte da janela para escrever/testar, sem
+  // transformar a proteção de custo em bloqueio prematuro.
+  const _hasMandatoryArtifact = /ARTEFATO(?:\s+DE\s+PROVA)?\s+OBRIGAT[ÓO]RIO|MANDATORY PROOF ARTIFACT/i.test(taskText);
   // Hotfixes não devem virar investigação infinita; missões compostas, porém,
   // precisam ler banco, configuração e fontes antes de escrever. Escala o teto
   // pelo orçamento de passos já autorizado, preservando um limite duro.
-  const _inspectionMax = _complexTask ? Math.min(6, Math.max(4, Math.ceil(maxIter * 0.20))) : 4;
+  // Um item atômico de interface existente normalmente precisa de contexto em
+  // HTML, estado, modelo e um segundo trecho paginado do arquivo principal.
+  // Seis leituras ainda cortava fluxos legítimos quando o executor precisava
+  // cruzar store, modelo, interface e prova existente antes de editar. Oito
+  // preserva uma janela finita e ainda deixa passos para escrever, testar e
+  // corrigir; repetição da mesma leitura continua coberta pelo detector de loop.
+  // Retomada de item já investigado não reabre o projeto: o Meta entrega os
+  // fatos da tentativa anterior e deixa só UMA leitura de âncora antes da
+  // mutação. Assim, uma falha objetiva vira correção curta em vez de outra
+  // rodada inteira de exploração.
+  const _inspectionMax = opts.recoveryMode && _actionExpected
+    ? 1
+    : (_hasMandatoryArtifact && _actionExpected
+      ? (opts.atomicMetaItem ? 8 : 2)
+      : (_complexTask ? Math.min(6, Math.max(4, Math.ceil(maxIter * 0.20))) : 4));
   const _inspectionWarnAt = Math.max(2, _inspectionMax - 1);
   let _executionStartedAt = 0;
 
@@ -1236,7 +1328,7 @@ async function run(task, opts = {}) {
         const reply = await llmCall({
           baseUrl: k.baseUrl, key: k.key, messages, model: selectedModel,
           toolsOverride: mainTools, creditBudget: Math.max(1, Math.min(maxCredits - charged - _visionCredits, _phaseBudgets.execution.credits - _phaseUsage.execution.credits)),
-          ...extra, signalMs, tries: 1,
+          ...extra, maxCompletionTokens: extra.maxCompletionTokens || 6000, signalMs, tries: 1,
         });
         if (model && forcedModelMismatch(model, reply && reply.model)) {
           const err = new ApiError(`Modelo forçado não foi respeitado: solicitado "${model}", recebido "${reply.model}". A missão foi interrompida sem fallback.`, { status: 409, code: 'model_substituted' });
@@ -1259,7 +1351,14 @@ async function run(task, opts = {}) {
   async function _callRole(role, system, user, validate = null) {
     const phase = role === 'planner' ? 'planning' : (role === 'inspector' ? 'verification' : 'execution');
     const contract = intelligence.agentRoleContract(role, opts.accountPlan || 'free', { complex: _complexTask });
-    const baseCandidates = (model ? [selectedModel] : [...contract.candidates]).slice(0, 1 + planUpgradeLimit(opts.accountPlan || 'free'));
+    // O executor pode ser fixado sem sequestrar o planejador. Missões do
+    // produto usam DeepSeek Pro para executar/corrigir e Luna para planejar;
+    // antes desta separação, `model` aplicava DeepSeek também ao planner.
+    const roleForcedModel = role === 'planner' && opts.plannerModel
+      ? String(opts.plannerModel)
+      : model;
+    const baseCandidates = (roleForcedModel ? [role === 'planner' && opts.plannerModel ? roleForcedModel : selectedModel] : [...contract.candidates])
+      .slice(0, 1 + planUpgradeLimit(opts.accountPlan || 'free'));
     // Plano vazio/JSON inválido é uma falha objetiva, mas não autoriza trocar o
     // planejador pelo executor. A segunda tentativa curta mantém a Luna como
     // dona do planejamento e atende inclusive ao Free sem upgrade de modelo.
@@ -1281,10 +1380,11 @@ async function run(task, opts = {}) {
         _phaseUsage[phase].attempts++;
         onStep({ name: 'agente_' + role, detail: roleModel, phase, model: roleModel });
         const r = await llmCall({ baseUrl: k.baseUrl, key: k.key, model: roleModel, noTools: true, signalMs,
+          maxCompletionTokens: role === 'planner' ? 2200 : 1400,
           creditBudget: Math.max(1, Math.min(maxCredits - charged - _visionCredits, _phaseBudgets[phase].credits - _phaseUsage[phase].credits)), tries: 1,
           messages: [{ role: 'system', content: contract.prompt + '\n' + system }, { role: 'user', content: user }] });
-        if (model && forcedModelMismatch(model, r && r.model)) {
-          const err = new ApiError(`Modelo forçado não foi respeitado: solicitado "${model}", recebido "${r.model}". A missão foi interrompida sem fallback.`, { status: 409, code: 'model_substituted' });
+        if (roleForcedModel && forcedModelMismatch(roleForcedModel, r && r.model)) {
+          const err = new ApiError(`Modelo forçado não foi respeitado: solicitado "${roleForcedModel}", recebido "${r.model}". A missão foi interrompida sem fallback.`, { status: 409, code: 'model_substituted' });
           throw err;
         }
         const u = r.usage || {};
@@ -1381,7 +1481,7 @@ async function run(task, opts = {}) {
         const sys = lang !== 'en'
           ? 'Resuma a conversa de agente abaixo em UM bloco curto e denso (máx ~300 palavras): objetivo, o que já foi feito (arquivos/comandos e resultados), decisões tomadas e o que falta. Preserve caminhos de arquivos e fatos técnicos EXATOS. Sem preâmbulo.'
           : 'Summarize the agent conversation below into ONE short dense block (max ~300 words): goal, what was done (files/commands and results), decisions, and what remains. Preserve EXACT file paths and technical facts. No preamble.';
-        const r = await llmCall({ baseUrl: k.baseUrl, key: k.key, model: selectedModel, noTools: true, signalMs: 60000, creditBudget: Math.max(1, maxCredits - charged - _visionCredits), messages: [{ role: 'system', content: sys }, { role: 'user', content: lines }] });
+        const r = await llmCall({ baseUrl: k.baseUrl, key: k.key, model: selectedModel, noTools: true, signalMs: 60000, maxCompletionTokens: 900, creditBudget: Math.max(1, maxCredits - charged - _visionCredits), messages: [{ role: 'system', content: sys }, { role: 'user', content: lines }] });
         const u = r.usage || {};
         acc.inTok += u.prompt_tokens || 0; acc.outTok += u.completion_tokens || 0;
         charged += (r.billing && r.billing.charged) || 0;
@@ -1410,7 +1510,10 @@ async function run(task, opts = {}) {
   // PLANEJADOR: uma chamada curta, sem ferramentas, antes de tarefas que alteram algo.
   // Decide o que é material para o usuário e transforma o restante em plano/aceite.
   // Falha do planejador degrada para o executor normal; nunca derruba missão viável.
-  if (!roMode && _actionExpected && opts.orchestrate !== false
+  // O Meta já planejou o item atômico antes de chamar este executor. Quando a
+  // retomada também trouxe um trecho local verificável, planejar de novo só
+  // duplica latência e pode consumir toda a janela antes da correção.
+  if (!opts.skipPlanner && !roMode && _actionExpected && opts.orchestrate !== false
       && (materialDecisionPreflight(taskText) || shouldRunPlanner({ priorMessages: opts.priorMessages, taskText }))) {
     const preflight = materialDecisionPreflight(taskText);
     if (preflight) {
@@ -1424,7 +1527,10 @@ async function run(task, opts = {}) {
     const planner = await _callRole('planner',
       'Responda APENAS JSON válido: {"decision":"execute|ask","decision_kind":"recipient|destination|irreversible|credential|external_authorization|payment|business_choice|technical|cosmetic|none","question":"","reason":"","assumptions":[],"steps":[],"acceptance":[]}. '
       + 'Pergunte SOMENTE se falta uma escolha material que muda o resultado ou autoriza efeito externo/irreversível. NUNCA pergunte sobre framework, cor, layout, nome interno, pasta descobrível, dependência ou detalhe reversível: escolha com bom senso. Se puder descobrir com ferramentas, execute.',
-      `TAREFA:\n${taskText}\n\nPROJETO:\n${_projectBrief.slice(0, 8500)}`,
+      `TAREFA:\n${taskText}\n\nPROJETO:\n${_projectBrief.slice(0, 8500)}`
+        + (opts.atomicMetaItem
+          ? '\n\nMODO ITEM ATÔMICO: esta é UMA etapa de checklist, não o projeto inteiro. Produza no máximo 3 passos diretamente ligados a esta etapa e critérios que possam ser provados nesta mesma rodada. Não inclua roadmap, próximas telas ou tarefas futuras.'
+          : ''),
       validatePlannerDecision);
     if (!planner) {
       finalText = 'Não iniciei a execução porque o planejador não produziu um plano válido dentro do orçamento da fase. Nenhum arquivo foi alterado. Você pode tentar novamente; o sistema registrou a falha objetiva para diagnóstico.';
@@ -1515,7 +1621,13 @@ async function run(task, opts = {}) {
     if (!tcs.length) {
       // alguns modelos (MiniMax/DeepSeek) vazam o raciocínio em <think> — o usuário não precisa ver
       const candidateText = String(r.msg.content || '').replace(/<think>[\s\S]*?<\/think>/gi, '').replace(/<think>[\s\S]*$/i, '').trim();
-      if (!roMode && _actionExpected && candidateAdmitsIncomplete(candidateText)
+      // Em uma tarefa que exige alteração comprovável, uma resposta sem ferramenta
+      // não é entrega — mesmo que o modelo tenha escrito uma frase confiante. Antes
+      // este recovery só disparava quando o próprio modelo admitia a pendência; isso
+      // deixava respostas vazias/"completed" encerrarem missões sem modificar nada.
+      const _noActionResponse = !actions.length
+        && (!candidateText || candidateAdmitsIncomplete(candidateText) || _actionExpected);
+      if (!roMode && _actionExpected && _noActionResponse
           && _incompleteRecoveryAttempts < 1 && !_guard()) {
         _incompleteRecoveryAttempts++;
         messages.push({ role: 'assistant', content: candidateText });
@@ -1821,6 +1933,26 @@ async function run(task, opts = {}) {
           onStep({ name, detail: argsShort(name, input), blocked: true });
         }
       }
+      // Navegador assistido: abrir/ler é seguro; clicar, digitar e analisar uma
+      // captura com modelo externo exigem confirmação SEMPRE. Nem --yolo silencia
+      // este gate, porque o agente não consegue saber se um botão publica, compra
+      // ou envia um formulário.
+      if (result === undefined && name === 'navegador') {
+        const browserRequest = browserApprovalRequest(input);
+        if (browserRequest) {
+          let approved = false, remoteTried = false;
+          if (!yes) {
+            const dec = await askApprove(browserRequest);
+            approved = decideApproval({ autoAll: false, decision: dec }).approved;
+          } else ({ approved, remoteTried } = await _remoteApprove(browserRequest.cmd, token, onRemote));
+          if (!approved) {
+            result = { erro: yes
+              ? (remoteTried ? 'RECUSADO: o dono negou ou não respondeu à ação no navegador.' : 'RECUSADO: ação no navegador exige aprovação remota no modo --yes.')
+              : 'O usuário recusou a ação no navegador. A página continua apenas em modo de leitura.' };
+            onStep({ name: 'navegador', detail: browserRequest.cmd, blocked: true });
+          }
+        }
+      }
       // Gate de AUTO-MODIFICAÇÃO (skills): o agente só cria/melhora skill com o humano
       // vendo a prévia. Em --yes (cron) NÃO pergunta nem grava live — marca _stage e a
       // tools grava em ~/.ts/skills-pending pro dono revisar depois (ts skills pendentes).
@@ -1949,8 +2081,21 @@ async function run(task, opts = {}) {
       // ORÇAMENTO DE INSPEÇÃO: em tarefa de ação, leitura e diagnóstico são uma fase
       // finita. Reserva as rodadas restantes para editar, testar e corrigir, independente
       // de o modelo executor ser conservador ou insistir em reler o projeto inteiro.
-      const _inspectionOnly = READONLY.has(name) || (name === 'executar_comando' && isInspectionCommand(input.comando));
-      if (result === undefined && _actionExpected && _inspectionOnly && _inspectionPhaseClosed && !_hasExecution()) {
+      // A leitura de uma skill que o harness acabou de anunciar não é
+      // investigação do projeto. Contá-la no teto de inspeção deixava apenas
+      // uma leitura do código antes de bloquear a edição em missões /meta.
+      const _trustedSkillRead = name === 'ler_arquivo'
+        && _trustedSkillPaths.some(allowed => path.resolve(String(allowed)) === path.resolve(String(input && input.caminho || '')));
+      const _inspectionOnly = !_trustedSkillRead && (READONLY.has(name) || (name === 'executar_comando' && isInspectionCommand(input.comando)));
+      const _inspectionSignature = name === 'ler_arquivo'
+        ? `file:${path.resolve(cwd, String(input && input.caminho || ''))}`
+        : (name === 'executar_comando'
+          ? `command:${String(input && input.comando || '').trim().replace(/\s+/g, ' ')}`
+          : `${name}:${JSON.stringify(input || {})}`);
+      const _lateFocusedInspection = _inspectionPhaseClosed
+        && !_lateFocusedInspectionUsed
+        && !_inspectionSignatures.has(_inspectionSignature);
+      if (result === undefined && _actionExpected && _inspectionOnly && _inspectionPhaseClosed && !_hasExecution() && !_lateFocusedInspection) {
         // O turno anterior já explicou que a investigação acabou. Repetir uma
         // leitura agora não é exploração legítima: é insistência sem progresso.
         // Cortamos aqui, antes de gastar mais turnos até MAX_ITER, e deixamos
@@ -1963,15 +2108,21 @@ async function run(task, opts = {}) {
         steps++;
       }
       if (result === undefined && _actionExpected && _inspectionOnly && !_hasExecution()) {
-        _inspectionCalls++;
-        const _phase = inspectionGateDecision({ actionExpected: true, hasMutation: false, calls: _inspectionCalls, warnAt: _inspectionWarnAt, max: _inspectionMax });
-        if (_phase === 'block') {
-          _inspectionPhaseClosed = true;
-          _forceActionGate = true;
-          onStep({ name, detail: 'fase de inspeção encerrada', blocked: true });
-          result = { erro: 'FASE DE INSPEÇÃO ENCERRADA: o pacote do projeto e as leituras anteriores já são suficientes. Não leia nem pesquise mais. A próxima chamada deve EDITAR/ESCREVER/EXECUTAR a solução; depois rode os testes.' };
-          steps++;
-        } else if (_phase === 'warn') _inspectionWarning = true;
+        _inspectionSignatures.add(_inspectionSignature);
+        if (_lateFocusedInspection) {
+          _lateFocusedInspectionUsed = true;
+          onStep({ name, detail: 'leitura focada final autorizada antes da edição', retry: true });
+        } else {
+          _inspectionCalls++;
+          const _phase = inspectionGateDecision({ actionExpected: true, hasMutation: false, calls: _inspectionCalls, warnAt: _inspectionWarnAt, max: _inspectionMax });
+          if (_phase === 'block') {
+            _inspectionPhaseClosed = true;
+            _forceActionGate = true;
+            onStep({ name, detail: 'fase de inspeção encerrada', blocked: true });
+            result = { erro: 'FASE DE INSPEÇÃO ENCERRADA: o pacote do projeto e as leituras anteriores já são suficientes. Não leia nem pesquise mais. A próxima chamada deve EDITAR/ESCREVER/EXECUTAR a solução; depois rode os testes.' };
+            steps++;
+          } else if (_phase === 'warn') _inspectionWarning = true;
+        }
       }
       if (result === undefined && READONLY.has(name)) {
         const _cached = _cachedRead;
@@ -1985,7 +2136,7 @@ async function run(task, opts = {}) {
       }
       if (result === undefined) {
         onStep({ name, detail: argsShort(name, input) });
-        result = await tools.execute(name, input, { confineDir, baseDir: cwd, token, allowedTools: _allowedToolNames });
+        result = await tools.execute(name, input, { confineDir, baseDir: cwd, token, allowedTools: _allowedToolNames, trustedReadPaths: _trustedSkillPaths });
         steps++; _ran = true;
         // TOOLRESULT TIPADO (core.classifyToolResult): classe de erro DETERMINÍSTICA. A verdade
         // sobre "deu certo?" vem daqui, não da narrativa do modelo. 'blocked' = política (gate),
@@ -2128,7 +2279,7 @@ async function run(task, opts = {}) {
     try {
       const signalMs = modelCallWindow({ maxDurationMs, elapsedMs: Date.now() - missionStartedAt });
       if (!signalMs) throw new ApiError('model_timeout', { code: 'timeout' });
-      const r = await llmCall({ baseUrl: k.baseUrl, key: k.key, messages: [...messages, { role: 'user', content: pedido }], model: selectedModel, noTools: true, signalMs, tries: 1, creditBudget: Math.max(1, maxCredits - charged - _visionCredits) });
+      const r = await llmCall({ baseUrl: k.baseUrl, key: k.key, messages: [...messages, { role: 'user', content: pedido }], model: selectedModel, noTools: true, signalMs, maxCompletionTokens: 900, tries: 1, creditBudget: Math.max(1, maxCredits - charged - _visionCredits) });
       const u = r.usage || {};
       acc.inTok += u.prompt_tokens || 0; acc.outTok += u.completion_tokens || 0;
       charged += (r.billing && r.billing.charged) || 0;
@@ -2249,4 +2400,4 @@ async function run(task, opts = {}) {
   return { text: finalText, steps, credits: charged + _visionCredits, tokens: acc, model: usedModel, actions, messages, cwd, context: lastCtx, toolErrors: _toolErrs, lastToolError: _lastErr, guard: guardStopped, completion, verification: verifyReport, observability: _observability, report: _finalReport, orchestration: { plan: _planDecision, roles: _roleTrace, inspections: _inspectionTrace, phaseBudgets: _phaseBudgets, phaseUsage: _phaseUsage }, missionCache: _missionCache.stats() };
 }
 
-module.exports = { run, llm, _test: { systemPrompt, projectBrief, inspectionGateDecision, candidateAdmitsIncomplete, isInspectionCommand, parseStageJson, materialDecisionPreflight, actionExpectedForTask, requiresActionEvidence, shouldRunPlanner, isComplexTask, validatePlannerDecision, planUpgradeLimit, commandRecoveryHint, windowsUnsupportedUnixCommand, mutationBatchConflicts, normalizePlannerDecision, normalizeInspectorDecision, winFor, estMsgsTok, COMPACT_AT, KEEP_TAIL, loopSig, isCycle, loopDecision, decideApproval, failureFingerprint, missionGuardDecision, missionBudgetSuggestion, missionTokenCap, missionTimeCap, modelCallWindow, executorFallbackChain, forcedModelMismatch, isTransientModelError, completionGateDecision, canCloseFromProofs, taskScopedToolDefs, explicitTaskWorkdir, restrictedGatewayDecision, validarModeloByok, scopeToolDefs, parseTextToolCalls, isUntrustedToolOutput, untrustedToolEnvelope, isRemoteDeployCommand } };
+module.exports = { run, llm, _test: { systemPrompt, projectBrief, inspectionGateDecision, candidateAdmitsIncomplete, isInspectionCommand, parseStageJson, materialDecisionPreflight, actionExpectedForTask, requiresActionEvidence, shouldRunPlanner, isComplexTask, validatePlannerDecision, planUpgradeLimit, commandRecoveryHint, windowsUnsupportedUnixCommand, mutationBatchConflicts, normalizePlannerDecision, normalizeInspectorDecision, winFor, estMsgsTok, COMPACT_AT, KEEP_TAIL, loopSig, isCycle, loopDecision, decideApproval, failureFingerprint, missionGuardDecision, missionBudgetSuggestion, missionTokenCap, missionTimeCap, modelCallWindow, executorFallbackChain, forcedModelMismatch, isTransientModelError, completionGateDecision, canCloseFromProofs, taskScopedToolDefs, explicitTaskWorkdir, restrictedGatewayDecision, validarModeloByok, scopeToolDefs, parseTextToolCalls, isUntrustedToolOutput, untrustedToolEnvelope, isRemoteDeployCommand, browserApprovalRequest } };

package/lib/conversation-scope.js

@@ -0,0 +1,21 @@
+'use strict';
+
+// Conversas de chat precisam ter continuidade DENTRO do mesmo trabalho, mas nunca
+// carregar o contexto de um projeto para outro. Um único `convId` global fazia uma
+// pergunta feita em D:\\CineHub herdar uma conversa antiga do EspecialRO.
+const crypto = require('crypto');
+const path = require('path');
+
+function workspaceScope(cwd = process.cwd(), kind = 'chat') {
+  const absolute = path.resolve(cwd || process.cwd());
+  const normalized = process.platform === 'win32' ? absolute.toLowerCase() : absolute;
+  const digest = crypto.createHash('sha256').update(normalized).digest('hex').slice(0, 16);
+  return `${String(kind || 'chat').toLowerCase()}:${digest}`;
+}
+
+function conversationTitle(cwd = process.cwd(), kind = 'CLI') {
+  const name = path.basename(path.resolve(cwd || process.cwd())) || 'início';
+  return `${kind} · ${name}`.slice(0, 120);
+}
+
+module.exports = { workspaceScope, conversationTitle };

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 };

package/lib/tools.js

@@ -39,6 +39,18 @@ function _snapshot(absPath) {
 // pra compatibilidade (tools.isDestructive segue funcionando pra quem já importava).
 const { isDestructive } = require('./core');
 
+// `findstr`, `rg` e `grep` usam o código 1 para informar que a busca foi
+// executada corretamente, mas não encontrou ocorrências. Para o harness isso
+// é evidência de inspeção (por exemplo: confirmar que um texto antigo já não
+// existe), e não uma falha operacional que justifique repetir a mesma ação.
+function _isReadOnlySearchNoMatch(command, code, stdout, stderr) {
+  if (Number(code) !== 1 || String(stdout || '').trim() || String(stderr || '').trim()) return false;
+  const executable = String(command || '')
+    .trim()
+    .replace(/^\s*cd\s+(?:\/d\s+)?(?:"[^"]+"|'[^']+'|[^&|]+)\s*(?:&&|&)\s*/i, '');
+  return /^(?:findstr|rg|grep)\b/i.test(executable);
+}
+
 // Conteúdo de e-mail/site/arquivo pode tentar convencer o modelo a mandar
 // segredos para fora. O prompt ajuda, mas a defesa precisa existir também no
 // executor: se um comando combina transporte de rede com fonte sensível, ele
@@ -523,6 +535,15 @@ function _commandScopeViolation(cmd, confineDir) {
     if (!/^[a-z][a-z0-9+.-]*:\/\//i.test(m[1])) candidates.push(m[1]);
   }
   for (const raw of candidates) {
+    // No CMD do Windows, `cd /d C:\\projeto` usa /d como um modificador
+    // (troca também a unidade atual), não como caminho Unix absoluto. Sem
+    // esta exceção o confinamento recusava uma mudança de pasta totalmente
+    // interna antes de o comando chegar ao shell.
+    // Opções do CMD também podem ter dois-pontos, por exemplo
+    // `findstr /c:"texto"`. Não são caminhos Unix nem tentativas de escapar da
+    // raiz. Sem esta exceção uma busca contendo `</script>` era lida como
+    // redirecionamento e o `/c:` seguinte virava um falso caminho externo.
+    if (process.platform === 'win32' && /^\/[a-z](?::|$)/i.test(raw)) continue;
     const abs = path.resolve(root, raw);
     if (!_scopeContains(root, abs)) {
       return `CAPABILITY_DENIED: comando mutante referencia "${raw}", fora da raiz autorizada "${root}".`;
@@ -653,6 +674,11 @@ async function execute(name, input, opts = {}) {
   }
   const _outsideScope = (p) => {
     if (!opts.confineDir) return false;
+    // Uma skill só pode ser lida fora do projeto se o chamador a tiver
+    // explicitamente anunciado nesta rodada. Isso permite seguir uma skill
+    // instalada sem transformar ~/.ts, ~/.codex etc. em acesso geral.
+    if (name === 'ler_arquivo' && Array.isArray(opts.trustedReadPaths)
+        && opts.trustedReadPaths.some(allowed => path.resolve(String(allowed)) === path.resolve(String(p)))) return false;
     return !_scopeContains(opts.confineDir, p);
   };
   const _scopeError = (p) => ({ erro: `CAPABILITY_DENIED: "${path.resolve(p)}" está fora da raiz autorizada "${path.resolve(opts.confineDir)}".` });
@@ -685,6 +711,11 @@ async function execute(name, input, opts = {}) {
             // B18: mascara chave/token ANTES de virar contexto do modelo e linha de log.
             const _rd = require('./core').redactSecrets;
             const r = { stdout: _rd(c.out), stderr: _rd(compactor.stripAnsi(err || '').slice(0, 1500)), codigo: e?.code ?? 0 };
+            if (_isReadOnlySearchNoMatch(comandoExecutado, r.codigo, r.stdout, r.stderr)) {
+              r.codigo = 0;
+              r.no_match = true;
+              r.stdout = 'Nenhuma ocorrência encontrada.';
+            }
             if (c.note) r.aviso = c.note;
             if (normalized) r.normalizado = normalized.note;
             if (!r.stdout.trim() && !r.stderr.trim() && r.codigo === 0 && /python3? -c/.test(comando) && comando.includes('\n'))
@@ -1165,4 +1196,4 @@ async function execute(name, input, opts = {}) {
 }
 
 module.exports = { DEFS, execute, isDestructive, selfDestructiveReason, secretExfiltrationReason, buildProjectMap,
-  _test: { shellGotcha: _shellGotcha, normalizeWindowsReadOnlyCommand: _normalizeWindowsReadOnlyCommand } };
+  _test: { shellGotcha: _shellGotcha, normalizeWindowsReadOnlyCommand: _normalizeWindowsReadOnlyCommand, commandScopeViolation: _commandScopeViolation, isReadOnlySearchNoMatch: _isReadOnlySearchNoMatch } };

package/lib/verify.js

@@ -17,8 +17,21 @@ function vCommand(c, cwd) {
   const want = c.exit != null ? Number(c.exit) : 0;
   try {
     const out = execSync(c.cmd, { cwd, encoding: 'utf8', timeout: (c.timeout_s || 120) * 1000, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
+    const output = String(out || '');
+    // Um script como `echo "No tests yet" && exit 0` não é uma prova de saúde.
+    // Para critérios que afirmam rodar testes, trate explicitamente essa saída
+    // como falha, mesmo que o processo tenha saído com código zero.
+    const isTestCommand = /(^|\s)(npm\s+test|pnpm\s+test|yarn\s+test|node\s+.*test)/i.test(String(c.cmd || ''));
+    const noTests = /\b(no tests? yet|no tests? (?:found|run)|0 tests? (?:found|run))\b/i.test(output);
+    if (want === 0 && isTestCommand && noTests) {
+      return { ok: false, detail: 'teste sem casos executados (falso positivo)', errorClass: 'verification_failed', evidence: output.slice(-200).replace(/\s+/g, ' ') };
+    }
+    const reportedFailure = /(^|\n)\s*(?:✗|FAIL(?:\s|:|$)|AssertionError\b)/im.test(output);
+    if (want === 0 && isTestCommand && reportedFailure) {
+      return { ok: false, detail: 'teste reportou falha apesar de exit 0 (falso positivo)', errorClass: 'verification_failed', evidence: output.slice(-300).replace(/\s+/g, ' ') };
+    }
     const ok = want === 0;
-    return { ok, detail: ok ? 'exit 0' : `exit 0 mas esperava ${want}`, evidence: String(out).slice(-200).replace(/\s+/g, ' ') };
+    return { ok, detail: ok ? 'exit 0' : `exit 0 mas esperava ${want}`, evidence: output.slice(-200).replace(/\s+/g, ' ') };
   } catch (e) {
     const code = typeof e.status === 'number' ? e.status : 1;
     const ok = code === want;

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "terminal-smart-cli",
-  "version": "0.97.31",
+  "version": "0.97.41",
   "description": "Terminal Smart no seu terminal — pergunte, analise logs por pipe e orquestre agentes de IA. Comando: ts",
   "bin": {
     "ts": "bin/ts.js"
   },
   "scripts": {
-    "test": "node test/core.test.js && node test/windows-shell-normalization.test.js && node test/gateways.test.js && node test/agent-recovery-guard.test.js && node test/agent-plan-model-contract.test.js && node test/agent-mission-limits.test.js && node test/agent-external-approval.test.js && node test/agent-prompt-injection.test.js && node test/file-concurrency.test.js && node test/mission-observability.test.js && node test/audit-packs.test.js && node test/intelligence-core.test.js && node test/cloud-slug.test.js && node test/eval-model.test.js && node test/project-cache.test.js && node test/memory-bus.test.js && node test/capabilities.test.js && node test/mcp-e2e.test.js && node test/erros.test.js && node test/evolution-telemetry.test.js && node test/owner-audit.test.js && node test/capability-pack.test.js && node test/video-generation.test.js && node test/image-job.test.js && node test/byok.test.js && node test/conhecimento.test.js && node test/policy.test.js && node test/temas.test.js && node test/skill-index.test.js && node test/doctor.test.js && node test/google-workspace-tools.test.js && node test/office-editors.test.js"
+    "test": "node test/core.test.js && node test/conversation-scope.test.js && node test/windows-shell-normalization.test.js && node test/gateways.test.js && node test/agent-recovery-guard.test.js && node test/agent-plan-model-contract.test.js && node test/agent-mission-limits.test.js && node test/agent-external-approval.test.js && node test/agent-prompt-injection.test.js && node test/file-concurrency.test.js && node test/mission-observability.test.js && node test/audit-packs.test.js && node test/intelligence-core.test.js && node test/cloud-slug.test.js && node test/eval-model.test.js && node test/project-cache.test.js && node test/memory-bus.test.js && node test/capabilities.test.js && node test/mcp-e2e.test.js && node test/erros.test.js && node test/evolution-telemetry.test.js && node test/owner-audit.test.js && node test/capability-pack.test.js && node test/video-generation.test.js && node test/image-job.test.js && node test/byok.test.js && node test/conhecimento.test.js && node test/policy.test.js && node test/temas.test.js && node test/skill-index.test.js && node test/doctor.test.js && node test/google-workspace-tools.test.js && node test/office-editors.test.js"
   },
   "files": [
     "bin",