terminal-smart-cli 0.98.0 → 0.99.0

package/lib/agent.js

@@ -756,6 +756,10 @@ function browserApprovalRequest(input = {}) {
 async function llm({ baseUrl, key, messages, model, signalMs = 180000, noTools = false, toolsOverride = null, onRetry = null, creditBudget = null, maxCompletionTokens = null, tries = 4 }) {
   // RESILIÊNCIA: o gateway CDC pode reiniciar/oscilar no meio de uma missão longa.
   // withRetry cobre conn/timeout/5xx (backoff+jitter); NUNCA re-tenta no_credits/auth.
+  // _tsPinned/_tsTask (marcas do resumo e da tarefa fixos) são internas: provedores estritos
+  // recusam campo extra na mensagem.
+  const wireMessages = (messages || []).map(m => (m && typeof m === 'object' && ('_tsPinned' in m || '_tsTask' in m))
+    ? (({ _tsPinned, _tsTask, ...rest }) => rest)(m) : m);
   return withRetry(async () => {
     const ctrl = new AbortController();
     let timer;
@@ -770,7 +774,7 @@ async function llm({ baseUrl, key, messages, model, signalMs = 180000, noTools =
             ? { 'X-TS-Credit-Budget': String(Math.floor(Number(creditBudget))) }
             : {}),
         },
-        body: JSON.stringify({ model: model || DEFAULT_EXECUTOR, messages,
+        body: JSON.stringify({ model: model || DEFAULT_EXECUTOR, messages: wireMessages,
           ...(Number.isFinite(Number(maxCompletionTokens)) && Number(maxCompletionTokens) > 0
             ? { max_completion_tokens: Math.max(32, Math.min(Math.floor(Number(maxCompletionTokens)), 16000)) }
             : {}),
@@ -965,7 +969,7 @@ async function _subAgent({ task, k, model, cwd, lang, onStep }) {
       let inp = {}; try { inp = JSON.parse((tc.function && tc.function.arguments) || '{}'); } catch (_) {}
       if (onStep) onStep({ name: '  ↳ ' + nm, detail: argsShort(nm, inp) });
       const res = READONLY.has(nm) ? await tools.execute(nm, inp, { baseDir: cwd, token: k }) : { erro: 'ferramenta não permitida no sub-agente (só leitura).' };
-      msgs.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify(res).slice(0, TOOL_RESULT_CAP) });
+      msgs.push({ role: 'tool', tool_call_id: tc.id, content: intelligence.compactToolResult(res, TOOL_RESULT_CAP) });
     }
   }
   // Esgotou os passos ainda chamando ferramentas? Fecha com UM resumo (sem ferramentas) —
@@ -981,25 +985,19 @@ async function _subAgent({ task, k, model, cwd, lang, onStep }) {
   return { resumo: out || (lang !== 'en' ? '(o sub-agente não produziu um resumo)' : '(sub-agent produced no summary)'), _tin: tin, _tout: tout, _tcach: tcach, _billed: billed };
 }
 
-// Aprovação remota via Telegram (modo --yes): envia o pedido e faz poll até
-// decisão/expiração. Qualquer falha = não aprovado (fail-safe).
-async function _remoteApprove(comando, token, onRemote) {
-  let st = null;
-  try { st = await api('/api/cli/approval/start', { method: 'POST', token, body: { comando, host: os.hostname() }, timeoutMs: 20000 }); }
-  catch (_) { return { approved: false, remoteTried: false }; }
-  if (!st || !st.success || !st.id) return { approved: false, remoteTried: false }; // sem canal
-  onRemote({ id: st.id, ttl: st.ttl || 120 });
-  const t0 = Date.now();
-  while (Date.now() - t0 < 150000) {
-    await new Promise(r => setTimeout(r, 3000));
-    let p = null;
-    try { p = await api('/api/cli/approval/poll', { method: 'POST', token, body: { id: st.id }, timeoutMs: 15000 }); } catch (_) { continue; }
-    if (p && p.status === 'approved') return { approved: true, remoteTried: true };
-    if (p && ['refused', 'expired', 'not_found'].includes(p.status)) return { approved: false, remoteTried: true };
-  }
-  return { approved: false, remoteTried: true };
+// Motivo curto e SEM segredo de uma falha do resumo automático (vai pra tela, pro
+// stream-json e pra ACP): código + mensagem, mascarados e cortados.
+function compactFailReason(e) {
+  const code = e && e.code ? String(e.code) : '';
+  const msg = String((e && e.message) || e || '').replace(/\s+/g, ' ').trim();
+  const txt = code && !msg.includes(code) ? `${code}: ${msg}` : (msg || code);
+  return core.redactSecrets(txt || 'erro desconhecido').slice(0, 160);
 }
 
+// Em --yes não há ninguém no terminal para aprovar: o que exige aprovação é RECUSADO na hora
+// (fail-safe). A aprovação é sempre LOCAL — no terminal (askApprove) ou no editor (ACP).
+// O aviso/aprovação pelo celular virá pelo hub; enquanto isso, nada sai desta máquina.
+
 /**
  * Roda o agente. opts:
  *  token (sessão ts) · lang · yes (auto-aprova NÃO-destrutivos; destrutivo recusa)
@@ -1008,9 +1006,14 @@ async function _remoteApprove(comando, token, onRemote) {
  *  onStep({name, detail, auto}) — passo iniciado (pra UI; auto=destrutivo aprovado em full-auto)
  *  onStepDone({name, ok, status, evidence}) — passo concluído (✓/✗ por etapa)
  *  askApprove(cmd|{kind,cmd}) → Promise<boolean|'all'>  ('all' liga o full-auto na sessão)
+ *  compactFirst — compacta o histórico retomado antes do primeiro passo (sessão perto do limite)
+ *  noProactiveCompact — a pessoa escolheu "Continuar assim" na folha de 95%: sem compactação
+ *    pelo limiar (só no limite útil ou num 400 de contexto)
+ * Retorno: context = {used, window, usable, measured} da ÚLTIMA chamada; compaction =
+ *  {count, ok, reason} (ok=false quando algum resumo automático falhou e a parte antiga se perdeu).
  */
 async function run(task, opts = {}) {
-  const { token, lang = 'pt', yes = false, autoAll = false, model = null, confineDir = null, onStep = () => {}, onStepDone = () => {}, askApprove = async () => false, onThinking = () => {}, onRemote = () => {} } = opts;
+  const { token, lang = 'pt', yes = false, autoAll = false, model = null, confineDir = null, onStep = () => {}, onStepDone = () => {}, askApprove = async () => false, onThinking = () => {} } = opts;
   // Costura exclusiva da API programática/testes: permite simular o gateway sem
   // expor uma flag no CLI nem alterar o caminho normal de produção.
   const llmCall = typeof opts.llmFn === 'function' ? opts.llmFn : llm;
@@ -1108,11 +1111,18 @@ async function run(task, opts = {}) {
   //    o gate por plano no backend (402 plan_limit → mensagem de upgrade).
   const k = opts.keyOverride || await keyring.resolve(token, { feature: 'cli_agent' });
   if (!k || !k.key) throw new ApiError('ai_key', {});
+  // Segredos desta execução que não estão em ~/.ts (a chave de IA em uso, inclusive a da nuvem):
+  // somam-se aos do ts na máscara das saídas de ferramenta e da aprovação remota.
+  const _runSecrets = [k.key];
+  const _maskOut = (x) => tools.maskKnownSecrets(x, [token, ..._runSecrets]);
   // A chave BYOK ainda é validada antes da primeira chamada. No modo Automático,
   // ela escolhe o provedor, mas os papéis continuam obedecendo ao plano. Para
   // escolher um modelo BYOK específico fora dessa regra, o usuário usa --modelo.
   const erroModeloByok = validarModeloByok(k);
   if (erroModeloByok) throw erroModeloByok;
+  // X-TS-Credit-Budget só faz sentido no gateway do TS (créditos legados). Com chave
+  // própria ou assinatura pessoal, o cabeçalho iria para um provedor de terceiros.
+  const _creditBudget = (n) => (k.source === 'cloud' ? n : null);
   let selectedModel = model;
   // BYOK: o catálogo do roteador é do GATEWAY (ids tipo "deepseek-v4-flash"); o provedor
   // do usuário tem os seus ("deepseek-ai/deepseek-v4-flash") e devolve 404 pro id errado.
@@ -1366,13 +1376,20 @@ async function run(task, opts = {}) {
     { role: 'system', content: systemPrompt(lang, cwd) + _memBlock + _busBlock + _interopBlock + skillsBlock + sugestaoBlock + evolveBlock + _erroBlock + planBlock + strictScopeBlock + _auditBlock + _mcpBlock + _hookCtx + _sharedChannelBlock },
     ...(_projectBrief ? [{ role: 'user', content: _projectBrief }] : []),
     ...(_memoryRecallMessage ? [_memoryRecallMessage] : []),
-    { role: 'user', content: taskText },
+    // _tsTask: a tarefa desta execução é FIXA — sobrevive à compactação e aos cortes da sessão
+    { role: 'user', content: taskText, _tsTask: true },
   ];
   // CONTINUAR sessão anterior (ts agente --continuar): reaproveita o histórico, MAS com o system
-  // prompt FRESCO (memória/skills atualizadas) + a nova tarefa no fim.
+  // prompt FRESCO (memória/skills atualizadas) + a nova tarefa no fim. O corte preserva o
+  // resumo fixo da compactação anterior e nunca começa numa resposta 'tool' órfã.
   if (Array.isArray(opts.priorMessages) && opts.priorMessages.length) {
-    const convo = opts.priorMessages.filter(m => m && m.role && m.role !== 'system').slice(-40);
-    messages = [messages[0], ...(_projectBrief ? [{ role: 'user', content: _projectBrief }] : []), ...(_memoryRecallMessage ? [_memoryRecallMessage] : []), ...convo, { role: 'user', content: taskText }];
+    // A tarefa da sessão anterior vira histórico comum (sem a marca): a fixa agora é a nova.
+    // Saídas de ferramenta da sessão salva passam pela máscara dos segredos conhecidos (sessões
+    // gravadas antes dela existir, ou um segredo novo desde então).
+    const convo = core.safeTail(opts.priorMessages.filter(m => m && m.role && m.role !== 'system'), 40)
+      .map(m => (core.isPinnedTask(m) ? (({ _tsTask, ...rest }) => rest)(m) : m))
+      .map(m => (m.role === 'tool' && typeof m.content === 'string' ? Object.assign({}, m, { content: _maskOut(m.content) }) : m));
+    messages = [messages[0], ...(_projectBrief ? [{ role: 'user', content: _projectBrief }] : []), ...(_memoryRecallMessage ? [_memoryRecallMessage] : []), ...convo, { role: 'user', content: taskText, _tsTask: true }];
   }
   const acc = { inTok: 0, outTok: 0, cachedTok: 0 };
   const _roleTrace = [];
@@ -1478,7 +1495,7 @@ async function run(task, opts = {}) {
       try {
         const reply = await llmCall({
           baseUrl: k.baseUrl, key: k.key, messages, model: selectedModel,
-          toolsOverride: mainTools, creditBudget: Math.max(1, Math.min(maxCredits - charged - _visionCredits, _phaseBudgets.execution.credits - _phaseUsage.execution.credits)),
+          toolsOverride: mainTools, creditBudget: _creditBudget(Math.max(1, Math.min(maxCredits - charged - _visionCredits, _phaseBudgets.execution.credits - _phaseUsage.execution.credits))),
           ...extra, maxCompletionTokens: executorCompletionCap(extra.maxCompletionTokens), signalMs, tries: 1,
         });
         if (model && forcedModelMismatch(model, reply && reply.model)) {
@@ -1532,7 +1549,7 @@ async function run(task, opts = {}) {
         onStep({ name: 'agente_' + role, detail: roleModel, phase, model: roleModel });
         const r = await llmCall({ baseUrl: k.baseUrl, key: k.key, model: roleModel, noTools: true, signalMs,
           maxCompletionTokens: role === 'planner' ? 2200 : 1400,
-          creditBudget: Math.max(1, Math.min(maxCredits - charged - _visionCredits, _phaseBudgets[phase].credits - _phaseUsage[phase].credits)), tries: 1,
+          creditBudget: _creditBudget(Math.max(1, Math.min(maxCredits - charged - _visionCredits, _phaseBudgets[phase].credits - _phaseUsage[phase].credits))), tries: 1,
           messages: [{ role: 'system', content: contract.prompt + '\n' + system }, { role: 'user', content: user }] });
         if (roleForcedModel && forcedModelMismatch(roleForcedModel, r && r.model)) {
           const err = new ApiError(`Modelo forçado não foi respeitado: solicitado "${roleForcedModel}", recebido "${r.model}". A missão foi interrompida sem fallback.`, { status: 409, code: 'model_substituted' });
@@ -1601,16 +1618,45 @@ async function run(task, opts = {}) {
       });
     } catch (_) {}
   };
-  let lastCtx = { used: 0, window: ctxWindow }; // ocupação REAL da janela (prompt_tokens da última chamada)
+  // Ocupação da janela na ÚLTIMA chamada (não a soma do turno). measured=true só quando o
+  // provedor devolveu prompt_tokens; sem isso é a estimativa chars/4 do histórico.
+  // Modo assinatura (personal): o prompt enviado é recortado no cliente (personal-agent-llm,
+  // ~23.800 caracteres) e o usage vem somado do backend — nem o histórico inteiro nem a janela do
+  // modelo do gateway medem o que vai de fato. O medidor fica DESLIGADO (used:0, personal:true):
+  // sem rodapé, sem aviso de 80% e sem a folha de 95%. A compactação segue pela estimativa.
+  const _toolsTok = k.source === 'personal' ? 0 : Math.ceil(JSON.stringify(mainTools || []).length / 4);
+  const _ctxEstimate = () => estMsgsTok(messages) + _toolsTok;
+  const _ctxSnapshot = (used, measured) => (k.source === 'personal'
+    ? { used: 0, window: ctxWindow, usable: core.usableWindow(ctxWindow), measured: false, personal: true }
+    : { used, window: ctxWindow, usable: core.usableWindow(ctxWindow), measured: !!measured });
+  let lastCtx = _ctxSnapshot(0, false);
+  const _progress = (extra = {}) => Object.assign({ inTok: acc.inTok, outTok: acc.outTok, cachedTok: acc.cachedTok, steps, model: usedModel, credits: charged + _visionCredits, elapsedMs: Date.now() - missionStartedAt, context: lastCtx }, extra);
 
   // Compacta o histórico quando cruza o limiar (ou quando force=true após um 400 de
-  // contexto): mensagens antigas viram UM resumo denso; as últimas KEEP_TAIL ficam
-  // íntegras. Falhou o resumo? Fallback determinístico (descarta com aviso) — nunca lança.
+  // contexto ou a pedido do chamador): mensagens antigas viram UM resumo denso, FIXO no
+  // índice 1; as últimas KEEP_TAIL ficam íntegras. A chamada usa o MESMO llmCall/k da
+  // execução. Falhou o resumo? A parte antiga é descartada, mas a falha fica VISÍVEL:
+  // passo bloqueado com o motivo + out.compaction.ok=false. Nunca lança.
   let _lastCompactLen = 0; // guarda anti-thrash: só recompacta depois do histórico CRESCER
+  let pinnedSummary = null;
+  const _compaction = { count: 0, ok: true, reason: null };
+  const TASK_PIN_MAX = 8000;
+  const _pinnedTaskCopy = (m) => {
+    const c = typeof m.content === 'string' ? m.content : JSON.stringify(m.content || '');
+    if (c.length <= TASK_PIN_MAX) return m;
+    return { role: 'user', _tsTask: true, content: c.slice(0, TASK_PIN_MAX) + (lang !== 'en'
+      ? '\n[… pedido cortado aqui para caber no contexto]' : '\n[… request cut here to fit the context]') };
+  };
   async function _compactIfNeeded(force) {
     try {
-      const used = estMsgsTok(messages);
-      if (!force && used < ctxWindow * COMPACT_AT) return;
+      // gatilho: o maior entre a estimativa (mensagens + esquemas de ferramentas) e o
+      // prompt medido na última chamada — o medido inclui o que a estimativa não vê.
+      const used = Math.max(_ctxEstimate(), Number(lastCtx.used) || 0);
+      // "Continuar assim" na folha de 95% (opts.noProactiveCompact): o limiar proativo não vale
+      // nesta execução — compacta só quando o histórico já não cabe no limite útil (a próxima
+      // chamada estouraria) ou depois de um 400 de contexto (force).
+      const threshold = opts.noProactiveCompact ? core.usableWindow(ctxWindow) : ctxWindow * COMPACT_AT;
+      if (!force && used < threshold) return;
       if (messages.length < KEEP_TAIL + 4) return; // pouco histórico — nada útil a resumir
       // recém-compactado e pouca coisa nova? não compacta de novo (compactar toda iteração
       // destrói a memória de trabalho do agente — ele começa a reler arquivos em loop)
@@ -1619,33 +1665,70 @@ async function run(task, opts = {}) {
       let cut = Math.max(1, messages.length - KEEP_TAIL);
       while (cut < messages.length && messages[cut].role === 'tool') cut++;
       if (cut >= messages.length - 1) return;
-      const old = messages.slice(1, cut), tail = messages.slice(cut);
-      onStep({ name: 'compactar_contexto', detail: `~${Math.round(used / 1000)}k tok → resumo (${Math.round(100 * used / ctxWindow)}% da janela)` });
+      // o resumo anterior entra INTEIRO (sem o corte de 1500 das mensagens comuns) e é
+      // substituído pelo novo; nunca fica duplicado nem é tratado como conversa.
+      const previous = messages.slice(1).filter(m => core.isPinnedSummary(m)).map(m => core.pinnedSummaryText(m)).filter(Boolean).join('\n\n');
+      const old = messages.slice(1, cut).filter(m => !core.isPinnedSummary(m));
+      const tail = messages.slice(cut).filter(m => !core.isPinnedSummary(m));
+      // a tarefa desta execução entra no bloco (dá o objetivo ao resumo) e, se caiu na parte
+      // antiga, volta logo depois do resumo, FIXA — sem ela o rabo costuma ter só assistant/
+      // tool e o modelo perde a missão. Pedido enorme (pipe, @arquivo) volta cortado.
+      const taskOld = old.find(m => core.isPinnedTask(m)) || null;
       const lines = old.map(m => {
         let c = typeof m.content === 'string' ? m.content : JSON.stringify(m.content || '');
         if (m.role === 'tool') c = c.slice(0, 300);
         if (m.tool_calls) c += ' ' + m.tool_calls.map(t => `[chamou ${(t.function && t.function.name) || '?'}(${String((t.function && t.function.arguments) || '').slice(0, 120)})]`).join(' ');
         return `${m.role}: ${c.slice(0, 1500)}`;
-      }).join('\n').slice(0, 60000);
-      let resumo = '';
+      }).join('\n');
+      const prevBlock = previous ? (lang !== 'en'
+        ? `RESUMO ANTERIOR (mantenha o que continua válido e atualize com a conversa que veio depois):\n${previous}\n\nCONVERSA DESDE O RESUMO ANTERIOR:\n`
+        : `PREVIOUS SUMMARY (keep what is still valid and update it with the conversation that followed):\n${previous}\n\nCONVERSATION SINCE THE PREVIOUS SUMMARY:\n`) : '';
+      const block = prevBlock + lines.slice(0, Math.max(0, 60000 - prevBlock.length));
+      onThinking(_progress({ compacting: true }));
+      let resumo = '', failReason = null;
       try {
         const sys = lang !== 'en'
           ? 'Resuma a conversa de agente abaixo em UM bloco curto e denso (máx ~300 palavras): objetivo, o que já foi feito (arquivos/comandos e resultados), decisões tomadas e o que falta. Preserve caminhos de arquivos e fatos técnicos EXATOS. Sem preâmbulo.'
           : 'Summarize the agent conversation below into ONE short dense block (max ~300 words): goal, what was done (files/commands and results), decisions, and what remains. Preserve EXACT file paths and technical facts. No preamble.';
-        const r = await llmCall({ baseUrl: k.baseUrl, key: k.key, model: selectedModel, noTools: true, signalMs: 60000, maxCompletionTokens: 900, creditBudget: Math.max(1, maxCredits - charged - _visionCredits), messages: [{ role: 'system', content: sys }, { role: 'user', content: lines }] });
+        // purpose:'compact' — o modo pessoal manda o bloco inteiro (não o recorte de 8 mensagens).
+        const r = await llmCall({ baseUrl: k.baseUrl, key: k.key, model: selectedModel, noTools: true, purpose: 'compact',
+          signalMs: opts.personalSubscription ? 120000 : 60000, maxCompletionTokens: 900,
+          creditBudget: _creditBudget(Math.max(1, maxCredits - charged - _visionCredits)),
+          messages: [{ role: 'system', content: sys }, { role: 'user', content: block }] });
         const u = r.usage || {};
         acc.inTok += u.prompt_tokens || 0; acc.outTok += u.completion_tokens || 0;
         charged += (r.billing && r.billing.charged) || 0;
-        resumo = String(r.msg.content || '').replace(/<think>[\s\S]*?<\/think>/gi, '').trim().slice(0, 6000);
-      } catch (_) {}
-      if (!resumo) resumo = lang !== 'en'
-        ? '(resumo automático indisponível — a parte antiga do histórico foi descartada por limite de contexto)'
-        : '(auto-summary unavailable — older history was dropped due to the context limit)';
-      const label = lang !== 'en'
-        ? 'RESUMO DA CONVERSA ATÉ AQUI (contexto antigo, condensado automaticamente):\n'
-        : 'CONVERSATION SUMMARY SO FAR (older context, auto-condensed):\n';
-      messages = [messages[0], { role: 'user', content: label + resumo }, ...tail];
+        resumo = String((r.msg && r.msg.content) || '').replace(/<think>[\s\S]*?<\/think>/gi, '').trim().slice(0, 6000);
+        if (!resumo) failReason = lang !== 'en' ? 'o modelo devolveu um resumo vazio' : 'the model returned an empty summary';
+      } catch (e) { failReason = compactFailReason(e); }
+      _compaction.count += 1;
+      const pctTxt = `~${Math.round(used / 1000)}k tok (${Math.round(100 * used / ctxWindow)}% ${lang !== 'en' ? 'da janela' : 'of the window'})`;
+      if (!resumo) {
+        _compaction.ok = false;
+        _compaction.reason = failReason;
+        // sem resumo novo, o anterior (se havia) continua valendo — só a parte nova se perde
+        const lostNote = lang !== 'en'
+          ? '(o resumo automático da parte seguinte falhou; essa parte do histórico foi descartada por limite de contexto)'
+          : '(the auto-summary of the following part failed; that part of the history was dropped due to the context limit)';
+        resumo = previous
+          ? (previous.includes(lostNote) ? previous : previous + '\n\n' + lostNote)
+          : (lang !== 'en'
+            ? '(resumo automático indisponível — a parte antiga do histórico foi descartada por limite de contexto)'
+            : '(auto-summary unavailable — older history was dropped due to the context limit)');
+        // UM evento só, já como bloqueado: a ACP o abre como 'failed' e o stream-json como
+        // 'blocked' — nada de 'completed' seguido de falha para o mesmo passo.
+        onStep({ name: 'compactar_contexto', blocked: true, detail: lang !== 'en'
+          ? `resumo falhou (${failReason}); parte antiga descartada · ${pctTxt}`
+          : `summary failed (${failReason}); older part dropped · ${pctTxt}` });
+      } else {
+        onStep({ name: 'compactar_contexto', detail: `${pctTxt} → ${lang !== 'en' ? 'resumo' : 'summary'}` });
+      }
+      pinnedSummary = { role: 'user', content: (lang !== 'en' ? core.SUMMARY_LABEL.pt : core.SUMMARY_LABEL.en) + resumo, _tsPinned: true };
+      messages = [messages[0], pinnedSummary, ...(taskOld ? [_pinnedTaskCopy(taskOld)] : []), ...tail];
       _lastCompactLen = messages.length;
+      // o medido da última chamada ficou velho: até a próxima chamada vale a estimativa
+      lastCtx = _ctxSnapshot(_ctxEstimate(), false);
+      onThinking(_progress({ compacting: false }));
     } catch (_) { /* compactação é best-effort — jamais derruba a run */ }
   }
   // cobrança Smart Credits (best-effort — o teto da sk-hub já protege no gateway)
@@ -1672,7 +1755,7 @@ async function run(task, opts = {}) {
       _planDecision = preflight;
       finalText = `Preciso de uma decisão sua antes de continuar: ${_planDecision.question}`;
       _logEp('human');
-      return { text: finalText, steps, credits: 0, tokens: acc, model: usedModel, actions, messages, cwd, context: lastCtx,
+      return { text: finalText, steps, credits: 0, tokens: acc, model: usedModel, actions, messages, cwd, context: lastCtx, compaction: Object.assign({}, _compaction),
         needHuman: { motivo: _planDecision.reason, o_que_fazer: _planDecision.question },
         orchestration: { plan: _planDecision, roles: _roleTrace, inspections: _inspectionTrace }, completion: { ok: false, reason: 'human_decision' }, missionCache: _missionCache.stats() };
     }
@@ -1702,7 +1785,7 @@ async function run(task, opts = {}) {
       finalText = `Preciso de uma decisão sua antes de continuar: ${_planDecision.question}`;
       await _bill();
       _logEp('human');
-      return { text: finalText, steps, credits: charged + _visionCredits, tokens: acc, model: usedModel, actions, messages, cwd, context: lastCtx,
+      return { text: finalText, steps, credits: charged + _visionCredits, tokens: acc, model: usedModel, actions, messages, cwd, context: lastCtx, compaction: Object.assign({}, _compaction),
         needHuman: { motivo: _planDecision.reason || 'Falta uma escolha material para executar com segurança.', o_que_fazer: _planDecision.question },
         orchestration: { plan: _planDecision, roles: _roleTrace, inspections: _inspectionTrace }, completion: { ok: false, reason: 'human_decision' }, missionCache: _missionCache.stats() };
     }
@@ -1725,8 +1808,10 @@ async function run(task, opts = {}) {
     guardStopped = _guard();
     if (guardStopped) break;
     // passa o snapshot de progresso pra a status line ao vivo (tempo é contado no cliente)
-    onThinking({ iter, inTok: acc.inTok, outTok: acc.outTok, cachedTok: acc.cachedTok, steps, model: usedModel, credits: charged + _visionCredits, elapsedMs: Date.now() - missionStartedAt });
-    await _compactIfNeeded(false); // proativo: compacta ao cruzar ~65% da janela
+    onThinking(_progress({ iter }));
+    // proativo: compacta ao cruzar ~65% da janela. compactFirst = o chamador decidiu compactar
+    // antes do primeiro passo (sessão retomada já perto do limite útil, item 22).
+    await _compactIfNeeded(iter === 0 && !!opts.compactFirst);
     let r;
     // gateway oscilou → mostra "reconectando" em vez de morrer calado (confiabilidade visível)
     const _onGwRetry = (e) => onStep({ name: 'gateway', detail: (lang !== 'en' ? 'reconectando ' : 'reconnecting ') + e.attempt + '/' + e.tries + ' (' + e.reason + ')', retry: true });
@@ -1758,7 +1843,10 @@ async function run(task, opts = {}) {
     _phaseUsage.execution.tokens += (u.prompt_tokens || 0) + (u.completion_tokens || 0);
     _phaseUsage.execution.attempts += 1;
     acc.cachedTok += (u.prompt_tokens_details && u.prompt_tokens_details.cached_tokens) || u.cached_tokens || 0;
-    lastCtx = { used: u.prompt_tokens || estMsgsTok(messages), window: ctxWindow };
+    // modo pessoal: o usage do backend vem somado no turno (Codex) ou sem cache (Claude) e o
+    // prompt é recortado no cliente — não serve como medida; fica a estimativa do histórico.
+    const _measured = k.source !== 'personal' && Number(u.prompt_tokens) > 0;
+    lastCtx = _ctxSnapshot(_measured ? Number(u.prompt_tokens) : _ctxEstimate(), _measured);
     if (r.model) usedModel = r.model;
 
     const tcs = r.msg.tool_calls || [];
@@ -1919,8 +2007,8 @@ async function run(task, opts = {}) {
 
       // ENFORCEMENT do modo só-leitura PRIMEIRO: bloqueia ferramentas que alteram/rodam ANTES de
       // qualquer efeito colateral. Não basta OMITIR a ferramenta (o modelo pode chamá-la mesmo
-      // assim); e se o gate destrutivo abaixo rodasse primeiro, chegaria a pedir aprovação (até no
-      // Telegram, em --yes) por um comando que jamais executaria.
+      // assim); e se o gate destrutivo abaixo rodasse primeiro, chegaria a pedir aprovação
+      // por um comando que jamais executaria.
       // (tools MCP read-only — needsApproval=false — são permitidas em roMode; as mutantes não)
       if (roMode && !READONLY.has(name) && name !== 'explorar' && !(_mcp.route[name] && !_mcp.route[name].needsApproval)) {
         onStep({ name, detail: argsShort(name, input), blocked: true });
@@ -1930,8 +2018,8 @@ async function run(task, opts = {}) {
       }
       // RECUSA INSTANTÂNEA de AUTO-DESTRUTIVOS (vem ANTES do gate de aprovação): comandos que
       // matam a própria missão (o processo do agente / o dev server que ela usa) ou a máquina
-      // são recusados NA HORA — sem askApprove, sem poll remoto no Telegram (~150s POR tentativa
-      // desperdiçados no incidente do jogo, em que o modelo insistia em "taskkill /f /im node").
+      // são recusados NA HORA — sem askApprove (antes, a espera da aprovação desperdiçava ~150s POR
+      // tentativa no incidente do jogo, em que o modelo insistia em "taskkill /f /im node").
       // Só o comando LOCAL (executar_comando roda NESTE processo/cwd); o remoto tem outro pid/cwd
       // e segue pelo gate de aprovação comum.
       if (result === undefined && name === 'executar_comando') {
@@ -1948,6 +2036,12 @@ async function run(task, opts = {}) {
         const sd = tools.selfDestructiveReason(String(input.comando || ''), { cwd });
         if (sd) { onStep({ name, detail: argsShort(name, input), blocked: true }); result = { erro: sd }; }
       }
+      // Credenciais do ts (~/.ts/config.json, providers.json, mcp*, sessions, agente) lidas por
+      // shell: recusa como o ler_arquivo — nem aprovação nem --yolo liberam, o conteúdo iria pro modelo.
+      if (result === undefined && name === 'executar_comando') {
+        const tr = tools.tsSecretReadReason(String(input.comando || ''), { cwd });
+        if (tr) { onStep({ name, detail: argsShort(name, input), blocked: true }); result = { erro: tr }; }
+      }
       // Defesa no dispatcher também cobre executar_remoto; o executor local tem
       // a mesma checagem para que nenhum chamador consiga contorná-la.
       if (result === undefined && ['executar_comando', 'executar_remoto'].includes(name)) {
@@ -1989,22 +2083,22 @@ async function run(task, opts = {}) {
       // explícita: full-auto não publica em produção silenciosamente.
       if (result === undefined && name === 'executar_remoto' && isRemoteDeployCommand(input.comando)) {
         const label = `DEPLOY REMOTO → ${String(input.comando || '').slice(0, 1200)}`;
-        let approved = false, remoteTried = false;
+        let approved = false;
         if (!yes) {
           const dec = await askApprove({ kind: 'deploy', cmd: label, warning: 'Este comando pode publicar, reiniciar ou alterar o ambiente remoto.' });
           approved = decideApproval({ autoAll: false, decision: dec }).approved;
-        } else ({ approved, remoteTried } = await _remoteApprove(label, token, onRemote));
+        }
         if (!approved) {
           result = { erro: yes
-            ? (remoteTried ? 'RECUSADO: o dono negou ou não respondeu ao deploy remoto.' : 'RECUSADO: deploy remoto exige aprovação remota no modo --yes.')
+            ? 'RECUSADO automaticamente: deploy remoto exige a aprovação de quem está no terminal, e em --yes não há quem aprove. Explique ao usuário e sugira rodar interativamente.'
             : 'O usuário recusou o deploy remoto. Não publique nem reinicie o ambiente.' };
           onStep({ name, detail: argsShort(name, input), blocked: true });
         }
       }
       // Gate de segurança: destrutivo → humano decide (só se ainda não foi bloqueado acima).
-      // Interativo pergunta no terminal; em --yes (cron) tenta APROVAÇÃO REMOTA no Telegram do dono.
+      // Interativo pergunta no terminal; em --yes (cron) não há quem aprove: recusa.
       if (result === undefined && !_polAllow && (name === 'executar_comando' || name === 'executar_remoto') && tools.isDestructive(input.comando)) {
-        let approved = false, remoteTried = false;
+        let approved = false;
         if (autoApproveDestructive) {
           // FULL-AUTO não abre mão do anti-catástrofe: os auto-destrutivos de máquina/processo/
           // pasta já caíram no gate acima (selfDestructiveReason). O que sobra é ~/.ts por shell
@@ -2026,13 +2120,11 @@ async function run(task, opts = {}) {
           const dec = await askApprove({ kind: 'destructive', cmd: _cmd, warning: core.globalStateWarning(_cmd) });
           const d = decideApproval({ autoAll: false, decision: dec });
           approved = d.approved; if (d.enableAll) autoApproveDestructive = true;
-        } else ({ approved, remoteTried } = await _remoteApprove(String(input.comando || ''), token, onRemote));
+        }
         // result === undefined evita sobrescrever a mensagem específica do bloqueio ~/.ts do full-auto
         if (!approved && result === undefined) {
           result = { erro: yes
-            ? (remoteTried
-              ? 'RECUSADO: o dono NEGOU (ou não respondeu em 2 min) a aprovação remota deste comando destrutivo. Não repita; siga sem ele e relate no resumo.'
-              : 'RECUSADO automaticamente: comando destrutivo não roda em modo --yes (sem Telegram vinculado pra aprovação remota). Explique ao usuário e sugira rodar interativamente ou vincular o Telegram.')
+            ? 'RECUSADO automaticamente: comando destrutivo não roda em modo --yes (não há quem aprove no terminal). Não repita; siga sem ele, relate no resumo e sugira rodar interativamente (ou com --yolo, se o dono quiser aprovar tudo).'
             : 'O usuário RECUSOU este comando destrutivo. Não repita; proponha uma alternativa segura ou explique o que seria necessário.' };
           onStep({ name, detail: argsShort(name, input), blocked: true });
         }
@@ -2046,14 +2138,14 @@ async function run(task, opts = {}) {
         const payload = JSON.stringify(input || {});
         const provider = name.includes('outlook') || name.includes('microsoft365') ? 'MICROSOFT 365' : 'GOOGLE WORKSPACE';
         const label = `${provider} → ${name}: ${payload.length > 1500 ? payload.slice(0, 1500) + ` …(+${payload.length - 1500} chars)` : payload}`;
-        let approved = false, remoteTried = false;
+        let approved = false;
         if (!yes) {
           const dec = await askApprove({ kind: 'cloud_mutation', cmd: label, warning: name.includes('enviar_') ? 'O e-mail será enviado ao destinatário.' : `Dados da conta ${provider} serão alterados.` });
           approved = decideApproval({ autoAll: false, decision: dec }).approved;
-        } else ({ approved, remoteTried } = await _remoteApprove(label, token, onRemote));
+        }
         if (!approved) {
           result = { erro: yes
-            ? (remoteTried ? `RECUSADO: o dono negou ou não respondeu à alteração ${provider}.` : `RECUSADO: alteração ${provider} exige aprovação remota no modo --yes.`)
+            ? `RECUSADO automaticamente: alteração ${provider} exige a aprovação de quem está no terminal, e em --yes não há quem aprove.`
             : `O usuário recusou a alteração na conta ${provider}. Não repita nesta sessão.` };
           onStep({ name, detail: argsShort(name, input), blocked: true });
         }
@@ -2067,7 +2159,7 @@ async function run(task, opts = {}) {
               ? String(input.caminho || '')
               : JSON.stringify(input || {}).slice(0, 600);
         const label = `DISPOSITIVO Android → ${name}: ${safe}`;
-        let approved = false, remoteTried = false;
+        let approved = false;
         if (autoApproveDestructive) {
           approved = true;
           onStep({ name, detail: argsShort(name, input), auto: true });
@@ -2076,14 +2168,10 @@ async function run(task, opts = {}) {
           const d = decideApproval({ autoAll: false, decision: dec });
           approved = d.approved;
           if (d.enableAll) autoApproveDestructive = true;
-        } else {
-          ({ approved, remoteTried } = await _remoteApprove(label, token, onRemote));
         }
         if (!approved) {
           result = { erro: yes
-            ? (remoteTried
-              ? 'RECUSADO: o dono negou ou não respondeu à ação no dispositivo.'
-              : 'RECUSADO automaticamente: ação em dispositivo físico exige aprovação remota.')
+            ? 'RECUSADO automaticamente: ação em dispositivo físico exige a aprovação de quem está no terminal, e em --yes não há quem aprove.'
             : 'O usuário recusou a ação no dispositivo. Não repita nesta sessão.' };
           onStep({ name, detail: argsShort(name, input), blocked: true });
         }
@@ -2095,14 +2183,14 @@ async function run(task, opts = {}) {
       if (result === undefined && name === 'navegador') {
         const browserRequest = browserApprovalRequest(input);
         if (browserRequest) {
-          let approved = false, remoteTried = false;
+          let approved = false;
           if (!yes) {
             const dec = await askApprove(browserRequest);
             approved = decideApproval({ autoAll: false, decision: dec }).approved;
-          } else ({ approved, remoteTried } = await _remoteApprove(browserRequest.cmd, token, onRemote));
+          }
           if (!approved) {
             result = { erro: yes
-              ? (remoteTried ? 'RECUSADO: o dono negou ou não respondeu à ação no navegador.' : 'RECUSADO: ação no navegador exige aprovação remota no modo --yes.')
+              ? 'RECUSADO automaticamente: ação no navegador exige a aprovação de quem está no terminal, e em --yes não há quem aprove.'
               : 'O usuário recusou a ação no navegador. A página continua apenas em modo de leitura.' };
             onStep({ name: 'navegador', detail: browserRequest.cmd, blocked: true });
           }
@@ -2140,22 +2228,22 @@ async function run(task, opts = {}) {
         }
       }
       // Gate de aprovação MCP: tool mutante (annotations/verbo de escrita) → humano decide,
-      // mesmo fluxo do destrutivo (interativo pergunta; --yes tenta o Telegram).
+      // mesmo fluxo do destrutivo (interativo pergunta; --yes recusa).
       if (result === undefined && _mcp.route[name] && _mcp.route[name].needsApproval) {
         // input COMPLETO no label (nunca esconde payload atrás de truncamento — o gate nativo
         // mostra o comando inteiro; o MCP faz igual, só marca quantos chars quando é enorme).
         const _js = JSON.stringify(input);
         const _lbl = 'MCP ' + _mcp.route[name].server + ' → ' + _mcp.route[name].realName + ' ' + (_js.length > 1500 ? _js.slice(0, 1500) + ' …(+' + (_js.length - 1500) + ' chars)' : _js);
-        let approved = false, remoteTried = false;
+        let approved = false;
         if (autoApproveDestructive) { approved = true; onStep({ name, detail: argsShort(name, input), auto: true }); }
         else if (!yes) {
           const dec = await askApprove(_lbl);
           const d = decideApproval({ autoAll: false, decision: dec });
           approved = d.approved; if (d.enableAll) autoApproveDestructive = true;
-        } else ({ approved, remoteTried } = await _remoteApprove(_lbl, token, onRemote));
+        }
         if (!approved) {
           result = { erro: yes
-            ? (remoteTried ? 'RECUSADO: o dono NEGOU (ou não respondeu) a aprovação remota desta ferramenta MCP mutante. Não repita; siga sem ela.' : 'RECUSADO automaticamente: ferramenta MCP mutante não roda em --yes sem aprovação remota (Telegram). Siga sem ela.')
+            ? 'RECUSADO automaticamente: ferramenta MCP mutante não roda em --yes (não há quem aprove no terminal). Siga sem ela.'
             : 'O usuário RECUSOU esta ferramenta MCP. Não repita; proponha uma alternativa.' };
           onStep({ name, detail: argsShort(name, input), blocked: true });
         }
@@ -2302,6 +2390,8 @@ async function run(task, opts = {}) {
       if (result === undefined) {
         onStep({ name, detail: argsShort(name, input) });
         result = await tools.execute(name, input, { confineDir, baseDir: cwd, token, allowedTools: _allowedToolNames, trustedReadPaths: _trustedSkillPaths });
+        // o executor já mascara os segredos do ts; aqui entra também a chave de IA da execução
+        result = _maskOut(result);
         steps++; _ran = true;
         // TOOLRESULT TIPADO (core.classifyToolResult): classe de erro DETERMINÍSTICA. A verdade
         // sobre "deu certo?" vem daqui, não da narrativa do modelo. 'blocked' = política (gate),
@@ -2368,7 +2458,7 @@ async function run(task, opts = {}) {
         const _cacheClass = core.classifyToolResult(result);
         if (_cacheClass.ok && READONLY.has(name)) {
           const _resultCap = name === 'ler_arquivos' ? 24000 : TOOL_RESULT_CAP;
-          _missionCache.remember(name, input, { toolCallId: tc.id, content: JSON.stringify(result).slice(0, _resultCap) });
+          _missionCache.remember(name, input, { toolCallId: tc.id, content: intelligence.compactToolResult(result, _resultCap) });
         } else if (_cacheClass.ok && !READONLY.has(name)) {
           _missionCache.invalidate();
         }
@@ -2383,6 +2473,9 @@ async function run(task, opts = {}) {
           && _researchCalls >= Math.ceil(RESEARCH_MAX * 2 / 3) && _researchCalls <= RESEARCH_MAX) {
         result = Object.assign({}, result, { _aviso: 'Você já pesquisou ' + _researchCalls + 'x (limite ' + RESEARCH_MAX + '). Se já tem o suficiente, PARE de pesquisar e ENTREGUE o resultado agora.' });
       }
+      // REDE DE SEGURANÇA por valor (tools.maskKnownSecrets): o que sai de MCP, navegador, sub-agente
+      // e das mensagens de bloqueio passa pela mesma máscara antes do status, do log e do modelo.
+      result = _maskOut(result);
       // STATUS POR ETAPA (UX): ✓ verde / ✗ vermelho por passo, a partir do ToolResult TIPADO
       // (core.classifyToolResult) — o usuário vê na hora o que deu certo/errado (antes as ⚙
       // não indicavam resultado nenhum). Só para passos que REALMENTE rodaram (não gate/bloqueio).
@@ -2390,12 +2483,18 @@ async function run(task, opts = {}) {
       // BLOQUEIO HUMANO: o agente pediu uma ação externa que só o usuário faz →
       // encerra o turno devolvendo o pedido; a missão pausa e chama o usuário.
       if (result && result._needHuman) {
+        // Sessão retomável (--continuar "feito, continua"): devolve o histórico, com resposta a
+        // ESTA chamada (o pedido ao humano) e às que sobraram no lote (não executadas) — um
+        // tool_call sem resposta faria o provedor recusar a retomada com 400.
+        messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify({ aguardando_humano: true, motivo: result.motivo, o_que_fazer: result.o_que_fazer }) });
+        for (const rest of tcs.slice(tcs.indexOf(tc) + 1)) messages.push({ role: 'tool', tool_call_id: rest.id, content: JSON.stringify({ erro: 'Não executado: o agente parou para pedir uma decisão humana.' }) });
         await _bill();
         _logEp('human');
-        return { text: finalText, steps, credits: charged + _visionCredits, tokens: acc, model: usedModel, actions, cwd, context: lastCtx, needHuman: { motivo: result.motivo, o_que_fazer: result.o_que_fazer }, orchestration: { plan: _planDecision, roles: _roleTrace, inspections: _inspectionTrace } };
+        return { text: finalText, steps, credits: charged + _visionCredits, tokens: acc, model: usedModel, actions, messages, cwd, context: lastCtx, compaction: Object.assign({}, _compaction), needHuman: { motivo: result.motivo, o_que_fazer: result.o_que_fazer }, orchestration: { plan: _planDecision, roles: _roleTrace, inspections: _inspectionTrace } };
       }
       const _resultCap = name === 'ler_arquivos' ? 24000 : TOOL_RESULT_CAP;
-      const _rawToolContent = _cachedContent || JSON.stringify(result).slice(0, _resultCap);
+      // Era .slice() no JSON: cortava o FIM (onde está o erro) e entregava JSON quebrado.
+      const _rawToolContent = _maskOut(_cachedContent || intelligence.compactToolResult(result, _resultCap));
       messages.push({ role: 'tool', tool_call_id: tc.id, content: isUntrustedToolOutput(name)
         ? untrustedToolEnvelope(name, _rawToolContent, lang)
         : _rawToolContent });
@@ -2427,8 +2526,8 @@ async function run(task, opts = {}) {
       ? `Interrompi esta missão porque ela atingiu ${labels[guardStopped.kind] || 'o limite de segurança'}. Foram executados ${steps} passo(s) e consumidos ${charged + _visionCredits} crédito(s). O que já foi concluído permanece válido; a etapa que falhou não foi declarada como pronta. Revise o último erro antes de continuar ou aumente o orçamento explicitamente.`
       : `I stopped this mission because it reached ${labels[guardStopped.kind] || 'the safety limit'}. ${steps} step(s) ran and ${charged + _visionCredits} credit(s) were consumed. Completed work remains valid; the failed step was not reported as done. Review the last error before continuing or explicitly raise the budget.`;
     if (guardStopped.kind === 'credits' && guardStopped.required) finalText += lang !== 'en'
-      ? ` A próxima chamada precisava de ${guardStopped.required} crédito(s), mas havia ${guardStopped.available} disponível(is). Retome com --max-creditos ${suggestedBudget} ou mais.`
-      : ` The next call required ${guardStopped.required} credit(s), but ${guardStopped.available} were available. Resume with --max-creditos ${suggestedBudget} or more.`;
+      ? ` A próxima chamada precisava de ${guardStopped.required} crédito(s), mas havia ${guardStopped.available} disponível(is). Retome com --orcamento ${suggestedBudget} ou mais (créditos legados da IA do Terminal Smart).`
+      : ` The next call required ${guardStopped.required} credit(s), but ${guardStopped.available} were available. Resume with --orcamento ${suggestedBudget} or more (Terminal Smart AI legacy credits).`;
   }
   // Se as ferramentas e os critérios já provaram a entrega, não faça mais uma
   // chamada ao provedor apenas para reescrever o resumo. Além de custar, essa
@@ -2450,7 +2549,7 @@ async function run(task, opts = {}) {
     try {
         const signalMs = modelCallWindow({ maxDurationMs, elapsedMs: Date.now() - missionStartedAt, capMs: modelCallCap(opts.personalSubscription, _complexTask) });
       if (!signalMs) throw new ApiError('model_timeout', { code: 'timeout' });
-      const r = await llmCall({ baseUrl: k.baseUrl, key: k.key, messages: [...messages, { role: 'user', content: pedido }], model: selectedModel, noTools: true, signalMs, maxCompletionTokens: 900, tries: 1, creditBudget: Math.max(1, maxCredits - charged - _visionCredits) });
+      const r = await llmCall({ baseUrl: k.baseUrl, key: k.key, messages: [...messages, { role: 'user', content: pedido }], model: selectedModel, noTools: true, signalMs, maxCompletionTokens: 900, tries: 1, creditBudget: _creditBudget(Math.max(1, maxCredits - charged - _visionCredits)) });
       const u = r.usage || {};
       acc.inTok += u.prompt_tokens || 0; acc.outTok += u.completion_tokens || 0;
       charged += (r.billing && r.billing.charged) || 0;
@@ -2573,7 +2672,7 @@ async function run(task, opts = {}) {
       }));
     await Promise.all(_syncTasks);
   } catch (_) {}
-  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() };
+  return { text: finalText, steps, credits: charged + _visionCredits, tokens: acc, model: usedModel, actions, messages, cwd, context: lastCtx, compaction: Object.assign({}, _compaction), 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, independentInspectorDecision, candidateAdmitsIncomplete, isInspectionCommand, parseStageJson, powershellFileChainIssue, reconcileBillingClaims, materialDecisionPreflight, actionExpectedForTask, requiresActionEvidence, shouldRunPlanner, isComplexTask, validatePlannerDecision, planUpgradeLimit, commandRecoveryHint, windowsUnsupportedUnixCommand, mutationBatchConflicts, normalizeFileToolInput, normalizePlannerDecision, normalizeInspectorDecision, winFor, estMsgsTok, COMPACT_AT, KEEP_TAIL, loopSig, isCycle, loopDecision, decideApproval, failureFingerprint, missionGuardDecision, missionBudgetSuggestion, missionTokenCap, missionTimeCap, modelCallWindow, modelCallCap, explicitExclusiveFileTargets, 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, powershellFileChainIssue, reconcileBillingClaims, materialDecisionPreflight, actionExpectedForTask, requiresActionEvidence, shouldRunPlanner, isComplexTask, validatePlannerDecision, planUpgradeLimit, commandRecoveryHint, windowsUnsupportedUnixCommand, mutationBatchConflicts, normalizeFileToolInput, normalizePlannerDecision, normalizeInspectorDecision, winFor, estMsgsTok, COMPACT_AT, KEEP_TAIL, loopSig, isCycle, loopDecision, decideApproval, failureFingerprint, missionGuardDecision, missionBudgetSuggestion, missionTokenCap, missionTimeCap, modelCallWindow, modelCallCap, explicitExclusiveFileTargets, executorFallbackChain, forcedModelMismatch, isTransientModelError, executorCompletionCap, completionGateDecision, canCloseFromProofs, taskScopedToolDefs, explicitTaskWorkdir, restrictedGatewayDecision, validarModeloByok, scopeToolDefs, parseTextToolCalls, isUntrustedToolOutput, untrustedToolEnvelope, isRemoteDeployCommand, browserApprovalRequest, compactFailReason } };