@orkastery/cli 0.5.3 → 0.6.0

package/dist/indice-vetorial.js

@@ -77,6 +77,7 @@ const node_crypto_1 = require("node:crypto");
 const estado_thread_1 = require("./estado-thread");
 const orkmind_1 = require("./orkmind");
 const policies_1 = require("./policies");
+const locale_1 = require("./locale");
 exports.CONTRATO_INDICE = 'ork.indice-vetorial/v1';
 /** D11: lote por chamada da ponte na indexacao. */
 exports.TAMANHO_DO_LOTE = 16;
@@ -360,23 +361,24 @@ function avisoDeCobertura(coerentes, entradas, alvo, onde = '') {
 }
 /** 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';
+    const m = (0, locale_1.msg)().operacao.restante.memory.indice;
+    return f ? m.foraMedido(f.injecao, f.expiradas, f.outrasColecoes) : m.foraNaoMedido;
 }
 /** 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 m = (0, locale_1.msg)().operacao.restante.memory.indice;
+    const custo = r.custoEstimadoUsd === null ? m.custoNaoEstimado : `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}`] : []),
+        m.titulo(r.alvo, r.dryRun, r.modelo ?? m.semModelo, r.dim),
+        m.universo(r.universo, colecoes, r.coerentes),
+        m.fora(textoForaDaBusca(r.foraDaBusca)),
+        m.embedados(r.embedados, r.reescritos, r.removidos),
+        m.recusados(r.recusados, r.foraDoLimite),
+        ...(r.truncados ? [m.truncados(r.truncados)] : []),
+        m.estimativa(r.tokensEstimados, custo, r.chamadasAoProvider),
+        ...(r.arquivo ? [m.arquivo(r.arquivo)] : []),
+        ...(r.motivo ? [m.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. */

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,9 @@ 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.';
+const detect_1 = require("./security-scan/detect");
+/** 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);
@@ -142,115 +145,112 @@ function detectar(dirInicial, nomeForcado, abbrevForcada) {
         baseBranch: baseBranchDetectada(raiz),
         gerenciador: gerenciadorDetectado(raiz),
         verify: verifyDetectado(raiz),
+        stacks: [...new Set((0, detect_1.detectStacks)(raiz).map((e) => e.stack))],
     };
 }
-/** 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:
 ${linhaVerify('build', d.verify.build)}
 ${linhaVerify('test', d.verify.test)}
 ${linhaVerify('typecheck', d.verify.typecheck)}
+${comentario(c.securityScan)}
+  ${d.stacks.length > 0 ? '' : '# '}security_scan: "ork security-scan"
+  ${d.stacks.length > 0 ? '' : '# '}timeout_ms_por_comando:
+  ${d.stacks.length > 0 ? '' : '# '}  security_scan: 900000
 
 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 +273,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,9 +286,12 @@ 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.
-    return { caminho, criado: true, deteccao, estadoIgnorado: (0, util_1.ignorarPastaNoGit)(estado, deteccao.raiz) };
+    // RM-061 F3c: so o arquivo do estado criado pelo `init` segue a lingua pedida. O `*` e a protecao
+    // contra sobrescrita continuam no util; a pasta de worktrees preserva o default historico.
+    const locale = opcoes.locale ?? locale_1.LOCALE_PADRAO;
+    const gitignore = `# ${(0, locale_1.msg)(locale).gerados.gitignoreDaMaquina}\n*\n`;
+    return { caminho, criado: true, deteccao, estadoIgnorado: (0, util_1.ignorarPastaNoGit)(estado, deteccao.raiz, gitignore) };
 }

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,8 @@ 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',
+    // Security scan (Task 13a): o scanner com o Docker real e as imagens do catalogo.
+    'security-scan-integracao.test.js',
 ]);