terminal-smart-cli 0.97.12 → 0.97.14

package/lib/meta.js

@@ -29,6 +29,96 @@ const MAX_VISUAL_FIXES = 5;  // rodadas de polimento VISUAL (o olho crítico)
 const MAX_VISUAL_FIXES_FLUTTER = 3; // Flutter: rebuild é MUITO mais pesado/lento → teto menor de polimento (economia)
 const VISUAL_ESCALATE_AT = 2; // após N reprovações visuais, a MÃO do fix vira o modelo forte (grok) — o deepseek erra layout complexo
 const MAX_BUILD_FIXES = 12; // rodadas extras de correção de build antes de desistir
+const META_PROJECT_TOOLS = Object.freeze([
+  'executar_comando', 'ler_arquivo', 'escrever_arquivo', 'editar_arquivo',
+  'restaurar_arquivo', 'listar_diretorio', 'buscar_arquivos', 'buscar_codigo',
+  'mapa_projeto', 'preciso_de_voce',
+]);
+
+// Most meta rounds work inside one local project. Do not send schemas for
+// Gmail, Outlook, Android, SSH and Drive unless the item needs integrations.
+function toolsForMetaItem(item, goal) {
+  const text = `${item && item.desc || ''}\n${goal || ''}`.toLowerCase();
+  if (/\b(gmail|outlook|e-?mail|google\s+(drive|docs|sheets)|onedrive|microsoft\s*365|ssh|vps|servidor remoto|android|celular|telegram|whatsapp)\b/i.test(text)) return null;
+  return [...META_PROJECT_TOOLS];
+}
+
+// Connect each checklist item to a concrete artifact. Planner criteria have
+// priority; deterministic fallbacks cover later items that exceed the criteria cap.
+function artifactForMetaItem(item, st) {
+  const list = Array.isArray(st && st.checklist) ? st.checklist : [];
+  const index = Math.max(0, list.indexOf(item));
+  const criterion = Array.isArray(st && st.criteria) ? st.criteria[index] : null;
+  if (criterion && criterion.type === 'file_exists' && criterion.path) return String(criterion.path);
+  const d = String(item && item.desc || '').toLowerCase();
+  if (/controller.*8 dire|8 dire.*controller/.test(d)) return 'src/player_controller.gd';
+  if (/combate b[aá]sico|sistema de combate/.test(d)) return 'src/combat_system.gd';
+  if (/interface|\bui\b|\bhud\b/.test(d)) return 'docs/UI_SPEC.md';
+  if (/80-100 monstros|lista.*monstros/.test(d)) return 'data/monsters.json';
+  if (/economia|zeny|vending/.test(d)) return 'docs/ECONOMY.md';
+  if (/prioriza|\bmvp\b.*alpha|roadmap/.test(d)) return 'docs/ROADMAP.md';
+  return `artifacts/${String(item && item.id || 'item').replace(/[^a-z0-9_-]/gi, '_')}.md`;
+}
+
+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)) {
+    const a = text.indexOf('['), o = text.indexOf('{');
+    const start = a >= 0 && (o < 0 || a < o) ? a : o;
+    const end = Math.max(text.lastIndexOf(']'), text.lastIndexOf('}'));
+    if (start < 0 || end < start) throw new Error('resposta sem JSON');
+    const parsed = JSON.parse(text.slice(start, end + 1));
+    text = JSON.stringify(parsed, null, 2) + '\n';
+  }
+  if (!text || text.length < 80) throw new Error('artefato vazio ou curto demais');
+  return text;
+}
+
+function persistMetaArtifact(dir, relativePath, raw) {
+  const root = path.resolve(dir);
+  const target = path.resolve(root, relativePath);
+  if (target !== root && !target.startsWith(root + path.sep)) throw new Error('artefato fora da pasta confinada');
+  const content = normalizeMetaArtifact(relativePath, raw);
+  fs.mkdirSync(path.dirname(target), { recursive: true });
+  fs.writeFileSync(target, content, 'utf8');
+  return { target, bytes: Buffer.byteLength(content) };
+}
+
+function directArtifactPlan(item) {
+  const d = String(item && item.desc || '').toLowerCase();
+  const groups = (values, size) => { const out = []; for (let i = 0; i < values.length; i += size) out.push(values.slice(i, i + size)); return out; };
+  const uniqueIds = (data, key) => {
+    const rows = data && data[key];
+    if (!Array.isArray(rows) || rows.some(row => !row || row.id === undefined || row.id === null || String(row.id).trim() === '')) return false;
+    const ids = rows.map(row => String(row.id));
+    return new Set(ids).size === ids.length;
+  };
+  if (/classes|novice|[aá]rvores de skills/.test(d)) return {
+    key: 'classes', minimum: 20,
+    parts: groups(['Novice','Swordsman','Mage','Archer','Merchant','Thief','Acolyte','Knight','Crusader','Wizard','Sage','Hunter','Bard','Dancer','Blacksmith','Alchemist','Assassin','Rogue','Priest','Monk'], 4),
+    schema: '{"classes":[{"id":"string","name":"string","tier":0,"base_attributes":{"STR":1,"AGI":1,"VIT":1,"INT":1,"DEX":1,"LUK":1},"skills":[{"id":"string","name":"string","max_level":10,"sp_cost":1,"cooldown_seconds":0,"description":"string"}]}]}',
+    validate: data => uniqueIds(data, 'classes') && data.classes.every(c => Array.isArray(c.skills) && c.skills.length >= 8 && new Set(c.skills.map(s => String(s.id))).size === c.skills.length),
+  };
+  if (/lista completa de mapas|cidades.*masmorras/.test(d)) return {
+    key: 'maps', minimum: 18,
+    parts: groups(['Prontera','Geffen','Payon','Morroc','Alberta','Izlude','Prontera Field North','Prontera Field South','Geffen Field','Payon Forest','Sograt Desert','Prontera Culvert','Byalan Island','Undersea Tunnel','Payon Cave','Geffen Dungeon','Pyramid','Orc Dungeon','Glast Heim'], 4),
+    schema: '{"maps":[{"id":"string","name":"string","type":"city|field|dungeon","level_range":[1,10],"layout":"string","npcs":["string"],"monsters":["string"],"connections":["string"],"safe_areas":["string"],"events":["string"]}]}',
+    validate: data => uniqueIds(data, 'maps'),
+  };
+  if (/50\+ quests|pelo menos 50 quests/.test(d)) return {
+    key: 'quests', minimum: 50,
+    parts: Array.from({ length: 5 }, (_, i) => `quests ${i * 10 + 1} a ${i * 10 + 10}`),
+    schema: '{"quests":[{"id":"string","title":"string","type":"main|side|job|daily|weekly","objectives":["string"],"rewards":{"exp":1,"job_exp":1,"zeny":1,"items":["string"]},"dialogue":"string","prerequisites":["string"]}]}',
+    validate: data => uniqueIds(data, 'quests'),
+  };
+  if (/80-100 monstros|lista detalhada.*monstros/.test(d)) return {
+    key: 'monsters', minimum: 80,
+    parts: Array.from({ length: 10 }, (_, i) => `monstros ${i * 10 + 1} a ${i * 10 + 10}`),
+    schema: '{"monsters":[{"id":"string","name":"string","level":1,"hp":10,"element":"Neutral","size":"Small|Medium|Large","map":"string","drops":[{"item":"string","chance_percent":1}],"is_mvp":false}]}',
+    validate: data => uniqueIds(data, 'monsters') && data.monsters.every(m => Number(m.level) > 0 && Number(m.hp) > 0 && Array.isArray(m.drops)),
+  };
+  return null;
+}
 const WEB_CANVAS_MOVE_MIN = 0.02; // check de MOVIMENTO do canvas web (jogo/cena 3D): diferença MÍNIMA
 // entre 2 quadros pra a cena contar como VIVA. Abaixo disso = parada/congelada (T-pose, mixer parado,
 // loop sem avançar o tempo). SÓ se aplica a canvas de JOGO/3D — dashboard/gráfico pode ficar estático.
