@orkastery/cli 0.5.3 → 0.6.0

package/dist/board.js

@@ -50,7 +50,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.perfisDetectados = perfisDetectados;
 exports.threadsDeTodosOsPerfis = threadsDeTodosOsPerfis;
 exports.estadosDeSessao = estadosDeSessao;
+exports.leituraDoRuntime = leituraDoRuntime;
+exports.leituraReaproveitada = leituraReaproveitada;
 exports.vagaDoDespacho = vagaDoDespacho;
+exports.sessoesQueOcupam = sessoesQueOcupam;
 exports.esperarVaga = esperarVaga;
 exports.planejar = planejar;
 exports.devolverVagas = devolverVagas;
@@ -71,6 +74,7 @@ const util_1 = require("./util");
 const sessoes_adopt_1 = require("./sessoes-adopt");
 const horario_1 = require("./horario");
 const conducao_1 = require("./conducao");
+const locale_1 = require("./locale");
 const conducao_texto_1 = require("./conducao-texto");
 /**
  * Perfis detectados no projeto.
@@ -127,6 +131,31 @@ function estadosDeSessao(raiz = null, staleMin) {
         return null;
     return (0, sessoes_contas_1.estadosNasContas)(raiz, { staleMin });
 }
+/** Prazo da consulta do runtime, por conta, dentro do portao: ele roda no despacho e nao pode prende-lo. */
+const PRAZO_DA_CONSULTA_MS = 20_000;
+/** As sessoes de todas as contas, com `--all`: a sessao parada (`stopped`) so aparece nessa lista (medido em 12/10/2026). */
+function leituraDoRuntime(carregado) {
+    return () => (0, sessoes_contas_1.consultarContas)(carregado.raiz, { todas: true, staleMin: carregado.manifesto.concurrency.stale_after_min, prazoMs: PRAZO_DA_CONSULTA_MS });
+}
+/** A mesma leitura reaproveitada por `janelaMs`: quem espera a vaga nao consulta o runtime a cada volta. */
+function leituraReaproveitada(ler, janelaMs, relogio = Date.now) {
+    let guardada = null;
+    return () => {
+        const agoraMs = relogio();
+        if (!guardada || agoraMs - guardada.em >= janelaMs)
+            guardada = { em: agoraMs, leitura: ler() };
+        return guardada.leitura;
+    };
+}
+/** As sessoes que o runtime mostra encerradas. Leitura que lanca nao prova nada: nenhuma sai da conta. */
+function encerradasNoRuntime(ler) {
+    try {
+        return new Set(ler().sessoes.filter(sessoes_contas_1.encerradaNaLista).map((s) => s.sessionId));
+    }
+    catch {
+        return new Set();
+    }
+}
 /**
  * RM-037 (rm037defeito, defeito 3): o portao de vaga do `ork phase run`. Com `max_parallel_threads: 5`,
  * um sexto despacho saiu as 09h03 de 29/09/2026 com cinco sessoes vivas: o `phase run` nao consultava
@@ -141,9 +170,41 @@ function estadosDeSessao(raiz = null, staleMin) {
  */
 function vagaDoDespacho(carregado, threadId, quando = (0, util_1.agora)(), 
 /** S-5 do CHECK 3: o `desde` da tomada deste despacho; despacho em curso de outra thread so conta se veio antes. */
-desdeProprio) {
+desdeProprio, 
+/** RM-037 (ork-rm037esperas, D6): a leitura do runtime no limite; sem ela, a de todas as contas com `--all`. */
+lerRuntime) {
+    const limite = Math.max(1, carregado.manifesto.concurrency.max_parallel_threads);
+    let ocupam = sessoesQueOcupam(carregado, { exceto: threadId, quando, desdeProprio });
+    if (ocupam.length < limite)
+        return null;
+    // RM-037 (ork-rm037esperas, D6): no limite, a sessao que o runtime mostra encerrada (estado terminal ou fantasma) nao
+    // trabalha mais, mesmo com o lease de pe, e sai da conta: em 12/10/2026, uma sessao parada com `claude stop` antes do
+    // `phase_result` prendia a vaga ate a thread fechar. So no limite, para o despacho comum nao pagar a consulta; a
+    // sessao ausente da lista e a leitura que falha continuam contando.
+    if (ocupam.some((o) => o.sessao !== null)) {
+        const encerradas = encerradasNoRuntime(lerRuntime ?? leituraDoRuntime(carregado));
+        ocupam = ocupam.filter((o) => o.sessao === null || !encerradas.has(o.sessao));
+        if (ocupam.length < limite)
+            return null;
+    }
+    return {
+        limite,
+        ocupam,
+        detalhe: `concurrency.limite: o projeto ja tem ${ocupam.length} sessao(oes) viva(s) em outras threads e o limite e ${limite} ` +
+            `(concurrency.max_parallel_threads): ${ocupam.map((o) => `${o.thread} ${o.fase ?? '-'} ` +
+                (o.sessao ? `${o.runtime} ${o.sessao.slice(0, 8)}` : 'despacho em curso')).join('; ')}`,
+        correcao: 'espere uma sessao terminar e repita com --esperar <min>; sessao que morreu sem evento sai com ' +
+            'ork conducao status <thread>; ou suba concurrency.max_parallel_threads no orkastery.yaml',
+    };
+}
+/**
+ * As vagas do projeto ocupadas agora, pela regra do portao de vaga do despacho (`vagaDoDespacho`): a conducao de uma
+ * sessao viva (salvo a parada ou escalada) e o despacho em curso. RM-063 (F6): a maquina ociosa conta por aqui. `exceto`
+ * tira a propria thread; `desdeProprio` desempata dois despachos pela ultima vaga. Somente leitura, mais antiga primeiro.
+ */
+function sessoesQueOcupam(carregado, opcoes = {}) {
     const { raiz, manifesto } = carregado;
-    const limite = Math.max(1, manifesto.concurrency.max_parallel_threads);
+    const quando = opcoes.quando ?? (0, util_1.agora)(), desdeProprio = opcoes.desdeProprio, threadId = opcoes.exceto ?? '';
     const staleMin = manifesto.concurrency.stale_after_min;
     const ocupam = [];
     for (const id of (0, thread_1.listarIds)(raiz)) {
@@ -175,24 +236,17 @@ desdeProprio) {
             sessao: atual.dono.tipo === 'sessao' ? atual.dono.sessionId : null,
             runtime: atual.dono.tipo === 'sessao' ? atual.dono.runtime : null });
     }
