@orkastery/cli 0.5.1 → 0.5.6

package/dist/entrega-pr.js

@@ -16,12 +16,15 @@ exports.registrarEntregasPorPr = registrarEntregasPorPr;
  * remota (ancestralidade conferida contra a ponta que o `ls-remote` devolve) e o check do CI no
  * head do PR. Sem CI verde, nao registra: merge sem prova independente nao e entrega.
  */
+const branch_de_estado_1 = require("./branch-de-estado");
 const ci_1 = require("./ci");
+const docs_1 = require("./docs");
 const fabrica_publicar_1 = require("./fabrica-publicar");
 const ledger_1 = require("./ledger");
 const modos_1 = require("./modos");
 const thread_1 = require("./thread");
 const util_1 = require("./util");
+const locale_1 = require("./locale");
 /** O merge `ship(<thread>)` mais recente na base remota, com o head do PR (segundo pai). */
 function mergeDaEntrega(raiz, thread, remoto, base) {
     const r = (0, util_1.exec)('git', ['log', `refs/remotes/${remoto}/${base}`, '--first-parent', '--format=%H%x09%P%x09%s', `--grep=^ship(${thread})`], raiz);
@@ -49,7 +52,7 @@ function avancarParaShip(raiz, threadId) {
     (0, thread_1.gravarThread)(raiz, atualizada);
 }
 function resultado(thread, acao, motivo, extra = {}) {
-    return { thread, acao, motivo, mergeSha: null, headSha: null, ci: null, ...extra };
+    return { thread, acao, motivo, mergeSha: null, headSha: null, ci: null, docsPendentes: [], ...extra };
 }
 /**
  * `ork ship registrar-pr <thread>`: grava o `ship_done` da entrega feita por PR. Idempotente:
@@ -57,39 +60,46 @@ function resultado(thread, acao, motivo, extra = {}) {
  */
 function registrarEntregaPorPr(carregado, threadId, opcoes = {}) {
     const raiz = carregado.raiz;
-    const remoto = opcoes.remoto ?? 'origin';
+    // RM-047: o `--remoto` vem da linha de comando; so nome de remoto chega ao git, e depois do `--`.
+    const remoto = (0, branch_de_estado_1.exigirRemoto)(opcoes.remoto ?? 'origin', 'ship');
     const base = carregado.manifesto.worktree.base_branch;
     const thread = (0, thread_1.lerThread)(raiz, threadId);
     if (thread.status === 'fechada')
-        return resultado(threadId, 'ja-registrada', 'thread ja fechada');
+        return resultado(threadId, 'ja-registrada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prThreadFechada));
     if (opcoes.buscar !== false)
-        (0, util_1.exec)('git', ['fetch', '-q', remoto, `+refs/heads/${base}:refs/remotes/${remoto}/${base}`], raiz);
-    const merge = mergeDaEntrega(raiz, threadId, remoto, base);
-    if (!merge)
-        return resultado(threadId, 'sem-merge', `nenhum merge ship(${threadId}) em ${remoto}/${base}`);
+        (0, util_1.exec)('git', ['fetch', '-q', '--', remoto, `+refs/heads/${base}:refs/remotes/${remoto}/${base}`], raiz);
+    const encontrado = mergeDaEntrega(raiz, threadId, remoto, base);
+    if (!encontrado)
+        return resultado(threadId, 'sem-merge', (0, locale_1.textoDoCatalogo)((m) => m.ship.prSemMerge(threadId, remoto, base)));
+    // RM-044 (A3): o condutor roda o registrar-pr logo depois do merge; e aqui que ele fica sabendo da pagina que
+    // vai deixar o push da base vermelho, lida da base remota que o fetch acabou de trazer.
+    const merge = { ...encontrado, docsPendentes: (0, docs_1.docsPendentesDoMerge)(raiz, threadId, `refs/remotes/${remoto}/${base}`) };
     const dir = (0, thread_1.dirThread)(raiz, threadId);
     const jaTem = (0, ledger_1.lerLedger)(dir).some((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.shipConcluido && e.mergeSha === merge.mergeSha);
     if (jaTem)
-        return resultado(threadId, 'ja-registrada', 'esta entrega ja tem ship_done', merge);
+        return resultado(threadId, 'ja-registrada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prJaTemShipDone), merge);
     // A ponta do remoto AGORA, e o merge dentro dela: e o que torna o push provado, nao presumido.
-    const remotoAgora = (0, util_1.exec)('git', ['ls-remote', remoto, `refs/heads/${base}`], raiz);
+    const remotoAgora = (0, util_1.exec)('git', ['ls-remote', '--', remoto, `refs/heads/${base}`], raiz);
     const ponta = remotoAgora.ok ? remotoAgora.stdout.split('\t')[0].trim() : '';
     if (!ponta || !(0, util_1.exec)('git', ['merge-base', '--is-ancestor', merge.mergeSha, ponta], raiz).ok) {
-        return resultado(threadId, 'recusada', `o merge ${merge.mergeSha.slice(0, 7)} nao esta na ponta de ${remoto}/${base}`, merge);
+        return resultado(threadId, 'recusada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prForaDaPonta(merge.mergeSha.slice(0, 7), remoto, base)), merge);
     }
     const ci = (0, ci_1.consultarCi)(carregado, merge.headSha ?? merge.mergeSha, remoto, opcoes.executorCi);
     if (ci.required && !ci.ok) {
-        return resultado(threadId, 'recusada', `sem CI verde no head do PR: ${ci.detail}`, { ...merge, ci });
+        return resultado(threadId, 'recusada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prSemCiVerde((0, locale_1.remontar)(ci.detail))), { ...merge, ci });
     }
     // RM-037 (fatia 3, defeito 6): o ensaio confere tudo e para aqui, sem ledger, fase nem fabrica.
     if (opcoes.dryRun) {
-        return resultado(threadId, 'registraria', `ensaio: registraria ship_done pelo merge ${merge.mergeSha.slice(0, 7)} do PR (nada gravado)`, { ...merge, ci });
+        return resultado(threadId, 'registraria', (0, locale_1.textoDoCatalogo)((m) => m.ship.prRegistraria(merge.mergeSha.slice(0, 7))), { ...merge, ci });
     }
     (0, ledger_1.registrar)(dir, threadId, ledger_1.TIPOS_DE_EVENTO.shipConcluido, {
         de: thread.base?.branch ?? null,
         para: base,
         shaDe: merge.headSha,
         mergeSha: merge.mergeSha,
+        // RM-037 (fatia 5, A1): a ponta que o ls-remote provou vai em campo proprio; o recibo do Maestro confere o push
+        // contra ela quando a base andou depois do merge.
+        pontaDaBase: ponta,
         jaIncorporado: true,
         remoto,
         shaRemoto: ponta,
@@ -105,7 +115,7 @@ function registrarEntregaPorPr(carregado, threadId, opcoes = {}) {
     avancarParaShip(raiz, threadId);
     if (opcoes.publicar !== false)
         (0, fabrica_publicar_1.publicarEmSegundoPlano)(raiz);
-    return resultado(threadId, 'registrou', `ship_done pelo merge ${merge.mergeSha.slice(0, 7)} do PR`, { ...merge, ci });
+    return resultado(threadId, 'registrou', (0, locale_1.textoDoCatalogo)((m) => m.ship.prRegistrou(merge.mergeSha.slice(0, 7))), { ...merge, ci });
 }
 const ghApi = (caminho) => (0, util_1.exec)('gh', ['api', caminho, '-H', 'Accept: application/vnd.github+json'], process.cwd(), 120000);
 function lerJson(r) {
@@ -130,25 +140,25 @@ function registrarEntregaExternaPorPr(carregado, threadId, opcoes) {
     const gh = opcoes.executorGitHub ?? ghApi;
     const declarados = carregado.manifesto.ci.external_repositories;
     if (!Object.hasOwn(declarados, repo)) {
-        return resultado(threadId, 'recusada', `o repositorio ${repo} nao esta declarado em ci.external_repositories do orkastery.yaml`);
+        return resultado(threadId, 'recusada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prRepoNaoDeclarado(repo)));
     }
     if (!Number.isSafeInteger(n) || n < 1)
-        return resultado(threadId, 'recusada', `--pr precisa ser o numero do PR, recebido ${String(n)}`);
+        return resultado(threadId, 'recusada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prNumeroInvalido(String(n))));
     const thread = (0, thread_1.lerThread)(raiz, threadId);
     if (thread.status === 'fechada')
-        return resultado(threadId, 'ja-registrada', 'thread ja fechada');
+        return resultado(threadId, 'ja-registrada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prThreadFechada));
     const dir = (0, thread_1.dirThread)(raiz, threadId);
     if ((0, ledger_1.lerLedger)(dir).some((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.shipConcluido && e.repositorio === repo && e.pr === n)) {
-        return resultado(threadId, 'ja-registrada', `o PR #${n} de ${repo} ja tem ship_done`);
+        return resultado(threadId, 'ja-registrada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prExternoJaTem(n, repo)));
     }
     const pr = lerJson(gh(`repos/${repo}/pulls/${n}`));
     if (!pr)
-        return resultado(threadId, 'recusada', `a consulta do PR #${n} de ${repo} ao GitHub falhou`);
+        return resultado(threadId, 'recusada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prConsultaFalhou(n, repo)));
     const mergeSha = typeof pr.merge_commit_sha === 'string' && /^[0-9a-f]{40}$/.test(pr.merge_commit_sha) ? pr.merge_commit_sha : null;
     const headSha = typeof pr.head?.sha === 'string' && /^[0-9a-f]{40}$/.test(pr.head.sha) ? pr.head.sha : null;
     const base = typeof pr.base?.ref === 'string' && /^[A-Za-z0-9._/-]{1,200}$/.test(pr.base.ref) ? pr.base.ref : null;
     if (pr.merged !== true || !mergeSha || !headSha || !base) {
-        return resultado(threadId, 'sem-merge', `o PR #${n} de ${repo} nao esta mesclado`);
+        return resultado(threadId, 'sem-merge', (0, locale_1.textoDoCatalogo)((m) => m.ship.prNaoMesclado(n, repo)));
     }
     // Achado A4 do CHECK: o PR precisa ser DESTA thread e ter entrado na branch padrao do repositorio. Sem o
     // vinculo, qualquer PR mesclado do repositorio viraria entrega de qualquer thread; sem a base, um PR
@@ -158,28 +168,28 @@ function registrarEntregaExternaPorPr(carregado, threadId, opcoes) {
         // letra ou digito colado nao (outro id). Sem diferenciar maiusculas.
         .some((x) => new RegExp(`(^|[^a-z0-9-])${threadId.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?![a-z0-9])`, 'i').test(x));
     if (!vinculo) {
-        return resultado(threadId, 'recusada', `o PR #${n} de ${repo} nao cita a thread ${threadId} no titulo, no corpo nem na branch`, { mergeSha, headSha });
+        return resultado(threadId, 'recusada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prNaoCitaThread(n, repo, threadId)), { mergeSha, headSha });
     }
     const repositorio = lerJson(gh(`repos/${repo}`));
     if (!repositorio)
-        return resultado(threadId, 'recusada', `a consulta de ${repo} ao GitHub falhou`, { mergeSha, headSha });
+        return resultado(threadId, 'recusada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prRepoFalhou(repo)), { mergeSha, headSha });
     if (repositorio.default_branch !== base) {
-        return resultado(threadId, 'recusada', `o PR #${n} entrou em ${base}, e a branch padrao de ${repo} e ${repositorio.default_branch ?? 'desconhecida'}`, { mergeSha, headSha });
+        return resultado(threadId, 'recusada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prOutraBase(n, base, repo, repositorio.default_branch)), { mergeSha, headSha });
     }
     // A ponta da base AGORA, e o merge dentro dela: o push provado, pela mesma pergunta do ls-remote.
     const ramo = lerJson(gh(`repos/${repo}/branches/${encodeURIComponent(base)}`));
     const ponta = typeof ramo?.commit?.sha === 'string' && /^[0-9a-f]{40}$/.test(ramo.commit.sha) ? ramo.commit.sha : '';
     const comparacao = ponta ? lerJson(gh(`repos/${repo}/compare/${mergeSha}...${ponta}`)) : null;
     if (!ponta || !comparacao || !['ahead', 'identical'].includes(String(comparacao.status))) {
-        return resultado(threadId, 'recusada', `o merge ${mergeSha.slice(0, 7)} nao esta na ponta de ${repo}:${base}`, { mergeSha, headSha });
+        return resultado(threadId, 'recusada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prExternoForaDaPonta(mergeSha.slice(0, 7), repo, base)), { mergeSha, headSha });
     }
     const check = declarados[repo];
     const ci = check ? (0, ci_1.consultarCiDoRepositorio)(repo, headSha, check, opcoes.executorCi) : null;
     if (ci && !ci.ok) {
-        return resultado(threadId, 'recusada', `sem CI verde no head do PR: ${ci.detail}`, { mergeSha, headSha, ci });
+        return resultado(threadId, 'recusada', (0, locale_1.textoDoCatalogo)((m) => m.ship.prSemCiVerde((0, locale_1.remontar)(ci.detail))), { mergeSha, headSha, ci });
     }
     if (opcoes.dryRun) {
-        return resultado(threadId, 'registraria', `ensaio: registraria ship_done pelo merge ${mergeSha.slice(0, 7)} do PR #${n} de ${repo} (nada gravado)`, { mergeSha, headSha, ci });
+        return resultado(threadId, 'registraria', (0, locale_1.textoDoCatalogo)((m) => m.ship.prExternoRegistraria(mergeSha.slice(0, 7), n, repo)), { mergeSha, headSha, ci });
     }
     (0, ledger_1.registrar)(dir, threadId, ledger_1.TIPOS_DE_EVENTO.shipConcluido, {
         de: thread.base?.branch ?? null,
@@ -189,6 +199,9 @@ function registrarEntregaExternaPorPr(carregado, threadId, opcoes) {
         url: pr.html_url ?? `https://github.com/${repo}/pull/${n}`,
         shaDe: headSha,
         mergeSha,
+        // RM-037 (fatia 5, A1; aviso da rodada 1 do CHECK): a ponta conferida vai em campo proprio, como no PR local; a
+        // comparacao aceita `ahead`, e o recibo do Maestro confere o push contra ela.
+        pontaDaBase: ponta,
         jaIncorporado: true,
         remoto: `github:${repo}`,
         shaRemoto: ponta,
@@ -203,13 +216,13 @@ function registrarEntregaExternaPorPr(carregado, threadId, opcoes) {
     avancarParaShip(raiz, threadId);
     if (opcoes.publicar !== false)
         (0, fabrica_publicar_1.publicarEmSegundoPlano)(raiz);
-    return resultado(threadId, 'registrou', `ship_done pelo merge ${mergeSha.slice(0, 7)} do PR #${n} de ${repo}`, { mergeSha, headSha, ci });
+    return resultado(threadId, 'registrou', (0, locale_1.textoDoCatalogo)((m) => m.ship.prExternoRegistrou(mergeSha.slice(0, 7), n, repo)), { mergeSha, headSha, ci });
 }
 /** `ork ship registrar-pr --todas`: toda thread aberta que ja tem merge `ship(<thread>)` na base. */
 function registrarEntregasPorPr(carregado, opcoes = {}) {
-    const remoto = opcoes.remoto ?? 'origin';
+    const remoto = (0, branch_de_estado_1.exigirRemoto)(opcoes.remoto ?? 'origin', 'ship');
     const base = carregado.manifesto.worktree.base_branch;
-    (0, util_1.exec)('git', ['fetch', '-q', remoto, `+refs/heads/${base}:refs/remotes/${remoto}/${base}`], carregado.raiz);
+    (0, util_1.exec)('git', ['fetch', '-q', '--', remoto, `+refs/heads/${base}:refs/remotes/${remoto}/${base}`], carregado.raiz);
     const r = (0, thread_1.listarIds)(carregado.raiz)
         .filter((id) => (0, thread_1.lerThread)(carregado.raiz, id).status !== 'fechada')
         .filter((id) => mergeDaEntrega(carregado.raiz, id, remoto, base) !== null)
@@ -218,7 +231,7 @@ function registrarEntregasPorPr(carregado, opcoes = {}) {
             return registrarEntregaPorPr(carregado, id, { ...opcoes, buscar: false, publicar: false });
         }
         catch (e) {
-            return resultado(id, 'recusada', e.message);
+            return resultado(id, 'recusada', e instanceof locale_1.ErroDoCatalogo ? (0, locale_1.textoDoCatalogo)(e.montar) : e.message);
         }
     });
     // Uma publicacao so para o lote inteiro, nao uma por thread.

package/dist/escopo-escrita.js

@@ -60,7 +60,16 @@ function exigirEscopoDeEscrita(threads) {
 /** Um nome autorizado nao pode ser alias de outra thread ou de estado externo. */
 function validarDiretorioDeThread(raiz, id) {
     validarThreadDeEscrita(id);
-    const dir = (0, estado_thread_1.estadoCanonico)(raiz, id);
+    let dir;
+    // RM-047: o estadoCanonico já recusa link (estado.link); aqui a recusa mantém o código do escopo.
+    try {
+        dir = (0, estado_thread_1.estadoCanonico)(raiz, id);
+    }
+    catch (e) {
+        if (e.message.startsWith('estado.link'))
+            throw new Error('scope.thread.alias');
+        throw e;
+    }
     for (const candidato of [path.dirname(path.dirname(dir)), path.dirname(dir), dir]) {
         const stat = fs.lstatSync(candidato, { throwIfNoEntry: false });
         if (!stat)

package/dist/esgotamentos.js

@@ -0,0 +1,181 @@
+"use strict";
+/**
+ * RM-040 (B7): `ork accounts esgotamentos`, a medida da metrica do item.
+ *
+ * A metrica da RM-040 e "zero despacho numa conta que outro projeto do mesmo usuario ja viu
+ * esgotada, dentro do prazo dela". Este relatorio so le: as marcas do registro compartilhado
+ * (`~/.orkastery/private/contas.json`) e os `phase_dispatch` com perfil dos ledgers de cada projeto
+ * registrado nesta maquina (`~/.orkastery/projetos.json`). Conta o despacho que caiu na conta de
+ * uma marca, dentro da janela dela, vindo de projeto diferente do que marcou.
+ *
+ * A saida nunca leva diretorio de conta: a conta vira um id opaco (sha256 da chave, 12 hex), o
+ * projeto sai pelo nome registrado e o perfil, pelo id.
+ *
+ * Limite declarado: o registro so guarda as marcas vivas. Uso bem sucedido, login reconferido e
+ * prazo vencido apagam a marca na gravacao seguinte; por isso o numero e um piso, e a leitura vale
+ * enquanto a marca existe.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NAO_REGISTRADO = exports.LIMITE_DO_RELATORIO = exports.CONTRATO_ESGOTAMENTOS = void 0;
+exports.contaOpaca = contaOpaca;
+exports.fimDaJanela = fimDaJanela;
+exports.relatorioDeEsgotamentos = relatorioDeEsgotamentos;
+exports.textoDosEsgotamentos = textoDosEsgotamentos;
+const node_crypto_1 = require("node:crypto");
+const fs = __importStar(require("node:fs"));
+const horario_1 = require("./horario");
+const ledger_1 = require("./ledger");
+const ledger_stats_1 = require("./ledger-stats");
+const projeto_alvo_1 = require("./projeto-alvo");
+const runtime_profiles_1 = require("./runtime-profiles");
+const thread_1 = require("./thread");
+const util_1 = require("./util");
+exports.CONTRATO_ESGOTAMENTOS = 'ork.esgotamentos/v1';
+exports.LIMITE_DO_RELATORIO = 'o registro guarda so as marcas vivas (uso bem sucedido, login reconferido e prazo vencido ' +
+    'apagam a marca): o total e um piso, valido enquanto a marca existe';
+exports.NAO_REGISTRADO = 'nao registrado';
+function contaOpaca(chave) {
+    return (0, node_crypto_1.createHash)('sha256').update(chave).digest('hex').slice(0, 12);
+}
+function caminhoReal(p) {
+    try {
+        return fs.realpathSync(p);
+    }
+    catch {
+        return p;
+    }
+}
+/** Fim da janela da marca: o prazo para cota esgotada; sem prazo (login, credencial paga), aberta. */
+function fimDaJanela(m) {
+    if (m.estado !== 'esgotado')
+        return Number.POSITIVE_INFINITY;
+    const ate = m.esgotadoAte === null ? NaN : Date.parse(m.esgotadoAte);
+    return Number.isFinite(ate) ? ate : Number.NEGATIVE_INFINITY;
+}
+function relatorioDeEsgotamentos(opcoes = {}) {
+    const agoraMs = opcoes.agoraMs ?? Date.now();
+    const desdeMs = (0, ledger_stats_1.parsePeriodo)(opcoes.desde ?? '7d', agoraMs);
+    if (desdeMs >= agoraMs)
+        throw Error('ledger.period.order');
+    // Um projeto por raiz real: o registro pode trazer a mesma copia por dois caminhos.
+    const vistos = new Set();
+    const projetos = (0, projeto_alvo_1.listarProjetos)().filter((p) => {
+        const real = caminhoReal(p.raiz);
+        if (vistos.has(real))
+            return false;
+        vistos.add(real);
+        return true;
+    }).map((p) => ({ ...p, real: caminhoReal(p.raiz) }));
+    const nomeDaRaiz = (raiz) => projetos.find((p) => p.real === caminhoReal(raiz))?.nome ?? exports.NAO_REGISTRADO;
+    const contas = (0, runtime_profiles_1.lerContasCompartilhadas)();
+    const marcas = contas.map((c) => ({ c, real: caminhoReal(c.projeto), inicio: Date.parse(c.em), fim: fimDaJanela(c) }));
+    const despachos = [];
+    const lidos = [];
+    for (const p of projetos) {
+        let comPerfil = 0;
+        let ids = [];
+        try {
+            ids = p.presente ? (0, thread_1.listarIds)(p.raiz) : [];
+        }
+        catch {
+            ids = [];
+        }
+        for (const id of ids) {
+            let eventos = [];
+            try {
+                eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(p.raiz, id));
+            }
+            catch {
+                continue;
+            }
+            for (const e of eventos) {
+                if (e.tipo !== 'phase_dispatch' || e.perfil === undefined || e.perfil === null)
+                    continue;
+                const t = Date.parse(String(e.ts));
+                if (!Number.isFinite(t) || t < desdeMs || t >= agoraMs)
+                    continue;
+                let perfil, chave;
+                try {
+                    perfil = (0, runtime_profiles_1.validarPerfilDeDespacho)(e.perfil);
+                    chave = (0, runtime_profiles_1.chaveDaConta)(perfil);
+                }
+                catch {
+                    continue;
+                }
+                comPerfil++;
+                const marca = marcas.find((m) => m.c.chave === chave && m.real !== p.real && t >= m.inicio && t < m.fim);
+                if (!marca)
+                    continue;
+                despachos.push({ em: new Date(t).toISOString(), projeto: p.nome, thread: String(e.thread ?? id),
+                    fase: typeof e.fase === 'string' ? e.fase : null, runtime: perfil.runtime, perfil: perfil.id,
+                    conta: contaOpaca(chave), marcadaPor: nomeDaRaiz(marca.c.projeto) });
+            }
+        }
+        lidos.push({ nome: p.nome, presente: p.presente, despachosComPerfil: comPerfil });
+    }
+    despachos.sort((a, b) => a.em.localeCompare(b.em));
+    return {
+        contrato: exports.CONTRATO_ESGOTAMENTOS,
+        periodo: { desde: new Date(desdeMs).toISOString(), ate: new Date(agoraMs).toISOString(), intervalo: '[desde,ate)' },
+        marcas: contas.map((c) => ({ conta: contaOpaca(c.chave), runtime: c.chave.slice(0, c.chave.indexOf(':')), estado: c.estado,
+            motivo: c.motivo, em: c.em, esgotadoAte: c.esgotadoAte, projeto: nomeDaRaiz(c.projeto) })),
+        projetos: lidos,
+        despachos,
+        total: despachos.length,
+        limite: exports.LIMITE_DO_RELATORIO,
+    };
+}
+/** Texto para o terminal, com o horario do dono e o fuso uma vez no fim. */
+function textoDosEsgotamentos(r) {
+    const linhas = [
+        `Esgotamentos de conta  ${(0, horario_1.formatarDataHora)(r.periodo.desde)} ate ${(0, horario_1.formatarDataHora)(r.periodo.ate)} ${r.periodo.intervalo}`,
+        `  marcas vivas no registro: ${r.marcas.length}`,
+    ];
+    for (const m of r.marcas) {
+        const ate = m.estado === 'esgotado' ? `ate ${(0, horario_1.formatarDataHora)(m.esgotadoAte)}` : 'sem prazo';
+        linhas.push(`    conta ${m.conta}  ${m.runtime}  ${m.estado} desde ${(0, horario_1.formatarDataHora)(m.em)}, ${ate}  visto em ${m.projeto} (${m.motivo})`);
+    }
+    linhas.push(`  projetos lidos: ${r.projetos.length === 0 ? 'nenhum registrado'
+        : r.projetos.map((p) => `${p.nome} (${p.presente ? `${p.despachosComPerfil} despacho(s) com perfil` : 'fora do disco'})`).join(', ')}`);
+    linhas.push(`  despachos em conta marcada por outro projeto: ${r.total}`);
+    if (r.despachos.length > 0) {
+        linhas.push((0, util_1.tabela)(['QUANDO', 'PROJETO', 'THREAD', 'FASE', 'PERFIL', 'CONTA', 'MARCADA POR'], r.despachos.map((d) => [(0, horario_1.formatarDataHora)(d.em), d.projeto, d.thread, d.fase ?? '-', d.perfil, d.conta, d.marcadaPor]))
+            .split('\n').map((l) => `    ${l}`).join('\n'));
+    }
+    linhas.push(`  limite: ${r.limite}`);
+    linhas.push((0, horario_1.legendaDoFuso)());
+    return linhas.join('\n');
+}

package/dist/estado-thread.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.raizDoEstado = raizDoEstado;
 exports.estadoCanonico = estadoCanonico;
+exports.exigirEstadoSemLink = exigirEstadoSemLink;
 exports.vincularEstado = vincularEstado;
 exports.comEstadoParaGit = comEstadoParaGit;
 exports.auditarEstado = auditarEstado;
@@ -66,7 +67,28 @@ function raizDoEstado(raiz) {
 function estadoCanonico(raiz, id) {
     if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(id))
         throw new Error('id de thread inválido');
-    return path.join(raizDoEstado(raiz), '.orkastery', 'threads', id);
+    const principal = raizDoEstado(raiz);
+    exigirEstadoSemLink(principal, ['.orkastery', 'threads', id]);
+    return path.join(principal, '.orkastery', 'threads', id);
+}
+/**
+ * RM-047 (fronteira de confiança): na árvore principal, `.orkastery`, `threads` e o diretório da thread
+ * são pastas de verdade. Um link versionado no clone levaria ledger, claims e thread.json para fora da
+ * raiz, e o `ork` anexaria linhas em arquivo alheio. O link que o próprio `ork` cria fica na worktree
+ * (`vincularEstado`) e aponta para cá; ele nunca é um destes componentes.
+ */
+function exigirEstadoSemLink(principal, componentes) {
+    let atual = principal;
+    for (const nome of componentes) {
+        atual = path.join(atual, nome);
+        const stat = fs.lstatSync(atual, { throwIfNoEntry: false });
+        if (!stat)
+            return;
+        if (stat.isSymbolicLink()) {
+            throw new Error(`estado.link: ${path.relative(principal, atual)} é link simbólico; o estado do ork fica em ` +
+                'pastas de verdade dentro da raiz (um link versionado levaria a escrita para fora dela). Remova o link.');
+        }
+    }
 }
 function mesmoArquivo(a, b) {
     return fs.existsSync(a) && fs.existsSync(b) && fs.realpathSync(a) === fs.realpathSync(b);

package/dist/experiencia-instalacao.js

@@ -41,10 +41,14 @@ exports.aplicarExperiencia = aplicarExperiencia;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const node_crypto_1 = require("node:crypto");
+const locale_1 = require("./locale");
 exports.INICIO_EXPERIENCIA = '<!-- orkastery:experiencia:begin -->';
 exports.FIM_EXPERIENCIA = '<!-- orkastery:experiencia:end -->';
 const CONTRATO = 'ork.experiencia-install/v1';
-const LINHA_DO_DIRETORIO = /^Se ativo, leia a skill selecionada pelo campo skill no diretório (".*")\.$/;
+/** RM-061 (F3a, D8): as linguas em que o bloco e escrito e, sem recibo, reconhecido. */
+const LOCALES_DO_BLOCO = ['pt-BR', 'en'];
+/** Marca do diretorio no molde da linha: o texto antes e depois dela reconhece a linha em cada lingua. */
+const MARCA_DO_DIRETORIO = '{{diretorio}}';
 const conflito = () => { throw Error('experiencia.bloco.conflict: bloco ou recibo alterado/duplicado; preserve os arquivos e revise a instalação'); };
 /** Recusa symlinks e hardlinks em qualquer componente antes da leitura/escrita. */
 function caminhoSeguro(projeto, arquivo) {
@@ -83,18 +87,35 @@ function decodificar(s) {
     return b;
 }
 const eolDe = (b) => b.includes('\r\n') ? '\r\n' : '\n';
-/** O caminho vai relativo ao projeto: o arquivo de instruções costuma ser versionado. */
-function nucleoDoBloco(skill, eol) {
-    return Buffer.from([exports.INICIO_EXPERIENCIA,
-        '## Experiência de orquestração',
-        'Consulte `ork experiencia show --json` neste projeto. Se experience for false, não ative o pacote.',
-        `Se ativo, leia a skill selecionada pelo campo skill no diretório ${JSON.stringify(skill)}.`,
-        'As preferências são dados do núcleo; preserve gates, proveniência humana e permissões do host.',
+/**
+ * O caminho vai relativo ao projeto: o arquivo de instruções costuma ser versionado. RM-061 (F3a, D1 e D2): o texto
+ * sai na língua pedida, pela família `gerados` do catálogo; os marcadores são os mesmos nas duas línguas.
+ */
+function nucleoDoBloco(skill, eol, locale) {
+    const t = (0, locale_1.msg)(locale).gerados.experiencia;
+    return Buffer.from([exports.INICIO_EXPERIENCIA, `## ${t.titulo}`, t.consulte, t.diretorio(JSON.stringify(skill)), t.preferencias,
         exports.FIM_EXPERIENCIA, ''].join(eol));
 }
+/** O diretório escrito na linha do bloco de uma língua, ou null se a linha não é a dessa língua. */
+function diretorioDaLinha(linha, locale) {
+    const molde = (0, locale_1.msg)(locale).gerados.experiencia.diretorio(MARCA_DO_DIRETORIO);
+    const corte = molde.indexOf(MARCA_DO_DIRETORIO);
+    const antes = molde.slice(0, corte), depois = molde.slice(corte + MARCA_DO_DIRETORIO.length);
+    if (linha.length < antes.length + depois.length || !linha.startsWith(antes) || !linha.endsWith(depois))
+        return null;
+    let skill;
+    try {
+        skill = JSON.parse(linha.slice(antes.length, linha.length - depois.length));
+    }
+    catch {
+        return null;
+    }
+    return typeof skill === 'string' && !/[\r\n`]/.test(skill) ? skill : null;
+}
 /**
  * Bloco sem recibo (clone novo, `.orkastery/` apagado) só é adotado quando é exatamente o texto
- * que esta versão ou a anterior geram, com qualquer diretório; qualquer outra edição é conflito.
+ * que esta versão ou a anterior geram, com qualquer diretório e em qualquer das duas línguas (RM-061,
+ * F3a, D8); qualquer outra edição é conflito.
  */
 function reconhecerBloco(antes) {
     if (contar(antes, exports.INICIO_EXPERIENCIA) !== 1 || contar(antes, exports.FIM_EXPERIENCIA) !== 1)
@@ -108,18 +129,14 @@ function reconhecerBloco(antes) {
         fim += eol.length;
     const texto = antes.subarray(inicio, fim);
     const linha = texto.toString('utf8').split(eol)[3] ?? '';
-    const m = LINHA_DO_DIRETORIO.exec(linha);
-    let skill;
-    try {
-        skill = m ? JSON.parse(m[1]) : undefined;
-    }
-    catch {
-        return null;
-    }
-    if (typeof skill !== 'string' || /[\r\n`]/.test(skill))
-        return null;
-    const esperado = nucleoDoBloco(skill, eol);
-    if (!texto.equals(esperado) && !texto.equals(esperado.subarray(0, esperado.length - eol.length)))
+    const reconhecido = LOCALES_DO_BLOCO.some((locale) => {
+        const skill = diretorioDaLinha(linha, locale);
+        if (skill === null)
+            return false;
+        const esperado = nucleoDoBloco(skill, eol, locale);
+        return texto.equals(esperado) || texto.equals(esperado.subarray(0, esperado.length - eol.length));
+    });
+    if (!reconhecido)
         return null;
     // Uma linha em branco antes do bloco é o separador que a instalação põe depois de uma linha.
     const sep = Buffer.from(eol);
@@ -144,8 +161,11 @@ function removerBloco(antes, bloco) {
     const juncao = prefixo.length && prefixo.at(-1) !== 10 && sufixo.length ? Buffer.from(bloco.eol) : Buffer.alloc(0);
     return Buffer.concat([prefixo, juncao, sufixo]);
 }
-/** Planejamento puro em relação ao disco: dry-run e preflight usam o mesmo contrato. */
-function planejarExperiencia(projeto, host, skill) {
+/**
+ * Planejamento puro em relação ao disco: dry-run e preflight usam o mesmo contrato. O bloco sai no `locale` pedido
+ * (RM-061, F3a), pt-BR por omissão: só o `ork adapter install` passa a língua do dono (D2).
+ */
+function planejarExperiencia(projeto, host, skill, locale = locale_1.LOCALE_PADRAO) {
     projeto = fs.realpathSync(path.resolve(projeto));
     if (!['claude-code', 'codex'].includes(host))
         throw Error('experiencia.host.unsupported');
@@ -189,7 +209,7 @@ function planejarExperiencia(projeto, host, skill) {
         let separador, nucleo, anterior;
         if (antes && bloco) {
             // Atualização no lugar: o que está antes e depois do bloco, inclusive edição externa, fica.
-            nucleo = nucleoDoBloco(skill, bloco.eol);
+            nucleo = nucleoDoBloco(skill, bloco.eol, locale);
             separador = bloco.separador;
             depois = Buffer.concat([antes.subarray(0, bloco.inicio), nucleo, antes.subarray(bloco.fim)]);
             // Adotado sem recibo: se só havia o bloco, o arquivo conta como criado pelo pacote.
@@ -198,7 +218,7 @@ function planejarExperiencia(projeto, host, skill) {
         }
         else {
             const base = antes ?? Buffer.alloc(0), eol = eolDe(base);
-            nucleo = nucleoDoBloco(skill, eol);
+            nucleo = nucleoDoBloco(skill, eol, locale);
             separador = Buffer.from(base.length ? (base.at(-1) === 10 ? eol : eol + eol) : '');
             depois = Buffer.concat([base, separador, nucleo]);
             anterior = antes?.toString('base64') ?? null;

package/dist/experiencia.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.IDIOMA_PADRAO = void 0;
 exports.normalizarIdioma = normalizarIdioma;
 exports.validarPreferencias = validarPreferencias;
 exports.idiomaDoSistema = idiomaDoSistema;
@@ -44,6 +45,11 @@ function validarPreferencias(valor) {
     }
     return resultado;
 }
+/**
+ * Ensaio de 03/10 (R2): sem idioma escolhido, vale a língua da CLI. Antes era en-US, e uma máquina com
+ * LANG=C.UTF-8 (contêiner, CI, servidor) recebia a experiência em inglês de uma CLI que fala português.
+ */
+exports.IDIOMA_PADRAO = 'pt-BR';
 /** C, POSIX e und (raiz do ICU) dizem que o sistema não escolheu idioma: vale o padrão. */
 const SEM_IDIOMA = new Set(['c', 'posix', 'und']);
 function idiomaEscolhido(valor) {
@@ -52,11 +58,15 @@ function idiomaEscolhido(valor) {
 }
 function idiomaDoSistema(env = process.env, doIntl = () => Intl.DateTimeFormat().resolvedOptions().locale) {
     const locale = env.LC_ALL || env.LC_MESSAGES || env.LANG;
-    return idiomaEscolhido(locale?.split(/[.@]/)[0].replace(/_/g, '-')) ?? idiomaEscolhido(doIntl()) ?? 'en-US';
+    if (locale) {
+        // Com C ou POSIX explícito, o Intl do Node cai no en-US do ICU: ele não diz a escolha de ninguém.
+        return idiomaEscolhido(locale.split(/[.@]/)[0].replace(/_/g, '-')) ?? exports.IDIOMA_PADRAO;
+    }
+    return idiomaEscolhido(doIntl()) ?? exports.IDIOMA_PADRAO;
 }
 function resolverExperiencia(owner = {}, sistema = { language: idiomaDoSistema(), timezone: (0, horario_1.fusoDoSistema)() }) {
     const p = validarPreferencias(owner);
-    const language = p.language ?? normalizarIdioma(sistema.language) ?? 'en-US';
+    const language = p.language ?? normalizarIdioma(sistema.language) ?? exports.IDIOMA_PADRAO;
     return {
         language, timezone: p.timezone ?? (0, horario_1.normalizarFuso)(sistema.timezone) ?? 'UTC',
         depth: p.depth ?? 'curta', experience: p.experience ?? true,