@@ -819,7 +909,7 @@ async function _llmJson({ token, system, user, maxTokens = 900 }) {
 }
 
 // Chamada de TEXTO com modelo arbitrário — usada pelo PENSADOR (escalonamento).
-async function _llmText({ token, model, system, user, maxTokens = 1200 }) {
+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);
@@ -827,7 +917,8 @@ async function _llmText({ token, model, system, user, maxTokens = 1200 }) {
   try {
     res = await fetch(String(_key.baseUrl).replace(/\/+$/, '') + '/chat/completions', {
       method: 'POST', signal: ctrl.signal,
-      headers: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + _key.key },
+      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 }] }),
     });
   } finally { clearTimeout(timer); }
@@ -836,7 +927,16 @@ async function _llmText({ token, model, system, user, maxTokens = 1200 }) {
   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 (_) {} }
-  return { text: String(j?.choices?.[0]?.message?.content || '').trim(), credits };
+  const text = String(j?.choices?.[0]?.message?.content || '').trim();
+  // Some providers may return HTTP 200 without `choices` during an internal
+  // failure. Empty output is not a valid brief and must never become success.
+  if (!text) {
+    const providerMessage = String(j?.error?.message || j?.message || '').trim();
+    throw new ApiError(`O modelo ${model || 'selecionado'} retornou uma resposta vazia${providerMessage ? ': ' + providerMessage : '.'}`, {
+      status: 502, code: 'empty_model_response',
+    });
+  }
+  return { text, credits };
 }
 
 // ESCALONAMENTO: o executor barato travou no mesmo erro. Chama o modelo CARO
