@orkastery/cli 0.5.3 → 0.5.6

package/dist/indice.js

@@ -59,13 +59,19 @@ exports.INSUMOS_DO_INDICE = [
  * reversao e `ship.ts`, que e quem sabe de merge e de base; aqui so se conta o evento
  * que ele gravou.
  */
+function pausaPrevistaDoFast(e) {
+    return e.tipo === ledger_1.TIPOS_DE_EVENTO.shipBloqueado && e.modo === 'fast' && e.motivo === 'human.pending';
+}
 function calcularIndice(eventos) {
     const parcelas = [];
     let valor = exports.INDICE_BASE;
     for (const insumo of exports.INSUMOS_DO_INDICE) {
         // Ensaio de 03/10/2026 (RM-049): o `ork ship --dry-run` barrado grava `ship_blocked` com `dryRun: true`;
         // ensaio nao e tropeco da entrega, como ja nao e pausa no board (fatia 2 do ensaio da 0.5.0, P2).
-        const ocorrencias = eventos.filter((e) => e.tipo === insumo.evento && e.dryRun !== true).length;
+        // EN8 (a), decisao do dono de 11/10/2026: no #Fast, o ship sem autorizacao de push e a pausa prevista
+        // do modo, e o `ship_blocked` com `human.pending` tambem nao conta.
+        const ocorrencias = eventos.filter((e) => e.tipo === insumo.evento && e.dryRun !== true &&
+            !pausaPrevistaDoFast(e)).length;
         if (ocorrencias === 0)
             continue;
         const bruto = insumo.peso * ocorrencias;

package/dist/init.js

@@ -48,6 +48,7 @@ exports.detectar = detectar;
 exports.manifestoYaml = manifestoYaml;
 exports.exigirRepositorioParaInit = exigirRepositorioParaInit;
 exports.init = init;
+const locale_1 = require("./locale");
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const manifest_1 = require("./manifest");
@@ -55,7 +56,8 @@ const slug_1 = require("./slug");
 const util_1 = require("./util");
 const horario_1 = require("./horario");
 const modos_1 = require("./modos");
-exports.PROXIMO_PASSO_INIT = 'Proximo passo: ork doctor; depois ork onboarding para conduzir a entrevista do projeto.';
+/** O proximo passo do `ork init` em pt-BR; o texto do CLI sai pelo catalogo (`msg().init.proximoPasso`). */
+exports.PROXIMO_PASSO_INIT = (0, locale_1.msg)('pt-BR').init.proximoPasso;
 /** Raiz do repositorio git, resolvendo tambem o caso de worktree. */
 function raizDoRepo(dirInicial) {
     const r = (0, util_1.exec)('git', ['rev-parse', '--show-toplevel'], dirInicial);
@@ -144,57 +146,57 @@ function detectar(dirInicial, nomeForcado, abbrevForcada) {
         verify: verifyDetectado(raiz),
     };
 }
-/** Serializa o manifesto v1 a partir da deteccao. */
-function manifestoYaml(d) {
-    const linhaVerify = (chave, valor) => valor ? `  ${chave}: "${valor}"` : `  # ${chave}: nao detectado`;
-    return `# Manifesto do Orkastery (v1, bloco B0)
-# Gerado por \`ork init\`. Fonte unica da configuracao do projeto.
-# Limite duro de 16 KB: prosa longa vai para a memoria com tag, nao para este arquivo.
+/** Cada linha do texto vira comentario do YAML, com o recuo da chave em que ele fica. */
+function comentario(texto, recuo = '  ') {
+    return texto.split('\n').map((linha) => `${recuo}# ${linha}`).join('\n');
+}
+/**
+ * Serializa o manifesto v1 a partir da deteccao. RM-061 (F3a, D1 a D3): os comentarios saem na lingua pedida, pela
+ * familia `gerados` do catalogo; chaves, valores e exemplos comentados sao este esqueleto, o mesmo nas duas linguas.
+ * Sem locale, pt-BR: so o `ork init` passa a lingua do dono (D2).
+ */
+function manifestoYaml(d, locale = locale_1.LOCALE_PADRAO) {
+    const c = (0, locale_1.msg)(locale).gerados.manifesto;
+    const linhaVerify = (chave, valor) => valor ? `  ${chave}: "${valor}"` : `  # ${chave}: ${c.naoDetectado}`;
+    return `${comentario(c.cabecalho, '')}
 
 project:
   name: "${d.nome}"
-  # abbrev: ate 3 caracteres [a-z0-9], parte 1 do slug de sessao, unica no workspace
+${comentario(c.abbrev)}
   abbrev: "${d.abbrev}"
   stage: nascente
 
 owner:
-  # fuso do dono (nome IANA): todo horario mostrado a pessoas usa este fuso.
-  # Ausente: fuso do sistema. Exemplo:
+${comentario(c.fuso)}
   # timezone: "${horario_1.FUSO_DE_BRASILIA}"
-  # Preferências: ork onboarding set maestro --conteudo '{"owner":{"experience":true}}'
-  # language: pt-BR  # ausente: locale do sistema
+${comentario(c.preferencias(`ork onboarding set maestro --conteudo '{"owner":{"experience":true}}'`))}
+  # language: ${c.exemploDeIdioma}  # ${c.idiomaAusente}
   # depth: curta    # curta | detalhada
-  # experience: true  # false desativa o pacote na próxima instalação do adaptador
+  # experience: true  # ${c.experienciaFalse}
 
 board:
   adapter: hermes-kanban
   default: default
 
 runtime:
-  # Runtimes homologados:
-  #   claude-bg (padrao, mais maduro): despacha \`claude --bg\`, sessao visivel no app
-  #             e em \`claude agents --json\`
-  #   codex: despacha \`codex exec\` headless na sessao autenticada do Codex CLI,
-  #          verificado no rollout de $CODEX_HOME/sessions (requer \`codex login\`)
+${comentario(c.runtimes)}
   adapter: claude-bg
   model: opus
   effort: high
-  # subscription-only: proibido despachar por provider pago (cobra por token, fora da assinatura)
+${comentario(c.providerPolicy)}
   provider_policy: subscription-only
-  # sandbox do runtime codex: read-only | workspace-write | danger-full-access
-  # (danger-full-access SO onde o bubblewrap nao roda; \`ork doctor\` tem a sonda)
+${comentario(c.sandbox)}
   sandbox: workspace-write
 
 conduction:
-  # modo usado quando o pedido do builder nao traz #TAG
+${comentario(c.modoPadrao)}
   default_mode: classic
   allowed_modes: [${modos_1.ORDEM_DOS_MODOS.join(', ')}]
 
 worktree:
   base_branch: "${d.baseBranch}"
   dir: ".claude/worktrees"
-  # true: o ork thread new cria a worktree e a branch da thread sem flag (--sem-worktree cria sem);
-  # false ou ausente: só com --worktree auto
+${comentario(c.porThread)}
   por_thread: true
 
 verify:
@@ -203,54 +205,46 @@ ${linhaVerify('test', d.verify.test)}
 ${linhaVerify('typecheck', d.verify.typecheck)}
 
 ci:
-  # Ative depois de publicar o workflow e tornar ork-verify um check obrigatório.
+${comentario(c.ci)}
   required_for_ship: false
   context: ork-verify
-  # command: "npm test" # perfil hermético opcional do runner; sem ele, usa verify acima
+  # command: "npm test" # ${c.ciComando}
 
 concurrency:
   max_parallel_threads: 3
-  # thread despachada sem atividade (ledger parado, sessao nao-working) por mais que
-  # isto NAO ocupa vaga do escalonador: a vaga volta para quem esta pronto para rodar
+${comentario(c.staleAfter)}
   stale_after_min: 240
 
 handoff:
-  # gate de tokens (bloco B1): rotaciona a sessao acima destas ocupacoes de janela
+${comentario(c.handoff)}
   rotate_above: 0.70
   force_rotate_above: 0.85
 
 retry:
-  # autonomia do bloco B3: retry tipado por motivo de gate e fila duravel de rate limit
-  # max_tentativas e o LIMITE DE ESCALACAO: estourado, pausa qualquer modo, ate #Auto
+${comentario(c.retry)}
   max_tentativas: 3
-  # janela usada so quando o runtime diz "rate limit" e NAO diz a hora do reset
-  # (fica marcada como estimativa na fila; o ork nunca inventa horario medido)
+${comentario(c.janelaPadrao)}
   janela_padrao_min: 60
   escalar_esforco: true
 
 memory:
-  # files = fallback honesto sem OrkMind (handoff por arquivos, ponteiro path#ancora)
-  # orkmind = camada semantica do bloco B6 por cima, com degradacao honesta para files
+${comentario(c.memoriaModo)}
   mode: files
-  # NOME da variavel de ambiente com a DSN da base PROPRIA deste tenant, nunca a DSN.
-  # Vazio = o regime orkmind nao liga (o ork nao adivinha base: base alheia e pior que
-  # base nenhuma, precedente do incidente memory-orkmind).
+${comentario(c.databaseUrl)}
   database_url_env: ""
   cli: orkmind
   timeout_ms: 15000
-  # busca por significado (ork memory search --texto): sem o bloco, provider none (desligada).
-  # api_key_env recebe o NOME da variavel com a chave dedicada, nunca o valor.
+${comentario(c.embedding)}
   # embedding:
   #   provider: "none"            # none | openrouter
   #   model: "qwen/qwen3-embedding-8b"
   #   dim: 1024
   #   api_key_env: "ORKASTERY_EMBEDDING_API_KEY"
-  #   fallback_model: ""          # modelo local offline, ex.: intfloat/multilingual-e5-small
+  #   fallback_model: ""          # ${c.modeloOffline}
   #   max_tokens_por_execucao: 1000000
 
 audit:
-  # governanca de custo dos auditores periodicos (bloco B5)
-  # janela ociosa da assinatura: fora dela a rodada so anda com --agora <quem>
+${comentario(c.audit)}
   janela_ociosa: "22:00-06:00"
   effort: eco
   since_padrao: 7d
@@ -273,10 +267,12 @@ function exigirRepositorioParaInit(dir) {
     const r = (0, util_1.exec)('git', ['rev-parse', '--is-inside-work-tree'], dir);
     if (r.ok && r.stdout.trim() === 'true')
         return;
-    throw new Error(`init.fora-do-repositorio: ${path.resolve(dir)} não está num repositório git; nada foi criado. ` +
-        'Entre no repositório do projeto (ou crie um com git init e o primeiro commit) e rode ork init de novo.');
+    throw new Error((0, locale_1.msg)().init.foraDoRepositorio(path.resolve(dir)));
 }
-/** Gera o manifesto e o esqueleto de `.orkastery/`. Nao sobrescreve sem `force`. */
+/**
+ * Gera o manifesto e o esqueleto de `.orkastery/`. Nao sobrescreve sem `force`. Os comentarios do manifesto saem
+ * no `locale` pedido (RM-061, F3a), pt-BR por omissao.
+ */
 function init(dirInicial, opcoes = {}) {
     const deteccao = detectar(dirInicial, opcoes.nome, opcoes.abbrev);
     const caminho = path.join(deteccao.raiz, manifest_1.NOME_MANIFESTO);
@@ -284,7 +280,7 @@ function init(dirInicial, opcoes = {}) {
     if (existe && !opcoes.force) {
         return { caminho, criado: false, deteccao };
     }
-    (0, util_1.gravar)(caminho, manifestoYaml(deteccao));
+    (0, util_1.gravar)(caminho, manifestoYaml(deteccao, opcoes.locale));
     const estado = path.join(deteccao.raiz, manifest_1.DIR_ESTADO);
     fs.mkdirSync(path.join(estado, 'threads'), { recursive: true });
     // Fatia 2 do ensaio da 0.5.0 (P3): o estado e da maquina; fica fora do git sem mexer no `.gitignore` do usuario.

package/dist/instabilidade.js

@@ -0,0 +1,144 @@
+"use strict";
+/**
+ * RM-037 (fatia 6, P6/T15): o registro de instabilidade, contrato `ork.instabilidade/v1`.
+ *
+ * Arquivo `core/instabilidade.json` na arvore verificada. Nasce vazio. Uma entrada diz que um teste
+ * depende do relogio e por isso reprova sob steal alto; ela so entra com a taxa MEDIDA (falhas em
+ * rodadas, com o comando que mediu e a data) e com revalidacao em ate 30 dias da medida. Vencida a
+ * revalidacao, a entrada deixa de valer ate alguem medir de novo.
+ *
+ * O registro nunca atenua uma falha sozinho: ele so diz ao verify que aquele teste e de relogio, e
+ * a reprovacao so vira `verify.timeout` com o steal medido acima de 40% na janela do comando. Sem
+ * steal, o teste registrado reprova como qualquer outro.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CAUSAS_DE_INSTABILIDADE = exports.REVALIDACAO_MAXIMA_DIAS = exports.ARQUIVO_INSTABILIDADE = exports.CONTRATO_INSTABILIDADE = void 0;
+exports.validarRegistro = validarRegistro;
+exports.vigente = vigente;
+exports.lerRegistroDeInstabilidade = lerRegistroDeInstabilidade;
+exports.testesDeRelogioVigentes = testesDeRelogioVigentes;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+exports.CONTRATO_INSTABILIDADE = 'ork.instabilidade/v1';
+exports.ARQUIVO_INSTABILIDADE = 'core/instabilidade.json';
+/** Prazo maximo entre a medida e a revalidacao. */
+exports.REVALIDACAO_MAXIMA_DIAS = 30;
+exports.CAUSAS_DE_INSTABILIDADE = ['relogio'];
+const DIA_MS = 24 * 60 * 60 * 1000;
+const CHAVES_DA_ENTRADA = new Set(['teste', 'arquivo', 'causa', 'taxa', 'revalidarAte', 'nota']);
+const CHAVES_DA_TAXA = new Set(['falhas', 'rodadas', 'comando', 'medidaEm']);
+function data(valor) {
+    if (typeof valor !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(valor))
+        return null;
+    const ms = Date.parse(`${valor}T00:00:00Z`);
+    return Number.isFinite(ms) && new Date(ms).toISOString().slice(0, 10) === valor ? ms : null;
+}
+const texto = (v) => typeof v === 'string' && v.trim() !== '';
+const inteiro = (v) => typeof v === 'number' && Number.isInteger(v);
+/** Os erros de contrato de um registro ja desserializado. Lista vazia: o registro vale. */
+function validarRegistro(bruto) {
+    const erros = [];
+    if (!bruto || typeof bruto !== 'object' || Array.isArray(bruto))
+        return ['o registro precisa ser um objeto JSON'];
+    const r = bruto;
+    if (r.contrato !== exports.CONTRATO_INSTABILIDADE)
+        erros.push(`contrato precisa ser "${exports.CONTRATO_INSTABILIDADE}"`);
+    for (const chave of Object.keys(r)) {
+        if (chave !== 'contrato' && chave !== 'entradas')
+            erros.push(`chave desconhecida no registro: ${chave}`);
+    }
+    if (!Array.isArray(r.entradas))
+        return [...erros, 'entradas precisa ser uma lista (vazia no nascimento)'];
+    const vistos = new Set();
+    r.entradas.forEach((e, i) => {
+        const onde = `entradas[${i}]`;
+        if (!e || typeof e !== 'object' || Array.isArray(e)) {
+            erros.push(`${onde}: precisa ser um objeto`);
+            return;
+        }
+        const entrada = e;
+        for (const chave of Object.keys(entrada)) {
+            if (!CHAVES_DA_ENTRADA.has(chave))
+                erros.push(`${onde}: chave desconhecida ${chave}`);
+        }
+        if (!texto(entrada.teste))
+            erros.push(`${onde}.teste: nome do teste como o runner reporta`);
+        else if (vistos.has(entrada.teste))
+            erros.push(`${onde}.teste: "${entrada.teste}" repetido`);
+        else
+            vistos.add(entrada.teste);
+        if (!texto(entrada.arquivo))
+            erros.push(`${onde}.arquivo: caminho do teste`);
+        if (!exports.CAUSAS_DE_INSTABILIDADE.includes(entrada.causa)) {
+            erros.push(`${onde}.causa: ${exports.CAUSAS_DE_INSTABILIDADE.join(' ou ')}`);
+        }
+        if (entrada.nota !== undefined && typeof entrada.nota !== 'string')
+            erros.push(`${onde}.nota: texto`);
+        const taxa = entrada.taxa;
+        let medida = null;
+        if (!taxa || typeof taxa !== 'object' || Array.isArray(taxa)) {
+            erros.push(`${onde}.taxa: sem taxa medida a entrada nao entra (falhas, rodadas, comando, medidaEm)`);
+        }
+        else {
+            for (const chave of Object.keys(taxa)) {
+                if (!CHAVES_DA_TAXA.has(chave))
+                    erros.push(`${onde}.taxa: chave desconhecida ${chave}`);
+            }
+            if (!inteiro(taxa.rodadas) || taxa.rodadas < 1)
+                erros.push(`${onde}.taxa.rodadas: inteiro de rodadas medidas, 1 ou mais`);
+            if (!inteiro(taxa.falhas) || taxa.falhas < 1)
+                erros.push(`${onde}.taxa.falhas: inteiro de reprovacoes medidas, 1 ou mais`);
+            else if (inteiro(taxa.rodadas) && taxa.falhas > taxa.rodadas)
+                erros.push(`${onde}.taxa.falhas: maior que rodadas`);
+            if (!texto(taxa.comando))
+                erros.push(`${onde}.taxa.comando: o comando que mediu, reproduzivel`);
+            medida = data(taxa.medidaEm);
+            if (medida === null)
+                erros.push(`${onde}.taxa.medidaEm: data AAAA-MM-DD valida`);
+        }
+        const revalidar = data(entrada.revalidarAte);
+        if (revalidar === null)
+            erros.push(`${onde}.revalidarAte: data AAAA-MM-DD valida`);
+        else if (medida !== null) {
+            if (revalidar < medida)
+                erros.push(`${onde}.revalidarAte: antes da medida`);
+            else if (revalidar - medida > exports.REVALIDACAO_MAXIMA_DIAS * DIA_MS) {
+                erros.push(`${onde}.revalidarAte: no maximo ${exports.REVALIDACAO_MAXIMA_DIAS} dias depois de taxa.medidaEm`);
+            }
+        }
+    });
+    return erros;
+}
+/** A entrada vale hoje? Vale ate o fim do dia de `revalidarAte`, em UTC. */
+function vigente(entrada, agoraMs = Date.now()) {
+    const ate = data(entrada.revalidarAte);
+    return ate !== null && agoraMs < ate + DIA_MS;
+}
+/** Le o registro da arvore `cwd`. Ausente: vazio. Ilegivel ou fora do contrato: erros e nada vale. */
+function lerRegistroDeInstabilidade(cwd, agoraMs = Date.now()) {
+    const arquivo = (0, node_path_1.join)(cwd, exports.ARQUIVO_INSTABILIDADE);
+    if (!(0, node_fs_1.existsSync)(arquivo))
+        return { arquivo: exports.ARQUIVO_INSTABILIDADE, presente: false, erros: [], vigentes: [], vencidas: [] };
+    let bruto;
+    try {
+        bruto = JSON.parse((0, node_fs_1.readFileSync)(arquivo, 'utf8'));
+    }
+    catch (e) {
+        return { arquivo: exports.ARQUIVO_INSTABILIDADE, presente: true, erros: [`JSON ilegivel: ${e.message}`], vigentes: [], vencidas: [] };
+    }
+    const erros = validarRegistro(bruto);
+    if (erros.length > 0)
+        return { arquivo: exports.ARQUIVO_INSTABILIDADE, presente: true, erros, vigentes: [], vencidas: [] };
+    const entradas = bruto.entradas;
+    return {
+        arquivo: exports.ARQUIVO_INSTABILIDADE,
+        presente: true,
+        erros: [],
+        vigentes: entradas.filter((e) => vigente(e, agoraMs)),
+        vencidas: entradas.filter((e) => !vigente(e, agoraMs)),
+    };
+}
+/** Os nomes dos testes de relogio que o verify pode considerar nesta rodada. */
+function testesDeRelogioVigentes(registro) {
+    return new Set(registro.vigentes.filter((e) => e.causa === 'relogio').map((e) => e.teste));
+}

package/dist/integracoes-locais.js

@@ -18,4 +18,6 @@ exports.TESTES_DE_INTEGRACAO_LOCAL = new Set([
     'rm037-fatia3-hard-link-mcp-git.test.js', 'rm037-fatia3-lease-mcp-git.test.js',
     // RM-038 (fatia de correcao): a ponte com o GovernedStore real da biblioteca instalada.
     'rm038-universo-ponte.test.js',
+    // RM-059 (T0.10): a conferencia pontual com o sandbox real do codex, como o mcp-verify.test.js.
+    'claims-conferir-sandbox.test.js',
 ]);

package/dist/intelligence-graph-cli.js

@@ -33,11 +33,12 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CORRECAO_DO_INDICE = exports.USO_DO_GRAFO = exports.AMOSTRA_SCHEMA = exports.STATUS_SCHEMA = void 0;
+exports.CORRECAO_DO_INDICE = exports.USO_DO_GRAFO = exports.AMOSTRA_SCHEMA = exports.REDACAO_DOS_ANALISADORES = exports.STATUS_SCHEMA = void 0;
 exports.descreverVersoes = descreverVersoes;
 exports.correcaoDosAnalisadores = correcaoDosAnalisadores;
 exports.checarAnalisadoresDoGrafo = checarAnalisadoresDoGrafo;
 exports.lerPedido = lerPedido;
+exports.situacaoNaArvore = situacaoNaArvore;
 exports.executarGrafo = executarGrafo;
 /**
  * RM-031 KG3 (D7, D8): `ork grafo`, o CLI do indice e da consulta do grafo de codigo.
@@ -78,17 +79,21 @@ const RECUSA_DOS_ANALISADORES = 'grafo.parser.indisponivel';
  * de `MODULOS_DO_EXTRATOR`, para a redacao nao entrar na chave do indice; a versao vem de quem chama
  * (o `index.ts`), porque o CLI do grafo so importa a propria familia (fronteira do KG3).
  */
-function correcaoDosAnalisadores(motivo, versao) {
-    if (/ERR_REQUIRE_ESM/.test(motivo)) {
-        return `o micromark e so ESM, e este Node (${process.version}) nao o carrega por require: use Node 20.19, 22.12 ou mais novo, ` +
-            'sem a opcao --no-experimental-require-module (na linha de comando ou no NODE_OPTIONS)';
-    }
+function correcaoDosAnalisadores(motivo, versao, redacao = exports.REDACAO_DOS_ANALISADORES) {
+    if (/ERR_REQUIRE_ESM/.test(motivo))
+        return redacao.soEsm(process.version);
     // Sem a versao do pacote (`0.0.0-desconhecida` quando o package.json dele nao e achado), o comando
     // sai sem `@<versao>` e o npm instala a ultima publicada.
     const fixada = versao && /^\d+\.\d+\.\d+/.test(versao) && !versao.startsWith('0.0.0') ? `@${versao}` : '';
-    return `reinstale o ork global, que traz os analisadores como dependencias: npm install -g @orkastery/cli${fixada}` +
-        ' (instalado dentro de um projeto ou pelo npx, o npm deixa os analisadores fora do pacote do ork, e o grafo os recusa)';
+    return redacao.reinstale(fixada);
 }
+exports.REDACAO_DOS_ANALISADORES = {
+    recusa: (motivo) => `${motivo}: o ork grafo indexar recusa nesta instalacao, e sem o indice as consultas e as tools ork_grafo_* tambem`,
+    soEsm: (versaoDoNode) => `o micromark e so ESM, e este Node (${versaoDoNode}) nao o carrega por require: use Node 20.19, 22.12 ou mais novo, ` +
+        'sem a opcao --no-experimental-require-module (na linha de comando ou no NODE_OPTIONS)',
+    reinstale: (fixada) => `reinstale o ork global, que traz os analisadores como dependencias: npm install -g @orkastery/cli${fixada}` +
+        ' (instalado dentro de um projeto ou pelo npx, o npm deixa os analisadores fora do pacote do ork, e o grafo os recusa)',
+};
 /**
  * RM-031 (pacote do npm): o check "analisadores do grafo" do `ork doctor`. Carrega o que o
  * `ork grafo indexar` carrega (`carregarAnalisadores`), entao diz o que o indexar faria, inclusive no
@@ -96,7 +101,7 @@ function correcaoDosAnalisadores(motivo, versao) {
  * fase. Fora da familia do grafo so o `index.ts` e o worker do MCP a abrem (fronteira do KG1), entao o
  * `index.ts` passa este check ao doctor, que nao importa o grafo.
  */
-function checarAnalisadoresDoGrafo(versao, carregar = intelligence_graph_parsers_1.carregarAnalisadores, versoes = intelligence_graph_parsers_1.versoesDosAnalisadores) {
+function checarAnalisadoresDoGrafo(versao, carregar = intelligence_graph_parsers_1.carregarAnalisadores, versoes = intelligence_graph_parsers_1.versoesDosAnalisadores, redacao = exports.REDACAO_DOS_ANALISADORES) {
     const nome = 'analisadores do grafo';
     try {
         carregar();
@@ -104,9 +109,7 @@ function checarAnalisadoresDoGrafo(versao, carregar = intelligence_graph_parsers
     }
     catch (e) {
         const motivo = e.message;
-        return { nome, nivel: 'warn',
-            detalhe: `${motivo}: o ork grafo indexar recusa nesta instalacao, e sem o indice as consultas e as tools ork_grafo_* tambem`,
-            correcao: correcaoDosAnalisadores(motivo, versao) };
+        return { nome, nivel: 'warn', detalhe: redacao.recusa(motivo), correcao: correcaoDosAnalisadores(motivo, versao, redacao) };
     }
 }
 /** O mesmo schema da amostra do KG2: as amostras auditadas continuam validas. */
@@ -366,7 +369,10 @@ function semIndiceDoHead(ctx, original) {
     }
     throw original;
 }
-/** O indice do HEAD pronto para consulta, com a concessao local e o cabecalho; `grafo` ja vem filtrado por ela. */
+/**
+ * O indice do HEAD pronto para consulta, com a concessao local e o cabecalho; `grafo` ja vem filtrado por ela.
+ * KG5 fatia 5 (D3): `situacao` so le a arvore quando o cabecalho diz `modificada`; limpa, tudo vale `igual`.
+ */
 function consultavel(ctx) {
     let doHead;
     try {
@@ -385,7 +391,8 @@ function consultavel(ctx) {
         arvore: arvore.motivo === null ? 'limpa' : 'modificada',
         extratores: grafo.snapshot.extractors.map((e) => ({ extractor_id: e.extractor_id, extractor_version: e.extractor_version })),
     };
-    return { g: (0, intelligence_graph_query_1.prepararConsulta)(grafo, concessao), cabecalho, grafo, raiz: arvore.raiz };
+    const situacao = cabecalho.arvore === 'limpa' ? intelligence_graph_query_1.TUDO_IGUAL : situacaoNaArvore(arvore.raiz, grafo.snapshot.source_manifest);
+    return { g: (0, intelligence_graph_query_1.prepararConsulta)(grafo, concessao), cabecalho, grafo, raiz: arvore.raiz, situacao };
 }
 function responder(ctx, p, r) {
     ctx.escrever(p.bandeiras.has('json') ? (0, intelligence_graph_query_1.jsonDaResposta)(r) : (0, intelligence_graph_query_1.textoDaResposta)(r));
@@ -430,15 +437,16 @@ function consultar(ctx, p) {
     // As opcoes sao conferidas antes de carregar o indice: erro de uso nao custa a leitura do grafo.
     const [a, b] = p.posicionais;
     const profundidade = inteiro(p, 'profundidade'), limite = inteiro(p, 'limite'), s = sentido(p), t = tipos(p), teto = tetoDeBytes(p);
-    const { g, cabecalho } = consultavel(ctx);
+    const { g, cabecalho, situacao } = consultavel(ctx);
+    // A busca binaria do teto pergunta de novo com outro limite; a situacao guarda o que ja leu da arvore.
     const perguntar = (lim) => {
         if (p.sub === 'vizinhos')
-            return (0, intelligence_graph_query_1.vizinhos)(g, cabecalho, a, { profundidade, limite: lim, sentido: s, tipos: t });
+            return (0, intelligence_graph_query_1.vizinhos)(g, cabecalho, a, { profundidade, limite: lim, sentido: s, tipos: t }, situacao);
         if (p.sub === 'chamadores')
-            return (0, intelligence_graph_query_1.chamadores)(g, cabecalho, a, { profundidade, limite: lim });
+            return (0, intelligence_graph_query_1.chamadores)(g, cabecalho, a, { profundidade, limite: lim }, situacao);
         if (p.sub === 'importadores')
-            return (0, intelligence_graph_query_1.importadores)(g, cabecalho, a, { profundidade, limite: lim });
-        return (0, intelligence_graph_query_1.caminho)(g, cabecalho, a, b, { sentido: s, tipos: t });
+            return (0, intelligence_graph_query_1.importadores)(g, cabecalho, a, { profundidade, limite: lim }, situacao);
+        return (0, intelligence_graph_query_1.caminho)(g, cabecalho, a, b, { sentido: s, tipos: t }, situacao);
     };
     if (teto === undefined)
         return responder(ctx, p, perguntar(limite));
@@ -452,18 +460,21 @@ function contexto(ctx, p) {
     if (!ctx.contextoDaThread)
         throw new intelligence_graph_query_1.ErroDeConsulta('grafo.contexto.indisponivel', 'borda sem leitor da thread');
     const lido = ctx.contextoDaThread(p.posicionais[0]);
-    const { grafo, cabecalho } = consultavel({ ...ctx, raiz: lido.raiz });
+    const { grafo, cabecalho, situacao } = consultavel({ ...ctx, raiz: lido.raiz });
     if (lido.head !== cabecalho.revision)
         throw new intelligence_graph_query_1.ErroDeConsulta('grafo.contexto.revisao-mudou', 'HEAD mudou durante a leitura; repita a consulta');
-    const json = (0, intelligence_graph_contexto_1.pacoteDeContexto)(grafo, cabecalho, lido.entrada, teto);
+    const json = (0, intelligence_graph_contexto_1.pacoteDeContexto)(grafo, cabecalho, lido.entrada, teto, situacao);
     if (p.bandeiras.has('json'))
         ctx.escrever(json);
     else {
         const r = JSON.parse(json);
+        // KG5 fatia 5 (D9): o resumo conta as ligacoes cuja fonte mudou na arvore, como o JSON marca.
+        const mudadas = r.arestas.filter((a) => a.arvore === 'modificada').length;
         ctx.escrever([`Contexto ${r.thread} @ ${r.indice.revision}`,
             `  ${r.sementes.length}/${r.total_sementes} sementes, ${r.arestas.length}/${r.total_ligacoes} ligacoes agregadas; ${r.medida.pacote_bytes} bytes JSON`,
             `  tamanho dos arquivos no pacote (nao descoberta): ${r.medida.leitura_crua_bytes} bytes (revisao indexada); tokens: unavailable`,
             `  diff: ${r.fontes.diff}`,
+            ...(mudadas ? [`  ligacoes com fonte modificada na arvore: ${mudadas}`] : []),
             `  truncado: ${r.truncado}; arvore: ${r.indice.arvore}; use --json para nos e evidencias`, json].join('\n'));
     }
     return 0;
@@ -507,6 +518,66 @@ function leitorDaArvore(raiz, grafo) {
         return bytes;
     };
 }
+/**
+ * KG5 fatia 5 (D3, D6): a situacao de cada fonte do indice na arvore, pelos bytes. So caminho do manifesto;
+ * sem seguir link, nem no ultimo nome nem numa pasta do caminho: o caminho real tem de ser o proprio caminho
+ * indexado dentro da raiz (CHECK rodada 1, A1). So arquivo regular; tamanho diferente do indexado e
+ * `modificada` sem ler, e o sha256 dos bytes decide o resto, lidos ate o tamanho indexado mais um. O arquivo
+ * aberto tem de ser o mesmo do `lstat` (dispositivo e inode, CHECK rodada 1, S3): troca entre a conferencia e
+ * a abertura vira `ausente`; duas trocas no intervalo ainda passam, e revelariam so se os bytes sao os
+ * indexados. Qualquer falha e `ausente`: nao ha arquivo regular legivel no caminho. Cada caminho e lido uma
+ * vez, sob demanda, e nada e escrito.
+ */
+function situacaoNaArvore(raiz, manifesto) {
+    const porCaminho = new Map(manifesto.map((m) => [m.path, m]));
+    const vistas = new Map();
+    let raizReal = null;
+    const ler = (p) => {
+        const m = porCaminho.get(p);
+        if (!m)
+            return 'ausente';
+        const absoluto = path.join(raiz, p);
+        try {
+            raizReal ??= fs.realpathSync(raiz);
+            const st = fs.lstatSync(absoluto, { throwIfNoEntry: false });
+            if (!st || !st.isFile())
+                return 'ausente';
+            // CHECK rodada 2 (R2-S1): caminho de manifesto adulterado com `..` coincidiria com o real fora da raiz.
+            const real = fs.realpathSync(absoluto);
+            if (real !== path.join(raizReal, p) || !real.startsWith(raizReal + path.sep))
+                return 'ausente';
+            if (st.size !== m.size_bytes)
+                return 'modificada';
+            const fd = fs.openSync(absoluto, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+            try {
+                const aberto = fs.fstatSync(fd);
+                if (!aberto.isFile() || aberto.dev !== st.dev || aberto.ino !== st.ino)
+                    return 'ausente';
+                if (aberto.size !== m.size_bytes)
+                    return 'modificada';
+                const bytes = Buffer.alloc(m.size_bytes + 1);
+                let lidos = 0;
+                for (let n = 1; n > 0 && lidos < bytes.length; lidos += n)
+                    n = fs.readSync(fd, bytes, lidos, bytes.length - lidos, null);
+                return lidos === m.size_bytes && sha256(bytes.subarray(0, lidos)) === m.source_hash ? 'igual' : 'modificada';
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+        }
+        catch {
+            return 'ausente';
+        }
+    };
+    return (p) => {
+        const vista = vistas.get(p);
+        if (vista !== undefined)
+            return vista;
+        const s = ler(p);
+        vistas.set(p, s);
+        return s;
+    };
+}
 const localizadorDe = (g) => new Map(g.nodes.map((n) => [n.node_id, { kind: n.kind, path: n.locator.path, fragment: n.locator.fragment }]));
 const rotulo = (l) => `${l.kind}:${l.path}${l.fragment === null ? '' : `#${l.fragment}`}`;
 const chaveDaAresta = (kind, de, para) => `${kind} ${rotulo(de)} -> ${rotulo(para)}`;