chatflux-gestao-agente 0.1.3 → 0.2.0

package/README.md

@@ -46,11 +46,11 @@ gestao login
   └─ abre  <portal>/agente/login?port=…&state=…
        └─ a página (só staff) mostra quem você é e pede confirmação
        └─ o browser — que JÁ tem sua sessão do Clerk — emite o JWT do
-          template `convex` e entrega no loopback
+          template `convex-agente` e entrega no loopback
   └─ guarda no Keychain (macOS) ou em ~/.config/gestao/token.json (0600)
 ```
 
-Vale **1 hora**. E na prática você não faz nada disso à mão: o próprio agente
+Vale **até 6 horas** (a validade real aparece no login e no `gestao status`). E na prática você não faz nada disso à mão: o próprio agente
 chama a tool `gestao_conectar` quando precisa, o navegador abre, você clica em
 **Autorizar** e ele refaz a ação. O `gestao login` no terminal existe como
 alternativa, não como o caminho normal.
@@ -58,7 +58,7 @@ alternativa, não como o caminho normal.
 **O servidor NÃO morre quando a sessão expira.** Ele sobe sempre: lista as tools a
 partir do último contrato buscado (cache em `~/.config/gestao/`), e `gestao_conectar`
 fica SEMPRE disponível — é justamente quando a sessão vence que ela precisa existir.
-Sem isso, a pessoa veria "Failed to connect — Connection closed" de hora em hora,
+Sem isso, a pessoa veria "Failed to connect — Connection closed" a cada expiração,
 sem pista do motivo.
 
 O cache é conveniência, nunca fonte: qualquer ação de verdade exige token válido.
@@ -93,12 +93,110 @@ arquivar empresa e encerrar projeto **cascateiam e não têm desfazer**.
 
 | arquivo | o quê |
 |---|---|
-| `bin/gestao.mjs` | CLI: `login`, `status`, `logout`, `mcp` |
+| `bin/gestao.mjs` | CLI pessoal/MCP e comandos do computador |
+| `lib/computador-cli.mjs` | registro, startup, controle local, desligamento offline e composição A1–A9 |
 | `lib/login.mjs` | loopback + `state` + abre o navegador |
 | `lib/config.mjs` | ambientes e guarda do token (Keychain / arquivo 0600) |
 | `lib/gestao.mjs` | busca o contrato e chama o Convex por nome |
 | `lib/tools.mjs` | contrato → lista de tools MCP |
 | `lib/mcp.mjs` | servidor MCP (stdio, JSON-RPC) |
 
-Zero dependências de propósito: isto roda na máquina de cada pessoa, e cada
-dependência é superfície.
+A única dependência é `convex` **1.41.0**, carregada sob demanda pelo residente
+para a assinatura oficial da fila. CLI/MCP legados continuam usando HTTP.
+
+## Meu computador (macOS e Windows)
+
+Instale **Node >=20**, VS Code estável, extensões Claude Code/Codex e git.
+Para repositórios privados, use suas credenciais locais de git/GitHub (`gh auth
+login`, se usar gh). O programa não instala essas ferramentas nem recebe o
+acesso GitHub do servidor.
+
+Faça uma instalação persistente; o cache temporário do npx não serve para iniciar
+com o sistema:
+
+```sh
+npm install -g chatflux-gestao-agente
+gestao ligar
+gestao status
+```
+
+`ligar` reutiliza o login pessoal e o clique **Autorizar** se necessário. Mostra
+conta e ambiente, registra a instalação, instala o início automático do usuário e
+abre **Meu computador**. Na página, confirme **Usar este computador neste
+navegador** e escolha a pasta padrão. O link contém só o ID público; não compartilhe
+arquivos locais de identidade/controle. Repetir `ligar` mantém a instalação e suas
+preferências. Um segundo computador tem identidade própria.
+
+No Mac, o início automático usa um LaunchAgent na sessão gráfica do usuário:
+`~/Library/LaunchAgents/ai.chatflux.gestao-computador.<env>.plist`. No Windows, usa
+**HKCU Run**, entrada `ChatFluxGestaoComputador-<env>` e launcher VBS sem console,
+sem administrador/SYSTEM. Ambos guardam caminhos absolutos do Node e do pacote;
+não dependem do PATH de uma janela de terminal. O subcomando técnico é
+`gestao computador executar`; normalmente o login do SO o chama.
+
+**Limites de campo desta versão:** F02 ainda precisa provar seletor, prontidão e
+nova/retomada Codex na extensão VS Code; as flags correspondentes continuam
+desabilitadas na composição padrão. Os adaptadores Windows (startup, ACL,
+lançadores e comandos) ainda precisam dos ensaios reais. Testes com adaptadores
+falsos não certificam o aceite nos dois sistemas. Os links manuais do portal
+continuam disponíveis; não contam como prova da abertura assistida.
+
+### Reconectar, trocar ambiente ou conta
+
+O login vence (normalmente até 6 h). O residente pausa os pedidos e orienta
+`gestao login` ou `gestao_conectar`; ele não renova o token silenciosamente.
+`gestao status` mostra ambiente, startup, computador e a causa local mesmo sem
+rede/login. O indicador do portal pode levar até 180 s para perder a conexão.
+
+O padrão é **prod** (`portal.chatflux.ai`). Para desenvolvimento, use o mesmo
+ambiente em todos os comandos:
+
+```sh
+# macOS
+GESTAO_ENV=dev gestao ligar
+GESTAO_ENV=dev gestao status
+GESTAO_ENV=dev gestao desligar
+```
+
+```powershell
+# Windows PowerShell (somente esta sessão)
+$env:GESTAO_ENV = 'dev'
+gestao ligar
+gestao status
+gestao desligar
+Remove-Item Env:GESTAO_ENV
+```
+
+O fallback `~/.config/gestao/token.json` é compartilhado entre ambientes: um login
+dev não autoriza o residente prod. O programa confere ambiente e subject a cada
+conexão. Para trocar a pessoa nesse perfil do SO, primeiro desligue e entregue a
+revogação com o login da pessoa anterior; depois faça login/ligar com a nova.
+Nenhuma pasta ou autorização é herdada. Perder `identidade.json` exige recuperação
+explícita e outra instalação, sem reutilizar caminhos do registro perdido.
+
+`GESTAO_SERVICO` é outro modo: um agente autônomo, não o residente pessoal.
+`ligar`/`desligar`/`computador executar` o recusam; retire essa variável para usar
+sua conta. Não use serviço para contornar o vencimento do login.
+
+### Desligar e remover
+
+```sh
+gestao desligar        # funciona offline; preserva login, projetos e pastas
+gestao logout          # pausa residente e remove apenas o login
+npm uninstall -g chatflux-gestao-agente
+```
+
+Antes de desinstalar, rode `desligar` em cada ambiente que ligou. Ele bloqueia
+pedidos no journal, remove o startup e interrompe a instância pelo canal local
+autenticado. Sem rede/login, guarda revogação pendente: no próximo `gestao login`,
+`ligar`, `desligar` ou início técnico com conexão entrega **só a revogação** antes
+de qualquer fila. Login sozinho não religa computador desligado. Use `ligar`
+explicitamente. Logout preserva startup; uma nova autorização da mesma conta
+permite ao residente pausado continuar.
+
+Se mudou a instalação/caminho do Node ou do pacote, rode `desligar` usando um Node
+válido e reinstale/religue no caminho novo. `status` mostra startup que precisa de
+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.

package/bin/gestao.mjs

@@ -1,19 +1,23 @@
 #!/usr/bin/env node
-// CLI do Gestão. Três verbos: `login`, `status`, `mcp`.
+// CLI do Gestão. Residente pessoal importado somente pelos verbos necessários.
 
-import { login } from "../lib/login.mjs";
+import { loginVerificado } from "../lib/login.mjs";
 import { servir } from "../lib/mcp.mjs";
 import { contrato, euSou, NaoAutenticado } from "../lib/gestao.mjs";
 import {
-  ambiente, lerToken, apagarToken, expiraEm, tokenValido,
+  ambiente, lerToken, expiraEm, tokenValido, descreverValidade,
 } from "../lib/config.mjs";
 import { montarTools } from "../lib/tools.mjs";
+import { nomeServico } from "../lib/servico.mjs";
 
 const AJUDA = `gestao — portal Gestão pela linha de comando e por agente (MCP)
 
   gestao login     autoriza este computador a agir como você (abre o navegador)
   gestao status    mostra quem está conectado e quanto tempo falta