@@ -1057,7 +1157,7 @@ async function run(goal, opts = {}) {
     const feasModel = thinker || 'grok-4.5';
     if (feasMode === true || (feasMode === 'auto' && looksComplex(goal))) {
       onRound({ n: 0, item: (lang === 'en' ? `Checking feasibility with ${feasModel}…` : `Avaliando viabilidade com ${feasModel}…`), attempt: 1 });
-      try { const fe = await feasibilityPhase(goal, feasModel, token); feasBrief = fe.brief; feasCred = fe.credits || 0; try { fs.writeFileSync(path.join(dir, 'VIABILIDADE.md'), feasBrief); } catch (_) {} onAlert({ type: 'design', text: `🔎 ts: viabilidade avaliada (${feasModel}, ${feasCred} créditos) — o que dá e o que não dá está fixado. Salvo em VIABILIDADE.md.` }); } catch (_e) { if (_e && _e.code === 'no_credits') throw _e; }
+      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)}` }); }
     }
     // FASE DE DESIGN (nova missão visual): o designer forte projeta o design system
     // ANTES do checklist e do código, pra o app sair bonito de fábrica.
@@ -1067,7 +1167,7 @@ async function run(goal, opts = {}) {
       onRound({ n: 0, item: (lang === 'en' ? `Designing the visual with ${designer}…` : `Projetando o visual com ${designer}…`), attempt: 1 });
       let mockupB64 = null;
       if (opts.mockup) { try { mockupB64 = fs.readFileSync(opts.mockup).toString('base64'); onAlert({ type: 'design', text: `🖼 ts: mockup de referência carregado (${path.basename(opts.mockup)}) — o designer vai projetar a partir dele e o olho vai cobrar fidelidade.` }); } catch (_) { onAlert({ type: 'design', text: `⚠ ts: não consegui ler o mockup ${opts.mockup} — seguindo sem ele.` }); } }
-      try { const d = await designPhase(goal, designer, token, { dir, mockupB64, kind: _projKind(goal, dir) }); designBrief = d.brief; designCred = d.credits || 0; try { fs.writeFileSync(path.join(dir, 'DESIGN.md'), designBrief); } catch (_) {} onAlert({ type: 'design', text: `🎨 ts: design system criado pelo ${designer} (${designCred} créditos) — o app vai seguir esse visual. Salvo em DESIGN.md.` }); } catch (_e) { if (_e && _e.code === 'no_credits') throw _e; }
+      try { const d = await designPhase(goal, designer, token, { dir, mockupB64, kind: _projKind(goal, dir) }); designBrief = d.brief; designCred = d.credits || 0; try { fs.writeFileSync(path.join(dir, 'DESIGN.md'), designBrief); } catch (_) {} onAlert({ type: 'design', text: `🎨 ts: design system criado pelo ${designer} (${designCred} créditos) — o app vai seguir esse visual. Salvo em DESIGN.md.` }); } catch (_e) { if (_e && _e.code === 'no_credits') throw _e; onAlert({ type: 'phase_error', text: `⚠ ts: design não concluído: ${String(_e && _e.message || _e).slice(0, 220)}` }); }
     }
     // FASE DE ARQUITETURA (3º pilar): app complexo ganha um CONTRATO antes do checklist
     let archBrief = null, archCred = 0;
@@ -1075,7 +1175,7 @@ async function run(goal, opts = {}) {
     const archModel = thinker || 'grok-4.5';
     if (archMode === true || (archMode === 'auto' && looksComplex(goal))) {
       onRound({ n: 0, item: (lang === 'en' ? `Designing the architecture with ${archModel}…` : `Projetando a arquitetura com ${archModel}…`), attempt: 1 });
-      try { const a = await archPhase(goal, archModel, token, { dir }); archBrief = a.brief; archCred = a.credits || 0; try { fs.writeFileSync(path.join(dir, 'ARQUITETURA.md'), archBrief); } catch (_) {} onAlert({ type: 'design', text: `📐 ts: contrato de arquitetura criado pelo ${archModel} (${archCred} créditos) — componentes, arquivos e assinaturas fixados. Salvo em ARQUITETURA.md.` }); } catch (_e) { if (_e && _e.code === 'no_credits') throw _e; }
+      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);
     // CRITÉRIOS (TaskSpec): usuário (--criterios) manda; senão, com --provar, combina o que o
@@ -1121,6 +1221,16 @@ async function run(goal, opts = {}) {
     // ABRE sem crashar E o "olho" aprova o layout. O portão REENTRA enquanto o visual não passa.
     if (!pend.length) {
       const b = detectBuild(dir);
+      // A documentation/data/code-sample package has no build target by
+      // design. Verify its executable file criteria and finish honestly;
+      // absence of a build system is not a "build-fix ceiling" failure.
+      if (!b) {
+        const criteriaOk = await _checkCriteria(st, dir);
+        st.verification = criteriaOk ? ((st.criteria || []).length ? 'verified' : 'no_gate') : 'unverified';
+        st.status = 'done'; st.finished_at = new Date().toISOString();
+        st.runNote = criteriaOk ? 'pacote sem alvo compilavel; criterios de artefato verificados' : 'criterios de artefato falharam';
+        save(st, dir); onRoundDone({ checklist: st.checklist, spent: st.creditsSpent }); return st;
+      }
       const buildCapLeft  = (st.buildFixes  || 0) < MAX_BUILD_FIXES;
       // teto de polimento visual: menor pra Flutter (rebuild caro/lento) que pra Android
       const visualCap = (b && b.kind === 'flutter') ? MAX_VISUAL_FIXES_FLUTTER : MAX_VISUAL_FIXES;
@@ -1256,9 +1366,119 @@ async function run(goal, opts = {}) {
     }
 
     const item = pend[0];
+    const expectedArtifact = artifactForMetaItem(item, st);
+    // A process can be interrupted after a read-only round but before the
+    // no-artifact branch persists `directArtifact`. Recover that evidence on
+    // resume instead of repeating the same exploratory attempt.
+    const expectedOnDisk = expectedArtifact
+      ? (path.isAbsolute(expectedArtifact) ? expectedArtifact : path.resolve(dir, expectedArtifact))
+      : null;
+    if (!item.directArtifact && (item.attempts || 0) > 0 && expectedOnDisk && !fs.existsSync(expectedOnDisk)) {
+      item.directArtifact = true;
+      item.directModel = item.directModel || 'glm-5.2';
+      item.attempts = Math.max(0, item.attempts - 1);
+    }
     item.attempts = (item.attempts || 0) + 1;
     onRound({ n: st.rounds.length + 1, item: item.desc, attempt: item.attempts });
 
+    // Known large structured deliverables are cheaper and more reliable when
+    // generated in validated batches from the start (classes/maps/quests/monsters).
+    if (!item.directArtifact && directArtifactPlan(item)) {
+      item.directArtifact = true;
+      item.directModel = 'glm-5.2';
+    }
+
+    // Some providers can generate a large document but refuse to place that
+    // content inside tool-call arguments. After a proven zero-tool response,
+    // generate content-only, validate it and let the confined harness persist it.
+    if (item.directArtifact) {
+      const directModel = item.directModel || 'glm-5.2';
+      const plan = directArtifactPlan(item);
+      let totalCredits = 0, finalText = '';
+      if (plan) {
+        const merged = [];
+        item.directParts = item.directParts || {};
+        for (let partIndex = 0; partIndex < plan.parts.length; partIndex++) {
+          if (Array.isArray(item.directParts[partIndex])) {
+            merged.push(...item.directParts[partIndex]);
+            continue;
+          }
+          const part = plan.parts[partIndex];
+          let generated = null, parsedPart = null, lastDirectError = null;
+          for (let directAttempt = 0; directAttempt < 2 && !parsedPart; directAttempt++) {
+            try {
+              const remainingBudget = Math.max(1, Math.floor(st.budget - st.creditsSpent));
+              generated = await _llmText({
+                token, model: directModel, maxTokens: 7500, creditBudget: remainingBudget,
+                system: `Gere SOMENTE JSON estritamente valido no schema pedido. Sem introducao, sem markdown fence, sem comentarios, sem virgula sobrando e com todas as aspas/chaves fechadas. Entregue apenas a parte solicitada. SCHEMA: ${plan.schema}`,
+                user: `OBJETIVO:\n${item.desc}\n\nPARTE ${partIndex + 1}/${plan.parts.length}: ${Array.isArray(part) ? part.join(', ') : part}. Inclua exatamente estas entidades e detalhe cada uma.`,
+              });
+              totalCredits += generated.credits || 0;
+              st.creditsSpent += generated.credits || 0;
+              save(st, dir); // custo existe mesmo se a saida abaixo for invalida
+              const parsed = JSON.parse(normalizeMetaArtifact(expectedArtifact, generated.text));
+              if (!Array.isArray(parsed[plan.key])) throw new Error(`parte ${partIndex + 1} sem array ${plan.key}`);
+              parsedPart = parsed[plan.key];
+            } catch (e) {
+              lastDirectError = e;
+              generated = null;
+              if (directAttempt === 0) await new Promise(r => setTimeout(r, 1500));
+            }
+          }
+          if (!parsedPart) {
+            item.attempts = Math.max(0, (item.attempts || 1) - 1);
+            const transient = /abort|timeout|fetch|network/i.test(String(lastDirectError && lastDirectError.message || lastDirectError)) || Number(lastDirectError && lastDirectError.status) >= 500;
+            st.status = 'paused'; st.pause_reason = transient ? 'connection' : 'invalid_artifact';
+            st.budget = st.creditsSpent;
+            save(st, dir);
+            onAlert({ type: transient ? 'conn' : 'retry', text: `Geracao em lotes pausada na parte ${partIndex + 1}/${plan.parts.length}: ${String(lastDirectError && lastDirectError.message || lastDirectError).slice(0, 180)}. As partes ja validadas e os custos foram preservados.` });
+            return st;
+          }
+          item.directParts[partIndex] = parsedPart;
+          merged.push(...item.directParts[partIndex]);
+          save(st, dir);
+        }
+        const data = { [plan.key]: merged };
+        if (merged.length < plan.minimum) throw new Error(`${plan.key}: esperado minimo ${plan.minimum}, recebido ${merged.length}`);
+        if (plan.validate && !plan.validate(data)) throw new Error(`${plan.key}: validacao semantica falhou`);
+        finalText = JSON.stringify(data, null, 2);
+      } else {
+        let generated = null, lastDirectError = null;
+        for (let directAttempt = 0; directAttempt < 2 && !generated; directAttempt++) {
+          try {
+            const remainingBudget = Math.max(1, Math.floor(st.budget - st.creditsSpent));
+            generated = await _llmText({
+              token, model: directModel, maxTokens: /\.json$/i.test(expectedArtifact) ? 16000 : 14000,
+              creditBudget: remainingBudget,
+              system: 'Gere o CONTEUDO COMPLETO do artefato solicitado. Responda SOMENTE com o conteudo final, sem introducao, sem promessas e sem markdown fence. Se for JSON, devolva JSON estritamente valido. Nao use ferramentas.',
+              user: `OBJETIVO MAIOR:\n${st.goal.slice(0, 1800)}\n\nITEM ATUAL:\n${item.desc}\n\nCAMINHO/FORMATO OBRIGATORIO: ${expectedArtifact}`,
+            });
+          } catch (e) {
+            lastDirectError = e;
+            if (directAttempt === 0) await new Promise(r => setTimeout(r, 1500));
+          }
+        }
+        if (!generated) {
+          item.attempts = Math.max(0, (item.attempts || 1) - 1);
+          const transient = /abort|timeout|fetch|network/i.test(String(lastDirectError && lastDirectError.message || lastDirectError)) || Number(lastDirectError && lastDirectError.status) >= 500;
+          st.status = 'paused'; st.pause_reason = transient ? 'connection' : 'invalid_artifact';
+          st.budget = st.creditsSpent;
+          save(st, dir);
+          onAlert({ type: transient ? 'conn' : 'retry', text: `Geracao direta pausada: ${String(lastDirectError && lastDirectError.message || lastDirectError).slice(0, 180)}. O item continua pendente e sera retomado sem consumir tentativa.` });
+          return st;
+        }
+        totalCredits += generated.credits || 0;
+        finalText = generated.text;
+      }
+      if (!plan) st.creditsSpent += totalCredits;
+      const persisted = persistMetaArtifact(dir, expectedArtifact, finalText);
+      item.passes = true; item.blocked = false; item.directArtifact = false; delete item.directParts;
+      st.rounds.push({ item: item.desc, id: item.id, result: `Artefato validado e persistido pelo harness: ${persisted.target} (${persisted.bytes} bytes)`, credits: totalCredits, steps: plan ? plan.parts.length : 1, at: new Date().toISOString() });
+      save(st, dir);
+      onRoundDone({ marks: [item.id], credits: totalCredits, checklist: st.checklist, spent: st.creditsSpent });
+      continue;
+    }
+
     // Rodada com CONTEXTO ZERADO: o agente recebe só o essencial (objetivo resumido +
     // estado do checklist + resultado da rodada anterior) — nunca o histórico inteiro.
     const last = st.rounds[st.rounds.length - 1];
@@ -1295,7 +1515,10 @@ async function run(goal, opts = {}) {
     const minimalBlock = (lang === 'en'
       ? `\nMINIMAL-CODE RULES (economy — mandatory, think like a pragmatic lazy senior):\n1) Does this really need to exist? If not, don't build it.\n2) Does it already exist in this project? If yes, REUSE it — never rewrite a second version.\n3) Does the language/platform/browser already do it natively? If yes, use the native thing (e.g. <input type="date"> instead of a datepicker lib; fetch instead of axios; CSS instead of a JS animation lib).\n4) Only then write code — the MINIMUM that solves the item. NO extra library without real need, no gratuitous abstractions/wrappers, no speculative "future-proofing".\n`
       : `\nREGRAS DE CÓDIGO MÍNIMO (economia — obrigatórias; pense como um sênior pragmático e "preguiçoso"):\n1) Isso precisa mesmo existir? Se não precisa, NÃO construa.\n2) Já existe neste projeto? Se sim, REUSE — nunca escreva uma segunda versão.\n3) A linguagem/plataforma/navegador já faz isso nativo? Se sim, use o nativo (ex: <input type="date"> em vez de lib de datepicker; fetch em vez de axios; CSS em vez de lib JS de animação).\n4) Só então escreva código — o MÍNIMO que resolve o item. SEM biblioteca extra sem necessidade real, sem abstração/wrapper gratuito, sem "preparar pro futuro" especulativo.\n`);
