@orkastery/cli 0.5.0 → 0.5.3

package/dist/leases.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * Leases de exclusao mutua entre threads (`.orkastery/leases/<nome>.json`).
+ * Leases de exclusao mutua entre threads (`.orkastery/leases/<nome>.json` da raiz do projeto).
  *
  * O lease `main-tree` serializa o SHIP: com N threads paralelas, so uma mergeia por vez.
  * A aquisicao e atomica de verdade (`open` com flag `wx`, que falha se o arquivo existe),
@@ -13,6 +13,11 @@
  * `path:<glob>`, `board:<card>` e `service:<porta>`, e uma FILA por colisao. Duas threads
  * que pedem a mesma regiao de path nao brigam: a segunda entra na fila em FIFO e recebe
  * o motivo tipado `lease.busy` com a correcao acionavel.
+ *
+ * RM-036 (fatia dos leases): todas as familias, e a fila, moram no estado CANONICO do projeto
+ * (`raizDoEstado`), como o `exec:` da I-36. O `ork` acha a raiz subindo do cwd e a worktree tem
+ * o proprio manifesto: com a pasta do checkout de quem chamava, um `ork` da raiz e outro da
+ * worktree pegavam o mesmo lease ao mesmo tempo.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -55,6 +60,8 @@ exports.nomeDeLease = nomeDeLease;
 exports.tipoDoLease = tipoDoLease;
 exports.alvoDoLease = alvoDoLease;
 exports.caminhoLease = caminhoLease;
+exports.argumentoDeLease = argumentoDeLease;
+exports.dirsLegadosDeLeases = dirsLegadosDeLeases;
 exports.regravarLease = regravarLease;
 exports.lerLease = lerLease;
 exports.expirado = expirado;
@@ -78,8 +85,11 @@ exports.adquirirRegiao = adquirirRegiao;
 exports.tabelaDeLeases = tabelaDeLeases;
 exports.soltarDaThread = soltarDaThread;
 exports.soltarThreadFechada = soltarThreadFechada;
+exports.podarRegioesDeThreadsFechadas = podarRegioesDeThreadsFechadas;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const node_child_process_1 = require("node:child_process");
 const manifest_1 = require("./manifest");
 const estado_thread_1 = require("./estado-thread");
 const util_1 = require("./util");
@@ -102,17 +112,21 @@ exports.FAMILIAS_DE_LEASE = {
 };
 /** I-36 (D1): prefixo da familia de execucao, `exec:<thread>`. */
 exports.PREFIXO_EXEC = 'exec';
