@orkastery/cli 0.2.0 → 0.4.1

package/dist/verify.js

@@ -13,8 +13,13 @@
  *      declarada como `verify.failed`, e nao como regressao que nao da para provar.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TIMEOUT_VERIFY_MS = void 0;
+exports.PREFIXO_BLOQUEADO_NO_VERIFY = exports.TIMEOUT_VERIFY_MS = void 0;
+exports.ambienteDoVerify = ambienteDoVerify;
+exports.prazoDoComando = prazoDoComando;
 exports.executar = executar;
+exports.identidadeDoProduto = identidadeDoProduto;
+exports.causaDoEncerramento = causaDoEncerramento;
+exports.comandoNoLedger = comandoNoLedger;
 exports.comandosDoManifesto = comandosDoManifesto;
 exports.cwdDaThread = cwdDaThread;
 exports.commitReal = commitReal;
@@ -26,7 +31,14 @@ const claims_1 = require("./claims");
 const gates_1 = require("./gates");
 const ledger_1 = require("./ledger");
 const thread_1 = require("./thread");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_crypto_1 = require("node:crypto");
 const util_1 = require("./util");
+const horario_1 = require("./horario");
+const redacao_saida_1 = require("./redacao-saida");
+const redacao_url_1 = require("./redacao-url");
+const conducao_1 = require("./conducao");
 /** Teto de tempo de um comando de verificacao (build e suite completa cabem). */
 exports.TIMEOUT_VERIFY_MS = 10 * 60 * 1000;
 /** Ultimas linhas da saida real, o suficiente para servir de evidencia no ledger. */
@@ -35,15 +47,123 @@ function resumirSaida(stdout, stderr) {
     const linhas = bruto.split('\n').filter((l) => l.trim() !== '');
     return linhas.slice(-10).join('\n').slice(-800);
 }