-  gestao logout    esquece a credencial desta máquina
+  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 logout    suspende o residente e esquece a credencial desta máquina
   gestao mcp       roda o servidor MCP (é o que o Claude Code/Desktop chama)
 
 Ambiente: ${ambiente().nome}  (GESTAO_ENV=dev para apontar ao dev)
@@ -27,17 +31,37 @@ const [, , verbo] = process.argv;
 try {
   switch (verbo) {
     case "login": {
-      const { email, onde } = await login();
-      const eu = await euSou();
+      if (nomeServico()) {
+        console.error("Modo serviço (GESTAO_SERVICO) ativo: não há login de pessoa. Use `gestao status`.");
+        process.exit(1);
+      }
+      const { email, onde, token, eu } = await loginVerificado();
       console.log(
         `Conectado como ${eu?.name ?? email ?? "?"} (${eu?.role ?? "?"}) no ambiente ${ambiente().nome}.`,
       );
       console.log(`Credencial guardada em: ${onde}`);
-      console.log("Vale por 1 hora. Quando expirar, rode `gestao login` de novo.");
+      console.log(`Vale por ${descreverValidade(token)}. Quando expirar, rode \`gestao login\` de novo.`);
+      const { afterComputerLogin } = await import("../lib/computador-cli.mjs");
+      await afterComputerLogin();
       break;
     }
 
     case "status": {
+      if (nomeServico()) {
+        const eu = await euSou();
+        const tools = montarTools(await contrato());
+        console.log(`Conectado (serviço ${nomeServico()}): ${eu?.name ?? "?"} — papel ${eu?.role ?? "?"}`);
+        console.log(`Ambiente:  ${ambiente().nome}`);
+        console.log(`Tools:     ${tools.length} (do contrato servido pelo deployment)`);
+        break;
+      }
+      const { statusComputer } = await import("../lib/computador-cli.mjs");
+      const computer = await statusComputer();
+      console.log(`Computador: ${computer.computerId ?? "não registrado"} · ${computer.state}`);
+      console.log(`Startup: ${computer.startupInstalled ? (computer.startupHealthy ? "instalado" : "precisa reparar com gestao ligar") : "removido"} · ambiente ${computer.env}`);
+      for (const [name, capability] of Object.entries(computer.capabilities ?? {})) {
+        console.log(`${name}: ${capability.enabled ? 'ligada' : 'desligada'}${capability.target ? ` (${capability.target})` : ''}${capability.reason || capability.pending ? ` · ${capability.reason ?? capability.pending}` : ''}`);
+      }
       const dados = lerToken();
       if (!dados) {
         console.log("Sem credencial nesta máquina. Rode `gestao login`.");
@@ -57,10 +81,32 @@ try {
       break;
     }
 
-    case "logout":
-      apagarToken();
-      console.log("Credencial removida desta máquina.");
+    case "ligar": {
+      const { ligarComputer } = await import("../lib/computador-cli.mjs");
+      await ligarComputer();
+      break;
+    }
+    case "desligar": {
+      const { desligarComputer } = await import("../lib/computador-cli.mjs");
+      await desligarComputer();
+      break;
+    }
+    case "computador": {
+      if (process.argv[3] !== "executar" || process.argv.length !== 4) throw new Error("Use gestao computador executar.");
+      const { executarComputer } = await import("../lib/computador-cli.mjs");
+      const resident = await executarComputer();
+      const stop = () => { void resident.close(); };
+      process.once("SIGTERM", stop); process.once("SIGINT", stop);
+      await resident.done;
+      process.removeListener("SIGTERM", stop); process.removeListener("SIGINT", stop);
       break;
+    }
+    case "logout": {
+      const { logoutComputer } = await import("../lib/computador-cli.mjs");
+      await logoutComputer();
+      console.log("Residente suspenso; credencial removida desta máquina.");
+      break;
+    }
 
     case "mcp":
       await servir();

package/lib/computador-abrir-uri.ps1

@@ -0,0 +1,27 @@
+# A4: receita Windows candidata, F02 pendente. Launcher local fixo, sem shell livre.
+param(
+    [Parameter(Mandatory=$true)][ValidateSet('folder', 'uri')][string]$Mode,
+    [Parameter(Mandatory=$true)][string]$ValueBase64
+)
+$ErrorActionPreference = 'Stop'
+try {
+    $utf8 = New-Object System.Text.UTF8Encoding($false, $true)
+    $value = $utf8.GetString([Convert]::FromBase64String($ValueBase64))
+    if ($value.Contains([char]0)) { exit 1 }
+    if ($Mode -eq 'folder') {
+        if (-not [System.IO.Path]::IsPathRooted($value)) { exit 1 }
+        $segments = $value.Replace('\', '/') -split '/'
+        if ($segments[0] -notmatch '^[A-Za-z]:$') { exit 1 }
+        $encoded = @($segments[0]) + @($segments | Select-Object -Skip 1 | ForEach-Object { [Uri]::EscapeDataString($_) })
+        $value = 'vscode://file/' + ($encoded -join '/')
+    }
+    $uri = [Uri]$value
+    if ($uri.Scheme -ne 'vscode') { exit 1 }
+    $info = New-Object System.Diagnostics.ProcessStartInfo
+    $info.FileName = $value
+    $info.UseShellExecute = $true
+    [System.Diagnostics.Process]::Start($info) | Out-Null
+    exit 0 # somente envio ao SO; nunca prova de conversa iniciada
+} catch {
+    exit 1 # nunca devolver output livre, URI ou prompt
+}

package/lib/computador-adaptadores.mjs

@@ -0,0 +1,257 @@
+/** A12: composição real, receitas locais fechadas. Nada vindo do portal escolhe
+ * binário/argv/flags. Readiness Mac é provisória (processo + 5s/2s), não uma
+ * inspeção da janela/extensão. F02/F04 continuam como aceite de campo.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn, execFile } from 'node:child_process';
+import { setTimeout as sleep } from 'node:timers/promises';
+import { createEditorAdapter } from './computador-editor.mjs';
+import { createReplyAdapter } from './computador-resposta.mjs';
+import { createHistoryAdapter, resolveLocalTranscript } from './computador-historico.mjs';
+import { createGitAdapter, normalizeGitHubRepo } from './computador-git.mjs';
+import { validatePath } from './computador-caminhos.mjs';
+import * as folders from './computador-pastas.mjs';
+import * as plugins from './computador-plugin.mjs';
+
+const flags = ['abrirVscode', 'abrirClaude', 'retomarClaude', 'abrirCodex', 'retomarCodex',
+  'clonar', 'atualizarPasta', 'atualizarPlugin', 'seletorPasta', 'responderClaude', 'responderCodex', 'lerHistoricoClaude', 'lerHistoricoCodex'];
+const blocked = () => Object.assign(new Error('Esta conversa ou pasta está em uso por outro processo.'), { errorType: 'editor', motivo: 'conversa_em_uso' });
+const uuid = value => typeof value === 'string' && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu.test(value);
+
+export async function createComputerAdapters(deps = {}) {
+  const { platform = process.platform, fsImpl = fs, home = os.homedir(), env = process.env,
+    spawnImpl = spawn, execFileImpl = execFile, killImpl = process.kill.bind(process), journal } = deps;
+  const now = deps.clock?.now ?? Date.now;
+  const delay = deps.clock?.sleep ?? ((ms, signal) => sleep(ms, undefined, { signal }));
+  const repeat = deps.clock?.setInterval ?? setInterval, unrepeat = deps.clock?.clearInterval ?? clearInterval;
+  const capabilityDetails = Object.fromEntries(flags.map(flag => [flag, { enabled: false, reason: 'Receita Windows sem ensaio de campo; capacidade desligada.' }]));
+  if (platform !== 'darwin') {
+    const unavailable = async () => { throw new Error('Receita Windows sem ensaio de campo.'); };
+    return { editor: createEditorAdapter({ platform, spawnImpl }), reply: createReplyAdapter({ platform }),
+      history: { capabilities: { lerHistoricoClaude: false, lerHistoricoCodex: false }, read: unavailable },
+      folders: { ...folders, capabilities: { seletorPasta: false }, chooseFolder: unavailable },
+      git: {}, plugins: {}, capabilityDetails };
+  }
+  // launchd does not inherit the login-shell PATH. Keep personal credentials,
+  // and make shebangs such as /usr/bin/env node use the resident's own Node.
+  const directories = [...new Set([path.dirname(process.execPath), ...(env.PATH ?? '').split(path.delimiter),
+    ...(deps.binaryDirectories ?? [path.join(home, '.local/bin'), '/opt/homebrew/bin', '/usr/local/bin'])])].filter(p => path.isAbsolute(p));
+  const commandEnv = { ...env, PATH: directories.join(path.delimiter) };
+  function probe(binary, argv, signal) {
+    return new Promise((resolve, reject) => execFileImpl(binary, argv, {
+      shell: false, timeout: 3000, maxBuffer: 1024 * 1024, encoding: 'utf8',
+      env: commandEnv,
+      stdio: ['ignore', 'pipe', 'ignore'], ...(signal ? { signal } : {}),
+    }, (error, output) => error ? reject(error) : resolve(output)));
+  }
+  async function processes(signal) {
+    const output = await probe('/bin/ps', ['-U', String(process.getuid()), '-o', 'pid=,ppid=,pgid=,comm='], signal);
+    if (!output.trim()) throw blocked();
+    return output.split('\n').filter(line => line.trim()).map(line => {
+      const m = line.match(/^\s*(\d+)\s+(\d+)\s+(\d+)\s+(.+)$/u);
+      if (!m) throw blocked(); // unknown inventory never proves closure
+      return { pid: Number(m[1]), ppid: Number(m[2]), group: Number(m[3]), command: m[4] };
+    });
+  }
+  const isCode = row => /\/Visual Studio Code\.app\//u.test(row.command);
+  const isCandidate = row => row.pid !== process.pid &&
+    /(?:^|\/)(?:claude(?:\.exe)?|codex|node(?:js)?)(?:$|\s)/u.test(row.command);
+  async function writerConflict({ sessionKey, path: sessionPath, signal, owner }) {
+    const rows = await processes(signal);
+    // Read the live owner after ps: this probe may have started before spawn.
+    const owned = new Set(Number.isSafeInteger(owner?.pid) ? [owner.pid] : []);
+    let added;
+    do {
+      added = false;
+      for (const row of rows) if (owned.has(row.ppid) && !owned.has(row.pid)) {
+        owned.add(row.pid); added = true;
+      }
+    } while (added);
+    const candidates = rows.filter(row => !owned.has(row.pid) && row.group !== owner?.group && isCandidate(row));
+    if (!candidates.length) return false;
+    const output = await probe('/bin/ps', ['-ww', '-p', candidates.map(row => row.pid).join(','), '-o', 'pid=,args='], signal);
+    const argumentsByPid = new Map(output.split('\n').flatMap(line => {
+      const match = line.match(/^\s*(\d+)\s+(.+)$/u);
+      return match ? [[Number(match[1]), match[2]]] : [];
+    }));
+    const writers = candidates.filter(row => {
+      const args = argumentsByPid.get(row.pid);
+      // A missing argument inventory cannot prove this candidate is unrelated.
+      if (!args || !/(?:^|\/)node(?:js)?$/u.test(row.command)) return true;
+      const script = args.trim().split(/\s+/u).slice(1).find(arg => !arg.startsWith('-')) ?? '';
+      return /(?:^|[/@])(?:claude|claude-code|codex)(?:[/.]|$)/u.test(script);
+    });
+    if (!writers.length) return false;
+    if (writers.some(row => (argumentsByPid.get(row.pid) ?? '').split(/[^a-z0-9-]+/iu)
+      .some(arg => arg.toLowerCase() === sessionKey.toLowerCase()))) return true;
+    let cwdOutput = '';
+    try {
+      cwdOutput = await probe('/usr/sbin/lsof', ['-a', '-d', 'cwd', '-p', writers.map(row => row.pid).join(','), '-Fn'], signal);
+    } catch { /* Check each unreadable candidate below; it may have exited during lsof. */ }
+    const cwds = new Map(); let pid;
+    for (const line of cwdOutput.split('\n')) {
+      if (/^p\d+$/u.test(line)) pid = Number(line.slice(1));
+      else if (line.startsWith('n') && pid) cwds.set(pid, line.slice(1));
+    }
+    return writers.some(row => {
+      try {
+        const cwd = fsImpl.realpathSync(cwds.get(row.pid)), relative = path.relative(sessionPath, cwd);
+        return relative === '' || (relative !== '..' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative));
+      } catch {
+        try { killImpl(row.pid, 0); }
+        catch (e) { if (e.code === 'ESRCH') return false; }
+        console.warn('Responder pelo portal: conversa_em_uso (cwd de processo candidato ilegível).');
+        return true;
+      }
+    });
+  }
+  function executable(name) {
+    for (const dir of directories) {
+      const file = path.join(dir, name);
+      try { fsImpl.accessSync(file, fs.constants.X_OK); if (fsImpl.statSync(file).isFile()) return file; } catch { /* absent */ }
+    }
+    return null;
+  }
+  const claude = executable('claude'), codex = executable('codex');
+  let codexResume = false;
+  if (codex) {
+    try { codexResume = /Usage:\s*codex exec resume\b[^\n]*\[SESSION_ID\][^\n]*\[PROMPT\]/u.test(await probe(codex, ['exec', 'resume', '--help'])); }
+    catch { /* no guessed fallback to interactive resume */ }
+  }
+  const history = createHistoryAdapter({ fsImpl, home, clock: deps.clock });
+  async function localSessionExists(args) {
+    let fd;
+    try {
+      const file = await resolveLocalTranscript({ ...args, fsImpl, home });
+      if (!file) return false;
+      if (args.harness !== 'claude' || !args.requireProject) return true;
+      // Preserve the older automatic-binding proof's first-100-lines bound.
+      // Path resolution, symlink/identity checks remain in the shared reader.
+      fd = fsImpl.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+      const header = Buffer.alloc(65536), size = fsImpl.readSync(fd, header, 0, header.length, 0);
+      return header.subarray(0, size).toString('utf8').split('\n').slice(0, 100).some(line => {
+        try {
+          const cwd = JSON.parse(line)?.cwd;
+          return typeof cwd === 'string' && path.isAbsolute(cwd) && fsImpl.realpathSync(cwd) === fsImpl.realpathSync(args.path);
+        } catch { return false; }
+      });
+    }
+    catch { return false; } // Existing editor interface is a closed boolean proof.
+    finally { if (fd !== undefined) fsImpl.closeSync(fd); }
+  }
+  // inspectRepo may fetch upstream refs. History needs only local root/origin
+  // evidence, so keep this read-only path separate from the opening snapshot.
+  async function validateOrigin({ path: candidate, expectedRepo, authorization, signal }) {
+    const cwd = validatePath({ candidate, ...authorization, platform, fsImpl });
+    const expected = normalizeGitHubRepo(expectedRepo);
+    const localEnv = Object.fromEntries(Object.entries(commandEnv).filter(([key]) => !key.startsWith('GIT_')));
+    const read = argv => new Promise((resolve, reject) => execFileImpl('/usr/bin/git', ['--no-optional-locks', ...argv], {
+      cwd, env: localEnv, shell: false, timeout: 3000, maxBuffer: 65536, encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'], ...(signal ? { signal } : {}),
+    }, (error, output) => error ? reject(Object.assign(new Error('Não foi possível conferir o origin local.'), { code: 'GIT_STATE' })) : resolve(output.trim())));
+    if (fsImpl.realpathSync(await read(['rev-parse', '--show-toplevel'])) !== cwd) throw Object.assign(new Error('Escolha a raiz do repositório.'), { code: 'GIT_NOT_ROOT' });
+    const origin = await read(['config', '--local', '--no-includes', '--get-all', 'remote.origin.url']);
+    if (normalizeGitHubRepo(origin) !== expected) throw Object.assign(new Error('Origin local divergente.'), { code: 'GIT_WRONG_REPO' });
+    if (validatePath({ candidate, ...authorization, platform, fsImpl }) !== cwd) throw Object.assign(new Error('Pasta local divergente.'), { code: 'PATH_NOT_AUTHORIZED' });
+  }
+  let readyAt = Infinity, openedPath = null, exclusion = null;
+  const rawEditor = createEditorAdapter({ platform, spawnImpl, localSessionExists,
+    readinessProbe: async ({ path: candidate, signal }) => {
+      if (candidate !== openedPath) return { ready: false, path: candidate };
+      if (now() < readyAt) await delay(readyAt - now(), signal);
+      return { ready: (await processes(signal)).some(isCode) && now() >= readyAt, path: candidate };
+    },
+    codexRecipe: { target: 'app',
+      newUri: ({ path: cwd, prompt }) => `codex://threads/new?path=${encodeURIComponent(cwd)}&prompt=${encodeURIComponent(prompt)}&mode=codex`,
+      resumeUri: ({ sessionKey }) => {
+        if (!uuid(sessionKey)) throw new Error('UUID Codex inválido.');
+        return `codex://threads/${sessionKey}`;
+      } },
+  });
+  const editor = { ...rawEditor,
+    hasLocalSessionInProject: args => localSessionExists({ ...args, requireProject: true }),
+    async openFolder(args) {
+      if (exclusion) throw blocked();
+      const wasOpen = (await processes(args.signal)).some(isCode);
+      await rawEditor.openFolder(args);
+      openedPath = args.path; readyAt = now() + (wasOpen ? 2000 : 5000);
+    },
+    async openNew(args) { if (exclusion) throw blocked(); return rawEditor.openNew(args); },
+    async resume(args) { if (exclusion) throw blocked(); return rawEditor.resume(args); },
+  };
+  const ownedGroups = new WeakMap(), failedLaunches = new WeakSet();
+  const reply = createReplyAdapter({ platform, fsImpl, clock: deps.replyClock,
+    spawnImpl(binary, argv, options) {
+      const child = spawnImpl(binary, argv, { ...options, env: commandEnv });
+      ownedGroups.set(child, child.pid);
+      child.once('error', () => { if (child.pid == null) failedLaunches.add(child); });
+      if (exclusion) { exclusion.pid = child.pid; exclusion.group = child.pid; }
+      return child;
+    },
+    recipes: { ...(claude ? { claude: { verified: true, platform, binary: claude } } : {}),
+      ...(codexResume ? { codex: { verified: true, platform, binary: codex,
+        argv: ({ sessionKey, texto }) => ['exec', 'resume', sessionKey, '--', texto] } } : {}) },
+    async acquireEditorExclusion({ sessionKey, path: sessionPath, signal, onConflict }) {
+      if (exclusion) throw blocked();
+      const guard = { pid: null, group: null }; exclusion = guard;
+      let timer, checking = false;
+      try {
+        if (await writerConflict({ sessionKey, path: sessionPath, signal })) throw blocked();
+        timer = repeat(async () => {
+          if (checking || exclusion !== guard) return;
+          checking = true;
+          try {
+            if (await writerConflict({ sessionKey, path: sessionPath, owner: guard })) onConflict(blocked());
+          } catch { onConflict(blocked()); }
+          finally { checking = false; }
+        }, 100);
+        timer?.unref?.();
+        return { closed: true, release() { unrepeat(timer); if (exclusion === guard) exclusion = null; } };
+      } catch (e) { if (timer) unrepeat(timer); if (exclusion === guard) exclusion = null; throw e; }
+    },
+    processTree: {
+      async stop(child) {
+        if (failedLaunches.has(child)) return;
+        const group = ownedGroups.get(child);
+        if (!Number.isSafeInteger(group) || group <= 1) throw blocked();
+        try { killImpl(-group, 'SIGTERM'); } catch (e) { if (e.code !== 'ESRCH') throw e; }
+        await delay(500);
+        try { killImpl(-group, 0); } catch (e) { if (e.code === 'ESRCH') return; throw e; }
+        try { killImpl(-group, 'SIGKILL'); } catch (e) { if (e.code !== 'ESRCH') throw e; }
+      },
+      async confirmExited(child) {
+        if (failedLaunches.has(child)) return true;
+        const group = ownedGroups.get(child);
+        if (!Number.isSafeInteger(group) || group <= 1) return false;
+        try { killImpl(-group, 0); return false; } catch (e) { return e.code === 'ESRCH'; }
+      },
+    },
+  });
+  for (const flag of flags) capabilityDetails[flag] = { enabled: true,
+    target: flag.startsWith('lerHistorico') ? 'filesystem' : flag.includes('Codex') && !flag.startsWith('responder') ? 'app'
+      : flag.startsWith('responder') || ['clonar', 'atualizarPasta', 'atualizarPlugin'].includes(flag) ? 'cli'
+        : flag === 'seletorPasta' ? 'native' : 'vscode' };
+  for (const [flag, on] of Object.entries(reply.capabilities)) {
+    capabilityDetails[flag] = { enabled: on, target: 'cli', ...(!on
+      ? { reason: flag === 'responderClaude' ? 'Claude CLI executável ausente na instalação local.' : 'Codex exec resume não interativo não comprovado pelo --help instalado.' }
+      : { pending: 'F04: exclusão externa e histórico ainda sem aceite de campo; guarda conservadora de processos.' }) };
+  }
+  capabilityDetails.abrirCodex.pending = capabilityDetails.retomarCodex.pending = 'Extensão VS Code sem receita comprovada; abertura pelo app.';
+  journal?.recordRecipe({ id: 'mac_vscode_readiness', status: 'provisoria' });
+  const pluginSpawn = (binary, argv, options) => {
+    const executable = binary.endsWith('/claude') ? claude : codex;
+    if (!executable) throw Object.assign(new Error('CLI local ausente.'), { code: 'ENOENT' });
+    return spawnImpl(executable, argv, { ...options, env: commandEnv });
+  };
+  return { editor, reply, history, folders: { ...folders, capabilities: { seletorPasta: true },
+    chooseFolder: options => folders.chooseFolder({ ...options, platform, fsImpl, spawnImpl }),
+    adoptKnownFolder: options => folders.adoptKnownFolder({ ...options, platform, fsImpl, home, execFileImpl }) },
+    git: { ...createGitAdapter({ platform, fsImpl, spawnImpl: (binary, argv, options) =>
+      spawnImpl(binary, argv, { ...options, env: { ...options.env, PATH: commandEnv.PATH } }) }), validateOrigin },
+    plugins: {
+      readPluginVersions: (options = {}) => plugins.readPluginVersions({ ...options, platform, spawnImpl: pluginSpawn }),
+      updatePlugins: (options = {}) => plugins.updatePlugins({ ...options, platform, spawnImpl: pluginSpawn }),
+    }, capabilityDetails };
+}

package/lib/computador-caminhos.mjs

@@ -0,0 +1,93 @@
+/** Os anchors defaultRoot/registeredPath são caminhos CANÔNICOS do espelho local
+ * confirmado, nunca strings recebidas da configuração/browser. Reexecutar esta
+ * função imediatamente antes de cada efeito; seu retorno não é um lease de FS.
+ * fsImpl tem a interface síncrona realpathSync/statSync de node:fs.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+const grants = new WeakSet();
+// Windows/F02 candidato: a prova de volume é uma operação estática, nunca shell.
+// Doubles must explicitly prove a local volume; missing/unknown fails closed.
+function localVolume(candidate, fsImpl) {
+  if (fsImpl !== fs) return fsImpl.isLocalVolume?.(candidate) === true;
+  try {
+    return execFileSync('C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe', [
+      '-NoLogo', '-NoProfile', '-NonInteractive', '-File',
+      fileURLToPath(new URL('./computador-escolher-pasta.ps1', import.meta.url)), '-CheckPath', candidate,
+    ], { encoding: 'utf8', shell: false, windowsHide: true, timeout: 10_000, stdio: ['ignore', 'pipe', 'ignore'] }).trim() === 'local';
+  } catch { return false; }
+}
+export const pathError = () => Object.assign(new Error('Pasta local não autorizada ou inválida.'), { code: 'PATH_NOT_AUTHORIZED' });
+function rules(platform) {
+  if (!['darwin', 'win32'].includes(platform)) throw pathError();
+  return platform === 'win32' ? path.win32 : path.posix;
+}
+function lexical(value, platform) {
+  const p = rules(platform);
+  if (typeof value !== 'string' || !value || /[\x00-\x1f\x7f]/u.test(value) || value.startsWith('-') || !p.isAbsolute(value)) throw pathError();
+  if (value.split(/[\\/]/u).includes('..')) throw pathError();
+  if (platform === 'win32') {
+    if (!/^[a-z]:[\\/]/iu.test(value) || value.slice(2).includes(':')) throw pathError();
+    if (value.slice(3).split(/[\\/]/u).some(s => /[. ]$/u.test(s) || /[<>"|?*]/u.test(s) || /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/iu.test(s))) throw pathError();
+  } else if (value.startsWith('//') || /^\/(mnt|net|Volumes)\//u.test(value)) {
+    // Fail closed for network/WSL mounts; local external-volume support needs a field probe.
+    throw pathError();
+  }
+  return p.normalize(value);
+}
+/** Resolve o ancestral existente mais próximo; ENOTDIR/EACCES não são ausência. */
+export function canonicalizePath({ candidate, platform = process.platform, fsImpl = fs }) {
+  const p = rules(platform), normalized = lexical(candidate, platform), missing = [];
+  let ancestor = normalized;
+  for (;;) {
+    try {
+      const real = lexical(fsImpl.realpathSync(ancestor), platform);
+      if (platform === 'win32' && !localVolume(real, fsImpl)) throw pathError();
+      if (!fsImpl.statSync(ancestor).isDirectory()) throw pathError();
+      return p.join(real, ...missing);
+    } catch (e) {
+      if (e.code !== 'ENOENT') throw pathError();
+      // A dangling symlink must not be treated as a new clone directory.
+      if (fsImpl.lstatSync) {
+        try { fsImpl.lstatSync(ancestor); throw pathError(); }
+        catch (entry) { if (entry.code !== 'ENOENT') throw pathError(); }
+      }
+      const parent = p.dirname(ancestor);
+      if (parent === ancestor) throw pathError();
+      missing.unshift(p.basename(ancestor)); ancestor = parent;
+    }
+  }
+}
+function inside(candidate, root, p) {
+  // realpath has already asked the volume for canonical case. Do not lowercase:
+  // Windows supports case-sensitive directories, even on the same drive.
+  const parts = value => value.split(p.sep).filter(Boolean);
+  const a = parts(candidate), b = parts(root);
+  return b.length <= a.length && b.every((s, i) => s === a[i]);
+}
+export function validatePath({ candidate, defaultRoot, registeredPath, nativeGrant, platform = process.platform, fsImpl = fs }) {
+  const p = rules(platform), input = lexical(candidate, platform);
+  const canonicalPath = canonicalizePath({ candidate: input, platform, fsImpl });
+  const anchor = value => {
+    const normalized = lexical(value, platform);
+    const current = canonicalizePath({ candidate: normalized, platform, fsImpl });
+    // Stored anchors were canonical when confirmed; never follow a replacement link.
+    return normalized === current ? current : null;
+  };
+  if (defaultRoot) {
+    const root = anchor(defaultRoot);
+    // Compare canonical segment names supplied by the filesystem; the lexical
+    // check uses realpath on the existing ancestor too, so volume casing works.
+    if (root && inside(canonicalPath, root, p)) return canonicalPath;
+  }
+  if (registeredPath && anchor(registeredPath) === canonicalPath) return canonicalPath;
+  if (nativeGrant && grants.has(nativeGrant) && nativeGrant.canonicalPath === canonicalPath && anchor(canonicalPath)) return canonicalPath;
+  throw pathError();
+}
+// Only the local selector/grant store calls this; JSON from the portal cannot
+// carry the in-process capability. No grant IDs or flags authorize by themselves.
+export function localGrant(canonicalPath) {
+  const grant = Object.freeze({ canonicalPath }); grants.add(grant); return grant;
+}