@orkastery/cli 0.2.0

package/dist/fix.js

@@ -0,0 +1,450 @@
+"use strict";
+/**
+ * GO-FIX e CHECK-REVERIFY automatizados (bloco B3).
+ *
+ * O melhor sub-loop do metodo era, ate aqui, manual: o CHECK reprovava, um humano lia o
+ * relatorio, escrevia a spec da correcao, mandava de volta ao GO e depois lembrava de
+ * reexecutar o CHECK inteiro. O B3 transforma esse ciclo em codigo, sem afrouxar nada:
+ *
+ *   - A spec do GO-FIX nasce do resultado REAL do `ork verify`, nao de prosa. Cada
+ *     correcao carrega o motivo tipado que a originou, o alvo exato (claim, comando ou
+ *     artefato), o comando que a julga e a saida real que provou a reprovacao.
+ *   - A classificacao A/B segue a regra do metodo (DoD 10, skill `check-quality`):
+ *     tipo A e uma linha ou equivalente e reexecuta so o que foi afetado; tipo B devolve
+ *     a tarefa ao GO, e o CHECK seguinte e reexecucao COMPLETA. Rodada com um unico tipo
+ *     B RECUSA reverify parcial, porque "parcial depois de tipo B nao e CHECK".
+ *   - O veredito e POR CORRECAO, alem do veredito final da rodada.
+ *
+ * Onde o humano continua entrando: no LIMITE DE ESCALACAO. Estouradas as tentativas do
+ * manifesto, a rodada sai `BLOQUEADO` e sobe para o humano, pausando QUALQUER modo,
+ * inclusive `#Auto`. Ate esse limite, `#Maestro` e `#Auto` atravessam sozinhos.
+ *
+ * Este modulo nao reimplementa verificacao: quem diz a verdade continua sendo o
+ * `ork verify` do B1, reexecutado no HEAD real.
+ */
+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.caminhoDosFixes = caminhoDosFixes;
+exports.lerCorrecoes = lerCorrecoes;
+exports.correcoesDaRodada = correcoesDaRodada;
+exports.ultimaRodada = ultimaRodada;
+exports.tipoDoMotivo = tipoDoMotivo;
+exports.derivarCorrecoes = derivarCorrecoes;
+exports.specDoGoFix = specDoGoFix;
+exports.abrirRodada = abrirRodada;
+exports.reverificar = reverificar;
+exports.rodadasGastas = rodadasGastas;
+exports.textoDaRodada = textoDaRodada;
+exports.textoDoReverify = textoDoReverify;
+const path = __importStar(require("node:path"));
+const gates_1 = require("./gates");
+const ledger_1 = require("./ledger");
+const thread_1 = require("./thread");
+const util_1 = require("./util");
+const verify_1 = require("./verify");
+/** Armazem append-only das correcoes da thread. */
+function caminhoDosFixes(raiz, threadId) {
+    return path.join((0, thread_1.dirThread)(raiz, threadId), 'fixes.jsonl');
+}
+/** Todas as correcoes ja registradas na thread (a ultima gravacao de um id vence). */
+function lerCorrecoes(raiz, threadId) {
+    return (0, util_1.lerJsonl)(caminhoDosFixes(raiz, threadId));
+}
+/** Correcoes de uma rodada especifica. */
+function correcoesDaRodada(raiz, threadId, rodada) {
+    return lerCorrecoes(raiz, threadId).filter((c) => c.rodada === rodada);
+}
+/** Numero da ultima rodada de GO-FIX aberta na thread (0 quando nao houve nenhuma). */
+function ultimaRodada(raiz, threadId) {
+    return lerCorrecoes(raiz, threadId).reduce((max, c) => Math.max(max, c.rodada), 0);
+}
+/**
+ * A classificacao A/B derivada do MOTIVO TIPADO, nao de julgamento de tamanho.
+ *
+ * O nucleo nao sabe medir "uma linha ou equivalente", entao ele nao finge saber: o
+ * padrao e o CONSERVADOR (tipo B, devolve ao GO e exige reexecucao completa). O unico
+ * caso que nasce tipo A e a alegacao sem comando de verificacao, em que a correcao E
+ * literalmente anexar o comando (`ork claims verificar`), sem tocar em codigo.
+ */
+function tipoDoMotivo(motivo) {
+    return motivo === 'claims.unverifiable' ? 'A' : 'B';
+}
+/**
+ * Deriva as correcoes dirigidas do resultado REAL do `ork verify`.
+ *
+ * Uma correcao por item reprovado, nunca uma correcao guarda-chuva: "o CHECK reprovou"
+ * nao e spec, e o GO-FIX precisa saber exatamente o que consertar e o que sera
+ * reexecutado para julga-lo.
+ */
+function derivarCorrecoes(thread, rodada, resultado, idsUsados) {
+    const correcoes = [];
+    const ids = [...idsUsados];
+    const proximo = () => {
+        const id = (0, util_1.proximoIdSequencial)(ids, 'FX');
+        ids.push(id);
+        return id;
+    };
+    const nascer = (origem, alvo, spec, verificar, evidencia) => {
+        correcoes.push({
+            id: proximo(),
+            thread: thread.id,
+            rodada,
+            tipo: tipoDoMotivo(origem),
+            origem,
+            alvo,
+            spec,
+            verificar,
+            evidencia,
+            estado: 'aberta',
+            vereditoEm: null,
+            detalheDoVeredito: '',
+            criadaEm: (0, util_1.agora)(),
+        });
+    };
+    for (const c of resultado.claims) {
+        if (c.verificado || c.motivo === null)
+            continue;
+        const falhou = c.execucoes.find((e) => !e.ok);
+        if (c.motivo === 'claims.unverifiable') {
+            nascer(c.motivo, `claim ${c.claim.id}`, `A alegacao ${c.claim.id} sobre ${c.claim.arquivo} ("${c.claim.alegacao}") nao tem comando ` +
+                'de verificacao. Anexe o comando que a comprova no HEAD real, ou retire a alegacao com ' +
+                `motivo: ork claims verificar ${thread.id} ${c.claim.id} --comando "<comando>"`, [], c.detalhe);
+            continue;
+        }
+        nascer(c.motivo, `claim ${c.claim.id}`, `A alegacao ${c.claim.id} sobre ${c.claim.arquivo} ("${c.claim.alegacao}") REPROVOU na ` +
+            `reexecucao no HEAD real. ${c.detalhe}. Corrija o artefato ate o comando passar, ou ` +
+            'retire a alegacao com motivo. Nao edite o comando para faze-lo passar.', c.claim.verificar, falhou ? `${falhou.comando} saiu com codigo ${falhou.code}:\n${falhou.resumo}` : c.detalhe);
+    }
+    for (const cmd of resultado.regressoes) {
+        nascer('verify.regression', `comando ${cmd.nome}`, `REGRESSAO: "${cmd.comando}" passava na baseline gravada antes do GO (commit ` +
+            `${resultado.baseline?.commit.slice(0, 8) ?? 'desconhecido'}) e falha agora. Este defeito ` +
+            'e desta thread, nao divida pre-existente. Corrija ate o comando voltar a passar.', [cmd.comando], `codigo ${cmd.code}:\n${cmd.resumo}`);
+    }
+    for (const cmd of resultado.falhasSemBaseline) {
+        nascer('verify.failed', `comando ${cmd.nome}`, `"${cmd.comando}" falha e NAO ha baseline para separar regressao de divida pre-existente. ` +
+            'Corrija a falha, ou grave a baseline antes do GO com `ork verify <thread> --baseline` ' +
+            'para que a proxima rodada saiba de quem e a culpa.', [cmd.comando], `codigo ${cmd.code}:\n${cmd.resumo}`);
+    }
+    return correcoes;
+}
+/** A spec EXATA que vai no prompt do GO-FIX. Sai dos dados, nunca de prosa livre. */
+function specDoGoFix(thread, rodada, correcoes) {
+    const temTipoB = correcoes.some((c) => c.tipo === 'B');
+    const linhas = [];
+    linhas.push(`GO-FIX da thread ${thread.id}, rodada ${rodada}.`);
+    linhas.push('');
+    linhas.push('O CHECK reprovou. Abaixo esta a spec EXATA de cada correcao, derivada do resultado real ' +
+        'de `ork verify` no HEAD, com o comando que vai julgar cada uma no CHECK-REVERIFY.');
+    linhas.push('');
+    for (const c of correcoes) {
+        linhas.push(`${c.id} (tipo ${c.tipo}, motivo tipado ${c.origem}) alvo: ${c.alvo}`);
+        linhas.push(`  o que fazer: ${c.spec}`);
+        linhas.push(`  como sera julgado: ${c.verificar.length > 0 ? c.verificar.join(' && ') : '(sem comando proprio: o verify completo julga)'}`);
+        linhas.push('  evidencia da reprovacao:');
+        for (const l of c.evidencia.split('\n').slice(-6))
+            linhas.push(`    | ${l}`);
+        linhas.push('');
+    }
+    linhas.push('Regras desta rodada:');
+    linhas.push('- Corrija o ARTEFATO. Editar o comando de verificacao para faze-lo passar e fraude de gate.');
+    linhas.push('- Um commit atomico por correcao, citando o id da correcao na mensagem.');
+    linhas.push(temTipoB
+        ? '- Ha correcao tipo B nesta rodada: o CHECK seguinte e reexecucao COMPLETA, nunca parcial.'
+        : '- Rodada so de tipo A: o CHECK seguinte reexecuta as verificacoes afetadas.');
+    linhas.push('- Nao ha pausa humana dentro deste sub-loop; o veredito final e que sobe.');
+    return linhas.join('\n');
+}
+/**
+ * Abre a rodada de GO-FIX a partir de um CHECK reprovado.
+ *
+ * A verdade vem do `ork verify` reexecutado agora: a rodada nao acredita em relatorio de
+ * CHECK nenhum, nem no do proprio agente que acabou de rodar.
+ */
+function abrirRodada(carregado, threadId, opcoes = {}) {
+    const { raiz } = carregado;
+    const thread = (0, thread_1.lerThread)(raiz, threadId);
+    const resultado = (0, verify_1.verificar)(carregado, threadId, { soClaims: opcoes.soClaims });
+    const rodada = ultimaRodada(raiz, threadId) + 1;
+    if (resultado.ok && resultado.motivos.length === 0) {
+        return {
+            thread: threadId,
+            rodada: rodada - 1,
+            veredito: 'PASSOU',
+            correcoes: [],
+            temTipoB: false,
+            spec: '',
+            motivos: [],
+            abertaEm: (0, util_1.agora)(),
+        };
+    }
+    const idsUsados = lerCorrecoes(raiz, threadId).map((c) => c.id);
+    const correcoes = derivarCorrecoes(thread, rodada, resultado, idsUsados);
+    for (const c of correcoes)
+        (0, util_1.anexarJsonl)(caminhoDosFixes(raiz, threadId), c);
+    const temTipoB = correcoes.some((c) => c.tipo === 'B');
+    const spec = specDoGoFix(thread, rodada, correcoes);
+    (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, threadId), threadId, ledger_1.TIPOS_DE_EVENTO.fixAberto, {
+        fase: 'CHECK',
+        rodada,
+        veredito: 'PRECISA DE MUDANCA',
+        correcoes: correcoes.map((c) => ({ id: c.id, tipo: c.tipo, origem: c.origem, alvo: c.alvo })),
+        temTipoB,
+        motivos: resultado.motivos,
+        commit: resultado.commit,
+        evidencia: `ork verify reexecutado no HEAD ${resultado.commit} em ${resultado.cwd}`,
+        reexecucaoCompletaObrigatoria: temTipoB,
+    });
+    return {
+        thread: threadId,
+        rodada,
+        veredito: 'PRECISA DE MUDANCA',
+        correcoes,
+        temTipoB,
+        spec,
+        motivos: resultado.motivos,
+        abertaEm: (0, util_1.agora)(),
+    };
+}
+/** Regrava uma correcao com o veredito do reverify. */
+function carimbar(raiz, correcao, aprovada, detalhe) {
+    const atualizada = {
+        ...correcao,
+        estado: aprovada ? 'aprovada' : 'reprovada',
+        vereditoEm: (0, util_1.agora)(),
+        detalheDoVeredito: detalhe,
+    };
+    (0, util_1.anexarJsonl)(caminhoDosFixes(raiz, correcao.thread), atualizada);
+    return atualizada;
+}
+/**
+ * CHECK-REVERIFY: veredito POR CORRECAO mais o veredito final da rodada.
+ *
+ * A cobertura nao e escolha de gosto. Rodada com tipo B e sempre `completa`; pedir
+ * `--parcial` nela LANCA, em vez de degradar em silencio para uma verificacao mais
+ * frouxa do que o metodo manda.
+ */
+function reverificar(carregado, threadId, opcoes = {}) {
+    const { raiz, manifesto } = carregado;
+    const thread = (0, thread_1.lerThread)(raiz, threadId);
+    const rodada = opcoes.rodada ?? ultimaRodada(raiz, threadId);
+    if (rodada === 0) {
+        throw new Error(`a thread ${threadId} nao tem rodada de GO-FIX aberta (abra com: ork fix open ${threadId})`);
+    }
+    const correcoes = correcoesDaRodada(raiz, threadId, rodada);
+    if (correcoes.length === 0) {
+        throw new Error(`rodada ${rodada} nao existe na thread ${threadId}`);
+    }
+    const temTipoB = correcoes.some((c) => c.tipo === 'B');
+    if (opcoes.parcial && temTipoB) {
+        throw new Error(`a rodada ${rodada} tem correcao tipo B (${correcoes
+            .filter((c) => c.tipo === 'B')
+            .map((c) => c.id)
+            .join(', ')}): o CHECK seguinte e reexecucao COMPLETA. ` +
+            'Parcial depois de tipo B nao e CHECK (DoD 10).');
+    }
+    const cobertura = opcoes.parcial && !temTipoB ? 'parcial' : 'completa';
+    const cwd = (0, verify_1.cwdDaThread)(raiz, thread);
+    const vereditos = correcoes.map((c) => {
+        if (c.verificar.length === 0) {
+            // Sem comando proprio a correcao nao se julga sozinha: quem decide e o verify
+            // completo. Chamar isso de "aprovada" seria self-report com outro nome.
+            return {
+                correcao: c,
+                aprovada: false,
+                execucoes: [],
+                detalhe: 'sem comando proprio de verificacao: o veredito depende do verify completo',
+            };
+        }
+        const execucoes = c.verificar.map((cmd, i) => (0, verify_1.executar)(`${c.id}.${i + 1}`, cmd, cwd));
+        const falhou = execucoes.find((e) => !e.ok);
+        return {
+            correcao: c,
+            aprovada: !falhou,
+            execucoes,
+            detalhe: falhou
+                ? `"${falhou.comando}" ainda sai com codigo ${falhou.code}`
+                : `${execucoes.length} comando(s) reexecutado(s) com sucesso no HEAD real`,
+        };
+    });
+    const verify = cobertura === 'completa' ? (0, verify_1.verificar)(carregado, threadId) : null;
+    for (const v of vereditos) {
+        // Correcao sem comando proprio herda o veredito do verify completo, e so quando ele
+        // roda: sem ele, ela continua aberta em vez de virar aprovada por conveniencia.
+        const aprovada = v.correcao.verificar.length === 0 ? (verify?.ok ?? false) : v.aprovada;
+        v.aprovada = aprovada;
+        carimbar(raiz, v.correcao, aprovada, v.detalhe);
+    }
+    const rodadas = rodada;
+    const limite = manifesto.retry.max_tentativas;
+    const todasAprovadas = vereditos.every((v) => v.aprovada);
+    const verifyOk = verify === null ? true : verify.ok;
+    const motivos = verify ? verify.motivos : [];
+    let veredito;
+    let escalado = false;
+    let razao;
+    if (todasAprovadas && verifyOk) {
+        veredito = 'PASSOU';
+        razao =
+            `${vereditos.length} correcao(oes) aprovada(s) por comando reexecutado no HEAD real` +
+                (verify ? `, com o verify completo verde no commit ${verify.commit.slice(0, 8)}` : '');
+    }
+    else if (rodadas >= limite) {
+        veredito = 'BLOQUEADO';
+        escalado = true;
+        razao =
+            `limite de escalacao atingido: ${rodadas} rodada(s) de GO-FIX para o limite de ${limite} ` +
+                'do manifesto. Escalacao tipada pausa QUALQUER modo, inclusive #Auto.';
+    }
+    else {
+        veredito = 'PRECISA DE MUDANCA';
+        razao =
+            `${vereditos.filter((v) => !v.aprovada).length} correcao(oes) ainda reprovada(s); ` +
+                `rodada ${rodadas} de ${limite} antes da escalacao.`;
+    }
+    const dir = (0, thread_1.dirThread)(raiz, threadId);
+    (0, ledger_1.registrar)(dir, threadId, ledger_1.TIPOS_DE_EVENTO.reverifyConcluido, {
+        fase: 'CHECK',
+        rodada,
+        cobertura,
+        veredito,
+        modo: thread.modo,
+        bloco: (0, thread_1.blocoDaThread)(thread, 'CHECK').fases.join('-'),
+        vereditos: vereditos.map((v) => ({
+            correcao: v.correcao.id,
+            tipo: v.correcao.tipo,
+            origem: v.correcao.origem,
+            aprovada: v.aprovada,
+            detalhe: v.detalhe,
+        })),
+        verify: verify ? { commit: verify.commit, ok: verify.ok, motivos: verify.motivos } : null,
+        escalado,
+        razao,
+        evidencia: 'comandos reexecutados no HEAD real, um veredito por correcao',
+    });
+    if (escalado) {
+        (0, gates_1.registrarGateBloqueado)(dir, threadId, {
+            gate: 'verify',
+            motivo: 'human.pending',
+            modo: thread.modo,
+            detalhe: razao,
+            evidencia: `rodada ${rodada} de GO-FIX/CHECK-REVERIFY na thread ${threadId}`,
+            correcao: `ork gate approve ${threadId} evidencias --por <quem>`,
+            rodada,
+            limite,
+            pausaQualquerModo: true,
+        });
+        (0, ledger_1.registrar)(dir, threadId, ledger_1.TIPOS_DE_EVENTO.retryEscalado, {
+            fase: 'CHECK',
+            motivo: 'human.pending',
+            origem: 'check.reverify',
+            rodada,
+            limite,
+            modo: thread.modo,
+            razao,
+        });
+    }
+    return {
+        thread: threadId,
+        rodada,
+        cobertura,
+        vereditos,
+        verify,
+        veredito,
+        rodadas,
+        limite,
+        escalado,
+        motivos,
+        razao,
+    };
+}
+/** Quantas rodadas de GO-FIX a thread ja gastou (para o limite de escalacao). */
+function rodadasGastas(raiz, threadId) {
+    return (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, threadId)).filter((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.fixAberto)
+        .length;
+}
+/** Texto de `ork fix open`. */
+function textoDaRodada(r) {
+    if (r.correcoes.length === 0) {
+        return (`Thread ${r.thread}: o CHECK PASSOU no HEAD real, nao ha correcao a abrir.\n` +
+            '  (nenhum motivo tipado bloqueante em `ork verify`)');
+    }
+    const linhas = [];
+    linhas.push(`GO-FIX aberto na thread ${r.thread} (rodada ${r.rodada})`);
+    linhas.push(`  veredito do CHECK   ${r.veredito}`);
+    linhas.push(`  motivos tipados     ${r.motivos.join(', ')}`);
+    linhas.push(`  reexecucao          ${r.temTipoB ? 'COMPLETA obrigatoria (ha correcao tipo B)' : 'parcial permitida (rodada so de tipo A)'}`);
+    linhas.push('');
+    linhas.push((0, util_1.tabela)(['ID', 'TIPO', 'MOTIVO', 'ALVO', 'JULGADO POR'], r.correcoes.map((c) => [
+        c.id,
+        c.tipo,
+        c.origem,
+        c.alvo,
+        c.verificar.join(' && ') || '(verify completo)',
+    ])));
+    linhas.push('');
+    linhas.push('Spec exata despachada ao GO-FIX:');
+    linhas.push('');
+    for (const l of r.spec.split('\n'))
+        linhas.push(`  ${l}`);
+    return linhas.join('\n');
+}
+/** Texto de `ork fix reverify`. */
+function textoDoReverify(r) {
+    const linhas = [];
+    linhas.push(`CHECK-REVERIFY da thread ${r.thread} (rodada ${r.rodada})`);
+    linhas.push(`  cobertura   ${r.cobertura}`);
+    linhas.push(`  rodadas     ${r.rodadas} de ${r.limite} antes da escalacao`);
+    linhas.push('');
+    linhas.push('Veredito por correcao:');
+    for (const v of r.vereditos) {
+        linhas.push(`  ${v.correcao.id}  tipo ${v.correcao.tipo}  ${v.aprovada ? 'APROVADA' : 'REPROVADA'}  ${v.correcao.alvo}`);
+        linhas.push(`      motivo de origem: ${v.correcao.origem}`);
+        linhas.push(`      ${v.detalhe}`);
+        for (const e of v.execucoes) {
+            linhas.push(`      ${e.ok ? 'ok  ' : 'FALHOU'} ${e.comando}`);
+        }
+    }
+    if (r.verify) {
+        linhas.push('');
+        linhas.push(`Verify completo no HEAD ${r.verify.commit.slice(0, 8)}: ${r.verify.ok ? 'verde' : `reprovado (${r.verify.motivos.join(', ')})`}`);
+    }
+    linhas.push('');
+    linhas.push(`Veredito final: ${r.veredito}`);
+    linhas.push(`  ${r.razao}`);
+    if (r.escalado) {
+        linhas.push('  ESCALADO PARA HUMANO: esta pausa vale em qualquer modo, inclusive #Auto.');
+    }
+    return linhas.join('\n');
+}

