@orkastery/cli 0.5.1 → 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

@@ -141,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',

package/dist/licoes.js

@@ -66,6 +66,7 @@ exports.DICA_DO_MOTIVO = {
     '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>`)',
     // 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`)',

package/dist/maestro-runtime.js

@@ -75,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) {

package/dist/manifest.js

@@ -356,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)
@@ -456,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)`);
@@ -491,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, ''),
@@ -522,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,
@@ -540,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

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,8 +150,39 @@ 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');
             }
@@ -231,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 });
     }));
 }

package/dist/mcp-git.js

@@ -195,7 +195,9 @@ function arvoreMetadados(root, alvo, opcoes = {}) {
                 ? '; empacote os objetos soltos sem perda com git repack -d (git count-objects -v mostra quantos)' : ''));
         if (profundidade > 32)
             falha(`metadata.unsupported: mais de 32 niveis em ${rotulo(alvo)}`);
-        const st = fs.lstatSync(f);
+        const st = fs.lstatSync(f, { throwIfNoEntry: false });
+        if (!st)
+            return; // Uma retomada pode remover a fila ou o candidato depois da enumeracao.
         if (st.isSymbolicLink())
             falha(`metadata.unsafe: link simbolico em ${rotulo(f)}`);
         if (!st.isDirectory() && !st.isFile())
@@ -205,9 +207,24 @@ function arvoreMetadados(root, alvo, opcoes = {}) {
                 `tire o vinculo sem perder conteudo: cp -p ${rotulo(f)} ${rotulo(f + '.tmp')} && mv ${rotulo(f + '.tmp')} ${rotulo(f)}`);
         if (f !== root && !dentro(root, f))
             falha(`metadata.unsafe: ${rotulo(f)} fora de ${path.basename(root)}`);
-        if (st.isDirectory())
-            for (const n of fs.readdirSync(f))
+        if (st.isDirectory()) {
+            let entradas;
+            try {
+                entradas = fs.readdirSync(f, { encoding: 'buffer' });
+            }
+            catch (e) {
+                if (e.code === 'ENOENT')
+                    return;
+                throw e;
+            }
+            for (const bytes of entradas) {
+                const n = bytes.toString('utf8');
+                // Perda de bytes nao e ENOENT transitorio: o nome decodificado pode nem apontar para esta entrada.
+                if (!Buffer.from(n, 'utf8').equals(bytes))
+                    falha(`metadata.unsafe: nome fora de UTF-8 em ${rotulo(f)}`);
                 visitar(path.join(f, n), profundidade + 1);
+            }
+        }
     };
     if (fs.realpathSync(alvo) !== alvo)
         falha(`metadata.unsafe: ${rotulo(alvo)} passa por link simbolico`);

package/dist/mcp-grafo-worker.js

@@ -38,7 +38,7 @@ exports.rodarConsulta = rodarConsulta;
  * RM-031 KG5 (D3, D8): o worker da consulta do grafo pelo MCP.
  *
  * Roda num processo filho, aberto pelo `mcp-grafo.ts` com o ambiente minimo do MCP. Le `{raiz, argv}`
- * do stdin, confere que o cwd e a raiz, aceita so as quatro consultas no argv que as tools montam (com
+ * do stdin, confere que o cwd e a raiz, aceita so as cinco consultas no argv que as tools montam (com
  * `--json` e `--teto-bytes`), carrega o manifesto da raiz (a worktree da thread) e chama o
  * `executarGrafo` com o argv que a CLI receberia: a resposta e a do `ork grafo`, byte a byte. O `main` do
  * `ork` nao roda aqui, entao nada do argv vira `--projeto`, `--version` ou `--help`.
@@ -52,7 +52,8 @@ const zod_1 = require("zod");
 const intelligence_graph_cli_1 = require("./intelligence-graph-cli");
 const manifest_1 = require("./manifest");
 const estado_thread_1 = require("./estado-thread");
-const CONSULTAS = Object.freeze({ vizinhos: 1, chamadores: 1, importadores: 1, caminho: 2 });
+const mcp_grafo_1 = require("./mcp-grafo");
+const CONSULTAS = Object.freeze({ vizinhos: 1, chamadores: 1, importadores: 1, caminho: 2, contexto: 1 });
 const OPCAO = /^--(profundidade|sentido|tipo|limite|teto-bytes)=[a-z0-9_,]{1,120}$/;
 const PEDIDO = zod_1.z.object({
     raiz: zod_1.z.string().min(1).max(4096).refine((p) => path.isAbsolute(p), 'raiz absoluta'),
@@ -78,7 +79,8 @@ function rodarConsulta(entrada, cwd, escrever) {
     const carregado = (0, manifest_1.exigirManifesto)(raiz);
     if (fs.realpathSync(carregado.raiz) !== fs.realpathSync(raiz))
         throw Error('grafo.mcp.worker: o manifesto nao e o da raiz pedida');
-    return (0, intelligence_graph_cli_1.executarGrafo)(argv, { raiz: carregado.raiz, estado: (0, estado_thread_1.raizDoEstado)(carregado.raiz), repositorio: carregado.manifesto.project.name, escrever });
+    return (0, intelligence_graph_cli_1.executarGrafo)(argv, { raiz: carregado.raiz, estado: (0, estado_thread_1.raizDoEstado)(carregado.raiz), repositorio: carregado.manifesto.project.name,
+        contextoDaThread: (id) => (0, mcp_grafo_1.lerEntradaDaThread)(carregado.raiz, id), escrever });
 }
 if (require.main === module) {
     try {

package/dist/mcp-grafo.js

@@ -35,16 +35,17 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LIMITE_MAXIMO_DO_MCP = exports.PROFUNDIDADE_MAXIMA_DO_MCP = exports.TIPOS_DE_ARESTA_DO_MCP = exports.PRAZO_DA_CONSULTA_MS = exports.TETO_MAXIMO = exports.TETO_MINIMO = exports.TETO_PADRAO = exports.TOOLS_DO_GRAFO = void 0;
 exports.grafoLigado = grafoLigado;
+exports.lerEntradaDaThread = lerEntradaDaThread;
 exports.argvDaTool = argvDaTool;
 exports.consultarPeloWorker = consultarPeloWorker;
 exports.registrarConsultasDoGrafo = registrarConsultasDoGrafo;
 /**
  * RM-031 KG5: a consulta do grafo de codigo pelas fases, pelo MCP do projeto.
  *
- * Quatro tools de leitura com o contrato do `ork grafo` (D6): cada uma roda, na worktree da thread, o
+ * Cinco tools de leitura com o contrato do `ork grafo` (D6): cada uma roda, na worktree da thread, o
  * argv que a CLI receberia (`<consulta> ... --json --teto-bytes N`) e devolve o que ela escreve, sem
  * transformar: a resposta e JSON `ork.code-graph-query/v0` com a evidencia de cada aresta e no maximo
- * `tetoBytes` bytes (D4); a recusa da consulta sai compacta e nao passa pelo teto.
+ * `tetoBytes` bytes (D4); contexto usa ork.thread-graph-context/v2. A recusa nao passa pelo teto.
  *
  * Desligadas por padrao (D2): so existem com `grafo.mcp: true` no manifesto da raiz, lido no startup, e
  * cada chamada confere a flag de novo. A consulta roda num worker (D3), um processo filho por chamada,
@@ -58,7 +59,10 @@ const path = __importStar(require("node:path"));
 const node_child_process_1 = require("node:child_process");
 const zod_1 = require("zod");
 const mcp_git_1 = require("./mcp-git");
-exports.TOOLS_DO_GRAFO = ['ork_grafo_vizinhos', 'ork_grafo_chamadores', 'ork_grafo_importadores', 'ork_grafo_caminho'];
+const mcp_artifacts_1 = require("./mcp-artifacts");
+const thread_1 = require("./thread");
+const estado_thread_1 = require("./estado-thread");
+exports.TOOLS_DO_GRAFO = ['ork_grafo_vizinhos', 'ork_grafo_chamadores', 'ork_grafo_importadores', 'ork_grafo_caminho', 'ork_grafo_contexto'];
 /** D4: o teto das respostas, em bytes do JSON. */
 exports.TETO_PADRAO = 32768;
 exports.TETO_MINIMO = 4096;
@@ -134,7 +138,49 @@ const DEFINICOES = [
         schema: zod_1.z.object({ threadId, de: no(`origem: ${DESCRICAO_DO_NO}`), para: no('destino, na mesma forma'), sentido, tipos, tetoBytes }).strict(),
         argv: (a) => ['caminho', a.de, a.para, ...opcoes(a)],
     },
+    {
+        nome: 'ork_grafo_contexto',
+        descricao: 'Pacote deterministico da thread: diff da worktree contra base (ignorado sem worktree), GOAL, PLAN e claims; fan-in agregado e evidencias compactas. '
+            + 'JSON ork.thread-graph-context/v2 limitado em bytes, refs locais, prioridade entre arquivos e por proximidade ao diff. Sem indice do HEAD, recusa com ork grafo indexar.',
+        schema: zod_1.z.object({ threadId, tetoBytes }).strict(),
+        argv: (a) => ['contexto', a.threadId, ...opcoes(a)],
+    },
 ];
+/** Leitura compartilhada por CLI e worker, fora da familia do grafo. Nunca escreve estado. */
+function lerEntradaDaThread(raiz, id) {
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/.test(id))
+        throw Error('grafo.contexto.thread-invalida: id invalido');
+    const projeto = fs.realpathSync((0, estado_thread_1.raizDoEstado)(raiz));
+    (0, mcp_artifacts_1.validarArquivosEstadoMcp)(projeto, id);
+    const t = (0, thread_1.lerThread)(projeto, id);
+    const cwd = fs.realpathSync(t.worktree ?? projeto);
+    if (cwd !== projeto && !cwd.startsWith(projeto + path.sep))
+        throw Error('grafo.contexto.escopo: worktree fora do projeto');
+    if (fs.realpathSync((0, estado_thread_1.raizDoEstado)(cwd)) !== projeto)
+        throw Error('grafo.contexto.escopo: worktree de outro repositorio');
+    // Em uma WT, consultar outra thread daria um pacote de outra arvore silenciosamente.
+    const origem = fs.realpathSync(raiz);
+    if (origem !== projeto && origem !== cwd)
+        throw Error('grafo.contexto.escopo: thread de outra worktree');
+    if (!/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(t.base.commit))
+        throw Error('grafo.contexto.base-invalida: thread sem commit base');
+    const git = (args) => {
+        const r = (0, node_child_process_1.spawnSync)('git', ['-c', 'core.fsmonitor=false', ...args], {
+            cwd, env: { ...(0, mcp_git_1.ambienteGitMcp)(), GIT_OPTIONAL_LOCKS: '0' }, encoding: 'utf8', timeout: 10000, maxBuffer: 8 * 1024 * 1024,
+        });
+        if (r.error || r.status !== 0)
+            throw Error('grafo.contexto.git-falhou: nao foi possivel ler HEAD/base/diff da thread');
+        return r.stdout;
+    };
+    const head = git(['rev-parse', '--verify', 'HEAD']).trim();
+    const diff = !t.worktree || cwd === projeto ? [] : git(['diff', '--no-ext-diff', '--no-textconv', '--no-renames', '--name-only', '-z', t.base.commit, '--']).split('\0').filter(Boolean);
+    const goal = (0, mcp_artifacts_1.lerArtefatoMcp)(projeto, id, 'goal').conteudo;
+    const plan = (0, mcp_artifacts_1.lerArtefatoMcp)(projeto, id, 'plan').conteudo;
+    const claims = (0, mcp_artifacts_1.listarClaimsMcp)(projeto, id).filter((c) => c.estado !== 'retirada').map(({ id, arquivo }) => ({ id, arquivo }));
+    if (head !== git(['rev-parse', '--verify', 'HEAD']).trim())
+        throw Error('grafo.contexto.revisao-mudou: HEAD mudou durante a leitura; repita');
+    return { raiz: cwd, head, entrada: { thread: id, base: t.base.commit, diff, diffEstado: !t.worktree || cwd === projeto ? 'ignorado-sem-worktree' : 'coletado-na-worktree', goal, plan, claims } };
+}
 /** D9: o argv que a tool monta para os argumentos dados; a medida offline usa o mesmo. */
 function argvDaTool(nome, args) {
     const d = DEFINICOES.find((x) => x.nome === nome);
@@ -204,7 +250,7 @@ function consultarPeloWorker(raiz, argv, opcoesDoWorker = {}) {
 }
 const texto = (t, isError = false) => ({ content: [{ type: 'text', text: t }], ...(isError ? { isError: true } : {}) });
 /**
- * As quatro tools, chamadas pelo servidor so com a flag ligada no startup. `carregar` e `thread` sao os
+ * As cinco tools, chamadas pelo servidor so com a flag ligada no startup. `carregar` e `thread` sao os
  * do servidor: o projeto fixado e a thread conferida (escopo da sessao filha e worktree confinada).
  */
 function registrarConsultasDoGrafo(registrar, contexto) {