@orkastery/cli 0.2.0 → 0.4.1

package/dist/ship.js

@@ -4,7 +4,7 @@
  *
  * A ordem dos passos e o contrato, e ela nao muda por modo de conducao:
  *
- *   1. autorizacao de push, pelo gate do modo (#Look/#Ork pausam; #Classic usa a
+ *   1. autorizacao de push, pelo gate do modo (#Classic usa a
  *      autorizacao antecipada registrada no ledger; #Maestro/#Auto usam a propria #TAG);
  *   2. policies do manifesto no gate `ship` (push_direto_na_base e provider);
  *   3. verificacao independente: `ork verify` reexecuta claims e comandos no HEAD real;
@@ -56,6 +56,8 @@ exports.prepararArvore = prepararArvore;
 exports.shaDaRef = shaDaRef;
 exports.shaNoRemoto = shaNoRemoto;
 exports.remotoConfigurado = remotoConfigurado;
+exports.detectarReversaoDaEntrega = detectarReversaoDaEntrega;
+exports.registrarReversaoDaEntrega = registrarReversaoDaEntrega;
 exports.ship = ship;
 exports.textoDoShip = textoDoShip;
 const fs = __importStar(require("node:fs"));
@@ -69,14 +71,31 @@ const policies_1 = require("./policies");
 const thread_1 = require("./thread");
 const util_1 = require("./util");
 const verify_1 = require("./verify");
+const ci_1 = require("./ci");
+const contrato_publico_1 = require("./contrato-publico");
+const prova_minima_1 = require("./prova-minima");
+const horario_1 = require("./horario");
+const fabrica_publicar_1 = require("./fabrica-publicar");
+/** Os caminhos de contrato publico que a entrega traz sobre a base (diff desde o merge-base). */
+function contratosDaEntrega(raiz, shaPara, shaDe) {
+    const base = (0, util_1.exec)('git', ['merge-base', shaPara, shaDe], raiz);
+    if (!base.ok)
+        return [];
+    const diff = (0, util_1.exec)('git', ['diff', '--name-only', '--no-renames', base.stdout.trim(), shaDe], raiz);
+    return diff.ok ? (0, contrato_publico_1.contratosTocados)(diff.stdout.split('\n').map((l) => l.trim()).filter(Boolean)) : [];
+}
 /** Modos em que a propria #TAG do pedido autoriza o push antecipadamente. */
 const MODOS_QUE_AUTORIZAM_PUSH = ['maestro', 'auto'];
 /**
  * Quem autoriza o push desta thread.
  *
- * `#Look` e `#Ork` pausam no proprio SHIP e esperam o humano. `#Classic` pausa antes,
- * no gate de evidencias, com autorizacao ANTECIPADA de push: aqui isso e conferido no
- * ledger, nao presumido. `#Maestro` e `#Auto` seguem pela #TAG, que fica registrada.
+ * `#Classic` pausa no gate de evidencias, com autorizacao ANTECIPADA de push: aqui isso
+ * e conferido no ledger, nao presumido. `#Maestro` e `#Auto` seguem pela #TAG, que fica
+ * registrada.
+ *
+ * I-43: thread LEGADA em `#Look` ou `#Ork` pausava no proprio SHIP. Ela continua caindo
+ * neste mesmo caminho (nao esta em `MODOS_QUE_AUTORIZAM_PUSH`, entao exige autorizacao
+ * registrada), e por isso a regra nao precisou de um ramo so para ela.
  */
 function autorizacaoDePush(raiz, thread, opcoes) {
     const tag = (0, modos_1.tagDoModo)(thread.modo);
@@ -112,8 +131,7 @@ function autorizacaoDePush(raiz, thread, opcoes) {
         tipo: 'pendente',
         por: '',
         razao: `o modo ${tag} pausa no push e ainda nao ha autorizacao humana registrada. ` +
-            `Autorize com: ork gate approve ${thread.id} push --por <quem>  ` +
-            `ou rode: ork ship ${thread.id} --para <branch> --autorizar-push <quem>`,
+            `Autorize na entrega: ork ship ${thread.id} --para <branch> --autorizar-push <quem>`,
     };
 }
 /** Diretorio temporario onde a arvore de merge e montada quando preciso. */
@@ -225,6 +243,7 @@ function baseDoResultado(thread, de, opcoes) {
         pushVerificado: false,
         autorizacao: { autorizado: false, tipo: 'pendente', por: '', razao: '' },
         verificacao: null,
+        ci: null,
         violacoes: [],
         lease: null,
         leaseOcupadoPor: null,
@@ -232,7 +251,78 @@ function baseDoResultado(thread, de, opcoes) {
         dryRun: opcoes.dryRun === true,
     };
 }
-/** Executa o SHIP da thread. Nunca lanca por reprovacao: reprovacao volta tipada. */
+/**
+ * A entrega ja feita por esta thread foi REVERTIDA na base? (I-43, D3, T7)
+ *
+ * Este era o buraco que tornava o indice de qualidade um numero que nunca muda:
+ * `rollback_done` existia na allowlist do ciclo e NAO era escrito por ninguem, e ele
+ * e o insumo de maior peso. Sem escritor, 23 das 29 threads entregues ficariam
+ * coladas no teto para sempre.
+ *
+ * A deteccao ancora no marcador que o PROPRIO git escreve. `git revert -m 1 <sha>`
+ * poe "This reverts commit <sha>" no corpo do commit, e e isso que se procura no
+ * historico da base DEPOIS do merge. Nao se infere reversao por diff de arvore: um
+ * arquivo que voltou ao estado anterior pode ser trabalho de outra thread, e chamar
+ * isso de reversao seria rebaixar entrega alheia por coincidencia.
+ *
+ * `para` e OPCIONAL, e isso e o que permite perguntar fora do ship (GO-FIX 1, A1):
+ * sem ele, o destino sai do proprio `ship_done`, que ja grava para onde entregou. Quem
+ * calcula o indice depois do MASTER nao tem branch de destino na mao, e inventar uma
+ * seria pior que nao perguntar.
+ *
+ * So le git; nao escreve nada. Quem grava o evento e `registrarReversaoDaEntrega`.
+ */
+function detectarReversaoDaEntrega(raiz, thread, para) {
+    const dir = (0, thread_1.dirThread)(raiz, thread.id);
+    const entregas = (0, ledger_1.lerLedger)(dir)
+        .filter((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.shipConcluido && typeof e.mergeSha === 'string')
+        .map((e) => ({ mergeSha: String(e.mergeSha), para: para ?? String(e.para ?? '') }))
+        .filter((e) => e.para.length > 0);
+    if (entregas.length === 0)
+        return null;
+    const perguntados = new Set();
+    for (const entrega of [...entregas].reverse()) {
+        const intervalo = `${entrega.mergeSha}..${entrega.para}`;
+        if (perguntados.has(intervalo))
+            continue;
+        perguntados.add(intervalo);
+        // O historico e append-only: o merge continua la, e o revert vem DEPOIS dele.
+        const log = (0, util_1.exec)('git', ['log', '--format=%H%x1f%B%x1e', intervalo], raiz, 60000);
+        if (!log.ok)
+            continue;
+        for (const bruto of log.stdout.split('\x1e')) {
+            const [sha, corpo] = bruto.split('\x1f');
+            if (!sha || !corpo)
+                continue;
+            if (corpo.includes(`This reverts commit ${entrega.mergeSha}`)) {
+                return { mergeSha: entrega.mergeSha, revertSha: sha.trim(), para: entrega.para };
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Grava `rollback_done` quando a reversao e nova, e devolve o que encontrou.
+ *
+ * IDEMPOTENTE por `revertSha`: o ledger e append-only e o mesmo revert nao pode
+ * rebaixar a thread duas vezes so porque alguem rodou o comando de novo.
+ */
+function registrarReversaoDaEntrega(raiz, thread, para) {
+    const achada = detectarReversaoDaEntrega(raiz, thread, para);
+    if (!achada)
+        return null;
+    const dir = (0, thread_1.dirThread)(raiz, thread.id);
+    const jaRegistrada = (0, ledger_1.lerLedger)(dir).some((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.rollbackConcluido && e.revertSha === achada.revertSha);
+    if (jaRegistrada)
+        return achada;
+    (0, ledger_1.registrar)(dir, thread.id, ledger_1.TIPOS_DE_EVENTO.rollbackConcluido, {
+        fase: 'SHIP',
+        ...achada,
+        prova: `git log ${achada.mergeSha.slice(0, 8)}..${achada.para} traz "This reverts commit ${achada.mergeSha}" em ${achada.revertSha.slice(0, 8)}`,
+        razao: 'I-43: a entrega foi desfeita na base; e o insumo de maior peso do indice de qualidade',
+    });
+    return achada;
+}
 function ship(carregado, threadId, opcoes) {
     const { raiz, manifesto } = carregado;
     const thread = (0, thread_1.lerThread)(raiz, threadId);
@@ -241,6 +331,14 @@ function ship(carregado, threadId, opcoes) {
     const para = opcoes.para;
     const remoto = opcoes.remoto ?? 'origin';
     const r = baseDoResultado(thread, de, opcoes);
+    // I-43 (T7): antes de qualquer coisa, se a entrega ANTERIOR desta thread foi
+    // revertida na base, isso vira `rollback_done`. E o insumo de maior peso do indice
+    // de qualidade, e o unico fato que diz sem interpretacao que a entrega nao servia.
+    // Idempotente: o mesmo revert nao rebaixa a thread duas vezes.
+    try {
+        registrarReversaoDaEntrega(raiz, thread, para);
+    }
+    catch { /* git indisponivel nao barra o ship */ }
     const bloquear = (motivo, detalhe, correcao) => {
         (0, gates_1.registrarGateBloqueado)(dir, threadId, {
             gate: 'ship',
@@ -266,22 +364,36 @@ function ship(carregado, threadId, opcoes) {
     const autorizacao = autorizacaoDePush(raiz, thread, opcoes);
     r.autorizacao = autorizacao;
     if (!autorizacao.autorizado) {
-        return bloquear('human.pending', autorizacao.razao, `ork gate approve ${threadId} push --por <quem>`);
+        return bloquear('human.pending', autorizacao.razao, `ork ship ${threadId} --para <branch> --autorizar-push <quem>`);
     }
-    // 2. Policies do manifesto que valem no gate `ship`.
+    // 2. Policies do manifesto que valem no gate `ship`. RM-008 (fatia 3): a branch da thread
+    // atras da base e fato do git, calculado aqui (a ponta da base nao esta contida na branch).
+    const pontaDe = shaDaRef(raiz, `refs/heads/${de}`);
+    const pontaPara = shaDaRef(raiz, `refs/heads/${para}`);
+    const branchAtrasDaBase = pontaDe && pontaPara && de !== para
+        ? !(0, util_1.exec)('git', ['merge-base', '--is-ancestor', pontaPara, pontaDe], raiz).ok
+        : undefined;
     const violacoes = (0, policies_1.avaliarPolicies)(manifesto, {
         gate: 'ship',
         de,
         para,
         baseBranch: manifesto.worktree.base_branch,
+        threadId,
+        branchAtrasDaBase,
     });
     r.violacoes = violacoes;
+    if (!r.dryRun) {
+        for (const v of (0, policies_1.avisos)(violacoes)) {
+            (0, ledger_1.registrar)(dir, threadId, ledger_1.TIPOS_DE_EVENTO.politicaAviso, { gate: 'ship', de, para,
+                policy: v.policy, detalhe: v.detalhe, correcao: v.correcao, modo: thread.modo });
+        }
+    }
     const bloqueiam = (0, policies_1.bloqueantes)(violacoes);
     if (bloqueiam.length > 0) {
         return bloquear('policy.violation', bloqueiam.map((v) => `${v.policy}: ${v.detalhe}`).join('; '), bloqueiam.map((v) => v.correcao).join('; '));
     }
     // 3. Verificacao independente: reexecuta claims e comandos no HEAD real da thread.
-    const verificacao = (0, verify_1.verificar)(carregado, threadId);
+    const verificacao = (0, verify_1.verificar)(carregado, threadId, { executor: opcoes.executorVerify });
     r.verificacao = verificacao;
     if (!verificacao.ok) {
         const motivo = verificacao.motivos.find((m) => m !== 'claims.unverifiable');
@@ -298,6 +410,19 @@ function ship(carregado, threadId, opcoes) {
     }
     r.shaDe = shaDe;
     r.shaParaAntes = shaPara;
+    // I-42 (D7): a fronteira do commit MCP vale tambem na entrega, onde aparece o commit feito
+    // por git direto. Ciclo sem PLAN nem CHECK nao entrega contrato publico.
+    const tocados = (0, prova_minima_1.cicloSemCheck)(thread) ? contratosDaEntrega(raiz, shaPara, shaDe) : [];
+    if (tocados.length > 0) {
+        return bloquear('policy.violation', `contrato publico em ciclo sem PLAN nem CHECK: ${tocados.join(', ')}`, 'refaca a mudanca numa thread #Classic, #Maestro ou #Auto');
+    }
+    // O recibo vem do provedor e pertence ao SHA exato da candidata. Teste local
+    // verde ou status de outro commit não libera a entrega.
+    const ci = (0, ci_1.consultarCi)(carregado, shaDe, remoto, opcoes.executorCi);
+    r.ci = ci;
+    if (!ci.ok) {
+        return bloquear('ci.failed', `${ci.detail} (commit ${shaDe}, contexto ${ci.context})`, `publique a branch, aguarde o check ${ci.context} verde no GitHub e repita o SHIP`);
+    }
     // 4. Lease `main-tree`: so uma thread mergeia por vez.
     if (r.dryRun) {
         const ocupado = (0, leases_1.lerLease)(raiz, leases_1.LEASE_MAIN_TREE);
@@ -334,6 +459,7 @@ function ship(carregado, threadId, opcoes) {
         thread: threadId,
         motivo: `ship de ${de} para ${para}`,
         ttlMs: opcoes.ttlLeaseMs,
+        retomarVencido: opcoes.retomarLeaseVencido,
     });
     if (!aquisicao.ok) {
         r.leaseOcupadoPor = aquisicao.ocupadoPor;
@@ -369,6 +495,7 @@ function ship(carregado, threadId, opcoes) {
     let arvore = null;
     try {
         try {
+            opcoes.revalidarGit?.('preparar');
             arvore = prepararArvore(raiz, para);
         }
         catch (e) {
@@ -376,6 +503,7 @@ function ship(carregado, threadId, opcoes) {
             return bloquear('tree.blocked', e.message, 'deixe a arvore da branch de destino limpa (ou libere a branch) e rode o ship de novo');
         }
         const passos = [];
+        opcoes.revalidarGit?.('merge', arvore.dir);
         // 5. Merge --no-ff, conferido no proprio git.
         const jaIncorporado = (0, util_1.exec)('git', ['merge-base', '--is-ancestor', shaDe, shaPara], raiz).ok;
         r.jaIncorporado = jaIncorporado;
@@ -410,6 +538,7 @@ function ship(carregado, threadId, opcoes) {
             passos.push(`(nada a mergear: ${de} ja e ancestral de ${para})`);
         }
         r.mergeSha = mergeSha;
+        opcoes.revalidarGit?.('push', arvore.dir);
         // 6. Push PROVADO por ls-remote.
         const temRemoto = remotoConfigurado(arvore.dir, remoto);
         r.remoto = temRemoto ? remoto : null;
@@ -468,12 +597,18 @@ function ship(carregado, threadId, opcoes) {
             evidencia: {
                 verificadoNoCommit: verificacao.commit,
                 claimsVerificadas: verificacao.claims.filter((c) => c.verificado).map((c) => c.claim.id),
-                comandos: verificacao.comandos.map((c) => ({ nome: c.nome, ok: c.ok })),
+                // I-37 (T9): a mesma evidencia do `verify_run`, com causa, prazo e o teste que caiu.
+                comandos: verificacao.comandos.map(verify_1.comandoNoLedger),
+                ci,
                 passos,
             },
         });
+        (0, fabrica_publicar_1.publicarEmSegundoPlano)(raiz);
         const atualizada = (0, thread_1.lerThread)(raiz, threadId);
-        atualizada.faseAtual = 'SHIP';
+        // I-42: ciclo sem SHIP (o `#Fast`) entrega sem trocar de fase; `faseAtual` fica sempre
+        // dentro do ciclo, porque board, pulse e prompt resolvem o bloco a partir dela.
+        if (!atualizada.fases?.length || atualizada.fases.includes('SHIP'))
+            atualizada.faseAtual = 'SHIP';
         atualizada.leases = [
             ...(atualizada.leases ?? []),
             { nome: leases_1.LEASE_MAIN_TREE, adquiridoEm: aquisicao.lease?.adquiridoEm ?? (0, util_1.agora)(), liberadoEm: (0, util_1.agora)() },
@@ -495,20 +630,34 @@ function ship(carregado, threadId, opcoes) {
 /** Texto de `ork ship` para o CLI. */
 function textoDoShip(r) {
     const linhas = [];
+    // I-35: horários no fuso do dono, sem rótulo por linha; o fuso é dito uma vez, no fim.
+    let comHorario = false;
+    const local = (texto) => {
+        const localizado = (0, horario_1.localizarTexto)(texto);
+        if (localizado !== texto)
+            comHorario = true;
+        return localizado;
+    };
+    const fechar = () => (comHorario ? [...linhas, (0, horario_1.legendaDoFuso)()] : linhas).join('\n');
     const cabecalho = r.dryRun ? 'ork ship (--dry-run, nada foi executado)' : 'ork ship';
     linhas.push(`${cabecalho}: thread ${r.thread}`);
     linhas.push(`  de            ${r.de}${r.shaDe ? ` @ ${r.shaDe.slice(0, 8)}` : ''}`);
     linhas.push(`  para          ${r.para}${r.shaParaAntes ? ` @ ${r.shaParaAntes.slice(0, 8)}` : ''}`);
     linhas.push(`  autorizacao   ${r.autorizacao.autorizado ? `AUTORIZADO por ${r.autorizacao.por} (${r.autorizacao.tipo})` : 'AGUARDANDO AUTORIZACAO HUMANA'}`);
-    linhas.push(`                ${r.autorizacao.razao}`);
+    linhas.push(`                ${local(r.autorizacao.razao)}`);
     if (r.verificacao) {
         const v = r.verificacao;
         linhas.push(`  verificacao   ${v.ok ? 'passou' : 'REPROVOU'} no HEAD ${v.commit.slice(0, 8)} ` +
             `(${v.claims.filter((c) => c.verificado).length}/${v.claims.length} claims, ` +
             `${v.comandos.filter((c) => c.ok).length}/${v.comandos.length} comandos)`);
     }
+    if (r.ci) {
+        linhas.push(`  ci             ${r.ci.required ? `${r.ci.state.toUpperCase()} ${r.ci.context} em ${r.ci.sha.slice(0, 8)}` : 'não exigido'}`);
+    }
+    linhas.push(...(0, policies_1.linhasDeAviso)(r.violacoes ?? []));
     if (r.leaseOcupadoPor) {
-        linhas.push(`  lease         ${leases_1.LEASE_MAIN_TREE} OCUPADO pela thread ${r.leaseOcupadoPor.thread} (desde ${r.leaseOcupadoPor.adquiridoEm})`);
+        comHorario = true;
+        linhas.push(`  lease         ${leases_1.LEASE_MAIN_TREE} OCUPADO pela thread ${r.leaseOcupadoPor.thread} (desde ${(0, horario_1.formatarDataHora)(r.leaseOcupadoPor.adquiridoEm)})`);
     }
     else if (r.lease) {
         linhas.push(`  lease         ${leases_1.LEASE_MAIN_TREE} tomado por ${r.thread} e liberado ao fim`);
@@ -519,16 +668,16 @@ function textoDoShip(r) {
     if (r.bloqueado) {
         linhas.push('');
         linhas.push(`BLOQUEADO. motivo tipado: ${r.motivo}`);
-        linhas.push(`  detalhe   ${r.detalhe}`);
+        linhas.push(`  detalhe   ${local(r.detalhe)}`);
         linhas.push(`  correcao  ${r.correcao}`);
-        return linhas.join('\n');
+        return fechar();
     }
     if (r.dryRun) {
         linhas.push('');
         linhas.push('Passos que o ship real executaria, nesta ordem:');
         for (const p of r.passos)
             linhas.push(`  ${p}`);
-        return linhas.join('\n');
+        return fechar();
     }
     linhas.push('');
     linhas.push(r.jaIncorporado
@@ -539,7 +688,7 @@ function textoDoShip(r) {
         linhas.push(`  e o destino local esta no mesmo sha: ${r.mergeSha}`);
     }
     else {
-        linhas.push(`Push nao provado: ${r.detalhe || 'sem remoto configurado'}`);
+        linhas.push(`Push nao provado: ${local(r.detalhe) || 'sem remoto configurado'}`);
     }
     linhas.push('');
     linhas.push('Evidencia (comandos executados):');
@@ -547,5 +696,5 @@ function textoDoShip(r) {
         linhas.push(`  ${p}`);
     linhas.push('');
     linhas.push(`Ledger: ork phase list ${r.thread}  (evento ship_done)`);
-    return linhas.join('\n');
+    return fechar();
 }

package/dist/slug.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * Slug de sessao em 3 partes (visao unificada, secao 3.4).
+ * Slug de sessao em 3 partes (conceitos: docs/conceitos/visao-geral.md).
  *
  *   <produto ate 3 letras>-<assunto ate 12 chars>-<fases>[-<rotacao>]
  *

package/dist/thread-close.js

@@ -0,0 +1,115 @@
+"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.validarArtefato = validarArtefato;
+exports.provaDeEntrega = provaDeEntrega;
+exports.exigirEntrega = exigirEntrega;
+exports.registrarArtefato = registrarArtefato;
+exports.fecharAdministrativamente = fecharAdministrativamente;
+/** Encerramento administrativo não representa uma entrega nem um score humano. */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const thread_1 = require("./thread");
+const ledger_1 = require("./ledger");
+const estado_thread_1 = require("./estado-thread");
+const util_1 = require("./util");
+const fabrica_publicar_1 = require("./fabrica-publicar");
+function validarArtefato(raiz, arquivo, sha256) {
+    if (!/^[a-f0-9]{64}$/.test(sha256))
+        throw new Error('sha256 inválido');
+    const root = fs.realpathSync((0, estado_thread_1.raizDoEstado)(raiz));
+    const destino = fs.realpathSync(path.resolve(root, arquivo));
+    const relativo = path.relative(root, destino);
+    if (!relativo || relativo === '..' || relativo.startsWith(`..${path.sep}`) || path.isAbsolute(relativo)) {
+        throw new Error('artefato deve estar dentro do projeto');
+    }
+    if (!fs.statSync(destino).isFile())
+        throw new Error('artefato deve ser arquivo regular');
+    if ((0, node_crypto_1.createHash)('sha256').update(fs.readFileSync(destino)).digest('hex') !== sha256) {
+        throw new Error('hash do artefato diverge');
+    }
+    return { tipo: 'artefato', arquivo: relativo, sha256 };
+}
+function provaDeEntrega(raiz, id) {
+    const eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, id));
+    const ship = [...eventos].reverse().find(e => e.tipo === ledger_1.TIPOS_DE_EVENTO.shipConcluido);
+    if (ship)
+        return { tipo: 'ship', ts: ship.ts, mergeSha: String(ship.mergeSha ?? '') };
+    for (const e of eventos.filter(e => e.tipo === ledger_1.TIPOS_DE_EVENTO.artefatoEntregue).reverse()) {
+        try {
+            return validarArtefato(raiz, String(e.arquivo), String(e.sha256));
+        }
+        catch { /* prova precisa continuar válida */ }
+    }
+    return null;
+}
+function exigirEntrega(raiz, id) {
+    const t = (0, thread_1.lerThread)(raiz, id);
+    if (t.fechamentoAdmin)
+        throw new Error('thread encerrada administrativamente não pode receber MASTER');
+    const prova = provaDeEntrega(raiz, id);
+    if (!prova)
+        throw new Error('MASTER exige entrega: ship_done ou artefato existente com hash verificado');
+    return prova;
+}
+function registrarArtefato(raiz, id, arquivo, sha256, por) {
+    const t = (0, thread_1.lerThread)(raiz, id);
+    if (t.status === 'fechada' || !por.trim())
+        throw new Error('artefato exige thread aberta e autoria explícita');
+    const prova = validarArtefato(raiz, arquivo, sha256);
+    (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, id), id, ledger_1.TIPOS_DE_EVENTO.artefatoEntregue, { arquivo, sha256, fase: 'SHIP', por: por.trim() });
+    return prova;
+}
+function fecharAdministrativamente(raiz, id, opcoes) {
+    if (!['orfa', 'engano', 'superada'].includes(opcoes.motivo))
+        throw new Error('motivo deve ser orfa, engano ou superada');
+    if (!opcoes.por.trim() || opcoes.justificativa.trim().length < 3)
+        throw new Error('fechamento exige autoria e justificativa');
+    const t = (0, thread_1.lerThread)(raiz, id);
+    if (t.fechamentoAdmin) {
+        if (t.fechamentoAdmin.motivo !== opcoes.motivo)
+            throw new Error('thread já encerrada por outro motivo');
+        return t;
+    }
+    if (provaDeEntrega(raiz, id) || t.score)
+        throw new Error('thread entregue ou pontuada exige MASTER, não fechamento administrativo');
+    t.fechamentoAdmin = { motivo: opcoes.motivo, por: opcoes.por.trim(), justificativa: opcoes.justificativa.trim(), fechadoEm: (0, util_1.agora)() };
+    (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, id), id, ledger_1.TIPOS_DE_EVENTO.threadFechadaAdmin, t.fechamentoAdmin);
+    t.status = 'fechada';
+    (0, thread_1.gravarThread)(raiz, t);
+    (0, fabrica_publicar_1.publicarEmSegundoPlano)(raiz);
+    return t;
+}