@orkastery/cli 0.5.6 → 0.6.1

package/dist/ship.js

@@ -59,6 +59,7 @@ exports.shaDaRef = shaDaRef;
 exports.shaNoRemoto = shaNoRemoto;
 exports.remotoConfigurado = remotoConfigurado;
 exports.detectarReversaoDaEntrega = detectarReversaoDaEntrega;
+exports.unscannedCategories = unscannedCategories;
 exports.registrarReversaoDaEntrega = registrarReversaoDaEntrega;
 exports.ship = ship;
 exports.textoDoShip = textoDoShip;
@@ -71,16 +72,22 @@ const ledger_1 = require("./ledger");
 const manifest_1 = require("./manifest");
 const modos_1 = require("./modos");
 const policies_1 = require("./policies");
+const estado_thread_1 = require("./estado-thread");
+const report_1 = require("./security-scan/report");
+const types_1 = require("./security-scan/types");
 const thread_1 = require("./thread");
 const util_1 = require("./util");
 const verify_1 = require("./verify");
 const ci_1 = require("./ci");
+const forja_1 = require("./forja");
 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");
+const mcp_ship_transporte_1 = require("./mcp-ship-transporte");
 const branch_de_estado_1 = require("./branch-de-estado");
 const locale_1 = require("./locale");
+const noctum_guarda_1 = require("./noctum-guarda");
 /**
  * RM-037 (fatia 5, A1): o commit de primeiro pai da base que incorporou o `shaDe`: o merge que trouxe a branch, ou
  * o proprio `shaDe` quando a base avancou por fast-forward ate ele. Com a branch ja incorporada, a ponta da base e
@@ -235,12 +242,17 @@ function prepararArvore(raiz, para) {
     return { dir, temporaria: true };
 }
 /** Remove a worktree temporaria do merge (best effort: o lease ja foi liberado). */
