chatflux-gestao-agente 0.2.6 → 0.2.7

package/README.md

@@ -231,3 +231,23 @@ reparo. Não apague journal/locks para repetir uma abertura incerta: preserve os
 arquivos, confirme que a instância terminou e recupere o bloqueio explicitamente.
 Uma falha parcial informa se o rollback não foi confirmado; não significa que o
 início automático está funcionando.
+
+Se `status` mostrar **escrita local ocupada** mesmo depois de encerrar todos os
+processos do Gestão (incluindo MCP e residente), rode:
+
+```sh
+gestao computador recuperar-bloqueio
+```
+
+O comando só age se o canal do residente não responder, o PID registrado estiver
+encerrado e a listagem do sistema não encontrar outro processo do programa.
+Ele desconsidera seu próprio processo e os wrappers ancestrais npx/npm exec.
+Só renomeia diretórios sem alterações há pelo menos 2 minutos (pelo `mtime`); bloqueios mais recentes são mantidos, com orientação para aguardar e rodar de novo.
+Se não conseguir confirmar essas condições, recusa sem alterar nada.
+Cada marcador vazio é renomeado no mesmo diretório para
+`<nome>.recuperado-AAAAMMDD-HHMMSS`, sem apagar seu conteúdo. Arquivos, symlinks
+e diretórios não vazios são mantidos e relatados. O comando sai com código 1
+se recusar ou mantiver algum bloqueio; sai com 0 se recuperar tudo ou mostrar
+“Nenhum bloqueio local pendente.” Journal, identidade, login e `controle.json`
+são preservados. Depois da recuperação, confira `gestao status` e use
+`gestao ligar` se quiser iniciar o computador novamente.

package/bin/gestao.mjs