-/** Executa um comando de verificacao pelo shell, no diretorio de trabalho da thread. */
-function executar(nome, comando, cwd) {
-    const r = (0, util_1.exec)('bash', ['-c', comando], cwd, exports.TIMEOUT_VERIFY_MS);
-    return {
+/** `timeout(1)` (GNU coreutils ou uutils): no estouro sinaliza o GRUPO de processos
+ * inteiro, nao so o filho direto. Os dois se poem no proprio grupo e devolvem 124. */
+const TIMEOUT_BIN = '/usr/bin/timeout';
+/**
+ * I-37 (D5, D6, D7): o comando de verificacao nunca herda a autoridade HITL.
+ *
+ * Um comando que prova uma alegacao nao pode agir como o dono: com a chave de ingresso e os
+ * ids do canal no ambiente, ele conseguiria responder um gate. Sai todo `ORK_HITL_*` (as seis
+ * variaveis do PLAN mais as do OpenClaw, que vieram depois), so no executor de verify, e sem
+ * valvula de escape: comando que precise delas vira escalacao para humano.
+ */
+exports.PREFIXO_BLOQUEADO_NO_VERIFY = 'ORK_HITL_';
+function ambienteDoVerify(base = process.env) {
+    return Object.fromEntries(Object.entries(base).filter(([chave]) => !chave.startsWith(exports.PREFIXO_BLOQUEADO_NO_VERIFY)));
+}
+/** I-37 (D2): o prazo de um comando, resolvido uma vez por rodada (D3). */
+function prazoDoComando(manifesto, nome) {
+    const porComando = manifesto.verify.timeout_ms_por_comando;
+    return porComando?.[nome] ?? manifesto.verify.timeout_ms ?? exports.TIMEOUT_VERIFY_MS;
+}
+/**
+ * Executa um comando de verificacao pelo shell, no diretorio de trabalho da thread.
+ *
+ * O `exec` sozinho mata so o `bash` quando estoura o teto: npm, tsc e node --test
+ * ficavam orfaos, rodando sem dono. Em 21/09/2026 isso acumulou ate 38 builds de teste
+ * presos e travou a VPS. Com o `timeout` na frente, o estouro leva a arvore inteira; e se
+ * o proprio `ork` morrer no meio, o `timeout` segue de pe e encerra o grupo no prazo.
+ * O estouro continua saindo como `code: -1`, o contrato de antes.
+ */
+function executar(nome, comando, cwd, tetoMs = exports.TIMEOUT_VERIFY_MS) {
+    const comGrupo = (0, node_fs_1.existsSync)(TIMEOUT_BIN);
+    const inicio = Date.now();
+    const ambiente = ambienteDoVerify();
+    const r = comGrupo
+        ? (0, util_1.exec)(TIMEOUT_BIN, ['--kill-after=15', `${Math.ceil(tetoMs / 1000)}`, 'bash', '-c', comando], cwd, tetoMs + 30_000, ambiente)
+        : (0, util_1.exec)('bash', ['-c', comando], cwd, tetoMs, ambiente);
+    const duracaoMs = Date.now() - inicio;
+    const causa = causaDoEncerramento({ code: r.code, signal: r.signal ?? null, error: r.error, comGrupo, duracaoMs, tetoMs });
+    const estourou = causa === 'timeout';
+    const resultado = {
         nome,
         comando,
         ok: r.ok,
-        code: r.code,
+        code: estourou ? -1 : r.code,
         resumo: resumirSaida(r.stdout, r.stderr),
+        causa,
+        prazoMs: tetoMs,
+        duracaoMs,
+        // I-54 (D11): so nao rodou o que o sistema recusou lancar; estouro e sinal rodaram e acabaram.
+        executado: !(r.error && NAO_LANCADO.has(r.error)),
+    };
+    if (!r.ok) {
+        const saida = r.stdout + (r.stderr ? '\n' + r.stderr : '');
+        const testes = (0, redacao_saida_1.testesQueCairam)(saida);
+        if (testes.length > 0)
+            resultado.testeQueCaiu = testes;
+        resultado.trecho = (0, redacao_saida_1.redigirSaida)(saida);
+    }
+    return resultado;
+}
+/** I-54 (D11): erros de spawn em que o processo nem chegou a existir. */
+const NAO_LANCADO = new Set(['ENOENT', 'EACCES', 'EAGAIN', 'ENOMEM', 'EPERM', 'EMFILE']);
+/**
+ * I-54 (RM-037, D11): a identidade do produto que a rodada verifica. HEAD, o diff contra ele e o
+ * conteudo dos arquivos nao rastreados (o que o `.gitignore` exclui, como `dist/`, fica fora). O
+ * mtime nao entra: `touch` o engana, e identidade e conteudo. O `.orkastery/` fica fora sempre: e
+ * o estado do proprio `ork` (ledger, claims), que a rodada escreve enquanto verifica.
+ */
+const FORA_DO_PRODUTO = [':(exclude).orkastery'];
+function identidadeDoProduto(cwd) {
+    const h = (0, node_crypto_1.createHash)('sha256');
+    h.update((0, util_1.exec)('git', ['rev-parse', 'HEAD'], cwd).stdout);
+    h.update((0, util_1.exec)('git', ['diff', 'HEAD', '--no-ext-diff', '--binary', '--', '.', ...FORA_DO_PRODUTO], cwd).stdout);
+    const soltos = (0, util_1.exec)('git', ['ls-files', '--others', '--exclude-standard', '-z', '--', '.', ...FORA_DO_PRODUTO], cwd).stdout
+        .split('\0').filter(Boolean).sort();
+    for (const arquivo of soltos) {
+        h.update(arquivo + '\0');
+        try {
+            h.update((0, node_fs_1.readFileSync)((0, node_path_1.join)(cwd, arquivo)));
+        }
+        catch {
+            h.update('<ilegivel>');
+        }
+    }
+    return h.digest('hex');
+}
+/**
+ * I-37 (T3): por que o comando terminou, a partir do que o processo devolveu.
+ *
+ * Pelo `timeout(1)`, 124 e o estouro e 137 o SIGKILL do `--kill-after`, e so contam como
+ * estouro quando o tempo corrido chegou ao prazo. Sem ele, o proprio spawnSync mata por prazo e
+ * devolve `ETIMEDOUT`. Comando que o shell nao achou sai 127. Morte por sinal aparece no
+ * `signal` do processo ou, no GNU `timeout`, como 128 + sinal (o uutils devolve so o numero,
+ * que fica indistinguivel de um `exit` e e tratado como tal).
+ */
+function causaDoEncerramento(r) {
+    const estourou = (r.comGrupo && (r.code === 124 || r.code === 137) && r.duracaoMs >= r.tetoMs - 1000)
+        || (!r.comGrupo && r.error === 'ETIMEDOUT');
+    if (estourou)
+        return 'timeout';
+    if (r.error === 'ENOENT' || r.code === 127)
+        return 'nao-encontrado';
+    if (r.signal || (r.comGrupo && r.code > 128 && r.code < 160))
+        return 'sinal';
+    return 'exit';
+}
+/** I-37 (D8): o que o ledger grava de um comando. Sucesso e o codigo 0; falha leva a evidencia. */
+function comandoNoLedger(c) {
+    if (c.ok)
+        return { nome: c.nome, ok: true, code: c.code };
+    return {
+        nome: c.nome, comando: (0, redacao_url_1.redigirCredenciaisUrl)(c.comando), ok: false, code: c.code,
+        ...(c.causa ? { causa: c.causa } : {}),
+        ...(c.prazoMs !== undefined ? { prazoMs: c.prazoMs } : {}),
+        ...(c.duracaoMs !== undefined ? { duracaoMs: c.duracaoMs } : {}),
+        ...(c.testeQueCaiu?.length ? { testeQueCaiu: c.testeQueCaiu } : {}),
+        ...(c.trecho !== undefined ? { trecho: c.trecho } : {}),
     };
 }
 /** Comandos declarados em `verify:` no manifesto, na ordem canonica. */
@@ -65,12 +185,34 @@ function commitReal(cwd) {
     const r = (0, util_1.exec)('git', ['rev-parse', 'HEAD'], cwd);
     return r.ok ? r.stdout.trim() : 'desconhecido';
 }
+/** O pedido de conducao de uma verificacao, com o prazo derivado dos comandos que ela vai rodar (D3). */
+function pedidoDoVerify(carregado, threadId, operacao, comandos, conducao) {
+    return {
+        canal: conducao.canal ?? (0, conducao_1.canalDoProcesso)(),
+        correlacao: conducao.correlacao ?? null,
+        operacao,
+        identidade: conducao.identidade ?? (0, conducao_1.identidadeDoAmbiente)(threadId),
+        prazoMs: (0, conducao_1.prazoDaVerificacao)(carregado.manifesto.verify.timeout_ms ?? exports.TIMEOUT_VERIFY_MS, comandos),
+        esperarMs: conducao.esperarMs,
+    };
+}
+/** O executor que renova o prazo da conducao antes de cada comando (D3). */
+function executorSobConducao(base, manifesto, conducao) {
+    return (nome, comando, cwd) => {
+        conducao.renovar(prazoDoComando(manifesto, nome));
+        return base(nome, comando, cwd);
+    };
+}
 /** `ork verify --baseline`: grava o estado do mundo ANTES do GO. */
-function gravarBaseline(carregado, threadId) {
+function gravarBaseline(carregado, threadId, executor = executar, conducao = {}) {
+    const pedido = pedidoDoVerify(carregado, threadId, 'baseline', comandosDoManifesto(carregado.manifesto).length, conducao);
+    return (0, conducao_1.comConducao)(carregado.raiz, threadId, pedido, (tomada) => gravarBaselineSobConducao(carregado, threadId, executorSobConducao(executor, carregado.manifesto, tomada)));
+}
+function gravarBaselineSobConducao(carregado, threadId, executor) {
     const { raiz, manifesto } = carregado;
     const thread = (0, thread_1.lerThread)(raiz, threadId);
     const cwd = cwdDaThread(raiz, thread);
-    const comandos = comandosDoManifesto(manifesto).map((c) => executar(c.nome, c.comando, cwd));
+    const comandos = comandosDoManifesto(manifesto).map((c) => executor(c.nome, c.comando, cwd));
     const baseline = { commit: commitReal(cwd), gravadaEm: (0, util_1.agora)(), comandos };
     thread.baseline = baseline;
     (0, thread_1.gravarThread)(raiz, thread);
@@ -88,7 +230,7 @@ function gravarBaseline(carregado, threadId) {
  * Exportada para o bloco B5: as claims dos ACHADOS de auditoria passam por este mesmo
  * julgamento, sem uma segunda regra paralela que pudesse ser mais frouxa.
  */
-function verificarClaim(claim, cwd) {
+function verificarClaim(claim, cwd, executor = executar) {
     if (claim.verificar.length === 0) {
         const negativa = claim.negativa;
         return {
@@ -102,14 +244,29 @@ function verificarClaim(claim, cwd) {
             execucoes: [],
         };
     }
-    const execucoes = claim.verificar.map((c, i) => executar(`${claim.id}.${i + 1}`, c, cwd));
+    const execucoes = claim.verificar.map((c, i) => executor(`${claim.id}.${i + 1}`, c, cwd));
+    // I-54 (D11): comando que nao rodou nao tem veredito, e lista vazia de execucao nunca aprova.
+    const naoRodou = execucoes.find((e) => e.executado === false);
+    if (naoRodou) {
+        return {
+            claim,
+            verificado: false,
+            motivo: 'verify.sem-veredito',
+            detalhe: `comando "${(0, redacao_url_1.redigirCredenciaisUrl)(naoRodou.comando)}" nao foi executado: ${naoRodou.resumo}`,
+            execucoes,
+        };
+    }
     const falhou = execucoes.find((e) => !e.ok);
+    // I-37 (D1): estouro de prazo nao desmente a alegacao; a prova so nao chegou ao fim.
+    const estourou = falhou?.causa === 'timeout';
     return {
         claim,
         verificado: !falhou,
-        motivo: falhou ? 'claims.failed' : null,
+        motivo: falhou ? (estourou ? 'verify.timeout' : 'claims.failed') : null,
         detalhe: falhou
-            ? `comando "${falhou.comando}" saiu com codigo ${falhou.code}`
+            ? estourou
+                ? `comando "${falhou.comando}" estourou o prazo de ${Math.round((falhou.prazoMs ?? 0) / 1000)} s sem terminar`
+                : `comando "${(0, redacao_url_1.redigirCredenciaisUrl)(falhou.comando)}" saiu com codigo ${falhou.code}`
             : `${execucoes.length} comando(s) reexecutado(s) com sucesso`,
         execucoes,
     };
@@ -119,16 +276,42 @@ function verificarClaim(claim, cwd) {
  * Nao decide pausa, decide VERDADE: quem pausa e o gate do modo de conducao.
  */
 function verificar(carregado, threadId, opcoes = {}) {
+    // I-36 (T4): sem a conducao da thread, nenhum comando roda; a recusa sai tipada, com quem conduz.
+    const planejados = (0, claims_1.lerClaims)(carregado.raiz, threadId).filter((c) => c.estado !== 'retirada')
+        .reduce((n, c) => n + c.verificar.length, 0) + (opcoes.soClaims ? 0 : comandosDoManifesto(carregado.manifesto).length) + 1;
+    const pedido = pedidoDoVerify(carregado, threadId, opcoes.operacao ?? 'verify', planejados, opcoes.conducao ?? {});
+    return (0, conducao_1.comConducao)(carregado.raiz, threadId, pedido, (tomada) => verificarSobConducao(carregado, threadId, opcoes, tomada, pedido.canal));
+}
+function verificarSobConducao(carregado, threadId, opcoes, conducao, canal) {
     const { raiz, manifesto } = carregado;
     const thread = (0, thread_1.lerThread)(raiz, threadId);
     const cwd = cwdDaThread(raiz, thread);
     const commit = commitReal(cwd);
     const dir = (0, thread_1.dirThread)(raiz, threadId);
+    // I-43 (D4, viga b): os criterios de pronto da thread viram claims do nucleo ANTES
+    // da reexecucao, para entrarem no MESMO veredito das demais alegacoes. Idempotente:
+    // `ork verify` roda em toda fase, e uma claim por criterio por rodada viraria
+    // acumulador em vez de verificacao.
+    (0, claims_1.registrarCriteriosDePronto)(raiz, threadId);
+    // I-37 (D2, D3): o prazo de cada comando sai do manifesto carregado no inicio da rodada;
+    // editar o manifesto no meio dela nao muda o teto de quem ainda vai rodar.
+    const executor = executorSobConducao(opcoes.executor
+        ?? ((nome, comando, dirDeTrabalho) => executar(nome, comando, dirDeTrabalho, prazoDoComando(manifesto, nome))), manifesto, conducao);
+    // I-54 (D10): o preparo roda UMA vez, antes das claims. Ele nunca e condicao para uma claim
+    // passar (cada uma roda o proprio comando inteiro); ele so deixa pronta a compilacao. A
+    // identidade do produto e tomada logo depois dele e conferida no fim da rodada.
+    const preparo = manifesto.verify.preparo ? (() => {
+        const resultado = executor('preparo', manifesto.verify.preparo, cwd);
+        return { resultado, identidade: identidadeDoProduto(cwd) };
+    })() : null;
     // Claim retirada sai do gate: o historico guarda a alegacao e o motivo da retirada.
     const claims = (0, claims_1.lerClaims)(raiz, threadId)
         .filter((c) => c.estado !== 'retirada')
-        .map((c) => verificarClaim(c, cwd));
+        .map((c) => verificarClaim(c, cwd, executor));
     for (const r of claims) {
+        // Estouro de prazo e comando que nao rodou nao julgam a alegacao: o estado anterior vale.
+        if (r.motivo === 'verify.timeout' || r.motivo === 'verify.sem-veredito')
+            continue;
         const estado = r.verificado
             ? 'verificado'
             : r.motivo === 'claims.unverifiable'
@@ -139,14 +322,19 @@ function verificar(carregado, threadId, opcoes = {}) {
     }
     const comandos = opcoes.soClaims
         ? []
-        : comandosDoManifesto(manifesto).map((c) => executar(c.nome, c.comando, cwd));
+        : comandosDoManifesto(manifesto).map((c) => executor(c.nome, c.comando, cwd));
     const baseline = thread.baseline ?? null;
     const regressoes = [];
     const preExistentes = [];
     const falhasSemBaseline = [];
+    const estouros = [];
     for (const atual of comandos) {
         if (atual.ok)
             continue;
+        if (atual.causa === 'timeout') {
+            estouros.push(atual);
+            continue;
+        }
         const antes = baseline?.comandos.find((c) => c.nome === atual.nome);
         if (!antes)
             falhasSemBaseline.push(atual);
@@ -155,6 +343,10 @@ function verificar(carregado, threadId, opcoes = {}) {
         else
             preExistentes.push(atual);
     }
+    // I-54 (D11): o produto mudou entre o preparo e o fim da rodada? Entao nenhum veredito vale.
+    const identidadeFinal = preparo ? identidadeDoProduto(cwd) : null;
+    const produtoAlterado = !!preparo && identidadeFinal !== preparo.identidade;
+    const naoExecutados = comandos.filter((c) => c.executado === false);
     const motivos = [];
     if (claims.some((c) => c.motivo === 'claims.failed'))
         motivos.push('claims.failed');
@@ -164,24 +356,40 @@ function verificar(carregado, threadId, opcoes = {}) {
         motivos.push('verify.regression');
     if (falhasSemBaseline.length > 0)
         motivos.push('verify.failed');
+    if (estouros.length > 0 || claims.some((c) => c.motivo === 'verify.timeout'))
+        motivos.push('verify.timeout');
+    if (produtoAlterado || naoExecutados.length > 0 || claims.some((c) => c.motivo === 'verify.sem-veredito')) {
+        motivos.push('verify.sem-veredito');
+    }
     const bloqueantes = motivos.filter((m) => m !== 'claims.unverifiable');
     const ok = bloqueantes.length === 0;
     (0, ledger_1.registrar)(dir, threadId, ledger_1.TIPOS_DE_EVENTO.verificacao, {
         commit,
         cwd,
-        claims: claims.map((c) => ({
-            id: c.claim.id,
-            verificado: c.verificado,
-            motivo: c.motivo,
-            detalhe: c.detalhe,
-        })),
-        comandos: comandos.map((c) => ({ nome: c.nome, ok: c.ok, code: c.code })),
+        claims: claims.map((c) => {
+            const falhou = c.execucoes.find((e) => !e.ok);
+            return {
+                id: c.claim.id,
+                verificado: c.verificado,
+                motivo: c.motivo,
+                detalhe: c.detalhe,
+                ...(falhou ? { execucao: comandoNoLedger(falhou) } : {}),
+            };
+        }),
+        comandos: comandos.map(comandoNoLedger),
         baseline: baseline ? { commit: baseline.commit, gravadaEm: baseline.gravadaEm } : null,
         regressoes: regressoes.map((r) => r.nome),
         preExistentes: preExistentes.map((r) => r.nome),
         falhasSemBaseline: falhasSemBaseline.map((r) => r.nome),
+        estouros: estouros.map((r) => r.nome),
+        prazoMs: manifesto.verify.timeout_ms ?? exports.TIMEOUT_VERIFY_MS,
+        ...(preparo ? { preparo: { ...comandoNoLedger(preparo.resultado), duracaoMs: preparo.resultado.duracaoMs,
+                identidade: preparo.identidade.slice(0, 16), identidadeFinal: identidadeFinal.slice(0, 16), produtoAlterado } } : {}),
         motivos,
         veredito: ok ? 'verdade sustentada' : 'reprovado',
+        // I-36: por qual canal a verificacao chegou; a reentrada da sessao que conduz aparece aqui.
+        canal,
+        conducao: { identidade: conducao.identidade, reentrada: conducao.reentrada },
     });
     for (const motivo of bloqueantes) {
         (0, gates_1.registrarGateBloqueado)(dir, threadId, {
@@ -195,11 +403,23 @@ function verificar(carregado, threadId, opcoes = {}) {
                     .join('; ')
                 : motivo === 'verify.regression'
                     ? `regressao em: ${regressoes.map((r) => r.nome).join(', ')}`
-                    : `falha sem baseline em: ${falhasSemBaseline.map((r) => r.nome).join(', ')}`,
+                    : motivo === 'verify.timeout'
+                        ? `estourou o prazo sem terminar: ${[...estouros.map((r) => r.nome),
+                            ...claims.filter((c) => c.motivo === 'verify.timeout').map((c) => c.claim.id)].join(', ')}`
+                        : motivo === 'verify.sem-veredito'
+                            ? [produtoAlterado ? 'o produto mudou entre o preparo e o fim da rodada' : '',
+                                ...naoExecutados.map((c) => `${c.nome} nao foi executado`),
+                                ...claims.filter((c) => c.motivo === 'verify.sem-veredito').map((c) => `${c.claim.id}: ${c.detalhe}`)]
+                                .filter(Boolean).join('; ')
+                            : `falha sem baseline em: ${falhasSemBaseline.map((r) => r.nome).join(', ')}`,
             evidencia: `reexecucao no HEAD ${commit} em ${cwd}`,
             correcao: motivo === 'claims.failed'
                 ? 'corrija o artefato ou a alegacao e rode `ork verify` de novo'
-                : 'corrija a regressao, ou grave a baseline antes do GO com `ork verify <thread> --baseline`',
+                : motivo === 'verify.timeout'
+                    ? 'rode `ork verify` de novo; se estourar sempre, suba verify.timeout_ms no manifesto ou divida o comando'
+                    : motivo === 'verify.sem-veredito'
+                        ? 'rode `ork verify` de novo, sem editar a worktree durante a rodada'
+                        : 'corrija a regressao, ou grave a baseline antes do GO com `ork verify <thread> --baseline`',
         });
     }
     return {
@@ -212,17 +432,36 @@ function verificar(carregado, threadId, opcoes = {}) {
         regressoes,
         preExistentes,
         falhasSemBaseline,
+        estouros,
+        preparo: preparo ? { ...preparo, identidadeFinal: identidadeFinal, produtoAlterado } : null,
         motivos,
         ok,
     };
 }
+/** `FALHOU (codigo 1)`, ou `ESTOUROU O PRAZO (600 s, rodou 612 s)`: a causa e dita pelo nome. */
+function situacaoDoComando(c) {
+    const s = (ms) => `${Math.round((ms ?? 0) / 1000)} s`;
+    if (c.causa === 'timeout')
+        return `ESTOUROU O PRAZO (${s(c.prazoMs)}, rodou ${s(c.duracaoMs)})`;
+    if (c.causa === 'nao-encontrado')
+        return `NAO EXECUTOU (comando nao encontrado, codigo ${c.code})`;
+    if (c.causa === 'sinal')
+        return `MORTO POR SINAL (codigo ${c.code})`;
+    return `FALHOU (codigo ${c.code})`;
+}
 /** Texto de `ork verify`. */
 function textoDoVerify(r) {
     const linhas = [];
     linhas.push(`ork verify da thread ${r.thread}`);
     linhas.push(`  HEAD real   ${r.commit}`);
     linhas.push(`  diretorio   ${r.cwd}`);
-    linhas.push(`  baseline    ${r.baseline ? `${r.baseline.commit.slice(0, 8)} de ${r.baseline.gravadaEm}` : '(nao gravada: falha nao pode ser chamada de regressao)'}`);
+    linhas.push(`  baseline    ${r.baseline ? `${r.baseline.commit.slice(0, 8)} de ${(0, horario_1.formatarDataHoraRotulada)(r.baseline.gravadaEm)}` : '(nao gravada: falha nao pode ser chamada de regressao)'}`);
+    if (r.preparo) {
+        const p = r.preparo;
+        linhas.push(`  preparo     ${p.resultado.ok ? 'ok' : situacaoDoComando(p.resultado)} em ` +
+            `${Math.round((p.resultado.duracaoMs ?? 0) / 1000)} s, uma vez para a rodada; produto ` +
+            `${p.produtoAlterado ? 'MUDOU no meio da rodada: nenhum veredito vale' : 'conferido do preparo ao fim'}`);
+    }
     linhas.push('');
     linhas.push('Claims reexecutadas no HEAD real:');
     if (r.claims.length === 0) {
@@ -239,9 +478,15 @@ function textoDoVerify(r) {
         linhas.push('');
         linhas.push('Comandos de verify do manifesto:');
         for (const c of r.comandos) {
-            linhas.push(`  ${c.nome.padEnd(10)} ${c.ok ? 'ok' : `FALHOU (codigo ${c.code})`}  ${c.comando}`);
+            linhas.push(`  ${c.nome.padEnd(10)} ${c.ok ? 'ok' : situacaoDoComando(c)}  ${c.comando}`);
+            if (!c.ok && c.testeQueCaiu?.length)
+                linhas.push(`             teste(s) que caiu(ram): ${c.testeQueCaiu.join('; ')}`);
         }
     }
+    if (r.estouros.length > 0) {
+        linhas.push('');
+        linhas.push(`Estouro de prazo (nao e reprovacao, a prova nao terminou): ${r.estouros.map((c) => c.nome).join(', ')}`);
+    }
     if (r.regressoes.length > 0 || r.preExistentes.length > 0 || r.falhasSemBaseline.length > 0) {
         linhas.push('');
         linhas.push(`Classificacao: ${r.regressoes.length} regressao(oes), ` +

package/dist/versao.js

@@ -0,0 +1,60 @@
+"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.VERSAO_DO_ORK = exports.NOME_DO_PACOTE = void 0;
+/**
+ * A versao do `ork`, lida do package.json que viaja com o pacote.
+ *
+ * Havia um literal por superficie (CLI, servidor MCP, recibo de instalacao de adaptador), e cada
+ * um precisava lembrar da publicacao seguinte. O package.json e a unica fonte: no repositorio ele
+ * fica em `core/`, e no pacote npm ao lado de `dist/`, sempre um nivel acima do arquivo compilado.
+ * A arvore de teste (`dist-test/src/`) fica dois niveis abaixo, por isso o segundo candidato.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+exports.NOME_DO_PACOTE = '@orkastery/cli';
+function lerVersao() {
+    for (const candidato of [path.join(__dirname, '..', 'package.json'), path.join(__dirname, '..', '..', 'package.json')]) {
+        try {
+            const pacote = JSON.parse(fs.readFileSync(candidato, 'utf8'));
+            if (pacote.name === exports.NOME_DO_PACOTE && typeof pacote.version === 'string')
+                return pacote.version;
+        }
+        catch { /* tenta o proximo candidato */ }
+    }
+    return '0.0.0-desconhecida';
+}
+/** A versao publicada em `@orkastery/cli`, a mesma do `version` do package.json. */
+exports.VERSAO_DO_ORK = lerVersao();

package/dist/worktree.js

@@ -62,6 +62,7 @@ const ledger_1 = require("./ledger");
 const leases_1 = require("./leases");
 const thread_1 = require("./thread");
 const util_1 = require("./util");
+const estado_thread_1 = require("./estado-thread");
 /** Diretorio canonico da worktree de uma thread, resolvido pelo `ork`. */
 function dirDaWorktree(carregado, id) {
     return path.resolve(carregado.raiz, carregado.manifesto.worktree.dir, id);
@@ -130,6 +131,13 @@ function garantirWorktree(carregado, id) {
                 correcao: `remova o diretorio ou registre a worktree; depois rode: ork worktree ensure ${id}`,
             };
         }
+        try {
+            (0, estado_thread_1.vincularEstado)(raiz, id, dir);
+        }
+        catch (e) {
+            return { ok: false, criada: false, dir, branch, base, motivo: 'tree.blocked',
+                detalhe: e.message, correcao: `reconcilie o estado e rode ork worktree sync ${id}` };
+        }
         if (thread.worktree !== dir) {
             thread.worktree = dir;
             (0, thread_1.gravarThread)(raiz, thread);
@@ -229,6 +237,13 @@ function sincronizarWorktree(carregado, id, opcoes = {}) {
             correcao: `commite ou guarde as alteracoes em ${dir} e rode de novo: ork worktree sync ${id}`,
         };
     }
+    try {
+        (0, estado_thread_1.vincularEstado)(raiz, id, dir, opcoes.dryRun);
+    }
+    catch (e) {
+        return { ...vazio, ok: false, jaAtualizada: false, rebaseFeito: false,
+            motivo: 'tree.blocked', detalhe: e.message, correcao: 'reconcilie as duas cópias sem descartar evidências' };
+    }
     const refBase = (0, util_1.exec)('git', ['rev-parse', '--verify', base], raiz);
     if (!refBase.ok) {
         return {
@@ -287,10 +302,22 @@ function sincronizarWorktree(carregado, id, opcoes = {}) {
             correcao: '',
         };
     }
-    const rebase = (0, util_1.exec)('git', ['rebase', shaBase], dir);
+    let rebase;
+    try {
+        rebase = (0, estado_thread_1.comEstadoParaGit)(raiz, id, dir, () => {
+            const resultado = (0, util_1.exec)('git', ['rebase', shaBase], dir);
+            if (!resultado.ok)
+                (0, util_1.exec)('git', ['rebase', '--abort'], dir);
+            return resultado;
+        });
+    }
+    catch (e) {
+        return { ...vazio, shaBase, shaAntes, ok: false, jaAtualizada: false, rebaseFeito: false,
+            motivo: 'tree.blocked', detalhe: e.message,
+            correcao: 'inspecione a cópia local e a fonte canônica preservadas antes de repetir o sync' };
+    }
     passos.push(`git rebase ${shaBase}`);
     if (!rebase.ok) {
-        (0, util_1.exec)('git', ['rebase', '--abort'], dir);
         passos.push('git rebase --abort');
         const detalhe = (rebase.stderr || rebase.stdout).trim().split('\n').slice(-4).join(' | ');
         (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, id), id, ledger_1.TIPOS_DE_EVENTO.worktreeSincronizada, {
@@ -431,6 +458,8 @@ function auditarWorktree(carregado, id) {
             nivel: 'ok',
             detalhe: `${path.relative(raiz, dirArtefatos)} fica fora da worktree`,
         });
+    if (existe)
+        checks.push((0, estado_thread_1.auditarEstado)(raiz, id, dir));
     const divergencias = checks.filter((c) => c.nivel === 'fail').length;
     (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, id), id, ledger_1.TIPOS_DE_EVENTO.worktreeAuditada, {
         dir,