-    const task = feasBlock + archBlock + designBlock + seedBlock + rulesBlock + minimalBlock + (lang === 'en'
+    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'
       ? `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` : '')
@@ -1324,13 +1547,34 @@ async function run(goal, opts = {}) {
     // ser o modelo forte (o pensador/olho, grok-4.5) — que sabe compor layout. Volta ao
     // barato assim que o olho aprovar (visual_fix some do checklist). Só nas rodadas visuais.
     let roundModel = useModel;
+    // If the automatic executor family was just proven unavailable, do not
+    // 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';
+    }
+    // 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
+    // reason to burn the item's second implementation attempt.
+    if (!model && Array.isArray(item.avoidModels) && item.avoidModels.length) {
+      const avoid = item.avoidModels.map(v => String(v).toLowerCase());
+      const candidates = ['glm-5.2', 'claude-haiku-4-5', 'deepseek-v4-pro'];
+      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)) {
       roundModel = useThinker || eye;
       onAlert({ type: 'escalate', text: `🎨 ts: o olho reprovou o layout ${st.visualFixes}x — passando a MÃO do fix visual pro ${roundModel} (mais forte em layout) até aprovar.` });
     }
     let out = null, connErr = null;
     for (let att = 0; att < 3 && !out; att++) {
-      try { out = await agent.run(task, { token, lang, yes, autoAll, model: roundModel, confineDir: dir, skipSessionStart: true, onStep: opts.onStep, onStepDone: opts.onStepDone, askApprove: opts.askApprove, onRemote: opts.onRemote, onThinking: opts.onThinking }); }
+      try {
+        // `agent.run` defaults to a defensive 40-credit cap. Complex meta rounds
+        // 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 });
+      }
       catch (e) {
         connErr = e;
         // teto de IA estourado → PAUSA limpa e resumível com CTA de upgrade (nunca segue em silêncio)
@@ -1339,13 +1583,63 @@ async function run(goal, opts = {}) {
           onAlert({ type: 'no_credits', text: `💳 ts: seu limite de IA acabou — a missão foi PAUSADA e salva. Assine um plano em terminalsmart.com.br/planos e retome com "ts meta".` });
           return st;
         }
-        if (e && (e.code === 'conn' || String(e.message).includes('fetch') || String(e.message).includes('network'))) { onAlert({ type: 'retry', text: `📡 ts: falha de conexão na rodada — tentando de novo (${att + 1}/3)…` }); await new Promise(r => setTimeout(r, 4000 * (att + 1))); }
-        else throw e; // erro não-transitório: sobe
+        const transientStatus = e && Number(e.status);
+        const transientProvider = e && ([408, 425, 429, 500, 502, 503, 504].includes(transientStatus) || (transientStatus >= 520 && transientStatus <= 527) || e.code === 'conn' || /fetch|network|temporariamente indispon[ií]vel/i.test(String(e.message)));
+        if (transientProvider) {
+          // Automatic Pro mode: once the selected executor exhausts its HTTP
+          // 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', 'claude-haiku-4-5'];
+          if (!model && att === 0 && !roundModel) {
+            st.autoExecutorDegradedUntil = Date.now() + (10 * 60 * 1000);
+            save(st, dir);
+          }
+          if (!model && att < fallbacks.length) roundModel = fallbacks[att];
+          onAlert({ type: 'retry', text: `📡 ts: provedor indisponível — tentando de novo (${att + 1}/3)${roundModel ? ` com ${roundModel}` : ''}…` });
+          await new Promise(r => setTimeout(r, 4000 * (att + 1)));
+        } else throw e; // erro não-transitório: sobe
       }
     }
     if (!out) { st.status = 'paused'; st.pause_reason = 'connection'; save(st, dir); onAlert({ type: 'conn', text: `📡 ts: sem conexão com o servidor após 3 tentativas. Missão PAUSADA e salva. Retome com "ts meta" quando a internet voltar.` }); return st; }
     st.creditsSpent += out.credits || 0;
 