@@ -18,6 +18,7 @@ const AJUDA = `gestao — portal Gestão pela linha de comando e por agente (MCP
   gestao ligar     instala início automático e associa este computador ao navegador
   gestao desligar  remove início automático e interrompe o computador, mesmo offline
   gestao computador executar  residente técnico (usado pelo login do SO)
+  gestao computador recuperar-bloqueio  preserva bloqueios locais com o Gestão parado
   gestao logout    suspende o residente e esquece a credencial desta máquina
   gestao mcp       roda o servidor MCP (é o que o Claude Code/Desktop chama)
 
@@ -98,7 +99,12 @@ try {
       break;
     }
     case "computador": {
-      if (process.argv[3] !== "executar" || process.argv.length !== 4) throw new Error("Use gestao computador executar.");
+      if (!["executar", "recuperar-bloqueio"].includes(process.argv[3]) || process.argv.length !== 4) throw new Error("Use gestao computador executar ou gestao computador recuperar-bloqueio.");
+      if (process.argv[3] === "recuperar-bloqueio") {
+        const { recuperarBloqueioComputer } = await import("../lib/computador-cli.mjs");
+        await recuperarBloqueioComputer();
+        break;
+      }
       const { executarComputer } = await import("../lib/computador-cli.mjs");
       const resident = await executarComputer();
       const stop = () => { void resident.close(); };

package/lib/computador-cli.mjs

@@ -19,8 +19,29 @@ const VERSION = JSON.parse(fs.readFileSync(new URL('../package.json', import.met
 const hash = value => createHash('sha256').update(value).digest('hex');
 const wait = ms => new Promise(resolve => setTimeout(resolve, ms));
 const fail = message => new Error(message);
+const LOCAL_BUSY_STATE = 'escrita local ocupada · se continuar com tudo parado, rode gestao computador recuperar-bloqueio';
 const claims = data => { try { return JSON.parse(Buffer.from(data.token.split('.')[1], 'base64url')); } catch { return {}; } };
 
+async function listLocalProcesses(platform, execFileImpl = execFile) {
+  const windows = platform === 'win32';
+  const binary = windows ? path.win32.join(process.env.SystemRoot || 'C:\\Windows', 'System32/WindowsPowerShell/v1.0/powershell.exe') : 'ps';
+  const script = "$ErrorActionPreference='Stop'; Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId,CommandLine | ConvertTo-Json -Compress";
+  const args = windows ? ['-NoLogo', '-NoProfile', '-NonInteractive', '-EncodedCommand', Buffer.from(script, 'utf16le').toString('base64')]
+    : ['-axo', 'pid=,ppid=,command='];
+  const output = await new Promise((resolve, reject) => execFileImpl(binary, args,
+    { shell: false, windowsHide: true, encoding: 'utf8', timeout: 10000, maxBuffer: 16 * 1024 * 1024 },
+    (error, stdout) => error ? reject(error) : resolve(stdout)));
+  if (windows) {
+    const rows = JSON.parse(output);
+    return (Array.isArray(rows) ? rows : [rows]).map(p => ({ pid: p.ProcessId, ppid: p.ParentProcessId, command: p.CommandLine ?? '' }));
+  }
+  return output.trim().split(/\r?\n/).map(line => {
+    const match = /^\s*(\d+)\s+(\d+)\s+(.+)$/.exec(line);
+    if (!match) throw fail('Listagem de processos incompleta.');
+    return { pid: Number(match[1]), ppid: Number(match[2]), command: match[3] };
+  });
+}
+
 export async function computerName({ platform, hostname = os.hostname, execFileImpl = execFile }) {
   if (platform === 'darwin') {
     try {
@@ -35,17 +56,17 @@ export async function computerName({ platform, hostname = os.hostname, execFileI
 }
 
 /** No browser-origin requests, no payload/command dispatcher, no deviceSecret. */
-export function createLocalControl({ httpImpl = http } = {}) {
+export function createLocalControl({ httpImpl = http, killImpl = process.kill.bind(process) } = {}) {
   const fileFor = identity => path.join(identity.directory, 'controle.json');
-  function metadata(identity) {
-    const data = readUserJson(fileFor(identity));
+  function metadata(identity, protect) {
+    const data = readUserJson(fileFor(identity), protect);
     if (data && (data.version !== 1 || !Number.isSafeInteger(data.port) || data.port < 1 || data.port > 65535 ||
         !Number.isSafeInteger(data.pid) || data.pid < 1 || !/^[a-f0-9]{64}$/.test(data.key))) throw recoveryError();
     return data;
   }
-  async function send(identity, verb) {
+  async function send(identity, verb, { readOnly = false } = {}) {
     if (!['status', 'stop', 'pause'].includes(verb)) throw recoveryError();
-    const data = metadata(identity); if (!data) return null;
+    const data = metadata(identity, readOnly ? () => {} : undefined); if (!data) return null;
     return new Promise((resolve, reject) => {
       const req = httpImpl.request({ host: '127.0.0.1', port: data.port, path: `/${verb}`, method: 'POST',
         headers: { Authorization: `Bearer ${data.key}` }, timeout: 15000, agent: false }, res => {
@@ -60,7 +81,7 @@ export function createLocalControl({ httpImpl = http } = {}) {
       req.on('error', e => {
         // Never steal an ambiguous/live PID or send it a termination signal.
         if (e.code === 'ECONNREFUSED') {
-          try { process.kill(data.pid, 0); } catch (dead) { if (dead.code === 'ESRCH') return resolve(null); }
+          try { killImpl(data.pid, 0); } catch (dead) { if (dead.code === 'ESRCH') return resolve(null); }
         }
         reject(Object.assign(fail('Instância local não confirmou o controle autenticado. Confira gestao status.'),
           { code: ['EPERM', 'EACCES', 'ETIMEDOUT'].includes(e.code) ? e.code : 'LOCAL_CONTROL_UNAVAILABLE' }));
@@ -70,7 +91,7 @@ export function createLocalControl({ httpImpl = http } = {}) {
   }
   async function start(identity, handlers) {
     const gate = path.join(identity.directory, '.controle-lock');
-    try { fs.mkdirSync(gate, { mode: 0o700 }); } catch { throw fail('Controle local ocupado; preserve o bloqueio e recupere explicitamente.'); }
+    try { fs.mkdirSync(gate, { mode: 0o700 }); } catch { throw fail('Controle local ocupado; se continuar com tudo parado, rode gestao computador recuperar-bloqueio.'); }
     try {
     if (await send(identity, 'status')) throw fail('Já existe uma instância neste ambiente.');
     const key = randomBytes(32).toString('hex');
@@ -143,7 +164,7 @@ export function createComputerCli(options = {}) {
     ? readUserJson(path.join(os.homedir(), '.config/gestao/token.json')) : lerToken());
   const eraseToken = options.eraseToken ?? apagarToken;
   const service = () => options.service ?? process.env.GESTAO_SERVICO;
-  const startup = options.startup ?? createStartupManager(), control = options.control ?? createLocalControl();
+  const startup = options.startup ?? createStartupManager(), control = options.control ?? createLocalControl({ killImpl: options.killImpl });
   const announce = options.announce ?? console.log;
   const scope = subject => ({ env, subject, baseDir });
   const localFile = identity => path.join(identity.directory, 'cli.json');
@@ -152,10 +173,10 @@ export function createComputerCli(options = {}) {
     if (!Number.isSafeInteger(data.generation) || data.generation < 1 || !(data.pausedTokenHash === null || /^[a-f0-9]{64}$/.test(data.pausedTokenHash))) throw recoveryError();
     return data;
   }
-  function active() {
-    const holder = readUserJson(activeFile); if (!holder) return null;
+  function active(protect) {
+    const holder = readUserJson(activeFile, protect); if (!holder) return null;
     if (holder.version !== 1 || typeof holder.subject !== 'string') throw recoveryError();
-    const identity = identityFor(scope(holder.subject));
+    const identity = identityFor({ ...scope(holder.subject), protect });
     if (!identity?.computerId) throw recoveryError(); // Lost identity is never silently recreated/inherited.
     return identity;
   }
@@ -183,7 +204,7 @@ export function createComputerCli(options = {}) {
   async function exclusive(work) {
     ensureUserDirectory(baseDir); ensureUserDirectory(directory);
     const gate = path.join(directory, '.cli-lock');
-    try { fs.mkdirSync(gate, { mode: 0o700 }); } catch { throw fail('Outra operação local está em curso; preserve o bloqueio após falha e recupere explicitamente.'); }
+    try { fs.mkdirSync(gate, { mode: 0o700 }); } catch { throw fail('Outra operação local está em curso; se continuar com tudo parado, rode gestao computador recuperar-bloqueio.'); }
     try { return await work(); } finally { fs.rmdirSync(gate); }
   }
   async function flush(identity) {
@@ -305,9 +326,11 @@ export function createComputerCli(options = {}) {
     const startupState = ['darwin', 'win32'].includes(platform) ? await startup.startupStatus({ env, platform }) : { installed: false, healthy: false };
     let state = 'não ligado', capabilities;
     if (identity) {
-      const journal = openJournal(identity.directory).read();
-      if (journal.stopped) state = journal.revocationPending ? 'desligado · revogação pendente' : 'desligado';
-      else {
+      let journal;
+      try { journal = openJournal(identity.directory).read(); }
+      catch (e) { if (e.code !== 'LOCAL_BUSY') throw e; state = LOCAL_BUSY_STATE; }
+      if (journal?.stopped) state = journal.revocationPending ? 'desligado · revogação pendente' : 'desligado';
+      else if (journal) {
         try { await credential(identity.subject); state = local(identity).pausedTokenHash ? 'pausado · reconecte com gestao login' : 'aguardando residente'; }
         catch { state = 'reconectar · mesma conta e ambiente com gestao login'; }
         try { const live = await control.send(identity, 'status'); if (live?.state) state = live.state; capabilities = live?.capabilities; } catch { state = 'controle local indisponível'; }
@@ -317,6 +340,93 @@ export function createComputerCli(options = {}) {
     return { env, computerId: identity?.computerId ?? null, startupInstalled: startupState.installed,
       startupHealthy: startupState.healthy, state, ...(capabilities ? { capabilities } : {}) };
   }
+  async function recuperarBloqueio() {
+    personalOnly();
+    // As conferências de recuperação não reescrevem permissões nem arquivos.
+    const identity = active(() => {});
+    if (identity) {
+      let live;
+      try { live = await control.send(identity, 'status', { readOnly: true }); }
+      catch { throw fail('Não foi possível confirmar se o residente terminou pelo canal local; nada foi alterado. Encerre o Gestão e tente novamente.'); }
+      if (live) throw fail('O residente do Gestão está respondendo; nada foi alterado. Encerre-o antes de recuperar os bloqueios.');
+    }
+    const instance = readUserJson(path.join(directory, 'residente-lock.json'), () => {});
+    if (instance) {
+      if (!Number.isSafeInteger(instance.pid) || instance.pid < 1) throw fail('Não foi possível confirmar o PID do residente; nada foi alterado.');
+      let dead = false;
+      try { (options.killImpl ?? process.kill.bind(process))(instance.pid, 0); }
+      catch (e) { dead = e.code === 'ESRCH'; }
+      if (!dead) throw fail(`O residente (PID ${instance.pid}) está vivo ou não foi possível confirmar seu encerramento; nada foi alterado. Encerre-o e tente novamente.`);
+    }
+    let processes;
+    try {
+      processes = await (options.listProcesses ?? (() => listLocalProcesses(platform, options.execFileImpl)))();
+      if (!Array.isArray(processes) || !processes.length || processes.some(p => !p || !Number.isSafeInteger(p.pid) || p.pid < 0 ||
+          !Number.isSafeInteger(p.ppid) || p.ppid < 0 || typeof p.command !== 'string') || !processes.some(p => p.pid === process.pid)) throw fail('Listagem incompleta.');
+    } catch { throw fail('Não foi possível listar todos os processos para confirmar que o Gestão está parado; nada foi alterado.'); }
+    const byPid = new Map(processes.map(p => [p.pid, p])), excluded = new Set();
+    let pid = process.pid;
+    while (pid > 0 && !excluded.has(pid)) { excluded.add(pid); pid = byPid.get(pid)?.ppid ?? 0; }
+    const running = processes.filter(p => !excluded.has(p.pid) && (/chatflux-gestao-agente|gestao\.mjs/i.test(p.command) ||
+      p.command.split(/\s+/).some(token => /(?:[/\\]gestao|^gestao|gestao\.cmd|gestao\.ps1)$/i.test(token.replace(/["']/g, '')))));
+    if (running.length) throw fail(`Há outro processo do Gestão rodando (PID ${running.map(p => p.pid).join(', ')}); nada foi alterado. Encerre-o e tente novamente.`);
+
+    const startupDirectory = ['darwin', 'win32'].includes(platform) ? startup.lockDirectory?.({ env, platform }) : null;
+    const identityDirectories = new Set(identity ? [identity.directory] : []);
+    let names;
+    try { names = fs.readdirSync(directory); }
+    catch (e) {
+      if (e.code !== 'ENOENT') throw fail('Não foi possível conferir as pastas de identidade; nada foi alterado.');
+      names = [];
+    }
+    for (const name of names) {
+      if (name.endsWith('-lock') || name.includes('.recuperado-')) continue;
+      const candidate = path.join(directory, name);
+      let stat;
+      try { stat = fs.lstatSync(candidate); }
+      catch { throw fail('Não foi possível conferir as pastas de identidade; nada foi alterado.'); }
+      if (stat.isDirectory() && !stat.isSymbolicLink()) identityDirectories.add(candidate);
+    }
+    const gates = [
+      ...[...identityDirectories].flatMap(dir => [path.join(dir, '.escrita-lock'), path.join(dir, '.controle-lock')]),
+      path.join(directory, '.escrita-lock'), path.join(directory, '.cli-lock'),
+      ...(startupDirectory ? [path.join(startupDirectory, '.escrita-lock')] : []),
+    ];
+    const date = new Date((options.clock?.now ?? Date.now)());
+    const pad = n => String(n).padStart(2, '0');
+    const stamp = `${date.getFullYear()}${pad(date.getMonth() + 1)}${pad(date.getDate())}-${pad(date.getHours())}${pad(date.getMinutes())}${pad(date.getSeconds())}`;
+    let recovered = 0, kept = 0;
+    for (const gate of gates) {
+      let stat;
+      try { stat = fs.lstatSync(gate); }
+      catch (e) {
+        if (e.code === 'ENOENT') continue;
+        announce(`Mantido: ${gate} · não foi possível conferir o bloqueio.`); kept++; continue;
+      }
+      if (!stat.isDirectory() || stat.isSymbolicLink()) {
+        announce(`Mantido: ${gate} · não é um diretório vazio comum.`); kept++; continue;
+      }
+      if ((options.clock?.now ?? Date.now)() - stat.mtimeMs < 120000) {
+        announce(`Mantido: ${gate} · criado há menos de 2 minutos; aguarde e rode de novo.`); kept++; continue;
+      }
+      try {
+        if (fs.readdirSync(gate).length) {
+          announce(`Mantido: ${gate} · diretório não vazio.`); kept++; continue;
+        }
+        const preservedAs = `${gate}.recuperado-${stamp}`;
+        let exists = false;
+        try { fs.lstatSync(preservedAs); exists = true; } catch (e) { if (e.code !== 'ENOENT') throw e; }
+        if (exists) {
+          announce(`Mantido: ${gate} · já existe uma cópia preservada neste horário; tente novamente.`); kept++; continue;
+        }
+        fs.renameSync(gate, preservedAs);
+        announce(`Recuperado: ${gate} · preservado como ${preservedAs}`); recovered++;
+      } catch { announce(`Mantido: ${gate} · não foi possível preservar por renomeação.`); kept++; }
+    }
+    if (!recovered && !kept) announce('Nenhum bloqueio local pendente.');
+    if (kept) throw fail('Os bloqueios mantidos acima não foram alterados.');
+    return { recovered };
+  }
   async function afterLogin() {
     personalOnly();
     try {
@@ -397,18 +507,19 @@ export function createComputerCli(options = {}) {
           runtime = await (options.makeRuntime ?? composeRuntime)(identity, portal, controller.signal, readToken);
           if (closed || controller.signal.aborted) await pause(); else currentState = 'residente iniciado';
         }
-      } catch { await pause(); backoff(); }
+      } catch (e) { await pause(); if (e.code === 'LOCAL_BUSY') currentState = LOCAL_BUSY_STATE; backoff(); }
       finally { if (!closed) timer = later(schedule, nextDelay); }
     }
     function schedule() { work = tick(); }
     schedule();
     return { close, done };
   }
-  return { ligar, desligar, logout, status, executar, afterLogin };
+  return { ligar, desligar, logout, status, recuperarBloqueio, executar, afterLogin };
 }
 export const ligarComputer = deps => createComputerCli(deps).ligar();
 export const desligarComputer = deps => createComputerCli(deps).desligar();
 export const logoutComputer = deps => createComputerCli(deps).logout();
 export const statusComputer = deps => createComputerCli(deps).status();
+export const recuperarBloqueioComputer = deps => createComputerCli(deps).recuperarBloqueio();
 export const executarComputer = deps => createComputerCli(deps).executar();
 export const afterComputerLogin = deps => createComputerCli(deps).afterLogin();

package/lib/computador-diagnostico.mjs

@@ -11,7 +11,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
-import { identityFor, protectUserFile, withFileGate, recoveryError } from './computador-identidade.mjs';
+import { identityFor, protectUserFile, protectUserFileOnFirstRead, withFileGate, recoveryError } from './computador-identidade.mjs';
 
 const TYPES = ['rede', 'portal_indisponivel', 'login', 'git_ocupado', 'git_acesso', 'git_estado', 'caminho', 'precisa_pasta', 'precisa_permissao', 'tempo_esgotado', 'editor', 'plugin', 'startup', 'resultado_incerto', 'outro', 'resume', 'turno_timeout', 'interacao_necessaria', 'historico_ausente', 'historico_incompativel', 'historico_limite'];
 const PHASES = ['recebido', 'conferindo_pasta', 'selecionando_pasta', 'baixando', 'conferindo_git', 'aguardando_pessoa', 'atualizando_pasta', 'preparar_editor', 'abrindo_pasta', 'aguardando_editor', 'abrindo_conversa', 'atualizando_plugin', 'respondendo_sessao', 'finalizado', 'lendo_historico'];
@@ -70,7 +70,7 @@ export function openDiagnostics(scope, { agentVersion, os, osMajor, currentScope
     try {
       const stat = fs.lstatSync(file);
       if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1 || stat.size > MAX_BYTES) throw recoveryError();
-      protect(file);
+      protectUserFileOnFirstRead(file, protect);
       const lines = fs.readFileSync(file, 'utf8').trimEnd().split('\n').map(s => JSON.parse(s));
       const [header, ...rows] = lines;
       if (!exact(header, ['version', 'dropped', 'pending']) || header.version !== 1 || !integer(header.dropped) ||

package/lib/computador-identidade.mjs

@@ -8,7 +8,6 @@ import os from 'node:os';
 import path from 'node:path';
 import { createHash, randomBytes, randomUUID } from 'node:crypto';
 import { execFileSync } from 'node:child_process';
-import { lerToken } from './config.mjs';
 
 const ROOT = () => path.join(os.homedir(), '.config', 'gestao', 'computadores');
 const MAX_USER_JSON_BYTES = 4 * 1024 * 1024;
@@ -25,6 +24,9 @@ export function scopeDirectory({ env, subject, baseDir = ROOT() }) {
 
 // Script fixo: caminho é dado por ambiente, nunca interpolado em PowerShell.
 // ACL nova, protegida de herança, com uma única regra para o SID atual.
+// SetAccessControl persiste só as seções alteradas (dono + DACL). Set-Acl regrava
+// também a SACL e, num arquivo já protegido, falha sem SeSecurityPrivilege
+// (PrivilegeNotHeldException; reproduzido no Windows 11 em 11/11/2026).
 const ACL = `
 $ErrorActionPreference = 'Stop'
 $p = $env:GESTAO_PROTECT_PATH
