@orkastery/cli 0.5.1 → 0.5.6

package/dist/indice-vetorial.js

@@ -56,13 +56,19 @@ exports.decodificarVetor = decodificarVetor;
 exports.lerIndice = lerIndice;
 exports.serializarIndice = serializarIndice;
 exports.gravarIndice = gravarIndice;
-exports.universoDoTenant = universoDoTenant;
+exports.conferirUniverso = conferirUniverso;
+exports.universoDaBusca = universoDaBusca;
+exports.codigoDaFalha = codigoDaFalha;
 exports.conteudoRecusado = conteudoRecusado;
+exports.indexavel = indexavel;
 exports.tokensEstimados = tokensEstimados;
 exports.dimDoModeloLocal = dimDoModeloLocal;
 exports.codigoDeEmbedding = codigoDeEmbedding;
 exports.espacoDoAlvo = espacoDoAlvo;
 exports.indexar = indexar;
+exports.avisoDeCobertura = avisoDeCobertura;
+exports.textoForaDaBusca = textoForaDaBusca;
+exports.textoDoIndice = textoDoIndice;
 exports.vetoresCoerentes = vetoresCoerentes;
 const fs = __importStar(require("node:fs"));
 const os = __importStar(require("node:os"));
@@ -170,18 +176,48 @@ function gravarIndice(arquivo, indice) {
     return true;
 }
 /**
- * Universo do tenant: o export governado das colecoes do ork (filtro de injecao e visibilidade
- * da biblioteca), com checagem EXPLICITA do tenant antes de qualquer texto ir ao embed.
+ * RM-038 (D6): a fronteira do universo no `ork`, num lugar so. Entrada de outro tenant, de colecao
+ * fora do ork ou com id repetido e violacao tipada, nunca descarte silencioso: nada disso vai ao embed.
  */
