@orkastery/cli 0.5.1 → 0.5.6

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"));
@@ -83,6 +87,7 @@ const modos_1 = require("./modos");
 const thread_1 = require("./thread");
 const types_1 = require("./types");
 const util_1 = require("./util");
+const locale_1 = require("./locale");
 const fs = __importStar(require("node:fs"));
 const horario_1 = require("./horario");
 const indice_1 = require("./indice");
@@ -105,6 +110,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 +202,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 +225,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 +321,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 +342,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 +438,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);
@@ -646,6 +733,7 @@ function pendentesDeScore(raiz, todas = false) {
  * inteiro, e a nota humana continua sobrescrevendo o indice quando o dono reclama.
  */
 function tabelaDeEntregas(raiz, todas = false) {
+    const m = (0, locale_1.msg)().master;
     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.
@@ -653,23 +741,18 @@ function tabelaDeEntregas(raiz, todas = false) {
     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}`,
+        : ['', m.aceitasTitulo(omissoes.length), '',
+            (0, util_1.tabela)([...m.colunasAceitas], 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>'];
+                m.caiuDepois(caiuDepoisDeAceita.length, caiuDepoisDeAceita.map((o) => o.thread).join(', ')),
+                m.caiuDepoisLinha1, m.caiuDepoisLinha2]),
+            '', m.discordouDeAlguma, m.pontuar];
     if (pendentes.length === 0) {
         return [
-            todas
-                ? 'Nenhuma thread aberta sem score.'
-                : 'Nenhuma entrega esperando decisao. Para ver tambem as que ainda nao entregaram: ork master --todas',
+            todas ? m.semEntregaTodas : m.semEntrega,
             ...secaoOmissao,
         ].join('\n');
     }
@@ -680,22 +763,23 @@ function tabelaDeEntregas(raiz, todas = false) {
             p.thread.slug,
             (0, modos_1.tagDoModo)(p.thread.modo),
             p.thread.faseAtual,
-            p.thread.status,
-            p.entregou ? 'sim' : 'nao',
+            (0, locale_1.msg)().thread.status(p.thread.status),
+            m.simNao(p.entregou),
             `${indice.valor}/${indice.base}`,
-            indice.parcelas.length === 0 ? 'sem tropeco' : indice.parcelas.map((x) => `${x.evento} x${x.ocorrencias}`).join(', '),
+            indice.parcelas.length === 0 ? m.semTropeco : indice.parcelas.map((x) => `${x.evento} x${x.ocorrencias}`).join(', '),
         ];
     });
     return [
-        `Entregas (${pendentes.length}) com o indice ja derivado do ledger. O numero nao foi digitado por ninguem.`,
+        m.entregas(pendentes.length),
         '',
-        (0, util_1.tabela)(['ID', 'SLUG', 'MODO', 'FASE', 'STATUS', 'ENTREGOU', 'INDICE', 'DE ONDE VEIO'], linhas),
+        (0, util_1.tabela)([...m.colunas], 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> --score <0-5> --justificativa "<por que>" --por <humano>   se quiser reclamar',
+        m.entregueEAceito,
+        m.aceitarEsta,
+        m.aceitarTodas,
+        m.reclamar,
         '',
-        `Classes fixas: ${exports.ORDEM_DAS_CLASSES.join(', ')}`,
+        m.classesFixas(exports.ORDEM_DAS_CLASSES.join(', ')),
         ...secaoOmissao,
     ].join('\n');
 }
@@ -706,10 +790,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: (0, locale_1.msg)().master.foraAdmin(id, thread.fechamentoAdmin.motivo) };
+    }
+    if (masterRatificado(raiz, id)) {
+        return { motivo: 'ja-fechada', texto: (0, locale_1.msg)().master.foraJaFechada(id) };
+    }
+    if (!entregou(raiz, id)) {
+        return { motivo: 'sem-entrega', texto: (0, locale_1.msg)().master.foraSemEntrega(id) };
+    }
+    return null;
 }
 /** Texto de `ork master <thread-id> --score`. */
 function textoDoMaster(r) {

package/dist/mcp-artifacts.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.diagnosticoNomeForaDeUtf8 = diagnosticoNomeForaDeUtf8;
 exports.validarArquivosEstadoMcp = validarArquivosEstadoMcp;
 exports.lerArtefatoMcp = lerArtefatoMcp;
 exports.escreverArtefatoMcp = escreverArtefatoMcp;
@@ -49,6 +50,14 @@ const claims_1 = require("./claims");
 const fases = { goal: 'GOAL', plan: 'PLAN', check: 'CHECK' };
 const limite = 128 * 1024;
 const hash = (bytes) => (0, node_crypto_1.createHash)('sha256').update(bytes).digest('hex');
+/** Diagnostico relativo, sem perda de bytes nem controles de terminal; nao e um comando shell. */
+function diagnosticoNomeForaDeUtf8(raiz, pasta, nome) {
+    const pai = path.relative(raiz, pasta);
+    const entrada = Buffer.concat([Buffer.from(pai ? pai + path.sep : ''), nome]);
+    const rotulo = Array.from(entrada, byte => byte >= 0x20 && byte <= 0x7e && byte !== 0x5c
+        ? String.fromCharCode(byte) : '\\x' + byte.toString(16).padStart(2, '0')).join('');
+    return `nome fora de UTF-8 em ${rotulo}\nRenomeie a entrada pelo shell para um nome UTF-8 valido e repita a operacao.`;
+}
 /** Core legado usa nomes de arquivos: este preflight recusa links existentes, nao promete CAS contra writers hostis. */
 function validarArquivosEstadoMcp(raiz, id) {
     validarId(id);
@@ -150,8 +159,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: ' + diagnosticoNomeForaDeUtf8(raiz, pastaLeases, nomeBytes));
+                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: ' + diagnosticoNomeForaDeUtf8(raiz, entrada, candidatoBytes));
+                        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 +271,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: ' + (0, mcp_artifacts_1.diagnosticoNomeForaDeUtf8)(opcoes.relativoA ?? path.dirname(root), f, bytes));
                 visitar(path.join(f, n), profundidade + 1);
+            }
+        }
     };
     if (fs.realpathSync(alvo) !== alvo)
         falha(`metadata.unsafe: ${rotulo(alvo)} passa por link simbolico`);
@@ -337,7 +354,7 @@ function estadoGitMcp(raiz, threadId) {
         scope: 'local-only', observedAt: new Date().toISOString() };
 }
 /** Somente o worker dedicado chama este corpo; não altera env do servidor. */
-function executar(raiz, p) {
+function executar(raiz, p, dispatchId) {
     const proprias = [];
     let commit = null, estadoAuditado = false;
     try {
@@ -347,6 +364,23 @@ function executar(raiz, p) {
         fisico(raiz, (0, thread_1.dirThread)(raiz, p.threadId));
         (0, mcp_artifacts_1.validarArquivosEstadoMcp)(raiz, p.threadId);
         const t = (0, thread_1.lerThread)(raiz, p.threadId), wt = t.worktree;
+        // Identidade vem do startup do servidor, nunca dos argumentos públicos da tool.
+        // Sem vínculo conhecido, o recibo continua sem atribuição de sessão.
+        let vinculo;
+        if (dispatchId !== undefined) {
+            if (!/^[a-f0-9-]{36}$/.test(dispatchId))
+                falha('session.invalid');
+            const despachos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, t.id)).filter(e => e.tipo === 'phase_dispatch');
+            const despacho = despachos.filter(e => e.identidade?.dispatchId === dispatchId).at(-1);
+            const proximo = despacho ? despachos[despachos.indexOf(despacho) + 1] : undefined;
+            const sessoes = despacho ? t.sessoes.filter(s => s.sessionId === despacho.sessionId && s.origem !== 'adocao' &&
+                s.fase === despacho.fase && s.promptSha256 === despacho.promptSha256 && typeof s.despachadaEm === 'string' &&
+                Date.parse(s.despachadaEm) >= Date.parse(despacho.ts) &&
+                (!proximo || Date.parse(s.despachadaEm) < Date.parse(proximo.ts))) : [];
+            if (sessoes.length !== 1)
+                falha('session.invalid');
+            vinculo = { sessionId: sessoes[0].sessionId, despachoEm: sessoes[0].despachadaEm };
+        }
         if (!wt || t.status === 'fechada' || !(0, thread_1.blocoDaThread)(t, t.faseAtual).fases.includes('GO') || wt === raiz)
             falha('thread.invalid');
         // I-42 (D7): ciclo sem PLAN nem CHECK nao commita contrato publico; a mudanca vira iniciativa.
@@ -428,7 +462,7 @@ function executar(raiz, p) {
         const alterados = git(wt, ['diff-tree', '--no-commit-id', '--name-only', '-r', '-z', commit]).split('\0').filter(Boolean);
         if (!alterados.length || alterados.some(f => !p.paths.includes(f)))
             falha('commit.paths-invalid');
-        (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, t.id), t.id, 'mcp_git_committed', { commit, paths: alterados, origem: 'mcp.git', estadoAuditado });
+        (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, t.id), t.id, 'mcp_git_committed', { commit, paths: alterados, origem: 'mcp.git', estadoAuditado, ...vinculo });
         return { ok: true, commit, erro: null, estadoAuditado };
     }
     catch (e) {
@@ -442,7 +476,7 @@ function executar(raiz, p) {
     }
 }
 /** Entrada do servidor: argumentos nunca escolhem executável/env/cwd/opções Git. */
-async function commitMcp(raiz, pedido, signal) {
+async function commitMcp(raiz, pedido, signal, dispatchId) {
     validar(pedido);
     if (signal?.aborted)
         return { ok: false, commit: null, erro: 'mcp.git.cancelled', estadoAuditado: false };
@@ -466,7 +500,7 @@ async function commitMcp(raiz, pedido, signal) {
             erro = true;
             child.stdin.end();
             return;
-        } child.stdin.end(JSON.stringify({ raiz, pedido })); });
+        } child.stdin.end(JSON.stringify({ raiz, pedido, dispatchId })); });
         child.stdin.on('error', () => { erro = true; });
         child.on('error', () => { erro = true; });
         child.stdout.on('data', (b) => { if (Buffer.byteLength(stdout) + b.length > LIMITE)
@@ -499,7 +533,7 @@ if (require.main === module && process.argv[2] === '--worker') {
         if (Buffer.byteLength(raw) > LIMITE)
             falha('request.invalid');
         const p = JSON.parse(raw);
-        process.stdout.write(JSON.stringify(executar(p.raiz, p.pedido)));
+        process.stdout.write(JSON.stringify(executar(p.raiz, p.pedido, p.dispatchId)));
     }
     catch {
         process.stdout.write(JSON.stringify({ ok: false, commit: null, erro: 'mcp.git.worker.invalid', estadoAuditado: false }));

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,18 @@ 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. Desde a
+ * fatia 5, a resposta traz as fontes (sha256 e blob) e diz por aresta se elas conferem com a arvore.
  *
  * 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 +60,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;
@@ -71,7 +76,7 @@ const TETO_DO_STDOUT = 1024 * 1024;
  * O vocabulario e os limites da consulta do KG3, repetidos aqui porque este modulo nao importa a
  * familia do grafo (D8); o teste confere que sao os mesmos do contrato v1 e da consulta.
  */
-exports.TIPOS_DE_ARESTA_DO_MCP = ['contains', 'declares', 'imports', 'calls', 'references', 'derived_from'];
+exports.TIPOS_DE_ARESTA_DO_MCP = ['contains', 'declares', 'imports', 'calls', 'references', 'derived_from', 'cites'];
 exports.PROFUNDIDADE_MAXIMA_DO_MCP = 5;
 exports.LIMITE_MAXIMO_DO_MCP = 10_000;
 /** D2: so o booleano `true` do manifesto da raiz liga as tools. */
@@ -94,7 +99,8 @@ const tipos = zod_1.z.array(zod_1.z.enum(exports.TIPOS_DE_ARESTA_DO_MCP)).min(1)
 const tetoBytes = zod_1.z.number().int().min(exports.TETO_MINIMO).max(exports.TETO_MAXIMO).optional()
     .describe(`teto da resposta em bytes (padrao ${exports.TETO_PADRAO}); acima, saem as arestas mais longe`);
 const COMUM = 'Leitura do grafo do HEAD da worktree da thread (o do ork grafo): so o que o extrator prova. '
-    + 'Resposta JSON ork.code-graph-query/v0 de ate tetoBytes; sem indice do HEAD, recusa com a correcao ork grafo indexar.';
+    + 'Resposta JSON ork.code-graph-query/v0 de ate tetoBytes; sem indice do HEAD, recusa com a correcao ork grafo indexar. '
+    + 'Cada aresta traz arvore (modificada quando uma fonte dela mudou depois do HEAD) e a resposta traz fontes, com o sha256 e o blob de cada arquivo citado.';
 /** As opcoes da CLI, na ordem dela, com `=`: o valor nunca vira outro argumento. */
 function opcoes(a) {
     const r = [];
@@ -134,7 +140,50 @@ 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. Citacoes literais cites; segundo salto marcado usa a sobra apos ligacoes diretas. '
+            + 'Grupo com fonte que mudou depois do HEAD traz arvore: modificada. 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 +253,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) {