@orkastery/cli 0.5.1 → 0.5.6

package/dist/conducao-sentinela.js

@@ -0,0 +1,388 @@
+"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_DA_PRESENCA_MS = exports.CONTRATO_DA_SENTINELA = exports.CANAL_DA_SENTINELA = void 0;
+exports.caminhoDaPresenca = caminhoDaPresenca;
+exports.presencaDaSentinela = presencaDaSentinela;
+exports.baterSentinela = baterSentinela;
+exports.desligarSentinela = desligarSentinela;
+exports.faseJaFeita = faseJaFeita;
+exports.bloqueioDepoisDoDespacho = bloqueioDepoisDoDespacho;
+exports.passoDaThread = passoDaThread;
+exports.passosDoCondutor = passosDoCondutor;
+exports.statusDaSentinela = statusDaSentinela;
+exports.textoDoStatusDaSentinela = textoDoStatusDaSentinela;
+/**
+ * RM-059 (fatia F6, T6.4; DD5 do plano dos mods): a conducao pela Sentinela do Condutor.
+ *
+ * A Sentinela (`adapters/claude-code/mods/ork-sentinela`) roda na sessao do dono no Claude Code e despacha a fase
+ * seguinte das threads #Auto pelo proprio nucleo (`ork phase run`, que toma o lease `exec:<thread>` e e idempotente).
+ * Dois fatos moram aqui, e so aqui:
+ *
+ * - a PRESENCA dela nesta maquina, com prazo curto renovado pela batida: enquanto ela vale, o condutor externo cede
+ *   o despacho e o retry; vencida (a sessao do dono fechou), ele volta a conduzir sozinho, como reserva;
+ * - o PASSO DO CONDUTOR de cada thread aberta, calculado com as mesmas leituras do pulse (`entregasDoProjeto`,
+ *   `esperaDoCondutor`), sem o limiar de 30 min e sem ler a forja. No #Auto, depois de uma fase concluida, sai a
+ *   fase seguinte a prova mais adiantada que a sessao do bloco deixou (artefato gravado depois do despacho, produto
+ *   na branch, `ship_done`, `master_done`), e nada sai quando o bloco ja passou do CHECK: a sessao que fez o bloco
+ *   inteiro nao ganha um PLAN repetido. A pendencia do dono (thread pausada, pergunta aberta) segura tudo.
+ *
+ * Nada aqui despacha nem toma conducao: quem despacha e o `ork phase run`, e a Sentinela nunca assume a conducao.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const conducao_1 = require("./conducao");
+const estado_thread_1 = require("./estado-thread");
+const ledger_1 = require("./ledger");
+const manifest_1 = require("./manifest");
+const maquina_1 = require("./maquina");
+const parado_no_condutor_1 = require("./parado-no-condutor");
+const thread_1 = require("./thread");
+var conducao_2 = require("./conducao");
+Object.defineProperty(exports, "CANAL_DA_SENTINELA", { enumerable: true, get: function () { return conducao_2.CANAL_DA_SENTINELA; } });
+Object.defineProperty(exports, "CONTRATO_DA_SENTINELA", { enumerable: true, get: function () { return conducao_2.CONTRATO_DA_SENTINELA; } });
+Object.defineProperty(exports, "PRAZO_DA_PRESENCA_MS", { enumerable: true, get: function () { return conducao_2.PRAZO_DA_PRESENCA_MS; } });
+/** O id da sessao do Claude Code que conduz pela Sentinela (o UUID dela, ou outro id curto sem espaco). */
+const SESSAO_VALIDA = /^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/;
+/** Uma trava de presenca mais velha que isto e de um processo que morreu no meio da escrita. */
+const TRAVA_VELHA_MS = 10 * 1000;
+const ESPERA_DA_TRAVA_MS = 3 * 1000;
+/** O nome da maquina como pedaco de nome de arquivo. */
+function nomeSeguro(maquina) {
+    return maquina.replace(/[^a-zA-Z0-9._-]/g, '-').replace(/^[.-]+/, '').slice(0, 64) || 'maquina';
+}
+function exigirSessao(sessao) {
+    if (typeof sessao !== 'string' || !SESSAO_VALIDA.test(sessao)) {
+        throw new Error('conducao.sentinela.sessao: --sessao exige o id da sessao do Claude Code (letras, digitos, ponto, hifen ou dois-pontos, ate 128)');
+    }
+    return sessao;
+}
+/** O ledger do projeto e o da raiz do estado, chamado da raiz ou de qualquer worktree (como o do setup). */
+function dirDoLedgerDoProjeto(raiz) {
+    return (0, manifest_1.dirEstado)((0, estado_thread_1.raizDoEstado)(raiz));
+}
+/** O arquivo da presenca desta maquina, no estado canonico do projeto. */
+function caminhoDaPresenca(raiz, maquina = (0, maquina_1.nomeDaMaquina)()) {
+    return path.join(dirDoLedgerDoProjeto(raiz), 'conducao', `sentinela-${nomeSeguro(maquina)}.json`);
+}
+function lerPresencaGravada(arquivo) {
+    let bruto;
+    try {
+        bruto = JSON.parse(fs.readFileSync(arquivo, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+    const p = bruto;
+    if (!p || p.contrato !== conducao_1.CONTRATO_DA_SENTINELA || p.canal !== conducao_1.CANAL_DA_SENTINELA)
+        return null;
+    for (const campo of ['maquina', 'sessao', 'desde', 'batidaEm', 'expiraEm']) {
+        if (typeof p[campo] !== 'string' || p[campo] === '')
+            return null;
+    }
+    if (!Number.isFinite(Date.parse(p.expiraEm)))
+        return null;
+    return p;
+}
+function comoLeitura(p, agora) {
+    return { ...p, ativa: Date.parse(p.expiraEm) > agora.getTime() };
+}
+function dormirSincrono(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+/** Uma escrita da presenca por vez: a trava e um arquivo criado com O_EXCL ao lado dela. */
+function comTrava(arquivo, fn) {
+    fs.mkdirSync(path.dirname(arquivo), { recursive: true });
+    const trava = `${arquivo}.trava`;
+    const limite = Date.now() + ESPERA_DA_TRAVA_MS;
+    for (;;) {
+        try {
+            fs.closeSync(fs.openSync(trava, 'wx'));
+            break;
+        }
+        catch (e) {
+            if (e.code !== 'EEXIST')
+                throw e;
+            const st = fs.statSync(trava, { throwIfNoEntry: false });
+            if (st && Date.now() - st.mtimeMs > TRAVA_VELHA_MS) {
+                // So a mesma trava velha sai: se outra sessao a trocou no meio (outro inode ou outro mtime), ela fica.
+                const deNovo = fs.statSync(trava, { throwIfNoEntry: false });
+                if (deNovo && deNovo.ino === st.ino && deNovo.mtimeMs === st.mtimeMs)
+                    fs.rmSync(trava, { force: true });
+                continue;
+            }
+            if (Date.now() > limite)
+                throw new Error('conducao.sentinela.trava: outra escrita da presenca nao terminou; tente de novo');
+            dormirSincrono(25);
+        }
+    }
+    try {
+        return fn();
+    }
+    finally {
+        fs.rmSync(trava, { force: true });
+    }
+}
+function gravarPresenca(arquivo, p) {
+    const temporario = `${arquivo}.${process.pid}.${(0, node_crypto_1.randomUUID)().slice(0, 8)}.tmp`;
+    fs.writeFileSync(temporario, JSON.stringify(p, null, 2) + '\n', { encoding: 'utf8', mode: 0o644 });
+    fs.renameSync(temporario, arquivo);
+}
+/** A presenca da Sentinela nesta maquina, viva ou vencida; `null` quando nao ha uma valida gravada. */
+function presencaDaSentinela(raiz, opcoes = {}) {
+    const gravada = lerPresencaGravada(caminhoDaPresenca(raiz, opcoes.maquina));
+    return gravada ? comoLeitura(gravada, opcoes.agora ?? new Date()) : null;
+}
+/**
+ * A batida da Sentinela: renova a presenca da propria sessao, ou a toma quando nao ha outra viva. Com outra
+ * sessao viva nesta maquina, devolve `ok: false` e a presenca dela, sem tocar em nada: uma Sentinela por maquina.
+ * So a troca (presenca nova, inclusive depois de uma vencida) vai ao ledger do projeto.
+ */
+function baterSentinela(raiz, opcoes) {
+    const sessao = exigirSessao(opcoes.sessao);
+    const agora = opcoes.agora ?? new Date();
+    const maquina = opcoes.maquina ?? (0, maquina_1.nomeDaMaquina)();
+    const arquivo = caminhoDaPresenca(raiz, maquina);
+    return comTrava(arquivo, () => {
+        const atual = lerPresencaGravada(arquivo);
+        const viva = !!atual && Date.parse(atual.expiraEm) > agora.getTime();
+        if (atual && viva && atual.sessao !== sessao)
+            return { ok: false, ligou: false, presenca: comoLeitura(atual, agora) };
+        const quando = agora.toISOString();
+        const nova = {
+            contrato: conducao_1.CONTRATO_DA_SENTINELA, canal: conducao_1.CANAL_DA_SENTINELA, maquina, sessao,
+            desde: atual && viva ? atual.desde : quando, batidaEm: quando,
+            expiraEm: new Date(agora.getTime() + conducao_1.PRAZO_DA_PRESENCA_MS).toISOString(),
+        };
+        gravarPresenca(arquivo, nova);
+        const ligou = !(atual && viva);
+        if (ligou) {
+            (0, ledger_1.registrar)(dirDoLedgerDoProjeto(raiz), 'projeto', ledger_1.TIPOS_DE_EVENTO.sentinelaLigada, {
+                canal: conducao_1.CANAL_DA_SENTINELA, sessao, maquina, prazoMs: conducao_1.PRAZO_DA_PRESENCA_MS,
+                ...(atual ? { anterior: { sessao: atual.sessao, expiraEm: atual.expiraEm } } : {}),
+            });
+        }
+        return { ok: true, ligou, presenca: comoLeitura(nova, agora) };
+    });
+}
+/** Tira a presenca da propria sessao; a de outra sessao fica como esta. */
+function desligarSentinela(raiz, opcoes) {
+    const sessao = exigirSessao(opcoes.sessao);
+    const agora = opcoes.agora ?? new Date();
+    const maquina = opcoes.maquina ?? (0, maquina_1.nomeDaMaquina)();
+    const arquivo = caminhoDaPresenca(raiz, maquina);
+    return comTrava(arquivo, () => {
+        const atual = lerPresencaGravada(arquivo);
+        if (!atual || atual.sessao !== sessao)
+            return { desligada: false, presenca: atual ? comoLeitura(atual, agora) : null };
+        fs.rmSync(arquivo, { force: true });
+        (0, ledger_1.registrar)(dirDoLedgerDoProjeto(raiz), 'projeto', ledger_1.TIPOS_DE_EVENTO.sentinelaDesligada, {
+            canal: conducao_1.CANAL_DA_SENTINELA, sessao, maquina, motivo: (opcoes.motivo ?? 'pedido da sessao').slice(0, 200),
+            vivaAte: atual.expiraEm,
+        });
+        return { desligada: true, presenca: null };
+    });
+}
+/** As fases que, com produto ja na branch, a sessao do bloco ja fez (ha produto, entao houve GO). */
+const FASES_ANTES_DO_PRODUTO = ['PLAN', 'GO'];
+/** O artefato de cada fase que tem um, na pasta `docs/` da thread. */
+const ARTEFATO_DA_FASE = { GOAL: 'goal.md', PLAN: 'plan.md', CHECK: 'check.md' };
+/** O evento que prova a fase sem artefato. */
+const EVENTO_DA_FASE = { SHIP: 'ship_done', MASTER: 'master_done' };
+const BLOQUEIOS = [ledger_1.TIPOS_DE_EVENTO.gateBloqueado, ledger_1.TIPOS_DE_EVENTO.despachoFalhou];
+/**
+ * Por que a sessao do ultimo despacho ja fez a fase, quando fez: no #Auto ela roda o bloco inteiro, e o
+ * artefato da fase gravado depois do despacho, o produto na branch (PLAN e GO) ou o evento da fase (SHIP e
+ * MASTER) depois dele provam que a fase seguinte ja aconteceu. `null`: nada prova, e a fase pode sair.
+ */
+function faseJaFeita(raiz, t, fase, estado, eventos) {
+    const despacho = [...eventos].reverse().find((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.faseDespachada);
+    const desde = despacho ? Date.parse(despacho.ts) : Number.NEGATIVE_INFINITY;
+    const artefato = ARTEFATO_DA_FASE[fase];
+    if (artefato) {
+        const st = fs.statSync(path.join((0, thread_1.dirThread)(raiz, t.id), 'docs', artefato), { throwIfNoEntry: false });
+        if (st && st.mtimeMs >= desde)
+            return `o ${artefato} foi gravado depois do despacho`;
+    }
+    if (FASES_ANTES_DO_PRODUTO.includes(fase) && estado.comProduto)
+        return `a branch ja tem produto, e o ${fase} vem antes dele`;
+    const evento = EVENTO_DA_FASE[fase];
+    if (evento && eventos.some((e) => e.tipo === evento && Date.parse(e.ts) >= desde))
+        return `o ${evento} ja esta no ledger depois do despacho`;
+    return null;
+}
+/** O bloqueio que sobrou do ultimo despacho: o ultimo evento de gate depois dele, quando reprova. */
+function bloqueioDepoisDoDespacho(eventos) {
+    let inicio = -1;
+    for (let i = eventos.length - 1; i >= 0; i--)
+        if (eventos[i].tipo === ledger_1.TIPOS_DE_EVENTO.faseDespachada) {
+            inicio = i;
+            break;
+        }
+    for (let i = eventos.length - 1; i > inicio; i--) {
+        const e = eventos[i];
+        if (e.tipo === ledger_1.TIPOS_DE_EVENTO.gateLiberado)
+            return null;
+        if (BLOQUEIOS.includes(e.tipo)) {
+            return { motivo: typeof e.motivo === 'string' && e.motivo ? e.motivo : e.tipo, em: e.ts,
+                deDespacho: e.tipo === ledger_1.TIPOS_DE_EVENTO.despachoFalhou || e.gate === 'phase.dispatch' };
+        }
+    }
+    return null;
+}
+/** As fases da entrega: depois de um bloco que ja passou do CHECK, quem publica e entrega e o condutor externo e o dono. */
+const FASES_DA_ENTREGA = ['SHIP', 'MASTER'];
+/**
+ * O passo de uma thread, pelas leituras que o pulse ja faz dela (`EstadoDaEntrega`). `jaFeita` diz por que a
+ * sessao do bloco ja fez uma fase (`faseJaFeita`), ou `null`; `doDono` e a pendencia do dono (`pendenciaDoDono`:
+ * thread pausada, pergunta aberta, escalacao), que segura qualquer passo automatico.
+ *
+ * No #Auto, depois de uma fase concluida, vale a prova mais adiantada que a sessao do bloco deixou: a fase seguinte a
+ * ela sai, e as do meio sem prova contam como feitas (nao ha CHECK sem GO). Se o bloco ja passou do CHECK, o passo e o
+ * da entrega (SHIP e MASTER ficam com o condutor externo e o dono) e vira aviso.
+ */
+function passoDaThread(t, estado, eventos, pedidoGuardado, jaFeita = () => null, doDono = null) {
+    const espera = estado.espera;
+    const base = {
+        thread: t.id, modo: t.modo, faseAtual: t.faseAtual, conduzida: estado.conduzidaAgora, fase: null,
+        caso: estado.parado?.caso ?? null, proximoPasso: estado.parado?.proximoPasso ?? null,
+        desdeEm: estado.parado?.desdeEm ?? espera?.fimDoTurnoEm ?? null,
+        bloqueio: bloqueioDepoisDoDespacho(eventos), pedidoGuardado,
+    };
+    const avisarOuNada = (porque) => ({ ...base, acao: base.caso ? 'avisar' : 'nada', porque });
+    if (estado.conduzidaAgora)
+        return { ...base, acao: 'nada', porque: 'conduzida agora: quem conduz segue' };
+    if (doDono)
+        return avisarOuNada(`o passo e do dono (${doDono}): nada sai sozinho`);
+    // Como o cron: so o #Auto anda sem o dono. Nos outros modos o caso do nucleo vira aviso.
+    if (t.modo !== 'auto')
+        return avisarOuNada(`modo ${t.modo}: so o #Auto e conduzido sem o dono`);
+    // Um despacho tentado depois do fim do turno falhou (a sessao nem abriu): quem decide o proximo passo e o retry plan,
+    // com a ordem de fallback do runtime, e nao um despacho repetido.
+    if (espera && base.bloqueio?.deDespacho && Date.parse(base.bloqueio.em) > Date.parse(espera.fimDoTurnoEm)) {
+        return { ...base, acao: 'retomar', desdeEm: base.bloqueio.em,
+            porque: `o despacho depois do fim do turno falhou (${base.bloqueio.motivo}): o retry plan diz se a retomada e automatica` };
+    }
+    if (espera?.tipo === 'check-sem-veredito') {
+        return { ...base, acao: 'despachar', fase: 'CHECK', desdeEm: espera.fimDoTurnoEm,
+            porque: 'CHECK em done sem exatamente um veredito: o passo do nucleo e redespachar o CHECK' };
+    }
+    if (espera?.tipo === 'concluida' && espera.comProva !== false) {
+        const rodou = espera.fase;
+        const i = rodou ? t.fases.indexOf(rodou) : -1;
+        if (i < 0 || i + 1 >= t.fases.length)
+            return avisarOuNada(`fase ${rodou ?? '-'} concluida e nao ha fase depois dela no ciclo`);
+        // A prova mais adiantada que a sessao deixou depois da fase do resultado.
+        let maisAdiantada = -1;
+        let prova = null;
+        for (let k = i + 1; k < t.fases.length; k++) {
+            const feita = jaFeita(t.fases[k]);
+            if (feita) {
+                maisAdiantada = k;
+                prova = `${t.fases[k]}: ${feita}`;
+            }
+        }
+        const proxima = t.fases[maisAdiantada >= 0 ? maisAdiantada + 1 : i + 1] ?? null;
+        if (!proxima)
+            return avisarOuNada(`fase ${rodou} concluida, e a sessao do bloco ja fez ate o fim do ciclo (${prova})`);
+        if (maisAdiantada >= 0 && FASES_DA_ENTREGA.includes(proxima)) {
+            return avisarOuNada(`fase ${rodou} concluida, e a sessao do bloco ja passou do CHECK (${prova}): o passo e o da entrega`);
+        }
+        return { ...base, acao: 'despachar', fase: proxima, desdeEm: espera.fimDoTurnoEm,
+            porque: prova ? `fase ${rodou} concluida, e a sessao do bloco ja fez ate ${prova}: a seguinte e ${proxima}`
+                : `fase ${rodou} concluida: a seguinte e ${proxima}` };
+    }
+    if (!espera && base.bloqueio) {
+        return { ...base, acao: 'retomar', desdeEm: base.bloqueio.em,
+            porque: `bloqueio ${base.bloqueio.motivo} depois do ultimo despacho: o retry plan diz se a retomada e automatica` };
+    }
+    return avisarOuNada(espera ? `fim do turno ${espera.tipo}: o passo e do dono ou da entrega` : 'nada a conduzir agora');
+}
+function temPedidoGuardado(raiz, t) {
+    try {
+        return (0, thread_1.pedidoDaThread)(raiz, t) !== null;
+    }
+    catch {
+        return false;
+    }
+}
+/** O passo do condutor em cada thread aberta deste checkout, em ordem de id. */
+function passosDoCondutor(carregado, opcoes = {}) {
+    const quando = opcoes.quando ?? new Date().toISOString();
+    const entregas = (0, parado_no_condutor_1.entregasDoProjeto)(carregado, { quando, limiarMin: 0 });
+    const passos = [];
+    for (const estado of entregas.estados) {
+        let t;
+        try {
+            t = (0, thread_1.lerThread)(carregado.raiz, estado.thread);
+        }
+        catch {
+            continue;
+        }
+        let eventos = [];
+        try {
+            eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(carregado.raiz, t.id));
+        }
+        catch { /* ledger ilegivel: sem bloqueio */ }
+        passos.push(passoDaThread(t, estado, eventos, temPedidoGuardado(carregado.raiz, t), (fase) => faseJaFeita(carregado.raiz, t, fase, estado, eventos), (0, parado_no_condutor_1.pendenciaDoDono)(t, eventos, quando)));
+    }
+    return passos.sort((a, b) => (a.thread < b.thread ? -1 : a.thread > b.thread ? 1 : 0));
+}
+/** O `ork conducao sentinela status`: a presenca desta maquina e o passo do condutor em cada thread aberta. */
+function statusDaSentinela(carregado, opcoes = {}) {
+    const agora = opcoes.agora ?? new Date();
+    const maquina = opcoes.maquina ?? (0, maquina_1.nomeDaMaquina)();
+    return {
+        contrato: conducao_1.CONTRATO_DA_SENTINELA, consultadoEm: agora.toISOString(), maquina,
+        presenca: presencaDaSentinela(carregado.raiz, { agora, maquina }),
+        threads: passosDoCondutor(carregado, { quando: agora.toISOString() }),
+    };
+}
+/** O status em texto, para o terminal. */
+function textoDoStatusDaSentinela(s) {
+    const linhas = [];
+    const p = s.presenca;
+    linhas.push(!p ? `Sentinela: desligada na maquina ${s.maquina}; o condutor externo conduz.`
+        : p.ativa ? `Sentinela: ligada na maquina ${s.maquina}, canal ${p.canal}, sessao ${p.sessao.slice(0, 8)}; o condutor externo cede o despacho e o retry.`
+            : `Sentinela: a presenca da sessao ${p.sessao.slice(0, 8)} venceu; o condutor externo conduz.`);
+    if (s.threads.length === 0)
+        linhas.push('  nenhuma thread aberta neste checkout');
+    for (const t of s.threads) {
+        const acao = t.acao === 'despachar' ? `despachar ${t.fase}` : t.acao;
+        linhas.push(`  ${t.thread.padEnd(20)} ${t.modo.padEnd(8)} ${acao.padEnd(16)} ${t.porque}`);
+    }
+    return linhas.join('\n');
+}

package/dist/conducao-texto.js

@@ -12,17 +12,9 @@ exports.linhaDeConducao = linhaDeConducao;
  * `thread.ts` e o `leases.ts` possam usa-lo sem ciclo de importacao.
  */
 const horario_1 = require("./horario");
-/** O que cada operacao de conducao e, em portugues de gente. */
-exports.NOME_DA_OPERACAO = {
-    'phase.run': 'despacho de fase',
-    'retry.run': 'retomada de fase',
-    verify: 'ork verify',
-    baseline: 'ork verify --baseline',
-    'fix.open': 'ork fix open',
-    'fix.reverify': 'ork fix reverify',
-    'mcp.verify': 'ork_verify (MCP)',
-    handoff: 'reserva de quem assumiu',
-};
+const locale_1 = require("./locale");
+/** O que cada operacao de conducao e, em portugues de gente (o texto gravado das recusas usa este). */
+exports.NOME_DA_OPERACAO = (0, locale_1.msg)('pt-BR').thread.operacoes;
 /** O objeto de leitura a partir do lease, sem consultar nada. */
 function conducaoDoLease(lease) {
     const c = lease.conducao;
@@ -43,19 +35,21 @@ function conducaoDoLease(lease) {
 }
 /** Quem segura a conducao, em poucas palavras: a sessao, o processo ou a reserva. */
 function quemConduz(c) {
+    // RM-061 (F2a): no locale do comando; fora dos comandos cobertos, o pt-BR de sempre.
+    const m = (0, locale_1.msg)().thread;
     if (c.sessao)
-        return `sessao ${c.sessao.slice(0, 8)}`;
+        return m.quemSessao(c.sessao.slice(0, 8));
     if (c.dono.tipo === 'processo')
-        return `processo ${c.dono.pid} (${exports.NOME_DA_OPERACAO[c.operacao]})`;
+        return m.quemProcesso(c.dono.pid, m.operacoes[c.operacao]);
     if (c.dono.tipo === 'reserva')
-        return `reserva de ${c.dono.por}`;
-    return exports.NOME_DA_OPERACAO[c.operacao];
+        return m.quemReserva(c.dono.por);
+    return m.operacoes[c.operacao];
 }
 /**
- * "conduzido agora por CANAL, sessao ID, fase F, desde HORARIO": a linha unica (CS7). O horario
+ * A linha unica de quem conduz (CS7): canal, quem, fase e desde, na redacao do catalogo (`msg().thread.conduzido`,
+ * RM-061), no locale do comando; fora dos comandos cobertos, o pt-BR de sempre. O horario
  * sai no fuso do dono; a legenda do fuso fica com a superficie, uma vez por tela.
  */
 function linhaDeConducao(c, opcoes = {}) {
-    return `conduzido agora por ${c.canal}, ${quemConduz(c)}, fase ${c.fase ?? '-'}, ` +
-        `desde ${(0, horario_1.formatarDataHora)(c.desde, opcoes.agora ? { agora: opcoes.agora } : {})}`;
+    return (0, locale_1.msg)().thread.conduzido(c.canal, quemConduz(c), c.fase ?? '-', (0, horario_1.formatarDataHora)(c.desde, opcoes.agora ? { agora: opcoes.agora } : {}));
 }