-function universoDoTenant(fonte, tenant, colecoes = orkmind_1.COLECOES_DO_ORK) {
-    return colecoes.flatMap(c => fonte.buscar({ collection: c, tags: { project: [tenant] } })
-        .filter(e => e.collection === c && (e.tags.project ?? []).includes(tenant)))
-        .sort((a, b) => a.collection.localeCompare(b.collection) || a.id.localeCompare(b.id));
+function conferirUniverso(entradas, tenant, lidoEm = Date.now()) {
+    const vistos = new Set();
+    for (const e of entradas) {
+        if (!(0, orkmind_1.pertenceAoUniverso)(e, tenant, lidoEm) || vistos.has(e.id))
+            throw new Error('memory.query.scope-violation');
+        vistos.add(e.id);
+    }
+}
+/**
+ * RM-038 (D4): o universo da busca e do indice, o domicilio unico. A fonte le uma vez (a ponte
+ * filtra o tenant na origem e aplica a governanca da biblioteca); aqui a fronteira e conferida de
+ * novo, a ordem fica estavel e a contagem por colecao sai pronta para o status e o index.
+ */
+function universoDaBusca(fonte, tenant) {
+    const lidoEm = Date.now();
+    const lido = fonte.universo(tenant);
+    conferirUniverso(lido.entradas, tenant, lidoEm);
+    const entradas = [...lido.entradas].sort((a, b) => a.collection.localeCompare(b.collection) || a.id.localeCompare(b.id));
+    const porColecao = Object.fromEntries(orkmind_1.COLECOES_DO_ORK.map(c => [c, 0]));
+    for (const e of entradas)
+        porColecao[e.collection] += 1;
+    return { tenant, lidoEm, entradas, porColecao, foraDaBusca: lido.foraDaBusca,
+        ...(lido.latenciaMs === undefined ? {} : { latenciaMs: lido.latenciaMs }) };
+}
+/** Codigo tipado de uma falha (`memory.query.window-saturated`), ou o padrao quando nao ha. */
+function codigoDaFalha(erro, padrao = 'memory.universo.indisponivel') {
+    return /^[a-z]+(?:\.[a-z-]+)+/.exec(erro instanceof Error ? erro.message : '')?.[0] ?? padrao;
 }
 /** Conteudo que nunca vai ao provider: padrao de segredo da policy ou URL com credencial. */
 function conteudoRecusado(conteudo) {
     return (0, policies_1.procurarSegredos)(conteudo).length > 0 || URL_COM_CREDENCIAL.test(conteudo);
 }
+/**
+ * RM-038: o indice embeda a entrada? Nao embeda texto vazio, acima do limite nem com padrao de
+ * segredo. Domicilio unico para o `indexar` e para o aviso de cobertura do status.
+ */
+function indexavel(e) {
+    return e.content.trim() !== '' && e.content.length <= orkmind_1.EMBED_MAX_CARACTERES && !conteudoRecusado(e.content);
+}
 function tokensEstimados(conteudo) {
     return Math.ceil(conteudo.length / exports.CARACTERES_POR_TOKEN);
 }
@@ -236,13 +272,20 @@ function espacoDoAlvo(config, alvo, env = process.env) {
  * que ja voltaram, porque cada vetor gravado e coerente por si.
  */
 function indexar(o) {
+    // RM-038 (D6): conferir de novo antes de qualquer coisa; nada de outro tenant vai ao embed, nem de
+    // um chamador que montou o universo a mao. Violacao falha alto, nunca vira descarte silencioso.
+    if (o.universo.tenant !== o.tenant)
+        throw new Error('memory.query.scope-violation');
+    conferirUniverso(o.universo.entradas, o.tenant, o.universo.lidoEm);
     const espaco = espacoDoAlvo(o.config, o.alvo, o.env);
-    const universo = o.universo.filter(e => (e.tags.project ?? []).includes(o.tenant));
+    const universo = o.universo.entradas;
     const foraDoLimite = universo.filter(e => e.content.length > orkmind_1.EMBED_MAX_CARACTERES);
     const recusados = universo.filter(e => e.content.length <= orkmind_1.EMBED_MAX_CARACTERES && conteudoRecusado(e.content));
-    const indexaveis = universo.filter(e => e.content.length <= orkmind_1.EMBED_MAX_CARACTERES && !conteudoRecusado(e.content) && e.content.trim());
+    const indexaveis = universo.filter(indexavel);
     const base = { alvo: o.alvo, modelo: null, dim: null, arquivo: null, dryRun: o.dryRun,
-        universo: universo.length, coerentes: 0, embedados: 0, reescritos: 0, removidos: 0, recusados: recusados.length,
+        universo: universo.length, porColecao: { ...o.universo.porColecao }, foraDaBusca: o.universo.foraDaBusca,
+        latenciaUniversoMs: o.universo.latenciaMs ?? null,
+        coerentes: 0, embedados: 0, reescritos: 0, removidos: 0, recusados: recusados.length,
         foraDoLimite: foraDoLimite.length, truncados: 0, tokensEstimados: 0, custoEstimadoUsd: 0, chamadasAoProvider: 0, motivo: null, detalhe: '' };
     if ('motivo' in espaco) {
         const tokens = indexaveis.reduce((t, e) => t + tokensEstimados(e.content), 0);
@@ -302,6 +345,40 @@ function indexar(o) {
         return { ...r, motivo, detalhe: `indexacao interrompida depois de ${r.embedados} vetor(es); os lotes concluidos ficaram gravados` };
     return r;
 }
+/**
+ * RM-038 (D7): o aviso de cobertura, o mesmo no status e na busca. Reindexar so e sugerido quando
+ * resolve; o que o indice nunca embeda (vazio, acima do limite, padrao de segredo) e dito a parte.
+ */
+function avisoDeCobertura(coerentes, entradas, alvo, onde = '') {
+    if (coerentes >= entradas.length)
+        return null;
+    const foraPorDesenho = entradas.filter(e => !indexavel(e)).length;
+    const base = `o indice cobre ${coerentes} de ${entradas.length} entrada(s) que a busca enxerga${onde}`;
+    if (coerentes < entradas.length - foraPorDesenho)
+        return `${base}: rode ork memory index${alvo === 'fallback' ? ' --modelo fallback' : ''}`;
+    return `${base}; ${foraPorDesenho} fica(m) fora do indice por desenho (vazia, acima de ${orkmind_1.EMBED_MAX_CARACTERES} caracteres ou com padrao de segredo)`;
+}
+/** RM-038: a linha do que fica fora da busca, a mesma no `ork memory index` e no `ork memory status`. */
+function textoForaDaBusca(f) {
+    return f ? `${f.injecao} com injection_risk e ${f.expiradas} expirada(s) (governanca da biblioteca), ` +
+        `${f.outrasColecoes} em outras colecoes (fora da busca do ork); nada disso vai ao embed` : 'nao medido nesta base';
+}
+/** Texto de `ork memory index`: de que universo, o que foi (ou seria) embedado e quanto custa estimado. */
+function textoDoIndice(r) {
+    const custo = r.custoEstimadoUsd === null ? 'nao estimado' : `US$ ${r.custoEstimadoUsd.toFixed(8)}`;
+    const colecoes = Object.entries(r.porColecao).map(([c, n]) => `${c} ${n}`).join(', ');
+    return [
+        `Indice vetorial (${r.alvo}${r.dryRun ? ', --dry-run' : ''}): ${r.modelo ?? '(sem modelo)'}${r.dim ? ` / ${r.dim} dim` : ''}`,
+        `  universo da busca    ${r.universo} entrada(s): ${colecoes}; coerentes ${r.coerentes}`,
+        `  fora da busca        ${textoForaDaBusca(r.foraDaBusca)}`,
+        `  embedados            ${r.embedados} (reescritos ${r.reescritos}); removidos ${r.removidos}`,
+        `  fora do indice       ${r.recusados} recusada(s) por padrao de segredo, ${r.foraDoLimite} acima do limite`,
+        ...(r.truncados ? [`  truncados            ${r.truncados} acima do contexto do modelo local, embedados pelo comeco`] : []),
+        `  estimativa           ${r.tokensEstimados} token(s), ${custo}; chamadas ao provider ${r.chamadasAoProvider}`,
+        ...(r.arquivo ? [`  arquivo              ${r.arquivo}`] : []),
+        ...(r.motivo ? [`  motivo               ${r.motivo}: ${r.detalhe}`] : r.detalhe ? [`  ${r.detalhe}`] : []),
+    ].join('\n');
+}
 /** Vetores coerentes de um indice para o universo informado: a base da busca e da cobertura. */
 function vetoresCoerentes(indice, universo) {
     const saida = new Map();

package/dist/indice.js

@@ -59,11 +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) {
-        const ocorrencias = eventos.filter((e) => e.tipo === insumo.evento).length;
+        // 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).
+        // 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

@@ -46,7 +46,9 @@ exports.baseBranchDetectada = baseBranchDetectada;
 exports.verifyDetectado = verifyDetectado;
 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");
@@ -54,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);
@@ -143,55 +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"
+${comentario(c.porThread)}
   por_thread: true
 
 verify:
@@ -200,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
@@ -259,7 +256,23 @@ policies:
   push_direto_na_base: block
 `;
 }
-/** Gera o manifesto e o esqueleto de `.orkastery/`. Nao sobrescreve sem `force`. */
+/**
+ * Ensaio de 03/10/2026 (RM-049): o `ork init` rodado por engano fora de um repositorio (no HOME, por
+ * exemplo) gravava manifesto, `AGENTS.md` e `.orkastery/` ali e saia 0; um repositorio criado depois
+ * dentro dessa pasta herdava o manifesto de fora, com outro nome e outra abbrev, e o doctor dizia PRONTO.
+ * A CLI recusa antes de gravar qualquer coisa. A funcao `init` segue aceitando qualquer pasta (demo e
+ * canarios montam o projeto por ela).
+ */
+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((0, locale_1.msg)().init.foraDoRepositorio(path.resolve(dir)));
+}
+/**
+ * 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);
@@ -267,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

@@ -16,4 +16,8 @@ exports.TESTES_DE_INTEGRACAO_LOCAL = new Set([
     'memory-publication-profile.test.js', 'native-fixture.test.js', 'orkmind-transport.test.js', 'verify-sandbox.test.js',
     // RM-037 (fatia 3): o worker do ork_git_commit e o sandbox do verify de verdade, como no mcp-git.test.js.
     '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',
 ]);