@orkastery/cli 0.2.0 → 0.4.1

package/dist/master.js

@@ -11,9 +11,9 @@
  *     contrato e nao mudam. "Uma entrega sem MASTER log nao aconteceu."
  *
  * O score e humano, de 0 a 5, com JUSTIFICATIVA OBRIGATORIA: o `ork` recusa score sem
- * justificativa, em qualquer modo. Nos modos que nao pausam no MASTER (`#Ork`,
+ * justificativa, em qualquer modo. Nos modos que nao pausam no MASTER (`#Classic`,
  * `#Maestro`, `#Auto`) o score nao desaparece: a thread cai na fila de batch scoring,
- * que `ork master --batch` lista para o humano pontuar em bloco.
+ * que `ork master` lista com o indice ja derivado do ledger (I-43: a fila saiu).
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -49,28 +49,45 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-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.ORDEM_DAS_CLASSES = exports.CLASSES_DE_FALHA = exports.VERSAO_MASTER_LOG = exports.CONTRATO_MASTER_LOG = void 0;
 exports.parseClasse = parseClasse;
 exports.caminhoPostmortem = caminhoPostmortem;
 exports.caminhoMasterLog = caminhoMasterLog;
 exports.fasesPercorridas = fasesPercorridas;
 exports.regimeDoScore = regimeDoScore;
 exports.entregou = entregou;
+exports.indiceDaThread = indiceDaThread;
 exports.exigirScoreValido = exigirScoreValido;
+exports.autoriaHumana = autoriaHumana;
+exports.exigirAutoriaHumana = exigirAutoriaHumana;
+exports.masterRatificado = masterRatificado;
+exports.preflightMaster = preflightMaster;
 exports.registrarMaster = registrarMaster;
+exports.proporMaster = proporMaster;
 exports.validarMasterLog = validarMasterLog;
+exports.validarMasterPendente = validarMasterPendente;
 exports.lerMasterLog = lerMasterLog;
+exports.aceitarPorOmissao = aceitarPorOmissao;
+exports.aceitosPorOmissao = aceitosPorOmissao;
 exports.pendentesDeScore = pendentesDeScore;
-exports.tabelaDeBatch = tabelaDeBatch;
+exports.tabelaDeEntregas = tabelaDeEntregas;
+exports.aceitarPendentesPorOmissao = aceitarPendentesPorOmissao;
 exports.textoDoMaster = textoDoMaster;
 exports.tabelaDeClasses = tabelaDeClasses;
 const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const thread_close_1 = require("./thread-close");
+const estado_thread_1 = require("./estado-thread");
 const ledger_1 = require("./ledger");
 const modos_1 = require("./modos");
 const thread_1 = require("./thread");
 const types_1 = require("./types");
 const util_1 = require("./util");
 const fs = __importStar(require("node:fs"));
+const horario_1 = require("./horario");
+const indice_1 = require("./indice");
+const ship_1 = require("./ship");
+const fabrica_publicar_1 = require("./fabrica-publicar");
 /** Identificador do contrato congelado do MASTER log. */
 exports.CONTRATO_MASTER_LOG = 'ork.master-log/v1';
 /** Versao do contrato. Uma mudanca de contrato exige uma versao nova, nao um campo novo. */
@@ -151,11 +168,48 @@ function fasesPercorridas(raiz, id) {
 }
 /** Regime do score: `pausa` nos modos que param no MASTER, `batch` nos demais. */
 function regimeDoScore(thread) {
+    // Ciclo sem MASTER (o `#Fast`, I-42) nao pausa no MASTER: o score, quando vier, e de lote.
+    // Sem esta guarda, uma thread #Fast entregue derrubava `ork master`, o aceite por omissao
+    // e o pulse, que listam as pendentes de score (27/09/2026).
+    if (!thread.blocos?.some((b) => b.fases.includes('MASTER')))
+        return 'batch';
     return (0, thread_1.pausaNaThread)(thread, 'MASTER') ? 'pausa' : 'batch';
 }
 /** A thread ja entregou (o ledger tem `ship_done`)? */
 function entregou(raiz, id) {
-    return (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, id)).some((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.shipConcluido);
+    return (0, thread_close_1.provaDeEntrega)(raiz, id) !== null;
+}
+/**
+ * Pergunta ao git se a entrega desta thread foi desfeita, e grava se foi. Nunca lanca.
+ *
+ * Idempotente por `revertSha` (`registrarReversaoDaEntrega`), entao pode rodar em toda
+ * consulta: a mesma reversao nao rebaixa a thread duas vezes. Git indisponivel nao
+ * derruba o MASTER; no pior caso o indice continua sendo o que o ledger ja sabia.
+ */
+function sincronizarReversao(raiz, id) {
+    try {
+        (0, ship_1.registrarReversaoDaEntrega)(raiz, (0, thread_1.lerThread)(raiz, id));
+    }
+    catch { /* git indisponivel nao barra o MASTER */ }
+}
+/**
+ * O indice da thread, DEPOIS de perguntar ao git se a entrega ainda esta de pe.
+ *
+ * ESTE E O PONTO UNICO por onde o MASTER calcula indice, e ele existe por causa do que
+ * o CHECK de 20/09/2026 provou com `git revert` real: o unico escritor de
+ * `rollback_done` rodava no COMECO de um `ork ship` SEGUINTE da mesma thread, e depois
+ * do MASTER nao ha ship seguinte. Uma entrega desfeita na base saia daqui como 5 de 5
+ * "sem tropeco", e `ork master --aceitar-omissao` gravava score 5 com a justificativa
+ * "sem reversao" sobre ela. Em 20 das 27 threads entregues do projeto a janela do ship
+ * seguinte nunca chegou a abrir.
+ *
+ * A regra que ficou: quem AFIRMA o numero e quem tem de conferir o fato. Por isso a
+ * deteccao roda no momento em que o indice e calculado e no momento em que a omissao e
+ * aceita, e nao so num ship futuro que quase nunca acontece.
+ */
+function indiceDaThread(raiz, id) {
+    sincronizarReversao(raiz, id);
+    return (0, indice_1.calcularIndice)((0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, id)));
 }
 /**
  * Valida o score humano ANTES de gravar qualquer coisa.
@@ -176,13 +230,17 @@ function exigirScoreValido(score, justificativa) {
  * Registra o MASTER da thread: POSTMORTEM tipado, MASTER log no contrato e o score.
  * Ao fim, a thread fecha (`status: fechada`) e o ledger ganha `master_done`.
  */
