@orkastery/cli 0.5.6 → 0.6.1

package/dist/autorizacao-duravel.js

@@ -0,0 +1,327 @@
+"use strict";
+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.PRAZO_MAXIMO_DIAS = exports.ACOES_DA_AUTORIZACAO = exports.ARQUIVO_DA_AUTORIZACAO = exports.CONTRATO_DA_AUTORIZACAO = void 0;
+exports.caminhoDaAutorizacao = caminhoDaAutorizacao;
+exports.lerAutorizacao = lerAutorizacao;
+exports.autorizada = autorizada;
+exports.referenciaDaAutorizacao = referenciaDaAutorizacao;
+exports.linhaDaAutorizacao = linhaDaAutorizacao;
+exports.prazoDoPedido = prazoDoPedido;
+exports.gravarAutorizacao = gravarAutorizacao;
+exports.textoDaAutorizacao = textoDaAutorizacao;
+/**
+ * RM-063 (F5): a autorizacao duravel do dono para a varredura agir sozinha nesta maquina.
+ *
+ * Incidente de 03 a 12/10/2026 (P4 e P5 da pagina da RM-063): o PR #112 foi mesclado e ficou dois dias sem
+ * `ork ship registrar-pr`, e as sessoes fantasmas de threads fechadas ficaram registradas, porque nada roda esses
+ * comandos sem um condutor. Agora a batida da varredura (`pulse-delivery`) faz isso sozinha, mas SO com a autorizacao
+ * do dono gravada nesta maquina, com prazo e com a lista do que ela pode. Sem autorizacao (ou com ela vencida,
+ * ilegivel, de outra maquina ou de outro projeto), cada acao vira um item da fila do pulse com o comando pronto.
+ *
+ * O arquivo e desta maquina e fica fora do git, como o `pulse-host.json` (RM-047):
+ * `.orkastery/monitor/autorizacao.json` no checkout canonico. O contrato e `ork.autorizacao-duravel/v1`; a referencia
+ * esta em `docs/referencia/contratos/autorizacao-duravel-rm063.md`. A leitura (`lerAutorizacao`) nunca grava; a F7
+ * grava pelo `ork conducao autorizar` (`gravarAutorizacao`), ato do dono, na mesma forma que a leitura confere.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const estado_thread_1 = require("./estado-thread");
+const horario_1 = require("./horario");
+const ledger_1 = require("./ledger");
+const master_1 = require("./master");
+const master_nota_1 = require("./master-nota");
+const maquina_1 = require("./maquina");
+const procedencia_1 = require("./procedencia");
+const runtime_ambiente_1 = require("./runtime-ambiente");
+const util_1 = require("./util");
+const locale_1 = require("./locale");
+exports.CONTRATO_DA_AUTORIZACAO = 'ork.autorizacao-duravel/v1';
+exports.ARQUIVO_DA_AUTORIZACAO = 'autorizacao.json';
+/** Um arquivo de autorizacao tem poucas linhas; acima disto, nao e o que o dono gravou. */
+const TETO_DO_ARQUIVO = 64 * 1024;
+/**
+ * As acoes do contrato. A varredura da F5 faz `limpar` (sessoes fantasmas), `registrar` (a entrega de PR ja mesclado)
+ * e `master` (o MASTER por omissao); a batida da conducao da F7 (`ork conducao batida`) faz tambem `merge` (o PR verde de
+ * branch `ork/*`) e `despachar` (a fase seguinte com o prompt gravado). Tag e publicacao nunca entram.
+ */
+exports.ACOES_DA_AUTORIZACAO = ['limpar', 'registrar', 'master', 'merge', 'despachar'];
+/** O arquivo da autorizacao desta maquina, no checkout canonico (de dentro de uma worktree, o da raiz). */
+function caminhoDaAutorizacao(raiz) {
+    return path.join((0, estado_thread_1.raizDoEstado)(raiz), '.orkastery', 'monitor', exports.ARQUIVO_DA_AUTORIZACAO);
+}
+/** A data e a hora existem no calendario (o `Date.parse` aceitaria 30/02 e o levaria a marco, calado). */
+const noCalendario = (v) => {
+    const m = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})/.exec(v);
+    if (!m)
+        return false;
+    const [ano, mes, dia, hora, minuto] = m.slice(1).map(Number);
+    const d = new Date(Date.UTC(ano, mes - 1, dia));
+    return d.getUTCFullYear() === ano && d.getUTCMonth() === mes - 1 && d.getUTCDate() === dia && hora <= 23 && minuto <= 59;
+};
+/** O instante com o fuso explicito (`Z` ou `-03:00`): sem ele, o prazo dependeria do fuso de quem le. */
+const instante = (v) => typeof v === 'string' &&
+    /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2}(\.\d{1,9})?)?(Z|[+-]\d{2}:\d{2})$/.test(v) && noCalendario(v) &&
+    Number.isFinite(Date.parse(v));
+const textoCurto = (v, teto) => typeof v === 'string' && v.trim() !== '' && v.length <= teto &&
+    !/\p{Cc}/u.test(v);
+/**
+ * Le e confere a autorizacao desta maquina. Cada recusa tem motivo tipado e detalhe; so a valida, no prazo, desta
+ * maquina e deste projeto, autoriza alguma coisa.
+ */
+function lerAutorizacao(raiz, opcoes) {
+    const arquivo = caminhoDaAutorizacao(raiz);
+    const recusa = (motivo, detalhe, autorizacao) => ({ valida: false, arquivo, motivo, detalhe, ...(autorizacao ? { autorizacao } : {}) });
+    const st = fs.lstatSync(arquivo, { throwIfNoEntry: false });
+    if (!st)
+        return recusa('autorizacao.ausente', 'nenhuma autorizacao duravel gravada nesta maquina');
+    // RM-047: como o transporte do pulse, a autorizacao so vale do arquivo local desta maquina.
+    if (!st.isFile())
+        return recusa('autorizacao.rastreada', 'a autorizacao precisa ser um arquivo comum desta maquina, nao link nem diretorio');
+    if ((0, procedencia_1.rastreadoPeloGit)(raiz, arquivo))
+        return recusa('autorizacao.rastreada', 'a autorizacao esta versionada no git; ela so vale do arquivo local desta maquina');
+    if (st.size > TETO_DO_ARQUIVO)
+        return recusa('autorizacao.ilegivel', `o arquivo passa de ${TETO_DO_ARQUIVO} bytes`);
+    let bruto, dado;
+    try {
+        bruto = fs.readFileSync(arquivo, 'utf8');
+        const lido = JSON.parse(bruto);
+        if (!lido || typeof lido !== 'object' || Array.isArray(lido))
+            throw new Error('nao e um objeto JSON');
+        dado = lido;
+    }
+    catch (e) {
+        return recusa('autorizacao.ilegivel', `o arquivo nao e JSON valido (${e.message.slice(0, 120)})`);
+    }
+    if (dado.contrato !== exports.CONTRATO_DA_AUTORIZACAO)
+        return recusa('autorizacao.contrato', `o contrato precisa ser ${exports.CONTRATO_DA_AUTORIZACAO}`);
+    for (const [campo, teto] of [['maquina', 80], ['projeto', 80], ['por', 120]]) {
+        if (!textoCurto(dado[campo], teto))
+            return recusa('autorizacao.campo', `o campo ${campo} precisa ser texto de ate ${teto} caracteres`);
+    }
+    // A autoria e a mesma regra da nota do MASTER: nome de agente, de runtime ou generico nao autoriza nada.
+    if (!(0, master_1.autoriaHumana)(dado.por)) {
+        return recusa('autorizacao.campo', 'o campo por precisa nomear a pessoa que autorizou; agente, runtime ou nome generico nao autoriza');
+    }
+    for (const campo of ['concedidaEm', 'ate']) {
+        if (!instante(dado[campo])) {
+            return recusa('autorizacao.campo', `o campo ${campo} precisa ser um instante ISO com fuso (Z ou -03:00), como 2026-10-18T23:59:00-03:00`);
+        }
+    }
+    if (dado.nota !== undefined && !textoCurto(dado.nota, 300))
+        return recusa('autorizacao.campo', 'a nota precisa ser texto de ate 300 caracteres');
+    const pode = dado.pode;
+    if (!Array.isArray(pode) || pode.length === 0 || pode.some((a) => typeof a !== 'string') || new Set(pode).size !== pode.length) {
+        return recusa('autorizacao.campo', 'o campo pode precisa ser uma lista de acoes, sem repeticao');
+    }
+    const desconhecida = pode.find((a) => !exports.ACOES_DA_AUTORIZACAO.includes(a));
+    if (desconhecida !== undefined) {
+        return recusa('autorizacao.acao-desconhecida', `a acao ${JSON.stringify(desconhecida)} nao e do contrato (${exports.ACOES_DA_AUTORIZACAO.join(', ')})`);
+    }
+    const autorizacao = {
+        contrato: exports.CONTRATO_DA_AUTORIZACAO, maquina: dado.maquina, projeto: dado.projeto, por: dado.por,
+        concedidaEm: dado.concedidaEm, ate: dado.ate, pode: pode,
+        ...(typeof dado.nota === 'string' ? { nota: dado.nota } : {}),
+    };
+    const maquina = opcoes.maquina ?? (0, maquina_1.nomeDaMaquina)();
+    if (autorizacao.maquina !== maquina) {
+        return recusa('autorizacao.outra-maquina', `a autorizacao e da maquina ${autorizacao.maquina}, e esta e ${maquina}`, autorizacao);
+    }
+    if (autorizacao.projeto !== opcoes.projeto) {
+        return recusa('autorizacao.outro-projeto', `a autorizacao e do projeto ${autorizacao.projeto}, e este e ${opcoes.projeto}`, autorizacao);
+    }
+    const agora = opcoes.agora ?? new Date();
+    if (Date.parse(autorizacao.ate) <= agora.getTime()) {
+        return recusa('autorizacao.expirada', `o prazo acabou em ${(0, horario_1.formatarDataHoraRotulada)(autorizacao.ate, { agora: agora.toISOString() })}`, autorizacao);
+    }
+    return { valida: true, arquivo, autorizacao, sha256: (0, node_crypto_1.createHash)('sha256').update(bruto, 'utf8').digest('hex') };
+}
+/** A acao esta autorizada agora? */
+function autorizada(leitura, acao) {
+    return leitura.valida && leitura.autorizacao.pode.includes(acao);
+}
+/** A referencia que vai ao ledger com cada acao feita: quem autorizou, ate quando e qual arquivo. */
+function referenciaDaAutorizacao(leitura) {
+    if (!leitura.valida)
+        return null;
+    const a = leitura.autorizacao;
+    return { contrato: a.contrato, por: a.por, ate: a.ate, pode: a.pode, sha256: leitura.sha256, ...(a.nota ? { nota: a.nota } : {}) };
+}
+/** Uma linha para o `ork fabrica batida status` e para o pulse. */
+function linhaDaAutorizacao(leitura, agora = new Date().toISOString()) {
+    const m = (0, locale_1.msg)().conducao.autorizacao;
+    if (leitura.valida) {
+        const a = leitura.autorizacao;
+        return m.linhaValida(a.por, (0, horario_1.formatarDataHoraRotulada)(a.ate, { agora }), a.pode.join(', '));
+    }
+    if (leitura.motivo === 'autorizacao.ausente') {
+        return m.linhaAusente;
+    }
+    return m.linhaInvalida(leitura.motivo, leitura.detalhe);
+}
+// ---------------------------------------------------------------------------
+// RM-063 (F7): a gravacao, pelo `ork conducao autorizar`.
+// ---------------------------------------------------------------------------
+/** O que nunca entra na autorizacao duravel, nem com o nome que o dono der: fica sempre com ele. */
+const ACOES_PROIBIDAS = ['tag', 'tags', 'publicar', 'publicacao', 'publicação', 'release', 'publish', 'npm', 'versao', 'versão'];
+/**
+ * O prazo mais longo que uma autorizacao pode ter: o dono renova quando quiser, e a permissao esquecida nao vale para
+ * sempre.
+ */
+exports.PRAZO_MAXIMO_DIAS = 31;
+/**
+ * O prazo do `--ate`, sempre com o fuso escrito. Instante com fuso vale como veio; so a data vale ate 23:59 dela no fuso
+ * do dono; data e hora sem fuso, no fuso do dono. O resto e recusado: o prazo nao e adivinhado.
+ */
+function prazoDoPedido(bruto, fuso) {
+    const v = bruto.trim();
+    if (instante(v))
+        return v;
+    const m = /^(\d{4})-(\d{2})-(\d{2})(?:[T ](\d{2}):(\d{2}))?$/.exec(v);
+    const nome = (0, horario_1.normalizarFuso)(fuso);
+    if (!m || !nome)
+        return null;
+    const hora = m[4] ? Number(m[4]) : 23, minuto = m[5] ? Number(m[5]) : 59;
+    if (hora > 23 || minuto > 59)
+        return null;
+    const ms = (0, horario_1.instanteNoFuso)(Number(m[1]), Number(m[2]), Number(m[3]), hora, minuto, nome);
+    return Number.isFinite(ms) ? (0, horario_1.isoComFuso)(ms, nome) : null;
+}
+/** O `user.name` do git do checkout, quando nomeia uma pessoa. */
+function autorDoGit(raiz) {
+    const r = (0, util_1.exec)('git', ['config', 'user.name'], (0, estado_thread_1.raizDoEstado)(raiz), 10000);
+    const nome = r.ok ? r.stdout.trim() : '';
+    return nome && textoCurto(nome, 120) && (0, master_1.autoriaHumana)(nome) ? nome : null;
+}
+/**
+ * RM-063 (F7): grava a autorizacao duravel do dono nesta maquina, na forma que `lerAutorizacao` confere. E ato do dono:
+ * a sessao despachada pelo `ork` (com a identidade de despacho no ambiente) nunca concede autorizacao a si mesma. O
+ * arquivo novo substitui o anterior inteiro, e cada concessao vai ao ledger do projeto (`autorizacao_concedida`), com a
+ * que ela substituiu. Tag e publicacao nunca entram, nem com outro nome.
+ */
+function gravarAutorizacao(raiz, pedido) {
+    const recusa = (motivo, detalhe) => ({ ok: false, motivo, detalhe });
+    const ambiente = pedido.ambiente ?? process.env;
+    if ((ambiente[runtime_ambiente_1.ENV_IDENTIDADE_DE_DESPACHO] ?? '').trim() || (ambiente[runtime_ambiente_1.ENV_THREAD_DO_DESPACHO] ?? '').trim()) {
+        return recusa('autorizacao.sessao-despachada', 'a autorização durável é ato do dono: uma sessão despachada pelo ork não a concede ' +
+            '(rode no terminal do dono, fora da sessão da fase)');
+    }
+    // A mesma regra da nota do MASTER em nome de pessoa (D8): de dentro de um host de agente (Claude Code, Codex, Hermes,
+    // OpenClaw), quem escreve o --por e o agente. O dono autoriza no proprio terminal.
+    const host = (0, master_nota_1.marcaDeHost)(ambiente);
+    if (host) {
+        return recusa('autorizacao.host', `a autorização durável é ato do dono no terminal dele: vinda de ${host}, ela não vale ` +
+            '(o agente não autoriza a si mesmo)');
+    }
+    const agora = pedido.agora ?? new Date();
+    const ate = prazoDoPedido(pedido.ate, pedido.fuso);
+    if (!ate) {
+        return recusa('autorizacao.ate-invalido', `--ate ${JSON.stringify(pedido.ate)} não é um prazo: use 2026-10-18 (até 23:59 no fuso ` +
+            `${pedido.fuso}), 2026-10-18T18:00 ou um instante com fuso, como 2026-10-18T23:59:00-03:00`);
+    }
+    if (Date.parse(ate) <= agora.getTime()) {
+        return recusa('autorizacao.ate-passado', `o prazo ${(0, horario_1.formatarDataHoraRotulada)(ate, { agora: agora.toISOString() })} já passou`);
+    }
+    if (Date.parse(ate) - agora.getTime() > exports.PRAZO_MAXIMO_DIAS * 24 * 60 * 60 * 1000) {
+        return recusa('autorizacao.ate-longe', `o prazo vai além de ${exports.PRAZO_MAXIMO_DIAS} dias: autorize por menos e renove quando quiser`);
+    }
+    const pode = pedido.pode.split(',').map((a) => a.trim().toLowerCase()).filter(Boolean);
+    if (!pode.length)
+        return recusa('autorizacao.pode-vazio', `--pode precisa de pelo menos uma ação (${exports.ACOES_DA_AUTORIZACAO.join(', ')})`);
+    if (new Set(pode).size !== pode.length)
+        return recusa('autorizacao.pode-repetido', '--pode repete uma ação');
+    const proibida = pode.find((a) => ACOES_PROIBIDAS.includes(a));
+    if (proibida) {
+        return recusa('autorizacao.acao-proibida', `${JSON.stringify(proibida)}: tag e publicação nunca entram na autorização durável; ` +
+            'ficam sempre com o dono');
+    }
+    const desconhecida = pode.find((a) => !exports.ACOES_DA_AUTORIZACAO.includes(a));
+    if (desconhecida !== undefined) {
+        return recusa('autorizacao.acao-desconhecida', `a ação ${JSON.stringify(desconhecida)} não é do contrato (${exports.ACOES_DA_AUTORIZACAO.join(', ')})`);
+    }
+    const por = (pedido.por ?? '').trim() || autorDoGit(raiz);
+    if (!por || !textoCurto(por, 120) || !(0, master_1.autoriaHumana)(por)) {
+        return recusa('autorizacao.por', por ? `--por ${JSON.stringify(por)} não nomeia uma pessoa (agente, runtime ou nome genérico não autoriza)`
+            : 'informe --por <seu nome>: o git deste checkout não tem user.name de uma pessoa');
+    }
+    const nota = (pedido.nota ?? '').trim();
+    if (nota && !textoCurto(nota, 300))
+        return recusa('autorizacao.nota', 'a nota precisa ser texto de até 300 caracteres, sem controle');
+    const arquivo = caminhoDaAutorizacao(raiz);
+    const st = fs.lstatSync(arquivo, { throwIfNoEntry: false });
+    if ((st && !st.isFile()) || (0, procedencia_1.rastreadoPeloGit)(raiz, arquivo)) {
+        return recusa('autorizacao.rastreada', `${arquivo} está no git, ou é link ou diretório: a autorização só vale do arquivo local desta máquina`);
+    }
+    const lida = lerAutorizacao(raiz, { projeto: pedido.projeto, agora, maquina: pedido.maquina });
+    const anterior = lida.valida ? lida.autorizacao : null;
+    const autorizacao = {
+        contrato: exports.CONTRATO_DA_AUTORIZACAO, maquina: pedido.maquina ?? (0, maquina_1.nomeDaMaquina)(), projeto: pedido.projeto, por,
+        concedidaEm: (0, horario_1.isoComFuso)(agora.getTime(), (0, horario_1.normalizarFuso)(pedido.fuso) ?? 'UTC'), ate, pode: pode,
+        ...(nota ? { nota } : {}),
+    };
+    fs.mkdirSync(path.dirname(arquivo), { recursive: true });
+    const temporario = `${arquivo}.${process.pid}.${(0, node_crypto_1.randomUUID)().slice(0, 8)}.tmp`;
+    try {
+        fs.writeFileSync(temporario, JSON.stringify(autorizacao, null, 2) + '\n', { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+        fs.renameSync(temporario, arquivo);
+    }
+    finally {
+        fs.rmSync(temporario, { force: true });
+    }
+    const leitura = lerAutorizacao(raiz, { projeto: pedido.projeto, agora, maquina: pedido.maquina });
+    if (!leitura.valida)
+        throw new Error(`a autorização gravada não foi aceita na releitura (${leitura.motivo}: ${leitura.detalhe})`);
+    try {
+        (0, ledger_1.registrar)(path.join((0, estado_thread_1.raizDoEstado)(raiz), '.orkastery'), 'projeto', ledger_1.TIPOS_DE_EVENTO.autorizacaoConcedida, {
+            maquina: autorizacao.maquina, por, concedidaEm: autorizacao.concedidaEm, ate, pode, ...(nota ? { nota } : {}),
+            sha256: leitura.sha256, canal: pedido.canal ?? null,
+            substituiu: anterior ? { por: anterior.por, ate: anterior.ate, pode: anterior.pode } : null,
+        });
+    }
+    catch { /* o arquivo e a autorizacao; o ledger do projeto e o rastro, e a releitura ja provou o arquivo */ }
+    return { ok: true, leitura, anterior };
+}
+/** O texto do `ork conducao autorizacao`: a vigente, ou por que nao ha, e o que isso quer dizer para a batida. */
+function textoDaAutorizacao(leitura, agora = new Date().toISOString()) {
+    const m = (0, locale_1.msg)().conducao.autorizacao;
+    if (!leitura.valida) {
+        return [m.sem(leitura.motivo, leitura.detalhe), m.semEfeito, m.autorizar].join('\n');
+    }
+    const a = leitura.autorizacao;
+    return [m.valida(a.por, (0, horario_1.formatarDataHoraRotulada)(a.ate, { agora }), a.pode.join(', ')),
+        m.concedida((0, horario_1.formatarDataHoraRotulada)(a.concedidaEm, { agora }), a.maquina, a.projeto, a.nota ?? ''),
+        m.arquivo(leitura.arquivo, leitura.sha256.slice(0, 12)), m.limite].join('\n');
+}

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;
@@ -128,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
@@ -142,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)) {
@@ -176,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;
@@ -429,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),
@@ -468,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)));
@@ -493,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,
@@ -519,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}`);
     }
@@ -535,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');
 }