@orkastery/cli 0.5.0 → 0.5.3

package/dist/ledger-stats.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parsePeriodo = parsePeriodo;
 exports.coletarEstatisticas = coletarEstatisticas;
 exports.registrarEstimativaPlano = registrarEstimativaPlano;
+exports.linhaDoHitlDeConducao = linhaDoHitlDeConducao;
 exports.textoDasEstatisticas = textoDasEstatisticas;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
@@ -43,6 +44,7 @@ const thread_1 = require("./thread");
 const ledger_1 = require("./ledger");
 const util_1 = require("./util");
 const horario_1 = require("./horario");
+const hitl_tempo_parado_1 = require("./hitl-tempo-parado");
 const MOTIVOS_PREVENTIVOS = new Set([
     'policy.violation', 'cost.violation', 'verify.regression', 'claims.failed', 'claims.unverifiable',
 ]);
@@ -118,7 +120,9 @@ function coletarEstatisticas(raiz, filtros) {
     const riscos = {};
     const leads = [];
     const fontes = new Set();
-    for (const { eventos } of selecionadas) {
+    const esperasDeConducao = [];
+    for (const { thread, eventos } of selecionadas) {
+        esperasDeConducao.push(...(0, hitl_tempo_parado_1.esperasDeHitl)(thread.id, eventos));
         corrompidos += eventos.filter(e => e.tipo === 'ledger_corrupted').length;
         const despachos = new Map();
         for (const e of eventos)
@@ -237,6 +241,7 @@ function coletarEstatisticas(raiz, filtros) {
         custoReferencia: { natureza: tarifas.nature, moeda: tarifas.currency, valor: precificadas ? Number(custo.toFixed(6)) : null, sessoesPrecificadas: precificadas, sessoesSemTarifa: semTarifa, tarifasVerificadasEm: tarifas.verifiedAt, fontes: [...fontes].sort() },
         leadTime: { mediaMs: leads.length ? leads.reduce((a, b) => a + b, 0) / leads.length : null, amostras: leads.length },
         esperaHumana: { milissegundos: esperaMs, fechadas: esperasFechadas, abertas: esperasAbertas },
+        hitlDeConducao: (0, hitl_tempo_parado_1.resumirTempoParado)(esperasDeConducao, desdeMs, ateMs),
         riscosPreventivos: { total: Object.values(riscos).reduce((a, b) => a + b, 0), porMotivo: riscos },
         estimativasPlano: { amostras: estimativas, semIaHoras, iaSemOrkHoras },
         qualidade: { ledgersCorrompidos: corrompidos, observacoes },
@@ -255,6 +260,14 @@ function registrarEstimativaPlano(raiz, threadId, dados) {
         throw Error('ledger.estimate.head-unavailable');
     return (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, threadId), threadId, 'plan_estimate', { fase: 'PLAN', unidade: 'hours', semIaHoras: dados.semIaHoras, iaSemOrkHoras: dados.iaSemOrkHoras, por: dados.por, metodo: dados.metodo, premissas: dados.premissas, incerteza: dados.incerteza ?? 'nao informada', head: head.stdout.trim() });
 }
+const minutos = (ms) => ms === null ? 'sem resposta medida' : `${(ms / 60_000).toFixed(1)} min`;
+/** RM-057: uma linha, com a meta ao lado da mediana, para o dono ver o tempo parado sem abrir o JSON. */
+function linhaDoHitlDeConducao(h) {
+    const meta = h.dentroDaMeta === null ? '' : h.dentroDaMeta ? ' (dentro da meta de 5 min)' : ' (acima da meta de 5 min)';
+    return `  HITL de conducao ${h.pedidos} pergunta(s); parado ${(h.paradoMs / 3_600_000).toFixed(2)} h; ` +
+        `mediana ${minutos(h.medianaRespostaMs)}${meta}; ${h.abertos} aberta(s); ` +
+        `texto fora da excecao ${h.emTexto.foraDaExcecao}`;
+}
 function textoDasEstatisticas(r) {
     const dinheiro = r.custoReferencia.valor === null ? 'sem cobertura' : `USD ${r.custoReferencia.valor.toFixed(6)}`;
     return [
@@ -265,6 +278,7 @@ function textoDasEstatisticas(r) {
         `  tokens           ${r.tokens.total} total; input ${r.tokens.input} (cached ${r.tokens.cachedInput}); output ${r.tokens.output}`,
         `  custo referencia ${dinheiro} — estimativa por tarifa publica, nao gasto/fatura`,
         `  espera humana    ${(r.esperaHumana.milissegundos / 3_600_000).toFixed(2)} h; ${r.esperaHumana.abertas} aberta(s)`,
+        linhaDoHitlDeConducao(r.hitlDeConducao),
         `  riscos evitados  ${r.riscosPreventivos.total} gate(s) preventivo(s)`,
         `  estimativas PLAN ${r.estimativasPlano.amostras} amostra(s)`,
         ...r.qualidade.observacoes.map(o => `  cobertura         ${o}`),

package/dist/ledger.js

@@ -45,6 +45,7 @@ exports.caminhoLedger = caminhoLedger;
 exports.registrar = registrar;
 exports.threadPresente = threadPresente;
 exports.registrarSeExiste = registrarSeExiste;
+exports.ehEnsaio = ehEnsaio;
 exports.lerLedger = lerLedger;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
@@ -140,6 +141,9 @@ exports.TIPOS_DE_EVENTO = {
     // I-33 (D5): troca de perfil ou de runtime depois de falha da conta (quem, de qual para
     // qual, evidencia e razao). Faz parte do catalogo, nao de literal solto.
     perfilRotacionado: 'runtime_profile_rotated',
+    // RM-037 (fatia 5): a cota que o observador viu na transcricao com a sessao viva; o perfil saiu do rodizio
+    // ali, ate a hora dita na mensagem, e nao so no fecho da fase.
+    cotaVistaNaTranscricao: 'runtime_quota_detected',
     fixAberto: 'go_fix_opened',
     fixDespachado: 'go_fix_dispatched',
     reverifyConcluido: 'check_reverify',
@@ -236,6 +240,14 @@ function registrarSeExiste(dirThread, threadId, tipo, dados = {}) {
     }
     return evento;
 }
+/**
+ * Fatia 2 do ensaio da 0.5.0 (P2): o evento que um `--dry-run` grava (`dryRun: true`) e ensaio, nao
+ * estado. O ledger o guarda como rastro; board, escalonador, monitor (o pulse) e maestro o descartam.
+ * O ensaio do ship gravava `gate_blocked human.pending` e a thread aparecia pausada sem ninguem pedir.
+ */
+function ehEnsaio(e) {
+    return e.dryRun === true;
+}
 /** Le o ledger inteiro. Linha corrompida vira evento `ledger_corrupted` em vez de quebrar a leitura. */
 function lerLedger(dirThread) {
     const caminho = caminhoLedger(dirThread);

package/dist/licoes.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PISO_DA_PROPOSTA = exports.JANELA_DA_PROPOSTA_DIAS = void 0;
+exports.PISO_DA_PROPOSTA = exports.JANELA_DA_PROPOSTA_DIAS = exports.DICA_DO_MOTIVO = void 0;
 exports.lerLicoes = lerLicoes;
 exports.resumoDasLicoes = resumoDasLicoes;
 exports.textoDasLicoes = textoDasLicoes;
@@ -59,15 +59,17 @@ const estado_thread_1 = require("./estado-thread");
 const ledger_1 = require("./ledger");
 const policies_1 = require("./policies");
 /** O que evita cada bloqueio, na forma de comando. Sem dica, a licao so conta a recorrencia. */
-const DICA_DO_MOTIVO = {
+exports.DICA_DO_MOTIVO = {
     'claims.failed': 'rode o comando da claim antes de registra-la; claim sem prova local volta como GO-FIX',
     'verify.regression': 'grave a baseline antes do GO (`ork verify <thread> --baseline`) e rode os testes focados antes do CHECK',
     'verify.failed': 'grave a baseline antes do GO, para a falha ter com que ser comparada',
     'verify.timeout': 'divida o comando lento ou suba `verify.timeout_ms` no manifesto',
     'runtime.unavailable': 'declare a ordem de fallback do bloco (`ork setup <modo> --bloco N --fallback runtime:modelo`)',
     'runtime.quota-exhausted': 'tenha um segundo perfil da conta (`ork accounts add`) ou fallback no bloco',
+    'runtime.profile-invalid': 'confira os perfis do runtime em `ork accounts list` antes de pedir `--perfil`',
     'tree.blocked': 'sincronize a worktree com a base antes do SHIP (`ork worktree sync <thread>`)',
-    'ci.failed': 'rode a suite hermetica (`npm --prefix core run test:ci`) antes do push',
+    // Fatia 2 do ensaio da 0.5.0 (P6): o que o CI do projeto roda, e nao o script do Orkastery.
+    'ci.failed': 'rode antes do push o que o CI do projeto roda (`ci.command` do manifesto ou, sem ele, os comandos de `verify`)',
     'artifact.missing': 'grave o artefato da fase exatamente no caminho que o prompt pede',
 };
 const DICA_DA_CLASSE = {
@@ -116,7 +118,7 @@ function recorrencias(licoes) {
     const classes = new Map();
     for (const l of licoes) {
         for (const m of l.motivos) {
-            const r = motivos.get(m) ?? { chave: `motivo:${m}`, tipo: 'motivo', nome: m, threads: [], vezes: 0, dica: DICA_DO_MOTIVO[m] ?? null };
+            const r = motivos.get(m) ?? { chave: `motivo:${m}`, tipo: 'motivo', nome: m, threads: [], vezes: 0, dica: exports.DICA_DO_MOTIVO[m] ?? null };
             r.threads.push(l.thread);
             motivos.set(m, r);
         }

package/dist/liveness.js

@@ -120,7 +120,8 @@ function detectarFasesOrfas(carregado, opcoes = {}) {
         const t = (0, thread_1.lerThread)(carregado.raiz, id), dir = (0, thread_1.dirThread)(carregado.raiz, id);
         if (t.status !== 'aberta')
             continue;
-        const eventos = (0, ledger_1.lerLedger)(dir), di = eventos.map(e => e.tipo).lastIndexOf('phase_dispatch');
+        // Fatia 2 do ensaio da 0.5.0 (P2; CHECK, rodada 1, A1): o gate do `ship --dry-run` nao e gate em aberto.
+        const eventos = (0, ledger_1.lerLedger)(dir).filter(e => !(0, ledger_1.ehEnsaio)(e)), di = eventos.map(e => e.tipo).lastIndexOf('phase_dispatch');
         if (di < 0)
             continue;
         const d = eventos[di], inicio = Date.parse(d.ts), fase = d.fase;

package/dist/maestro-runtime.js

@@ -47,6 +47,7 @@ const hitl_sessions_1 = require("./hitl-sessions");
 const thread_1 = require("./thread");
 const hitl_gates_1 = require("./hitl-gates");
 const ocupacao_1 = require("./ocupacao");
+const ledger_1 = require("./ledger");
 const horario_1 = require("./horario");
 const conducao_1 = require("./conducao");
 const conducao_texto_1 = require("./conducao-texto");
@@ -74,8 +75,11 @@ const shipView = zod_1.z.union([
     zod_1.z.object({
         tipo: zod_1.z.literal('ship_done'), ts: shipTs, pushVerificado: zod_1.z.boolean(), mergeSha: shipSha,
         shaRemoto: shipSha.nullable().optional(),
+        // RM-037 (fatia 5, A1): o push prova a ponta da base; o `mergeSha` e o merge que entregou, que pode ser mais
+        // velho que ela. Recibo sem o campo continua valendo pela regra de antes.
+        pontaDaBase: shipSha.nullable().optional(),
         fonteDaProva: zod_1.z.string().min(1).max(512).refine(v => !/[\u0000-\u001f\u007f]/.test(v)).nullable().optional(),
-    }).refine(s => !s.pushVerificado || (s.shaRemoto === s.mergeSha && typeof s.fonteDaProva === 'string')),
+    }).refine(s => !s.pushVerificado || (s.shaRemoto === (s.pontaDaBase ?? s.mergeSha) && typeof s.fonteDaProva === 'string')),
     zod_1.z.object({ tipo: zod_1.z.enum(['ship_started', 'ship_blocked']), ts: shipTs }),
 ]);
 function operationalSources(reader, threads, native = [], now = new Date().toISOString(), threadScope) {
@@ -95,6 +99,8 @@ function operationalSources(reader, threads, native = [], now = new Date().toISO
             events = raw.split('\n').filter(Boolean).map(line => JSON.parse(line));
             if (events.some(e => typeof e.tipo !== 'string' || e.thread !== t.id))
                 throw Error('invalid');
+            // Fatia 2 do ensaio da 0.5.0 (P2): o ensaio (`dryRun: true`) nao vira bloqueio nem entrega incompleta.
+            events = events.filter(e => !(0, ledger_1.ehEnsaio)(e));
         }
         catch {
             for (const name of names.filter(n => !['leases', 'retries'].includes(n)))

package/dist/manifest.js

@@ -165,6 +165,28 @@ function booleano(v, padrao) {
 function mapa(v) {
     return v && typeof v === 'object' && !Array.isArray(v) ? v : {};
 }
+/**
+ * RM-031 KG5 (D2): `grafo.mcp` so liga com o booleano `true`. Ausente vale `false`; texto que parece
+ * booleano, outro tipo ou `grafo` que nao e mapa tambem valem `false`, com aviso: ligar expoe as tools
+ * do grafo, e na duvida fica desligado. Chave desconhecida em `grafo` so avisa.
+ */
+function lerGrafo(v, avisos) {
+    const mostrar = (x) => JSON.stringify(x).slice(0, 80);
+    if (v === undefined || v === null)
+        return { mcp: false };
+    if (typeof v !== 'object' || Array.isArray(v)) {
+        avisos.push(`grafo deve ser um mapa com mcp: true ou false; vale mcp: false (${mostrar(v)} nao reconhecido)`);
+        return { mcp: false };
+    }
+    for (const chave of Object.keys(v))
+        if (chave !== 'mcp')
+            avisos.push(`grafo.${chave} desconhecida; o bloco grafo so tem mcp`);
+    const mcp = v.mcp;
+    if (mcp === undefined || mcp === null || typeof mcp === 'boolean')
+        return { mcp: mcp === true };
+    avisos.push(`grafo.mcp deve ser true ou false; vale false (${mostrar(mcp)} nao reconhecido)`);
+    return { mcp: false };
+}
 /** Mesmo contrato na leitura do YAML e nos consumidores de manifesto em memoria. */
 function validarOptInPlaybook(valor) {
     if (valor === undefined)
@@ -334,6 +356,16 @@ function carregarManifesto(dirInicial = diretorioDoProjeto()) {
         avisos.push(`runtime_profiles.${nome} deve ser true ou false; vale o padrao ${padrao} (${JSON.stringify(v)} nao reconhecido)`);
         return padrao;
     };
+    // RM-056 (D2): opt-in. Valor desconhecido vale o padrao `ordem`, com aviso.
+    const distribuicaoDePerfis = () => {
+        const v = perfisDeRuntime.distribuir;
+        if (v === undefined || v === null || v === 'ordem')
+            return 'ordem';
+        if (v === 'carga')
+            return 'carga';
+        avisos.push(`runtime_profiles.distribuir aceita ordem ou carga; vale o padrao ordem (${JSON.stringify(v)} nao reconhecido)`);
+        return 'ordem';
+    };
     const liveness = mapa(dados.liveness);
     const silencioMaxMin = numero(liveness.silencio_max_min, 10);
     if (!Number.isFinite(silencioMaxMin) || silencioMaxMin <= 0)
@@ -434,6 +466,11 @@ function carregarManifesto(dirInicial = diretorioDoProjeto()) {
             '(o `ork` nao adivinha DSN, e base alheia e pior do que base nenhuma)');
     }
     const embedding = lerEmbedding(memory.embedding, variavelDaDsn, erros);
+    const prazoDoUniverso = memory.universo_timeout_ms === undefined ? orkmind_1.TIMEOUT_DO_UNIVERSO_MS : memory.universo_timeout_ms;
+    if (typeof prazoDoUniverso !== 'number' || !Number.isSafeInteger(prazoDoUniverso) || prazoDoUniverso <= 0 ||
+        prazoDoUniverso > orkmind_1.LIMITE_TIMEOUT_DO_UNIVERSO_MS) {
+        erros.push('memory.universo_timeout_ms: esperado inteiro em ms entre 1 e 86400000 (24 h; valor omitido)');
+    }
     const bytes = Buffer.byteLength(bruto, 'utf8');
     if (bytes > exports.LIMITE_MANIFESTO_BYTES) {
         erros.push(`manifesto com ${bytes} bytes, acima do limite duro de ${exports.LIMITE_MANIFESTO_BYTES} (prosa vai para memoria com tag, nao para o YAML)`);
@@ -469,7 +506,9 @@ function carregarManifesto(dirInicial = diretorioDoProjeto()) {
         worktree: {
             base_branch: texto(worktree.base_branch, 'main'),
             dir: texto(worktree.dir, '.claude/worktrees'),
-            por_thread: booleano(worktree.por_thread, true),
+            // P4 do ensaio da 0.5.0: o `ork thread new` cria a worktree sem flag quando a chave diz true. Ausente le
+            // false, para o projeto que nunca a declarou seguir como era.
+            por_thread: booleano(worktree.por_thread, false),
         },
         verify: {
             build: verify.build === null || verify.build === undefined ? undefined : texto(verify.build, ''),
@@ -500,6 +539,7 @@ function carregarManifesto(dirInicial = diretorioDoProjeto()) {
         runtime_profiles: {
             rotate_same_runtime_on_quota: chaveDeRotacao('rotate_same_runtime_on_quota', true),
             rotate_same_runtime_on_auth: chaveDeRotacao('rotate_same_runtime_on_auth', true),
+            distribuir: distribuicaoDePerfis(),
         },
         // Bloco B3: o limite de escalacao tem padrao, e o padrao e conservador. Manifesto
         // sem bloco `retry:` continua andando com 3 tentativas e janela estimada de 60 min,
@@ -518,6 +558,7 @@ function carregarManifesto(dirInicial = diretorioDoProjeto()) {
             cli: texto(memory.cli, 'orkmind'),
             tenant: texto(memory.tenant, '') || nomeProjeto,
             timeout_ms: numero(memory.timeout_ms, 15000),
+            universo_timeout_ms: typeof prazoDoUniverso === 'number' ? prazoDoUniverso : orkmind_1.TIMEOUT_DO_UNIVERSO_MS,
             ...(embedding ? { embedding } : {}),
         },
         // Bloco B5: governanca de custo dos auditores. Ausente no manifesto quer dizer
@@ -534,6 +575,8 @@ function carregarManifesto(dirInicial = diretorioDoProjeto()) {
             compartilhada: booleano(fabrica.compartilhada, false),
             remoto: texto(fabrica.remoto, 'origin'),
         },
+        // RM-031 KG5 (D2): expor as tools do grafo no MCP e opt-in do dono.
+        grafo: lerGrafo(dados.grafo, avisos),
         policies: Object.fromEntries(Object.entries(mapa(dados.policies)).map(([k, v]) => [k, texto(v, '')])),
     };
     return { caminho: achado.caminho, raiz, legado: achado.legado, bytes, manifesto, erros, avisos };

package/dist/master-nota.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ERRO_PROVA_DE_CANAL = exports.CONTRATO_PEDIDO_DE_NOTA = void 0;
+exports.marcaDeHost = marcaDeHost;
 exports.exigirNotaSemHost = exigirNotaSemHost;
 exports.arquivoDasNotas = arquivoDasNotas;
 exports.pedirNota = pedirNota;
@@ -84,10 +85,11 @@ exports.CONTRATO_PEDIDO_DE_NOTA = 'ork.master-nota/v1';
 exports.ERRO_PROVA_DE_CANAL = 'master.prova-de-canal';
 const sha = (s) => (0, node_crypto_1.createHash)('sha256').update(s).digest('hex');
 /**
- * D8: nota em nome de pessoa, vinda de processo de host, e recusada. O canal e lido SO do
- * ambiente: `--canal` em argv nao conta, porque quem escreve argv e justamente quem chama.
+ * A marca de host ou de despacho do processo, ou `undefined` no terminal do dono. Lida SO do
+ * ambiente. Serve para RECUSAR (D8) e para AVISAR (RM-008, aceite por omissao sem thread), nunca
+ * para autorizar.
  */
-function exigirNotaSemHost(ambiente = process.env) {
+function marcaDeHost(ambiente = process.env) {
     let canal;
     try {
         canal = (0, conducao_1.canalDoProcesso)(undefined, ambiente);
@@ -97,12 +99,19 @@ function exigirNotaSemHost(ambiente = process.env) {
     }
     // B2 do CHECK: `ORK_CANAL=cli` NAO absolve. A sessao despachada herda `ORK_CANAL=cli` quando a
     // thread e conduzida do terminal, e o Claude Code e o Codex marcam os proprios processos. Qualquer
-    // marca de host ou de despacho recusa, mesmo com o canal declarado como terminal.
-    const marca = canal !== 'cli' ? canal
+    // marca de host ou de despacho conta, mesmo com o canal declarado como terminal.
+    return canal !== 'cli' ? canal
         : ambiente.ORK_DISPATCH_ID ? 'sessão despachada (ORK_DISPATCH_ID)'
             : ambiente.CLAUDECODE === '1' ? 'claude-code (CLAUDECODE)'
                 : ambiente.CODEX_SANDBOX || ambiente.CODEX_SANDBOX_NETWORK_DISABLED ? 'codex (CODEX_SANDBOX)'
                     : (ambiente.HERMES_HOME ?? '').trim() ? 'hermes (HERMES_HOME)' : undefined;
+}
+/**
+ * D8: nota em nome de pessoa, vinda de processo de host, e recusada. O canal e lido SO do
+ * ambiente: `--canal` em argv nao conta, porque quem escreve argv e justamente quem chama.
+ */
+function exigirNotaSemHost(ambiente = process.env) {
+    const marca = marcaDeHost(ambiente);
     if (marca) {
         throw new Error(`${exports.ERRO_PROVA_DE_CANAL}: nota em nome de pessoa vinda de ${marca} exige a prova de canal do ingresso. ` +
             'Peça a nota com ork master pedir <thread>: o dono responde pelo Telegram com o código, e a nota é gravada com o recibo.');

package/dist/master.js

@@ -49,7 +49,9 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AUTOR_DA_OMISSAO = exports.CONTRATO_MASTER_PENDENTE = exports.ORDEM_DAS_CLASSES = exports.CLASSES_DE_FALHA = exports.VERSAO_MASTER_LOG = exports.CONTRATO_MASTER_LOG = void 0;
+exports.AUTOR_DA_OMISSAO = exports.CONTRATO_MASTER_PENDENTE = exports.FASE_DO_TIPO = exports.ORDEM_DAS_CLASSES = exports.CLASSE_DO_MOTIVO = exports.CLASSES_DE_FALHA = exports.VERSAO_MASTER_LOG = exports.CONTRATO_MASTER_LOG = void 0;
+exports.classesPelosGates = classesPelosGates;
+exports.sincronizacoesComABase = sincronizacoesComABase;
 exports.parseClasse = parseClasse;
 exports.caminhoPostmortem = caminhoPostmortem;
 exports.caminhoMasterLog = caminhoMasterLog;
@@ -72,6 +74,8 @@ exports.aceitosPorOmissao = aceitosPorOmissao;
 exports.pendentesDeScore = pendentesDeScore;
 exports.tabelaDeEntregas = tabelaDeEntregas;
 exports.aceitarPendentesPorOmissao = aceitarPendentesPorOmissao;
+exports.entregasParaOmissao = entregasParaOmissao;
+exports.motivoForaDaOmissao = motivoForaDaOmissao;
 exports.textoDoMaster = textoDoMaster;
 exports.tabelaDeClasses = tabelaDeClasses;
 const path = __importStar(require("node:path"));
@@ -105,6 +109,65 @@ exports.CLASSES_DE_FALHA = {
     'scope-creep': 'a entrega cresceu alem do que o GOAL prometia',
     outra: 'nao cabe em nenhuma classe acima (descreva na justificativa)',
 };
+/**
+ * RM-008 (classe pelo gate): a classe que cada motivo tipado do gate sustenta quando ninguem informa
+ * `--classe`. Antes, todo gate virava "outra", a classe que o `ork licoes` ignora: 8 POSTMORTEMs de
+ * 03/10 fecharam assim por aceite por omissao. Motivo fora da tabela (prazo, falta de veredito,
+ * runtime, conta, custo, espera humana) nao cabe numa classe fixa e segue "outra".
+ */
+exports.CLASSE_DO_MOTIVO = {
+    'artifact.missing': 'processo',
+    'claims.failed': 'processo',
+    'claims.unverifiable': 'processo',
+    'policy.violation': 'processo',
+    'runtime.autoconferencia': 'processo',
+    'verify.regression': 'processo',
+    'verify.failed': 'processo',
+    'ci.failed': 'processo',
+    'hitl.formato': 'processo',
+    'runtime.rate-limited': 'rate-limit',
+    'runtime.quota-exhausted': 'rate-limit',
+    'lease.busy': 'conflito',
+    'conducao.em-andamento': 'conflito',
+    'tree.blocked': 'conflito',
+};
+/** As classes que os motivos dos gates sustentam, na ordem canonica e sem repetir. */
+function classesPelosGates(motivos) {
+    const achadas = new Set();
+    for (const m of motivos)
+        achadas.add(exports.CLASSE_DO_MOTIVO[m] ?? 'outra');
+    if (achadas.size === 0)
+        achadas.add('sem-falha');
+    return exports.ORDEM_DAS_CLASSES.filter((c) => achadas.has(c));
+}
+/** Teto de merges conferidos por entrega: a branch de 03/10 com mais sincronizacoes trouxe 16. */
+const TETO_DE_MERGES_POR_ENTREGA = 200;
+/**
+ * RM-008 (base-avancou): quantas vezes a thread precisou trazer a base para dentro da branch. Conta os
+ * `worktree_synced` do ledger e, em cada entrega com merge, os merges da branch (entre o primeiro e o
+ * segundo pai do merge) cujo pai trazido ja estava na base. Em 03/10/2026, 29 de 35 entregas trouxeram
+ * a `origin/main` antes do merge, e nenhuma fechou com `base-avancou`. Git sem resposta conta 0 e nunca
+ * derruba o MASTER.
+ */
+function sincronizacoesComABase(raiz, eventos, mergeShas) {
+    let total = eventos.filter((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.worktreeSincronizada).length;
+    for (const sha of new Set(mergeShas)) {
+        if (!/^[0-9a-f]{40}$/.test(sha))
+            continue;
+        const r = (0, util_1.exec)('git', ['rev-list', '--merges', '--parents', `--max-count=${TETO_DE_MERGES_POR_ENTREGA}`,
+            `${sha}^1..${sha}^2`], raiz, 30000);
+        if (!r.ok)
+            continue;
+        for (const linha of r.stdout.split('\n')) {
+            const pais = linha.trim().split(/\s+/).slice(1);
+            // O pai trazido (o segundo em diante) ja estava na base: e a base entrando na branch.
+            if (pais.slice(1).some((p) => /^[0-9a-f]{40}$/.test(p) &&
+                (0, util_1.exec)('git', ['merge-base', '--is-ancestor', p, `${sha}^1`], raiz, 30000).ok))
+                total += 1;
+        }
+    }
+    return total;
+}
 /** Ordem canonica das classes na saida do CLI. */
 exports.ORDEM_DAS_CLASSES = [
     'sem-falha',
@@ -138,6 +201,19 @@ function caminhoPostmortem(raiz, id) {
 function caminhoMasterLog(raiz, id) {
     return path.join((0, thread_1.dirThread)(raiz, id), 'master-log.json');
 }
+/**
+ * RM-008 (fases pelo tipo): a fase dos eventos que o nucleo grava sem o campo `fase`. O `verify_run`
+ * e o `ship_done` nunca trouxeram fase, e 34 dos 35 POSTMORTEM de 03/10 sairam sem o CHECK, e 33 sem o
+ * SHIP, embora o ledger os tivesse (`ork-rm037testesi`: 6 `verify_run`, 1 `ship_done`, "GOAL GO MASTER").
+ * So vale quando o evento nao traz `fase`: o campo explicito continua vencendo.
+ */
+exports.FASE_DO_TIPO = {
+    [ledger_1.TIPOS_DE_EVENTO.verificacao]: 'CHECK',
+    [ledger_1.TIPOS_DE_EVENTO.reverifyConcluido]: 'CHECK',
+    [ledger_1.TIPOS_DE_EVENTO.shipIniciado]: 'SHIP',
+    [ledger_1.TIPOS_DE_EVENTO.shipConcluido]: 'SHIP',
+    [ledger_1.TIPOS_DE_EVENTO.shipBloqueado]: 'SHIP',
+};
 /**
  * As fases que a thread realmente percorreu, reconstruidas do LEDGER.
  *
@@ -148,7 +224,7 @@ function fasesPercorridas(raiz, id) {
     const eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, id));
     const porFase = new Map();
     for (const e of eventos) {
-        const bruta = typeof e.fase === 'string' ? e.fase.toUpperCase() : null;
+        const bruta = typeof e.fase === 'string' ? e.fase.toUpperCase() : (exports.FASE_DO_TIPO[e.tipo] ?? null);
         if (!bruta || !types_1.FASES.includes(bruta))
             continue;
         const atual = porFase.get(bruta) ?? {
@@ -244,7 +320,8 @@ function prepararDocumentos(raiz, id, opcoes) {
     sincronizarReversao(raiz, id);
     const eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, id));
     const gatesBloqueados = eventos
-        .filter((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.gateBloqueado)
+        // Ensaio de 03/10/2026 (RM-049): o gate barrado por um `ork ship --dry-run` e ensaio, nao reprovacao.
+        .filter((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.gateBloqueado && e.dryRun !== true)
         .map((e) => ({
         ts: e.ts,
         motivo: String(e.motivo ?? '(sem motivo)'),
@@ -264,11 +341,20 @@ function prepararDocumentos(raiz, id, opcoes) {
     let classes = opcoes.classes ?? [];
     if (classes.length === 0) {
         classesInferidas = true;
-        classes = gatesBloqueados.length > 0 ? ['outra'] : ['sem-falha'];
-        avisos.push(gatesBloqueados.length > 0
-            ? `a thread levou ${gatesBloqueados.length} reprovacao(oes) tipada(s) e nenhuma --classe foi ` +
-                'informada: o `ork` gravou "outra". Corrija com --classe <classe> --refazer.'
-            : 'nenhuma --classe informada e nenhum gate reprovou: o `ork` gravou "sem-falha".');
+        classes = classesPelosGates(gatesBloqueados.map((g) => g.motivo));
+        const motivos = [...new Set(gatesBloqueados.map((g) => g.motivo))];
+        const sincronizacoes = sincronizacoesComABase(raiz, eventos, entregas.map((e) => e.mergeSha));
+        if (sincronizacoes > 0) {
+            classes = exports.ORDEM_DAS_CLASSES.filter((c) => c === 'base-avancou' || (c !== 'sem-falha' && classes.includes(c)));
+        }
+        const pelaBase = sincronizacoes > 0
+            ? ` A branch trouxe a base ${sincronizacoes} vez(es) antes da entrega: o \`ork\` juntou "base-avancou".` : '';
+        avisos.push((gatesBloqueados.length > 0
+            ? `a thread levou ${gatesBloqueados.length} reprovacao(oes) tipada(s) (${motivos.join(', ')}) e nenhuma --classe foi ` +
+                `informada: o \`ork\` inferiu "${classes.join('", "')}" pelo motivo do gate.${pelaBase} Corrija com --classe <classe> --refazer.`
+            : sincronizacoes > 0
+                ? `nenhuma --classe informada e nenhum gate reprovou.${pelaBase} Corrija com --classe <classe> --refazer.`
+                : 'nenhuma --classe informada e nenhum gate reprovou: o `ork` gravou "sem-falha".'));
     }
     // I-43 (D3): o indice e DERIVADO do ledger no momento do registro, e acompanha o
     // score como o que a maquina achava antes de o dono falar. Quando as duas existem,
@@ -351,7 +437,7 @@ function autoriaHumana(por) {
 }
 function exigirAutoriaHumana(por) {
     if (!autoriaHumana(por))
-        throw new Error('ratificação exige --por humano explícito; agente ou autoria pendente não pode pontuar');
+        throw new Error('ratificação exige --por humano explícito (ex.: --por "seu-nome"); agente ou autoria pendente não pode pontuar');
 }
 function masterRatificado(raiz, id) {
     const t = (0, thread_1.lerThread)(raiz, id);
@@ -692,7 +778,8 @@ function tabelaDeEntregas(raiz, todas = false) {
         (0, util_1.tabela)(['ID', 'SLUG', 'MODO', 'FASE', 'STATUS', 'ENTREGOU', 'INDICE', 'DE ONDE VEIO'], linhas),
         '',
         'ENTREGUE E ACEITO, a menos que voce diga o contrario.',
-        '  ork master --aceitar-omissao          aceita as entregues, com o indice e os insumos no ledger',
+        '  ork master <id> --aceitar-omissao     aceita so esta entrega, com o indice e os insumos no ledger',
+        '  ork master --aceitar-omissao          aceita TODAS as entregues da lista (--dry-run mostra quais, sem gravar)',
         '  ork master <id> --score <0-5> --justificativa "<por que>" --por <humano>   se quiser reclamar',
         '',
         `Classes fixas: ${exports.ORDEM_DAS_CLASSES.join(', ')}`,
@@ -706,10 +793,40 @@ function tabelaDeEntregas(raiz, todas = false) {
  * ENTREGOU: uma thread que nunca chegou ao ship nao tem entrega para aceitar, e
  * aceita-la seria inventar um fato.
  */
-function aceitarPendentesPorOmissao(raiz) {
+function aceitarPendentesPorOmissao(raiz, opcoes = {}) {
+    return entregasParaOmissao(raiz, opcoes.thread).map((p) => aceitarPorOmissao(raiz, p.thread.id));
+}
+/**
+ * RM-008 (03/10/2026): o que `ork master --aceitar-omissao` fecharia, sem gravar nada.
+ *
+ * Na madrugada de 03/10, tres vezes, um condutor rodou `ork master --aceitar-omissao` para fechar
+ * a PROPRIA thread, e o comando fechou tambem as entregues de outras frentes paralelas. A CLI nao
+ * deixava indicar a thread. Com `thread`, o alvo e so ela; sem, continua sendo toda entrega que
+ * espera decisao (o padrao nao mudou). Thread inexistente recusa pelo `lerThread`.
+ */
+function entregasParaOmissao(raiz, thread) {
+    if (thread !== undefined)
+        (0, thread_1.lerThread)(raiz, thread);
     return pendentesDeScore(raiz)
         .filter((p) => p.entregou)
-        .map((p) => aceitarPorOmissao(raiz, p.thread.id));
+        .filter((p) => thread === undefined || p.thread.id === thread);
+}
+/**
+ * Por que a thread indicada nao entra no aceite por omissao, ou `null` quando entra.
+ * `ja-fechada` e idempotencia (nada a fazer); `fechamento-admin` e `sem-entrega` sao recusa.
+ */
+function motivoForaDaOmissao(raiz, id) {
+    const thread = (0, thread_1.lerThread)(raiz, id);
+    if (thread.fechamentoAdmin) {
+        return { motivo: 'fechamento-admin', texto: `a thread ${id} foi fechada administrativamente (${thread.fechamentoAdmin.motivo}); nao ha entrega para aceitar.` };
+    }
+    if (masterRatificado(raiz, id)) {
+        return { motivo: 'ja-fechada', texto: `a thread ${id} ja tem MASTER registrado; nada a aceitar.` };
+    }
+    if (!entregou(raiz, id)) {
+        return { motivo: 'sem-entrega', texto: `a thread ${id} ainda nao entregou (sem ship_done no ledger); registre a entrega antes: ork ship registrar-pr ${id}` };
+    }
+    return null;
 }
 /** Texto de `ork master <thread-id> --score`. */
 function textoDoMaster(r) {

package/dist/mcp-artifacts.js

@@ -150,13 +150,46 @@ function comEscrita(raiz, id, executar) {
         if (st) {
             if (!st.isDirectory() || st.isSymbolicLink() || fs.realpathSync(pastaLeases) !== pastaLeases)
                 throw Error('mcp.state.unsafe: leases');
-            for (const nome of fs.readdirSync(pastaLeases)) {
-                const s = fs.lstatSync(path.join(pastaLeases, nome));
+            for (const nomeBytes of fs.readdirSync(pastaLeases, { encoding: 'buffer' })) {
+                const nome = nomeBytes.toString('utf8');
+                // Antes do lstat: uma decodificacao com perda nao prova que a entrada desapareceu.
+                if (!Buffer.from(nome, 'utf8').equals(nomeBytes))
+                    throw Error('mcp.state.unsafe: nome fora de UTF-8 em leases');
+                const entrada = path.join(pastaLeases, nome), s = fs.lstatSync(entrada, { throwIfNoEntry: false });
+                if (!s)
+                    continue; // Uma retomada pode ter acabado durante o preflight.
+                if (s.isDirectory() && nome.endsWith('.json.retomadas')) {
+                    const base = nome.slice(0, -'.json.retomadas'.length);
+                    if (!base || encodeURIComponent(decodeURIComponent(base)) !== base)
+                        throw Error('mcp.state.unsafe: fila de retomada');
+                    let candidatos;
+                    try {
+                        candidatos = fs.readdirSync(entrada, { encoding: 'buffer' });
+                    }
+                    catch (e) {
+                        if (e.code === 'ENOENT')
+                            continue;
+                        throw e;
+                    }
+                    for (const candidatoBytes of candidatos) {
+                        const candidato = candidatoBytes.toString('utf8');
+                        if (!Buffer.from(candidato, 'utf8').equals(candidatoBytes))
+                            throw Error('mcp.state.unsafe: nome fora de UTF-8 na fila');
+                        const c = fs.lstatSync(path.join(entrada, candidato), { throwIfNoEntry: false });
+                        if (!c)
+                            continue;
+                        if (!/^\d+-[a-f0-9-]+\.json(?:\.tmp)?$/.test(candidato) || !c.isFile() || c.nlink !== 1)
+                            throw Error('mcp.state.unsafe: candidato de retomada');
+                    }
+                    continue;
+                }
                 if (!s.isFile() || s.isSymbolicLink() || s.nlink !== 1)
                     throw Error('mcp.state.unsafe: lease ou fila');
             }
         }
         const nome = `path:.orkastery/threads/${id}`;
+        // RM-037 (fatia 3, defeito 4): lease e fila de thread fechada sao orfaos e saem antes da conferencia.
+        (0, leases_1.podarRegioesDeThreadsFechadas)(raiz, [nome], id);
         if ((0, leases_1.lerLease)(raiz, nome) || (0, leases_1.leasesColidentes)(raiz, nome).length)
             throw Error('lease.busy: estado canonico ocupado');
         const r = (0, leases_1.adquirirRegiao)(raiz, nome, { thread: id, motivo: 'MCP documento ou claim', ttlMs: 30000, retomarVencido: false });
@@ -229,6 +262,6 @@ function adicionarClaimMcp(raiz, id, entrada) {
         if ((0, thread_1.lerThread)(raiz, id).status === 'fechada')
             throw Error('mcp.claim.closed');
         // Strings sao dados da claim; a reexecucao MCP deve usar o executor confinado.
-        return (0, claims_1.adicionarClaim)(raiz, id, entrada);
+        return (0, claims_1.adicionarClaim)(raiz, id, { ...entrada, semProvaLocal: true });
     }));
 }