-function registrarMaster(raiz, id, opcoes) {
+function prepararDocumentos(raiz, id, opcoes) {
     const thread = (0, thread_1.lerThread)(raiz, id);
     exigirScoreValido(opcoes.score, opcoes.justificativa);
     if (thread.score && !opcoes.refazer) {
         throw new Error(`a thread ${id} ja tem score ${thread.score.valor}/5 dado por ${thread.score.avaliadoPor} ` +
-            `em ${thread.score.avaliadoEm}; use --refazer para regravar o MASTER`);
+            `em ${(0, horario_1.formatarDataHoraRotulada)(thread.score.avaliadoEm)}; use --refazer para regravar o MASTER`);
     }
+    (0, thread_close_1.exigirEntrega)(raiz, id);
+    // A1: o indice gravado ao lado do score sai do ledger, e o ledger so sabe da reversao
+    // se alguem perguntar ao git. Aqui e o momento em que o numero e congelado.
+    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)
@@ -211,12 +269,17 @@ function registrarMaster(raiz, id, opcoes) {
                 'informada: o `ork` gravou "outra". 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,
+    // a nota humana e a que vale; o indice fica ao lado dela, nao no lugar.
+    const indice = (0, indice_1.calcularIndice)(eventos);
     const score = {
         valor: opcoes.score,
         justificativa: opcoes.justificativa.trim(),
-        avaliadoPor: (opcoes.por ?? 'humano').trim() || 'humano',
+        avaliadoPor: opcoes.por?.trim() ?? '',
         avaliadoEm: (0, util_1.agora)(),
-        regime: regimeDoScore(thread),
+        regime: opcoes.regime ?? regimeDoScore(thread),
+        indice: indice.valor,
     };
     const percorridas = fasesPercorridas(raiz, id);
     const resumo = opcoes.resumo?.trim() ||
@@ -257,6 +320,12 @@ function registrarMaster(raiz, id, opcoes) {
         avaliadoEm: score.avaliadoEm,
         classesDeFalha: classes,
         resumo,
+        regime: score.regime,
+        indice: {
+            valor: indice.valor,
+            base: indice.base,
+            parcelas: indice.parcelas.map((p) => ({ evento: p.evento, ocorrencias: p.ocorrencias, desconto: p.desconto })),
+        },
         base: thread.base,
         worktree: thread.worktree,
         evidencia: {
@@ -267,72 +336,140 @@ function registrarMaster(raiz, id, opcoes) {
             claims: thread.claims.length,
         },
     };
-    const invalido = validarMasterLog(masterLog);
-    if (invalido.length > 0) {
-        throw new Error(`MASTER log fora do contrato congelado:\n  - ${invalido.join('\n  - ')}`);
-    }
-    const caminhoP = caminhoPostmortem(raiz, id);
-    const caminhoM = caminhoMasterLog(raiz, id);
-    (0, util_1.gravarJson)(caminhoP, postmortem);
-    (0, util_1.gravarJson)(caminhoM, masterLog);
-    thread.score = score;
-    thread.faseAtual = 'MASTER';
+    if (classes.some(c => !exports.ORDEM_DAS_CLASSES.includes(c)))
+        throw new Error('classe fora do catálogo fixo');
+    return { thread, postmortem, masterLog, caminhoPostmortem: caminhoPostmortem(raiz, id),
+        caminhoMasterLog: caminhoMasterLog(raiz, id), classesInferidas, avisos };
+}
+/** Identidade declarada explicitamente. Não é autenticação de host. */
+function autoriaHumana(por) {
+    const genericos = ['humano', 'humana', 'operador', 'usuario', 'user', 'anonimo', 'ninguem', 'host', 'admin', 'root', 'equipe', 'time'];
+    return typeof por === 'string' && por.trim().length >= 2 && !por.trim().startsWith('-') &&
+        !genericos.includes(semAcento(por.trim().toLowerCase())) &&
+        !/(?:^|[^a-z0-9])(codex|claude|gpt(?:[0-9-]*)?|openai|agente?|agent|runtime|auto|ia|llm|bot|pendente|pending|batch)(?:$|[^a-z0-9])/i.test(semAcento(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');
+}
+function masterRatificado(raiz, id) {
+    const t = (0, thread_1.lerThread)(raiz, id);
+    if (!t.score || !autoriaHumana(t.score.avaliadoPor) || t.fechamentoAdmin)
+        return false;
+    const e = [...(0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, id))].reverse().find(e => e.tipo === ledger_1.TIPOS_DE_EVENTO.masterConcluido);
+    return !!e && e.por === t.score.avaliadoPor && e.score === t.score.valor && e.justificativa === t.score.justificativa;
+}
+/** Preflight reutilizado pelo lote, sem escrita. */
+function preflightMaster(raiz, id, opcoes) {
+    // Mantém erros de valor e duplicação anteriores ao erro de autoria.
+    const r = prepararDocumentos(raiz, id, opcoes);
+    exigirAutoriaHumana(opcoes.por);
+    const erros = validarMasterLog(r.masterLog);
+    if (erros.length)
+        throw new Error(erros.join('; '));
+    return r;
+}
+function registrarMaster(raiz, id, opcoes) {
+    const r = preflightMaster(raiz, id, opcoes);
+    const { thread, postmortem, masterLog } = r;
+    (0, util_1.gravarJson)(r.caminhoPostmortem, postmortem);
+    (0, util_1.gravarJson)(r.caminhoMasterLog, masterLog);
+    thread.score = postmortem.score;
+    thread.score_proposto = null;
+    // I-42: ciclo sem MASTER (o `#Fast`) fecha sem trocar de fase; `faseAtual` fica dentro do ciclo.
+    if (!thread.fases?.length || thread.fases.includes('MASTER'))
+        thread.faseAtual = 'MASTER';
     thread.status = 'fechada';
     (0, thread_1.gravarThread)(raiz, thread);
+    (0, fabrica_publicar_1.publicarEmSegundoPlano)(raiz);
     (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, id), id, ledger_1.TIPOS_DE_EVENTO.postmortemGravado, {
-        fase: 'MASTER',
-        classesDeFalha: classes,
-        classesInferidas,
-        gatesBloqueados: gatesBloqueados.length,
-        arquivo: path.relative(raiz, caminhoP),
+        fase: 'MASTER', classesDeFalha: postmortem.classesDeFalha, classesInferidas: r.classesInferidas,
+        gatesBloqueados: postmortem.gatesBloqueados.length, arquivo: path.relative((0, estado_thread_1.raizDoEstado)(raiz), r.caminhoPostmortem),
     });
     (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, id), id, ledger_1.TIPOS_DE_EVENTO.masterConcluido, {
-        fase: 'MASTER',
-        modo: thread.modo,
-        tag: (0, modos_1.tagDoModo)(thread.modo),
-        score: score.valor,
-        justificativa: score.justificativa,
-        autorizadoPor: score.avaliadoPor,
-        regime: score.regime,
-        contrato: exports.CONTRATO_MASTER_LOG,
-        arquivo: path.relative(raiz, caminhoM),
-        estado: 'thread fechada',
+        fase: 'MASTER', modo: thread.modo, tag: (0, modos_1.tagDoModo)(thread.modo), score: masterLog.score,
+        justificativa: masterLog.justificativa, por: masterLog.avaliadoPor, autorizadoPor: masterLog.avaliadoPor,
+        classesDeFalha: masterLog.classesDeFalha, regime: postmortem.score.regime,
+        contrato: exports.CONTRATO_MASTER_LOG, arquivo: path.relative((0, estado_thread_1.raizDoEstado)(raiz), r.caminhoMasterLog), estado: 'thread fechada',
+        masterLogSha256: hashDocumento(r.caminhoMasterLog), postmortemSha256: hashDocumento(r.caminhoPostmortem),
     });
-    return {
-        thread,
-        postmortem,
-        masterLog,
-        caminhoPostmortem: caminhoP,
-        caminhoMasterLog: caminhoM,
-        classesInferidas,
-        avisos,
-    };
+    return r;
+}
+exports.CONTRATO_MASTER_PENDENTE = 'ork.master-pending/v1';
+function proporMaster(raiz, id, opcoes) {
+    if (!opcoes.por?.trim())
+        throw new Error('proposta exige autoria explícita');
+    if ((0, thread_1.lerThread)(raiz, id).score)
+        throw new Error('thread já pontuada; proposta não sobrescreve score');
+    const r = prepararDocumentos(raiz, id, opcoes);
+    const proposta = { valor: opcoes.score, justificativa: opcoes.justificativa.trim(),
+        classes: r.postmortem.classesDeFalha, propostoPor: opcoes.por.trim(), propostoEm: (0, util_1.agora)(), resumo: r.postmortem.resumo };
+    // O contrato pendente não contém avaliadoPor nem avaliadoEm.
+    const { avaliadoPor: _por, avaliadoEm: _em, ...base } = r.masterLog;
+    const log = { ...base, contrato: exports.CONTRATO_MASTER_PENDENTE, score: null,
+        estado: 'ratificacao-pendente', score_proposto: proposta };
+    const post = { ...r.postmortem, score: null, score_proposto: proposta };
+    (0, util_1.gravarJson)(r.caminhoPostmortem, post);
+    (0, util_1.gravarJson)(r.caminhoMasterLog, log);
+    r.thread.score_proposto = proposta;
+    if (!r.thread.fases?.length || r.thread.fases.includes('MASTER'))
+        r.thread.faseAtual = 'MASTER';
+    r.thread.status = 'aberta';
+    (0, thread_1.gravarThread)(raiz, r.thread);
+    (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, id), id, ledger_1.TIPOS_DE_EVENTO.scoreProposto, { fase: 'MASTER', ...proposta, arquivo: path.relative((0, estado_thread_1.raizDoEstado)(raiz), r.caminhoMasterLog) });
+    return log;
 }
 /**
  * Valida um MASTER log contra o contrato congelado. Devolve a lista de erros (vazia = valido).
  * E o mesmo validador que a suite roda: o contrato e executavel, nao prosa.
  */
 function validarMasterLog(bruto) {
-    const erros = [];
+    const erros = validarBaseMaster(bruto);
     if (!bruto || typeof bruto !== 'object')
         return ['o MASTER log nao e um objeto'];
     const log = bruto;
     if (log.contrato !== exports.CONTRATO_MASTER_LOG) {
         erros.push(`campo "contrato" deve ser "${exports.CONTRATO_MASTER_LOG}"`);
     }
-    if (log.versao !== exports.VERSAO_MASTER_LOG)
-        erros.push(`campo "versao" deve ser ${exports.VERSAO_MASTER_LOG}`);
-    for (const campo of ['thread', 'slug', 'modo', 'tag', 'justificativa', 'resumo', 'avaliadoPor']) {
-        const v = log[campo];
-        if (typeof v !== 'string' || v.trim() === '')
-            erros.push(`campo "${campo}" ausente ou vazio`);
-    }
     if (typeof log.score !== 'number' || !Number.isInteger(log.score) || log.score < 0 || log.score > 5) {
         erros.push('campo "score" deve ser um inteiro de 0 a 5');
     }
     if (typeof log.avaliadoEm !== 'string' || Number.isNaN(Date.parse(log.avaliadoEm))) {
         erros.push('campo "avaliadoEm" deve ser um carimbo ISO valido');
     }
+    if (!autoriaHumana(log.avaliadoPor))
+        erros.push('avaliadoPor precisa de autoria humana explícita');
+    return erros;
+}
+/** Valida a proposta sem convertê-la em avaliação humana. */
+function validarMasterPendente(bruto) {
+    const erros = validarBaseMaster(bruto);
+    if (!bruto || typeof bruto !== 'object')
+        return erros;
+    const log = bruto;
+    if (log.contrato !== exports.CONTRATO_MASTER_PENDENTE || log.estado !== 'ratificacao-pendente' || log.score !== null ||
+        Object.hasOwn(log, 'avaliadoPor') || Object.hasOwn(log, 'avaliadoEm'))
+        erros.push('MASTER pendente exige ratificação sem score humano');
+    const p = log.score_proposto;
+    if (!p || !Number.isInteger(p.valor) || p.valor < 0 || p.valor > 5 ||
+        typeof p.propostoPor !== 'string' || !p.propostoPor.trim() ||
+        typeof p.propostoEm !== 'string' || !Number.isFinite(Date.parse(p.propostoEm)) ||
+        p.justificativa !== log.justificativa || p.resumo !== log.resumo ||
+        JSON.stringify(p.classes) !== JSON.stringify(log.classesDeFalha))
+        erros.push('proposta de score inválida');
+    return erros;
+}
+function validarBaseMaster(bruto) {
+    if (!bruto || typeof bruto !== 'object')
+        return ['o MASTER log nao e um objeto'];
+    const erros = [], log = bruto;
+    if (log.versao !== exports.VERSAO_MASTER_LOG)
+        erros.push(`campo "versao" deve ser ${exports.VERSAO_MASTER_LOG}`);
+    for (const campo of ['thread', 'slug', 'modo', 'tag', 'justificativa', 'resumo']) {
+        const v = log[campo];
+        if (typeof v !== 'string' || v.trim() === '')
+            erros.push(`campo "${campo}" ausente ou vazio`);
+    }
     if (!Array.isArray(log.fases) || log.fases.length === 0) {
         erros.push('campo "fases" deve listar as fases percorridas');
     }
@@ -361,22 +498,120 @@ function validarMasterLog(bruto) {
     }
     return erros;
 }