+    // A preflight budget stop is financial state, not an implementation
+    // failure. Do not consume an attempt or block a valid checklist item.
+    if (out.guard && out.guard.kind === 'credits' && !(out.steps > 0)) {
+      item.attempts = Math.max(0, (item.attempts || 1) - 1);
+      st.status = 'paused';
+      st.pause_reason = 'budget';
+      // Signals night mode to open a fresh window without inventing spend.
+      st.budget = st.creditsSpent;
+      save(st, dir);
+      const need = out.guard.required ? ` (minimo estimado: ${out.guard.required}; disponivel: ${out.guard.available || 0})` : '';
+      onAlert({ type: 'budget', text: `A rodada precisava de mais contexto que o saldo desta janela${need}. Pausei sem marcar o item como falho; a proxima janela retoma limpo.` });
+      return st;
+    }
+
+    const expectedNow = String(expectedArtifact || '').replace(/\\/g, '/').toLowerCase();
+    const wroteExpectedNow = (out.actions || []).some(a => {
+      if (!['escrever_arquivo', 'editar_arquivo'].includes(a && a.name)) return false;
+      const target = String(a.target || '').replace(/\\/g, '/').toLowerCase();
+      return target === expectedNow || target.endsWith('/' + expectedNow);
+    });
+    // Reading/searching is not implementation progress. A model can consume
+    // 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')])];
+      item.directArtifact = true;
+      const failedModel = String(out.model || roundModel || 'glm-5.2');
+      item.directModel = /glm/i.test(failedModel) ? 'glm-5.2' : failedModel;
+      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'} respondeu, mas executou zero ferramentas. Nao marquei falha do item; a retomada usara outro executor.` });
+      return st;
+    }
+
     // ── BLOQUEIO HUMANO: o agente pediu uma ação externa que só o usuário faz ──
     // A missão PAUSA (gasto zero enquanto espera) e chama o usuário. Retoma com "ts meta".
     if (out.needHuman) {
@@ -1364,7 +1658,7 @@ async function run(goal, opts = {}) {
     let marks = [];
     const written = (out.actions || []).filter(a => a.name === 'escrever_arquivo' || a.name === 'editar_arquivo').map(a => String(a.target || ''));
     const _basename = (p) => String(p).replace(/\\/g, '/').split('/').pop().toLowerCase();
-    const _fileHints = (txt) => (String(txt).match(/[\w.\-]+\.(kt|java|xml|gradle|json|md|txt|kts|properties|pro|png|webp|py|js|ts|html|css|sh)\b/gi) || []).map(s => s.toLowerCase());
+    const _fileHints = (txt) => (String(txt).match(/[\w.\-]+\.(kt|java|xml|gradle|json|md|txt|kts|properties|pro|png|webp|py|gd|js|ts|html|css|sh)\b/gi) || []).map(s => s.toLowerCase());
     const itemFiles = _fileHints(item.desc);
     // Uma escrita/comando genérico não prova um item sem vínculo. Só há marcação automática
     // quando o próprio texto do item identifica o artefato e a rodada gravou esse artefato.
@@ -1372,7 +1666,13 @@ async function run(goal, opts = {}) {
     // para outros itens só porque algum arquivo/comando apareceu na mesma rodada.
     const wroteForItem = itemFiles.length > 0
       && itemFiles.some(f => written.some(w => _basename(w) === f));
-    if (wroteForItem) marks.push(item.id);
+    const _normPath = (p) => String(p || '').replace(/\\/g, '/').replace(/^\.\//, '').toLowerCase();
+    const expectedNorm = _normPath(expectedArtifact);
+    const wroteExpectedArtifact = !!expectedNorm && written.some(w => {
+      const n = _normPath(w);
+      return n === expectedNorm || n.endsWith('/' + expectedNorm);
+    });
+    if (wroteForItem || wroteExpectedArtifact) marks.push(item.id);
 
     // Item de correção de build: NÃO usa marcador — o PORTÃO DE BUILD é a única
     // autoridade (recompila de verdade). Marca provisório pra reabrir o gate; se o
@@ -1394,7 +1694,7 @@ async function run(goal, opts = {}) {
       const mk = await _llmJson({ token, system: MARK_SYS,
         user: `OBJETIVO:\n${st.goal.slice(0, 600)}\n\nCHECKLIST (contexto):\n${fmtChecklist(st.checklist)}\n\nITEM ALVO: (${item.id}) ${item.desc}\n\nRESULTADO DA RODADA:\n${String(out.text || '').slice(0, 2000)}${evid}` });
       st.creditsSpent += mk.credits || 0;
-      if (mk.json && mk.json.passou === true) marks.push(item.id);
+      if (mk.json && mk.json.passou === true && wroteExpectedArtifact) marks.push(item.id);
     } catch (_) {}
     marks = [...new Set(marks)];
     for (const it of st.checklist) if (marks.includes(it.id)) it.passes = true;
@@ -1456,4 +1756,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, 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, normalizeMetaArtifact, persistMetaArtifact, directArtifactPlan, verificationLabel, _checkCriteria, trailSummary };

package/lib/office-editors.js

@@ -92,27 +92,82 @@ function _replaceInXmlText(xml, search, replacement, replaceAll) {
   return { xml: output, count: selected.length };
 }
 
+function _replaceTableValueByLabel(xml, label, value, replaceAll = false) {
+  const rowRe = /<w:tr(?:\s[^>]*)?>[\s\S]*?<\/w:tr>/g;
+  const rows = []; let match;
+  while ((match = rowRe.exec(xml))) {
+    const raw = match[0];
+    const cells = [...raw.matchAll(/<w:tc(?:\s[^>]*)?>[\s\S]*?<\/w:tc>/g)].map(cell => ({
+      raw: cell[0], start: cell.index,
+      text: _decodeXml([...cell[0].matchAll(/<w:t(?:\s[^>]*)?>([\s\S]*?)<\/w:t>/g)].map(node => node[1]).join('')),
+    }));
+    const labelIndex = cells.findIndex(cell => cell.text.trim() === label.trim());
+    if (labelIndex >= 0 && cells[labelIndex + 1]) rows.push({ start: match.index, end: rowRe.lastIndex, raw, cells, labelIndex });
+  }
+  if (!rows.length) return { xml, count: 0 };
+  if (rows.length > 1 && !replaceAll) throw new Error(`Rótulo de tabela ambíguo: ${rows.length} ocorrências para ${label}.`);
+  const selected = replaceAll ? rows : rows.slice(0, 1);
+  let output = xml;
+  for (let index = selected.length - 1; index >= 0; index--) {
+    const row = selected[index];
+    const target = row.cells[row.labelIndex + 1];
+    const changed = _replaceInXmlText(target.raw, target.text, String(value ?? ''), false);
+    if (!changed.count) throw new Error(`Não foi possível alterar a célula ao lado de ${label}.`);
+    const rowXml = row.raw.slice(0, target.start) + changed.xml + row.raw.slice(target.start + target.raw.length);
+    output = output.slice(0, row.start) + rowXml + output.slice(row.end);
+  }
+  return { xml: output, count: selected.length };
+}
+
 async function editarDocumento(input = {}) {
   try {
     const original = _existing(input.caminho, '.docx');
-    const search = String(input.buscar || '');
-    const replacement = String(input.substituir ?? '');
-    if (!search) throw new Error('Informe buscar com o texto exato que será alterado.');
+    const rules = Array.isArray(input.substituicoes) && input.substituicoes.length
+      ? input.substituicoes.slice(0, 50)
+      : (input.buscar != null ? [{ buscar: input.buscar, substituir: input.substituir, todas: input.todas }] : []);
+    const tableRules = Array.isArray(input.alteracoes_tabela) ? input.alteracoes_tabela.slice(0, 50) : [];
+    if (!rules.length && !tableRules.length) throw new Error('Informe substituicoes ou alteracoes_tabela.');
+    if (rules.some(rule => !String(rule && rule.buscar || ''))) {
+      throw new Error('Informe buscar com o texto exato em cada substituição.');
+    }
     const destination = _destination(original, input, '.docx');
     const zip = await JSZip.loadAsync(fs.readFileSync(original));
     const xmlFiles = Object.keys(zip.files).filter(name => /^word\/(document|header\d+|footer\d+|footnotes|endnotes)\.xml$/.test(name));
-    let changes = 0;
-    for (const name of xmlFiles) {
-      const xml = await zip.file(name).async('string');
-      const result = _replaceInXmlText(xml, search, replacement, !!input.todas);
-      if (result.count) { zip.file(name, result.xml); changes += result.count; }
-      if (changes && !input.todas) break;
+    let changes = 0; const applied = [];
+    for (const rule of rules) {
+      const search = String(rule.buscar || '');
+      const replacement = String(rule.substituir ?? '');
+      const replaceAll = !!rule.todas;
+      let ruleChanges = 0;
+      for (const name of xmlFiles) {
+        const xml = await zip.file(name).async('string');
+        const result = _replaceInXmlText(xml, search, replacement, replaceAll);
+        if (result.count) { zip.file(name, result.xml); ruleChanges += result.count; }
+        if (ruleChanges && !replaceAll) break;
+      }
+      if (!ruleChanges) throw new Error(`Texto não encontrado no documento: ${search.slice(0, 100)}`);
+      changes += ruleChanges;
+      applied.push({ buscar: search.slice(0, 120), ocorrencias: ruleChanges });
+    }
+    for (const rule of tableRules) {
+      const label = String(rule && rule.rotulo || '');
+      if (!label) throw new Error('Informe rotulo em cada alteração de tabela.');
+      let ruleChanges = 0;
+      for (const name of xmlFiles) {
+        const xml = await zip.file(name).async('string');
+        const result = _replaceTableValueByLabel(xml, label, rule.valor, !!rule.todas);
+        if (result.count) { zip.file(name, result.xml); ruleChanges += result.count; }
+        if (ruleChanges && !rule.todas) break;
+      }
+      if (!ruleChanges) throw new Error(`Rótulo não encontrado em tabela: ${label.slice(0, 100)}`);
+      changes += ruleChanges;
+      applied.push({ rotulo: label.slice(0, 120), ocorrencias: ruleChanges });
     }
-    if (!changes) throw new Error('Texto não encontrado no documento. Leia o arquivo e copie um trecho exato.');
     const backup = destination === original ? _backup(original) : null;
     const buffer = await zip.generateAsync({ type: 'nodebuffer', compression: 'DEFLATE' });
     fs.writeFileSync(destination, buffer);
-    return { ok: true, caminho: destination, editou_original: destination === original, ocorrencias: changes, backup };
+    return { ok: true, caminho: destination, editou_original: destination === original,
+      ocorrencias: changes, substituicoes_aplicadas: applied, backup };
   } catch (error) { return { ok: false, erro: 'Falha ao editar DOCX: ' + error.message }; }
 }
 
@@ -128,7 +183,9 @@ async function editarPlanilha(input = {}) {
       const backup = destination === original ? _backup(original) : null;
       const { editXlsxCompat } = require('./xlsx-compat-editor');
       const result = await editXlsxCompat(original, destination, input);
-      return { ok: true, caminho: destination, editou_original: destination === original, celulas_alteradas: result.changes.length, alteracoes: result.changes.slice(0, 100), backup, engine: result.engine, compatibilidade: readError.message };
+      return { ok: true, caminho: destination, editou_original: destination === original, celulas_alteradas: result.changes.length,
+        alteracoes: result.changes.slice(0, 100), formulas_invalidadas: result.formulasInvalidated,
+        recalcular_ao_abrir: result.recalculateOnOpen, backup, engine: result.engine, compatibilidade: readError.message };
     }
     const changes = [];
     for (const update of (Array.isArray(input.alteracoes) ? input.alteracoes : []).slice(0, 500)) {
@@ -162,10 +219,27 @@ async function editarPlanilha(input = {}) {
       if (!replaced) throw new Error(`Texto não encontrado na planilha: ${search.slice(0, 80)}`);
     }
     if (!changes.length) throw new Error('Informe alteracoes ou substituicoes.');
+    // ExcelJS preserves cached formula results that may depend on edited input cells.
+    // Those caches become stale for previews/readers until Excel recalculates. Keep
+    // each formula, discard only its old result and request a full calculation on open.
+    let formulasInvalidated = 0;
+    for (const sheet of workbook.worksheets) {
+      sheet.eachRow({ includeEmpty: false }, row => row.eachCell({ includeEmpty: false }, cell => {
+        const value = cell.value;
+        if (!value || typeof value !== 'object' || (!value.formula && !value.sharedFormula)) return;
+        if (Object.prototype.hasOwnProperty.call(value, 'result')) {
+          const fresh = { ...value };
+          delete fresh.result;
+          cell.value = fresh;
+          formulasInvalidated++;
+        }
+      }));
+    }
+    workbook.calcProperties.fullCalcOnLoad = true;
     const backup = destination === original ? _backup(original) : null;
     await workbook.xlsx.writeFile(destination);
-    return { ok: true, caminho: destination, editou_original: destination === original, celulas_alteradas: changes.length, alteracoes: changes.slice(0, 100), backup, engine: 'exceljs' };
+    return { ok: true, caminho: destination, editou_original: destination === original, celulas_alteradas: changes.length, alteracoes: changes.slice(0, 100), formulas_invalidadas: formulasInvalidated, recalcular_ao_abrir: true, backup, engine: 'exceljs' };
   } catch (error) { return { ok: false, erro: 'Falha ao editar XLSX: ' + error.message }; }
 }
 
-module.exports = { editarDocumento, editarPlanilha, _replaceInXmlText };
+module.exports = { editarDocumento, editarPlanilha, _replaceInXmlText, _replaceTableValueByLabel };

package/lib/office-readers.js

@@ -103,4 +103,17 @@ async function lerApresentacao(input = {}) {
   }
 }
 
-module.exports = { lerDocumento, lerApresentacao };
+async function lerPlanilha(input = {}) {
+  try {
+    const p = path.resolve(String(input.caminho || ''));
+    if (!p.toLowerCase().endsWith('.xlsx')) throw new Error('O arquivo precisa terminar em .xlsx.');
+    if (!fs.existsSync(p) || !fs.statSync(p).isFile()) throw new Error('Arquivo não encontrado: ' + p);
+    if (fs.statSync(p).size > 80 * 1048576) throw new Error('Arquivo maior que 80 MB.');
+    const data = await require('./xlsx-compat-editor').readXlsxCompat(p, input);
+    return { ok: true, arquivo: p, tamanho_bytes: fs.statSync(p).size, ...data };
+  } catch (error) {
+    return { ok: false, erro: 'Falha ao ler XLSX: ' + error.message };
+  }
+}
+
+module.exports = { lerDocumento, lerPlanilha, lerApresentacao };