@orkastery/cli 0.5.3 → 0.6.0

package/dist/intelligence-graph-query.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.rotuloDoNo = exports.ErroDeConsulta = exports.AVISO_DE_PARCIALIDADE = exports.CANDIDATOS_LISTADOS = exports.LIMITE_MAXIMO = exports.LIMITE_PADRAO = exports.PROFUNDIDADE_MAXIMA = exports.CONSULTA_SCHEMA = void 0;
+exports.rotuloDoNo = exports.ErroDeConsulta = exports.TUDO_IGUAL = exports.TEXTOS_DA_CONSULTA = exports.AVISO_DE_PARCIALIDADE = exports.CANDIDATOS_LISTADOS = exports.LIMITE_MAXIMO = exports.LIMITE_PADRAO = exports.PROFUNDIDADE_MAXIMA = exports.CONSULTA_SCHEMA = void 0;
 exports.filtrarGrafo = filtrarGrafo;
 exports.prepararConsulta = prepararConsulta;
 exports.resolverNo = resolverNo;
@@ -23,6 +23,10 @@ exports.textoDaResposta = textoDaResposta;
  *
  * D7: a resposta e a mesma para o mesmo grafo e a mesma pergunta, byte a byte, em texto e em JSON
  * (`ork.code-graph-query/v0`, provisorio e fora do contrato): ordem por code point, sem horario.
+ *
+ * RM-031 KG5 fatia 5 (D2 a D4, D9, D10): a resposta traz `fontes`, o sha256 e o blob de cada caminho
+ * citado, e cada aresta diz se as fontes dela conferem com a arvore. Quem chama passa a situacao de
+ * cada caminho (o CLI le os bytes); sem ela, tudo vale `igual`, e a consulta continua sem arquivo.
  */
 const intelligence_graph_contract_1 = require("./intelligence-graph-contract");
 exports.CONSULTA_SCHEMA = 'ork.code-graph-query/v0';
@@ -32,6 +36,25 @@ exports.LIMITE_MAXIMO = 10_000;
 /** Candidatos listados quando um nome solto e ambiguo. */
 exports.CANDIDATOS_LISTADOS = 20;
 exports.AVISO_DE_PARCIALIDADE = 'parcial: so arestas que o extrator prova; chamada por despacho de tipo, import nao resolvido e as lacunas do relatorio de extracao ficam fora';
