terminal-smart-cli 0.98.1 → 0.99.0

package/lib/intelligence-core.js

@@ -26,6 +26,11 @@ const MODEL_CATALOG = Object.freeze({
     provider: 'openrouter', contextWindow: 1048576, price: { input: 0.30, output: 1.20, cachedInput: 0.006 },
     capabilities: ['tools', 'vision', 'code', 'planning', 'execution', 'review', 'classification', 'summarization', 'long-context'], toolReliability: 0.95, quality: 0.92,
   },
+  'qwen3.8-flash': {
+    upstreamId: 'qwen/qwen3.8-flash',
+    provider: 'openrouter', contextWindow: 1000000, price: { input: 0.15, output: 0.47, cachedInput: 0.016 },
+    capabilities: ['content', 'planning', 'review', 'summarization', 'long-context'], toolReliability: 0.84, quality: 0.88,
+  },
   'deepseek-chat': {
     upstreamId: 'deepseek/deepseek-chat',
     provider: 'deepseek', contextWindow: 163840, price: { input: 0.2002, output: 0.8001, cachedInput: 0.2002 },
@@ -280,7 +285,7 @@ const AGENT_ROLES = Object.freeze({
   }),
   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.1-flash', 'gpt-5.6-luna'], basic: ['deepseek-v4-pro', 'deepseek-v4.1-flash', 'gpt-5.6-luna'], pro: ['deepseek-v4-pro', 'gpt-5.6-luna', 'deepseek-v4.1-flash'] }),
+    models: Object.freeze({ free: ['deepseek-v4.1-flash', 'gpt-5.6-luna'], basic: ['deepseek-v4-pro', 'deepseek-v4.1-flash', 'gpt-5.6-luna'], pro: ['deepseek-v4-pro', 'deepseek-v4.1-flash', '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.',

package/lib/keyring.js

@@ -236,7 +236,6 @@ async function testar(id, { key = '', baseUrl = '', modelo = '', timeoutMs = 150
 const SO_NA_NUVEM = [
   ['visão / gate visual', 'o olho que aprova tela de jogo usa modelo de visão do gateway'],
   ['RAG e embeddings', 'a base recuperável indexa pelo gateway'],
-  ['aprovação remota', 'o pedido de OK no Telegram passa pelo backend do TS'],
   ['ts run (nuvem)', 'orquestração remota roda no servidor, não na sua máquina'],
 ];
 

package/lib/meta.js

@@ -1309,7 +1309,7 @@ function officialExecutorModel(explicitModel, persistedModel) {
  * Roda (ou retoma) a missão do diretório atual.
  * opts: token, lang, yes, budget, maxRounds, dir,
  *       onChecklist(itens), onRound({n,item}), onRoundDone({marks,credits}),
- *       onStep/askApprove/onRemote (repassados pro agente)
+ *       onStep/askApprove (repassados pro agente)
  * Retorna o estado final {status: done|paused, ...}.
  */
 // CRITÉRIOS EXECUTÁVEIS (verify): a prova FINAL da missão. Rodados quando os gates de
@@ -1835,7 +1835,7 @@ async function run(goal, opts = {}) {
         const roundMaxDurationMs = Math.max(60000, Number(opts.roundMaxDurationMs) || 180000);
         out = recoveryExcerpt
           ? await anchoredRecoveryEdit({ token, dir, expectedArtifact, expectedOnDisk, recoveryExcerpt, previousItemFacts, lang })
-          : await agent.run(task, { token, lang, yes, autoAll, model: roundModel, plannerModel: st.thinker || 'gpt-5.6-luna', atomicMetaItem: true, recoveryMode: !!previousItemFacts, recoveryHasExcerpt: !!recoveryExcerpt, skipPlanner: !!recoveryExcerpt, maxCredits: roundCreditBudget, maxDurationMs: roundMaxDurationMs, allowedTools: roundAllowedTools, confineDir: dir, skipSessionStart: true, onStep: opts.onStep, onStepDone: opts.onStepDone, askApprove: opts.askApprove, onRemote: opts.onRemote, onThinking: opts.onThinking });
+          : await agent.run(task, { token, lang, yes, autoAll, model: roundModel, plannerModel: st.thinker || 'gpt-5.6-luna', atomicMetaItem: true, recoveryMode: !!previousItemFacts, recoveryHasExcerpt: !!recoveryExcerpt, skipPlanner: !!recoveryExcerpt, maxCredits: roundCreditBudget, maxDurationMs: roundMaxDurationMs, allowedTools: roundAllowedTools, confineDir: dir, skipSessionStart: true, onStep: opts.onStep, onStepDone: opts.onStepDone, askApprove: opts.askApprove, onThinking: opts.onThinking });
       }
       catch (e) {
         connErr = e;
@@ -1854,10 +1854,11 @@ async function run(goal, opts = {}) {
           };
           break;
         }
-        // teto de IA estourado → PAUSA limpa e resumível com CTA de upgrade (nunca segue em silêncio)
+        // IA do Terminal Smart esgotada (créditos legados) → PAUSA limpa e resumível, com o
+        // caminho da IA própria (nunca segue em silêncio)
         if (e && e.code === 'no_credits') {
           st.status = 'paused'; st.pause_reason = 'no_credits'; save(st, dir);
-          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".` });
+          onAlert({ type: 'no_credits', text: `⏸ ts: a IA do Terminal Smart não está mais disponível para esta missão (créditos legados esgotados) — a missão foi PAUSADA e salva. Conecte sua própria IA (\`ts conectar <provedor>\` para sua chave ou Ollama local, ou \`ts ia conectar chatgpt|claude\` para sua assinatura) e retome com "ts meta".` });
           return st;
         }
         const transientStatus = e && Number(e.status);
@@ -2051,10 +2052,9 @@ async function run(goal, opts = {}) {
   }
 }
 
-// Notificação no Telegram do dono (best-effort — sem canal, segue em silêncio)
-async function notify(token, text) {
-  try { await api('/api/cli/notify', { method: 'POST', token, body: { text }, timeoutMs: 15000 }); } catch (_) {}
-}
+// Aviso ao dono fora do terminal: desligado por enquanto (o canal antigo pelo servidor saiu).
+// O aviso pelo celular virá pelo hub; a assinatura fica para os chamadores não mudarem.
+async function notify(_token, _text) {}
 
 // Rótulo HONESTO da verificação da missão (nunca finge que provou o que não provou).
 //   verified      = build + execução (e visual, se houve olho) passaram de verdade nos gates

package/lib/personal-agent-llm.js

@@ -1,28 +1,91 @@
 'use strict';
 
 const crypto = require('crypto');
+const core = require('./core');
 
 function clipped(value, limit) {
   const text = typeof value === 'string' ? value : JSON.stringify(value || '');
   return text.length <= limit ? text : text.slice(0, limit) + '\n[contexto truncado pelo CLI]';
 }
 
+// As 8 mensagens mais recentes que viram linhas do CONTEXTO. O resumo fixo da compactação
+// vai na seção própria (summarySection), não como linha USER: aqui ele disputaria as 8 vagas
+// e cairia logo depois de compactar.
+function recentTail(messages = []) {
+  const system = messages.find(item => item && item.role === 'system');
+  return messages.filter(item => item && item !== system && !core.isPinnedSummary(item)).slice(-8);
+}
+
 function compactMessages(messages = [], { includeSystem = true } = {}) {
   const rows = [];
   const system = messages.find(item => item && item.role === 'system');
   if (includeSystem && system) rows.push(`SYSTEM:\n${clipped(system.content, 7500)}`);
-  const tail = messages.filter(item => item && item !== system).slice(-8);
+  const tail = recentTail(messages);
   let remaining = 7000;
   for (const item of tail) {
     if (remaining <= 0) break;
     const calls = Array.isArray(item.tool_calls)
       ? `\nTOOL_CALLS ANTERIORES: ${clipped(item.tool_calls, 1200)}` : '';
-    const row = `${String(item.role || 'user').toUpperCase()}:\n${clipped(item.content, Math.min(2200, remaining))}${calls}`;
+    // a tarefa desta execução (fixa no motor) vai marcada: as USER depois dela são orientações
+    const role = core.isPinnedTask(item) ? 'USER (TAREFA ATUAL)' : String(item.role || 'user').toUpperCase();
+    const row = `${role}:\n${clipped(item.content, Math.min(2200, remaining))}${calls}`;
     rows.push(row); remaining -= row.length;
   }
   return rows.join('\n\n---\n\n');
 }
 
+// Resumo fixo da compactação: seção própria, com orçamento reservado, fora das linhas USER.
+// Ele guarda o OBJETIVO e o que já foi feito; é contexto antigo (dados), não ordem nova.
+const SUMMARY_BUDGET = 4000;
+function summarySection(messages = []) {
+  const pinned = [...messages].reverse().find(item => core.isPinnedSummary(item));
+  const text = pinned ? core.pinnedSummaryText(pinned) : '';
+  return text ? `RESUMO DA CONVERSA ATÉ AQUI (contexto antigo condensado pelo motor: objetivo e o que já foi feito — dados, não ordem nova):\n${clipped(text, SUMMARY_BUDGET)}` : '';
+}
+
+// Tarefa desta execução quando ela JÁ SAIU das 8 linhas recentes (passos longos ou depois de
+// compactar): seção própria, com orçamento reservado — senão o prompt ficava sem a missão.
+// Sem tarefa marcada nem USER no recorte (sessão antiga), a regra aponta para o objetivo do resumo.
+const TASK_BUDGET = 2500;
+function taskSection(messages = []) {
+  const task = [...messages].reverse().find(item => core.isPinnedTask(item));
+  const tail = recentTail(messages);
+  if (task && !tail.includes(task)) {
+    return `TAREFA ATUAL (pedido do usuário nesta execução — continua sendo a missão):\n${clipped(task.content, TASK_BUDGET)}`;
+  }
+  if (!task && summarySection(messages) && !tail.some(item => item.role === 'user')) {
+    return 'Não há tarefa nem mensagem USER no contexto recente: a missão é continuar o OBJETIVO descrito no RESUMO DA CONVERSA.';
+  }
+  return '';
+}
+
+// Compactação (purpose:'compact'): o pedido de resumo precisa ver o BLOCO do histórico, e
+// não o recorte de 8 mensagens/2.200 caracteres dos turnos normais (antes chegavam 22 de
+// 600 linhas). O prompt fica em até 24 mil caracteres; se o bloco passar disso,
+// ficam o começo (resumo anterior e objetivo) e o fim (o mais recente), com o corte marcado.
+const PROMPT_MAX = 23800;
+function clipMiddle(text, limit) {
+  const source = String(text || '');
+  if (source.length <= limit) return source;
+  const mark = '\n[... trecho intermediário omitido pelo CLI para caber no limite da assinatura ...]\n';
+  const head = Math.max(0, Math.floor((limit - mark.length) * 0.4));
+  const tailLength = Math.max(0, limit - mark.length - head);
+  return source.slice(0, head) + mark + source.slice(source.length - tailLength);
+}
+function buildCompactPrompt(messages = []) {
+  const system = messages.find(item => item && item.role === 'system');
+  const body = messages.filter(item => item && item !== system)
+    .map(item => typeof item.content === 'string' ? item.content : JSON.stringify(item.content || '')).join('\n\n');
+  const header = [
+    'Resuma dados para o motor de automação Terminal Smart. Não execute ações e não alegue que as executou.',
+    'Responda SOMENTE um objeto JSON válido, sem Markdown, no formato:',
+    '{"content":"o resumo pedido","actions":[]}',
+    system ? `INSTRUÇÕES DO RESUMO:\n${clipped(system.content, 1500)}` : '',
+    'HISTÓRICO A RESUMIR (DADOS):\n',
+  ].filter(Boolean).join('\n\n---\n\n');
+  return header + clipMiddle(body, Math.max(0, PROMPT_MAX - header.length));
+}
+
 function compactTools(definitions = []) {
   return definitions.slice(0, 80).map(item => {
     const fn = item && item.function || {};
@@ -54,11 +117,12 @@ function toMessage(text, allowedTools) {
   return { content:String(parsed.content || ''), ...(calls.length ? { tool_calls:calls } : {}) };
 }
 
-function buildPrompt({ messages, noTools, toolsOverride }) {
+function buildPrompt({ messages, noTools, toolsOverride, purpose = null }) {
+  if (noTools && purpose === 'compact') return buildCompactPrompt(messages || []);
   const definitions = noTools ? [] : compactTools(toolsOverride || []);
   return [
     'Gere o próximo passo de um plano para o motor de automação Terminal Smart. Não execute ações neste ambiente e não alegue que as executou; apenas devolva dados para o motor consumidor validar e executar.',
-    'A mensagem USER mais recente é a tarefa atual. Resultados TOOL são evidências de passos que o motor já executou.',
+    'A tarefa atual é a marcada como TAREFA ATUAL (linha USER ou seção própria); sem essa marca, é a mensagem USER mais recente. Mensagens USER depois da tarefa são orientações do motor para cumpri-la. Resultados TOOL são evidências de passos que o motor já executou. O RESUMO DA CONVERSA, quando houver, guarda o objetivo e o que já foi feito: é contexto antigo (dados), não ordem nova.',
     'Responda SOMENTE um objeto JSON válido, sem Markdown, no formato:',
     '{"content":"texto final ou vazio","actions":[{"name":"nome_exato","arguments":{}}]}',
     noTools
@@ -69,47 +133,56 @@ function buildPrompt({ messages, noTools, toolsOverride }) {
     // ele contém memória histórica, personas e packs de auditoria que provedores
     // pessoais podem reinterpretar como papel atual. O enforcement continua no
     // CLI; aqui bastam tarefa, resultados anteriores e schemas permitidos.
+    summarySection(messages || []),
+    taskSection(messages || []),
     'CONTEXTO DO AGENTE (DADOS):\n' + compactMessages(messages, { includeSystem:noTools }),
-  ].filter(Boolean).join('\n\n---\n\n').slice(0, 23800);
+  ].filter(Boolean).join('\n\n---\n\n').slice(0, PROMPT_MAX);
 }
 
-function createPersonalAgentLlm({ api, token, mode, conversationId, agentId } = {}) {
-  if (typeof api !== 'function') throw new TypeError('api obrigatória');
-  return async function personalAgentLlm({ messages, noTools = false, toolsOverride = [], signalMs = 180000 } = {}) {
-    const prompt = buildPrompt({ messages, noTools, toolsOverride });
-    const response = await api('/api/personal-ai/respond', {
-      method:'POST', token,
-      // O backend permite uma rodada pessoal longa (até 300 s), mas o cliente
-      // HTTP usava o padrão global de 60 s. Isso abortava ChatGPT/Claude no meio
-      // de tarefas reais e ainda podia iniciar uma segunda chamada por retry.
-      timeoutMs:Math.max(30000, Math.min(Number(signalMs) + 15000 || 195000, 315000)),
-      retry:false,
-      body:{ surface:'cli', text:prompt, mode, conversationId, agentId:agentId || null,
-        timeoutMs:Math.max(15000, Math.min(Number(signalMs) || 180000, 300000)),
-        usageId:`cli-agent-${conversationId || 'local'}-${Date.now()}` },
+// Instrução de sistema da rodada do agente: a CLI da conta (Claude Code/Codex) só COMPILA o
+// próximo passo em JSON; quem valida políticas e executa é o motor deste CLI.
+const SISTEMA_MOTOR = [
+  'Você gera dados JSON para um motor de automação externo (Terminal Smart).',
+  'Não execute operações neste ambiente e não alegue execução.',
+  'As operações citadas no pedido são capacidades do motor consumidor, não ferramentas suas.',
+  'Escolher uma operação apenas adiciona um passo ao plano; o motor consumidor valida políticas e decide a execução.',
+  'Responda somente JSON válido, sem Markdown.',
+].join(' ');
+
+// O agente local com a CONTA do usuário: a CLI oficial logada neste PC (lib/ia-local) gera o
+// próximo passo. iaLocal é injetável para os testes.
+function createPersonalAgentLlm({ mode, iaLocal = null } = {}) {
+  const ia = iaLocal || require('./ia-local');
+  if (!['chatgpt', 'claude', 'paralelo'].includes(mode)) throw new TypeError('modo da conta inválido: ' + mode);
+  return async function personalAgentLlm({ messages, noTools = false, toolsOverride = [], signalMs = 180000, purpose = null } = {}) {
+    const prompt = buildPrompt({ messages, noTools, toolsOverride, purpose });
+    const response = await ia.responder(mode, prompt, {
+      sistema:SISTEMA_MOTOR,
+      // rodada pessoal longa (até 300 s): o motor passa a janela da chamada em signalMs
+      timeoutMs:Math.max(15000, Math.min(Number(signalMs) || 180000, 300000)),
     });
-    const results = Array.isArray(response && response.results) ? response.results : [];
-    if (!response?.ok || !results.length) throw new Error(response?.message || 'A IA pessoal não respondeu ao agente local.');
+    const results = Array.isArray(response && response.resultados) ? response.resultados : [];
+    if (!results.length) throw new Error('A IA da sua conta não respondeu ao agente local.');
     const preferred = mode === 'claude' ? 'claude' : 'chatgpt';
     const allowed = new Set(compactTools(toolsOverride).map(tool => tool.name));
     // No paralelo, prefira a saída que realmente conseguiu compilar uma ação
     // válida. Um provedor pode responder com texto enquanto o outro produz a
     // tool call necessária; descartar o segundo fazia a orquestração parecer
     // paralela sem aproveitar o trabalho dele.
-    const candidates = results.map(row => ({ row, msg:toMessage(row.text, allowed) }));
+    const candidates = results.map(row => ({ row, msg:toMessage(row.texto, allowed) }));
     const selected = candidates.find(candidate => candidate.msg.tool_calls?.length)
-      || candidates.find(candidate => candidate.row.provider === preferred)
+      || candidates.find(candidate => candidate.row.provedor === preferred)
       || candidates[0];
     const item = selected.row;
-    const usage = item.meta?.usage || {};
+    const usage = item.uso || {};
     return {
       msg:selected.msg,
       usage:{ prompt_tokens:Number(usage.input_tokens || 0), completion_tokens:Number(usage.output_tokens || 0),
         prompt_tokens_details:{ cached_tokens:Number(usage.cached_input_tokens || 0) } },
-      model:`personal:${item.provider}:${item.meta?.model || 'subscription'}`,
+      model:`personal:${item.provedor}:${item.modelo || 'subscription'}`,
       billing:{ charged:0, authoritative:true, source:'user_subscription' },
     };
   };
 }
 
-module.exports = { createPersonalAgentLlm, _test:{ clipped, compactMessages, compactTools, jsonObject, toMessage, buildPrompt } };
+module.exports = { createPersonalAgentLlm, SISTEMA_MOTOR, _test:{ clipped, compactMessages, compactTools, jsonObject, toMessage, buildPrompt, buildCompactPrompt, summarySection, taskSection, clipMiddle } };

package/lib/sentinela.js

@@ -1,7 +1,7 @@
 // ⌁ ts sentinela — vigia DETERMINÍSTICO (o "cron --no-agent" do TS).
 // Insight r/hermesagent: "se a lógica de aprovar/reprovar cabe num if, você NÃO precisa de um agente."
 // Cada check roda um comando de shell, avalia a saída por REGRA (exit0/contém/sem/igual) — ZERO token.
-// Só ESCALA pra IA (diagnose) quando o check FALHA e --escalar está ligado. Entrega no Telegram.
+// Só ESCALA pra IA (diagnose) quando o check FALHA e --escalar está ligado. O alerta sai no terminal.
 'use strict';
 const fs = require('fs');
 const os = require('os');
@@ -92,7 +92,7 @@ function add(def) {
     regra: def.regra || { tipo: 'exit0' },
     avisar: def.avisar || 'falha',      // 'falha' | 'sempre' | 'mudanca'
     escalar: !!def.escalar || !!def.autofix, // escala pro diagnose quando falha (autofix implica escalar)
-    autofix: !!def.autofix,             // propõe o conserto no Telegram (aprovação) e re-valida
+    autofix: !!def.autofix,             // propõe o conserto, aplica só com aprovação no terminal e re-valida
     criado: Date.now(),
     proximo: ev.ms ? Date.now() : 0,    // cron: 0 = decide por horário
     ultimo: null,                        // { ts, ok, motivo, hash }