@orkastery/cli 0.5.6 → 0.6.0

package/dist/thread.js

@@ -61,6 +61,9 @@ exports.avisoDaWorktree = avisoDaWorktree;
 exports.prepararPedido = prepararPedido;
 exports.pedidoDaThread = pedidoDaThread;
 exports.novaThread = novaThread;
+exports.dependenciasPendentes = dependenciasPendentes;
+exports.prepararDependenciasPendentes = prepararDependenciasPendentes;
+exports.prepararDependenciasDaThread = prepararDependenciasDaThread;
 exports.exigirVarianteCompativel = exigirVarianteCompativel;
 exports.blocoDaThread = blocoDaThread;
 exports.pausaNaThread = pausaNaThread;
@@ -84,9 +87,12 @@ const ledger_1 = require("./ledger");
 const estado_thread_1 = require("./estado-thread");
 const creation_operation_store_1 = require("./creation-operation-store");
 const horario_1 = require("./horario");
+const check_modo_1 = require("./check-modo");
 const maquina_1 = require("./maquina");
 const conducao_texto_1 = require("./conducao-texto");
 const locale_1 = require("./locale");
+const branch_de_estado_1 = require("./branch-de-estado");
+const dependencias_da_worktree_1 = require("./dependencias-da-worktree");
 /** Diretorio de threads do projeto. */
 function dirThreads(raiz) {
     return path.join((0, manifest_1.dirEstado)((0, estado_thread_1.raizDoEstado)(raiz)), 'threads');
@@ -172,9 +178,11 @@ function alvoDaWorktree(carregado, id, slug, opcoes = {}) {
  */
 function worktreePrevista(carregado, id, slug, opcoes = {}) {
     const alvo = alvoDaWorktree(carregado, id, slug, opcoes);
+    const base = opcoes.base ?? carregado.manifesto.worktree.base_branch;
+    const remoto = (0, branch_de_estado_1.exigirRemoto)(carregado.manifesto.fabrica.remoto, 'worktree');
     const refs = opcoes.branchExistente
         ? [opcoes.branchExistente]
-        : [opcoes.base ?? carregado.manifesto.worktree.base_branch, 'HEAD'];
+        : [(0, branch_de_estado_1.refRemota)(remoto, base), base, 'HEAD'];
     let commit = null;
     for (const ref of refs) {
         const r = (0, util_1.exec)('git', ['rev-parse', '--verify', ref], carregado.raiz);
@@ -189,6 +197,36 @@ function worktreePrevista(carregado, id, slug, opcoes = {}) {
         : commit === null ? 'sem-commit' : branchJaExiste ? 'branch-existe' : null;
     return { ...alvo, commit, falha };
 }
+/**
+ * Resolve a base de uma worktree nova. Com remoto configurado e presente, a fonte e sempre
+ * `refs/remotes/<remoto>/<base>` atualizada por um fetch explicito; a branch local pode pertencer a
+ * outra worktree e ficar parada indefinidamente. Repositorio sem esse remoto preserva o caso local.
+ */
+function baseAtualDaWorktree(carregado, base) {
+    const { raiz, manifesto } = carregado;
+    const remoto = (0, branch_de_estado_1.exigirRemoto)(manifesto.fabrica.remoto, 'worktree');
+    const temRemoto = (0, util_1.exec)('git', ['remote', 'get-url', '--', remoto], raiz).ok;
+    let ref = base;
+    if (temRemoto) {
+        ref = (0, branch_de_estado_1.refRemota)(remoto, base);
+        const ambiente = { ...process.env, GIT_TERMINAL_PROMPT: '0',
+            GIT_SSH_COMMAND: process.env.GIT_SSH_COMMAND ?? 'ssh -o BatchMode=yes' };
+        const fetch = (0, util_1.exec)('git', ['fetch', '-q', '--no-tags', '--', remoto,
+            `+refs/heads/${base}:${ref}`], raiz, 120000, ambiente);
+        if (!fetch.ok) {
+            const saida = (fetch.stderr || fetch.stdout).trim().split('\n').slice(-2).join(' | ');
+            throw new locale_1.ErroDoCatalogo((m) => m.worktree.baseRemotaFalhou(remoto, base, saida));
+        }
+    }
+    const resolvida = (0, util_1.exec)('git', ['rev-parse', '--verify', ref], raiz);
+    if (!resolvida.ok) {
+        // Repositorio local ainda sem a branch do manifesto conserva a recusa historica do
+        // `git worktree add ... HEAD`; com remoto presente, o fetch acima ja teria recusado.
+        const head = (0, util_1.exec)('git', ['rev-parse', '--verify', 'HEAD'], raiz);
+        return { ref: 'HEAD', commit: head.ok ? head.stdout.trim() : util_1.COMMIT_DESCONHECIDO };
+    }
+    return { ref, commit: resolvida.stdout.trim() };
+}
 /**
  * Cria a worktree isolada da thread (paralelismo sem colisao entre threads).
  *
@@ -202,31 +240,38 @@ function criarWorktree(carregado, id, slug, opcoes = {}) {
     (0, worktree_local_1.exigirPastaDasWorktrees)(raiz, manifesto);
     const { dir, branch } = alvoDaWorktree(carregado, id, slug, opcoes);
     if (fs.existsSync(dir)) {
-        throw new Error(`worktree ja existe em ${dir}`);
+        throw new locale_1.ErroDoCatalogo((m) => m.worktree.worktreeJaExisteEm(dir));
     }
     const base = opcoes.base ?? manifesto.worktree.base_branch;
-    const commitBase = (0, util_1.exec)('git', ['rev-parse', '--verify', base], raiz);
-    const ref = commitBase.ok ? commitBase.stdout.trim() : 'HEAD';
+    const resolvida = opcoes.branchExistente
+        ? (() => {
+            const r = (0, util_1.exec)('git', ['rev-parse', '--verify', opcoes.branchExistente], raiz);
+            if (!r.ok)
+                throw new locale_1.ErroDoCatalogo((m) => m.worktree.baseInexistente(opcoes.branchExistente));
+            return { ref: opcoes.branchExistente, commit: r.stdout.trim() };
+        })()
+        : baseAtualDaWorktree(carregado, base);
     // Fatia 2 do ensaio da 0.5.0 (P3): a pasta das worktrees que o ork cria agora nasce fora do git.
     const pastaDasWorktrees = path.dirname(dir);
     const pastaNova = !fs.existsSync(pastaDasWorktrees);
     // Branch nova (`-b`) no caso comum; branch que ja existe no ciclo `merge-branch`.
     const argumentos = opcoes.branchExistente
         ? ['worktree', 'add', dir, opcoes.branchExistente]
-        : ['worktree', 'add', '-b', branch, dir, ref];
+        : ['worktree', 'add', '-b', branch, dir, resolvida.ref];
     const r = (0, util_1.exec)('git', argumentos, raiz);
     if (!r.ok) {
-        throw new Error(`git worktree add falhou: ${(r.stderr || r.stdout).trim()}`);
+        const saida = (r.stderr || r.stdout).trim();
+        throw new locale_1.ErroDoCatalogo((m) => m.worktree.worktreeAddFalhou(saida));
     }
     if (pastaNova)
         (0, util_1.ignorarPastaNoGit)(pastaDasWorktrees, (0, estado_thread_1.raizDoEstado)(raiz));
     const lista = (0, util_1.exec)('git', ['worktree', 'list', '--porcelain'], raiz);
     const criada = lista.ok && lista.stdout.split('\n').some((l) => l.trim() === `worktree ${dir}`);
     if (!criada) {
-        throw new Error(`worktree nao apareceu em \`git worktree list\` apos a criacao: ${dir}`);
+        throw new locale_1.ErroDoCatalogo((m) => m.worktree.worktreeNaoApareceu(dir));
     }
     (0, estado_thread_1.vincularEstado)(raiz, id, dir);
-    return { dir, branch };
+    return { dir, branch, commit: resolvida.commit };
 }
 /**
  * Resolve `--worktree`, `--sem-worktree` e `worktree.por_thread`. As flags vencem a chave; as duas juntas, ou
@@ -387,7 +432,63 @@ function gravarPedido(dir, texto) {
 function novaThread(carregado, opcoes) {
     if (opcoes.dryRun)
         return criarThreadSerializada(carregado, opcoes);
-    return (0, creation_operation_store_1.withCreationLock)((0, estado_thread_1.raizDoEstado)(carregado.raiz), 'threads', () => criarThreadSerializada(carregado, opcoes));
+    const criada = (0, creation_operation_store_1.withCreationLock)((0, estado_thread_1.raizDoEstado)(carregado.raiz), 'threads', () => criarThreadSerializada(carregado, opcoes));
+    // RM-037 (defeito 2 de 19 e 20/10/2026): o preparo das dependencias roda depois da trava de criacao, que espera
+    // segundos, e nao os minutos de um `npm ci`.
+    if (!criada.gravada || !criada.worktreePor || !criada.thread.worktree)
+        return criada;
+    if (opcoes.adiarDependencias) {
+        adiarDependenciasDaThread(carregado, criada.thread.id, criada.thread.worktree);
+        return { ...criada, dependencias: null };
+    }
+    return { ...criada, dependencias: prepararDependenciasDaThread(carregado, criada.thread.id, criada.thread.worktree) };
+}
+/** RM-037 (CHECK 3 da ork-rm037defeit2): a criacao que nao pode esperar o preparo so o anota como pendente. */
+function adiarDependenciasDaThread(carregado, id, dir) {
+    const { dependencias } = carregado.manifesto.worktree;
+    if (!dependencias)
+        return;
+    (0, ledger_1.registrar)(dirThread(carregado.raiz, id), id, ledger_1.TIPOS_DE_EVENTO.worktreeDependenciasPendentes, { dir, comando: dependencias, fonte: 'worktree.dependencias do manifesto' });
+}
+/**
+ * RM-037 (CHECK 3 da ork-rm037defeit2): a worktree `dir` tem o preparo adiado na criacao sem um preparo ok depois dele? O
+ * preparo que falhou nao cobre: a baseline e o verify o repetem e recusam seguir enquanto ele falhar.
+ */
+function dependenciasPendentes(eventos, dir) {
+    let pendente = false;
+    for (const e of eventos) {
+        if (typeof e.dir !== 'string' || path.resolve(e.dir) !== path.resolve(dir))
+            continue;
+        if (e.tipo === ledger_1.TIPOS_DE_EVENTO.worktreeDependenciasPendentes)
+            pendente = true;
+        else if (e.tipo === ledger_1.TIPOS_DE_EVENTO.worktreeDependencias && e.ok === true)
+            pendente = false;
+    }
+    return pendente;
+}
+/**
+ * RM-037 (CHECK 3 da ork-rm037defeit2): roda o preparo que a criacao adiou, antes de a baseline ou o verify rodarem um
+ * comando, com a vez na fila pesada que eles ja seguram; `antes` so e chamado quando ha preparo a rodar (a renovacao da
+ * conducao pelo prazo dele), e o `executor` da operacao, quando ela traz um (o do sandbox do MCP), roda o preparo no lugar
+ * do executor do verify. Devolve o preparo rodado agora, ou `null` sem nada pendente; quem chama recusa a falha.
+ */
+function prepararDependenciasPendentes(carregado, id, dir, opcoes = {}) {
+    if (!dependenciasPendentes((0, ledger_1.lerLedger)(dirThread(carregado.raiz, id)), dir))
+        return null;
+    opcoes.antes?.();
+    return prepararDependenciasDaThread(carregado, id, dir, opcoes.executor);
+}
+/**
+ * RM-037 (defeito 2 de 19 e 20/10/2026): roda `worktree.dependencias` na worktree que acabou de nascer e grava o
+ * resultado no ledger da thread. Sem a chave no manifesto, nada roda e nada se grava. A falha nao desfaz nada.
+ */
+function prepararDependenciasDaThread(carregado, id, dir, executor) {
+    const comando = carregado.manifesto.worktree.dependencias;
+    if (!comando)
+        return null;
+    const preparo = (0, dependencias_da_worktree_1.prepararDependencias)(dir, comando, undefined, executor);
+    (0, ledger_1.registrar)(dirThread(carregado.raiz, id), id, ledger_1.TIPOS_DE_EVENTO.worktreeDependencias, (0, dependencias_da_worktree_1.eventoDoPreparo)(dir, preparo));
+    return preparo;
 }
 /**
  * I-42 (D12): variante que redesenha blocos nao cabe num modo de bloco unico e parcial.
@@ -552,10 +653,9 @@ function criarThreadSerializada(carregado, opcoes) {
             branchExistente: opcoes.branch,
         });
         thread.worktree = worktreeCriada.dir;
-        const commitDaBranch = (0, util_1.exec)('git', ['rev-parse', worktreeCriada.branch], raiz);
         thread.base = {
             branch: worktreeCriada.branch,
-            commit: commitDaBranch.ok ? commitDaBranch.stdout.trim() : thread.base.commit,
+            commit: worktreeCriada.commit,
         };
     }
     // RM-059 (T6.0): o pedido vai ao lado do thread.json, so com permissao do dono, como ele, e antes dele: o
@@ -652,6 +752,10 @@ function resumoDaThread(thread, conducao) {
     if (thread.score) {
         linhas.push(campo(r.score, m.score(thread.score.valor, thread.score.avaliadoPor, thread.score.regime, (0, horario_1.formatarDataHoraRotulada)(thread.score.avaliadoEm))));
     }
+    // RM-072 (D17): o modo do ultimo CHECK, so quando a thread ja teve verify.
+    if (thread.check) {
+        linhas.push(campo(r.check, m.check(check_modo_1.NOME_DO_MODO[thread.check.modo], thread.check.origem, (0, horario_1.formatarDataHoraRotulada)(thread.check.em), (0, util_1.shaCurto)(thread.check.commit))));
+    }
     linhas.push(m.blocosPrevistos);
     for (const b of thread.blocos) {
         const marca = b.pausa ? m.pausaPrevista(m.pausaSobre(b.pausaSobre)) : m.semPausa;
@@ -688,23 +792,22 @@ function threadsDaListagem(raiz, opcoes = {}) {
 /** Tabela de `ork thread list`. */
 function tabelaDeThreads(raiz, opcoes = {}) {
     const linhas = threadsDaListagem(raiz, opcoes);
+    // RM-061 (F3b): o texto pelo catalogo; o status (dado do `--json`) so se traduz na impressao, pelo id.
+    const mt = (0, locale_1.msg)().thread;
     if (linhas.length === 0) {
         // A divida paga aqui: a mensagem sugeria `--modo default`, um modo que
         // `parseModo` recusa, e e a origem provavel das 3 threads com `modo: default`
         // gravadas em disco. A sugestao agora e um modo que existe.
-        const vazio = opcoes.todas === true
-            ? 'Nenhuma thread em .orkastery/threads.'
-            : 'Nenhuma thread aberta ou pausada (use --todas para ver as fechadas).';
-        return `${vazio} Crie uma com: ork thread new "<nome>" --modo ${modos_1.ORDEM_DOS_MODOS[0]}`;
+        return mt.listaVazia(opcoes.todas === true, modos_1.ORDEM_DOS_MODOS[0]);
     }
     const corpo = linhas.map((l) => [
-        l.id, l.slug, l.tag, l.fase, l.status, String(l.pausas), String(l.sessoes),
+        l.id, l.slug, l.tag, l.fase, mt.status(l.status), String(l.pausas), String(l.sessoes),
     ]);
-    const t = (0, util_1.tabela)(['ID', 'SLUG', 'MODO', 'FASE', 'STATUS', 'PAUSAS', 'SESSOES'], corpo);
+    const t = (0, util_1.tabela)([...mt.colunasDaLista], corpo);
     if (opcoes.todas === true)
         return t;
     const fechadas = listarIds(raiz).length - linhas.length;
-    return fechadas > 0 ? `${t}\n\n  ${fechadas} fechada(s) omitida(s). Use --todas para ver todas.` : t;
+    return fechadas > 0 ? `${t}\n\n${mt.fechadasOmitidas(fechadas)}` : t;
 }
 /** Fase valida e pertencente ao ciclo da thread. */
 function exigirFase(thread, bruto) {

package/dist/tokens.js

@@ -63,6 +63,7 @@ const modos_1 = require("./modos");
 const phase_1 = require("./phase");
 const thread_1 = require("./thread");
 const util_1 = require("./util");
+const locale_1 = require("./locale");
 /**
  * Janela nominal usada na estimativa por transcript.
  * Declarada, nao escondida: quem le a medida sabe contra o que ela foi calculada.
@@ -208,21 +209,24 @@ function gateDeTokens(carregado, threadId, opcoes = {}) {
 }
 /** Texto de `ork gate next`. */
 function textoDoGateDeTokens(v) {
+    const m = (0, locale_1.msg)().operacao.restante.gate.tokens;
+    const detalhe = m.localizarDetalhe(v.medida.fonte, v.medida.detalhe);
+    const razao = m.localizarRazao(v.medida.ocupacao, v.limiares.rotate_above, v.limiares.force_rotate_above, v.passoPesado, v.razao.includes('refazer fase reprovada'), v.proximoPasso, v.razao);
     const linhas = [];
-    linhas.push(`ork gate next: thread ${v.thread}`);
-    linhas.push(`  ocupacao       ${v.medida.ocupacao === null ? 'nao medivel' : `${(v.medida.ocupacao * 100).toFixed(1)}%`}`);
-    linhas.push(`  fonte          ${v.medida.fonte}`);
-    linhas.push(`                 ${v.medida.detalhe}`);
-    linhas.push(`  limiares       rotate_above ${v.limiares.rotate_above} | force_rotate_above ${v.limiares.force_rotate_above}`);
-    linhas.push(`  proximo passo  ${v.proximoPasso} (${v.passoPesado ? 'pesado' : 'leve'})`);
+    linhas.push(m.titulo(v.thread));
+    linhas.push(m.ocupacao(v.medida.ocupacao === null ? m.naoMedivel : `${(v.medida.ocupacao * 100).toFixed(1)}%`));
+    linhas.push(m.fonte(v.medida.fonte));
+    linhas.push(m.detalhe(detalhe));
+    linhas.push(m.limiares(v.limiares.rotate_above, v.limiares.force_rotate_above));
+    linhas.push(m.proximo(v.proximoPasso, v.passoPesado ? m.pesado : m.leve));
     linhas.push('');
-    linhas.push(`VEREDITO: ${v.veredito}  (decidido por ${v.decididoPor})`);
-    linhas.push(`  razao: ${v.razao}`);
+    linhas.push(m.veredito(v.veredito, v.decididoPor));
+    linhas.push(m.razao(razao));
     if (v.slugSugerido) {
-        linhas.push(`  slug da nova sessao: ${v.slugSugerido}`);
-        linhas.push(`  proximo passo: ork handoff export ${v.thread} --proxima-fase ${v.proximoPasso}`);
+        linhas.push(m.slug(v.slugSugerido));
+        linhas.push(m.handoff(v.thread, v.proximoPasso));
     }
     linhas.push('');
-    linhas.push(`Registrado no ledger como token_gate: ork phase list ${v.thread}`);
+    linhas.push(m.ledger(v.thread));
     return linhas.join('\n');
 }

package/dist/trabalho-thread.js

@@ -0,0 +1,297 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LIMITE_DE_ARQUIVOS_DO_TRABALHO = exports.LIMITE_TOTAL_DO_TRABALHO = exports.LIMITE_DE_ARQUIVO_DO_TRABALHO = void 0;
+exports.diretorioDoTrabalho = diretorioDoTrabalho;
+exports.caminhoDoTrabalho = caminhoDoTrabalho;
+exports.garantirDiretorioDoTrabalho = garantirDiretorioDoTrabalho;
+exports.gravarRespostaFinalDaSessao = gravarRespostaFinalDaSessao;
+exports.resumirTrabalhoDaThread = resumirTrabalhoDaThread;
+exports.formatarResumoDoTrabalho = formatarResumoDoTrabalho;
+/** RM-064 T4: o trabalho pequeno da sessão acompanha a thread entre contas. */
+const node_crypto_1 = require("node:crypto");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const thread_1 = require("./thread");
+exports.LIMITE_DE_ARQUIVO_DO_TRABALHO = 256 * 1024;
+exports.LIMITE_TOTAL_DO_TRABALHO = 512 * 1024;
+exports.LIMITE_DE_ARQUIVOS_DO_TRABALHO = 24;
+const LIMITE_DE_ENTRADAS = 256;
+const PROFUNDIDADE_MAXIMA = 4;
+/** Caminho real no estado canônico. O prompt usa a forma relativa e portátil de `caminhoDoTrabalho`. */
+function diretorioDoTrabalho(raiz, threadId) {
+    return path.join((0, thread_1.dirThread)(raiz, threadId), 'trabalho');
+}
+function caminhoDoTrabalho(threadId) {
+    return `.orkastery/threads/${threadId}/trabalho/`;
+}
+function abrirDiretorioDoTrabalho(raiz, threadId) {
+    const diretorio = diretorioDoTrabalho(raiz, threadId);
+    fs.mkdirSync(diretorio, { recursive: true, mode: 0o700 });
+    let fd;
+    try {
+        fd = fs.openSync(diretorio, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_DIRECTORY);
+    }
+    catch {
+        throw new Error('trabalho da thread precisa ser diretorio real, nunca link');
+    }
+    try {
+        const aberto = fs.fstatSync(fd);
+        if (!aberto.isDirectory())
+            throw new Error('trabalho da thread precisa ser diretorio real, nunca link');
+        // `mode` de mkdir só vale na criação. Pelo descritor, uma troca de caminho não aplica modo em outro alvo.
+        fs.fchmodSync(fd, 0o700);
+        const real = fs.realpathSync(diretorio), peloCaminho = fs.statSync(real);
+        if (aberto.dev !== peloCaminho.dev || aberto.ino !== peloCaminho.ino)
+            throw new Error('trabalho da thread mudou durante a abertura');
+        return { diretorio, real, fd };
+    }
+    catch (erro) {
+        fs.closeSync(fd);
+        throw erro;
+    }
+}
+function garantirDiretorioDoTrabalho(raiz, threadId) {
+    const aberto = abrirDiretorioDoTrabalho(raiz, threadId);
+    fs.closeSync(aberto.fd);
+    const { diretorio } = aberto;
+    return diretorio;
+}
+function nomeSeguro(nome) {
+    return nome.replace(/[\u0000-\u001f\u007f]/g, '?');
+}
+/**
+ * Persiste a resposta do runtime na pasta privada da thread. O ledger recebe somente este recibo:
+ * conteúdo de agente pode conter detalhes grandes ou sensíveis e nunca é copiado para o evento.
+ */
+function gravarRespostaFinalDaSessao(raiz, threadId, sessionId, texto) {
+    if (!/^[a-zA-Z0-9-]{1,128}$/.test(sessionId))
+        throw new Error('id de sessão inválido para resposta final');
+    const aberto = abrirDiretorioDoTrabalho(raiz, threadId);
+    const bruto = Buffer.from(texto, 'utf8');
+    const truncada = bruto.byteLength > exports.LIMITE_DE_ARQUIVO_DO_TRABALHO;
+    const conteudo = truncada
+        ? Buffer.from(bruto.subarray(0, exports.LIMITE_DE_ARQUIVO_DO_TRABALHO).toString('utf8').replace(/\uFFFD$/, ''), 'utf8')
+        : bruto;
+    const arquivo = `resposta-final-${sessionId}.md`;
+    const alvo = path.join(aberto.diretorio, arquivo);
+    const temporario = path.join(aberto.diretorio, `.${arquivo}.${process.pid}.${(0, node_crypto_1.randomUUID)()}.tmp`);
+    try {
+        fs.writeFileSync(temporario, conteudo, { mode: 0o600, flag: 'wx' });
+        fs.chmodSync(temporario, 0o600);
+        try {
+            fs.linkSync(temporario, alvo);
+        }
+        catch (e) {
+            if (e.code !== 'EEXIST')
+                throw e;
+            const existente = lerArquivoSeguro(aberto.real, alvo, {});
+            if (existente.estado !== 'ok' || !existente.conteudo.equals(conteudo))
+                throw new Error('resposta final já existe com conteúdo divergente');
+        }
+        const persistido = lerArquivoSeguro(aberto.real, alvo, {});
+        if (persistido.estado !== 'ok')
+            throw new Error('resposta final não pôde ser reconferida');
+        fs.chmodSync(alvo, 0o600);
+        return { arquivo, bytes: persistido.conteudo.byteLength,
+            sha256: (0, node_crypto_1.createHash)('sha256').update(persistido.conteudo).digest('hex'), truncada };
+    }
+    finally {
+        try {
+            fs.rmSync(temporario, { force: true });
+        }
+        catch { /* temporário já ausente */ }
+        fs.closeSync(aberto.fd);
+    }
+}
+const contido = (base, alvo) => alvo === base || alvo.startsWith(base + path.sep);
+/** Abre a entrada sem seguir o componente final e nunca lê mais que o teto mais um byte. */
+function lerArquivoSeguro(baseReal, absoluto, opcoes) {
+    try {
+        const antes = fs.realpathSync(absoluto);
+        if (!contido(baseReal, antes))
+            return { estado: 'link' };
+    }
+    catch {
+        return { estado: 'outro' };
+    }
+    opcoes.antesDeAbrir?.(absoluto);
+    let fd;
+    try {
+        fd = fs.openSync(absoluto, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+    }
+    catch (erro) {
+        return { estado: erro.code === 'ELOOP' ? 'link' : 'outro' };
+    }
+    try {
+        const inicial = fs.fstatSync(fd);
+        if (!inicial.isFile())
+            return { estado: 'outro' };
+        if (inicial.size > exports.LIMITE_DE_ARQUIVO_DO_TRABALHO)
+            return { estado: 'grande' };
+        const buffer = Buffer.alloc(exports.LIMITE_DE_ARQUIVO_DO_TRABALHO + 1);
+        let lidos = 0;
+        while (lidos < buffer.length) {
+            const n = fs.readSync(fd, buffer, lidos, buffer.length - lidos, null);
+            if (n === 0)
+                break;
+            lidos += n;
+        }
+        const final = fs.fstatSync(fd);
+        if (lidos > exports.LIMITE_DE_ARQUIVO_DO_TRABALHO || final.size > exports.LIMITE_DE_ARQUIVO_DO_TRABALHO)
+            return { estado: 'grande' };
+        // Confere que o caminho ainda aponta para o mesmo inode aberto e continua dentro da pasta.
+        let peloCaminho, realDepois;
+        try {
+            realDepois = fs.realpathSync(absoluto);
+            peloCaminho = fs.statSync(realDepois);
+        }
+        catch {
+            return { estado: 'outro' };
+        }
+        if (!contido(baseReal, realDepois) || peloCaminho.dev !== final.dev || peloCaminho.ino !== final.ino)
+            return { estado: 'link' };
+        // Mudança durante a leitura não produz hash de estado híbrido.
+        if (lidos !== final.size || inicial.size !== final.size || inicial.mtimeMs !== final.mtimeMs || inicial.ctimeMs !== final.ctimeMs)
+            return { estado: 'outro' };
+        return { estado: 'ok', conteudo: buffer.subarray(0, lidos) };
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+/**
+ * Inventário deliberadamente limitado: não segue links, lê cada arquivo por descritor limitado e não deixa uma árvore
+ * de job dominar o prompt. A sessão sucessora recebe nomes, tamanhos e hashes; lê o arquivo pelo caminho se precisar.
+ */
+function resumirTrabalhoDaThread(raiz, threadId, opcoes = {}) {
+    const aberto = abrirDiretorioDoTrabalho(raiz, threadId);
+    const base = aberto.diretorio, baseReal = aberto.real;
+    const arquivos = [];
+    const ignorados = { grandes: 0, links: 0, excedentes: 0, outros: 0 };
+    let bytes = 0;
+    let entradas = 0;
+    const visitar = (diretorio, relativo, profundidade) => {
+        if (profundidade > PROFUNDIDADE_MAXIMA || entradas >= LIMITE_DE_ENTRADAS) {
+            ignorados.excedentes += 1;
+            return;
+        }
+        let dir;
+        try {
+            const real = fs.realpathSync(diretorio);
+            if (!contido(baseReal, real) || !fs.lstatSync(diretorio).isDirectory()) {
+                ignorados.links += 1;
+                return;
+            }
+            dir = fs.opendirSync(diretorio);
+        }
+        catch {
+            ignorados.outros += 1;
+            return;
+        }
+        const itens = [];
+        try {
+            while (entradas + itens.length < LIMITE_DE_ENTRADAS) {
+                const item = dir.readSync();
+                if (!item)
+                    break;
+                itens.push(item);
+            }
+            if (entradas + itens.length >= LIMITE_DE_ENTRADAS && dir.readSync())
+                ignorados.excedentes += 1;
+        }
+        finally {
+            dir.closeSync();
+        }
+        entradas += itens.length;
+        itens.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+        for (const item of itens) {
+            const absoluto = path.join(diretorio, item.name);
+            const nome = path.posix.join(relativo, nomeSeguro(item.name));
+            if (item.isSymbolicLink()) {
+                ignorados.links += 1;
+                continue;
+            }
+            if (item.isDirectory()) {
+                visitar(absoluto, nome, profundidade + 1);
+                continue;
+            }
+            if (!item.isFile()) {
+                ignorados.outros += 1;
+                continue;
+            }
+            // Lista ou orçamento já cheios: o arquivo só conta como excedente, sem ser aberto nem lido.
+            if (arquivos.length >= exports.LIMITE_DE_ARQUIVOS_DO_TRABALHO || bytes >= exports.LIMITE_TOTAL_DO_TRABALHO) {
+                ignorados.excedentes += 1;
+                continue;
+            }
+            const leitura = lerArquivoSeguro(baseReal, absoluto, opcoes);
+            if (leitura.estado !== 'ok') {
+                if (leitura.estado === 'grande')
+                    ignorados.grandes += 1;
+                else if (leitura.estado === 'link')
+                    ignorados.links += 1;
+                else
+                    ignorados.outros += 1;
+                continue;
+            }
+            if (arquivos.length >= exports.LIMITE_DE_ARQUIVOS_DO_TRABALHO || bytes + leitura.conteudo.byteLength > exports.LIMITE_TOTAL_DO_TRABALHO) {
+                ignorados.excedentes += 1;
+                continue;
+            }
+            arquivos.push({ arquivo: nome, bytes: leitura.conteudo.byteLength,
+                sha256: (0, node_crypto_1.createHash)('sha256').update(leitura.conteudo).digest('hex') });
+            bytes += leitura.conteudo.byteLength;
+        }
+    };
+    try {
+        visitar(base, '', 0);
+        return { caminho: caminhoDoTrabalho(threadId), arquivos, ignorados };
+    }
+    finally {
+        fs.closeSync(aberto.fd);
+    }
+}
+function formatarResumoDoTrabalho(resumo) {
+    const linhas = resumo.arquivos.length
+        ? resumo.arquivos.map((a) => `  - \`${a.arquivo.replace(/`/g, '\\`')}\` (${a.bytes} bytes, sha256 \`${a.sha256}\`)`)
+        : ['  - (nenhum arquivo pequeno)'];
+    const totalIgnorado = Object.values(resumo.ignorados).reduce((soma, n) => soma + n, 0);
+    if (totalIgnorado > 0) {
+        linhas.push(`  - Ignorados pelos limites: ${resumo.ignorados.grandes} grandes, ${resumo.ignorados.links} links, ` +
+            `${resumo.ignorados.excedentes} excedentes, ${resumo.ignorados.outros} outros.`);
+    }
+    return linhas.join('\n');
+}