terminal-smart-cli 0.97.49 → 0.97.54

package/bin/ts.js

@@ -484,7 +484,10 @@ async function sendMessage(token, content) {
     let buf = '', errMsg = null;
     try {
       await sse('/api/ia/chat', {
-        token, body: { conversationId: convId, content, projectId: memoryScope.projectId, workstreamId: memoryScope.workstreamId, surface: 'cli' },
+        // Paridade com Web/App: o chat comum do CLI também declara o modo
+        // automático. Sem isso o backend tratava a chamada como legado e podia
+        // reutilizar um agente/modelo premium antigo, fora da equipe oficial.
+        token, body: { conversationId: convId, content, projectId: memoryScope.projectId, workstreamId: memoryScope.workstreamId, surface: 'cli', mode: 'auto' },
         onEvent: (ev) => {
           if (ev.delta) { buf += ev.delta; sp.text(`${T.receiving} ${fmtK(buf.length)}`); }
           if (ev.error) errMsg = ev.error;
@@ -1100,6 +1103,15 @@ async function chatRepl() {
           console.log('  ' + C.dim((cfg.lang === 'en' ? 'working folder: ' : 'pasta de trabalho: ') + agentCwd));
         } catch (_) { console.error(ui.errLine((cfg.lang === 'en' ? 'no such folder: ' : 'pasta inexistente: ') + target)); }
       } else {
+        const personalIntent = require('../lib/personal-ai-intent').parsePersonalAiIntent(msg);
+        if (personalIntent) {
+          if (personalIntent.action === 'connect') await personalAiCmd(['conectar', personalIntent.provider]);
+          else if (personalIntent.action === 'disconnect') await personalAiCmd(['desconectar', personalIntent.provider]);
+          else if (personalIntent.action === 'use') await personalAiCmd(['usar', personalIntent.mode]);
+          else if (personalIntent.action === 'status') await personalAiCmd(['status']);
+          else console.log(ui.infoLine('Para proteger credenciais, use o fluxo interativo de login exibido pelo CLI.'));
+          continue;
+        }
         // ROTEADOR: linguagem natural pura — o sistema decide o caminho e AVISA
         const r = await router.route(msg, token);
         if (r.dest === 'agente') {
@@ -1430,6 +1442,25 @@ async function agentCmd(words, { askFn, cwd: cwdIn = null, onCwd = null, maxIter
     try { const s = JSON.parse(_fs.readFileSync(sessFile, 'utf8')); priorMessages = s.messages; if (!cwdIn && s.cwd) startCwd = s.cwd; if (!streamJson) console.log('  ' + C.dim((cfg.lang === 'en' ? '↻ resuming this folder\'s session (' : '↻ continuando a sessão desta pasta (') + (s.messages ? s.messages.length : 0) + ' msgs)')); }
     catch (_) { if (!streamJson) console.log('  ' + C.dim(cfg.lang === 'en' ? '(no prior session here — starting fresh)' : '(sem sessão anterior aqui — começando nova)')); }
   }
+  // Retomada por linguagem natural depois de queda/restart. O estado parcial
+  // não é tratado como concluído: o agente recebe a tarefa original e deve
+  // inspecionar o projeto antes de continuar. Se alguma ferramenta chegou a
+  // iniciar, a retomada pede confirmação para não repetir uma ação às cegas.
+  const durableOps = require('../lib/durable-operation');
+  const interruptedOp = durableOps.findInterrupted(startCwd);
+  const naturalResume = durableOps.isNaturalResume(task);
+  if (interruptedOp && naturalResume) {
+    if (interruptedOp.hadTools && !(YES || YOLO || _inlineYolo || autoAllIn)) {
+      if (!process.stdin.isTTY && !askFn) {
+        if (!streamJson) console.log('  ' + C.warn('▲ tarefa interrompida após uma ação; rode novamente com --continuar após revisar o estado.'));
+        return;
+      }
+      const answer = await (askFn || ui.ask)('A tarefa anterior já havia iniciado ações. Retomar após conferir o estado atual? [s/N] ');
+      if (!/^s|^y/i.test(String(answer || ''))) { durableOps.patch(startCwd, { status:'paused' }); return; }
+    }
+    task = `${interruptedOp.task}\n\nRETOMADA APÓS INTERRUPÇÃO: confira primeiro o estado real do projeto e não repita ações que já estejam aplicadas. Pedido atual: ${task}`;
+    if (!streamJson) console.log('  ' + C.dim('↻ retomando a tarefa interrompida desta pasta pela linguagem natural'));
+  }
   // WORKTREE: cria a cópia isolada e passa a trabalhar nela (todas as edições ficam confinadas ali).
   let _wt = null;
   if (useWorktree) {
@@ -1470,25 +1501,31 @@ async function agentCmd(words, { askFn, cwd: cwdIn = null, onCwd = null, maxIter
   // É best-effort para o CLI continuar funcional durante indisponibilidade do backend.
   let sharedChannelPrompt = '';
   let sharedConversationId = null;
+  let personalAgentLlm = null;
+  let personalAgentMode = null;
   try {
     sharedConversationId = await ensureConv(token, 'agent', startCwd);
     const shared = await api('/api/channel/resolve', { method:'POST', token, body:{
       surface:'cli', text:task, conversationId:sharedConversationId,
     } });
     if (shared?.ok && shared.promptBlock) sharedChannelPrompt = shared.promptBlock;
-    const personal = await api('/api/personal-ai/respond', { method:'POST', token, body:{
-      surface:'cli', text:task, conversationId:sharedConversationId,
-      agentId:shared?.agent?.id || null, usageId:`cli-${sharedConversationId}-${Date.now()}`,
-    } });
-    if (personal?.ok && Array.isArray(personal.results) && personal.results.length) {
-      const collaboration = personal.results.map(item =>
-        `### ${item.provider === 'chatgpt' ? 'ChatGPT/Codex' : 'Claude'} (plano pessoal)\n${String(item.text || '').slice(0, 12000)}`
-      ).join('\n\n');
-      sharedChannelPrompt += `\n\nPLANEJAMENTO/REVISÃO DE MODELOS PESSOAIS (valide com ferramentas locais antes de afirmar execução):\n${collaboration}`;
-      if (!streamJson) _hlog('  ' + C.dim(`IA pessoal: ${personal.results.map(item => item.provider === 'chatgpt' ? 'ChatGPT/Codex' : 'Claude').join(' + ')} · 0 créditos TS`));
+    const personalState = await api('/api/personal-ai/status', { token });
+    const personalReady = personalState?.ok && personalState.mode !== 'automatico'
+      && (personalState.mode === 'chatgpt' ? personalState.chatgpt
+        : personalState.mode === 'claude' ? personalState.claude
+          : personalState.chatgpt && personalState.claude);
+    if (personalReady) {
+      personalAgentMode = personalState.mode;
+      personalAgentLlm = require('../lib/personal-agent-llm').createPersonalAgentLlm({
+        api, token, mode:personalAgentMode, conversationId:sharedConversationId,
+        agentId:shared?.agent?.id || null,
+      });
+      if (!streamJson) _hlog('  ' + C.dim(`IA pessoal como executora local: ${personalAgentMode === 'chatgpt' ? 'ChatGPT/Codex' : personalAgentMode === 'claude' ? 'Claude' : 'ChatGPT/Codex + Claude'} · 0 créditos TS`));
     }
   } catch (_) {}
   let out;
+  const durableCwd = _wt ? _wt.base : startCwd;
+  durableOps.begin(durableCwd, task, { engine:'cli', naturalResume:!!(interruptedOp && naturalResume) });
   try {
     // --passos N (ou --steps): quantas iterações o agente pode fazer numa run (default 15, teto 120).
     // Pra missões grandes ("faça tudo de uma vez") sem o pára-e-continua.
@@ -1503,6 +1540,9 @@ async function agentCmd(words, { askFn, cwd: cwdIn = null, onCwd = null, maxIter
     out = await agent.run(task, {
       token, lang: cfg.lang || 'pt', yes: YES, autoAll: (YOLO || _inlineYolo || autoAllIn), model, priorMessages, cwd: startCwd, readOnly, plan, accountPlan: cfg.plan || 'free', browser: useBrowser, allowedTools, maxIter: _maxPassos,
       conversationId:sharedConversationId, sharedChannelPrompt,
+      llmFn:personalAgentLlm || undefined,
+      keyOverride:personalAgentLlm ? { key:'personal-subscription', baseUrl:'personal://subscription', source:'personal', billingAuthoritative:true } : undefined,
+      personalSubscription:!!personalAgentLlm,
       maxCredits: _maxCredits, maxDurationMs: _maxDurationMs || undefined, maxTokens: _maxTokens,
       onThinking: (p) => {
         if (p && typeof p === 'object') {
@@ -1512,6 +1552,8 @@ async function agentCmd(words, { askFn, cwd: cwdIn = null, onCwd = null, maxIter
         sp.text(_statusLine());
       },
       onStep: ({ name, detail, blocked, loop, retry, auto }) => {
+        const durableInternalStep = /^(?:agente_.+|fallback_modelo|fallback_planejador|nova_tentativa|compactar_contexto|gateway|provar_conclusao)$/i.test(String(name || ''));
+        if (name && !blocked && !durableInternalStep) durableOps.toolStarted(durableCwd, name);
         if (streamJson) { _emit(core.AgentEvents.tool({ subtype: retry ? 'retry' : loop ? 'loop' : blocked ? 'blocked' : auto ? 'auto_approved' : 'started', tool: name, detail: detail || '' })); return; }
         sp.stop();
         const tag = auto ? C.warn('▲ auto') : retry ? C.warn('⟳') : loop ? C.warn('↻ loop') : blocked ? C.err('■ ' + T.agent_blocked) : C.cyan('›');
@@ -1542,6 +1584,7 @@ async function agentCmd(words, { askFn, cwd: cwdIn = null, onCwd = null, maxIter
       },
     });
   } catch (e) {
+    durableOps.interrupt(durableCwd, e && (e.code || e.message) || 'agent_error');
     if (_liveTimer) clearInterval(_liveTimer);
     sp.stop();
     const hint = providerCapacityHint(e);
@@ -1554,6 +1597,7 @@ async function agentCmd(words, { askFn, cwd: cwdIn = null, onCwd = null, maxIter
   }
   if (_liveTimer) clearInterval(_liveTimer);
   sp.stop();
+  durableOps.finish(durableCwd, out);
   // cwd EFETIVO (o agente pode ter feito cd/mudar_diretorio) → devolve ao REPL e persiste.
   const effCwd = out.cwd || startCwd;
   // em worktree NÃO propaga o cwd (o REPL/sessão devem ficar na base, não na cópia descartável —

package/lib/agent.js

@@ -145,6 +145,27 @@ function canCloseFromProofs(verifyReport, actions) {
   return !!(verifyReport && verifyReport.allOk && verifyReport.total > 0 && Array.isArray(actions) && actions.length > 0);
 }
 
+// Assinaturas pessoais executam cada papel por um processo separado do Codex/
+// Claude CLI. Para uma alteração local simples, chamar outro modelo apenas para
+// reler o mesmo ledger de ferramentas adiciona bastante contexto sem acrescentar
+// uma prova independente. Nesses casos o harness (resultado da escrita + gates
+// determinísticos) encerra a missão; tarefas complexas, comandos, ações externas,
+// erros ou lotes maiores continuam recebendo o inspetor de IA.
+function independentInspectorDecision({ personalSubscription = false, complexTask = false,
+  actions = [], verifyReport = null, unresolvedErrors = [] } = {}) {
+  if (!personalSubscription) return { run:true, reason:'managed_plan' };
+  if (complexTask) return { run:true, reason:'complex_task' };
+  if (Array.isArray(unresolvedErrors) && unresolvedErrors.length) return { run:true, reason:'tool_errors' };
+  const rows = Array.isArray(actions) ? actions : [];
+  const mutations = rows.filter(a => ['escrever_arquivo', 'editar_arquivo', 'editar_documento', 'editar_planilha'].includes(a && a.name));
+  if (!mutations.length) return { run:true, reason:'non_file_action' };
+  if (mutations.length > 2 || rows.some(a => ['executar_comando', 'executar_remoto'].includes(a && a.name))) {
+    return { run:true, reason:'broader_change' };
+  }
+  if (verifyReport && verifyReport.total > 0 && !verifyReport.allOk) return { run:true, reason:'failed_proof' };
+  return { run:false, reason:verifyReport && verifyReport.total > 0 ? 'deterministic_proof' : 'simple_file_ledger' };
+}
+
 function missionBudgetSuggestion({ limit = 0, spent = 0, required = 0, available = 0 } = {}) {
   const missing = Math.max(0, Number(required) - Number(available));
   return Math.max(Number(limit) + 1, Number(spent) + Number(required), Number(limit) + missing);
@@ -1557,6 +1578,7 @@ async function run(task, opts = {}) {
   // cobrança Smart Credits (best-effort — o teto da sk-hub já protege no gateway)
   const _bill = async () => {
     if (acc.inTok + acc.outTok <= 0) return;
+    if (opts.personalSubscription) return;
     if (k.billingAuthoritative) return;
     try {
       const c = await api('/api/credit/charge', { method: 'POST', token, body: { model: usedModel, inTok: acc.inTok, outTok: acc.outTok, cachedTok: acc.cachedTok } });
@@ -1590,27 +1612,19 @@ async function run(task, opts = {}) {
           : ''),
       validatePlannerDecision);
     if (!planner) {
-      finalText = 'Não iniciei a execução porque o planejador não produziu um plano válido dentro do orçamento da fase. Nenhum arquivo foi alterado. Você pode tentar novamente; o sistema registrou a falha objetiva para diagnóstico.';
-      await _bill();
-      _logEp('planner_failed');
-      return { text: finalText, steps, credits: charged + _visionCredits, tokens: acc, model: usedModel, actions, messages, cwd, context: lastCtx,
-        orchestration: { plan: null, roles: _roleTrace, inspections: _inspectionTrace, phaseBudgets: _phaseBudgets, phaseUsage: _phaseUsage },
-        completion: { ok: false, reason: 'planner_invalid' },
-        report: {
-          models: _roleTrace.map(x => ({ role: x.role, model: x.model, ok: x.ok })),
-          attempts: _roleTrace.length,
-          fallbacks: _fallbackTrace,
-          proofs: [],
-          credits: charged + _visionCredits,
-          tokens: Object.assign({}, acc),
-          durationMs: Date.now() - missionStartedAt,
-          phaseBudgets: _phaseBudgets,
-          phaseUsage: _phaseUsage,
-          reason: 'planner_invalid',
-        },
-        missionCache: _missionCache.stats() };
+      // O planejador é uma otimização, não um ponto único de falha. A própria
+      // tarefa original e os gates determinísticos continuam válidos; portanto
+      // siga com o executor e registre a degradação de forma observável.
+      _planDecision = normalizePlannerDecision({
+        decision:'execute', decision_kind:'technical',
+        reason:'Planejador indisponível; execução continuou com os gates determinísticos.',
+        assumptions:[], steps:[], acceptance:[],
+      });
+      onStep({ name:'fallback_planejador', detail:'planejador indisponível — seguindo com o executor', retry:true });
+      messages.splice(messages.length - 1, 0, { role:'user', content:'O PLANEJADOR FICOU INDISPONÍVEL. Continue diretamente com a tarefa original. Inspecione o estado real, use as ferramentas necessárias e prove a conclusão. Não invente resultados.' });
+    } else {
+      _planDecision = normalizePlannerDecision(planner.json);
     }
-    _planDecision = normalizePlannerDecision(planner.json);
     if (_planDecision.decision === 'ask') {
       finalText = `Preciso de uma decisão sua antes de continuar: ${_planDecision.question}`;
       await _bill();
@@ -1722,19 +1736,25 @@ async function run(task, opts = {}) {
       // INSPETOR independente: recebe apenas objetivo, plano e EVIDÊNCIAS. Não tem
       // ferramentas nem pode alterar o projeto. Se confirmar uma falha, o próximo
       // turno muda para o papel corretor e recebe somente essas falhas.
-      if (!roMode && _actionExpected && actions.length && !guardStopped && opts.orchestrate !== false && _inspectorAttempts < 2) {
+      const recoveredTools = new Set(actions.map(a => a.name));
+      const unresolvedErrors = _toolErrs.filter(e => !recoveredTools.has(e.tool)).slice(-8);
+      const inspectorDecision = independentInspectorDecision({
+        personalSubscription:!!opts.personalSubscription, complexTask:_complexTask,
+        actions, verifyReport, unresolvedErrors,
+      });
+      if (!roMode && _actionExpected && actions.length && !guardStopped && opts.orchestrate !== false
+          && _inspectorAttempts < 2 && inspectorDecision.run) {
         _inspectorAttempts++;
         const proofEvidence = (verifyReport && verifyReport.results || []).map(p => ({ ok: p.ok, label: p.label || p.type, detail: p.detail })).slice(0, 12);
         const mutationActions = actions.filter(a => ['escrever_arquivo', 'editar_arquivo', 'editar_documento', 'editar_planilha'].includes(a.name));
-        const recoveredTools = new Set(actions.map(a => a.name));
-        const unresolvedErrors = _toolErrs.filter(e => !recoveredTools.has(e.tool)).slice(-8);
         const inspector = await _callRole('inspector',
           'Responda APENAS JSON válido: {"verdict":"pass|fail","confirmed_failures":[],"summary":""}. '
-          + 'Falhe somente por divergência concreta entre pedido/critério e evidência. Não invente requisito, não peça melhoria opcional e não aceite narrativa sem prova.',
-          + ' O ledger de ferramentas e runFacts sao evidencia deterministica do harness: fileMutationCount=0 prova zero mutacoes por ferramentas de arquivo nesta rodada. Alvos de comando sao resumos de telemetria; nao falhe apenas por corte visual se a evidencia registra exit 0.',
+          + 'Falhe somente por divergência concreta entre pedido/critério e evidência. Não invente requisito, não peça melhoria opcional e não aceite narrativa sem prova. '
+          + 'O ledger de ferramentas e runFacts é evidência determinística do harness: fileMutationCount=0 prova zero mutações por ferramentas de arquivo nesta rodada. Alvos de comando são resumos de telemetria; não falhe apenas por corte visual se a evidência registra exit 0.',
           JSON.stringify({ task: taskText, auditPack: _auditPack && _auditPack.id, plan: _planDecision, actions, proofs: proofEvidence,
             runFacts: { fileMutationCount: mutationActions.length, fileMutations: mutationActions },
-            unresolvedToolErrors: unresolvedErrors, executorSummary: candidateText.slice(0, 4000) }));
+            unresolvedToolErrors: unresolvedErrors, executorSummary: candidateText.slice(0, 4000) }),
+          value => !!(value && /^(?:pass|fail)$/i.test(String(value.verdict || ''))));
         const inspection = normalizeInspectorDecision(inspector && inspector.json);
         _inspectionTrace.push(Object.assign({ model: inspector && inspector.model || '' }, inspection));
         if (!inspection.passed && inspection.failures.length && !_guard()) {
@@ -2457,4 +2477,4 @@ async function run(task, opts = {}) {
   return { text: finalText, steps, credits: charged + _visionCredits, tokens: acc, model: usedModel, actions, messages, cwd, context: lastCtx, toolErrors: _toolErrs, lastToolError: _lastErr, guard: guardStopped, completion, verification: verifyReport, observability: _observability, report: _finalReport, orchestration: { plan: _planDecision, roles: _roleTrace, inspections: _inspectionTrace, phaseBudgets: _phaseBudgets, phaseUsage: _phaseUsage }, missionCache: _missionCache.stats() };
 }
 
-module.exports = { run, llm, _test: { systemPrompt, projectBrief, inspectionGateDecision, candidateAdmitsIncomplete, isInspectionCommand, parseStageJson, materialDecisionPreflight, actionExpectedForTask, requiresActionEvidence, shouldRunPlanner, isComplexTask, validatePlannerDecision, planUpgradeLimit, commandRecoveryHint, windowsUnsupportedUnixCommand, mutationBatchConflicts, normalizePlannerDecision, normalizeInspectorDecision, winFor, estMsgsTok, COMPACT_AT, KEEP_TAIL, loopSig, isCycle, loopDecision, decideApproval, failureFingerprint, missionGuardDecision, missionBudgetSuggestion, missionTokenCap, missionTimeCap, modelCallWindow, executorFallbackChain, forcedModelMismatch, isTransientModelError, executorCompletionCap, completionGateDecision, canCloseFromProofs, taskScopedToolDefs, explicitTaskWorkdir, restrictedGatewayDecision, validarModeloByok, scopeToolDefs, parseTextToolCalls, isUntrustedToolOutput, untrustedToolEnvelope, isRemoteDeployCommand, browserApprovalRequest } };
+module.exports = { run, llm, _test: { systemPrompt, projectBrief, inspectionGateDecision, independentInspectorDecision, candidateAdmitsIncomplete, isInspectionCommand, parseStageJson, materialDecisionPreflight, actionExpectedForTask, requiresActionEvidence, shouldRunPlanner, isComplexTask, validatePlannerDecision, planUpgradeLimit, commandRecoveryHint, windowsUnsupportedUnixCommand, mutationBatchConflicts, normalizePlannerDecision, normalizeInspectorDecision, winFor, estMsgsTok, COMPACT_AT, KEEP_TAIL, loopSig, isCycle, loopDecision, decideApproval, failureFingerprint, missionGuardDecision, missionBudgetSuggestion, missionTokenCap, missionTimeCap, modelCallWindow, executorFallbackChain, forcedModelMismatch, isTransientModelError, executorCompletionCap, completionGateDecision, canCloseFromProofs, taskScopedToolDefs, explicitTaskWorkdir, restrictedGatewayDecision, validarModeloByok, scopeToolDefs, parseTextToolCalls, isUntrustedToolOutput, untrustedToolEnvelope, isRemoteDeployCommand, browserApprovalRequest } };

package/lib/content-quality.js

@@ -4,6 +4,11 @@ const path=require('path');
 
 const TEXT_EXT=new Set(['.html','.htm','.css','.js','.mjs','.cjs','.ts','.tsx','.jsx','.json','.md','.txt','.svg','.xml','.yml','.yaml']);
 const SKIP=new Set(['node_modules','.git','.cache','.idea','.vscode','coverage']);
+// Arquivos `.ts-*` pertencem ao runtime do Terminal Smart (checkpoint, memória,
+// erros, episódios etc.). Eles não são artefatos entregues pelo projeto e podem
+// conter a saída bruta de processos externos em outra página de código. Incluí-los
+// na prova de qualidade gera falsos negativos sem dizer nada sobre o produto.
+const isInternalRuntimeEntry=name=>String(name || '').toLowerCase().startsWith('.ts-');
 const MOJIBAKE=[
   { regex:/\uFFFD/g, label:'caractere de substituição Unicode (�)' },
   { regex:/Ã[\u0080-\u00BF]/g, label:'UTF-8 interpretado como Latin-1 (Ã…)' },
@@ -27,6 +32,7 @@ function scanProject(root,{maxFiles=1500,maxBytes=2*1024*1024}={}) {
     let entries=[]; try{entries=fs.readdirSync(dir,{withFileTypes:true});}catch(_){return;}
     for(const entry of entries){
       if(scanned>=maxFiles) break;
+      if(isInternalRuntimeEntry(entry.name)) continue;
       if(entry.isDirectory()){ if(!SKIP.has(entry.name)) walk(path.join(dir,entry.name)); continue; }
       const file=path.join(dir,entry.name); const ext=path.extname(entry.name).toLowerCase();
       if(!TEXT_EXT.has(ext)) continue;
@@ -42,4 +48,4 @@ function scanProject(root,{maxFiles=1500,maxBytes=2*1024*1024}={}) {
   return {ok:defects.length===0,defects,scanned,truncated:scanned>=maxFiles};
 }
 
-module.exports={inspectText,scanProject};
+module.exports={inspectText,scanProject,isInternalRuntimeEntry};

package/lib/durable-operation.js

@@ -0,0 +1,61 @@
+'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', 'agent-operations');
+function keyFor(cwd) { return crypto.createHash('sha256').update(path.resolve(cwd).toLowerCase()).digest('hex').slice(0, 20); }
+function fileFor(cwd) { return path.join(DIR, keyFor(cwd) + '.json'); }
+function load(cwd) {
+  try { return JSON.parse(fs.readFileSync(fileFor(cwd), 'utf8')); } catch (_) { return null; }
+}
+function save(cwd, value) {
+  fs.mkdirSync(DIR, { recursive:true, mode:0o700 });
+  const target = fileFor(cwd), tmp = target + '.' + process.pid + '.tmp';
+  fs.writeFileSync(tmp, JSON.stringify(value, null, 2), { encoding:'utf8', mode:0o600 });
+  fs.renameSync(tmp, target);
+  return value;
+}
+function begin(cwd, task, meta = {}) {
+  const previous = load(cwd);
+  const now = new Date().toISOString();
+  return save(cwd, {
+    id:crypto.randomUUID(), cwd:path.resolve(cwd), task:String(task || ''), status:'running',
+    startedAt:now, updatedAt:now, attemptCount:Number(previous?.attemptCount || 0) + 1,
+    hadTools:false, lastTool:null, ...meta,
+  });
+}
+function patch(cwd, changes) {
+  const current = load(cwd); if (!current) return null;
+  return save(cwd, { ...current, ...changes, updatedAt:new Date().toISOString() });
+}
+function toolStarted(cwd, name) { return patch(cwd, { hadTools:true, lastTool:String(name || '') }); }
+function complete(cwd, result = {}) { return patch(cwd, { status:'done', completedAt:new Date().toISOString(), result }); }
+function interrupt(cwd, reason, result = null) {
+  return patch(cwd, {
+    status:'interrupted', interruptedAt:new Date().toISOString(),
+    reason:String(reason || 'interrupted').slice(0, 300),
+    ...(result == null ? {} : { result }),
+  });
+}
+function finish(cwd, outcome = {}) {
+  const result = {
+    steps:Number(outcome.steps || 0), credits:Number(outcome.credits || 0),
+    model:String(outcome.model || ''), completion:outcome.completion || null,
+  };
+  if (outcome.completion && outcome.completion.ok === false) {
+    return interrupt(cwd, outcome.completion.reason || 'mission_incomplete', result);
+  }
+  return complete(cwd, result);
+}
+function findInterrupted(cwd) {
+  const op = load(cwd);
+  if (!op || !['running','interrupted'].includes(op.status)) return null;
+  if (op.status === 'running') return interrupt(cwd, 'process_restart');
+  return op;
+}
+function isNaturalResume(text) { return /\b(?:continu(?:a|ar|e|emos)|retom(?:a|ar|e|emos)|seguir|prossiga|onde\s+parou)\b/i.test(String(text || '')); }
+
+module.exports = { DIR, keyFor, fileFor, load, save, begin, patch, toolStarted, complete, interrupt, finish, findInterrupted, isNaturalResume };

package/lib/personal-agent-llm.js

@@ -0,0 +1,115 @@
+'use strict';
+
+const crypto = require('crypto');
+
+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]';
+}
+
+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);
+  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}`;
+    rows.push(row); remaining -= row.length;
+  }
+  return rows.join('\n\n---\n\n');
+}
+
+function compactTools(definitions = []) {
+  return definitions.slice(0, 80).map(item => {
+    const fn = item && item.function || {};
+    return { name:String(fn.name || ''), description:clipped(fn.description || '', 260), parameters:fn.parameters || { type:'object' } };
+  }).filter(item => item.name);
+}
+
+function jsonObject(text) {
+  const source = String(text || '').replace(/```(?:json)?/gi, '').replace(/```/g, '').trim();
+  const start = source.indexOf('{'), end = source.lastIndexOf('}');
+  if (start < 0 || end <= start) return null;
+  try { return JSON.parse(source.slice(start, end + 1)); } catch (_) { return null; }
+}
+
+function toMessage(text, allowedTools) {
+  const parsed = jsonObject(text);
+  if (!parsed || (!Object.prototype.hasOwnProperty.call(parsed, 'content') && !Array.isArray(parsed.tool_calls) && !Array.isArray(parsed.actions))) {
+    return { content:String(text || '').trim() };
+  }
+  const calls = (parsed.actions || parsed.tool_calls || []).map(call => {
+    const name = String(call && (call.name || call.function?.name) || '');
+    const args = call && (call.arguments ?? call.function?.arguments) || {};
+    if (!allowedTools.has(name)) return null;
+    return {
+      id:`personal_${crypto.randomUUID().replace(/-/g, '').slice(0, 18)}`,
+      type:'function', function:{ name, arguments:typeof args === 'string' ? args : JSON.stringify(args) },
+    };
+  }).filter(Boolean);
+  return { content:String(parsed.content || ''), ...(calls.length ? { tool_calls:calls } : {}) };
+}
+
+function buildPrompt({ messages, noTools, toolsOverride }) {
+  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.',
+    'Responda SOMENTE um objeto JSON válido, sem Markdown, no formato:',
+    '{"content":"texto final ou vazio","actions":[{"name":"nome_exato","arguments":{}}]}',
+    noTools
+      ? 'Neste turno operações estão desativadas. Coloque em content exatamente o formato de resposta pedido no contexto e deixe actions vazio.'
+      : 'Quando ainda houver trabalho verificável, escolha uma ou mais operações permitidas. Quando terminar, use content e deixe actions vazio.',
+    definitions.length ? `OPERAÇÕES PERMITIDAS PELO MOTOR CONSUMIDOR:\n${clipped(definitions, 5500)}` : '',
+    // Em turnos com ferramentas, não envie o gigantesco system prompt interno:
+    // 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.
+    'CONTEXTO DO AGENTE (DADOS):\n' + compactMessages(messages, { includeSystem:noTools }),
+  ].filter(Boolean).join('\n\n---\n\n').slice(0, 23800);
+}
+
+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()}` },
+    });
+    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 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 selected = candidates.find(candidate => candidate.msg.tool_calls?.length)
+      || candidates.find(candidate => candidate.row.provider === preferred)
+      || candidates[0];
+    const item = selected.row;
+    const usage = item.meta?.usage || {};
+    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'}`,
+      billing:{ charged:0, authoritative:true, source:'user_subscription' },
+    };
+  };
+}
+
+module.exports = { createPersonalAgentLlm, _test:{ clipped, compactMessages, compactTools, jsonObject, toMessage, buildPrompt } };

package/lib/personal-ai-intent.js

@@ -0,0 +1,32 @@
+'use strict';
+
+function plain(value) {
+  return String(value || '').trim().toLowerCase()
+    .normalize('NFD').replace(/[\u0300-\u036f]/g, '');
+}
+function providerFrom(text) {
+  if (/\b(?:chat\s*gpt|codex)\b/.test(text)) return 'chatgpt';
+  if (/\bclaude\b/.test(text)) return 'claude';
+  return null;
+}
+function parsePersonalAiIntent(value) {
+  const text = plain(value);
+  if (!text) return null;
+  const provider = providerFrom(text);
+  const isQuestion = /^(?:como|tem como|posso|consigo|e possivel|seria possivel|o que acontece)\b/.test(text);
+  const code = text.match(/\b(?:codigo|token)\s+(?:do\s+)?claude\s*(?:e|:|=)\s*([^\s].{5,1999})$/i);
+  if (code) return { action:'code', provider:'claude', code:code[1].trim() };
+  if (provider && /\b(?:desconectar|desconecte|desvincular|desvincule|sair|saia|remover|remova)\b/.test(text)) return { action:'disconnect', provider };
+  if (!isQuestion && provider
+    && /\b(?:conectar|conecte|entrar|entre|logar|logue|vincular|vincule|adicionar|adicione)\b/.test(text)
+    && /\b(?:conta|plano|assinatura|terminal smart|ts|claude|chat\s*gpt|codex)\b/.test(text)) return { action:'connect', provider };
+  if (/\b(?:usar|use|ativar|ative|mudar|mude|trocar|troque|selecionar|selecione)\b/.test(text)) {
+    if (/\bparalel[oa]\b/.test(text)) return { action:'use', mode:'paralelo' };
+    if (/\bautomatic[oa]\b/.test(text)) return { action:'use', mode:'automatico' };
+    if (provider) return { action:'use', mode:provider };
+  }
+  if (/\b(?:status|situacao|conectad[oa]s?|qual ia|modo de ia)\b/.test(text)
+    && /\b(?:ia|chat\s*gpt|codex|claude|modelo|conta)\b/.test(text)) return { action:'status' };
+  return null;
+}
+module.exports = { parsePersonalAiIntent };

package/package.json

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