-    if (ocupam.length < limite)
-        return null;
-    ocupam.sort((a, b) => a.desde.localeCompare(b.desde));
-    return {
-        limite,
-        ocupam,
-        detalhe: `concurrency.limite: o projeto ja tem ${ocupam.length} sessao(oes) viva(s) em outras threads e o limite e ${limite} ` +
-            `(concurrency.max_parallel_threads): ${ocupam.map((o) => `${o.thread} ${o.fase ?? '-'} ` +
-                (o.sessao ? `${o.runtime} ${o.sessao.slice(0, 8)}` : 'despacho em curso')).join('; ')}`,
-        correcao: 'espere uma sessao terminar e repita com --esperar <min>; sessao que morreu sem evento sai com ' +
-            'ork conducao status <thread>; ou suba concurrency.max_parallel_threads no orkastery.yaml',
-    };
+    return ocupam.sort((a, b) => a.desde.localeCompare(b.desde));
 }
 /** `--esperar`: espera a vaga do projeto ate o prazo. Devolve true quando ha vaga. */
-function esperarVaga(carregado, threadId, esperarMs) {
+function esperarVaga(carregado, threadId, esperarMs, 
+/** RM-037 (ork-rm037esperas, D6): a leitura do runtime; os testes injetam a deles. */
+ler = leituraDoRuntime(carregado)) {
     const prazo = Date.now() + esperarMs;
+    // RM-037 (ork-rm037esperas, D6): a leitura do runtime vale 30 s nesta espera, e nao uma consulta a cada volta.
+    const lerRuntime = leituraReaproveitada(ler, 30_000);
     for (;;) {
-        if (!vagaDoDespacho(carregado, threadId))
+        if (!vagaDoDespacho(carregado, threadId, undefined, undefined, lerRuntime))
             return true;
         if (Date.now() >= prazo)
             return false;
@@ -316,8 +370,8 @@ function planejar(carregado, opcoes = {}) {
                 situacao: 'espera',
                 motivo: 'vaga.stale',
                 detalhe: oc.detalhe,
-                correcao: `redespache com ork phase run ${t.id} --fase ${t.faseAtual}, ` +
-                    `ou feche com ork master ${t.id}`,
+                // RM-061 (F2b, G2): o pulse mostra esta correcao nas acoes automaticas e a remonta no locale.
+                correcao: (0, locale_1.textoDoCatalogo)((m) => m.pulse.vagaStaleCorrecao(t.id, t.faseAtual)),
                 leases: meus,
             });
             continue;
@@ -347,7 +401,7 @@ function planejar(carregado, opcoes = {}) {
                 situacao: 'espera',
                 motivo: 'concurrency.limite',
                 detalhe: `a maquina ja tem ${ocupadas} thread(s) em andamento, o limite e ${max}`,
-                correcao: 'espere uma thread liberar, ou suba concurrency.max_parallel_threads no orkastery.yaml',
+                correcao: (0, locale_1.textoDoCatalogo)((m) => m.pulse.limiteCorrecao),
                 leases: [],
             });
             continue;
@@ -428,34 +482,35 @@ function devolverVagas(carregado, opcoes = {}) {
 }
 /** Texto de `ork board reap`. */
 function textoDoReap(devolvidas) {
+    const m = (0, locale_1.msg)().operacao.restante.board;
     if (devolvidas.length === 0) {
-        return 'Nenhuma vaga a devolver: toda thread aberta tem procura ativa ou esta pronta para rodar.';
+        return m.reapVazio;
     }
     // I-35: o ledger guarda o ISO; o texto ao dono sai no fuso dele, rotulado uma vez.
-    const linhas = [`Vagas devolvidas por falta de procura ativa: ${devolvidas.length}. ${(0, horario_1.legendaDoFuso)()}`, ''];
+    const linhas = [m.reapTitulo(devolvidas.length, (0, horario_1.legendaDoFuso)()), ''];
     for (const d of devolvidas) {
-        const marca = d.registrada ? 'slot_released gravado no ledger' : 'ja registrado antes (idempotente)';
+        const marca = d.registrada ? m.reapMarca.gravada : m.reapMarca.anterior;
         linhas.push(`  ${d.thread.padEnd(20)} [${d.motivo}] ${marca}`);
-        linhas.push(`    detalhe  : ${(0, horario_1.localizarTexto)(d.detalhe)}`);
-        linhas.push(`    evidencia: ${(0, horario_1.localizarTexto)(d.evidencia)}`);
+        linhas.push(m.detalhe((0, horario_1.localizarTexto)(d.detalhe)));
+        linhas.push(m.evidencia((0, horario_1.localizarTexto)(d.evidencia)));
     }
     return linhas.join('\n');
 }
 function linhaDeFila(p, i, agora) {
-    return `  ${i + 1}. ${p.thread} quer ${p.nome} (colide com ${p.colidiuCom}, thread ${p.bloqueadaPor}) desde ${(0, horario_1.formatarDesde)(p.desdeEm, { agora })}`;
+    return (0, locale_1.msg)().operacao.restante.board.filaItem(i + 1, p.thread, p.nome, p.colidiuCom, p.bloqueadaPor, (0, horario_1.formatarDesde)(p.desdeEm, { agora }));
 }
 /** Texto de `ork board plan`. */
 function textoDoPlano(plano) {
+    const m = (0, locale_1.msg)().operacao.restante.board;
     const linhas = [];
-    linhas.push(`Escalonador por maquina. ${(0, horario_1.legendaDoFuso)(undefined, plano.decididoEm)}`);
-    linhas.push(`  limite de paralelismo: ${plano.maxParalelas} (concurrency.max_parallel_threads) | ` +
-        `em andamento agora (procura ativa): ${plano.emAndamento}`);
+    linhas.push(m.planoTitulo((0, horario_1.legendaDoFuso)(undefined, plano.decididoEm)));
+    linhas.push(m.limite(plano.maxParalelas, plano.emAndamento));
     linhas.push('');
     if (plano.vagas.length === 0) {
-        linhas.push('  Nenhuma thread no projeto.');
+        linhas.push(m.nenhumaThread);
     }
     else {
-        linhas.push((0, util_1.tabela)(['THREAD', 'SLUG', 'MODO', 'FASE', 'SITUACAO', 'MOTIVO', 'DETALHE'], plano.vagas.map((v) => [
+        linhas.push((0, util_1.tabela)([...m.colunasPlano], plano.vagas.map((v) => [
             v.thread,
             v.slug,
             (0, modos_1.tagDoModo)(v.modo),
@@ -467,23 +522,23 @@ function textoDoPlano(plano) {
         const comCorrecao = plano.vagas.filter((v) => v.correcao !== '');
         if (comCorrecao.length > 0) {
             linhas.push('');
-            linhas.push('  Correcoes acionaveis:');
+            linhas.push(m.correcoes);
             for (const v of comCorrecao)
                 linhas.push(`    ${v.thread}: ${(0, horario_1.localizarTexto)(v.correcao, { agora: plano.decididoEm })}`);
         }
     }
     linhas.push('');
-    linhas.push(`Merge queue (lease ${leases_1.LEASE_MAIN_TREE}, o unico gate de merge)`);
+    linhas.push(m.merge);
     if (plano.filaDeMerge.length === 0) {
-        linhas.push('  vazia: nenhuma thread esperando para mergear');
+        linhas.push(m.mergeVazia);
     }
     else {
         plano.filaDeMerge.forEach((p, i) => linhas.push(linhaDeFila(p, i, plano.decididoEm)));
     }
     linhas.push('');
-    linhas.push('Fila por colisao de regiao');
+    linhas.push(m.regiao);
     if (plano.filaDeRegiao.length === 0) {
-        linhas.push('  vazia: nenhuma colisao de path, board ou porta');
+        linhas.push(m.regiaoVazia);
     }
     else {
         plano.filaDeRegiao.forEach((p, i) => linhas.push(linhaDeFila(p, i, plano.decididoEm)));
@@ -492,17 +547,17 @@ function textoDoPlano(plano) {
 }
 /** Texto de `ork board [--all]`: a visao unica das threads. */
 function textoDoBoard(carregado, todos) {
+    const m = (0, locale_1.msg)().operacao.restante.board;
     const itens = threadsDeTodosOsPerfis(carregado, todos);
     const perfis = todos ? perfisDetectados(carregado) : perfisDetectados(carregado).slice(0, 1);
     const linhas = [];
-    linhas.push(`Board do Orkastery, projeto ${carregado.manifesto.project.name} ` +
-        `(${itens.length} thread(s) em ${perfis.length} perfil(is): ${perfis.map((p) => p.nome).join(', ')})`);
+    linhas.push(m.titulo(carregado.manifesto.project.name, itens.length, perfis.length, perfis.map((p) => p.nome).join(', ')));
     linhas.push('');
     if (itens.length === 0) {
-        linhas.push('  Nenhuma thread ainda. Crie uma com: ork thread new "<nome>" --modo default');
+        linhas.push(m.vazio);
         return linhas.join('\n');
     }
-    linhas.push((0, util_1.tabela)(['PERFIL', 'ID', 'SLUG', 'MODO', 'FASE', 'STATUS', 'PAUSAS', 'SCORE', 'WORKTREE', 'LEASES'], itens.map((i) => [
+    linhas.push((0, util_1.tabela)([...m.colunas], itens.map((i) => [
         i.perfil,
         i.thread.id,
         i.thread.slug,
@@ -518,14 +573,14 @@ function textoDoBoard(carregado, todos) {
     const conduzidas = itens.map((i) => ({ id: i.thread.id, c: (0, conducao_1.conducaoDaThread)(i.raiz, i.thread.id) })).filter((x) => x.c);
     if (conduzidas.length > 0) {
         linhas.push('');
-        linhas.push('Conducao agora');
+        linhas.push(m.conducao);
         for (const x of conduzidas)
             linhas.push(`  ${x.id}: ${(0, conducao_texto_1.linhaDeConducao)(x.c)}`);
     }
     const comVariante = itens.filter((i) => i.thread.variante);
     if (comVariante.length > 0) {
         linhas.push('');
-        linhas.push('  Variantes de ciclo em uso:');
+        linhas.push(m.variantes);
         for (const i of comVariante)
             linhas.push(`    ${i.thread.id}: --ciclo ${i.thread.variante}`);
     }
@@ -534,8 +589,8 @@ function textoDoBoard(carregado, todos) {
     const semScore = itens.filter((i) => !i.thread.score && i.thread.faseAtual === 'MASTER');
     if (semScore.length > 0) {
         linhas.push('');
-        linhas.push(`Fila de batch scoring: ${semScore.length} thread(s) esperando score humano`);
-        linhas.push('  veja em: ork master (com o indice derivado do ledger)');
+        linhas.push(m.batch(semScore.length));
+        linhas.push(m.batchVeja);
     }
     return linhas.join('\n');
 }

package/dist/branch-de-estado.js

@@ -33,11 +33,12 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.refRemota = exports.remotoValido = exports.REMOTO_DO_GIT = void 0;
+exports.refRemota = exports.shaValido = exports.remotoValido = exports.REMOTO_DO_GIT = void 0;
 exports.git = git;
 exports.exigirGit = exigirGit;
 exports.remotoRedigido = remotoRedigido;
 exports.exigirRemoto = exigirRemoto;
+exports.branchValida = branchValida;
 exports.pontaLocal = pontaLocal;
 exports.buscarBranch = buscarBranch;
 exports.jsonsDaPonta = jsonsDaPonta;
@@ -60,6 +61,7 @@ const fs = __importStar(require("node:fs"));
 const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
 const redacao_url_1 = require("./redacao-url");
+const locale_1 = require("./locale");
 function git(raiz, args, extra = {}) {
     const r = (0, node_child_process_1.spawnSync)('git', args, { cwd: raiz, encoding: 'utf8', input: extra.input, timeout: extra.timeoutMs ?? 60000,
         env: { ...process.env, ...extra.env } });
@@ -67,8 +69,11 @@ function git(raiz, args, extra = {}) {
 }
 function exigirGit(raiz, args, prefixo, extra = {}) {
     const r = git(raiz, args, extra);
-    if (!r.ok)
-        throw new Error(`${prefixo}.git: git ${args[0]} falhou: ${r.stderr.trim().split('\n').pop() ?? ''}`);
+    if (!r.ok) {
+        // RM-061 (F3b, GO-FIX 1): pelo catalogo, com o codigo `<prefixo>.git` igual; a saida do git vai como veio.
+        const comando = args[0], saida = r.stderr.trim().split('\n').pop() ?? '';
+        throw new locale_1.ErroDoCatalogo((m) => m.estado.gitFalhou(prefixo, comando, saida));
+    }
     return r.stdout;
 }
 /**
@@ -103,10 +108,31 @@ function remotoRedigido(remoto) {
 function exigirRemoto(remoto, prefixo) {
     if ((0, exports.remotoValido)(remoto))
         return remoto;
-    throw new Error(`${prefixo}.remoto-invalido: o remoto ${remotoRedigido(remoto)} não é nome de remoto do git ` +
-        '(letras, dígitos, ".", "_", "-" e "/" entre partes, cada parte começando por letra ou dígito, sem URL); nada foi passado ao git. ' +
-        'Corrija fabrica.remoto no orkastery.yaml ou --remoto (padrão: origin).');
+    // RM-061 (F3b): a recusa nasce do catalogo; o codigo `<prefixo>.remoto-invalido` e o mesmo nas duas linguas.
+    const redigido = remotoRedigido(remoto);
+    throw new locale_1.ErroDoCatalogo((m) => m.estado.remotoInvalido(prefixo, redigido));
+}
+/**
+ * RM-047 (fronteira de confiança): nome de branch que pode ir ao git como argumento. O valor vem do
+ * `worktree.base_branch` do manifesto, do campo `para` do ledger ou do frontmatter, e todos podem ser
+ * do clone: um nome que começa com `-` viraria opção do git (`--output=<arquivo>` grava arquivo).
+ * A regra é a do `git check-ref-format --branch`, então nenhum nome que o git aceite é recusado.
+ */
+function branchValida(branch) {
+    if (typeof branch !== 'string' || branch.length === 0 || branch.length > 255)
+        return false;
+    if (branch.startsWith('-') || branch === '@' || branch.includes('..') || branch.includes('@{'))
+        return false;
+    // eslint-disable-next-line no-control-regex
+    if (/[\x00-\x20\x7f~^:?*[\\]/.test(branch))
+        return false;
+    if (branch.startsWith('/') || branch.endsWith('/') || branch.includes('//') || branch.endsWith('.'))
+        return false;
+    return branch.split('/').every((parte) => !parte.startsWith('.') && !parte.endsWith('.lock'));
 }
+/** Sha hexadecimal (abreviado ou inteiro, SHA-1 ou SHA-256): o único formato de commit lido do ledger que vai ao git. */
+const shaValido = (sha) => typeof sha === 'string' && /^[0-9a-f]{7,64}$/i.test(sha);
+exports.shaValido = shaValido;
 const refRemota = (remoto, branch) => `refs/remotes/${remoto}/${branch}`;
 exports.refRemota = refRemota;
 /** A ultima copia lida da branch nesta maquina, sem rede. `null` quando nunca foi lida. */
@@ -157,7 +183,7 @@ function jsonsDaPonta(raiz, ponta, dir, prefixo) {
  * Grava uma versao nova da branch em cima de `ponta`, sem tocar arvore de trabalho nem indice:
  * indice temporario, blobs, `write-tree` e `commit-tree`. Push sem forca; recusa volta `false`.
  */
-function gravarNaBranch(raiz, remoto, branch, ponta, mudancas, mensagem, prefixo, rede = {}) {
+function gravarNaBranch(raiz, remoto, branch, ponta, mudancas, mensagem, prefixo, rede = {}, autor) {
     exigirRemoto(remoto, prefixo);
     const indice = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'ork-branch-estado-')), 'index');
     const env = { GIT_INDEX_FILE: indice };
@@ -176,7 +202,10 @@ function gravarNaBranch(raiz, remoto, branch, ponta, mudancas, mensagem, prefixo
             }
         }
         const arvore = exigirGit(raiz, ['write-tree'], prefixo, { env }).trim();
-        const commit = exigirGit(raiz, ['commit-tree', arvore, ...(ponta ? ['-p', ponta] : []), '-m', mensagem], prefixo).trim();
+        // RM-058 N3 (S6 da revisão da ork-rm058n3): quem grava pode dar a identidade do commit, para a do git da pessoa não ir ao remoto.
+        const identidade = autor ? { env: { GIT_AUTHOR_NAME: autor.nome, GIT_AUTHOR_EMAIL: autor.email, GIT_COMMITTER_NAME: autor.nome,
+                GIT_COMMITTER_EMAIL: autor.email } } : {};
+        const commit = exigirGit(raiz, ['commit-tree', arvore, ...(ponta ? ['-p', ponta] : []), '-m', mensagem], prefixo, identidade).trim();
         // `rede`: prazo e ambiente so do que vai a rede (RM-037, achado A3: o fechamento nao espera 60 s).
         const push = git(raiz, ['push', '--quiet', '--', remoto, `${commit}:refs/heads/${branch}`], rede);
         if (push.ok) {
@@ -185,7 +214,8 @@ function gravarNaBranch(raiz, remoto, branch, ponta, mudancas, mensagem, prefixo
         }
         if (/rejected|non-fast-forward|fetch first|stale info|failed to push/i.test(push.stderr))
             return false;
-        throw new Error(`${prefixo}.sem-remoto: o push para ${remoto} falhou: ${push.stderr.trim().split('\n').pop() ?? ''}`);
+        const saida = push.stderr.trim().split('\n').pop() ?? '';
+        throw new locale_1.ErroDoCatalogo((m) => m.estado.pushFalhou(prefixo, remoto, saida));
     }
     finally {
         fs.rmSync(path.dirname(indice), { recursive: true, force: true });

package/dist/busca-semantica.js

@@ -22,6 +22,7 @@ exports.fundirRrf = fundirRrf;
 exports.buscarPorSignificado = buscarPorSignificado;
 exports.textoDaBuscaPorSignificado = textoDaBuscaPorSignificado;
 const indice_vetorial_1 = require("./indice-vetorial");
+const locale_1 = require("./locale");
 exports.MODOS_DE_BUSCA = ['hibrido', 'vetor', 'fts'];
 /** D9: constante da fusao RRF. */
 exports.RRF_K = 60;
@@ -185,17 +186,18 @@ function buscarPorSignificado(o) {
  * id do FTS fora do universo e o aviso de cobertura vivem nele, e o texto os perdia na busca que deu certo.
  */
 function textoDaBuscaPorSignificado(r) {
-    const linhas = [`Busca por significado (NAO deterministica; modo ${r.modo}, origem ${r.origem}${r.modeloUsado ? ` ${r.modeloUsado}` : ''})`];
+    const m = (0, locale_1.msg)().operacao.restante.memory.busca;
+    const linhas = [m.titulo(r.modo, r.origem, r.modeloUsado ?? '')];
     if (r.motivo)
-        linhas.push(`  motivo: ${r.motivo}${r.detalhe ? `; ${r.detalhe}` : ''}`);
+        linhas.push(m.motivo(r.motivo, r.detalhe));
     else if (r.detalhe)
-        linhas.push(`  detalhe: ${r.detalhe}`);
+        linhas.push(m.detalhe(r.detalhe));
     linhas.push('');
     r.resultados.forEach((e, i) => {
-        const sim = e.similaridade === null ? '' : `  similaridade ${e.similaridade}`;
+        const sim = e.similaridade === null ? '' : m.similaridade(e.similaridade);
         linhas.push(`  ${i + 1}. [${e.collection}] ${e.id}  score ${e.score}  ${e.fontes.join('+')}${sim}`);
         linhas.push(`      ${e.resumo}`);
     });
-    linhas.push('', `  ${r.resultados.length} resultado(s); busca por tag continua em ork memory search --tags`);
+    linhas.push('', m.resumo(r.resultados.length));
     return linhas.join('\n');
 }

package/dist/catalogo.js

@@ -45,11 +45,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BUCKETS = void 0;
 exports.raizDoCatalogo = raizDoCatalogo;
 exports.exigirCatalogo = exigirCatalogo;
+exports.catalogoDoPacote = catalogoDoPacote;
+exports.exigirCatalogoDoPacote = exigirCatalogoDoPacote;
 exports.cliDoCatalogo = cliDoCatalogo;
 exports.skillsDoCatalogo = skillsDoCatalogo;
 exports.referenciasDoCatalogo = referenciasDoCatalogo;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
+const locale_1 = require("./locale");
 /** O que precisa existir para um diretorio ser a raiz do catalogo. */
 const MARCAS = ['skills', 'references', 'eval'];
 function ehRaizDoCatalogo(dir) {
@@ -79,10 +82,41 @@ function raizDoCatalogo(inicial) {
 function exigirCatalogo(inicial) {
     const raiz = raizDoCatalogo(inicial);
     if (!raiz) {
-        throw new Error('catalogo do Orkastery nao encontrado (esperado um diretorio com skills/, references/ e eval/)');
+        throw new locale_1.ErroDoCatalogo((m) => m.adapter.catalogoNaoEncontrado);
     }
     return raiz;
 }
+/** A raiz do catálogo do pacote que está rodando: subindo a partir do próprio código, nunca do cwd. */
+function catalogoDoPacote() {
+    return subirProcurando(__dirname);
+}
+function real(p) {
+    try {
+        return fs.realpathSync(p);
+    }
+    catch {
+        return path.resolve(p);
+    }
+}
+/**
+ * RM-047 (P4): o catálogo que o `ork eval` executa. O eval roda os canários, os hooks e o `core/dist`
+ * do catálogo, então ele só vale o do pacote que está rodando. Um diretório com `skills/`,
+ * `references/` e `eval/` achado a partir do cwd (um clone qualquer) que não seja o próprio pacote é
+ * recusado com `eval.catalogo-alheio`, com o comando que roda o eval daquele checkout de propósito.
+ */
+function exigirCatalogoDoPacote(inicial) {
+    const pacote = catalogoDoPacote();
+    if (!pacote) {
+        throw new Error('catalogo do Orkastery nao encontrado (esperado um diretorio com skills/, references/ e eval/)');
+    }
+    const doCwd = subirProcurando(inicial);
+    if (doCwd && real(doCwd) !== real(pacote)) {
+        throw new Error(`eval.catalogo-alheio: ${doCwd} tem skills/, references/ e eval/, mas nao e o pacote deste ork ` +
+            `(${pacote}). O eval executa os canarios, os hooks e o core/dist do catalogo, e so roda o do proprio pacote. ` +
+            `Para avaliar aquele checkout de proposito, rode o ork dele: node ${path.join(doCwd, 'core', 'dist', 'index.js')} eval`);
+    }
+    return pacote;
+}
 /** Os buckets do catalogo, na ordem em que o README os apresenta. */
 exports.BUCKETS = [
     'core',