-/** Diretorio dos leases do projeto. */
+/**
+ * Diretorio dos leases do projeto: o `.orkastery/leases` da raiz do estado, o mesmo das threads,
+ * chamado da raiz ou de qualquer worktree (RM-036, D1 do PLAN). Com o diretorio do checkout, cada
+ * um teria o seu e os dois segurariam o mesmo lease. Fora de repositorio git, `raizDoEstado`
+ * devolve a propria raiz.
+ */
 function dirLeases(raiz) {
-    return path.join((0, manifest_1.dirEstado)(raiz), 'leases');
+    return path.join((0, manifest_1.dirEstado)((0, estado_thread_1.raizDoEstado)(raiz)), 'leases');
 }
 /**
- * I-36: o lease de execucao mora no estado CANONICO do projeto (o mesmo das threads), nunca no
- * checkout de quem chamou. Um canal que roda da raiz e outro que roda de uma worktree disputam o
- * mesmo arquivo; com o diretorio do checkout, cada um teria o seu e os dois executariam juntos.
+ * I-36: o lease de execucao mora no estado CANONICO do projeto, nunca no checkout de quem chamou.
+ * Desde a RM-036 todas as familias moram la; o nome segue para quem ja o importava.
  */
 function dirLeasesDeExecucao(raiz) {
-    return path.join((0, manifest_1.dirEstado)((0, estado_thread_1.raizDoEstado)(raiz)), 'leases');
+    return dirLeases(raiz);
 }
 /**
  * Nome canonico de um lease de familia tipada: `path:core/src/**`, `service:5173`.
@@ -148,8 +162,191 @@ function alvoDoLease(nome) {
  * inalterado, o que preserva os leases gravados pelo bloco B1.
  */
 function caminhoLease(raiz, nome) {
-    const dir = tipoDoLease(nome) === 'exec' ? dirLeasesDeExecucao(raiz) : dirLeases(raiz);
-    return path.join(dir, `${encodeURIComponent(nome)}.json`);
+    return path.join(dirLeases(raiz), `${encodeURIComponent(nome)}.json`);
+}
+// ---------------------------------------------------------------------------
+// RM-036: o legado, o que a versao anterior gravou no `.orkastery/leases` de uma worktree.
+// ---------------------------------------------------------------------------
+/** Diretorio de verdade: `lstat`, entao link simbolico nao conta. */
+function diretorioDeVerdade(caminho) {
+    try {
+        return fs.lstatSync(caminho).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/** Arquivo regular de verdade, nunca pelo link simbolico. */
+function arquivoDeVerdade(caminho) {
+    try {
+        return fs.lstatSync(caminho).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+/** Texto que pode sair no terminal, no monitor ou numa correcao de comando. */
+function textoSeguro(texto) {
+    return String(texto ?? '').replace(/[\p{Cc}\p{Cf}\u2028\u2029]/gu, '');
+}
+/** Um argumento literal de shell, inclusive quando vem da fila canonica. */
+function argumentoDeLease(texto) {
+    return `'${textoSeguro(texto).replace(/'/g, "'\\''")}'`;
+}
+/** O legado nao admite sintaxe de shell nem nomes arbitrariamente longos. */
+function nomeLegadoSeguro(nome) {
+    return typeof nome === 'string' && /^[A-Za-z0-9][A-Za-z0-9._/*?:@+-]{0,199}$/.test(nome);
+}
+/** A primeira consulta abre uma unica janela, mesmo sem legado; nunca a renova. */
+function janelaDoLegado(principal) {
+    const marcador = path.join(dirLeases(principal), '.legado');
+    try {
+        fs.mkdirSync(path.dirname(marcador), { recursive: true });
+        fs.closeSync(fs.openSync(marcador, 'wx'));
+    }
+    catch { /* EEXIST: outra chamada abriu a mesma janela; falha de leitura fecha. */ }
+    try {
+        const stat = fs.lstatSync(marcador);
+        return stat.isFile() && Date.now() - stat.mtimeMs < exports.TTL_PADRAO_MS;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * As pastas `.orkastery/leases` das worktrees registradas no git do projeto, onde a versao anterior
+ * gravava os leases pedidos de dentro delas. A lista vem do git (`.git/worktrees/<n>/gitdir`),
+ * nunca de argumento, e so entra diretorio de verdade, sem link simbolico em `.orkastery` nem em `leases`:
+ * a leitura do legado nunca e levada para fora; limpeza grava apenas marcas no canonico. O `.git` da worktree precisa apontar
+ * de volta ao registro. A janela de 30 min dispensa a varredura depois da troca de versao.
+ */
+function dirsLegadosDeLeases(raiz) {
+    const principal = (0, estado_thread_1.raizDoEstado)(raiz);
+    if (janelaDoLegado(principal) === false)
+        return [];
+    const registro = path.join(principal, '.git', 'worktrees');
+    let nomes;
+    try {
+        nomes = fs.readdirSync(registro);
+    }
+    catch {
+        return [];
+    }
+    const real = (dir) => { try {
+        return fs.realpathSync(dir);
+    }
+    catch {
+        return path.resolve(dir);
+    } };
+    const vistos = new Set([real(dirLeases(principal))]);
+    const dirs = [];
+    for (const nome of nomes.sort()) {
+        const entrada = path.join(registro, nome);
+        if (!diretorioDeVerdade(entrada) || !arquivoDeVerdade(path.join(entrada, 'gitdir')))
+            continue;
+        let gitdir;
+        try {
+            gitdir = fs.readFileSync(path.join(entrada, 'gitdir'), 'utf8').trim();
+        }
+        catch {
+            continue;
+        }
+        if (!gitdir)
+            continue;
+        const gitDaWorktree = path.resolve(entrada, gitdir);
+        if (path.basename(gitDaWorktree) !== '.git' || !arquivoDeVerdade(gitDaWorktree))
+            continue;
+        try {
+            const volta = /^gitdir: (.+)\s*$/.exec(fs.readFileSync(gitDaWorktree, 'utf8').trim());
+            if (!volta || real(path.resolve(path.dirname(gitDaWorktree), volta[1].trim())) !== real(entrada))
+                continue;
+        }
+        catch {
+            continue;
+        }
+        const estado = (0, manifest_1.dirEstado)(path.dirname(gitDaWorktree));
+        const dir = path.join(estado, 'leases');
+        if (!diretorioDeVerdade(estado) || !diretorioDeVerdade(dir) || vistos.has(real(dir)))
+            continue;
+        vistos.add(real(dir));
+        dirs.push(dir);
+    }
+    return dirs;
+}
+/** Legado e entrada nao confiavel: formato, nome do arquivo e prazo precisam concordar. */
+function lerLeaseLegado(caminho) {
+    let fd;
+    try {
+        fd = fs.openSync(caminho, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+        const stat = fs.fstatSync(fd);
+        if (!stat.isFile() || stat.size > 64 * 1024)
+            return null;
+        const lease = JSON.parse(fs.readFileSync(fd, 'utf8'));
+        if (!lease || !nomeLegadoSeguro(lease.nome) ||
+            path.basename(caminho) !== `${encodeURIComponent(lease.nome)}.json` || tipoDoLease(lease.nome) === 'exec' ||
+            typeof lease.thread !== 'string' || !/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/.test(lease.thread) ||
+            typeof lease.motivo !== 'string' || !Number.isSafeInteger(lease.pid) || lease.pid <= 0)
+            return null;
+        const inicio = Date.parse(lease.adquiridoEm), fim = Date.parse(lease.expiraEm);
+        if (!Number.isFinite(inicio) || !Number.isFinite(fim) ||
+            new Date(inicio).toISOString() !== lease.adquiridoEm || new Date(fim).toISOString() !== lease.expiraEm ||
+            inicio > Date.now() || fim <= inicio || fim - inicio > exports.TTL_PADRAO_MS + 1_000)
+            return null;
+        // Nao transporta campos extras (como conducao) de um arquivo gravavel pela worktree.
+        return { nome: lease.nome, thread: lease.thread, motivo: '(legado)', pid: lease.pid,
+            adquiridoEm: lease.adquiridoEm, expiraEm: lease.expiraEm };
+    }
+    catch {
+        return null;
+    }
+    finally {
+        if (fd !== undefined)
+            fs.closeSync(fd);
+    }
+}
+/** Descarte da geracao dev/ino/ctime; inode reutilizado nao herda o descarte anterior. */
+function marcaDeLegado(raiz, identidade) {
+    return path.join(dirLeases(raiz), `.legado-ignorado-${identidade.dev}-${identidade.ino}-${identidade.ctimeMs}`);
+}
+function legadoIgnorado(raiz, identidade) {
+    return arquivoDeVerdade(marcaDeLegado(raiz, identidade));
+}
+function ignorarLegado(raiz, caminho, identidade) {
+    try {
+        if (!diretorioDeVerdade(path.dirname(caminho)) || !diretorioDeVerdade(path.dirname(path.dirname(caminho))))
+            return false;
+        const atual = fs.lstatSync(caminho);
+        if (!atual.isFile() || atual.dev !== identidade.dev || atual.ino !== identidade.ino || atual.ctimeMs !== identidade.ctimeMs)
+            return false;
+        fs.writeFileSync(marcaDeLegado(raiz, identidade), '', { flag: 'wx' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** As copias legadas de um nome. O `exec:` nunca morou no legado (I-36). */
+function copiasLegadas(raiz, nome) {
+    if (tipoDoLease(nome) === 'exec')
+        return [];
+    const copias = [];
+    for (const dir of dirsLegadosDeLeases(raiz)) {
+        const caminho = path.join(dir, `${encodeURIComponent(nome)}.json`);
+        if (!arquivoDeVerdade(caminho))
+            continue;
+        let identidadeLegada;
+        try {
+            identidadeLegada = fs.lstatSync(caminho);
+        }
+        catch {
+            continue;
+        }
+        if (!identidadeLegada.isFile() || legadoIgnorado(raiz, identidadeLegada))
+            continue;
+        const lease = lerLeaseLegado(caminho);
+        copias.push({ caminho, lease: lease && lease.nome === nome ? lease : null, identidadeLegada });
+    }
+    return copias;
 }
 /**
  * I-36 (D3): regrava um lease que a propria operacao segura (renovacao do prazo e conversao do
@@ -162,11 +359,15 @@ function regravarLease(raiz, lease) {
     fs.writeFileSync(temporario, JSON.stringify(lease, null, 2) + '\n', { encoding: 'utf8', mode: 0o644 });
     fs.renameSync(temporario, caminho);
 }
-/** Le o lease em disco. Arquivo corrompido conta como lease ausente. */
+/**
+ * Le somente o arquivo canonico. Legado pode barrar uma aquisicao, nunca provar posse
+ * para ativacao de escrita nem substituir um arquivo canonico que sumiu durante uma liberacao.
+ */
 function lerLease(raiz, nome) {
-    const caminho = caminhoLease(raiz, nome);
-    if (!fs.existsSync(caminho))
-        return null;
+    return lerArquivoDeLease(caminhoLease(raiz, nome));
+}
+/** O arquivo de lease do estado canonico; ausente ou corrompido conta como lease ausente. */
+function lerArquivoDeLease(caminho) {
     try {
         return JSON.parse(fs.readFileSync(caminho, 'utf8'));
     }
@@ -174,6 +375,196 @@ function lerLease(raiz, nome) {
         return null;
     }
 }
+/** O criador exclusivo pode estar entre o open(wx) e a escrita do JSON. */
+function escritaRecente(caminho) {
+    try {
+        return Date.now() - fs.lstatSync(caminho).mtimeMs < 5_000;
+    }
+    catch {
+        return false;
+    }
+}
+/** Candidatos e temporarios pertencem ao mesmo namespace de PID do processo local. */
+function lerCandidatoRetomada(dir, nome) {
+    const match = /^(\d+)-[a-f0-9-]+\.json(\.tmp)?$/.exec(nome);
+    const pid = Number(match?.[1]);
+    if (!match || !Number.isSafeInteger(pid) || pid <= 0)
+        throw Object.assign(Error('candidato de retomada invalido'), { code: 'EPERM' });
+    let fd;
+    try {
+        fd = fs.openSync(path.join(dir, nome), fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+        const stat = fs.fstatSync(fd);
+        if (!stat.isFile() || stat.nlink !== 1 || stat.size > 1024)
+            throw Object.assign(Error('candidato inseguro'), { code: 'EPERM' });
+        // SIGKILL pode deixar JSON parcial: o temporario nao participa da ordem de tickets.
+        const ticket = match[2] ? null : JSON.parse(fs.readFileSync(fd, 'utf8')).ticket;
+        if (ticket !== null && (!Number.isSafeInteger(ticket) || ticket < 0))
+            throw Object.assign(Error('ticket invalido'), { code: 'EPERM' });
+        return { nome, pid, ticket, stat };
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return null;
+        throw e;
+    }
+    finally {
+        if (fd !== undefined)
+            fs.closeSync(fd);
+    }
+}
+/** Nomes nao se repetem. Ainda assim, nunca recolhe um inode substituido. */
+function recolherCandidato(dir, c) {
+    const arquivo = path.join(dir, c.nome), atual = fs.lstatSync(arquivo, { throwIfNoEntry: false });
+    if (atual?.isFile() && atual.nlink === 1 && atual.dev === c.stat.dev && atual.ino === c.stat.ino) {
+        try {
+            fs.unlinkSync(arquivo);
+        }
+        catch (e) {
+            if (e.code !== 'ENOENT')
+                throw e;
+        }
+    }
+}
+/**
+ * Bakery local e portatil, com prazo limitado a 30 min. Publica ticket zero e depois
+ * o ticket por rename atomico. Todo retomador participa, inclusive com flock.
+ * Candidato recolhido nao autoriza seu processo a continuar: a posse e revalidada
+ * na entrada da secao critica e imediatamente antes da conferencia final do lease.
+ */
+function comFilaDeRetomada(caminho, retomar) {
+    const dir = `${caminho}.retomadas`;
+    fs.mkdirSync(dir, { recursive: true });
+    if (!fs.lstatSync(dir).isDirectory())
+        throw Object.assign(Error('fila insegura'), { code: 'EPERM' });
+    const nome = `${process.pid}-${(0, node_crypto_1.randomUUID)()}.json`, arquivo = path.join(dir, nome);
+    const prazo = Date.now() + exports.TTL_PADRAO_MS;
+    const publicar = (ticket) => {
+        const tmp = `${arquivo}.tmp`;
+        try {
+            fs.writeFileSync(tmp, JSON.stringify({ ticket }), { flag: 'wx' });
+            fs.renameSync(tmp, arquivo);
+        }
+        finally {
+            try {
+                fs.unlinkSync(tmp);
+            }
+            catch (e) {
+                if (e.code !== 'ENOENT')
+                    throw e;
+            }
+        }
+    };
+    let recolheuExpirado = false;
+    const candidatos = () => {
+        const resultado = [];
+        for (const entrada of fs.readdirSync(dir)) {
+            const c = lerCandidatoRetomada(dir, entrada);
+            if (!c)
+                continue;
+            if (Date.now() - c.stat.mtimeMs >= exports.TTL_PADRAO_MS) {
+                recolherCandidato(dir, c);
+                recolheuExpirado = true;
+                continue;
+            }
+            try {
+                process.kill(c.pid, 0);
+            }
+            catch (e) {
+                if (e.code === 'ESRCH') {
+                    recolherCandidato(dir, c);
+                    continue;
+                }
+                // EPERM nao prova morte; o prazo limita a espera por PID inacessivel/reutilizado.
+            }
+            if (c.ticket !== null)
+                resultado.push({ nome: entrada, ticket: c.ticket });
+        }
+        return resultado;
+    };
+    try {
+        publicar(0);
+        const ticket = Math.max(0, ...candidatos().map((c) => c.ticket)) + 1;
+        if (recolheuExpirado)
+            return 'fila-expirada';
+        publicar(ticket);
+        const identidade = fs.lstatSync(arquivo);
+        const aindaCandidato = () => {
+            const atual = fs.lstatSync(arquivo, { throwIfNoEntry: false });
+            return Date.now() < prazo && !!atual?.isFile() && atual.nlink === 1 &&
+                atual.dev === identidade.dev && atual.ino === identidade.ino;
+        };
+        const outros = candidatos();
+        if (recolheuExpirado || !aindaCandidato())
+            return 'fila-expirada';
+        if (outros.some((c) => c.nome !== nome && (c.ticket === 0 || c.ticket < ticket ||
+            (c.ticket === ticket && c.nome < nome))))
+            return 'ocupado';
+        return retomar(aindaCandidato);
+    }
+    finally {
+        // Se ficar, outro retomador o recolhe por PID morto ou prazo; preservar resultado e erro original.
+        try {
+            fs.unlinkSync(arquivo);
+        }
+        catch { /* Melhor esforco: candidato remanescente sera recolhido. */ }
+        // rmdir e atomico e so remove uma pasta vazia; nunca remove candidato concorrente.
+        try {
+            fs.rmdirSync(dir);
+        }
+        catch { /* Melhor esforco: nao altera o resultado da retomada. */ }
+    }
+}
+/** O fd e a fila exclusiva ficam presos ao inode antigo ate concluir o novo wx. */
+function retomarArquivo(caminho, corpo) {
+    let fd;
+    try {
+        fd = fs.openSync(caminho, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+        const stat = fs.fstatSync(fd);
+        if (stat.nlink === 0)
+            return 'ocupado';
+        if (!stat.isFile() || stat.nlink !== 1)
+            return 'indisponivel';
+        try {
+            const trava = (0, node_child_process_1.spawnSync)('/usr/bin/flock', ['--exclusive', '--nonblock', '3'], { stdio: ['ignore', 'pipe', 'pipe', fd], timeout: 2_000 });
+            if (!trava.error && trava.status === 1)
+                return 'ocupado';
+        }
+        catch { /* Transporte ausente ou bloqueado: a fila portatil ainda serializa. */ }
+        const descritor = fd;
+        return comFilaDeRetomada(caminho, (aindaCandidato) => {
+            let atual = null;
+            try {
+                atual = JSON.parse(fs.readFileSync(descritor, 'utf8'));
+            }
+            catch { /* corrompido */ }
+            if ((atual && !expirado(atual)) || (!atual && Date.now() - fs.fstatSync(descritor).mtimeMs < 5_000))
+                return 'ocupado';
+            const agoraNoPath = fs.lstatSync(caminho);
+            if (!agoraNoPath.isFile() || agoraNoPath.dev !== stat.dev || agoraNoPath.ino !== stat.ino)
+                return 'ocupado';
+            if (!aindaCandidato())
+                return 'fila-expirada';
+            // Reconfere imediatamente antes do unlink; a primeira leitura pode ter envelhecido.
+            const antesDeApagar = fs.lstatSync(caminho);
+            if (!antesDeApagar.isFile() || antesDeApagar.dev !== stat.dev || antesDeApagar.ino !== stat.ino)
+                return 'ocupado';
+            fs.unlinkSync(caminho);
+            fs.writeFileSync(caminho, corpo, { encoding: 'utf8', flag: 'wx' });
+            return 'retomado';
+        });
+    }
+    catch (e) {
+        if (['ENOENT', 'EEXIST'].includes(e.code ?? ''))
+            return 'ocupado';
+        if (['ELOOP', 'EACCES', 'EPERM', 'ENOSYS'].includes(e.code ?? ''))
+            return 'indisponivel';
+        throw e;
+    }
+    finally {
+        if (fd !== undefined)
+            fs.closeSync(fd);
+    }
+}
 /** O lease venceu? */
 function expirado(lease, referencia = new Date()) {
     const fim = Date.parse(lease.expiraEm);
@@ -276,27 +667,37 @@ function adquirir(raiz, nome, opcoes) {
         expiraEm: new Date(Date.now() + ttl).toISOString(),
     };
     const corpo = JSON.stringify(lease, null, 2) + '\n';
-    for (const tentativa of [1, 2]) {
-        try {
-            // `wx` falha se o arquivo existe: e a atomicidade do lease, sem corrida.
-            fs.writeFileSync(caminho, corpo, { encoding: 'utf8', flag: 'wx' });
-            return { ok: true, lease, ocupadoPor: null, tomadoDeVencido: tentativa === 2 };
+    // So o legado valido e vivo barra, inclusive quando o MCP desliga a retomada do canonico.
+    let tomouLegado = false;
+    for (const copia of copiasLegadas(raiz, nome)) {
+        if (copia.lease && !expirado(copia.lease)) {
+            return { ok: false, lease: null, ocupadoPor: copia.lease, tomadoDeVencido: false };
         }
-        catch (e) {
-            if (e.code !== 'EEXIST')
-                throw e;
-            const atual = lerLease(raiz, nome);
-            if (opcoes.retomarVencido === false || (atual && !expirado(atual))) {
-                return { ok: false, lease: null, ocupadoPor: atual, tomadoDeVencido: false };
-            }
-            // Lease vencido ou corrompido: remove e tenta uma unica vez mais.
-            try {
-                fs.unlinkSync(caminho);
-            }
-            catch {
-                /* outra thread removeu antes; a segunda tentativa decide */
-            }
+        // Vencido nao barra: adquirir nunca apaga arquivos da worktree legada.
+        if (copia.lease)
+            tomouLegado = true;
+    }
+    try {
+        // `wx` falha se o arquivo existe: e a atomicidade do lease, sem corrida.
+        fs.writeFileSync(caminho, corpo, { encoding: 'utf8', flag: 'wx' });
+        return { ok: true, lease, ocupadoPor: null, tomadoDeVencido: tomouLegado };
+    }
+    catch (e) {
+        if (e.code !== 'EEXIST')
+            throw e;
+        const atual = lerLease(raiz, nome);
+        if (opcoes.retomarVencido === false || (atual && !expirado(atual)) || (!atual && escritaRecente(caminho))) {
+            return { ok: false, lease: null, ocupadoPor: atual, tomadoDeVencido: false };
         }
+        const retomada = retomarArquivo(caminho, corpo);
+        if (retomada === 'retomado')
+            return { ok: true, lease, ocupadoPor: null, tomadoDeVencido: true };
+        if (retomada === 'fila-expirada')
+            return { ok: false, lease: null, ocupadoPor: lerLease(raiz, nome),
+                tomadoDeVencido: false, falhaRetomada: 'lease.resume-unavailable', filaRetomadaExpirada: true };
+        if (retomada === 'indisponivel')
+            return { ok: false, lease: null, ocupadoPor: lerLease(raiz, nome),
+                tomadoDeVencido: false, falhaRetomada: 'lease.resume-unavailable' };
     }
     const atual = lerLease(raiz, nome);
     return { ok: false, lease: null, ocupadoPor: atual, tomadoDeVencido: false };
@@ -304,62 +705,125 @@ function adquirir(raiz, nome, opcoes) {
 /**
  * Libera o lease. Sem `forcar`, so a thread que o segura pode liberar: liberar o lease
  * dos outros e exatamente o bug que o lease existe para impedir.
+ *
+ * RM-036: release atua no canonico, quando presente. Sem canonico, apenas marca o inode legado
+ * como ignorado. Nunca apaga o legado nem limpa as duas origens no mesmo pedido.
  */
 function liberar(raiz, nome, thread, forcar = false) {
-    const atual = lerLease(raiz, nome);
-    if (!atual) {
+    const copias = [];
+    const canonico = caminhoLease(raiz, nome);
+    if (fs.lstatSync(canonico, { throwIfNoEntry: false })) {
+        copias.push({ caminho: canonico, lease: lerArquivoDeLease(canonico) });
+    }
+    if (copias.length === 0) {
+        for (const copia of copiasLegadas(raiz, nome))
+            copias.push(copia);
+    }
+    if (copias.length === 0) {
         sairDaFila(raiz, nome, thread);
         return { ok: true, detalhe: `lease ${nome} ja estava livre` };
     }
-    if (atual.thread !== thread && !forcar) {
+    const soltas = copias.filter((c) => forcar || c.lease?.thread === thread);
+    if (soltas.length === 0) {
         return {
             ok: false,
-            detalhe: `lease ${nome} pertence a thread ${atual.thread}; use --forcar para tomar`,
+            detalhe: `lease ${nome} pertence a thread ${textoSeguro(copias[0].lease?.thread ?? '(ilegivel)')}; use --forcar para tomar`,
         };
     }
-    fs.unlinkSync(caminhoLease(raiz, nome));
-    sairDaFila(raiz, nome, atual.thread);
+    const removidas = [];
+    for (const copia of soltas) {
+        try {
+            if (copia.identidadeLegada) {
+                if (!ignorarLegado(raiz, copia.caminho, copia.identidadeLegada))
+                    continue;
+            }
+            else
+                fs.unlinkSync(copia.caminho);
+            removidas.push(copia);
+        }
+        catch {
+            continue; // Nada saiu: nao anunciar liberacao nem retirar o dono da fila.
+        }
+        if (copia.lease)
+            sairDaFila(raiz, nome, copia.lease.thread);
+    }
+    if (removidas.length === 0)
+        return { ok: false, detalhe: `lease ${nome}: nada removido ou ignorado; consulte ork lease list` };
+    const outra = copias.find((c) => !removidas.includes(c));
     const proximo = proximoDaFila(raiz, nome);
     const seguinte = proximo ? `; proximo da fila: thread ${proximo.thread}` : '';
-    return { ok: true, detalhe: `lease ${nome} liberado${seguinte}` };
+    const resta = outra ? `; segue a copia da thread ${textoSeguro(outra.lease?.thread ?? '(ilegivel)')}` : '';
+    const acao = removidas.every((c) => c.identidadeLegada) ? 'legado ignorado (arquivo preservado)' : 'liberado';
+    return { ok: true, detalhe: `lease ${nome} ${acao}${seguinte}${resta}` };
 }
-/** Todos os leases existentes no projeto, pelo nome canonico gravado no arquivo. */
-function listarLeases(raiz) {
-    const leases = [];
-    const ler = (dir, soExecucao) => {
-        if (!fs.existsSync(dir))
+/** Os leases do estado canonico e os do legado das worktrees, canonico antes do legado no mesmo nome. */
+function leasesEmDisco(raiz) {
+    const saida = [];
+    const ler = (dir, legado) => {
+        let arquivos;
+        try {
+            arquivos = fs.readdirSync(dir);
+        }
+        catch {
             return;
-        for (const arquivo of fs.readdirSync(dir)) {
+        }
+        for (const arquivo of arquivos) {
             if (!arquivo.endsWith('.json') || arquivo === exports.NOME_ARQUIVO_FILA)
                 continue;
+            const caminho = path.join(dir, arquivo);
+            if (legado) {
+                let identidadeLegada;
+                try {
+                    identidadeLegada = fs.lstatSync(caminho);
+                }
+                catch {
+                    continue;
+                }
+                const lease = arquivoDeVerdade(caminho) ? lerLeaseLegado(caminho) : null;
+                // O `exec:` nunca morou no legado (I-36): arquivo de execucao ali nao e lease de versao nenhuma.
+                if (lease && identidadeLegada.isFile() && !legadoIgnorado(raiz, identidadeLegada) && tipoDoLease(lease.nome) !== 'exec')
+                    saida.push({ lease, caminho, legado: dir, identidadeLegada });
+                continue;
+            }
             try {
-                const lease = JSON.parse(fs.readFileSync(path.join(dir, arquivo), 'utf8'));
+                const lease = JSON.parse(fs.readFileSync(caminho, 'utf8'));
                 if (!lease || typeof lease.nome !== 'string')
                     continue;
-                if (soExecucao && tipoDoLease(lease.nome) !== 'exec')
-                    continue;
-                leases.push(lease);
+                saida.push({ lease, caminho, legado: null });
             }
             catch {
                 /* arquivo corrompido conta como lease ausente */
             }
         }
     };
-    // I-36: os do checkout, mais os de execucao do estado canonico quando ele e outro diretorio.
-    const local = dirLeases(raiz), canonico = dirLeasesDeExecucao(raiz);
-    const real = (dir) => (fs.existsSync(dir) ? fs.realpathSync(dir) : path.resolve(dir));
-    ler(local, false);
-    if (real(local) !== real(canonico))
-        ler(canonico, true);
-    return leases.sort((a, b) => a.nome.localeCompare(b.nome));
+    ler(dirLeases(raiz), false);
+    for (const dir of dirsLegadosDeLeases(raiz))
+        ler(dir, true);
+    return saida.sort((a, b) => a.lease.nome.localeCompare(b.lease.nome) || Number(a.legado !== null) - Number(b.legado !== null));
+}
+/**
+ * Leases do estado canonico e legados validos consultados durante a janela da troca.
+ * Vencidos podem aparecer para diagnostico; so os vivos disputam regioes.
+ */
+function listarLeases(raiz) {
+    return leasesEmDisco(raiz).map((e) => e.lease);
 }
 /** Leases ativos (nao vencidos) que colidem com o nome pedido. */
 function leasesColidentes(raiz, nome, thread) {
     return listarLeases(raiz).filter((l) => !expirado(l) && l.thread !== thread && leasesColidem(nome, l.nome));
 }
-/** Leases ativos segurados por uma thread. */
+/**
+ * Leases ativos segurados por uma thread, um por nome: a copia canonica antes da legada que a
+ * versao anterior deixou com o mesmo nome (RM-036).
+ */
 function leasesDaThread(raiz, thread) {
-    return listarLeases(raiz).filter((l) => l.thread === thread && !expirado(l));
+    const nomes = new Set();
+    return listarLeases(raiz).filter((l) => {
+        if (l.thread !== thread || expirado(l) || nomes.has(l.nome))
+            return false;
+        nomes.add(l.nome);
+        return true;
+    });
 }
 // ---------------------------------------------------------------------------
 // Fila por colisao.
@@ -370,23 +834,50 @@ exports.NOME_ARQUIVO_FILA = 'fila.json';
 function caminhoFila(raiz) {
     return path.join(dirLeases(raiz), exports.NOME_ARQUIVO_FILA);
 }
-/** Le a fila inteira, em ordem FIFO. Arquivo corrompido conta como fila vazia. */
-function lerFila(raiz) {
-    const caminho = caminhoFila(raiz);
-    if (!fs.existsSync(caminho))
-        return [];
+/** Le um arquivo de fila: so os pedidos bem formados. Ausente ou corrompido conta como fila vazia. */
+function lerArquivoDeFila(caminho) {
     try {
         const dados = JSON.parse(fs.readFileSync(caminho, 'utf8'));
-        return Array.isArray(dados) ? dados.sort((a, b) => a.desdeEm.localeCompare(b.desdeEm)) : [];
+        if (!Array.isArray(dados))
+            return null;
+        return dados.filter((p) => !!p && typeof p === 'object' &&
+            typeof p.nome === 'string' && typeof p.thread === 'string' &&
+            typeof p.desdeEm === 'string');
     }
     catch {
-        return [];
+        return null;
     }
 }
+/** A espera legada era local ao checkout: nao migra, refaz-se no proximo pedido. */
+function lerFila(raiz) {
+    const todos = lerArquivoDeFila(caminhoFila(raiz)) ?? [];
+    const vistos = new Set();
+    return todos.sort((a, b) => a.desdeEm.localeCompare(b.desdeEm)).filter((p) => {
+        const chave = JSON.stringify([p.thread, p.nome]);
+        if (vistos.has(chave))
+            return false;
+        vistos.add(chave);
+        return true;
+    });
+}
+/**
+ * Grava a fila canonica por arquivo temporario e rename (RM-036, D4): a raiz e as worktrees dividem
+ * esta fila, e a fila lida pela metade contava como vazia, sumindo com a espera de todos.
+ */
 function gravarFila(raiz, fila) {
     const caminho = caminhoFila(raiz);
     fs.mkdirSync(path.dirname(caminho), { recursive: true });
-    fs.writeFileSync(caminho, JSON.stringify(fila, null, 2) + '\n', 'utf8');
+    const temporario = `${caminho}.${process.pid}.${(0, node_crypto_1.randomUUID)()}.tmp`;
+    try {
+        fs.writeFileSync(temporario, JSON.stringify(fila, null, 2) + '\n', 'utf8');
+        fs.renameSync(temporario, caminho);
+    }
+    finally {
+        try {
+            fs.unlinkSync(temporario);
+        }
+        catch { /* ja virou a fila */ }
+    }
 }
 /** Coloca o pedido na fila (idempotente por thread e nome). Devolve a posicao, 1 = proxima. */
 function enfileirar(raiz, nome, dados) {
@@ -443,9 +934,20 @@ function adquirirRegiao(raiz, nome, opcoes) {
         podarThreadsFechadas(raiz, nome, opcoes.thread);
     }
     catch { /* a regra de colisao abaixo decide */ }
+    // Recusar a segunda copia nao cria espera atras de si mesmo, nem atras de quem ja espera por ela.
+    const proprio = copiasLegadas(raiz, nome).find((c) => c.lease?.thread === opcoes.thread && !expirado(c.lease));
+    if (proprio?.lease) {
+        sairDaFila(raiz, nome, opcoes.thread);
+        return { ...base, ok: false, ocupadoPor: proprio.lease, esperando: false, posicaoNaFila: 0,
+            colidiuCom: proprio.lease, motivo: 'lease.busy',
+            detalhe: `o lease legado "${nome}" ja pertence a thread ${opcoes.thread}`,
+            correcao: 'aguarde o prazo do legado ou o fim da janela de 30 min; o arquivo legado e preservado' };
+    }
     const colidentes = leasesColidentes(raiz, nome, opcoes.thread);
     if (colidentes.length > 0) {
         const dono = colidentes[0];
+        const legado = copiasLegadas(raiz, dono.nome).some((c) => c.lease?.thread === dono.thread &&
+            c.lease.adquiridoEm === dono.adquiridoEm);
         const posicao = enfileirar(raiz, nome, {
             thread: opcoes.thread,
             motivo: opcoes.motivo,
@@ -462,8 +964,9 @@ function adquirirRegiao(raiz, nome, opcoes) {
             motivo: 'lease.busy',
             detalhe: `a regiao "${nome}" colide com "${dono.nome}", que esta com a thread ${dono.thread} ` +
                 `desde ${dono.adquiridoEm}`,
-            correcao: `espere a thread ${dono.thread} liberar (posicao ${posicao} na fila), ` +
-                `ou reduza o glob da sua regiao, ou libere com: ork lease release "${dono.nome}" --forcar`,
+            correcao: legado ? 'aguarde o prazo do legado ou o fim da janela de 30 min; o arquivo legado e preservado' :
+                `espere a thread ${dono.thread} liberar (posicao ${posicao} na fila), ` +
+                    `ou reduza o glob da sua regiao, ou libere com: ork lease release ${argumentoDeLease(dono.nome)} --forcar`,
         };
     }
     // Fila vazia para a regiao? Entao adquire. Se ha fila e a vez nao e desta thread,
@@ -505,9 +1008,13 @@ function adquirirRegiao(raiz, nome, opcoes) {
             esperando: true,
             posicaoNaFila: posicao,
             colidiuCom: dono,
-            motivo: 'lease.busy',
-            detalhe: `o lease "${nome}" esta com a thread ${dono?.thread ?? '(desconhecida)'}`,
-            correcao: `espere a vez (posicao ${posicao} na fila) ou: ork lease release "${nome}" --forcar`,
+            falhaRetomada: r.falhaRetomada,
+            filaRetomadaExpirada: r.filaRetomadaExpirada,
+            motivo: r.falhaRetomada ?? 'lease.busy',
+            detalhe: r.filaRetomadaExpirada ? `fila de retomada do lease \"${nome}\" excedeu 30 min; candidatos expirados recolhidos` : r.falhaRetomada ? `retomada indisponivel para o lease "${nome}"; use --forcar para liberar explicitamente` :
+                `o lease "${nome}" esta com a thread ${dono?.thread ?? '(desconhecida)'}`,
+            correcao: r.filaRetomadaExpirada ? 'consulte ork lease list; depois repita a aquisicao' : r.falhaRetomada ? `ork lease release ${argumentoDeLease(nome)} --forcar; depois repita a aquisicao` :
+                `espere a vez (posicao ${posicao} na fila) ou: ork lease release ${argumentoDeLease(nome)} --forcar`,
         };
     }
     sairDaFila(raiz, nome, opcoes.thread);
@@ -526,39 +1033,104 @@ function adquirirRegiao(raiz, nome, opcoes) {
 }
 /** Texto de `ork lease list`: leases ativos, familias e a fila por colisao. */
 function tabelaDeLeases(raiz) {
-    const leases = listarLeases(raiz);
+    const emDisco = leasesEmDisco(raiz);
     const fila = lerFila(raiz);
     const linhas = ['Leases do projeto', ''];
-    if (leases.length === 0) {
+    const principal = (0, estado_thread_1.raizDoEstado)(raiz);
+    if (emDisco.length === 0) {
         linhas.push('  Nenhum lease tomado. O merge na base esta liberado.');
     }
     else {
-        for (const l of leases) {
+        for (const { lease: l, legado } of emDisco) {
             const situacao = expirado(l) ? 'VENCIDO (tomavel)' : 'ativo';
-            linhas.push(`  ${l.nome.padEnd(28)} [${tipoDoLease(l.nome)}] thread ${l.thread.padEnd(18)} ${situacao}`);
+            linhas.push(`  ${textoSeguro(l.nome).padEnd(28)} [${tipoDoLease(l.nome)}] thread ${textoSeguro(l.thread).padEnd(18)} ${situacao}`);
             linhas.push(`    desde ${(0, horario_1.formatarDataHora)(l.adquiridoEm)} ate ${(0, horario_1.formatarDataHora)(l.expiraEm)} (pid ${l.pid})`);
-            linhas.push(`    motivo: ${l.motivo}`);
+            linhas.push(`    motivo: ${textoSeguro(l.motivo)}`);
+            // RM-036: a copia antiga e somente lida, ate vencer ou encerrar a janela.
+            if (legado) {
+                const relativo = path.relative(principal, legado);
+                const onde = relativo && !relativo.startsWith('..') && !path.isAbsolute(relativo) ? relativo : legado;
+                linhas.push(`    legado: ${textoSeguro(onde)} (vale enquanto vivo, dentro da janela de 30 min da troca)`);
+            }
             // I-36: o lease de execucao diz quem conduz, com a mesma linha das outras superficies.
             const conducao = (0, conducao_texto_1.conducaoDoLease)(l);
             if (conducao)
                 linhas.push(`    ${(0, conducao_texto_1.linhaDeConducao)(conducao)}`);
         }
     }
+    // Diagnosticos nunca entram em listarLeases: arquivo invalido nao disputa regiao nem prova posse.
+    for (const dir of dirsLegadosDeLeases(raiz)) {
+        let arquivos;
+        try {
+            arquivos = fs.readdirSync(dir);
+        }
+        catch {
+            continue;
+        }
+        for (const arquivo of arquivos.sort()) {
+            const caminho = path.join(dir, arquivo);
+            if (!arquivo.endsWith('.json') || arquivo === exports.NOME_ARQUIVO_FILA ||
+                !arquivoDeVerdade(caminho) || lerLeaseLegado(caminho))
+                continue;
+            try {
+                if (legadoIgnorado(raiz, fs.lstatSync(caminho)))
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            let nome;
+            try {
+                nome = decodeURIComponent(arquivo.slice(0, -5));
+            }
+            catch {
+                nome = arquivo.slice(0, -5);
+            }
+            if (tipoDoLease(nome) === 'exec')
+                continue;
+            linhas.push(`  legado: ${textoSeguro(arquivo)} INVALIDO ou ILEGIVEL (ignorado)`);
+            linhas.push('    arquivo legado preservado; ignorado sem alterar o lease canonico');
+        }
+    }
     linhas.push('');
+    // Consulta nao recolhe candidatos: mostra a fila, inclusive sobras de SIGKILL.
+    const pasta = dirLeases(raiz);
+    const retomadas = fs.existsSync(pasta) ? fs.readdirSync(pasta).filter((n) => n.endsWith('.json.retomadas')).sort() : [];
+    linhas.push(`Fila de retomada: ${retomadas.length === 0 ? 'vazia' : `${retomadas.length} lease(s)`}`);
+    for (const nome of retomadas) {
+        const dir = path.join(pasta, nome);
+        linhas.push(`  ${textoSeguro(nome)}`);
+        try {
+            if (!fs.lstatSync(dir).isDirectory())
+                throw Error('fila insegura');
+            for (const entrada of fs.readdirSync(dir).sort()) {
+                const c = lerCandidatoRetomada(dir, entrada);
+                if (!c)
+                    continue;
+                const idade = Math.max(0, Date.now() - c.stat.mtimeMs), vencido = idade >= exports.TTL_PADRAO_MS;
+                linhas.push(`    ${textoSeguro(c.nome)} pid ${c.pid} ${c.ticket === null ? 'temporario' : `ticket ${c.ticket}`} idade ${Math.floor(idade / 1000)}s`);
+                if (vencido)
+                    linhas.push('      lease.resume-unavailable: prazo de 30 min excedido; repita a aquisicao para recolher e consulte ork lease list');
+            }
+        }
+        catch {
+            linhas.push('    lease.resume-unavailable: fila ilegivel ou insegura; inspecione candidatos antes de repetir a aquisicao');
+        }
+    }
     const merge = fila.filter((p) => p.tipo === 'main-tree');
     const regiao = fila.filter((p) => p.tipo !== 'main-tree');
     linhas.push(`Fila de merge (lease ${exports.LEASE_MAIN_TREE}): ${merge.length === 0 ? 'vazia' : `${merge.length} na espera`}`);
     merge.forEach((p, i) => {
-        linhas.push(`  ${i + 1}. thread ${p.thread} desde ${(0, horario_1.formatarDesde)(p.desdeEm)} (bloqueada por ${p.bloqueadaPor})`);
+        linhas.push(`  ${i + 1}. thread ${textoSeguro(p.thread)} desde ${(0, horario_1.formatarDesde)(p.desdeEm)} (bloqueada por ${textoSeguro(p.bloqueadaPor)})`);
     });
     linhas.push(`Fila por colisao de regiao: ${regiao.length === 0 ? 'vazia' : `${regiao.length} na espera`}`);
     regiao.forEach((p, i) => {
-        linhas.push(`  ${i + 1}. thread ${p.thread} quer ${p.nome}, colide com ${p.colidiuCom} ` +
-            `(thread ${p.bloqueadaPor}) desde ${(0, horario_1.formatarDesde)(p.desdeEm)}`);
+        linhas.push(`  ${i + 1}. thread ${textoSeguro(p.thread)} quer ${textoSeguro(p.nome)}, colide com ${textoSeguro(p.colidiuCom)} ` +
+            `(thread ${textoSeguro(p.bloqueadaPor)}) desde ${(0, horario_1.formatarDesde)(p.desdeEm)}`);
     });
-    if (leases.length > 0 || fila.length > 0)
+    if (emDisco.length > 0 || fila.length > 0)
         linhas.push((0, horario_1.legendaDoFuso)());
-    return linhas.join('\n');
+    return linhas.map(textoSeguro).join('\n');
 }
 // ---------------------------------------------------------------------------
 // RM-037 (rm037noite, defeito 2): thread fechada nao segura regiao nem fila.
@@ -580,19 +1152,25 @@ function threadFechada(raiz, thread) {
  * conducao tem ciclo proprio e ja trata thread fechada como sem conducao.
  */
 function soltarDaThread(raiz, thread) {
-    const leases = [];
-    for (const lease of listarLeases(raiz)) {
+    const leases = new Set();
+    // RM-036: a copia canonica e as legadas das worktrees, cada uma pelo proprio arquivo.
+    for (const { lease, caminho, legado, identidadeLegada } of leasesEmDisco(raiz)) {
         if (lease.thread !== thread || tipoDoLease(lease.nome) === 'exec')
             continue;
         // Achado A2 do CHECK 1: rele logo antes de apagar. Outra poda pode ter soltado este lease e uma
         // thread viva pode ter adquirido o mesmo nome no meio; apagar pelo caminho da listagem levaria o
         // lease dela. So sai o arquivo que ainda e o da thread fechada, com o mesmo carimbo.
-        const atual = lerLease(raiz, lease.nome);
+        const atual = legado ? (arquivoDeVerdade(caminho) ? lerLeaseLegado(caminho) : null) : lerArquivoDeLease(caminho);
         if (!atual || atual.thread !== thread || atual.adquiridoEm !== lease.adquiridoEm)
             continue;
         try {
-            fs.unlinkSync(caminhoLease(raiz, lease.nome));
-            leases.push(lease.nome);
+            if (legado) {
+                if (!identidadeLegada || !ignorarLegado(raiz, caminho, identidadeLegada))
+                    continue;
+            }
+            else
+                fs.unlinkSync(caminho);
+            leases.add(lease.nome);
         }
         catch { /* outra limpeza chegou antes */ }
     }
@@ -600,7 +1178,7 @@ function soltarDaThread(raiz, thread) {
     const dela = fila.filter((p) => p.thread === thread);
     if (dela.length > 0)
         gravarFila(raiz, fila.filter((p) => p.thread !== thread));
-    return { leases, fila: dela.map((p) => p.nome) };
+    return { leases: [...leases], fila: dela.map((p) => p.nome) };
 }
 /**
  * Solta o que a thread fechada deixou e registra no ledger dela: `lease_released` por lease e
@@ -634,3 +1212,18 @@ function podarThreadsFechadas(raiz, nome, quem) {
             soltarThreadFechada(raiz, thread, 'poda', quem);
     }
 }
+/**
+ * RM-037 (fatia 3, defeito 4): a mesma poda, para as conferencias previas do MCP. O `ork_git_commit`
+ * conferia `lerLease` antes do `adquirirRegiao` e recusava com `lease.busy` o lease que a ork-companybrai3
+ * (fechada) deixou, e soltar o lease de outra thread exigia o dono. Lease e fila de thread fechada sao
+ * orfaos: saem aqui, com registro no ledger dela. Lease de thread aberta, vencido ou nao, e o da propria
+ * thread seguem como estao, e a conferencia de quem chama decide. De melhor esforco, como no `adquirirRegiao`.
+ */
+function podarRegioesDeThreadsFechadas(raiz, nomes, quem) {
+    for (const nome of nomes) {
+        try {
+            podarThreadsFechadas(raiz, nome, quem);
+        }
+        catch { /* a conferencia de quem chama decide */ }
+    }
+}