@orkastery/cli 0.6.6 → 0.6.7

package/dist/claim-lint.js

@@ -35,6 +35,8 @@ const CORRECAO = {
     'ork-fora-do-path': (0, locale_1.msg)('pt-BR').claims.correcoesDoLint['ork-fora-do-path'],
     'estado-local': (0, locale_1.msg)('pt-BR').claims.correcoesDoLint['estado-local'],
     'aspas-escapadas': (0, locale_1.msg)('pt-BR').claims.correcoesDoLint['aspas-escapadas'],
+    'contexto-artificial': (0, locale_1.msg)('pt-BR').claims.correcoesDoLint['contexto-artificial'],
+    'artefato-de-fechamento': (0, locale_1.msg)('pt-BR').claims.correcoesDoLint['artefato-de-fechamento'],
 };
 /** RM-037: estes achados tornam uma claim nova inexequivel no checkout do runner. */
 exports.REGRAS_FATAIS_DE_CLAIM = new Set([
@@ -54,6 +56,12 @@ const SO_ANCESTRALIDADE = /merge-base\s+--is-ancestor\s+\S+\s+\S+/g;
 /** (b2) Contagem de commits comparada a um numero. */
 const CONTAGEM = /rev-list\s+(?:[^|;&]*\s)?--count\b|\bgit\s+log\b[^|;&]*\|\s*wc\s+-l\b/;
 const COMPARACAO = /-(?:eq|ne|gt|lt|ge|le)\s+['"]?\d|[^=!<>]==?\s*['"]?\d|grep\s+-(?:q?x|xq)\s+['"]?\d/;
+/** RM-079: execucao isolada que reconstrói contexto do produto dentro da propria claim. */
+const NODE_EVAL = /\bnode\b[^;&|]*(?:\s-e\b|\s--eval\b)/;
+const PARSER_DE_AST = /\b(?:@babel\/parser|acorn|esprima|recast|ts-morph|typescript)\b|\b(?:createSourceFile|parseExpression|parseScript|parseModule)\s*\(/;
+const EXECUCAO_ARTIFICIAL = /\brunIn(?:Context|NewContext|ThisContext)\s*\(|\bnew\s+Function\s*\(/;
+/** Artefatos produzidos pelo proprio fechamento nao podem ser a fonte circular da claim. */
+const ARTEFATO_DE_FECHAMENTO = /(?:^|[\s"'=])((?:\.\/)?\.ork-ci\/[\w./-]+\.json|(?:\.\/)?docs\/check\.md|(?:\.\/)?pr-body\.md|(?:\.\/)?(?:POSTMORTEM|MASTER)\.(?:json|md))(?=$|[\s"'])/;
 /** Executavel em posicao de comando, no inicio ou depois de um operador do shell. */
 function executavelDireto(comando, nome) {
     return new RegExp(`(?:^|&&|\\|\\||[;|(])\\s*(?:command\\s+|env\\s+)?(${nome})(?=\\s|$)`).exec(comando);
@@ -72,6 +80,17 @@ function analisarComando(comando) {
     const aspas = /\\x(?:22|27)/i.exec(comando);
     if (aspas)
         achados.push({ regra: 'aspas-escapadas', trecho: aspas[0], correcao: CORRECAO['aspas-escapadas'] });
+    const artificial = EXECUCAO_ARTIFICIAL.exec(comando)
+        ?? (NODE_EVAL.test(comando) ? PARSER_DE_AST.exec(comando) : null);
+    if (artificial)
+        achados.push({
+            regra: 'contexto-artificial', trecho: artificial[0].trim(), correcao: CORRECAO['contexto-artificial'],
+        });
+    const fechamento = ARTEFATO_DE_FECHAMENTO.exec(comando);
+    if (fechamento)
+        achados.push({
+            regra: 'artefato-de-fechamento', trecho: fechamento[1], correcao: CORRECAO['artefato-de-fechamento'],
+        });
     const suite = SUITE_INTEIRA.exec(comando);
     if (suite)
         achados.push({ regra: 'suite-inteira', trecho: suite[0].trim(), correcao: CORRECAO['suite-inteira'] });

package/dist/claims.js

@@ -56,6 +56,7 @@ exports.registrarCriteriosDePronto = registrarCriteriosDePronto;
 exports.exigirClaim = exigirClaim;
 exports.anexarComando = anexarComando;
 exports.retirarClaim = retirarClaim;
+exports.retirarClaimTipada = retirarClaimTipada;
 exports.carimbarEstado = carimbarEstado;
 exports.tabelaDeClaims = tabelaDeClaims;
 const fs = __importStar(require("node:fs"));
@@ -69,6 +70,8 @@ const verify_1 = require("./verify");
 const util_1 = require("./util");
 const claim_lint_1 = require("./claim-lint");
 const locale_1 = require("./locale");
+const gates_1 = require("./gates");
+const hitl_1 = require("./hitl");
 /** Caminho do `claims.jsonl` da thread (append-only, como o ledger). */
 function caminhoClaims(raiz, threadId) {
     return path.join((0, thread_1.dirThread)(raiz, threadId), 'claims.jsonl');
@@ -116,6 +119,10 @@ function ehAlegacaoNegativa(texto) {
  */
 function montarClaim(entrada) {
     const verificar = (entrada.verificar ?? []).filter((c) => c.trim() !== '');
+    const dependenciasExternas = [...new Set(entrada.dependenciasExternas ?? [])].sort();
+    if (dependenciasExternas.some((d) => d !== 'rede' && d !== 'relogio')) {
+        throw new Error('claim.dependencia-externa-invalida: use rede ou relogio');
+    }
     return {
         id: entrada.id,
         thread: entrada.dono,
@@ -124,6 +131,7 @@ function montarClaim(entrada) {
         alegacao: entrada.alegacao.trim(),
         negativa: ehAlegacaoNegativa(entrada.alegacao),
         verificar,
+        ...(dependenciasExternas.length ? { dependenciasExternas } : {}),
         criadoEm: (0, util_1.agora)(),
         estado: verificar.length > 0 ? 'pendente' : 'nao-verificavel',
         ...(entrada.origem ? { origem: entrada.origem } : {}),
@@ -152,6 +160,7 @@ function adicionarClaim(raiz, threadId, opcoes) {
         arquivo: opcoes.arquivo,
         alegacao: opcoes.alegacao,
         verificar: opcoes.verificar,
+        dependenciasExternas: opcoes.dependenciasExternas,
         origem: opcoes.origem,
     });
     const recusas = (claim.lint ?? []).filter((a) => (0, claim_lint_1.regraFatalDeClaim)(a.regra));
@@ -170,6 +179,7 @@ function adicionarClaim(raiz, threadId, opcoes) {
         alegacao: claim.alegacao,
         negativa,
         verificar,
+        ...(claim.dependenciasExternas?.length ? { dependenciasExternas: claim.dependenciasExternas } : {}),
         estado: claim.estado,
         ...(claim.lint?.length ? { lint: claim.lint.map((a) => a.regra) } : {}),
     });
@@ -286,25 +296,81 @@ function anexarComando(raiz, threadId, claimId, comando) {
     });
     return atualizada;
 }
-/**
- * Retira uma claim, com motivo obrigatorio.
- *
- * O `claims.jsonl` e append-only: a alegacao errada continua no historico, com a retirada
- * registrada em cima. `ork verify` para de exigir prova dela, e o ledger guarda o porque.
- */
-function retirarClaim(raiz, threadId, claimId, motivo) {
-    const claim = exigirClaim(raiz, threadId, claimId);
-    const atualizada = { ...claim, estado: 'retirada', motivoDaRetirada: motivo };
+const AUTOR_LEGADO = { tipo: 'sessao', id: 'api:legada' };
+function retirarERegistrar(raiz, threadId, claim, motivo, autor, tipada, motivoTipo, substituidaPor) {
+    if (claim.estado === 'retirada')
+        throw new Error(`claim "${claim.id}" ja foi retirada`);
+    const motivoSeguro = (0, hitl_1.redigirSegredos)(motivo);
+    const atualizada = { ...claim, estado: 'retirada', motivoDaRetirada: motivoSeguro };
     gravarClaim(raiz, atualizada);
     (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, threadId), threadId, ledger_1.TIPOS_DE_EVENTO.claimRegistrada, {
-        claim: claimId,
+        claim: claim.id,
         alteracao: 'claim retirada',
         alegacao: claim.alegacao,
-        motivoDaRetirada: motivo,
+        motivoDaRetirada: motivoSeguro,
         estado: 'retirada',
+        tipada,
+        autor,
+        ...(motivoTipo ? { motivoTipo } : {}),
+        ...(substituidaPor ? { substituidaPor } : {}),
     });
     return atualizada;
 }
+function retirarClaim(raiz, threadId, claimId, motivo, autor = AUTOR_LEGADO) {
+    const claim = exigirClaim(raiz, threadId, claimId);
+    return retirarERegistrar(raiz, threadId, claim, motivo, autor, false);
+}
+/** RM-079: troca tipada de regra; sem substituta, preserva a claim e escala ao dono. */
+function retirarClaimTipada(raiz, threadId, claimId, opcoes) {
+    if (!['substituicao', 'obsoleta', 'erro'].includes(opcoes.motivoTipo)) {
+        throw new Error(`motivo-tipo invalido: ${opcoes.motivoTipo}`);
+    }
+    if (!opcoes.motivo.trim())
+        throw new Error('o motivo da retirada e obrigatorio');
+    const claim = exigirClaim(raiz, threadId, claimId);
+    if (claim.estado === 'retirada')
+        throw new Error(`claim "${claim.id}" ja foi retirada`);
+    if (opcoes.substituidaPor) {
+        const repetirVerify = (motivo, detalhe) => new Error(`${motivo}: ${detalhe}; rode node core/dist/index.js verify ${threadId}`);
+        if (opcoes.substituidaPor === claimId)
+            throw new Error('a claim substituta precisa ser diferente da retirada');
+        const substituta = exigirClaim(raiz, threadId, opcoes.substituidaPor);
+        if (substituta.estado === 'retirada') {
+            throw repetirVerify('claims.substituta.inativa', `claim substituta "${substituta.id}" nao esta ativa`);
+        }
+        const rodada = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, threadId)).filter((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.verificacao).at(-1);
+        const headAtual = (0, verify_1.commitReal)((0, verify_1.cwdDaThread)(raiz, (0, thread_1.lerThread)(raiz, threadId)));
+        if (rodada?.commit !== headAtual) {
+            throw repetirVerify('claims.substituta.verify-head', `o ultimo verify_run pertence a ${String(rodada?.commit ?? 'commit ausente')}, nao ao HEAD ${headAtual}`);
+        }
+        const prova = Array.isArray(rodada?.claims)
+            ? rodada.claims.find((c) => c.id === substituta.id)
+            : undefined;
+        if (prova?.verificado !== true) {
+            throw repetirVerify('claims.substituta.nao-verificada', `claim substituta "${substituta.id}" nao passou no ultimo verify_run`);
+        }
+        if (typeof prova.verificarSha256 !== 'string'
+            || prova.verificarSha256 !== (0, verify_1.impressaoDosComandos)(substituta.verificar)) {
+            throw repetirVerify('claims.substituta.alterada-depois-do-verify', `claim substituta "${substituta.id}" mudou o comando verificar depois do ultimo verify_run`);
+        }
+        const retirada = retirarERegistrar(raiz, threadId, claim, opcoes.motivo, opcoes.autor, true, opcoes.motivoTipo, substituta.id);
+        return { estado: 'retirada', claim: retirada, tipada: true, autor: opcoes.autor, substituidaPor: substituta.id };
+    }
+    const thread = (0, thread_1.lerThread)(raiz, threadId);
+    (0, gates_1.registrarGateBloqueado)((0, thread_1.dirThread)(raiz, threadId), threadId, {
+        gate: 'claims.retirar',
+        motivo: 'claims.retirada-sem-substituta',
+        modo: thread.modo,
+        fase: thread.faseAtual,
+        detalhe: `${claim.id}: ${opcoes.motivoTipo}; ${(0, hitl_1.redigirSegredos)(opcoes.motivo.trim())}`,
+        evidencia: `claim ativa ${claim.id}`,
+        correcao: 'o dono decide pelo pedido tipado ou uma substituta verde e informada',
+        claim: claim.id,
+        autor: opcoes.autor,
+    });
+    return { estado: 'pendente-do-dono', claim, tipada: true, autor: opcoes.autor,
+        motivo: 'claims.retirada-sem-substituta' };
+}
 /** Regrava a claim com o estado carimbado pelo `ork verify` (o append mais novo vence). */
 function carimbarEstado(raiz, claim, estado) {
     const atualizada = { ...claim, estado };

package/dist/fila-pesada.js

@@ -495,7 +495,7 @@ function vagaDoAncestral(chave, dir) {
  * artefato e uma das `slots` vagas, todas do kernel. Espera em primeiro plano até `esperarMs` e, sem a vez, lança
  * `ErroDaFilaPesada` sem rodar nada. Dentro de quem já segura a vez neste processo, roda direto.
  */
-function comRecursoPesado(raiz, pedido, executar) {
+function comRecursoPesado(raiz, pedido, executar, dependencias = {}) {
     if (!(pedido.slots > 0))
         return executar({ situacao: 'desligada', slot: null, esperouMs: 0 });
     const chave = path.resolve((0, estado_thread_1.raizDoEstado)(raiz));
@@ -508,7 +508,9 @@ function comRecursoPesado(raiz, pedido, executar) {
     const doAncestral = vagaDoAncestral(chave, dir);
     if (doAncestral !== null)
         return executar({ situacao: 'reentrada', slot: doAncestral, esperouMs: 0 });
-    const inicio = Date.now();
+    const agora = dependencias.agora ?? Date.now;
+    const pausar = dependencias.pausar ?? dormir;
+    const inicio = agora();
     const prazo = inicio + Math.max(0, pedido.esperarMs);
     let senha = tirarSenha(dir);
     let avisou = false;
@@ -525,7 +527,7 @@ function comRecursoPesado(raiz, pedido, executar) {
                 process.env[exports.ENV_DONO_DA_FILA] = JSON.stringify({ raiz: chave, pid: process.pid, inicio: inicioDoProcesso(process.pid), slot: posse.slot,
                     posse: posse.id });
                 try {
-                    return executar({ situacao: 'adquirida', slot: posse.slot, esperouMs: Date.now() - inicio });
+                    return executar({ situacao: 'adquirida', slot: posse.slot, esperouMs: agora() - inicio });
                 }
                 finally {
                     if (marcaAnterior === undefined)
@@ -536,8 +538,8 @@ function comRecursoPesado(raiz, pedido, executar) {
                     soltar(posse);
                 }
             }
-            if (Date.now() >= prazo)
-                throw new ErroDaFilaPesada(recusaDaFila(pedido, Date.now() - inicio, ocupantesDaFilaPesada(raiz)));
+            if (agora() >= prazo)
+                throw new ErroDaFilaPesada(recusaDaFila(pedido, agora() - inicio, ocupantesDaFilaPesada(raiz)));
             if (!avisou) {
                 avisou = true;
                 try {
@@ -545,7 +547,7 @@ function comRecursoPesado(raiz, pedido, executar) {
                 }
                 catch { /* o aviso nunca derruba a espera */ }
             }
-            dormir(Math.min(PAUSA_MS, prazo - Date.now()));
+            pausar(Math.min(PAUSA_MS, prazo - agora()));
         }
     }
     finally {

package/dist/fix.js

@@ -56,19 +56,24 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.lerParecerParaFix = lerParecerParaFix;
 exports.caminhoDosFixes = caminhoDosFixes;
 exports.lerCorrecoes = lerCorrecoes;
 exports.correcoesDaRodada = correcoesDaRodada;
 exports.ultimaRodada = ultimaRodada;
 exports.tipoDoMotivo = tipoDoMotivo;
 exports.derivarCorrecoes = derivarCorrecoes;
+exports.derivarCorrecoesDoParecer = derivarCorrecoesDoParecer;
 exports.specDoGoFix = specDoGoFix;
 exports.abrirRodada = abrirRodada;
 exports.reverificar = reverificar;
 exports.rodadasGastas = rodadasGastas;
+exports.statusDaRodada = statusDaRodada;
 exports.textoDaRodada = textoDaRodada;
 exports.textoDoReverify = textoDoReverify;
+const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
 const gates_1 = require("./gates");
 const ledger_1 = require("./ledger");
 const thread_1 = require("./thread");
@@ -76,6 +81,95 @@ const util_1 = require("./util");
 const verify_1 = require("./verify");
 const conducao_1 = require("./conducao");
 const locale_1 = require("./locale");
+const hitl_1 = require("./hitl");
+const LIMITE_DO_PARECER = 128 * 1024;
+function vereditoBilíngue(texto) {
+    const linhasDeVeredito = [];
+    const malformadas = [];
+    const achados = new Set();
+    const mapa = {
+        passou: 'PASSOU', reprovou: 'REPROVOU', 'precisa de mudanca': 'PRECISA DE MUDANCA', bloqueado: 'BLOQUEADO',
+        passed: 'PASSOU', failed: 'REPROVOU', 'needs changes': 'PRECISA DE MUDANCA', blocked: 'BLOQUEADO',
+    };
+    for (const [i, linha] of texto.split(/\r?\n/).entries()) {
+        const rotulo = /^[#>*_`\s-]*(?:veredito|verdict)[*_`\s]*:[*_`\s]*(.*?)\s*$/iu.exec(linha);
+        if (!rotulo)
+            continue;
+        const listada = `${i + 1}: ${(0, hitl_1.redigirSegredos)(linha)}`;
+        linhasDeVeredito.push(listada);
+        const valor = rotulo[1].replace(/[*_`]+$/g, '').replace(/[.!]$/g, '').trim()
+            .normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase();
+        const canonico = mapa[valor];
+        if (canonico)
+            achados.add(canonico);
+        else
+            malformadas.push(listada);
+    }
+    if (linhasDeVeredito.length === 0)
+        throw new Error('fix.check.veredito-ausente: docs/check.md');
+    if (malformadas.length > 0 || achados.size !== 1) {
+        throw new Error(`fix.check.veredito-malformado: ${[...malformadas, ...linhasDeVeredito].join(' | ')}`);
+    }
+    return [...achados][0];
+}
+/** RM-079: le somente docs/check.md e extrai achados sem claim no contrato bilíngue do CHECK. */
+function lerParecerParaFix(raiz, threadId) {
+    const arquivo = path.join((0, thread_1.dirThread)(raiz, threadId), 'docs', 'check.md');
+    let fd;
+    try {
+        fd = fs.openSync(arquivo, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+    }
+    catch (e) {
+        if (e.code === 'ENOENT') {
+            throw new Error('fix.check.ausente: docs/check.md');
+        }
+        throw new Error('fix.check.unsafe');
+    }
+    try {
+        const st = fs.fstatSync(fd);
+        if (!st.isFile() || st.nlink !== 1 || st.size > LIMITE_DO_PARECER)
+            throw new Error('fix.check.unsafe');
+        const bytes = fs.readFileSync(fd);
+        if (bytes.length > LIMITE_DO_PARECER)
+            throw new Error('fix.check.too-large');
+        const texto = bytes.toString('utf8');
+        const linhas = texto.split(/\r?\n/);
+        const achados = [];
+        const linhasMalformadas = [];
+        const vistos = new Set();
+        const regra = /^\s*-\s+(A\d+)\s+\[(bloqueador|aviso|sugestao|blocker|warning|suggestion)\]\s+([A-Za-z0-9_./-]+):(\d+)\s+-\s+(.+?)\s*$/i;
+        const severidade = (valor) => ({ blocker: 'bloqueador', warning: 'aviso', suggestion: 'sugestao' }[valor.toLowerCase()]
+            ?? valor.toLowerCase());
+        for (let i = 0; i < linhas.length; i++) {
+            const m = regra.exec(linhas[i]);
+            if (!m) {
+                if (/^\s*-\s+A\d+\b/i.test(linhas[i]))
+                    linhasMalformadas.push(`${i + 1}: ${(0, hitl_1.redigirSegredos)(linhas[i])}`);
+                continue;
+            }
+            if (vistos.has(m[1]))
+                throw new Error(`fix.check.finding.duplicado: ${m[1]}`);
+            const relativo = path.posix.normalize(m[3]);
+            if (relativo.startsWith('../') || relativo === '..' || path.posix.isAbsolute(relativo) || relativo.includes('\\')) {
+                throw new Error(`fix.check.finding.path: ${m[3]}`);
+            }
+            if (Number(m[4]) < 1)
+                throw new Error(`fix.check.finding.line: ${m[4]}`);
+            const proxima = linhas[i + 1] ?? '';
+            const reproducao = /^\s*(?:reproduzir|reproduce)\s*:\s*`([^`]+)`\s*$/i.exec(proxima);
+            achados.push({ id: m[1], severidade: severidade(m[2]), arquivo: relativo, linha: Number(m[4]),
+                descricao: (0, hitl_1.redigirSegredos)(m[5]), ...(reproducao ? { reproduzir: (0, hitl_1.redigirSegredos)(reproducao[1]) } : {}) });
+            vistos.add(m[1]);
+        }
+        if (linhasMalformadas.length > 0) {
+            throw new Error(`fix.check.finding.malformado: ${linhasMalformadas.join(' | ')}`);
+        }
+        return { veredito: vereditoBilíngue(texto), sha256: (0, node_crypto_1.createHash)('sha256').update(bytes).digest('hex'), achados };
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
 /** Armazem append-only das correcoes da thread. */
 function caminhoDosFixes(raiz, threadId) {
     return path.join((0, thread_1.dirThread)(raiz, threadId), 'fixes.jsonl');
@@ -132,6 +226,7 @@ function derivarCorrecoes(thread, rodada, resultado, idsUsados) {
             estado: 'aberta',
             vereditoEm: null,
             detalheDoVeredito: '',
+            commitQueFechou: null,
             criadaEm: (0, util_1.agora)(),
         });
     };
@@ -161,6 +256,28 @@ function derivarCorrecoes(thread, rodada, resultado, idsUsados) {
     }
     return correcoes;
 }
+/** Achados sem claim entram na mesma rodada, mas so um novo parecer PASSOU consegue fecha-los. */
+function derivarCorrecoesDoParecer(thread, rodada, parecer, idsUsados) {
+    const ids = [...idsUsados];
+    return parecer.achados.map((achado) => {
+        const id = (0, util_1.proximoIdSequencial)(ids, 'FX');
+        ids.push(id);
+        return {
+            id, thread: thread.id, rodada, tipo: 'B', origem: 'check.finding',
+            alvo: `${achado.arquivo}:${achado.linha}`,
+            spec: `${achado.id} [${achado.severidade}]: ${achado.descricao}. Corrija o artefato indicado; ` +
+                'o fechamento exige um novo parecer independente com veredito PASSOU.',
+            verificar: [],
+            evidencia: [achado.reproduzir ? `reproduzir: ${achado.reproduzir}` : '',
+                `parecer sha256 ${parecer.sha256 ?? 'ausente'}`].filter(Boolean).join('\n'),
+            estado: 'aberta', vereditoEm: null, detalheDoVeredito: '', commitQueFechou: null,
+            achado: { id: achado.id, severidade: achado.severidade, arquivo: achado.arquivo, linha: achado.linha,
+                ...(achado.reproduzir ? { reproduzir: achado.reproduzir } : {}) },
+            parecerSha256: parecer.sha256 ?? undefined,
+            criadaEm: (0, util_1.agora)(),
+        };
+    });
+}
 /** 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');
@@ -217,7 +334,9 @@ function abrirRodadaSobConducao(carregado, threadId, opcoes) {
     // RM-058 N2 (A1 da rodada 2 do CHECK): a espera da fila pesada que o `--esperar` do CLI pediu.
     const resultado = (0, verify_1.verificar)(carregado, threadId, { soClaims: opcoes.soClaims, conducao: { filaPesada: opcoes.conducao?.filaPesada } });
     const rodada = ultimaRodada(raiz, threadId) + 1;
-    if (resultado.ok && resultado.motivos.length === 0) {
+    const parecer = lerParecerParaFix(raiz, threadId);
+    const parecerNegativo = parecer.veredito !== 'PASSOU';
+    if (resultado.ok && resultado.motivos.length === 0 && !parecerNegativo) {
         return {
             thread: threadId,
             rodada: rodada - 1,
@@ -230,7 +349,11 @@ function abrirRodadaSobConducao(carregado, threadId, opcoes) {
         };
     }
     const idsUsados = lerCorrecoes(raiz, threadId).map((c) => c.id);
-    const correcoes = derivarCorrecoes(thread, rodada, resultado, idsUsados);
+    if (parecerNegativo && parecer.achados.length === 0 && resultado.ok) {
+        throw new Error('fix.check.findings: parecer negativo sem achado estruturado; use A<n> [severidade] caminho:linha - descricao');
+    }
+    const doVerify = derivarCorrecoes(thread, rodada, resultado, idsUsados);
+    const correcoes = [...doVerify, ...(parecerNegativo ? derivarCorrecoesDoParecer(thread, rodada, parecer, [...idsUsados, ...doVerify.map((c) => c.id)]) : [])];
     for (const c of correcoes)
         (0, util_1.anexarJsonl)(caminhoDosFixes(raiz, threadId), c);
     const temTipoB = correcoes.some((c) => c.tipo === 'B');
@@ -244,6 +367,7 @@ function abrirRodadaSobConducao(carregado, threadId, opcoes) {
         motivos: resultado.motivos,
         commit: resultado.commit,
         evidencia: `ork verify reexecutado no HEAD ${resultado.commit} em ${resultado.cwd}`,
+        parecer: parecer.sha256 ? { sha256: parecer.sha256, veredito: parecer.veredito, achados: parecer.achados.map((a) => a.id) } : null,
         reexecucaoCompletaObrigatoria: temTipoB,
     });
     return {
@@ -258,12 +382,13 @@ function abrirRodadaSobConducao(carregado, threadId, opcoes) {
     };
 }
 /** Regrava uma correcao com o veredito do reverify. */
-function carimbar(raiz, correcao, aprovada, detalhe) {
+function carimbar(raiz, correcao, aprovada, detalhe, commit) {
     const atualizada = {
         ...correcao,
         estado: aprovada ? 'aprovada' : 'reprovada',
         vereditoEm: (0, util_1.agora)(),
         detalheDoVeredito: detalhe,
+        commitQueFechou: aprovada ? (correcao.commitQueFechou ?? commit) : null,
     };
     (0, util_1.anexarJsonl)(caminhoDosFixes(raiz, correcao.thread), atualizada);
     return atualizada;
@@ -317,17 +442,25 @@ function reverificarSobConducao(carregado, threadId, opcoes) {
             aprovada: !falhou,
             execucoes,
             detalhe: falhou
-                ? `"${falhou.comando}" ainda sai com codigo ${falhou.code}`
+                ? `"${(0, hitl_1.redigirSegredos)(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, { conducao: { filaPesada: opcoes.conducao?.filaPesada } }) : null;
+    const parecer = lerParecerParaFix(raiz, threadId);
     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;
+        const eAchado = v.correcao.origem === 'check.finding';
+        const checkNovoPassou = eAchado && parecer.veredito === 'PASSOU' && parecer.sha256 !== v.correcao.parecerSha256;
+        const aprovada = eAchado ? Boolean(verify?.ok && checkNovoPassou)
+            : v.correcao.verificar.length === 0 ? (verify?.ok ?? false) : v.aprovada;
         v.aprovada = aprovada;
-        carimbar(raiz, v.correcao, aprovada, v.detalhe);
+        if (eAchado)
+            v.detalhe = checkNovoPassou
+                ? 'novo parecer independente PASSOU e o verify completo ficou verde'
+                : 'aguarda novo parecer independente com veredito PASSOU';
+        v.correcao = carimbar(raiz, v.correcao, aprovada, v.detalhe, aprovada ? (verify?.commit ?? (0, verify_1.commitReal)(cwd)) : null);
     }
     const rodadas = rodada;
     const limite = manifesto.retry.max_tentativas;
@@ -417,6 +550,19 @@ 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;
 }
+function statusDaRodada(raiz, threadId, rodada = ultimaRodada(raiz, threadId)) {
+    (0, thread_1.lerThread)(raiz, threadId);
+    if (rodada === 0)
+        return { thread: threadId, rodada: 0, estado: 'sem-rodada', achados: [], faltam: [] };
+    const correcoes = correcoesDaRodada(raiz, threadId, rodada);
+    if (correcoes.length === 0)
+        throw new Error(`rodada ${rodada} nao existe na thread ${threadId}`);
+    const achados = correcoes.map((c) => ({ correcao: c.id, achado: c.achado?.id ?? null, origem: c.origem,
+        arquivo: c.achado?.arquivo ?? null, linha: c.achado?.linha ?? null, estado: c.estado,
+        commitQueFechou: c.commitQueFechou ?? null }));
+    const faltam = achados.filter((a) => a.estado !== 'aprovada').map((a) => a.correcao);
+    return { thread: threadId, rodada, estado: faltam.length ? 'aberta' : 'concluida', achados, faltam };
+}
 /** Texto de `ork fix open`. */
 function textoDaRodada(r) {
     const m = (0, locale_1.msg)().operacao.restante.fix;

package/dist/hitl-gates.js

@@ -259,7 +259,7 @@ function diagnosticoSemConclusao(resultado) {
  * gate e quem pergunta se um gate ainda espera o dono leem a mesma.
  */
 exports.MOTIVOS_DE_ESCALACAO_HUMANA = ['policy.violation', 'cost.violation', 'retry.max_tentativas',
-    'hitl.credencial', 'runtime.unavailable'];
+    'hitl.credencial', 'runtime.unavailable', 'claims.retirada-sem-substituta'];
 /** Uma pausa do modo cria pedido, nunca human_gate. Escalação exige evento tipado. */
 function abrirPedidoGate(raiz, id, motivo = 'human.pending', quando = new Date().toISOString()) {
     const preparado = prepararPedidoGate(raiz, id, motivo, quando);

package/dist/index.js

@@ -1413,12 +1413,14 @@ function comandoClaims(args) {
             return 2;
         }
         const comando = texto(args.opcoes.verificar) ?? texto(args.opcoes.verify);
+        const dependenciasExternas = (texto(args.opcoes['dependencia-externa']) ?? '').split(',').map((d) => d.trim()).filter(Boolean);
         const faseBruta = texto(args.opcoes.fase);
         const thread = (0, thread_1.lerThread)(carregado.raiz, id);
         const claim = (0, locale_1.comLocale)('pt-BR', () => (0, claims_1.adicionarClaim)(carregado.raiz, id, {
             arquivo,
             alegacao,
             verificar: comando ? [comando] : [],
+            dependenciasExternas,
             fase: faseBruta ? (0, thread_1.exigirFase)(thread, faseBruta) : undefined,
         }));
         console.log(mc.registrada(claim.id, id));
@@ -1500,14 +1502,40 @@ function comandoClaims(args) {
         const id = args.posicionais[2];
         const claimId = args.posicionais[3];
         const motivo = texto(args.opcoes.motivo);
+        const motivoTipo = texto(args.opcoes['motivo-tipo']);
+        const substituidaPor = texto(args.opcoes['substituida-por']);
         if (!id || !claimId || !motivo) {
             console.error(mc.usoRetirar);
             return 2;
         }
-        const claim = (0, locale_1.comLocale)('pt-BR', () => (0, claims_1.retirarClaim)(carregado.raiz, id, claimId, motivo));
-        console.log(mc.retirada(claim.id, id));
-        console.log(mc.campoAlegacao(claim.alegacao));
-        console.log(mc.campoMotivo(motivo));
+        const dispatchId = (0, conducao_1.identidadeDoAmbiente)(id, process.env, carregado.raiz);
+        const autor = dispatchId ? { tipo: 'sessao', id: dispatchId } : { tipo: 'dono', id: 'terminal-local' };
+        const motivoSeguro = (0, hitl_1.redigirSegredos)(motivo);
+        if (!motivoTipo) {
+            const claim = (0, locale_1.comLocale)('pt-BR', () => (0, claims_1.retirarClaim)(carregado.raiz, id, claimId, motivo, autor));
+            console.log(mc.retirada(claim.id, id));
+            console.log(mc.retiradaTipada(false));
+            console.log(mc.autorDaRetirada(autor.tipo, autor.id));
+            console.log(mc.campoAlegacao(claim.alegacao));
+            console.log(mc.campoMotivo(motivoSeguro));
+            console.log(mc.historicoContinua);
+            return 0;
+        }
+        const resultado = (0, locale_1.comLocale)('pt-BR', () => (0, claims_1.retirarClaimTipada)(carregado.raiz, id, claimId, { motivoTipo, substituidaPor, motivo, autor }));
+        if (resultado.estado === 'pendente-do-dono') {
+            (0, hitl_gates_1.abrirPedidoGate)(carregado.raiz, id, resultado.motivo);
+            console.log(mc.retiradaPendente(claimId));
+            console.log(mc.retiradaTipada(true));
+            console.log(mc.autorDaRetirada(autor.tipo, autor.id));
+            console.log(mc.campoMotivo(motivoSeguro));
+            return 1;
+        }
+        console.log(mc.retirada(resultado.claim.id, id));
+        console.log(mc.retiradaTipada(true));
+        console.log(mc.autorDaRetirada(autor.tipo, autor.id));
+        console.log(mc.substitutaDaRetirada(resultado.substituidaPor));
+        console.log(mc.campoAlegacao(resultado.claim.alegacao));
+        console.log(mc.campoMotivo(motivoSeguro));
         console.log(mc.historicoContinua);
         return 0;
     }
@@ -2026,6 +2054,27 @@ function comandoFix(args) {
         ])));
         return 0;
     }
+    if (sub === 'status') {
+        if (!id) {
+            console.error(mf.usoStatus);
+            return 2;
+        }
+        const rodadaBruta = texto(args.opcoes.rodada);
+        const status = (0, fix_1.statusDaRodada)(carregado.raiz, id, rodadaBruta ? Number(rodadaBruta) : undefined);
+        if (args.opcoes.json === true) {
+            console.log(JSON.stringify(status, null, 2));
+            return 0;
+        }
+        console.log(mf.status(status.rodada, id));
+        console.log(mf.estado(status.estado));
+        console.log(mf.faltam(status.faltam.length ? status.faltam.join(', ') : mf.semFaltas));
+        if (status.achados.length) {
+            console.log('');
+            console.log((0, util_1.tabela)([...mf.colunasStatus], status.achados.map((a) => [a.correcao, a.achado ?? '-', a.origem,
+                a.arquivo && a.linha ? `${a.arquivo}:${a.linha}` : '-', a.estado, a.commitQueFechou ?? '-'])));
+        }
+        return 0;
+    }
     if (sub === 'reverify') {
         if (!id) {
             console.error(mf.usoReverify);

package/dist/locale-ajuda.js

@@ -141,7 +141,7 @@ Uso: ork [--projeto <nome|caminho>] <comando> [argumentos]
         [--limiares <arquivo>]                  os limiares do dono; o que faltar fica com a proposta, marcada
         [--publicar <arquivo>]                  grava a versão publicável, sem dado pessoal
 
-  claims add <thread-id> <arquivo> --claim "<alegacao>" [--verificar "<comando>"] [--fase F]
+  claims add <thread-id> <arquivo> --claim "<alegacao>" [--verificar "<comando>"] [--dependencia-externa rede,relogio] [--fase F]
                                             Registra alegacao verificavel da thread
   claims list <thread-id>                   Claims da thread e o estado de cada uma
   claims conferir <thread-id> --claims C1,C2|--tarefa T1 [--prazo S] [--json]
@@ -154,7 +154,8 @@ Uso: ork [--projeto <nome|caminho>] <comando> [argumentos]
   decisao placar <thread-id> [--json]       Decididas contra perguntas por fase, reversoes e o limiar
   claims verificar <thread-id> <claim-id> --comando "<comando>"
                                             Anexa o comando que comprova uma claim ja feita
-  claims retirar <thread-id> <claim-id> --motivo "<motivo>"
+  claims retirar <thread-id> <claim-id> [--motivo-tipo substituicao|obsoleta|erro]
+        [--substituida-por <claim-id>] --motivo "<motivo>"
                                             Retira a alegacao (o historico fica no claims.jsonl)
   claims ausente <thread-id> --paths A,B --motivo "<motivo>" [--commit SHA]
                                             Ciclo sem CHECK: declara no ledger o que ficou sem prova
@@ -191,6 +192,8 @@ Uso: ork [--projeto <nome|caminho>] <comando> [argumentos]
   fix open <thread-id> [--so-claims]        GO-FIX: deriva a spec exata do CHECK reprovado
         [--reverify] [--json]                    (uma correcao por motivo tipado, tipo A ou B)
   fix list <thread-id> [--rodada N]         Correcoes da rodada e o veredito de cada uma
+  fix status <thread-id> [--rodada N]       Achados, commit que fechou e o que falta
+        [--json]
   fix reverify <thread-id> [--rodada N]     CHECK-REVERIFY com veredito POR correcao
         [--parcial] [--json]                     (--parcial e RECUSADO se houver tipo B)
 
@@ -555,7 +558,7 @@ Usage: ork [--projeto <name|path>] <command> [arguments]
         [--limiares <file>]                     the owner's thresholds; what is missing stays with the proposal, marked
         [--publicar <file>]                     writes the publishable version, without personal data
 
-  claims add <thread-id> <file> --claim "<claim>" [--verificar "<command>"] [--fase F]
+  claims add <thread-id> <file> --claim "<claim>" [--verificar "<command>"] [--dependencia-externa rede,relogio] [--fase F]
                                             Records a verifiable claim of the thread
   claims list <thread-id>                   Claims of the thread and the state of each one
   claims conferir <thread-id> --claims C1,C2|--tarefa T1 [--prazo S] [--json]
@@ -568,7 +571,8 @@ Usage: ork [--projeto <name|path>] <command> [arguments]
   decisao placar <thread-id> [--json]       Decided versus asked per phase, reversals and the threshold
   claims verificar <thread-id> <claim-id> --comando "<command>"
                                             Attaches the command that proves a claim already made
-  claims retirar <thread-id> <claim-id> --motivo "<reason>"
+  claims retirar <thread-id> <claim-id> [--motivo-tipo substituicao|obsoleta|erro]
+        [--substituida-por <claim-id>] --motivo "<reason>"
                                             Withdraws the claim (the history stays in claims.jsonl)
   claims ausente <thread-id> --paths A,B --motivo "<reason>" [--commit SHA]
                                             Cycle without CHECK: declares in the ledger what was left without proof
@@ -605,6 +609,8 @@ Usage: ork [--projeto <name|path>] <command> [arguments]
   fix open <thread-id> [--so-claims]        GO-FIX: derives the exact spec of the failed CHECK
         [--reverify] [--json]                    (one fix per typed reason, type A or B)
   fix list <thread-id> [--rodada N]         Fixes of the round and the verdict of each one
+  fix status <thread-id> [--rodada N]       Findings, closing commit, and remaining work
+        [--json]
   fix reverify <thread-id> [--rodada N]     CHECK-REVERIFY with a verdict PER fix
         [--parcial] [--json]                     (--parcial is REFUSED if there is a type B)