+exports.TEXTOS_DA_CONSULTA = {
+    titulo: (repositorio, revisao, chave, snapshot) => `grafo de ${repositorio} na revisao ${revisao}, indice ${chave}, snapshot ${snapshot}`,
+    arvore: 'aviso: a arvore tem mudanca rastreada; a resposta e do HEAD, nao da arvore',
+    fontes: (lista, resto) => `fontes que mudaram na arvore: ${lista}${resto ? ` e mais ${resto}` : ''}`,
+    marca: '  [fonte modificada na arvore]',
+    pagina: (pagina) => `pagina ${pagina}`,
+    extratores: (lista) => `extratores: ${lista}`,
+    semCaminho: (de, para, sentido, nos) => `sem caminho de ${de} para ${para} (sentido ${sentido}): ${nos} nos explorados`,
+    caminho: (de, para, sentido, passos) => `caminho de ${de} para ${para} (sentido ${sentido}): ${passos} passo(s)`,
+    contra: '(contra a aresta) ',
+    todos: 'todos',
+    resultado: (tipo, alvo, profundidade, filtro, arestas, nos) => `${tipo} de ${alvo} (profundidade ${profundidade}${filtro}): ${arestas} aresta(s), ${nos} no(s)`,
+    filtro: (sentido, tipos) => `, sentido ${sentido}, tipos ${tipos}`,
+    truncado: (devolvidas, total) => `truncado: ${devolvidas} de ${total} arestas, as mais perto do alvo; use --limite`,
+    parcial: exports.AVISO_DE_PARCIALIDADE,
+};
+/** Sem saber da arvore, toda fonte vale `igual`: e o que a arvore limpa garante. */
+const TUDO_IGUAL = () => 'igual';
+exports.TUDO_IGUAL = TUDO_IGUAL;
 /** Erro tipado da consulta; `candidatos` so no nome ambiguo, e so com nos visiveis. */
 class ErroDeConsulta extends Error {
     codigo;
@@ -101,7 +124,11 @@ function prepararConsulta(grafoInteiro, concessao) {
         lista.sort(ordem((a) => rotulos.get(a.from)));
     for (const lista of porFragmento.values())
         lista.sort((x, y) => (0, intelligence_graph_contract_1.compararUtf8)((0, exports.rotuloDoNo)(x), (0, exports.rotuloDoNo)(y)));
-    return { repository_id: grafo.repository_id, snapshot_id: grafo.snapshot.snapshot_id, nos, rotulos, porLocalizador, arquivos, porFragmento, saida, entrada };
+    const fontes = new Map();
+    for (const m of grafo.snapshot.source_manifest)
+        if (visivel(m.access, concessao))
+            fontes.set(m.path, { source_hash: m.source_hash, source_version: m.source_version });
+    return { repository_id: grafo.repository_id, snapshot_id: grafo.snapshot.snapshot_id, nos, rotulos, porLocalizador, arquivos, porFragmento, saida, entrada, fontes };
 }
 function ambiguo(texto, candidatos) {
     const rotulos = candidatos.map(exports.rotuloDoNo).sort(intelligence_graph_contract_1.compararUtf8);
@@ -169,6 +196,31 @@ function arestaDaResposta(g, a, distancia) {
         || (0, intelligence_graph_contract_1.compararUtf8)(x.extractor_id, y.extractor_id) || (0, intelligence_graph_contract_1.compararUtf8)(x.extraction_method, y.extraction_method));
     return { kind: a.kind, from: g.rotulos.get(a.from), to: g.rotulos.get(a.to), edge_id: a.edge_id, distancia, evidencias };
 }
+/**
+ * KG5 fatia 5 (D4): a aresta so e `igual` quando as fontes dela inteiras conferem: o arquivo da origem, o
+ * do alvo (calls e imports resolvem o alvo nele) e os das evidencias. So as devolvidas pedem a situacao.
+ * Com teto, a busca binaria monta respostas com limites diferentes, e o CLI le os arquivos citados pela
+ * maior delas, a do limite pedido, mesmo os que o corte tira (CHECK rodada 1, S4).
+ */
+function comArvore(g, a, r, situacao) {
+    const caminhos = [g.nos.get(a.from).locator.path, g.nos.get(a.to).locator.path, ...r.evidencias.map((e) => e.path)];
+    const { evidencias, ...resto } = r;
+    return { ...resto, arvore: caminhos.every((p) => situacao(p) === 'igual') ? 'igual' : 'modificada', evidencias };
+}
+/** KG5 fatia 5 (D2, D10): uma entrada por caminho dos nos e das evidencias da resposta, em ordem UTF-8. */
+function fontesDaResposta(g, nos, arestas, situacao) {
+    const caminhos = new Set(nos.map((n) => n.path));
+    for (const a of arestas)
+        for (const e of a.evidencias)
+            caminhos.add(e.path);
+    const fontes = [];
+    for (const p of [...caminhos].sort(intelligence_graph_contract_1.compararUtf8)) {
+        const f = g.fontes.get(p);
+        if (f)
+            fontes.push({ path: p, source_hash: f.source_hash, source_version: f.source_version, arvore: situacao(p) });
+    }
+    return fontes;
+}
 /** CHECK rodada 1 (A2): primeiro as arestas mais perto do alvo, e o limite corta as mais longe. */
 const ordemDasArestas = (x, y) => (x.distancia - y.distancia)
     || (0, intelligence_graph_contract_1.compararUtf8)(x.kind, y.kind) || (0, intelligence_graph_contract_1.compararUtf8)(x.from, y.from) || (0, intelligence_graph_contract_1.compararUtf8)(x.to, y.to) || (0, intelligence_graph_contract_1.compararUtf8)(x.edge_id, y.edge_id);
@@ -204,7 +256,7 @@ function tiposValidos(tipos) {
  * cada uma com a distancia do no que a explorou. `limite` corta pela distancia e pela ordem fixa, e
  * a lista de nos so traz o alvo e as pontas das arestas devolvidas.
  */
-function vizinhanca(g, cabecalho, tipo, texto, opcoes) {
+function vizinhanca(g, cabecalho, tipo, texto, opcoes, situacao) {
     const profundidade = inteiroEntre('profundidade', opcoes.profundidade ?? 1, 1, exports.PROFUNDIDADE_MAXIMA);
     const limite = inteiroEntre('limite', opcoes.limite ?? exports.LIMITE_PADRAO, 1, exports.LIMITE_MAXIMO);
     const sentido = opcoes.sentido ?? 'ambos';
@@ -228,8 +280,8 @@ function vizinhanca(g, cabecalho, tipo, texto, opcoes) {
         }
         camada = proxima;
     }
-    const todas = [...vistas.values()].map(({ aresta, d }) => arestaDaResposta(g, aresta, d)).sort(ordemDasArestas);
-    const devolvidas = todas.slice(0, limite);
+    const todas = [...vistas.values()].map(({ aresta, d }) => ({ aresta, r: arestaDaResposta(g, aresta, d) })).sort((x, y) => ordemDasArestas(x.r, y.r));
+    const devolvidas = todas.slice(0, limite).map(({ aresta, r }) => comArvore(g, aresta, r, situacao));
     const idPorRotulo = new Map([...distancia.keys()].map((id) => [g.rotulos.get(id), id]));
     const pontas = new Set([alvo.node_id, ...devolvidas.flatMap((a) => [idPorRotulo.get(a.from), idPorRotulo.get(a.to)])]);
     const nos = [...pontas].map((id) => noDaResposta(g, g.nos.get(id), distancia.get(id)))
@@ -239,31 +291,31 @@ function vizinhanca(g, cabecalho, tipo, texto, opcoes) {
         consulta: { tipo, alvo: texto, para: null, profundidade, sentido, tipos, limite },
         indice: cabecalho, alvo: noDaResposta(g, alvo, 0), para: null, nos, total_nos: distancia.size,
         arestas: devolvidas, total_arestas: todas.length, truncado: todas.length > limite,
-        caminho: null, nos_explorados: null, parcial: exports.AVISO_DE_PARCIALIDADE,
+        caminho: null, nos_explorados: null, fontes: fontesDaResposta(g, nos, devolvidas, situacao), parcial: exports.AVISO_DE_PARCIALIDADE,
     };
 }
-function vizinhos(g, cabecalho, alvo, opcoes = {}) {
-    return vizinhanca(g, cabecalho, 'vizinhos', alvo, opcoes);
+function vizinhos(g, cabecalho, alvo, opcoes = {}, situacao = exports.TUDO_IGUAL) {
+    return vizinhanca(g, cabecalho, 'vizinhos', alvo, opcoes, situacao);
 }
 /** Quem chama o simbolo: as arestas `calls` que chegam, ate `profundidade` saltos. */
-function chamadores(g, cabecalho, alvo, opcoes = {}) {
+function chamadores(g, cabecalho, alvo, opcoes = {}, situacao = exports.TUDO_IGUAL) {
     if (resolverNo(g, alvo).kind !== 'symbol')
         throw new ErroDeConsulta('grafo.consulta.alvo-invalido', 'chamadores pede um simbolo; para arquivo, use importadores ou vizinhos');
-    return vizinhanca(g, cabecalho, 'chamadores', alvo, { ...opcoes, sentido: 'entrada', tipos: ['calls'] });
+    return vizinhanca(g, cabecalho, 'chamadores', alvo, { ...opcoes, sentido: 'entrada', tipos: ['calls'] }, situacao);
 }
 /** Quem importa o arquivo ou o simbolo: as arestas `imports` que chegam, ate `profundidade` saltos. */
-function importadores(g, cabecalho, alvo, opcoes = {}) {
+function importadores(g, cabecalho, alvo, opcoes = {}, situacao = exports.TUDO_IGUAL) {
     const kind = resolverNo(g, alvo).kind;
     if (kind !== 'file' && kind !== 'symbol')
         throw new ErroDeConsulta('grafo.consulta.alvo-invalido', 'importadores pede um arquivo ou um simbolo');
-    return vizinhanca(g, cabecalho, 'importadores', alvo, { ...opcoes, sentido: 'entrada', tipos: ['imports'] });
+    return vizinhanca(g, cabecalho, 'importadores', alvo, { ...opcoes, sentido: 'entrada', tipos: ['imports'] }, situacao);
 }
 /**
  * D5: o menor caminho de `de` a `para`, pelas arestas no sentido pedido (padrao: `saida`, a direcao
  * da aresta). Busca em largura com a expansao na ordem fixa: entre caminhos do mesmo tamanho, sai
  * sempre o mesmo. Sem caminho, `caminho` e `null`, com os nos explorados.
  */
-function caminho(g, cabecalho, de, para, opcoes = {}) {
+function caminho(g, cabecalho, de, para, opcoes = {}, situacao = exports.TUDO_IGUAL) {
     const sentido = opcoes.sentido ?? 'saida';
     if (!['entrada', 'saida', 'ambos'].includes(sentido))
         throw new ErroDeConsulta('grafo.consulta.uso', `sentido desconhecido: ${sentido}`);
@@ -284,61 +336,71 @@ function caminho(g, cabecalho, de, para, opcoes = {}) {
     if (anterior.has(destino.node_id)) {
         const cadeia = [];
         for (let id = destino.node_id, atual = anterior.get(id); atual; id = atual.de, atual = anterior.get(id)) {
-            cadeia.push({ id, passo: { sentido: atual.sentido, aresta: arestaDaResposta(g, atual.aresta, 0) } });
+            cadeia.push({ id, sentido: atual.sentido, aresta: atual.aresta });
         }
         cadeia.reverse();
-        cadeia.forEach((c, n) => { c.passo.aresta.distancia = n; });
-        passos = cadeia.map((c) => c.passo);
+        passos = cadeia.map((c, n) => ({ sentido: c.sentido, aresta: comArvore(g, c.aresta, arestaDaResposta(g, c.aresta, n), situacao) }));
         nos = [origem.node_id, ...cadeia.map((c) => c.id)].map((id, d) => noDaResposta(g, g.nos.get(id), d));
     }
+    const arestas = passos ? passos.map((p) => p.aresta) : [];
     return {
         schema: exports.CONSULTA_SCHEMA,
         consulta: { tipo: 'caminho', alvo: de, para, profundidade: null, sentido, tipos, limite: null },
         indice: cabecalho, alvo: noDaResposta(g, origem, 0), para: noDaResposta(g, destino, passos ? passos.length : null),
         nos, total_nos: nos.length,
-        arestas: passos ? passos.map((p) => p.aresta) : [], total_arestas: passos ? passos.length : 0, truncado: false,
-        caminho: passos, nos_explorados: anterior.size, parcial: exports.AVISO_DE_PARCIALIDADE,
+        arestas, total_arestas: arestas.length, truncado: false,
+        caminho: passos, nos_explorados: anterior.size, fontes: fontesDaResposta(g, nos, arestas, situacao), parcial: exports.AVISO_DE_PARCIALIDADE,
     };
 }
 function jsonDaResposta(r) {
     return JSON.stringify(r, null, 2);
 }
-function linhasDaEvidencia(e) {
+function linhasDaEvidencia(e, m) {
     const s = e.span;
     const onde = s.type === 'text'
         ? `${e.path}:${s.line_start ?? '?'}${s.line_end !== null && s.line_end !== s.line_start ? `-${s.line_end}` : ''}`
-        : `${e.path} pagina ${s.page}`;
+        : `${e.path} ${m.pagina(s.page)}`;
     return `      ${e.extractor_id} ${e.extraction_method} ${onde} bytes ${s.byte_start}-${s.byte_end}`;
 }
-function linhasDaAresta(a, prefixo = '  ') {
-    return [`${prefixo}${a.kind}  ${a.from} -> ${a.to}`, ...a.evidencias.map(linhasDaEvidencia)];
+/** KG5 fatia 5 (D9): a aresta cuja fonte mudou diz isso na propria linha, como o JSON diz no campo `arvore`. */
+function linhasDaAresta(a, m, prefixo = '  ') {
+    const marca = a.arvore === 'modificada' ? m.marca : '';
+    return [`${prefixo}${a.kind}  ${a.from} -> ${a.to}${marca}`, ...a.evidencias.map((e) => linhasDaEvidencia(e, m))];
+}
+/** KG5 fatia 5 (D9): ate cinco fontes que nao tem na arvore os bytes do indice, com a situacao de cada uma. */
+function linhaDasFontesMudadas(fontes, m) {
+    const mudaram = fontes.filter((f) => f.arvore !== 'igual');
+    if (!mudaram.length)
+        return [];
+    return [m.fontes(mudaram.slice(0, 5).map((f) => `${f.path} (${f.arvore})`).join(', '), Math.max(0, mudaram.length - 5))];
 }
-function textoDaResposta(r) {
+function textoDaResposta(r, m = exports.TEXTOS_DA_CONSULTA) {
     const c = r.consulta, i = r.indice;
     const linhas = [
-        `grafo de ${i.repository_id} na revisao ${i.revision.slice(0, 12)}, indice ${i.chave.slice(0, 16)}, snapshot ${i.snapshot_id.slice(0, 17)}`,
+        m.titulo(i.repository_id, i.revision.slice(0, 12), i.chave.slice(0, 16), i.snapshot_id.slice(0, 17)),
     ];
     if (i.arvore === 'modificada')
-        linhas.push('aviso: a arvore tem mudanca rastreada; a resposta e do HEAD, nao da arvore');
-    linhas.push(`extratores: ${i.extratores.map((e) => `${e.extractor_id} ${e.extractor_version}`).join(', ')}`);
+        linhas.push(m.arvore);
+    linhas.push(...linhaDasFontesMudadas(r.fontes, m));
+    linhas.push(m.extratores(i.extratores.map((e) => `${e.extractor_id} ${e.extractor_version}`).join(', ')));
     if (c.tipo === 'caminho') {
         const para = r.para;
         if (!r.caminho) {
-            linhas.push(`sem caminho de ${r.alvo.rotulo} para ${para.rotulo} (sentido ${c.sentido}): ${r.nos_explorados} nos explorados`);
+            linhas.push(m.semCaminho(r.alvo.rotulo, para.rotulo, c.sentido, r.nos_explorados));
         }
         else {
-            linhas.push(`caminho de ${r.alvo.rotulo} para ${para.rotulo} (sentido ${c.sentido}): ${r.caminho.length} passo(s)`);
-            r.caminho.forEach((p, n) => linhas.push(...linhasDaAresta(p.aresta, `  ${n + 1}. ${p.sentido === 'entrada' ? '(contra a aresta) ' : ''}`)));
+            linhas.push(m.caminho(r.alvo.rotulo, para.rotulo, c.sentido, r.caminho.length));
+            r.caminho.forEach((p, n) => linhas.push(...linhasDaAresta(p.aresta, m, `  ${n + 1}. ${p.sentido === 'entrada' ? m.contra : ''}`)));
         }
     }
     else {
-        const filtro = c.tipo === 'vizinhos' ? `, sentido ${c.sentido}, tipos ${c.tipos.length === intelligence_graph_contract_1.TIPOS_DE_ARESTA.length ? 'todos' : c.tipos.join(',')}` : '';
-        linhas.push(`${c.tipo} de ${r.alvo.rotulo} (profundidade ${c.profundidade}${filtro}): ${r.total_arestas} aresta(s), ${r.total_nos - 1} no(s)`);
+        const filtro = c.tipo === 'vizinhos' ? m.filtro(c.sentido, c.tipos.length === intelligence_graph_contract_1.TIPOS_DE_ARESTA.length ? m.todos : c.tipos.join(',')) : '';
+        linhas.push(m.resultado(c.tipo, r.alvo.rotulo, c.profundidade, filtro, r.total_arestas, r.total_nos - 1));
         for (const a of r.arestas)
-            linhas.push(...linhasDaAresta(a));
+            linhas.push(...linhasDaAresta(a, m));
         if (r.truncado)
-            linhas.push(`truncado: ${r.arestas.length} de ${r.total_arestas} arestas, as mais perto do alvo; use --limite`);
+            linhas.push(m.truncado(r.arestas.length, r.total_arestas));
     }
-    linhas.push(r.parcial);
+    linhas.push(m.parcial);
     return linhas.join('\n');
 }

package/dist/leases.js

@@ -97,6 +97,7 @@ const horario_1 = require("./horario");
 const conducao_texto_1 = require("./conducao-texto");
 const ledger_1 = require("./ledger");
 const thread_1 = require("./thread");
+const locale_1 = require("./locale");
 /** Nome do lease que serializa o merge na base (visao, paridade 5). */
 exports.LEASE_MAIN_TREE = 'main-tree';
 /** TTL padrao de 30 minutos: um SHIP que passe disso deixou de existir. */
@@ -1033,24 +1034,25 @@ function adquirirRegiao(raiz, nome, opcoes) {
 }
 /** Texto de `ork lease list`: leases ativos, familias e a fila por colisao. */
 function tabelaDeLeases(raiz) {
+    const m = (0, locale_1.msg)().operacao.restante.lease;
     const emDisco = leasesEmDisco(raiz);
     const fila = lerFila(raiz);
-    const linhas = ['Leases do projeto', ''];
+    const linhas = [m.titulo, ''];
     const principal = (0, estado_thread_1.raizDoEstado)(raiz);
     if (emDisco.length === 0) {
-        linhas.push('  Nenhum lease tomado. O merge na base esta liberado.');
+        linhas.push(m.nenhum);
     }
     else {
         for (const { lease: l, legado } of emDisco) {
-            const situacao = expirado(l) ? 'VENCIDO (tomavel)' : 'ativo';
-            linhas.push(`  ${textoSeguro(l.nome).padEnd(28)} [${tipoDoLease(l.nome)}] thread ${textoSeguro(l.thread).padEnd(18)} ${situacao}`);
-            linhas.push(`    desde ${(0, horario_1.formatarDataHora)(l.adquiridoEm)} ate ${(0, horario_1.formatarDataHora)(l.expiraEm)} (pid ${l.pid})`);
-            linhas.push(`    motivo: ${textoSeguro(l.motivo)}`);
+            const situacao = expirado(l) ? m.situacao.vencido : m.situacao.ativo;
+            linhas.push(m.item(textoSeguro(l.nome), tipoDoLease(l.nome), textoSeguro(l.thread), situacao));
+            linhas.push(m.periodo((0, horario_1.formatarDataHora)(l.adquiridoEm), (0, horario_1.formatarDataHora)(l.expiraEm), l.pid));
+            linhas.push(m.motivo(textoSeguro(l.motivo)));
             // RM-036: a copia antiga e somente lida, ate vencer ou encerrar a janela.
             if (legado) {
                 const relativo = path.relative(principal, legado);
                 const onde = relativo && !relativo.startsWith('..') && !path.isAbsolute(relativo) ? relativo : legado;
-                linhas.push(`    legado: ${textoSeguro(onde)} (vale enquanto vivo, dentro da janela de 30 min da troca)`);
+                linhas.push(m.legado(textoSeguro(onde)));
             }
             // I-36: o lease de execucao diz quem conduz, com a mesma linha das outras superficies.
             const conducao = (0, conducao_texto_1.conducaoDoLease)(l);
@@ -1088,15 +1090,15 @@ function tabelaDeLeases(raiz) {
             }
             if (tipoDoLease(nome) === 'exec')
                 continue;
-            linhas.push(`  legado: ${textoSeguro(arquivo)} INVALIDO ou ILEGIVEL (ignorado)`);
-            linhas.push('    arquivo legado preservado; ignorado sem alterar o lease canonico');
+            linhas.push(m.legadoInvalido(textoSeguro(arquivo)));
+            linhas.push(m.legadoPreservado);
         }
     }
     linhas.push('');
     // Consulta nao recolhe candidatos: mostra a fila, inclusive sobras de SIGKILL.
     const pasta = dirLeases(raiz);
     const retomadas = fs.existsSync(pasta) ? fs.readdirSync(pasta).filter((n) => n.endsWith('.json.retomadas')).sort() : [];
-    linhas.push(`Fila de retomada: ${retomadas.length === 0 ? 'vazia' : `${retomadas.length} lease(s)`}`);
+    linhas.push(m.filaRetomada(retomadas.length));
     for (const nome of retomadas) {
         const dir = path.join(pasta, nome);
         linhas.push(`  ${textoSeguro(nome)}`);
@@ -1108,25 +1110,24 @@ function tabelaDeLeases(raiz) {
                 if (!c)
                     continue;
                 const idade = Math.max(0, Date.now() - c.stat.mtimeMs), vencido = idade >= exports.TTL_PADRAO_MS;
-                linhas.push(`    ${textoSeguro(c.nome)} pid ${c.pid} ${c.ticket === null ? 'temporario' : `ticket ${c.ticket}`} idade ${Math.floor(idade / 1000)}s`);
+                linhas.push(m.candidato(textoSeguro(c.nome), c.pid, c.ticket, Math.floor(idade / 1000)));
                 if (vencido)
-                    linhas.push('      lease.resume-unavailable: prazo de 30 min excedido; repita a aquisicao para recolher e consulte ork lease list');
+                    linhas.push(m.prazo);
             }
         }
         catch {
-            linhas.push('    lease.resume-unavailable: fila ilegivel ou insegura; inspecione candidatos antes de repetir a aquisicao');
+            linhas.push(m.filaInsegura);
         }
     }
     const merge = fila.filter((p) => p.tipo === 'main-tree');
     const regiao = fila.filter((p) => p.tipo !== 'main-tree');
-    linhas.push(`Fila de merge (lease ${exports.LEASE_MAIN_TREE}): ${merge.length === 0 ? 'vazia' : `${merge.length} na espera`}`);
+    linhas.push(m.filaMerge(merge.length));
     merge.forEach((p, i) => {
-        linhas.push(`  ${i + 1}. thread ${textoSeguro(p.thread)} desde ${(0, horario_1.formatarDesde)(p.desdeEm)} (bloqueada por ${textoSeguro(p.bloqueadaPor)})`);
+        linhas.push(m.esperaMerge(i + 1, textoSeguro(p.thread), (0, horario_1.formatarDesde)(p.desdeEm), textoSeguro(p.bloqueadaPor)));
     });
-    linhas.push(`Fila por colisao de regiao: ${regiao.length === 0 ? 'vazia' : `${regiao.length} na espera`}`);
+    linhas.push(m.filaRegiao(regiao.length));
     regiao.forEach((p, i) => {
-        linhas.push(`  ${i + 1}. thread ${textoSeguro(p.thread)} quer ${textoSeguro(p.nome)}, colide com ${textoSeguro(p.colidiuCom)} ` +
-            `(thread ${textoSeguro(p.bloqueadaPor)}) desde ${(0, horario_1.formatarDesde)(p.desdeEm)}`);
+        linhas.push(m.esperaRegiao(i + 1, textoSeguro(p.thread), textoSeguro(p.nome), textoSeguro(p.colidiuCom), textoSeguro(p.bloqueadaPor), (0, horario_1.formatarDesde)(p.desdeEm)));
     });
     if (emDisco.length > 0 || fila.length > 0)
         linhas.push((0, horario_1.legendaDoFuso)());

package/dist/ledger-stats.js

@@ -45,6 +45,7 @@ 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 locale_1 = require("./locale");
 const MOTIVOS_PREVENTIVOS = new Set([
     'policy.violation', 'cost.violation', 'verify.regression', 'claims.failed', 'claims.unverifiable',
 ]);
@@ -260,27 +261,27 @@ 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`;
+const minutos = (ms) => ms === null ? (0, locale_1.msg)().operacao.ledger.semResposta : `${(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}`;
+    const m = (0, locale_1.msg)().operacao.ledger;
+    const meta = h.dentroDaMeta === null ? '' : h.dentroDaMeta ? m.metaDentro : m.metaFora;
+    return m.hitl(h.pedidos, (h.paradoMs / 3_600_000).toFixed(2), minutos(h.medianaRespostaMs), meta, h.abertos, h.emTexto.foraDaExcecao);
 }
 function textoDasEstatisticas(r) {
-    const dinheiro = r.custoReferencia.valor === null ? 'sem cobertura' : `USD ${r.custoReferencia.valor.toFixed(6)}`;
+    const m = (0, locale_1.msg)().operacao.ledger;
+    const dinheiro = r.custoReferencia.valor === null ? m.semCobertura : `USD ${r.custoReferencia.valor.toFixed(6)}`;
     return [
-        `Ledger stats  ${(0, horario_1.formatarDataHora)(r.periodo.desde)} ate ${(0, horario_1.formatarDataHoraRotulada)(r.periodo.ate)} ${r.periodo.intervalo}`,
-        `  threads/sessoes  ${r.threads} / ${r.sessoes.concluidas} concluidas (${r.sessoes.despachadas} despachos)`,
-        `  throughput       ${r.throughput.ships} ship(s); ${r.sessoes.retries} retry(ies)`,
-        `  execucao         ${r.execucao.horas.toFixed(2)} h (${r.execucao.cobertura.medidas} medidas; ${r.execucao.cobertura.semMedida} ausentes)`,
-        `  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)`,
+        m.periodo((0, horario_1.formatarDataHora)(r.periodo.desde), (0, horario_1.formatarDataHoraRotulada)(r.periodo.ate), r.periodo.intervalo),
+        m.sessoes(r.threads, r.sessoes.concluidas, r.sessoes.despachadas),
+        m.throughput(r.throughput.ships, r.sessoes.retries),
+        m.execucao(r.execucao.horas.toFixed(2), r.execucao.cobertura.medidas, r.execucao.cobertura.semMedida),
+        m.tokens(r.tokens.total, r.tokens.input, r.tokens.cachedInput, r.tokens.output),
+        m.custo(dinheiro),
+        m.espera((r.esperaHumana.milissegundos / 3_600_000).toFixed(2), r.esperaHumana.abertas),
         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}`),
+        m.riscos(r.riscosPreventivos.total),
+        m.estimativas(r.estimativasPlano.amostras),
+        ...r.qualidade.observacoes.map(o => m.cobertura(m.observacao(o))),
     ].join('\n');
 }

package/dist/ledger.js

@@ -52,6 +52,7 @@ const path = __importStar(require("node:path"));
 const util_1 = require("./util");
 const node_crypto_1 = require("node:crypto");
 const company_brain_journal_1 = require("./company-brain-journal");
+const locale_1 = require("./locale");
 /** Tipos de evento do ledger. B0 abriu a lista; o B1 acrescenta os seus. */
 exports.TIPOS_DE_EVENTO = {
     // Bloco B0
@@ -60,6 +61,10 @@ exports.TIPOS_DE_EVENTO = {
     faseDespachada: 'phase_dispatch',
     despachoVerificado: 'phase_dispatch_verified',
     despachoFalhou: 'phase_dispatch_failed',
+    // RM-063 (F3): o prompt foi ao disco e ao ledger, com o sha256, ANTES do adaptador. O despacho que morre
+    // depois (contexto do runtime, adaptador que lanca, processo morto) deixa o que o `ork retry run`
+    // redespacha sem pedir o texto. Escritor: `phase.ts` (`rodarFaseSobLock`).
+    promptGravado: 'phase_prompt_recorded',
     decisaoAutonoma: 'autonomous_decision',
     pausaHumana: 'human_gate',
     // Bloco B1: verdade, leases, ship e handoff
@@ -73,6 +78,10 @@ exports.TIPOS_DE_EVENTO = {
     shipIniciado: 'ship_started',
     shipConcluido: 'ship_done',
     shipBloqueado: 'ship_blocked',
+    // Security scan: a loop category was not scanned for the candidate SHA and a human authorized the delivery anyway.
+    entregaSemScanAutorizada: 'ship_unscanned_authorized',
+    // RM-059 (F7, T7.1): o `ork ship publicar` publicou a branch ou abriu o PR, com a prova do `ls-remote`.
+    shipPublicado: 'ship_published',
     /**
      * I-43 (D3): a entrega foi revertida na base depois do ship.
      *
@@ -96,6 +105,13 @@ exports.TIPOS_DE_EVENTO = {
     handoffRecuperado: 'handoff_recalled',
     // Bloco B2: worktree gerenciada, fila de leases, escalonador e MASTER/score
     worktreeGarantida: 'worktree_ensured',
+    /** RM-037 (defeito 2 de 19 e 20/10/2026): o preparo de `worktree.dependencias` na worktree nova. */
+    worktreeDependencias: 'worktree_dependencias',
+    /**
+     * RM-037 (CHECK 3 da ork-rm037defeit2): o preparo que a criacao adiou (o passo do arco abre a thread sob a trava de
+     * despacho); a baseline e o verify o rodam antes do primeiro comando.
+     */
+    worktreeDependenciasPendentes: 'worktree_dependencias_pendentes',
     worktreeSincronizada: 'worktree_synced',
     worktreeAuditada: 'worktree_audited',
     worktreeLiberada: 'worktree_released',
@@ -175,6 +191,33 @@ exports.TIPOS_DE_EVENTO = {
     // RM-037 (rm037defeito, A-1 do CHECK 3): o despacho recusado antes da sessao devolveu o lease que a tomada consumiu.
     conducaoDevolvida: 'conducao_devolvida',
     conducaoRenovada: 'conducao_renovada',
+    // RM-063 (F1): a batida da varredura instalada ou removida no crontab desta maquina, pelo
+    // `ork fabrica batida`. Mora no ledger da maquina (`~/.orkastery/ledger.jsonl`, thread `maquina`):
+    // o crontab e do usuario na maquina, nao de uma thread. Escritor: `fabrica-batida.ts`.
+    batidaInstalada: 'batida_instalada',
+    batidaRemovida: 'batida_removida',
+    // RM-063 (F4): um degrau da escada de recuperacao do runtime (reerguer o daemon, o fallback do bloco, outro
+    // perfil), feito, pulado ou falho, com o destino e o mesmo sha256 do prompt. Escritor: `runtime-escada.ts`.
+    recuperacaoDoRuntime: 'runtime_recuperacao',
+    // RM-063 (F5): uma acao da varredura (limpar sessao fantasma, registrar a entrega de PR mesclado, MASTER por omissao),
+    // feita ou recusada, com a autorizacao duravel do dono que a permitiu. Escritor: `varredura-acoes.ts`.
+    acaoDaVarredura: 'varredura_acao',
+    // RM-063 (F6): o dono foi avisado de que a maquina esta ociosa (vaga livre e item reservado para ela sem ninguem
+    // trabalhando), uma linha por episodio, no ledger do projeto. Escritor: a varredura (`pulse-delivery.ts`).
+    maquinaOciosaAvisada: 'maquina_ociosa_avisada',
+    // RM-063 (F7): o dono gravou a autorizacao duravel desta maquina (`ork conducao autorizar`), no ledger do projeto, com
+    // quem autorizou, ate quando, o que pode e a que ela substituiu. Escritor: `autorizacao-duravel.ts`.
+    autorizacaoConcedida: 'autorizacao_concedida',
+    // RM-059 (F6, T6.4): a Sentinela do Condutor ligou ou desligou nesta maquina (ledger do projeto, so na troca).
+    sentinelaLigada: 'sentinela_ligada',
+    sentinelaDesligada: 'sentinela_desligada',
+    // RM-059 (F9, T9.1): a resposta de sessao `claude-bg` pelo Mensageiro de Sessoes (`entrega-por-mod.ts`), sem o
+    // texto, so o sha256 do corpo. Na fila: o `enviar` do controle por mod, no servidor do dono que recebeu a resposta.
+    // Enviada: a `ork_session_outbox` com o resultado do `$.session.send`. Reservada: a `ork_session_inbox` do servidor
+    // preso ao despacho, quando a conferencia no receptor passa. O `session_answered` sai da reconciliacao de sempre.
+    entregaNaFila: 'session_delivery_queued',
+    entregaEnviada: 'session_delivery_sent',
+    entregaReservada: 'session_delivery_reserved',
 };
 /**
  * I-41 (GO-FIX 1, B4 e D11): o rastro tipado da decisao autonoma.
@@ -190,7 +233,8 @@ function exigirRastroDeDecisaoAutonoma(dados) {
     for (const campo of ['quemDecidiu', 'evidencia', 'razao']) {
         const v = dados[campo];
         if (typeof v !== 'string' || !v.trim() || v.length > 1000 || /[\x00-\x08\x0b-\x1f\x7f]/.test(v)) {
-            throw new Error(`decisão autônoma exige ${campo}: quem decidiu, com que evidência e por quê`);
+            // RM-061 F3c: a recusa sai do catalogo, na lingua de quem a le; o pt-BR e o de sempre.
+            throw new locale_1.ErroDoCatalogo((m) => m.decisao.rastroObrigatorio(campo));
         }
     }
 }
@@ -223,7 +267,7 @@ function registrarSeExiste(dirThread, threadId, tipo, dados = {}) {
         return null;
     let fd;
     try {
-        fd = fs.openSync(caminhoLedger(dirThread), fs.constants.O_WRONLY | fs.constants.O_APPEND);
+        fd = fs.openSync(caminhoLedger(dirThread), fs.constants.O_WRONLY | fs.constants.O_APPEND | fs.constants.O_NOFOLLOW);
     }
     catch (e) {
         if (e.code === 'ENOENT')

package/dist/licoes.js

@@ -58,6 +58,7 @@ const path = __importStar(require("node:path"));
 const estado_thread_1 = require("./estado-thread");
 const ledger_1 = require("./ledger");
 const policies_1 = require("./policies");
+const locale_1 = require("./locale");
 /** O que evita cada bloqueio, na forma de comando. Sem dica, a licao so conta a recorrencia. */
 exports.DICA_DO_MOTIVO = {
     'claims.failed': 'rode o comando da claim antes de registra-la; claim sem prova local volta como GO-FIX',
@@ -154,17 +155,16 @@ const curto = (t, teto) => (t.length > teto ? `${t.slice(0, teto - 3)}...` : t);
 function textoDasLicoes(r) {
     if (r.threads === 0 || (r.motivos.length === 0 && r.classes.length === 0 && r.recentes.length === 0))
         return '';
-    const linhas = [`Das ${r.threads} threads ja fechadas pelo MASTER neste produto:`];
+    const m = (0, locale_1.msg)().operacao.restante.licoes;
+    const linhas = [m.resumo(r.threads)];
     for (const m of r.motivos) {
-        linhas.push(`- o bloqueio ${m.nome} apareceu em ${m.threads.length} ${m.threads.length === 1 ? 'thread' : 'threads'}` +
-            (m.dica ? `; o que evita: ${m.dica}` : ''));
+        linhas.push((0, locale_1.msg)().operacao.restante.licoes.bloqueio(m.nome, m.threads.length, m.threads.length === 1 ? 'thread' : 'threads', m.dica));
     }
     for (const c of r.classes) {
-        linhas.push(`- a classe de falha ${c.nome} fechou ${c.threads.length} ${c.threads.length === 1 ? 'thread' : 'threads'}` +
-            (c.dica ? `; o que evita: ${c.dica}` : ''));
+        linhas.push(m.classe(c.nome, c.threads.length, c.threads.length === 1 ? 'thread' : 'threads', c.dica));
     }
     for (const l of r.recentes)
-        linhas.push(`- ${l.thread} fechou com ${l.score}/5: ${curto(l.justificativa, 160)}`);
+        linhas.push(m.nota(l.thread, l.score, curto(l.justificativa, 160)));
     return linhas.join('\n');
 }
 /** Janela e piso da recorrencia que vira proposta de policy. */
@@ -208,16 +208,17 @@ function registrarPropostasNovas(raiz, agoraIso = new Date().toISOString()) {
 }
 /** `ork licoes`: o que volta no proximo GOAL e PLAN, e as propostas de policy. */
 function textoDeLicoes(raiz, agoraIso = new Date().toISOString()) {
+    const m = (0, locale_1.msg)().operacao.restante.licoes;
     const resumo = resumoDasLicoes(raiz, null);
-    const linhas = ['Licoes que voltam no GOAL e no PLAN da proxima thread', ''];
-    linhas.push(textoDasLicoes(resumo) || 'Nenhuma thread fechada pelo MASTER ainda: nada a ensinar.');
+    const linhas = [m.titulo, ''];
+    linhas.push(textoDasLicoes(resumo) || m.nenhuma);
     const propostas = propostasDePolicy(raiz, agoraIso);
     linhas.push('');
-    linhas.push(`Propostas de policy (a mesma falha em ${exports.PISO_DA_PROPOSTA}+ threads nos ultimos ${exports.JANELA_DA_PROPOSTA_DIAS} dias):`);
+    linhas.push(m.propostas(exports.PISO_DA_PROPOSTA, exports.JANELA_DA_PROPOSTA_DIAS));
     if (propostas.length === 0)
-        linhas.push('  nenhuma');
+        linhas.push(m.propostaNenhuma);
     for (const p of propostas)
         linhas.push(`  ${p.chave} em ${p.threads.length} threads (${p.threads.slice(0, 5).join(', ')})`, `    ${p.sugestao}`);
-    linhas.push('', 'Proposta nao bloqueia nada: vira policy so quando o dono a declara em `policies:` no orkastery.yaml.');
+    linhas.push('', m.fecho);
     return linhas.join('\n');
 }

package/dist/liveness.js

@@ -46,6 +46,7 @@ const thread_1 = require("./thread");
 const ledger_1 = require("./ledger");
 const retry_1 = require("./retry");
 const util_1 = require("./util");
+const procedencia_1 = require("./procedencia");
 /**
  * Transcrição local do Claude. O UUID evita interpretar identificador como caminho.
  * I-33 (D4): `config` é o diretório já resolvido pelo perfil da sessão (ou o implícito, sem
@@ -70,8 +71,10 @@ function transcricaoClaude(sessionId, cwd, config) {
     }
     return undefined;
 }
-function fontesReais(t, d) {
-    const commit = t.worktree ? (0, util_1.exec)('git', ['log', '-1', '--format=%cI'], t.worktree) : null;
+function fontesReais(raiz, t, d) {
+    // RM-047 (P2): o git da prova de vida so roda na worktree registrada.
+    const wt = t.worktree ? (0, procedencia_1.cwdLocalOuNulo)(raiz, t.id, t.worktree, 'thread') : null;
+    const commit = wt ? (0, util_1.exec)('git', ['log', '-1', '--format=%cI'], wt) : null;
     const commitEm = commit?.ok ? commit.stdout.trim() : undefined;
     if (typeof d.sessionId !== 'string')
         return { commitEm };
@@ -157,7 +160,7 @@ function detectarFasesOrfas(carregado, opcoes = {}) {
                 incorporar(e.ts, e.tipo);
             }
         }
-        const fontes = (opcoes.fontes ?? fontesReais)(t, d);
+        const fontes = opcoes.fontes ? opcoes.fontes(t, d) : fontesReais(carregado.raiz, t, d);
         incorporar(fontes.commitEm, 'commit na worktree');
         const file = path.join(dir, 'liveness.json'), chave = `${d.ts}|${d.sessionId}`;
         let anterior = null;