@@ -40,7 +42,7 @@ if ($item.PSIsContainer) {
   $rule = New-Object System.Security.AccessControl.FileSystemAccessRule($sid, 'FullControl', 'Allow')
 }
 $acl.AddAccessRule($rule)
-Set-Acl -LiteralPath $p -AclObject $acl
+$item.SetAccessControl($acl)
 `;
 export function protectUserFile(file, { platform = process.platform, execFile = execFileSync } = {}) {
   try {
@@ -59,6 +61,15 @@ export function protectUserFile(file, { platform = process.platform, execFile =
 }
 
 // Primitivas compartilhadas só pelos módulos locais; falham sem incluir payload/segredo no erro.
+const protectedReads = new WeakMap();
+export function protectUserFileOnFirstRead(file, protect = protectUserFile) {
+  const resolved = path.resolve(file);
+  let paths = protectedReads.get(protect);
+  if (paths?.has(resolved)) return;
+  protect(file);
+  if (!paths) { paths = new Set(); protectedReads.set(protect, paths); }
+  paths.add(resolved);
+}
 export function ensureUserDirectory(directory, protect = protectUserFile) {
   fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
   if (!fs.lstatSync(directory).isDirectory() || fs.lstatSync(directory).isSymbolicLink()) throw recoveryError();
@@ -68,7 +79,7 @@ export function readUserJson(file, protect = protectUserFile) {
   try {
     const stat = fs.lstatSync(file);
     if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1 || stat.size > MAX_USER_JSON_BYTES) throw recoveryError();
-    protect(file);
+    protectUserFileOnFirstRead(file, protect);
     const value = JSON.parse(fs.readFileSync(file, 'utf8'));
     // null é JSON válido, mas não significa arquivo ausente: não recriar identidade/journal.
     if (!value || typeof value !== 'object' || Array.isArray(value)) throw recoveryError();
@@ -109,11 +120,11 @@ export function withFileGate(directory, run, protect = protectUserFile) {
   const gate = path.join(directory, '.escrita-lock');
   try { fs.mkdirSync(gate, { mode: 0o700 }); }
   catch (e) {
-    if (e.code === 'EEXIST') throw Object.assign(new Error('Escrita local ocupada; se persistir após encerrar o residente, recupere o bloqueio local.'), { code: 'LOCAL_BUSY' });
+    if (e.code === 'EEXIST') throw Object.assign(new Error('Escrita local ocupada; se continuar com tudo parado, rode gestao computador recuperar-bloqueio.'), { code: 'LOCAL_BUSY' });
     throw e;
   }
   // Um crash neste trecho deixa o gate fechado: recuperação humana, nunca roubo por timeout.
-  try { protect(gate); return run(); }
+  try { return run(); }
   finally { fs.rmdirSync(gate); }
 }
 
@@ -156,7 +167,7 @@ export function createIdentity(options) {
 /** Só pré-validação local; assinatura e papel continuam sendo autoridade do portal.
  * Relê a fonte em TODA chamada. Não renova/apaga token nem acessa serviço.mjs.
  */
-export async function loadPersonalToken({ env, subject, readToken = lerToken, now = Date.now, service = process.env.GESTAO_SERVICO }) {
+export async function loadPersonalToken({ env, subject, readToken = async () => (await import('./config.mjs')).lerToken(), now = Date.now, service = process.env.GESTAO_SERVICO }) {
   scopeDirectory({ env, subject });
   if (service) throw new Error('Modo serviço não pode operar um computador pessoal.');
   const reconnect = () => Object.assign(new Error('Reconectar com gestao login na mesma conta e ambiente; execução suspensa.'), { code: 'RECONNECT_REQUIRED' });

package/lib/computador-startup.mjs

@@ -221,7 +221,8 @@ export function createStartupManager({
       return { installed: false };
     }, protect);
   }
-  return { installStartup, removeStartup, startupStatus };
+  const lockDirectory = options => locations(options).directory;
+  return { installStartup, removeStartup, startupStatus, lockDirectory };
 }
 export const installStartup = options => createStartupManager().installStartup(options);
 export const removeStartup = options => createStartupManager().removeStartup(options);

package/lib/config.mjs

@@ -5,6 +5,7 @@ import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { ensureUserDirectory, protectUserFile } from './computador-identidade.mjs';
 
 const AMBIENTES = {
   prod: {
@@ -60,8 +61,13 @@ export function salvarToken(dados) {
       /* cai no arquivo */
     }
   }
-  fs.mkdirSync(path.dirname(ARQUIVO), { recursive: true });
+  ensureUserDirectory(path.dirname(ARQUIVO));
   fs.writeFileSync(ARQUIVO, json, { mode: 0o600 });
+  try { protectUserFile(ARQUIVO); }
+  catch (e) {
+    fs.unlinkSync(ARQUIVO);
+    throw e;
+  }
   return ARQUIVO;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chatflux-gestao-agente",
-  "version": "0.2.6",
+  "version": "0.2.7",
   "type": "module",
   "description": "Opere o portal Gestão da ChatFlux pelo Claude Code, Claude Desktop ou qualquer harness MCP — com a sua identidade e o seu papel.",
   "keywords": [