-function descartarArvore(raiz, arvore) {
+function descartarArvore(raiz, arvore, trava = []) {
     if (!arvore.temporaria)
         return;
-    (0, util_1.exec)('git', ['worktree', 'remove', '--force', arvore.dir], raiz);
-    (0, util_1.exec)('git', ['worktree', 'prune'], raiz);
+    (0, util_1.exec)('git', [...trava, 'worktree', 'remove', '--force', arvore.dir], raiz);
+    (0, util_1.exec)('git', [...trava, 'worktree', 'prune'], raiz);
 }
+/**
+ * O git local que o transporte fixado roda no projeto depois da ultima conferencia: nenhum hook (o
+ * `reference-transaction` do `update-ref`, inclusive) e nenhum fsmonitor, que o agente pode ter posto ali durante o push.
+ */
+const TRAVA_LOCAL_DO_FIXADO = ['-c', 'core.hooksPath=/dev/null', '-c', 'core.fsmonitor='];
 /** sha de uma referencia local, ou null quando ela nao existe. */
 function shaDaRef(dir, ref) {
     const r = (0, util_1.exec)('git', ['rev-parse', '--verify', '--quiet', ref], dir);
@@ -253,9 +265,34 @@ function shaDaRef(dir, ref) {
  * E o unico jeito aceito de provar push nesta maquina: `gh api` e imprevisivel aqui, e o
  * codigo de saida do `git push` nao prova que o remoto ficou com o commit certo.
  */
-function shaNoRemoto(dir, remoto, branch) {
+function shaNoRemoto(dir, remoto, branch, config = []) {
     // RM-047: so nome de remoto chega ao git, e depois do `--` (nunca vira opcao nem transporte).
-    const r = (0, util_1.exec)('git', ['ls-remote', '--', (0, branch_de_estado_1.exigirRemoto)(remoto, 'ship'), `refs/heads/${branch}`], dir, 120000);
+    const r = (0, util_1.exec)('git', [...configDoRemotoValida(config), 'ls-remote', '--', (0, branch_de_estado_1.exigirRemoto)(remoto, 'ship'), `refs/heads/${branch}`], dir, 120000);
+    return shaDoLsRemote(r, branch);
+}
+function validarUrlFixada(url, config) {
+    const protocolo = (0, mcp_ship_transporte_1.protocoloDaConfigDeRede)(config);
+    const recusa = () => { throw new locale_1.ErroDoCatalogo((m) => m.ship.configDoRemotoInvalida('urlFixada')); };
+    if (!protocolo || typeof url !== 'string' || /[\x00-\x20\x7f]/.test(url) || url.startsWith('-'))
+        return recusa();
+    try {
+        const e = (0, mcp_ship_transporte_1.enderecoDoOrigin)(protocolo === 'ssh' ? 'forja-ssh' : 'forja-https', url);
+        if (e.transporte === 'forja-https' && (0, mcp_ship_transporte_1.urlDaConfigDeRede)(config) !== url)
+            return recusa();
+    }
+    catch {
+        return recusa();
+    }
+    return { url, protocolo };
+}
+/** O git que vai a rede no transporte fixado: do gitdir privado, so com o protocolo do modo. */
+function gitDoRemotoFixado(f, args, timeoutMs) {
+    return (0, util_1.exec)('git', [`--git-dir=${f.gitdir}`, ...f.config, ...args], f.gitdir, timeoutMs, { ...process.env, GIT_ALLOW_PROTOCOL: f.protocolo });
+}
+function shaNoRemotoFixado(f, branch) {
+    return shaDoLsRemote(gitDoRemotoFixado(f, ['ls-remote', '--', f.url, `refs/heads/${branch}`], 120000), branch);
+}
+function shaDoLsRemote(r, branch) {
     if (!r.ok)
         return null;
     // RM-059 (S1 da revisao da ork-rm059pista): o padrao do ls-remote casa por sufixo; vale so a linha da ref exata.
@@ -263,6 +300,14 @@ function shaNoRemoto(dir, remoto, branch) {
     const sha = linha?.[0] ?? '';
     return /^[0-9a-f]{40}$/.test(sha) ? sha : null;
 }
+/** So a lista que `configDeRede` emite, chave e valor: nenhuma outra opcao, chave ou valor chega antes do subcomando de rede. */
+function configDoRemotoValida(config) {
+    const recusada = (0, mcp_ship_transporte_1.chaveRecusadaDaConfigDeRede)(config);
+    // Nunca ecoa o valor: so a chave (ate 80 caracteres) mostra o que foi recusado.
+    if (recusada !== null)
+        throw new locale_1.ErroDoCatalogo((m) => m.ship.configDoRemotoInvalida(recusada.slice(0, 80)));
+    return config;
+}
 /** O remoto esta configurado neste repositorio? */
 function remotoConfigurado(dir, remoto) {
     return (0, util_1.exec)('git', ['remote', 'get-url', '--', (0, branch_de_estado_1.exigirRemoto)(remoto, 'ship')], dir).ok;
@@ -347,6 +392,23 @@ function detectarReversaoDaEntrega(raiz, thread, para) {
     }
     return null;
 }
+/**
+ * Loop categories (secret, dependency, sast, iac, workflow) not scanned for `sha` (spec 11.2): `[]` without
+ * `verify.security_scan` and with `ci.required_for_ship` (the scan is then in the CI bundle, which the independent CI
+ * check covers). Otherwise the report of `sha` decides: a loop tool `unavailable` or `failed` leaves its category
+ * unscanned (the spec says `unavailable`; a `failed` loop tool is equally not scanned, never clean), except the
+ * "nothing to scan" reasons excused by `isExcusedUnscanned` (same rule as the exit code), and no report at all leaves
+ * every loop category unscanned (no evidence is not clean). Sorted, distinct.
+ */
+function unscannedCategories(carregado, sha) {
+    if (carregado.manifesto.verify.security_scan === undefined || carregado.manifesto.ci.required_for_ship)
+        return [];
+    const report = (0, report_1.readReport)((0, estado_thread_1.raizDoEstado)(carregado.raiz), sha);
+    if (!report)
+        return [...types_1.LOOP_CATEGORIES].sort();
+    const missing = (0, report_1.unscannedLoopTools)(report).map(t => t.category);
+    return [...new Set(missing)].sort();
+}
 /**
  * Grava `rollback_done` quando a reversao e nova, e devolve o que encontrou.
  *
@@ -379,7 +441,20 @@ function ship(carregado, threadId, opcoes) {
     // so nome de remoto passa; o resto recusa com `ship.remoto-invalido`, e o ship nao entrega sem push provado
     // por um remoto que nunca existiu.
     const remoto = (0, branch_de_estado_1.exigirRemoto)(opcoes.remoto ?? 'origin', 'ship');
+    const configDoRemoto = configDoRemotoValida(opcoes.configDoRemoto ?? []);
+    const comConfig = (args) => `git ${[...configDoRemoto, ...args].join(' ')}`;
+    const urlFixada = opcoes.urlFixada === undefined ? null : validarUrlFixada(opcoes.urlFixada, configDoRemoto);
+    // Nos passos, o gitdir privado e a URL fixada vao por nome: o caminho temporario nao diz nada a quem le.
     const r = baseDoResultado(thread, de, opcoes);
+    // RM-058, integracao (T1.1, D3 da ork-rm058integra): a thread de um arco #Noctum que a guarda e entregue pelo passo da
+    // entrega do arco, nunca por aqui (nem pelo `ork_ship` do MCP, que chama este mesmo ship). A recusa vem antes de qualquer
+    // git e nao vai ao ledger da thread: um `ship_blocked` ou um gate por uma tentativa de fora pesaria no indice da thread e
+    // apareceria como pausa do dono na fila do arco.
+    const guarda = (0, noctum_guarda_1.guardaDaThread)(raiz, threadId);
+    if (guarda) {
+        return { ...r, autorizacao: autorizacaoDePush(raiz, thread, opcoes), bloqueado: true, ok: false, motivo: 'policy.violation',
+            codigo: guarda.motivo, detalhe: guarda.detalhe, correcao: guarda.correcao };
+    }
     // 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.
@@ -388,7 +463,18 @@ function ship(carregado, threadId, opcoes) {
         registrarReversaoDaEntrega(raiz, thread, para);
     }
     catch { /* git indisponivel nao barra o ship */ }
-    const bloquear = (motivo, detalhe, correcao) => {
+    // O push pode ter saido: a troca do origin ou da config durante ele bloqueia o gate no ledger e sobe tipada.
+    const conferirDepoisDoPush = (passos) => {
+        try {
+            opcoes.conferirDepoisDoPush?.();
+        }
+        catch (e) {
+            r.passos = passos;
+            bloquear('runtime.unavailable', e instanceof locale_1.ErroDoCatalogo ? (0, locale_1.textoDoCatalogo)(e.montar) : e.message, (0, locale_1.textoDoCatalogo)((m) => m.ship.pushSemProvaCorrecao), 'transport.mudou-no-push');
+            throw e;
+        }
+    };
+    const bloquear = (motivo, detalhe, correcao, codigo) => {
         (0, gates_1.registrarGateBloqueado)(dir, threadId, {
             gate: 'ship',
             motivo,
@@ -404,12 +490,13 @@ function ship(carregado, threadId, opcoes) {
             de,
             para,
             motivo,
+            ...(codigo ? { codigo } : {}),
             detalhe,
             correcao,
             modo: thread.modo,
             dryRun: r.dryRun,
         });
-        return { ...r, bloqueado: true, ok: false, motivo, detalhe, correcao };
+        return { ...r, bloqueado: true, ok: false, motivo, detalhe, correcao, ...(codigo ? { codigo } : {}) };
     };
     // 1. Autorizacao de push pelo gate do modo de conducao.
     const autorizacao = autorizacaoDePush(raiz, thread, opcoes);
@@ -497,6 +584,21 @@ function ship(carregado, threadId, opcoes) {
     if (!ci.ok) {
         return bloquear('ci.failed', (0, locale_1.textoDoCatalogo)((m) => m.ship.ciReprovou((0, locale_1.remontar)(ci.detail), shaDe, ci.context)), (0, locale_1.textoDoCatalogo)((m) => m.ship.ciReprovouCorrecao(ci.context)));
     }
+    // Security scan (spec 11.2): com `verify.security_scan` e sem o scan no bundle do CI, categoria do laco sem varredura
+    // no SHA da candidata pede autorizacao humana, antes de qualquer push.
+    const naoVarridas = unscannedCategories(carregado, shaDe);
+    let autorizariaSemScan = null;
+    if (naoVarridas.length > 0) {
+        const quem = opcoes.allowUnscanned?.trim();
+        if (!quem) {
+            return bloquear('human.pending', (0, locale_1.textoDoCatalogo)((m) => m.ship.scanNaoVarrido(naoVarridas.join(', '), shaDe)), (0, locale_1.textoDoCatalogo)((m) => m.ship.scanNaoVarridoCorrecao(threadId)));
+        }
+        // O ensaio nao grava a autorizacao: so diz, nos passos, o que o ship real gravaria.
+        if (r.dryRun)
+            autorizariaSemScan = (0, locale_1.textoDoCatalogo)((m) => m.ship.passoAutorizariaSemScan(quem, naoVarridas.join(', '), shaDe));
+        else
+            (0, ledger_1.registrar)(dir, threadId, ledger_1.TIPOS_DE_EVENTO.entregaSemScanAutorizada, { por: quem, categorias: naoVarridas, sha: shaDe });
+    }
     // 4. Lease `main-tree`: so uma thread mergeia por vez.
     if (r.dryRun) {
         const ocupado = (0, leases_1.leasesColidentes)(raiz, leases_1.LEASE_MAIN_TREE)[0] ?? null;
@@ -514,6 +616,7 @@ function ship(carregado, threadId, opcoes) {
             ? (m) => opcoes.semPush ? m.ship.semPushPorFlag : m.ship.semRemoto(remoto) : null;
         r.passos = [
             r.detalhe,
+            ...(autorizariaSemScan ? [autorizariaSemScan] : []),
             (0, locale_1.textoDoCatalogo)((m) => m.ship.passoMerge(de)),
             ...(semPushNoReal ? [(0, locale_1.textoDoCatalogo)((m) => m.ship.passoSemPush(semPushNoReal(m)))] : [
                 `git push ${remoto} ${para}`,
@@ -632,27 +735,65 @@ function ship(carregado, threadId, opcoes) {
         r.pontaDaBase = pontaDaBase;
         opcoes.revalidarGit?.('push', arvore.dir);
         // 6. Push PROVADO por ls-remote.
-        const temRemoto = remotoConfigurado(arvore.dir, remoto);
+        const temRemoto = urlFixada !== null || remotoConfigurado(arvore.dir, remoto);
         r.remoto = temRemoto ? remoto : null;
-        if (opcoes.semPush || !temRemoto) {
+        if (urlFixada && !opcoes.semPush) {
+            const fixado = { gitdir: (0, mcp_ship_transporte_1.criarGitdirDoPush)(raiz), ...urlFixada, config: configDoRemoto };
+            const comFixado = (args) => `git --git-dir=<gitdir privado> ${[...configDoRemoto, ...args].join(' ')}`.replaceAll(urlFixada.url, '<origin fixado>');
+            try {
+                // O sha e o decidido aqui. Sem `-u`: o gitdir privado nao tem branch para rastrear, e gravar o upstream na
+                // config do projeto mudaria a config conferida; o `ls-remote` que so decidia o `-u` sai junto.
+                const argsPush = ['push', '--', urlFixada.url, `${pontaDaBase}:refs/heads/${para}`];
+                const push = gitDoRemotoFixado(fixado, argsPush, 300000);
+                passos.push(comFixado(argsPush));
+                if (!push.ok) {
+                    r.passos = passos;
+                    const erro = (0, forja_1.detalheDoPush)(push.stderr || push.stdout);
+                    if ((0, forja_1.pushRecusadoPelaProtecao)(`${push.stderr}\n${push.stdout}`)) {
+                        return bloquear('runtime.unavailable', (0, locale_1.textoDoCatalogo)((m) => m.ship.pushBaseProtegida(remoto, para, erro)), (0, locale_1.textoDoCatalogo)((m) => m.ship.pushBaseProtegidaCorrecao(threadId)), 'entrega.base-protegida');
+                    }
+                    return bloquear('runtime.unavailable', (0, locale_1.textoDoCatalogo)((m) => m.ship.pushFalhou(remoto, para, erro)), (0, locale_1.textoDoCatalogo)((m) => m.ship.pushFalhouCorrecao));
+                }
+                const shaRemoto = shaNoRemotoFixado(fixado, para);
+                passos.push(comFixado(['ls-remote', '--', urlFixada.url, `refs/heads/${para}`]));
+                conferirDepoisDoPush(passos);
+                r.shaRemoto = shaRemoto;
+                r.pushVerificado = shaRemoto !== null && shaRemoto === pontaDaBase;
+                if (!r.pushVerificado) {
+                    r.passos = passos;
+                    return bloquear('runtime.unavailable', (0, locale_1.textoDoCatalogo)((m) => m.ship.pushSemProva(shaRemoto, pontaDaBase)), (0, locale_1.textoDoCatalogo)((m) => m.ship.pushSemProvaCorrecao));
+                }
+                // A ref de rastreio do projeto acompanha o remoto provado, como no push por nome; local, sem rede.
+                (0, util_1.exec)('git', [...TRAVA_LOCAL_DO_FIXADO, 'update-ref', '--', `refs/remotes/${remoto}/${para}`, pontaDaBase], raiz);
+            }
+            finally {
+                fs.rmSync(fixado.gitdir, { recursive: true, force: true });
+            }
+        }
+        else if (opcoes.semPush || !temRemoto) {
             r.pushVerificado = false;
             r.detalhe = (0, locale_1.textoDoCatalogo)((m) => opcoes.semPush ? m.ship.semPushPorFlag : m.ship.semRemoto(remoto));
         }
         else {
-            const existeNoRemoto = shaNoRemoto(arvore.dir, remoto, para) !== null;
+            const existeNoRemoto = shaNoRemoto(arvore.dir, remoto, para, configDoRemoto) !== null;
             const argsPush = existeNoRemoto
                 ? ['push', '--', remoto, `refs/heads/${para}:refs/heads/${para}`]
                 : ['push', '-u', '--', remoto, `refs/heads/${para}:refs/heads/${para}`];
-            const push = (0, util_1.exec)('git', argsPush, arvore.dir, 300000);
-            passos.push(`git ${argsPush.join(' ')}`);
+            const push = (0, util_1.exec)('git', [...configDoRemoto, ...argsPush], arvore.dir, 300000);
+            passos.push(comConfig(argsPush));
             if (!push.ok) {
                 r.passos = passos;
-                const erro = (push.stderr || push.stdout).trim().slice(0, 400);
+                const erro = (0, forja_1.detalheDoPush)(push.stderr || push.stdout);
+                // A protecao da base recusou: a entrega e por PR/MR e o registro dele. O motivo do gate nao muda, so a orientacao.
+                if ((0, forja_1.pushRecusadoPelaProtecao)(`${push.stderr}\n${push.stdout}`)) {
+                    return bloquear('runtime.unavailable', (0, locale_1.textoDoCatalogo)((m) => m.ship.pushBaseProtegida(remoto, para, erro)), (0, locale_1.textoDoCatalogo)((m) => m.ship.pushBaseProtegidaCorrecao(threadId)), 'entrega.base-protegida');
+                }
                 return bloquear('runtime.unavailable', (0, locale_1.textoDoCatalogo)((m) => m.ship.pushFalhou(remoto, para, erro)), (0, locale_1.textoDoCatalogo)((m) => m.ship.pushFalhouCorrecao));
             }
             // A prova: o sha que o REMOTO devolve tem que ser o mesmo do destino local.
-            const shaRemoto = shaNoRemoto(arvore.dir, remoto, para);
-            passos.push(`git ls-remote ${remoto} refs/heads/${para}`);
+            const shaRemoto = shaNoRemoto(arvore.dir, remoto, para, configDoRemoto);
+            passos.push(comConfig(['ls-remote', remoto, `refs/heads/${para}`]));
+            conferirDepoisDoPush(passos);
             r.shaRemoto = shaRemoto;
             r.pushVerificado = shaRemoto !== null && shaRemoto === pontaDaBase;
             if (!r.pushVerificado) {
@@ -695,7 +836,9 @@ function ship(carregado, threadId, opcoes) {
                 passos,
             },
         });
-        (0, fabrica_publicar_1.publicarEmSegundoPlano)(raiz);
+        // A publicacao da fabrica empurra pelo origin do projeto, sem o transporte fixado: no fixado, nao sai daqui.
+        if (!urlFixada)
+            (0, fabrica_publicar_1.publicarEmSegundoPlano)(raiz);
         const atualizada = (0, thread_1.lerThread)(raiz, threadId);
         // 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.
@@ -710,7 +853,7 @@ function ship(carregado, threadId, opcoes) {
     }
     finally {
         if (arvore)
-            descartarArvore(raiz, arvore);
+            descartarArvore(raiz, arvore, urlFixada ? TRAVA_LOCAL_DO_FIXADO : []);
         const solto = (0, leases_1.liberar)(raiz, leases_1.LEASE_MAIN_TREE, threadId);
         (0, ledger_1.registrar)(dir, threadId, ledger_1.TIPOS_DE_EVENTO.leaseLiberado, {
             lease: leases_1.LEASE_MAIN_TREE,

package/dist/superficie.js

@@ -90,6 +90,7 @@ exports.blocoDoFormato = blocoDoFormato;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const util_1 = require("./util");
+const locale_1 = require("./locale");
 /** Ordem canonica das regras novas, usada no catalogo e nas saidas. */
 exports.REGRAS_DE_SUPERFICIE = ['SP8', 'SP9', 'SP10', 'SP11', 'SP12'];
 /** O que cada nivel de confianca significa, dito por extenso em toda saida. */
@@ -1286,8 +1287,9 @@ function entradaBrutaDaSuperficie(a) {
 }
 /** Tabela dos achados da varredura. */
 function tabelaDaVarredura(r) {
+    const m = (0, locale_1.msg)().audit.superficie;
     if (r.achados.length === 0) {
-        return `Nenhum achado de superficie de ataque. ${r.detalhe}`;
+        return m.vazia(r.detalhe);
     }
     const linhas = r.achados.map((a) => [
         a.regra,
@@ -1298,30 +1300,31 @@ function tabelaDaVarredura(r) {
         `${a.arquivo}:${a.linha}`,
         a.titulo,
     ]);
-    return (0, util_1.tabela)(['REGRA', 'SEVERIDADE', 'CONFIANCA', 'FRAMEWORK', 'ROTA', 'EVIDENCIA', 'TITULO'], linhas);
+    return (0, util_1.tabela)([...m.cabecalho], linhas);
 }
 /** Texto completo de `ork audit surface`. */
 function textoDaVarredura(r) {
+    const m = (0, locale_1.msg)().audit.superficie;
     const L = [];
-    L.push('Varredura deterministica da superficie de ataque de rede (pack security-privacy, SP8..SP12)');
+    L.push(m.titulo);
     L.push('');
-    L.push(`  raiz          ${r.raiz}`);
-    L.push(`  escopo        ${r.detalhe}`);
-    L.push(`  frameworks    ${r.frameworks.length > 0 ? r.frameworks.join(', ') : '(nenhum reconhecido)'}`);
-    L.push(`  teto          ${r.limitePorRegra} achado(s) por regra`);
+    L.push(m.campo(m.campos.raiz, r.raiz));
+    L.push(m.campo(m.campos.escopo, r.detalhe));
+    L.push(m.campo(m.campos.frameworks, r.frameworks.length > 0 ? r.frameworks.join(', ') : m.nenhumFramework));
+    L.push(m.campo(m.campos.teto, m.teto(r.limitePorRegra)));
     L.push('');
     L.push(tabelaDaVarredura(r));
     L.push('');
     for (const t of r.truncados) {
-        L.push(`  ATENCAO: ${t.ocultos} achado(s) de ${t.regra} ficaram fora do teto desta varredura.`);
+        L.push(m.truncado(t.ocultos, t.regra));
     }
     const baixas = r.achados.filter((a) => a.confianca === 'baixa').length;
     if (baixas > 0) {
-        L.push(`  ${baixas} achado(s) sairam com confianca baixa: ${exports.DESCRICAO_DA_CONFIANCA.baixa}`);
+        L.push(m.baixa(baixas, exports.DESCRICAO_DA_CONFIANCA.baixa));
     }
     L.push('');
-    L.push('Cada achado carrega o comando que o reexecuta no HEAD real (o auditor nao tem self-report).');
-    L.push('Para registrar no board de divida de uma rodada: ork audit surface --registrar <rodada>');
+    L.push(m.claims);
+    L.push(m.registrar);
     return L.join('\n');
 }
 /** O bloco que a rodada deixa no `FORMATO.md` para o auditor nao repetir o que ja foi achado. */

package/dist/thread-close.js

@@ -51,17 +51,17 @@ const fechamento_1 = require("./fechamento");
 const locale_1 = require("./locale");
 function validarArtefato(raiz, arquivo, sha256) {
     if (!/^[a-f0-9]{64}$/.test(sha256))
-        throw new Error('sha256 inválido');
+        throw new locale_1.ErroDoCatalogo((m) => m.thread.sha256Invalido);
     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');
+        throw new locale_1.ErroDoCatalogo((m) => m.thread.artefatoForaDoProjeto);
     }
     if (!fs.statSync(destino).isFile())
-        throw new Error('artefato deve ser arquivo regular');
+        throw new locale_1.ErroDoCatalogo((m) => m.thread.artefatoNaoRegular);
     if ((0, node_crypto_1.createHash)('sha256').update(fs.readFileSync(destino)).digest('hex') !== sha256) {
-        throw new Error('hash do artefato diverge');
+        throw new locale_1.ErroDoCatalogo((m) => m.thread.artefatoDiverge);
     }
     return { tipo: 'artefato', arquivo: relativo, sha256 };
 }
@@ -90,24 +90,24 @@ function exigirEntrega(raiz, id) {
 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');
+        throw new locale_1.ErroDoCatalogo((m) => m.thread.artefatoExige);
     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');
+        throw new locale_1.ErroDoCatalogo((m) => m.thread.motivoDoFechamento);
     if (!opcoes.por.trim() || opcoes.justificativa.trim().length < 3)
-        throw new Error('fechamento exige autoria e justificativa');
+        throw new locale_1.ErroDoCatalogo((m) => m.thread.fechamentoExige);
     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');
+            throw new locale_1.ErroDoCatalogo((m) => m.thread.encerradaPorOutroMotivo);
         return t;
     }
     if (provaDeEntrega(raiz, id) || t.score)
-        throw new Error('thread entregue ou pontuada exige MASTER, não fechamento administrativo');
+        throw new locale_1.ErroDoCatalogo((m) => m.thread.entregueExigeMaster);
     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';