terminal-smart-cli 0.97.28 → 0.97.30

package/lib/core.js

@@ -136,10 +136,10 @@ const EVENT_TYPES = ['system', 'tool', 'assistant', 'result'];
 // raw (retrocompatível). Classe de erro alimenta o Recovery Engine e o ledger; `ok:false`
 // deve barrar a marcação de sucesso a montante (meta/orquestrador).
 const ERROR_CLASSES = ['permission_denied', 'not_found', 'port_in_use', 'missing_dep', 'package_lock',
-  'timeout', 'compile_error', 'test_failed', 'network', 'auth', 'git_conflict', 'invalid_schema',
-  'blocked', 'unknown'];
+  'timeout', 'compile_error', 'test_failed', 'network', 'auth', 'git_conflict', 'invalid_schema', 'resource_locked',
+  'invalid_command', 'invalid_workdir', 'blocked', 'unknown'];
 // classes transitórias → vale re-tentar (mesma abordagem); as demais exigem mudar de abordagem.
-const RETRYABLE_CLASSES = new Set(['network', 'timeout', 'package_lock', 'port_in_use']);
+const RETRYABLE_CLASSES = new Set(['network', 'timeout', 'package_lock', 'resource_locked', 'port_in_use']);
 
 function classifyError(msg) {
   const s = String(msg || '').toLowerCase();
@@ -147,8 +147,15 @@ function classifyError(msg) {
   if (/\bbloquead|\brecus|read-only|só-leitura|loop detectad|\bloop:|aprova(ção|r) neg|negou.*aprova/i.test(s)) return 'blocked';
   if (/eacces|permission denied|access is denied|operation not permitted|acesso negado|permissão negada/i.test(s)) return 'permission_denied';
   if (/could not get lock|dpkg was interrupted|resource temporarily unavailable.*lock|another (app|process) .*lock|unable to (acquire|lock)/i.test(s)) return 'package_lock';
+  if (/arquivo[_ ]ocupado|file[_ ]locked|resource[_ ]locked|another terminal smart process.*(?:editing|altering)|eexist.*\.lock/i.test(s)) return 'resource_locked';
   if (/eaddrinuse|address already in use|porta .*(ocupad|em uso)|already running/i.test(s)) return 'port_in_use';
-  if (/cannot find module|command not found|not recognized as|modulenotfounderror|no module named|no such command|is not installed|não (foi )?encontrad[oa] o comando/i.test(s)) return 'missing_dep';
+  // Binário/comando inválido pede dialeto/sintaxe correto; módulo ausente pode justificar instalar pacote.
+  if (/cannot find module|modulenotfounderror|no module named|is not installed/i.test(s)) return 'missing_dep';
+  // cmd.exe pode devolver texto OEM/UTF-8 corrompido ("não" vira "n�o").
+  // A classe precisa sobreviver a isso: o recovery correto depende dela e não
+  // pode cair em unknown só por causa do encoding do terminal.
+  if (/is not recognized as (an )?(internal|the name of)|command not found|no such command|n[^a-z\s]{0,3}o (?:foi )?encontrad[oa] o comando|n[^a-z\s]{0,3}o [^\r\n]{0,80}reconhecid[oa]|invalid switch|unrecognized option|syntax of the command is incorrect|unexpectedtoken|parsererror|terminator.*string/i.test(s)) return 'invalid_command';
+  if (/working directory|invalid directory|directory name is invalid|system cannot find the path specified|n[^a-z\s]{0,3}o pode encontrar o caminho especificado|enoent.*(?:spawn|chdir)|chdir.*enoent/i.test(s)) return 'invalid_workdir';
   if (/enoent|no such file|não encontrad|not found|arquivo inexistente|404/i.test(s)) return 'not_found';
   if (/etimedout|timed out|timeout|excedeu o tempo/i.test(s)) return 'timeout';
   if (/econnrefused|enotfound|getaddrinfo|network|connection refused|conexão recusada|conn|dns/i.test(s)) return 'network';

package/lib/eval.js

@@ -152,7 +152,7 @@ async function judge({ key, baseUrl, model, caseObj, evidence }) {
 // opts: { token, lang, model (executor), judgeModel, onCase({i,total,id,phase}) }
 // Roda os casos EM SÉRIE (sandbox isolado por caso; evita colisão e rate-limit).
 async function runSuite(suite, opts = {}) {
-  const { token, lang = 'pt', model = null, judgeModel = DEFAULT_JUDGE } = opts;
+  const { token, lang = 'pt', model = null, judgeModel = DEFAULT_JUDGE, maxIter, maxDurationMs, maxCredits } = opts;
   const onCase = opts.onCase || (() => {});
   // chave sk-hub (mesma do agente) — reusada pra chamar o juiz direto no gateway.
   const k = await keyring.resolve(token, { feature: 'cli_agent' });
@@ -188,7 +188,7 @@ async function runSuite(suite, opts = {}) {
         out = await agent.run(c.task, {
           token, lang, yes: true, model,
           cwd: sandbox, confineDir: sandbox, readOnly: c.readonly,
-          skipSessionStart: true,
+          skipSessionStart: true, maxIter, maxDurationMs, maxCredits,
         });
       } catch (e) {
         if (e && (e.code === 'no_credits' || e.status === 402)) throw e; // teto → aborta a suíte

package/lib/evolution-proposal.js

@@ -0,0 +1,47 @@
+'use strict';
+
+// Autoevolução é deliberadamente separada da execução: incidentes geram uma
+// PROPOSTA revisável, nunca um patch, comando ou deploy automático. Por decisão
+// de produto, somente o GPT SOL pode assinar esse diagnóstico de harness.
+const DIAGNOSTICIAN_MODEL = 'gpt-5.6-sol';
+const telemetry = require('./evolution-telemetry');
+
+function diagnosticianFor() { return DIAGNOSTICIAN_MODEL; }
+
+function buildRequest(events = [], context = {}) {
+  const cleanEvents = telemetry.buildEvents(events, [], context).map(event => ({
+    tool: event.tool, errorClass: event.errorClass, pattern: event.pattern,
+    stage: event.stage, fingerprint: event.fingerprint, retryable: event.retryable,
+    recovered: event.recovered,
+  }));
+  return {
+    model: DIAGNOSTICIAN_MODEL,
+    mode: 'proposal_only',
+    instruction: 'Analise somente os incidentes sanitizados. Proponha uma hipótese, testes de regressão e uma mudança mínima para revisão humana. Não gere comandos de produção, não aplique patches, não faça deploy e não trate a proposta como correção aprovada.',
+    incidents: cleanEvents.slice(0, 20),
+  };
+}
+
+function normalizeProposal(value, model) {
+  const v = value && typeof value === 'object' ? value : {};
+  const bySol = String(model || '') === DIAGNOSTICIAN_MODEL;
+  const list = (items, limit, width) => (Array.isArray(items) ? items : [])
+    .map(item => String(item || '').replace(/\s+/g, ' ').trim().slice(0, width))
+    .filter(Boolean).slice(0, limit);
+  return {
+    accepted: bySol,
+    model: bySol ? DIAGNOSTICIAN_MODEL : '',
+    mode: 'proposal_only',
+    requiresHumanReview: true,
+    autoApply: false,
+    title: String(v.title || '').replace(/\s+/g, ' ').trim().slice(0, 160),
+    diagnosis: String(v.diagnosis || v.summary || '').replace(/\s+/g, ' ').trim().slice(0, 1200),
+    evidence: list(v.evidence, 8, 360),
+    proposedChanges: list(v.proposedChanges || v.recommendations, 8, 500),
+    regressionTests: list(v.regressionTests || v.tests, 8, 360),
+  };
+}
+
+function canAutoApply() { return false; }
+
+module.exports = { DIAGNOSTICIAN_MODEL, diagnosticianFor, buildRequest, normalizeProposal, canAutoApply };

package/lib/file-lock.js

@@ -0,0 +1,42 @@
+// Lock cooperativo entre processos do Terminal Smart. `wx` cria o arquivo de
+// forma atômica: duas CLIs não conseguem adquirir o mesmo alvo ao mesmo tempo.
+'use strict';
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+
+const DIR = path.join(os.homedir(), '.ts', 'locks');
+const STALE_MS = 2 * 60 * 1000;
+const keyFor = (target) => crypto.createHash('sha256').update(path.resolve(target).toLowerCase()).digest('hex').slice(0, 24);
+const pathFor = (target) => path.join(DIR, keyFor(target) + '.lock');
+
+function acquire(target, { staleMs = STALE_MS } = {}) {
+  const lockPath = pathFor(target);
+  try { fs.mkdirSync(DIR, { recursive: true }); } catch (_) { return null; }
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const fd = fs.openSync(lockPath, 'wx', 0o600);
+      try { fs.writeFileSync(fd, JSON.stringify({ pid: process.pid, target: path.resolve(target), createdAt: new Date().toISOString() })); } finally { fs.closeSync(fd); }
+      let released = false;
+      return {
+        release() {
+          if (released) return;
+          released = true;
+          try { fs.unlinkSync(lockPath); } catch (_) {}
+        },
+        lockPath,
+      };
+    } catch (err) {
+      if (!err || err.code !== 'EEXIST') return null;
+      try {
+        const age = Date.now() - fs.statSync(lockPath).mtimeMs;
+        if (age > staleMs) { fs.unlinkSync(lockPath); continue; }
+      } catch (_) { continue; }
+      return null;
+    }
+  }
+  return null;
+}
+
+module.exports = { DIR, STALE_MS, keyFor, pathFor, acquire };

package/lib/gateways.js

@@ -0,0 +1,69 @@
+// Gateways operacionais: aliases OpenSSH com comando forçado (não são shells
+// remotos normais). A configuração guarda apenas alias e allowlist; chaves e
+// credenciais continuam exclusivamente no OpenSSH do sistema.
+const config = require('./config');
+
+const OPS = Object.freeze(['status', 'logs', 'deploy']);
+
+function normalized(value) {
+  return String(value || '').normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase().trim();
+}
+
+function safeName(value) {
+  const raw = String(value || '').trim();
+  if (!raw || /[\\/]/.test(raw) || raw === '.' || raw === '..' || raw.includes('..')) return null;
+  const name = normalized(raw).replace(/[^a-z0-9_-]+/g, '-').replace(/^-+|-+$/g, '');
+  return /^[a-z0-9][a-z0-9_-]{0,63}$/.test(name) ? name : null;
+}
+
+function safeAlias(value) {
+  const alias = String(value || '').trim();
+  return /^[A-Za-z0-9_.-]{1,128}$/.test(alias) ? alias : null;
+}
+
+function normalizeOps(value) {
+  const values = Array.isArray(value) ? value : String(value || '').split(',');
+  const ops = [...new Set(values.map(x => String(x).trim().toLowerCase()).filter(x => OPS.includes(x)))];
+  return ops.length ? ops : ['status'];
+}
+
+function list() {
+  const raw = config.load().gateways || {};
+  return Object.entries(raw).map(([name, item]) => {
+    const alias = safeAlias(item && item.sshAlias);
+    if (!alias) return null;
+    return { name, label: String(item.label || name), sshAlias: alias, operations: normalizeOps(item.operations) };
+  }).filter(Boolean);
+}
+
+function save(name, input = {}) {
+  const id = safeName(name);
+  const alias = safeAlias(input.sshAlias);
+  if (!id) throw new Error('Nome do gateway inválido. Use letras, números, hífen ou sublinhado.');
+  if (!alias) throw new Error('Alias OpenSSH inválido. Use apenas letras, números, ponto, hífen ou sublinhado.');
+  const cfg = config.load();
+  const gateways = { ...(cfg.gateways || {}) };
+  gateways[id] = { label: String(input.label || id).trim().slice(0, 80), sshAlias: alias, operations: normalizeOps(input.operations) };
+  config.save({ gateways });
+  return { name: id, ...gateways[id] };
+}
+
+function remove(name) {
+  const id = safeName(name);
+  const cfg = config.load();
+  const gateways = { ...(cfg.gateways || {}) };
+  if (!id || !gateways[id]) return false;
+  delete gateways[id];
+  config.save({ gateways });
+  return true;
+}
+
+function findInText(text, entries = list()) {
+  const normalizedText = normalized(text);
+  return entries.find(entry => {
+    const terms = [entry.name, entry.label, entry.sshAlias].map(normalized).filter(Boolean);
+    return terms.some(term => normalizedText.includes(term));
+  }) || null;
+}
+
+module.exports = { OPS, normalized, safeName, safeAlias, normalizeOps, list, save, remove, findInText };

package/lib/intelligence-core.js

@@ -53,11 +53,6 @@ const MODEL_CATALOG = Object.freeze({
     provider: 'moonshot', contextWindow: 262144, price: { input: 0.75, output: 3.50, cachedInput: 0.15 },
     capabilities: ['tools', 'code', 'vision', 'long-context'], toolReliability: 0.86, quality: 0.84,
   },
-  'kimi-k3': {
-    upstreamId: 'moonshotai/kimi-k3',
-    provider: 'moonshot', contextWindow: 262144, price: { input: 3.00, output: 15.00, cachedInput: 0.30 },
-    capabilities: ['tools', 'code', 'planning', 'long-context'], toolReliability: 0.88, quality: 0.91,
-  },
   'glm-4.6': {
     upstreamId: 'z-ai/glm-4.6',
     provider: 'zai', contextWindow: 204800, price: { input: 0.50, output: 2.00, cachedInput: 0.10 },
@@ -109,7 +104,9 @@ const MODEL_CATALOG = Object.freeze({
     capabilities: ['tools', 'code', 'planning', 'review'], toolReliability: 0.96, quality: 0.95,
   },
   'claude-haiku-4-5': {
-    upstreamId: 'anthropic/claude-haiku-4.5',
+    // ID canônico exposto pelo OpenRouter. O alias interno permanece estável
+    // para planos e histórico, mas o gateway precisa receber este identificador.
+    upstreamId: 'anthropic/claude-4.5-haiku-20251001',
     provider: 'anthropic', contextWindow: 200000, price: { input: 1.00, output: 5.00, cachedInput: 0.10 },
     capabilities: ['tools', 'code', 'planning', 'execution', 'review', 'vision'], toolReliability: 0.94, quality: 0.88,
   },
@@ -176,7 +173,6 @@ const MODEL_CATALOG = Object.freeze({
 const MODEL_ALIASES = Object.freeze({
   deepseek: 'deepseek-v4-flash',
   'deepseek-v4': 'deepseek-v4-flash',
-  kimi: 'kimi-k2.7-code-highspeed',
   glm: 'glm-4.6',
   mimo: 'mimo-v2.5',
   'gemini-lite': 'gemini-2.5-flash-lite',
@@ -193,35 +189,35 @@ const AGENT_ROLES = Object.freeze({
   }),
   planner: Object.freeze({
     prompt: 'Decomponha o objetivo em etapas executáveis, dependências, riscos, critérios de aceite e provas. Não execute a tarefa.',
-    models: Object.freeze({ free: ['deepseek-v4-flash'], basic: ['deepseek-v4-pro', 'deepseek-v4-flash'], pro: ['gpt-5.6-luna', 'deepseek-v4-pro', 'glm-5.2'] }),
+    models: Object.freeze({ free: ['deepseek-v4-flash'], basic: ['gpt-5.6-luna', 'deepseek-v4-pro'], pro: ['gpt-5.6-luna', 'deepseek-v4-pro', 'glm-5.2'] }),
   }),
   executor: Object.freeze({
     prompt: 'Execute somente a etapa recebida com as ferramentas autorizadas. Não declare sucesso sem resultado verificável.',
-    models: Object.freeze({ free: ['deepseek-v4-flash'], basic: ['deepseek-v4-flash', 'deepseek-v4-pro'], pro: ['deepseek-v4-flash', 'deepseek-v4-pro', 'glm-5.2', 'claude-haiku-4-5'] }),
+    models: Object.freeze({ free: ['deepseek-v4-flash'], basic: ['deepseek-v4-pro', 'gpt-5.6-luna'], pro: ['deepseek-v4-pro', 'gpt-5.6-luna'] }),
   }),
   inspector: Object.freeze({
     prompt: 'Inspecione em modo somente leitura e compare evidências com os critérios de aceite. Não altere nada e não elogie por cortesia.',
-    models: Object.freeze({ free: ['gemini-2.5-flash-lite'], basic: ['gemini-2.5-flash', 'gpt-4o-mini'], pro: ['gpt-5.6-luna', 'claude-haiku-4-5', 'gemini-2.5-flash'] }),
+    models: Object.freeze({ free: ['gemini-2.5-flash-lite'], basic: ['gpt-5.6-luna', 'gemini-2.5-flash'], pro: ['gpt-5.6-luna', 'gemini-2.5-flash'] }),
   }),
   corrector: Object.freeze({
     prompt: 'Corrija apenas falhas confirmadas pelo inspetor, preserve o que funciona e repita as provas afetadas. Não amplie o escopo.',
-    models: Object.freeze({ free: ['deepseek-v4-flash'], basic: ['deepseek-v4-pro', 'deepseek-v4-flash'], pro: ['deepseek-v4-pro', 'claude-haiku-4-5', 'glm-5.2'] }),
+    models: Object.freeze({ free: ['deepseek-v4-flash'], basic: ['deepseek-v4-pro', 'gpt-5.6-luna'], pro: ['deepseek-v4-pro', 'gpt-5.6-luna', 'glm-5.2'] }),
   }),
   vision: Object.freeze({
     prompt: 'Extraia fatos observáveis da imagem e separe leitura, inferência e incerteza. Não invente texto ilegível.',
-    models: Object.freeze({ free: ['smart'], basic: ['gemini-2.5-flash'], pro: ['gpt-5.6-luna', 'gemini-2.5-flash', 'claude-haiku-4-5'] }),
+    models: Object.freeze({ free: ['gemini-2.5-flash'], basic: ['mimo-v2.5', 'gemini-2.5-flash'], pro: ['mimo-v2.5', 'gemini-2.5-flash', 'gpt-5.6-luna'] }),
   }),
   document: Object.freeze({
     prompt: 'Produza conteúdo estruturado e use o motor nativo do formato solicitado. Preserve editabilidade e valide o arquivo gerado.',
-    models: Object.freeze({ free: ['deepseek-v4-flash'], basic: ['deepseek-v4-pro', 'deepseek-v4-flash'], pro: ['gpt-5.6-luna', 'deepseek-v4-pro', 'claude-haiku-4-5'] }),
+    models: Object.freeze({ free: ['deepseek-v4-flash'], basic: ['deepseek-v4-pro', 'mimo-v2.5', 'gemini-2.5-flash'], pro: ['mimo-v2.5', 'deepseek-v4-pro', 'gpt-5.6-luna'] }),
   }),
   site_builder: Object.freeze({
     prompt: 'Crie ou edite o site completo, responsivo e acessível. Preserve o existente quando editar e valide a URL publicada.',
-    models: Object.freeze({ free: ['deepseek-v4-flash'], basic: ['deepseek-v4-flash', 'deepseek-v4-pro'], pro: ['deepseek-v4-pro', 'deepseek-v4-flash', 'claude-haiku-4-5'] }),
+    models: Object.freeze({ free: ['deepseek-v4-flash'], basic: ['deepseek-v4-pro', 'gpt-5.6-luna'], pro: ['deepseek-v4-pro', 'gpt-5.6-luna'] }),
   }),
   cloud_box: Object.freeze({
     prompt: 'Opere a box com mudanças mínimas, registre comandos e valide serviço, porta e URL. Nunca exponha segredos.',
-    models: Object.freeze({ free: ['deepseek-v4-flash'], basic: ['deepseek-v4-flash'], pro: ['deepseek-v4-flash', 'deepseek-v4-pro', 'claude-haiku-4-5'] }),
+    models: Object.freeze({ free: ['deepseek-v4-flash'], basic: ['deepseek-v4-pro'], pro: ['deepseek-v4-pro', 'gpt-5.6-luna'] }),
   }),
 });
 
@@ -338,6 +334,74 @@ function _cleanText(value, max) {
     .slice(0, max);
 }
 
+// Dados que cruzam a fronteira da máquina (handoff, painel e telemetria) não
+// precisam de e-mails, URLs, caminhos locais ou comandos literais. Mantemos o
+// sinal operacional, mas removemos detalhes que pertencem somente à sessão local.
+function cleanOperationalText(value, max) {
+  return _cleanText(value, max || 300)
+    .replace(/\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi, '<email>')
+    .replace(/https?:\/\/[^\s"']+/gi, '<url>')
+    .replace(/\b(?:\d{1,3}\.){3}\d{1,3}\b/g, '<ip>')
+    .replace(/[A-Za-z]:\\[^\s"']+/g, '<path>')
+    .replace(/\/(?:home|root|opt|var|tmp|Users|mnt)\/[^\s"']+/g, '<path>')
+    .replace(/\b(?:nvapi-|AIza)[A-Za-z0-9._-]{12,}\b/gi, '<secret>')
+    .replace(/\b[0-9a-f]{32,}\b/gi, '<id>')
+    .replace(/\s+/g, ' ').trim().slice(0, max || 300);
+}
+
+function _safeToolName(value) {
+  const name = String(value || 'unknown').replace(/[^a-z0-9_-]/gi, '_').slice(0, 80);
+  return name || 'unknown';
+}
+
+function _safeModelId(value) {
+  const normalized = normalizeModelId(value);
+  return MODEL_CATALOG[normalized] || normalized === 'smart' ? normalized : _safeToolName(value);
+}
+
+// Contrato compacto para painéis e comparação de execuções. É deliberadamente
+// agregado: o painel sabe se a missão funcionou e onde falhou, sem receber o
+// pedido do usuário, conteúdo de e-mail, arquivo, comando ou diretório.
+function buildOperationalSummary(input) {
+  const x = input || {};
+  const usage = x.tokens || x.usage || {};
+  const failures = new Map();
+  for (const item of (Array.isArray(x.toolErrors) ? x.toolErrors : []).slice(-50)) {
+    const tool = _safeToolName(item && item.tool);
+    const errorClass = _safeToolName(item && (item.errorClass || item.class || 'unknown'));
+    const key = tool + ':' + errorClass;
+    const row = failures.get(key) || { tool, errorClass, count: 0, retryable: false };
+    row.count++;
+    row.retryable = row.retryable || item.retryable === true;
+    failures.set(key, row);
+  }
+  const actions = {};
+  for (const action of (Array.isArray(x.actions) ? x.actions : []).slice(0, 200)) {
+    const name = _safeToolName(action && action.name);
+    actions[name] = (actions[name] || 0) + 1;
+  }
+  const verification = x.verification || {};
+  return {
+    version: 1,
+    surface: _safeToolName(x.surface || 'cli'),
+    model: _safeModelId(x.model || 'smart'),
+    status: x.completion && x.completion.ok ? 'completed' : (x.guard ? 'stopped_by_guard' : 'blocked'),
+    completionReason: _safeToolName(x.completion && x.completion.reason || 'unknown'),
+    steps: Math.max(0, Number(x.steps) || 0),
+    durationMs: Math.max(0, Number(x.durationMs) || 0),
+    credits: Math.max(0, Number(x.credits) || 0),
+    tokens: {
+      input: Math.max(0, Number(usage.inTok || usage.input_tokens) || 0),
+      output: Math.max(0, Number(usage.outTok || usage.output_tokens) || 0),
+      cached: Math.max(0, Number(usage.cachedTok || usage.cacheTok || usage.cached_tokens) || 0),
+    },
+    actions,
+    failures: [...failures.values()].sort((a, b) => b.count - a.count || a.tool.localeCompare(b.tool)).slice(0, 20),
+    verification: { total: Math.max(0, Number(verification.total) || 0), passed: Math.max(0, Number(verification.passed) || 0), allOk: verification.allOk === true },
+    cache: Object.assign({ hits: 0, misses: 0, entries: 0 }, x.missionCache || {}),
+  };
+}
+
 function createMemoryRecord(input) {
   const x = input || {};
   const type = MEMORY_TYPES.includes(x.type) ? x.type : 'episodic';
@@ -385,16 +449,16 @@ function createHandoff(input) {
   return {
     version: 1,
     workstreamId: _cleanText(x.workstreamId || 'default', 160),
-    goal: _cleanText(x.goal, 2000),
+    goal: cleanOperationalText(x.goal, 600),
     status: ['running', 'blocked', 'done', 'paused'].includes(x.status) ? x.status : 'running',
-    decisions: (x.decisions || []).slice(0, 20).map(v => _cleanText(v, 800)),
+    decisions: (x.decisions || []).slice(0, 20).map(v => cleanOperationalText(v, 400)),
     changedFiles: (x.changedFiles || []).slice(0, 100).map(v => typeof v === 'string'
-      ? { path: _cleanText(v, 500), hash: '' }
-      : { path: _cleanText(v.path, 500), hash: _cleanText(v.hash, 128) }),
-    evidence: (x.evidence || []).slice(0, 30).map(v => _cleanText(v, 1000)),
-    failedApproaches: (x.failedApproaches || []).slice(0, 20).map(v => _cleanText(v, 1000)),
-    openQuestions: (x.openQuestions || []).slice(0, 20).map(v => _cleanText(v, 800)),
-    nextActions: (x.nextActions || []).slice(0, 20).map(v => _cleanText(v, 800)),
+      ? { path: cleanOperationalText(v, 180), hash: '' }
+      : { path: cleanOperationalText(v.path, 180), hash: _cleanText(v.hash, 128) }),
+    evidence: (x.evidence || []).slice(0, 30).map(v => cleanOperationalText(v, 300)),
+    failedApproaches: (x.failedApproaches || []).slice(0, 20).map(v => cleanOperationalText(v, 300)),
+    openQuestions: (x.openQuestions || []).slice(0, 20).map(v => cleanOperationalText(v, 300)),
+    nextActions: (x.nextActions || []).slice(0, 20).map(v => cleanOperationalText(v, 300)),
     budget: Object.assign({ currency: 'USD', spent: 0, remaining: null }, x.budget || {}),
     createdAt: x.createdAt || new Date().toISOString(),
   };
@@ -411,8 +475,14 @@ function agentRoleContract(role, plan, options) {
   const id = Object.prototype.hasOwnProperty.call(AGENT_ROLES, role) ? role : 'executor';
   const planId = normalizeAgentPlan(plan);
   const spec = AGENT_ROLES[id];
-  const requested = spec.models[planId] || spec.models.free;
-  const allowedRaw = options && Array.isArray(options.allowedModels) ? options.allowedModels : null;
+  // Tarefas complexas nunca usam modelos Flash nos papeis que decidem ou
+  // alteram o projeto. Isto vale inclusive no Free: o limite desse plano e de
+  // tentativas/orcamento, nao uma degradacao silenciosa da qualidade do papel.
+  const complexCore = options && options.complex === true && ['planner', 'executor', 'corrector'].includes(id)
+    ? (id === 'planner' ? ['gpt-5.6-luna', 'deepseek-v4-pro'] : ['deepseek-v4-pro', 'gpt-5.6-luna'])
+    : null;
+  const requested = complexCore || spec.models[planId] || spec.models.free;
+  const allowedRaw = complexCore && planId === 'free' ? null : (options && Array.isArray(options.allowedModels) ? options.allowedModels : null);
   const allowAll = !allowedRaw || allowedRaw.includes('*');
   const allowed = allowAll ? null : new Set(allowedRaw.map(normalizeModelId));
   const candidates = requested.map(normalizeModelId).filter(model => model === 'smart' || MODEL_CATALOG[model])
@@ -436,23 +506,26 @@ function routeModel(task, reliability) {
   if (t.kind === 'vision') required.add('vision');
   const candidates = (t.candidates || Object.keys(MODEL_CATALOG)).map(normalizeModelId).filter(id => MODEL_CATALOG[id] && id !== 'smart');
   const rel = reliability || {};
+  const plan = String(t.plan || '').toLowerCase();
+  const isPaid = plan && plan !== 'free' && plan !== 'gratuito';
+
   const scored = candidates.map(id => {
     const m = MODEL_CATALOG[id];
     const missing = [...required].filter(c => !m.capabilities.includes(c)).length;
     const observed = rel[id] && Number.isFinite(rel[id].successRate) ? rel[id].successRate : m.toolReliability;
     const price = m.price.input + m.price.output;
-    const qualityWeight = t.risk === 'high' ? 0.55 : 0.35;
-    const costWeight = t.risk === 'high' ? 0.10 : 0.30;
+    const qualityWeight = isPaid ? 0.75 : (t.risk === 'high' ? 0.55 : 0.35);
+    const costWeight = isPaid ? 0.05 : (t.risk === 'high' ? 0.10 : 0.30);
     const score = (observed * 0.35) + (m.quality * qualityWeight) + ((1 / (1 + price)) * costWeight) - (missing * 2);
     return { id, score: +score.toFixed(6), missing };
   }).sort((a, b) => b.score - a.score);
-  return { model: scored[0] ? scored[0].id : 'deepseek-v4-flash', ranked: scored };
+  return { model: scored[0] ? scored[0].id : (isPaid ? 'deepseek-v4-pro' : 'deepseek-v4-flash'), ranked: scored };
 }
 
 module.exports = {
   INTELLIGENCE_CONTRACT, PRICE_REVISION, MODEL_CATALOG, MODEL_ALIASES, DEFAULT_PRICE,
   MEMORY_TYPES, MEMORY_TRUST, CONTEXT_SOURCES, AGENT_ROLES,
   normalizeModelId, modelInfo, legacyPriceMap, normalizeUsage, estimateCostUsd, catalogFreshness,
-  createContextLedger, createMemoryRecord, scoreMemoryRecord, createHandoff,
+  createContextLedger, createMemoryRecord, scoreMemoryRecord, createHandoff, cleanOperationalText, buildOperationalSummary,
   normalizeAgentPlan, agentRoleContract, routeModel,
 };

package/lib/meta.js

@@ -973,6 +973,10 @@ async function _llmText({ token, model, system, user, maxTokens = 1200, creditBu
 // "pensador" numa análise FOCADA (sem ferramentas, sem loop) com o erro + o código
 // dos arquivos citados, e devolve um diagnóstico + fix EXATO pro executor aplicar.
 async function escalate(buildErr, projDir, thinker, token) {
+  // Diagnóstico de falha repetida não segue a escolha genérica de "pensador":
+  // somente o GPT SOL pode propor causa/fix. O executor continua sendo quem
+  // aplica a alteração e os gates continuam exigindo prova posterior.
+  const diagnostician = require('./evolution-proposal').diagnosticianFor(thinker);
   // ── DIAGNÓSTICO ANTES DE ESCALAR (v0.52): em vez de só chutar pelo TEXTO do erro, o TS
   // INVESTIGA o sistema real com sondas só-leitura (hipótese→sonda→verificação adversarial)
   // e entrega a CAUSA RAIZ ao pensador. Só na escalação (já estamos travados) → custo contido.
@@ -980,7 +984,7 @@ async function escalate(buildErr, projDir, thinker, token) {
   let diagBlock = '', diagCred = 0;
   if (process.env.TS_META_DIAGNOSE !== '0') {
     try {
-      const dr = await require('./diagnose').diagnose(String(buildErr).slice(0, 1400), { token, cwd: projDir, model: thinker, maxRounds: Number(process.env.TS_META_DIAGNOSE_ROUNDS) || 4 });
+      const dr = await require('./diagnose').diagnose(String(buildErr).slice(0, 1400), { token, cwd: projDir, model: diagnostician, maxRounds: Number(process.env.TS_META_DIAGNOSE_ROUNDS) || 4 });
       diagCred = dr.credits || 0;
       if (dr.status === 'solved' && dr.rootCause) diagBlock = `\n\nDIAGNÓSTICO (o TS investigou o sistema com sondas só-leitura${dr.verified ? ', causa VERIFICADA' : ''}):\nCAUSA RAIZ: ${dr.rootCause}\nFIX apontado: ${dr.fix || '—'}\n(Use isto como base — é evidência do sistema real, não palpite.)`;
     } catch (_) {}
@@ -991,7 +995,7 @@ async function escalate(buildErr, projDir, thinker, token) {
   const sys = 'Você é um engenheiro sênior de DEBUG. Recebe o ERRO REAL de um build, um DIAGNÓSTICO do sistema (se houver) e o código dos arquivos citados. '
     + 'Se houver DIAGNÓSTICO, PARTA DELE (é evidência do sistema real). Diga a CAUSA-RAIZ em 1-2 linhas e depois o FIX EXATO e mínimo: em QUAL arquivo, QUAL linha/trecho, e o QUE trocar (mostre o antes→depois curto). '
     + 'NÃO reescreva o app inteiro, só o necessário pra compilar. Seja preciso e direto.';
-  const r = await _llmText({ token, model: thinker, system: sys, user: `ERRO DO BUILD:\n${String(buildErr).slice(0, 2500)}${diagBlock}\n\nCÓDIGO RELEVANTE:${ctx.slice(0, 6000)}`, maxTokens: 1200 });
+  const r = await _llmText({ token, model: diagnostician, system: sys, user: `ERRO DO BUILD:\n${String(buildErr).slice(0, 2500)}${diagBlock}\n\nCÓDIGO RELEVANTE:${ctx.slice(0, 6000)}`, maxTokens: 1200 });
   return { hint: (diagBlock ? diagBlock.trim() + '\n\n' : '') + r.text, credits: (r.credits || 0) + diagCred };
 }
 
@@ -1167,6 +1171,16 @@ async function _checkCriteria(st, dir) {
   }
 }
 
+// Fast fail-closed gate used after every implementation round. File/content
+// criteria may belong to later checklist items, but command criteria (tests,
+// lint, typecheck) describe repository health and must stay green throughout.
+async function _checkRoundCommandCriteria(st, dir) {
+  const criteria = (st.criteria || []).filter(c => c && c.type === 'command');
+  if (!criteria.length) return { allOk: true, passed: 0, total: 0, results: [] };
+  try { return await require('./verify').runAll(criteria, { cwd: dir }); }
+  catch (e) { return { allOk: false, passed: 0, total: criteria.length, results: [], error: String(e && e.message || e) }; }
+}
+
 async function run(goal, opts = {}) {
   const { token, lang = 'pt', yes = false, autoAll = false, budget = 400, maxRounds = 20, dir = process.cwd(), model = null, thinker = null, maxMinutes = 0, designer = null, design = 'auto', runGate = true, eye = null, visualLadder = true, prove = false } = opts;
   const onChecklist = opts.onChecklist || (() => {});
@@ -1693,6 +1707,18 @@ async function run(goal, opts = {}) {
       return st;
     }
 
+    const roundCommandProof = await _checkRoundCommandCriteria(st, dir);
+    if (!roundCommandProof.allOk) {
+      item.attempts = Math.max(0, (item.attempts || 1) - 1);
+      st.status = 'paused'; st.pause_reason = 'verification_failed';
+      st.rounds.push({ item: item.desc, id: item.id,
+        result: `Prova determinística falhou: ${roundCommandProof.passed}/${roundCommandProof.total} comandos passaram. O item permanece aberto para correção.`,
+        credits: out.credits || 0, steps: out.steps || 0, at: new Date().toISOString() });
+      save(st, dir);
+      onAlert({ type: 'verification', text: `Os testes/comandos obrigatórios falharam (${roundCommandProof.passed}/${roundCommandProof.total}). Não marquei o item como concluído; a próxima janela deve corrigir a regressão.` });
+      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) {

package/lib/owner-audit.js

@@ -0,0 +1,112 @@
+'use strict';
+
+const crypto = require('crypto');
+const core = require('./core');
+
+/**
+ * Módulo de Auditoria Privada do Dono para sessões de teste e homologação.
+ * Opt-in, temporário, estritamente sanitizado.
+ */
+
+function sanitizeAuditString(value, allowContent = false) {
+  if (typeof value !== 'string') return '';
+  let str = core.redactSecrets ? core.redactSecrets(value) : value;
+
+  // Remoção incondicional de segredos e tokens sensíveis
+  str = str
+    .replace(/\b(?:Bearer\s+)[A-Za-z0-9._~+/-]+=*/gi, 'Bearer [REDACTED]')
+    .replace(/\b(?:ya29\.[A-Za-z0-9_-]+)/gi, '[GOOGLE_OAUTH_TOKEN]')
+    .replace(/\b(?:ghp_|gho_|github_pat_)[A-Za-z0-9_]{16,}/gi, '[GITHUB_TOKEN]')
+    .replace(/\b(?:nvapi-|AIza|sk-|xox[baprs]-)[A-Za-z0-9._-]{10,}/gi, '[API_KEY]')
+    .replace(/-----BEGIN[ A-Z0-9_-]*PRIVATE KEY-----[\s\S]*?-----END[ A-Z0-9_-]*PRIVATE KEY-----/gi, '[PRIVATE_KEY]')
+    .replace(/(?:password|passwd|secret|token|authorization|auth_token)\s*[:=]\s*["']?[^"',\s]+["']?/gi, '$1=[REDACTED]');
+
+  if (!allowContent) {
+    // Mascara URLs completas com parâmetros e e-mails se não for incidente com autorização explícita
+    str = str
+      .replace(/\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi, '<email>')
+      .replace(/https?:\/\/[^\s"']+/gi, '<url>');
+  }
+
+  return str.replace(/[\u0000-\u001f\u007f]/g, ' ').replace(/\s+/g, ' ').trim().slice(0, 1000);
+}
+
+function isOwnerAuditActive(options = {}, env = process.env) {
+  if (options.ownerAudit === true) return true;
+  const envVal = String(env.TS_OWNER_AUDIT || '').toLowerCase();
+  return envVal === '1' || envVal === 'true' || envVal === 'on';
+}
+
+class OwnerAuditSession {
+  constructor(options = {}) {
+    this.sessionId = options.sessionId || crypto.randomBytes(8).toString('hex');
+    this.startedAt = Date.now();
+    this.appVersion = options.appVersion || '0.97.29';
+    this.surface = options.surface || 'cli';
+    this.accountType = 'owner';
+    this.explicitContentAuthorization = options.explicitContentAuthorization === true;
+    this.records = [];
+  }
+
+  recordStep({ stage, tool, durationMs, result, recovered, costTokens, costUsd, meta = {} }) {
+    const sanitizedMeta = {};
+    if (meta && typeof meta === 'object') {
+      for (const [k, v] of Object.entries(meta)) {
+        if (typeof v === 'string') {
+          sanitizedMeta[k] = sanitizeAuditString(v, this.explicitContentAuthorization);
+        } else if (typeof v === 'number' || typeof v === 'boolean') {
+          sanitizedMeta[k] = v;
+        }
+      }
+    }
+
+    const entry = {
+      id: crypto.randomBytes(6).toString('hex'),
+      timestamp: Date.now(),
+      stage: String(stage || 'step').slice(0, 50),
+      tool: String(tool || 'system').slice(0, 80),
+      durationMs: Number(durationMs) || 0,
+      result: result === 'success' || result === true ? 'success' : (result === 'blocked' ? 'blocked' : 'failed'),
+      recovered: recovered === true,
+      version: this.appVersion,
+      costTokens: Number(costTokens) || 0,
+      costUsd: Number(costUsd) || 0,
+      meta: sanitizedMeta
+    };
+
+    this.records.push(entry);
+    if (this.records.length > 500) {
+      this.records.shift();
+    }
+    return entry;
+  }
+
+  getSummary() {
+    const totalDuration = this.records.reduce((sum, r) => sum + r.durationMs, 0);
+    const totalCostTokens = this.records.reduce((sum, r) => sum + r.costTokens, 0);
+    const totalCostUsd = this.records.reduce((sum, r) => sum + r.costUsd, 0);
+    const successCount = this.records.filter(r => r.result === 'success').length;
+    const failedCount = this.records.filter(r => r.result === 'failed').length;
+    const recoveredCount = this.records.filter(r => r.recovered).length;
+
+    return {
+      sessionId: this.sessionId,
+      appVersion: this.appVersion,
+      surface: this.surface,
+      totalSteps: this.records.length,
+      successCount,
+      failedCount,
+      recoveredCount,
+      totalDurationMs: totalDuration,
+      totalCostTokens,
+      totalCostUsd: Number(totalCostUsd.toFixed(6)),
+      records: [...this.records]
+    };
+  }
+}
+
+module.exports = {
+  isOwnerAuditActive,
+  sanitizeAuditString,
+  OwnerAuditSession
+};

package/lib/providers.js

@@ -59,7 +59,10 @@ const PROVEDORES = {
   openrouter: {
     nome: 'OpenRouter',
     baseUrl: 'https://openrouter.ai/api/v1',
-    modeloPadrao: 'deepseek/deepseek-chat',
+    // O padrão precisa refletir o produto: Flash fica restrito ao Free no
+    // roteador do TS; para uma conexão OpenRouter sem modelo explícito, use o
+    // executor oficial pago em vez do legado deepseek-chat.
+    modeloPadrao: 'deepseek/deepseek-v4-pro',
     prefixo: /^sk-or-/,
     gratuito: false,
     limite: 'free tier com rate limit frequente',