package/dist/gates.js

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * Gates tipados (bloco B1).
+ *
+ * O gate do B0 era por FASE e por MODO: decidia se o bloco pausa para o humano.
+ * O gate do B1 acrescenta o MOTIVO TIPADO da reprovacao: `claims.failed`,
+ * `policy.violation`, `verify.regression` e companhia, sempre do catalogo,
+ * nunca por contagem de bytes ou grep no artefato.
+ *
+ * Regra central que atravessa o espectro de modos: o modo afrouxa a PAUSA, nunca a
+ * VERIFICACAO. Por isso todo motivo tipado deste catalogo reprova em qualquer modo,
+ * inclusive `#Auto`; o que o modo decide e apenas se a AUTORIZACAO espera o humano.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DESCRICAO_DO_MOTIVO = void 0;
+exports.reprovaEmTodoModo = reprovaEmTodoModo;
+exports.bloqueia = bloqueia;
+exports.registrarGateBloqueado = registrarGateBloqueado;
+exports.registrarGateLiberado = registrarGateLiberado;
+exports.descreverMotivo = descreverMotivo;
+exports.aprovarGateHumano = aprovarGateHumano;
+exports.aprovacoesHumanas = aprovacoesHumanas;
+const ledger_1 = require("./ledger");
+const modos_1 = require("./modos");
+const thread_1 = require("./thread");
+/** O que cada motivo tipado significa, em uma linha, para a saida do CLI. */
+exports.DESCRICAO_DO_MOTIVO = {
+    'artifact.missing': 'artefato exigido pela fase nao existe no disco',
+    'claims.failed': 'alegacao verificavel reprovou na reexecucao no HEAD real',
+    'claims.unverifiable': 'alegacao sem comando de verificacao declarado',
+    'policy.violation': 'policy do manifesto com severidade block foi violada',
+    'verify.regression': 'comando que passava na baseline falha agora',
+    'verify.failed': 'comando de verificacao falhou (sem baseline para separar divida pre-existente)',
+    'runtime.unavailable': 'runtime adapter indisponivel para o despacho',
+    'runtime.rate-limited': 'o runtime bateu o limite de uso da assinatura e a fase morreu antes de terminar (bloco B3: entra na fila duravel e e retomada na janela seguinte)',
+    'cost.violation': 'o despacho seria redirecionado para provider pago (violacao de custo: e o unico motivo que NUNCA recebe retry automatico)',
+    'tree.blocked': 'a arvore de destino nao esta disponivel para o merge (branch em check-out com alteracao nao commitada, ou worktree que nao pode ser montada)',
+    'lease.busy': 'lease ocupado por outra thread',
+    'human.pending': 'gate humano do modo de conducao ainda nao autorizou',
+};
+/**
+ * Motivos que reprovam em QUALQUER modo, inclusive `#Auto`.
+ *
+ * Sao todos os motivos de verificacao e de policy: o modo nunca afrouxa verificacao.
+ * `human.pending` e a excecao de natureza: nao e reprovacao de verdade, e espera de
+ * autorizacao, e por isso existe so nos modos que pausam.
+ */
+function reprovaEmTodoModo(motivo) {
+    return motivo !== 'human.pending';
+}
+/** Motivos que bloqueiam a entrega. `claims.unverifiable` avisa, mas nao bloqueia. */
+function bloqueia(motivo) {
+    return motivo !== 'claims.unverifiable';
+}
+/** Registra a reprovacao tipada no ledger da thread. */
+function registrarGateBloqueado(dirDaThread, threadId, dados) {
+    return (0, ledger_1.registrar)(dirDaThread, threadId, ledger_1.TIPOS_DE_EVENTO.gateBloqueado, {
+        ...dados,
+        tag: modos_1.MODOS[dados.modo].tag,
+        significado: exports.DESCRICAO_DO_MOTIVO[dados.motivo],
+        reprovaEmTodoModo: reprovaEmTodoModo(dados.motivo),
+    });
+}
+/** Registra a liberacao do gate, com quem autorizou e com que evidencia. */
+function registrarGateLiberado(dirDaThread, threadId, dados) {
+    return (0, ledger_1.registrar)(dirDaThread, threadId, ledger_1.TIPOS_DE_EVENTO.gateLiberado, {
+        ...dados,
+        tag: modos_1.MODOS[dados.modo].tag,
+    });
+}
+/** Linha de saida do CLI para um motivo tipado. */
+function descreverMotivo(motivo, detalhe) {
+    return `motivo tipado: ${motivo} (${exports.DESCRICAO_DO_MOTIVO[motivo]})\n  detalhe: ${detalhe}`;
+}
+/**
+ * `ork gate approve`: o humano autoriza uma pausa do modo pela linha de comando.
+ *
+ * E o que torna a "autorizacao antecipada de push" do `#Ork` verificavel: ela vira um
+ * evento no ledger com quem autorizou e quando, em vez de memoria de conversa.
+ */
+function aprovarGateHumano(raiz, threadId, sobre, por, observacao) {
+    return (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, threadId), threadId, ledger_1.TIPOS_DE_EVENTO.pausaHumana, {
+        estado: 'aprovado',
+        sobre,
+        autorizadoPor: por,
+        observacao: observacao ?? '',
+    });
+}
+/** Aprovacoes humanas ja registradas no ledger da thread, para os gates consultarem. */
+function aprovacoesHumanas(raiz, threadId) {
+    return (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, threadId)).filter((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.pausaHumana && e.estado === 'aprovado');
+}