terminal-smart-cli 0.97.30 → 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;
@@ -1079,6 +1094,19 @@ async function pollRun(token, runId, sp) {
   }
 }
 
+// A run é o resumo; o motivo técnico da falha fica na etapa. Centralizar a
+// leitura evita que o usuário receba apenas "falhou" e tenha de investigar
+// logs ou a interface web para saber o que fazer em seguida.
+function runFailureMessage(run) {
+  const failed = (run && Array.isArray(run.steps) ? run.steps : []).find(s => s && s.status === 'failed');
+  const raw = String((failed && (failed.error_message || failed.result_summary)) || (run && run.error) || '').trim();
+  const code = String((failed && failed.error_code) || '').trim();
+  if (code === 'execution_unavailable' || /n[aã]o executo comandos diretamente|n[aã]o tenho acesso.*(windows|computador|m[aá]quina|sistema)|execute.*powershell/i.test(raw)) {
+    return 'Esta orquestração roda na nuvem e não acessa arquivos do seu computador. Para criar, editar ou inspecionar algo local, use: ts agente "sua tarefa".';
+  }
+  return raw || 'Nenhuma ação foi concluída. Consulte as etapas da execução para ver o motivo.';
+}
+
 // Fluxo completo de orquestração (usado pelo `ts run` e pelo /run do modo conversa).
 // askFn permite aprovar com o readline do REPL sem conflito de stdin; nunca chama process.exit.
 async function runFlow(goal, { askFn = ui.ask, json = false, yes = false } = {}) {
@@ -1112,7 +1140,7 @@ async function runFlow(goal, { askFn = ui.ask, json = false, yes = false } = {})
     const result = run.final_result || run.result || '';
     if (result) { console.log(''); console.log(ui.md(String(result)).split('\n').map(l => '  ' + l).join('\n')); console.log(''); }
   } else if (run.status === 'failed') {
-    console.error(ui.errLine(C.bold(T.run_failed) + (run.error ? C.dim(' · ' + String(run.error).slice(0, 140)) : '')));
+    console.error(ui.errLine(C.bold(T.run_failed) + C.dim(' · ' + runFailureMessage(run).slice(0, 320))));
   } else {
     console.log(ui.infoLine(T.run_paused(runLbl(run.status))));
   }
@@ -1818,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. ──
@@ -3169,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));
 }
 
@@ -3280,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,20 @@ 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 candidates = (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.
+    const candidates = role === 'planner' && baseCandidates.length === 1
+      ? [baseCandidates[0], baseCandidates[0]]
+      : baseCandidates;
     let last = null;
     let lastFailureReported = false;
     const phaseStartedAt = Date.now();
@@ -1275,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 || {};
@@ -1296,8 +1402,12 @@ async function run(task, opts = {}) {
           onStepDone({ name: 'agente_' + role, ok: false, status: 'error', evidence: last.message });
           lastFailureReported = true;
           if (candidateIndex + 1 < candidates.length) {
-            _fallbackTrace.push({ role, from: roleModel, to: candidates[candidateIndex + 1], reason: last.message });
-            onStep({ name: 'fallback_modelo', detail: `${last.message}: ${roleModel} → ${candidates[candidateIndex + 1]}`, retry: true });
+            const next = candidates[candidateIndex + 1];
+            if (next === roleModel) onStep({ name: 'nova_tentativa', detail: `${last.message}: nova tentativa curta com ${roleModel}`, retry: true });
+            else {
+              _fallbackTrace.push({ role, from: roleModel, to: next, reason: last.message });
+              onStep({ name: 'fallback_modelo', detail: `${last.message}: ${roleModel} → ${next}`, retry: true });
+            }
           }
           continue;
         }
@@ -1313,8 +1423,12 @@ async function run(task, opts = {}) {
         lastFailureReported = true;
         if (candidateIndex + 1 < candidates.length) {
           const reason = String(e && e.message || 'falha objetiva').slice(0, 100);
-          _fallbackTrace.push({ role, from: roleModel, to: candidates[candidateIndex + 1], reason });
-          onStep({ name: 'fallback_modelo', detail: `${reason}: ${roleModel} → ${candidates[candidateIndex + 1]}`, retry: true });
+          const next = candidates[candidateIndex + 1];
+          if (next === roleModel) onStep({ name: 'nova_tentativa', detail: `${reason}: nova tentativa curta com ${roleModel}`, retry: true });
+          else {
+            _fallbackTrace.push({ role, from: roleModel, to: next, reason });
+            onStep({ name: 'fallback_modelo', detail: `${reason}: ${roleModel} → ${next}`, retry: true });
+          }
         }
         if (!isTransientModelError(e) && Number(e && e.status) !== 404 && !/model.*(?:not found|unavailable|unsupported)/i.test(String(e && e.message || ''))) break;
       }
@@ -1367,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;
@@ -1396,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) {
@@ -1410,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.';
@@ -1501,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 });
@@ -1807,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).
@@ -1935,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
@@ -1949,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;
@@ -1971,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),
@@ -2114,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;
@@ -2235,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 };