-/** Le o MASTER log de uma thread, quando existe. */
+function hashDocumento(arquivo) {
+    return (0, node_crypto_1.createHash)('sha256').update(fs.readFileSync(arquivo)).digest('hex');
+}
+/** Leitura fail-closed: documento divergente não vira aprendizado ratificado. */
 function lerMasterLog(raiz, id) {
     const caminho = caminhoMasterLog(raiz, id);
     if (!fs.existsSync(caminho))
         return null;
-    return (0, util_1.lerJson)(caminho);
+    let log;
+    try {
+        log = (0, util_1.lerJson)(caminho);
+    }
+    catch {
+        return null; /* JSON inválido não é MASTER */
+    }
+    if (validarMasterLog(log).length || !masterRatificado(raiz, id))
+        return null;
+    const score = (0, thread_1.lerThread)(raiz, id).score;
+    const evento = [...(0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, id))].reverse().find(e => e.tipo === ledger_1.TIPOS_DE_EVENTO.masterConcluido);
+    if (log.thread !== id || log.score !== score.valor || log.justificativa !== score.justificativa ||
+        log.avaliadoPor !== score.avaliadoPor || log.avaliadoEm !== score.avaliadoEm)
+        return null;
+    if (Array.isArray(evento.classesDeFalha) && JSON.stringify(log.classesDeFalha) !== JSON.stringify(evento.classesDeFalha))
+        return null;
+    // Hashes são evidência adicional no evento, sem mudar o contrato congelado v1.
+    if (evento.masterLogSha256 && hashDocumento(caminho) !== evento.masterLogSha256)
+        return null;
+    if (evento.postmortemSha256 && (!fs.existsSync(caminhoPostmortem(raiz, id)) ||
+        hashDocumento(caminhoPostmortem(raiz, id)) !== evento.postmortemSha256))
+        return null;
+    return log;
+}
+/** Quem decide quando ninguem decide. Literal unico, para o leitor reconhecer. */
+exports.AUTOR_DA_OMISSAO = 'nucleo ork (omissao)';
+/**
+ * Aceita a entrega por OMISSAO e registra que foi por omissao (I-43, D3).
+ *
+ * Este e o coracao da remocao da fila de ratificacao, e a parte que nao pode dar
+ * errado. Aceitacao por default sem registro seria pior que a fila: a fila ao menos
+ * deixava 13 threads visiveis esperando; uma entrega ruim aceita em silencio some, e
+ * some sem deixar rastro de que sumiu (R4 do GOAL).
+ *
+ * Entao a aceitacao produz TRES rastros independentes:
+ *   1. o evento `aceite_por_omissao` no ledger, append-only, com o indice e os
+ *      insumos que o produziram;
+ *   2. o `score` gravado com `regime: 'omissao'` e `avaliadoPor` do nucleo,
+ *      distinguivel de nota humana a olho e por codigo;
+ *   3. a visao de `ork master`, que lista o que passou sem o dono olhar.
+ *
+ * E ela NAO e irreversivel: reclamar continua possivel para sempre. O dono pontua a
+ * thread quando quiser, o score vira `regime: 'pausa'` com o nome dele, e o evento de
+ * omissao PERMANECE no ledger, porque o ledger e append-only e a historia de que a
+ * entrega passou sem revisao continua sendo verdade.
+ */
+function aceitarPorOmissao(raiz, id) {
+    const thread = (0, thread_1.lerThread)(raiz, id);
+    const dir = (0, thread_1.dirThread)(raiz, id);
+    // A1: aceitar por default so pode carimbar nota depois de perguntar ao git se a
+    // entrega ainda esta de pe. Era aqui que uma entrega revertida virava score 5.
+    const indice = indiceDaThread(raiz, id);
+    const aceitoEm = (0, util_1.agora)();
+    (0, ledger_1.registrar)(dir, id, ledger_1.TIPOS_DE_EVENTO.aceitePorOmissao, {
+        fase: 'MASTER',
+        indice: indice.valor,
+        base: indice.base,
+        // Os INSUMOS vao junto: um numero sem origem no ledger e um numero inventado.
+        insumos: indice.parcelas.map((p) => ({ evento: p.evento, ocorrencias: p.ocorrencias, desconto: p.desconto })),
+        decididoPor: exports.AUTOR_DA_OMISSAO,
+        razao: 'entrega aceita por default: ninguem pontuou. Nota humana posterior sobrescreve, e este evento permanece',
+    });
+    registrarMaster(raiz, id, {
+        score: Math.round(indice.valor),
+        justificativa: `Aceita por omissao: ninguem pontuou esta entrega. Indice derivado do ledger = ` +
+            `${indice.valor} de ${indice.base}` +
+            (indice.parcelas.length === 0
+                ? ', sem reversao, GO-FIX, CHECK refeito nem ship barrado.'
+                : `, descontando ${indice.parcelas.map((p) => `${p.evento} x${p.ocorrencias}`).join(', ')}.`) +
+            ' O dono pode pontuar quando quiser; a nota humana sobrescreve e o registro da omissao permanece.',
+        por: exports.AUTOR_DA_OMISSAO,
+        regime: 'omissao',
+        refazer: thread.status === 'fechada',
+    });
+    return { thread: id, indice, decididoPor: exports.AUTOR_DA_OMISSAO, aceitoEm };
+}
+/** As entregas aceitas por omissao: o que passou sem o dono olhar. */
+function aceitosPorOmissao(raiz) {
+    const saida = [];
+    for (const id of (0, thread_1.listarIds)(raiz)) {
+        const eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, id));
+        const aceite = [...eventos].reverse().find((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.aceitePorOmissao);
+        if (!aceite)
+            continue;
+        // A1: a reversao pode ter vindo DEPOIS do aceite. O indice aqui e recalculado ao
+        // vivo, e `scoreGravado` fica ao lado para a divergencia aparecer em vez de sumir:
+        // o MASTER log e contrato congelado e nao se reescreve sozinho.
+        saida.push({
+            thread: id,
+            indice: indiceDaThread(raiz, id),
+            decididoPor: String(aceite.decididoPor ?? exports.AUTOR_DA_OMISSAO),
+            aceitoEm: String(aceite.ts ?? ''),
+            scoreGravado: (0, thread_1.lerThread)(raiz, id).score?.valor ?? null,
+        });
+    }
+    return saida;
 }
 /**
  * A fila de batch scoring: threads que entregaram (ou chegaram ao MASTER) e ainda nao
- * tem score. E a fila que `#Ork`, `#Maestro` e `#Auto` alimentam ao entregar sem pausa.
+ * tem score. E a fila que `#Classic`, `#Maestro` e `#Auto` alimentam ao entregar sem pausa.
  */
 function pendentesDeScore(raiz, todas = false) {
     const saida = [];
     for (const id of (0, thread_1.listarIds)(raiz)) {
         const thread = (0, thread_1.lerThread)(raiz, id);
-        if (thread.score)
+        if (thread.fechamentoAdmin || masterRatificado(raiz, id))
             continue;
         const jaEntregou = entregou(raiz, id);
         const noMaster = thread.faseAtual === 'MASTER';
@@ -392,44 +627,93 @@ function pendentesDeScore(raiz, todas = false) {
     }
     return saida;
 }
-/** Tabela de `ork master --batch`: o review em bloco. */
-function tabelaDeBatch(raiz, todas = false) {
+/**
+ * A visao de entregas de `ork master` (I-43, T8): o que a FILA deixou de ser.
+ *
+ * O que saiu foi a FILA, e o que ela era: uma lista que acumulava "entregou e nao tem
+ * score" esperando o humano. Ela tinha 13 entradas em 20/09/2026, e nao por falta de
+ * lembrete: lembrete nao converte em nota. Enquanto ela existia, a unica informacao
+ * sobre a qualidade de uma entrega era uma nota que ninguem dava.
+ *
+ * No lugar dela, cada entrega chega com um INDICE ja calculado do ledger, e o comando
+ * oferece UM caminho para drenar o que sobrou: aceitar por omissao, com registro.
+ *
+ * O que NAO saiu, e nao podia sair: pontuar. `ork master <thread> --score` continua
+ * inteiro, e a nota humana continua sobrescrevendo o indice quando o dono reclama.
+ */
+function tabelaDeEntregas(raiz, todas = false) {
     const pendentes = pendentesDeScore(raiz, todas);
+    const omissoes = aceitosPorOmissao(raiz);
+    // A1: o indice da coluna e o de AGORA; `SCORE GRAVADO` e o que o MASTER log congelou.
+    // Quando o segundo e maior, a entrega caiu depois de aceita e isso precisa aparecer.
+    const caiuDepoisDeAceita = omissoes.filter((o) => typeof o.scoreGravado === 'number' && o.indice.valor < o.scoreGravado);
+    const secaoOmissao = omissoes.length === 0
+        ? []
+        : ['', `Aceitas por omissao (${omissoes.length}): o que passou sem voce olhar.`, '',
+            (0, util_1.tabela)(['ID', 'INDICE', 'SCORE GRAVADO', 'ACEITA EM'], omissoes.map((o) => [o.thread, `${o.indice.valor}/${o.indice.base}`,
+                typeof o.scoreGravado === 'number' ? `${o.scoreGravado}/5` : '-',
+                (0, horario_1.formatarDataHora)(o.aceitoEm)])),
+            (0, horario_1.legendaDoFuso)(),
+            ...(caiuDepoisDeAceita.length === 0 ? [] : ['',
+                `ATENCAO: ${caiuDepoisDeAceita.length} entrega(s) cairam DEPOIS de aceitas: ` +
+                    caiuDepoisDeAceita.map((o) => o.thread).join(', ') + '.',
+                '  O MASTER log e contrato congelado e nao se reescreve sozinho. Pontue para o',
+                '  registro humano alcancar o fato; o registro da omissao permanece no ledger.']),
+            '', 'Discordou de alguma? A nota humana sobrescreve, e o registro da omissao permanece:',
+            '  ork master <thread-id> --score <0-5> --justificativa "<por que>" --por <humano>'];
     if (pendentes.length === 0) {
-        return todas
-            ? 'Nenhuma thread aberta sem score. A fila de batch scoring esta vazia.'
-            : 'Nenhuma thread entregue esperando score. A fila de batch scoring esta vazia.\n' +
-                'Para ver tambem as threads que ainda nao entregaram: ork master --batch --todas';
+        return [
+            todas
+                ? 'Nenhuma thread aberta sem score.'
+                : 'Nenhuma entrega esperando decisao. Para ver tambem as que ainda nao entregaram: ork master --todas',
+            ...secaoOmissao,
+        ].join('\n');
     }
-    const linhas = pendentes.map((p) => [
-        p.thread.id,
-        p.thread.slug,
-        (0, modos_1.tagDoModo)(p.thread.modo),
-        p.thread.faseAtual,
-        p.thread.status,
-        p.regime,
-        p.entregou ? 'sim' : 'nao',
-        String(p.fasesPercorridas),
-    ]);
-    const cabecalho = (0, util_1.tabela)(['ID', 'SLUG', 'MODO', 'FASE', 'STATUS', 'REGIME', 'ENTREGOU', 'FASES'], linhas);
+    const linhas = pendentes.map((p) => {
+        const indice = indiceDaThread(raiz, p.thread.id);
+        return [
+            p.thread.id,
+            p.thread.slug,
+            (0, modos_1.tagDoModo)(p.thread.modo),
+            p.thread.faseAtual,
+            p.thread.status,
+            p.entregou ? 'sim' : 'nao',
+            `${indice.valor}/${indice.base}`,
+            indice.parcelas.length === 0 ? 'sem tropeco' : indice.parcelas.map((x) => `${x.evento} x${x.ocorrencias}`).join(', '),
+        ];
+    });
     return [
-        `Fila de score (${pendentes.length} thread(s) esperando o humano)`,
+        `Entregas (${pendentes.length}) com o indice ja derivado do ledger. O numero nao foi digitado por ninguem.`,
         '',
-        cabecalho,
+        (0, util_1.tabela)(['ID', 'SLUG', 'MODO', 'FASE', 'STATUS', 'ENTREGOU', 'INDICE', 'DE ONDE VEIO'], linhas),
         '',
-        'Pontue em bloco, uma linha por thread:',
-        ...pendentes.map((p) => `  ork master ${p.thread.id} --score <0-5> --justificativa "<por que>" --classe <classe>`),
+        '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> --score <0-5> --justificativa "<por que>" --por <humano>   se quiser reclamar',
         '',
         `Classes fixas: ${exports.ORDEM_DAS_CLASSES.join(', ')}`,
+        ...secaoOmissao,
     ].join('\n');
 }
+/**
+ * Aceita por omissao TODAS as entregas que ainda esperam decisao.
+ *
+ * E o comando que drena a fila de uma vez, e por isso ele so alcanca o que de fato
+ * ENTREGOU: uma thread que nunca chegou ao ship nao tem entrega para aceitar, e
+ * aceita-la seria inventar um fato.
+ */
+function aceitarPendentesPorOmissao(raiz) {
+    return pendentesDeScore(raiz)
+        .filter((p) => p.entregou)
+        .map((p) => aceitarPorOmissao(raiz, p.thread.id));
+}
 /** Texto de `ork master <thread-id> --score`. */
 function textoDoMaster(r) {
     const linhas = [];
     linhas.push(`MASTER registrado: thread ${r.thread.id} fechada.`);
     linhas.push(`  score          ${r.masterLog.score}/5 (${r.postmortem.score.regime})`);
     linhas.push(`  justificativa  ${r.masterLog.justificativa}`);
-    linhas.push(`  avaliado por   ${r.masterLog.avaliadoPor} em ${r.masterLog.avaliadoEm}`);
+    linhas.push(`  avaliado por   ${r.masterLog.avaliadoPor} em ${(0, horario_1.formatarDataHoraRotulada)(r.masterLog.avaliadoEm)}`);
     linhas.push(`  classes        ${r.masterLog.classesDeFalha.join(', ')}`);
     linhas.push(`  fases          ${r.masterLog.fases.join(' -> ')}`);
     linhas.push(`  entregas       ${r.postmortem.entregas.length} ship(s) concluido(s) no ledger`);