@orkastery/cli 0.5.1 → 0.5.6

package/dist/locale-thread.js

@@ -0,0 +1,277 @@
+"use strict";
+/**
+ * RM-061, fatia F2a: a familia `thread` do catalogo de mensagens (`ork thread new` e `ork thread
+ * status`, o resumo da thread, a linha de conducao, a worktree e os avisos da criacao). O pt-BR e a
+ * fonte; o ingles e tipado por ele. Sem import do nucleo: o que vem do estado entra por parametro.
+ *
+ * Dado gravado sai como foi gravado: nome e assunto da thread, criterio e comando de pronto, o
+ * regime do score. Valor fechado que o texto mostra (status da thread, `pausaSobre` de um bloco,
+ * nome da operacao de conducao) so e traduzido na impressao; `thread.json` nao muda.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.THREAD_EN = exports.THREAD_PT_BR = void 0;
+const PAUSA_SOBRE_EN = {
+    objetivo: 'goal', plano: 'plan', implementacao: 'implementation', evidencias: 'evidence', push: 'push', score: 'score',
+    premissas: 'assumptions', 'evidencias, com autorizacao antecipada de push': 'evidence, with push authorized in advance',
+};
+const STATUS_EN = { aberta: 'open', pausada: 'paused', fechada: 'closed' };
+exports.THREAD_PT_BR = {
+    /** Largura do rotulo no resumo (`  id        valor`). */
+    largura: 9,
+    rotulos: { id: 'id', slug: 'slug', nome: 'nome', modo: 'modo', ciclo: 'ciclo', fase: 'fase', status: 'status', base: 'base',
+        worktree: 'worktree', conducao: 'conducao', score: 'score' },
+    modo: (tag, pausas) => `${tag} (${pausas} pausas humanas previstas)`,
+    cicloPadrao: 'padrao do modo',
+    status: (status) => status,
+    raizDoProjeto: '(raiz do projeto)',
+    ninguemConduz: 'ninguem conduz agora',
+    validacao: '  validacao CHECK em runtime diferente do GO (exigido pela thread)',
+    prontoQuando: (n) => `  pronto quando (${n} criterio(s) executaveis)`,
+    score: (valor, por, regime, quando) => `${valor}/5 por ${por} (${regime}) em ${quando}`,
+    blocosPrevistos: '  blocos previstos',
+    pausaPrevista: (sobre) => `pausa prevista: ${sobre}`,
+    pausaSobre: (sobre) => sobre,
+    semPausa: 'sem pausa humana prevista',
+    /** `produto "loc", assunto "x", fases "full"`: o slug de 3 partes descrito. */
+    slug: (produto, assunto, fases, rotacao) => `produto "${produto}", assunto "${assunto}", fases "${fases}"${rotacao ? `, rotacao ${rotacao}` : ''}`,
+    /** Linha unica de quem conduz (conducao-texto.ts). */
+    conduzido: (canal, quem, fase, desde) => `conduzido agora por ${canal}, ${quem}, fase ${fase}, desde ${desde}`,
+    quemSessao: (id) => `sessao ${id}`,
+    quemProcesso: (pid, operacao) => `processo ${pid} (${operacao})`,
+    quemReserva: (por) => `reserva de ${por}`,
+    operacoes: {
+        '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',
+    },
+    // ork thread new
+    criada: 'Thread criada.',
+    simulacao: 'Simulacao (--dry-run), nada foi gravado.',
+    roadmapReservado: (item, maquina) => `  roadmap: ${item} reservado para esta maquina (${maquina})`,
+    slugEm3Partes: (descrito) => `  slug em 3 partes: ${descrito}`,
+    estado: (id) => `  estado: .orkastery/threads/${id}/thread.json`,
+    proximoPasso: (id, fase) => `Proximo passo: ork phase run ${id} ${fase} --prompt "<pedido>"`,
+    usoNew: 'uso: ork thread new <nome> --modo <MODO>',
+    doneSemComando: (entrada) => `done.sem-comando: "${entrada}" nao traz comando. ` +
+        'Use --done "<criterio> :: <comando que o prova>"; criterio sem comando e prosa, nao criterio de pronto.',
+    doneIncompleto: (entrada) => `done.incompleto: "${entrada}" precisa de criterio E comando`,
+    varianteInvalida: (bruto, variantes) => `variante de ciclo invalida: "${bruto}". Use uma de: ${variantes}`,
+    cicloExigeWorktree: (variante) => `uso: o ciclo ${variante} exige worktree isolada: crie a thread sem --sem-worktree ou escolha outro ciclo`,
+    worktreeVazia: 'uso: --worktree pede auto ou um diretório que já existe',
+    semWorktreeComValor: (valor) => `uso: --sem-worktree não leva valor (recebeu "${valor}")`,
+    worktreeESemWorktree: 'uso: --worktree e --sem-worktree se excluem; use um dos dois',
+    worktreeChave: (gravada) => `  worktree: ${gravada ? 'criada' : 'seria criada'} pela chave worktree.por_thread do ` +
+        'orkastery.yaml; para criar sem ela, use --sem-worktree',
+    worktreeFlag: (gravada) => `  worktree: ${gravada ? 'criada' : 'seria criada'} pelo --worktree auto`,
+    worktreeCiclo: (gravada, variante) => `  worktree: ${gravada ? 'criada' : 'seria criada'} pelo ciclo ${variante ?? 'da thread'}, que exige worktree isolada`,
+    avisoSemWorktree: (id, gravada, c) => {
+        const inicio = gravada
+            ? `Aviso: thread ${id} sem worktree (--sem-worktree): ela trabalha na raiz do projeto`
+            : `Aviso: sem worktree (--sem-worktree), a thread ${id} trabalharia na raiz do projeto`;
+        const ensure = `Antes do GO, ork worktree ensure ${id} cria a worktree e a branch da thread`;
+        if (c.caso === 'sem-commit') {
+            return `${inicio}, num repositório ainda sem commit, fora de qualquer branch, e o ork ship não tem branch de origem ` +
+                'para entregar. Faça o primeiro commit e siga o aviso de thread sem base.';
+        }
+        if (c.caso === 'head') {
+            return `${inicio}, com o HEAD destacado, fora de qualquer branch, e o ork ship não tem branch de origem para entregar. ${ensure}.`;
+        }
+        if (c.caso === 'outra') {
+            return `${inicio}, na branch ${c.branch}, e o ork ship entrega essa branch como estiver, com o que mais entrar nela; ` +
+                `com --para ${c.branch}, a entrega vira push direto, que a policy push_direto_na_base confere. ${ensure}.`;
+        }
+        const efeito = c.policy === 'block'
+            ? 'o ork ship barra a entrega por push_direto_na_base (block): não há branch de thread para mergear'
+            : c.policy === undefined || c.policy === 'off'
+                ? 'o ork ship empurra a base direto, sem branch de thread (push_direto_na_base desligada)'
+                : `o ork ship avisa push_direto_na_base (${c.policy}) e empurra a base direto, sem branch de thread`;
+        return `${inicio}, na branch base ${c.base}, e ${efeito}. ${ensure}; depois do GO, os commits já estão na base e o ship não os separa.`;
+    },
+    worktreeFalharia: (motivo, dir, branch, peloCiclo) => {
+        const semWorktree = peloCiclo ? '' : ' ou crie com --sem-worktree';
+        if (motivo === 'pasta-existe') {
+            return `Aviso: a pasta ${dir} já existe, e a criação de verdade recusaria a worktree da thread: tire a pasta${semWorktree}.`;
+        }
+        if (motivo === 'branch-existe') {
+            return `Aviso: a branch ${branch} já existe, e a criação de verdade recusaria a worktree da thread: tire a branch${semWorktree}.`;
+        }
+        return 'Aviso: o repositório ainda não tem commit, e a criação de verdade recusaria a worktree da thread no git worktree add: ' +
+            'faça o primeiro commit antes.';
+    },
+    chaveSemCommit: (gravada) => 'Aviso: worktree.por_thread pede a worktree da thread, mas o repositório ainda não tem commit: ' +
+        `a thread ${gravada ? 'nasceu' : 'nasceria'} na raiz do projeto, sem worktree.`,
+    semBase: (id, gravada) => gravada
+        ? `Aviso: o repositório ainda não tem commit, e a thread ${id} nasceu sem base: o ship não tem de onde partir. ` +
+            `Faça o primeiro commit, feche esta com ork thread close ${id} --motivo engano --por <quem> ` +
+            '--justificativa "aberta antes do primeiro commit" e abra outra.'
+        : 'Aviso: o repositório ainda não tem commit, e a thread nasceria sem base: faça o primeiro commit antes de abrir a primeira thread.',
+    roadmapNoNome: (item) => `Aviso: ${item} no nome não associa a thread ao roadmap. No terminal, consulte ork roadmap reservas ` +
+        `e ork fabrica; para associar e reservar, use --roadmap ${item} em ork thread new. Nenhuma reserva foi criada por este aviso.`,
+    modoDesconhecido: (entrada, tags) => `modo.desconhecido: "${entrada}" nao e um modo de conducao. Use um de: ${tags}.`,
+    modoAposentado: (motivo, tag, substitutos) => `${motivo}: ${tag} foi aposentado e nao abre trabalho novo. Use ${substitutos.join(' ou ')}. ` +
+        `Thread ja gravada em ${tag} continua abrindo normalmente.`,
+    publicacaoPendente: (motivo) => `Memoria: publicacao pendente (${motivo}); ativacao explicita necessaria.`,
+    memoriaGravada: (tenant, gravados) => `Memoria (orkmind, tenant ${tenant}): ${gravados}.`,
+    nadaAGravar: 'nada a gravar',
+    gravacoesFalhas: (n) => `  ${n} gravacao(oes) nao concluida(s); veja ork memory status.`,
+    // ork thread status
+    naoEncontrada: (id, dir) => `thread "${id}" nao encontrada em ${dir}`,
+    usoStatus: 'uso: ork thread status <thread-id>',
+    /** D14: erros de argumento de `thread new` que nascem no escopo pt-BR da gravacao (`ErroDoCatalogo`). */
+    slugInvalido: (slug, regex) => `slug invalido: "${slug}" (regex canonica: ${regex})`,
+    roadmapItemInvalido: (item) => `roadmap.item: "${item}" nao e um item do roadmap (esperado RM-NNN)`,
+    roadmapItemInexistente: (id) => `roadmap.item: ${id} nao existe em docs/roadmap`,
+    /** RM-059 (T6.0) no thread new: o pedido do builder guardado ao lado do thread.json. */
+    usoPedido: 'uso: --pedido "<texto do pedido do builder>"',
+    /** D14: os demais erros de argumento de `thread new`, lancados no escopo pt-BR da criacao. */
+    varianteIncompativel: (variante, tag, fases) => `o ciclo ${variante} redesenha os blocos e o modo ${tag} ` +
+        `tem um bloco so (${fases}): crie a thread sem --ciclo ou escolha um modo de ciclo completo`,
+    modoNaoPermitido: (tag, permitidos) => `modo ${tag} fora de conduction.allowed_modes (permitidos: ${permitidos})`,
+    nomeSemAssunto: (nome) => `nome "${nome}" nao produz assunto valido (esperado [a-z0-9])`,
+    cicloExigeBranch: (variante) => `o ciclo ${variante} parte de uma branch que ja existe: informe --branch <branch>`,
+    branchInexistente: (branch) => `branch "${branch}" nao existe neste repositorio`,
+    branchSemCiclo: '--branch so vale com --ciclo merge-branch',
+    ocupadaPelaChave: (pasta, alvo) => `${pasta ? 'a pasta' : 'a branch'} ${alvo} já existe, e a chave ` +
+        'worktree.por_thread pede a worktree da thread: tire-a ou crie com --sem-worktree',
+    usoComMotivo: (motivo) => `uso: ${motivo}`,
+    pedidoVazio: 'thread.pedido.invalido: o pedido esta vazio',
+    pedidoGrande: (bytes, teto) => `thread.pedido.invalido: o pedido tem ${bytes} bytes, e o teto e ${teto}`,
+    pedidoGuardado: (gravada, caminho, sha, bytes) => `  pedido: ${gravada ? 'guardado em' : 'seria guardado em'} ${caminho} (sha256 ${sha}, ${bytes} bytes); o ork prompt render o usa quando falta --pedido`,
+    nenhumaSessao: '  nenhuma sessao despachada ainda',
+    sessoesDespachadas: '  sessoes despachadas (estado real conferido em `ork sessions`)',
+    sessao: (verificada, canal) => `verificada no runtime: ${verificada ? 'sim' : 'nao'}  canal: ${canal}`,
+    pausasDoModo: (n) => `  pausas humanas do modo: ${n}`,
+};
+exports.THREAD_EN = {
+    largura: 10,
+    rotulos: { id: 'id', slug: 'slug', nome: 'name', modo: 'mode', ciclo: 'cycle', fase: 'phase', status: 'status', base: 'base',
+        worktree: 'worktree', conducao: 'conduction', score: 'score' },
+    modo: (tag, pausas) => `${tag} (${pausas} planned human pause${pausas === 1 ? '' : 's'})`,
+    cicloPadrao: 'default for the mode',
+    status: (status) => STATUS_EN[status] ?? status,
+    raizDoProjeto: '(project root)',
+    ninguemConduz: 'nobody right now',
+    validacao: '  validation CHECK on a runtime other than the GO one (required by the thread)',
+    prontoQuando: (n) => `  done when (${n} executable criteri${n === 1 ? 'on' : 'a'})`,
+    score: (valor, por, regime, quando) => `${valor}/5 by ${por} (${regime}) on ${quando}`,
+    blocosPrevistos: '  planned blocks',
+    pausaPrevista: (sobre) => `planned pause: ${sobre}`,
+    pausaSobre: (sobre) => PAUSA_SOBRE_EN[sobre] ?? sobre,
+    semPausa: 'no planned human pause',
+    slug: (produto, assunto, fases, rotacao) => `product "${produto}", subject "${assunto}", phases "${fases}"${rotacao ? `, rotation ${rotacao}` : ''}`,
+    conduzido: (canal, quem, fase, desde) => `conducted now by ${canal}, ${quem}, phase ${fase}, since ${desde}`,
+    quemSessao: (id) => `session ${id}`,
+    quemProcesso: (pid, operacao) => `process ${pid} (${operacao})`,
+    quemReserva: (por) => `reserved by ${por}`,
+    operacoes: {
+        'phase.run': 'phase dispatch',
+        'retry.run': 'phase retry',
+        verify: 'ork verify',
+        baseline: 'ork verify --baseline',
+        'fix.open': 'ork fix open',
+        'fix.reverify': 'ork fix reverify',
+        'mcp.verify': 'ork_verify (MCP)',
+        handoff: 'reservation of whoever took over',
+    },
+    criada: 'Thread created.',
+    simulacao: 'Dry run (--dry-run): nothing was written.',
+    roadmapReservado: (item, maquina) => `  roadmap: ${item} reserved for this machine (${maquina})`,
+    slugEm3Partes: (descrito) => `  3-part slug: ${descrito}`,
+    estado: (id) => `  state: .orkastery/threads/${id}/thread.json`,
+    proximoPasso: (id, fase) => `Next step: \`ork phase run ${id} ${fase} --prompt "<request>"\``,
+    usoNew: 'usage: ork thread new <name> --modo <MODE>',
+    doneSemComando: (entrada) => `done.sem-comando: "${entrada}" has no command. ` +
+        'Use `--done "<criterion> :: <command that proves it>"`; a criterion without a command is prose, not a done criterion.',
+    doneIncompleto: (entrada) => `done.incompleto: "${entrada}" needs a criterion AND a command`,
+    varianteInvalida: (bruto, variantes) => `invalid cycle variant: "${bruto}". Use one of: ${variantes}`,
+    cicloExigeWorktree: (variante) => `usage: the ${variante} cycle requires an isolated worktree: create the thread without \`--sem-worktree\` or pick another cycle`,
+    worktreeVazia: 'usage: `--worktree` takes `auto` or a directory that already exists',
+    semWorktreeComValor: (valor) => `usage: \`--sem-worktree\` takes no value (got "${valor}")`,
+    worktreeESemWorktree: 'usage: `--worktree` and `--sem-worktree` exclude each other; use one of them',
+    worktreeChave: (gravada) => `  worktree: ${gravada ? 'created' : 'would be created'} by the \`worktree.por_thread\` key in ` +
+        'orkastery.yaml; to create without it, use `--sem-worktree`',
+    worktreeFlag: (gravada) => `  worktree: ${gravada ? 'created' : 'would be created'} by \`--worktree auto\``,
+    worktreeCiclo: (gravada, variante) => `  worktree: ${gravada ? 'created' : 'would be created'} by ` +
+        `${variante ? `the ${variante} cycle` : 'the thread cycle'}, which requires an isolated worktree`,
+    avisoSemWorktree: (id, gravada, c) => {
+        const inicio = gravada
+            ? `Warning: thread ${id} has no worktree (\`--sem-worktree\`): it works at the project root`
+            : `Warning: without a worktree (\`--sem-worktree\`), thread ${id} would work at the project root`;
+        const ensure = `Before GO, \`ork worktree ensure ${id}\` creates the thread worktree and branch`;
+        if (c.caso === 'sem-commit') {
+            return `${inicio}, in a repository with no commit yet, outside any branch, and \`ork ship\` has no source branch ` +
+                'to deliver. Make the first commit and follow the warning about a thread without a base.';
+        }
+        if (c.caso === 'head') {
+            return `${inicio}, with a detached HEAD, outside any branch, and \`ork ship\` has no source branch to deliver. ${ensure}.`;
+        }
+        if (c.caso === 'outra') {
+            return `${inicio}, on branch ${c.branch}, and \`ork ship\` delivers that branch as it is, with whatever else lands on it; ` +
+                `with \`--para ${c.branch}\`, the delivery becomes a direct push, which the \`push_direto_na_base\` policy checks. ${ensure}.`;
+        }
+        const efeito = c.policy === 'block'
+            ? '`ork ship` refuses the delivery under `push_direto_na_base` (block): there is no thread branch to merge'
+            : c.policy === undefined || c.policy === 'off'
+                ? '`ork ship` pushes the base directly, without a thread branch (`push_direto_na_base` off)'
+                : `\`ork ship\` warns about \`push_direto_na_base\` (${c.policy}) and pushes the base directly, without a thread branch`;
+        return `${inicio}, on the base branch ${c.base}, and ${efeito}. ${ensure}; after GO, the commits are already on the base and ` +
+            'ship does not separate them.';
+    },
+    worktreeFalharia: (motivo, dir, branch, peloCiclo) => {
+        const semWorktree = peloCiclo ? '' : ' or create it with `--sem-worktree`';
+        if (motivo === 'pasta-existe') {
+            return `Warning: the folder ${dir} already exists, and the real creation would refuse the thread worktree: remove the folder${semWorktree}.`;
+        }
+        if (motivo === 'branch-existe') {
+            return `Warning: the branch ${branch} already exists, and the real creation would refuse the thread worktree: remove the branch${semWorktree}.`;
+        }
+        return 'Warning: the repository has no commit yet, and the real creation would refuse the thread worktree in `git worktree add`: ' +
+            'make the first commit first.';
+    },
+    chaveSemCommit: (gravada) => 'Warning: `worktree.por_thread` asks for the thread worktree, but the repository has no commit yet: ' +
+        `the thread ${gravada ? 'was created' : 'would be created'} at the project root, without a worktree.`,
+    semBase: (id, gravada) => gravada
+        ? `Warning: the repository has no commit yet, and thread ${id} was created without a base: ship has nowhere to start from. ` +
+            `Make the first commit, close this one with \`ork thread close ${id} --motivo engano --por <who> ` +
+            '--justificativa "opened before the first commit"` and open another.'
+        : 'Warning: the repository has no commit yet, and the thread would be created without a base: make the first commit before opening the first thread.',
+    roadmapNoNome: (item) => `Warning: ${item} in the name does not link the thread to the roadmap. In the terminal, check ` +
+        `\`ork roadmap reservas\` and \`ork fabrica\`; to link and reserve it, use \`--roadmap ${item}\` in \`ork thread new\`. ` +
+        'No reservation was created by this warning.',
+    modoDesconhecido: (entrada, tags) => `modo.desconhecido: "${entrada}" is not a conduction mode. Use one of: ${tags}.`,
+    modoAposentado: (motivo, tag, substitutos) => `${motivo}: ${tag} was retired and opens no new work. Use ${substitutos.join(' or ')}. ` +
+        `A thread already recorded in ${tag} keeps opening normally.`,
+    publicacaoPendente: (motivo) => `Memory: publication pending (${motivo}); explicit activation required.`,
+    memoriaGravada: (tenant, gravados) => `Memory (orkmind, tenant ${tenant}): ${gravados}.`,
+    nadaAGravar: 'nothing to write',
+    gravacoesFalhas: (n) => `  ${n} write(s) not completed; see \`ork memory status\`.`,
+    naoEncontrada: (id, dir) => `thread "${id}" not found in ${dir}`,
+    usoStatus: 'usage: ork thread status <thread-id>',
+    slugInvalido: (slug, regex) => `invalid slug: "${slug}" (canonical regex: ${regex})`,
+    roadmapItemInvalido: (item) => `roadmap.item: "${item}" is not a roadmap item (expected RM-NNN)`,
+    roadmapItemInexistente: (id) => `roadmap.item: ${id} does not exist in \`docs/roadmap\``,
+    usoPedido: 'usage: --pedido "<builder request text>"',
+    varianteIncompativel: (variante, tag, fases) => `the ${variante} cycle redraws the blocks, and mode ${tag} has a single block ` +
+        `(${fases}): create the thread without \`--ciclo\` or pick a full-cycle mode`,
+    modoNaoPermitido: (tag, permitidos) => `mode ${tag} is not in \`conduction.allowed_modes\` (allowed: ${permitidos})`,
+    nomeSemAssunto: (nome) => `name "${nome}" does not produce a valid subject (expected [a-z0-9])`,
+    cicloExigeBranch: (variante) => `the ${variante} cycle starts from a branch that already exists: pass \`--branch <branch>\``,
+    branchInexistente: (branch) => `branch "${branch}" does not exist in this repository`,
+    branchSemCiclo: '`--branch` only applies with `--ciclo merge-branch`',
+    ocupadaPelaChave: (pasta, alvo) => `${pasta ? 'the folder' : 'the branch'} ${alvo} already exists, and \`worktree.por_thread\` ` +
+        'asks for the thread worktree: remove it or create the thread with `--sem-worktree`',
+    usoComMotivo: (motivo) => `usage: ${motivo}`,
+    pedidoVazio: 'thread.pedido.invalido: the request is empty',
+    pedidoGrande: (bytes, teto) => `thread.pedido.invalido: the request has ${bytes} bytes, above the ${teto}-byte limit`,
+    pedidoGuardado: (gravada, caminho, sha, bytes) => `  request: ${gravada ? 'saved to' : 'would be saved to'} ${caminho} (sha256 ${sha}, ` +
+        `${bytes} bytes); \`ork prompt render\` uses it when \`--pedido\` is missing`,
+    nenhumaSessao: '  no session dispatched yet',
+    sessoesDespachadas: '  dispatched sessions (real state checked in `ork sessions`)',
+    sessao: (verificada, canal) => `verified in the runtime: ${verificada ? 'yes' : 'no'}  channel: ${canal}`,
+    pausasDoModo: (n) => `  planned human pauses in this mode: ${n}`,
+};

package/dist/locale-verify.js

@@ -0,0 +1,125 @@
+"use strict";
+/**
+ * RM-061, fatia F2b: a familia `verify` do catalogo de mensagens (`ork verify` e `ork verify --baseline`).
+ * O pt-BR e a fonte; o ingles e tipado por ele. Sem import do nucleo.
+ *
+ * O detalhe de cada claim reexecutada vai ao ledger (`verify_run`): o comando o monta em pt-BR, e so a
+ * impressao o remonta no locale (G2 da F2b). Motivo tipado, comando, sha e o texto da claim (dado de quem
+ * a registrou) saem iguais nas duas linguas.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERIFY_EN = exports.VERIFY_PT_BR = void 0;
+exports.VERIFY_PT_BR = {
+    uso: 'uso: ork verify <thread-id> [--baseline] [--so-claims] [--canal C] [--esperar [min]]',
+    // ork verify --baseline
+    baselineGravada: (id) => `Baseline gravada para a thread ${id}.`,
+    baselineCommit: (commit) => `  commit ${commit}`,
+    baselineComando: (nome, ok, code, comando) => `  ${nome.padEnd(10)} ${ok ? 'passava' : `ja falhava (codigo ${code})`}  ${comando}`,
+    baselineSaida: (caminho, id) => `  saida de quem falhou: as ultimas linhas em ${caminho}, campo baseline.comandos ` +
+        `(resumo e trecho); o evento baseline_recorded esta em ork phase list ${id}`,
+    baselineSemComandos: '  (nenhum comando em verify: no manifesto: a baseline guarda so o commit, e o verify nao tem como separar regressao de divida)',
+    // ork verify: cabecalho
+    titulo: (id) => `ork verify da thread ${id}`,
+    head: (commit) => `  HEAD real   ${commit}`,
+    diretorio: (cwd) => `  diretorio   ${cwd}`,
+    baseline: (sha, quando) => `  baseline    ${sha} de ${quando}`,
+    semBaseline: '  baseline    (nao gravada: falha nao pode ser chamada de regressao)',
+    preparo: (situacao, segundos, alterado) => `  preparo     ${situacao} em ` +
+        `${segundos} s, uma vez para a rodada; produto ` +
+        `${alterado ? 'MUDOU no meio da rodada: nenhum veredito vale' : 'conferido do preparo ao fim'}`,
+    stealMedido: (pct, fonte, limiar) => `  steal       ${pct}% na rodada (${fonte}; acima de ${limiar}%, teste com relogio que reprova fica sem veredito)`,
+    stealNaoMedido: (fonte) => `  steal       nao medido (sem ${fonte} nesta maquina): nenhuma reprovacao e atenuada`,
+    instabilidadeForaDoContrato: (arquivo, erros) => `  instabilidade ${arquivo} FORA DO CONTRATO, nenhuma entrada vale: ${erros}`,
+    instabilidadeVencidas: (n, testes) => `  instabilidade ${n} entrada(s) vencida(s), sem valor ate nova medida: ${testes}`,
+    // Claims
+    claimsReexecutadas: 'Claims reexecutadas no HEAD real:',
+    nenhumaClaim: '  (nenhuma claim registrada nesta thread)',
+    claim: (id, verificado, alegacao) => `  ${id}  verificado: ${verificado ? 'sim' : 'NAO'}  ${alegacao}`,
+    arquivo: (arquivo) => `      arquivo: ${arquivo}`,
+    comandos: (comandos) => `      comando(s): ${comandos}`,
+    semComando: '      sem comando de verificacao',
+    motivoTipado: (motivo, detalhe) => `      motivo tipado: ${motivo} (${detalhe})`,
+    // Comandos do manifesto
+    comandosDoManifesto: 'Comandos de verify do manifesto:',
+    comandoOk: 'ok',
+    comando: (nome, situacao, comando) => `  ${nome.padEnd(10)} ${situacao}  ${comando}`,
+    testesQueCairam: (testes) => `             teste(s) que caiu(ram): ${testes}`,
+    estourou: (prazo, rodou) => `ESTOUROU O PRAZO (${prazo}, rodou ${rodou})`,
+    relogioSobSteal: (pct, limiar) => `RELOGIO SOB STEAL (${pct}% de steal, acima de ${limiar}%)`,
+    naoExecutou: (code) => `NAO EXECUTOU (comando nao encontrado, codigo ${code})`,
+    mortoPorSinal: (code) => `MORTO POR SINAL (codigo ${code})`,
+    falhou: (code) => `FALHOU (codigo ${code})`,
+    semVeredito: (nomes) => `Sem veredito por tempo (nao e reprovacao: prazo estourado ou relogio sob steal): ${nomes}`,
+    // Classificacao e veredito
+    classificacao: (regressoes, preExistentes, semBaseline) => `Classificacao: ${regressoes} regressao(oes), ${preExistentes} pre-existente(s), ${semBaseline} falha(s) sem baseline`,
+    regressao: (nome, comando) => `  regressao      ${nome}: ${comando}`,
+    preExistente: (nome, comando) => `  pre-existente  ${nome}: ${comando}`,
+    falhaSemBaseline: (nome, comando) => `  sem baseline   ${nome}: ${comando}`,
+    verdade: 'Veredito: VERDADE SUSTENTADA (nenhum motivo bloqueante).',
+    reprovado: (motivos) => `Veredito: REPROVADO. Motivos tipados: ${motivos}`,
+    // Detalhe da claim reexecutada (vai ao ledger em pt-BR)
+    claimNegativaSemComando: 'alegacao negativa/absoluta sem comando de verificacao: nao ha como comprova-la',
+    claimSemComando: 'sem comando de verificacao declarado',
+    claimNaoExecutada: (comando, resumo) => `comando "${comando}" nao foi executado: ${resumo}`,
+    claimEstourou: (comando, segundos) => `comando "${comando}" estourou o prazo de ${segundos} s sem terminar`,
+    claimRelogio: (comando, pct, limiar, testes) => `comando "${comando}" reprovou so em teste com relogio sob steal de ${pct}% (acima de ${limiar}%): ${testes}`,
+    claimSaiu: (comando, code) => `comando "${comando}" saiu com codigo ${code}`,
+    claimOk: (n) => `${n} comando(s) reexecutado(s) com sucesso`,
+    // RM-058 N2: a espera pela fila de recursos pesados, dita uma vez no stderr enquanto o verify espera.
+    filaPesadaOcupante: (operacao, thread, desde) => `${operacao}${thread ? ` da thread ${thread}` : ''} desde ${desde}`,
+    filaPesadaEsperando: (operacao, ocupantes) => `Esperando a vez na fila de recursos pesados (concurrency.max_parallel_heavy) para o ${operacao}: ` +
+        `ocupada por ${ocupantes || 'um pedido que chegou antes'}.`,
+};
+exports.VERIFY_EN = {
+    uso: 'usage: ork verify <thread-id> [--baseline] [--so-claims] [--canal C] [--esperar [min]]',
+    baselineGravada: (id) => `Baseline recorded for thread ${id}.`,
+    baselineCommit: (commit) => `  commit ${commit}`,
+    baselineComando: (nome, ok, code, comando) => `  ${nome.padEnd(10)} ${ok ? 'passed' : `already failing (exit ${code})`}  ${comando}`,
+    baselineSaida: (caminho, id) => `  output of the failing commands: the last lines in ${caminho}, field \`baseline.comandos\` ` +
+        `(summary and excerpt); the baseline_recorded event is in \`ork phase list ${id}\``,
+    baselineSemComandos: '  (no command under `verify:` in the manifest: the baseline keeps only the commit, and verify cannot tell a regression from existing debt)',
+    titulo: (id) => `ork verify for thread ${id}`,
+    head: (commit) => `  real HEAD   ${commit}`,
+    diretorio: (cwd) => `  directory   ${cwd}`,
+    baseline: (sha, quando) => `  baseline    ${sha} from ${quando}`,
+    semBaseline: '  baseline    (not recorded: a failure cannot be called a regression)',
+    preparo: (situacao, segundos, alterado) => `  prepare     ${situacao} in ${segundos} s, once for the run; product ` +
+        `${alterado ? 'CHANGED during the run: no verdict counts' : 'checked from prepare to end'}`,
+    stealMedido: (pct, fonte, limiar) => `  steal       ${pct}% in the run (${fonte}; above ${limiar}%, a failing clock-bound test gets no verdict)`,
+    stealNaoMedido: (fonte) => `  steal       not measured (no ${fonte} on this machine): no failure is softened`,
+    instabilidadeForaDoContrato: (arquivo, erros) => `  flaky tests ${arquivo} OUT OF CONTRACT, no entry counts: ${erros}`,
+    instabilidadeVencidas: (n, testes) => `  flaky tests ${n} expired entry(ies), not counted until measured again: ${testes}`,
+    claimsReexecutadas: 'Claims rerun on the real HEAD:',
+    nenhumaClaim: '  (no claim recorded in this thread)',
+    claim: (id, verificado, alegacao) => `  ${id}  verified: ${verificado ? 'yes' : 'NO'}  ${alegacao}`,
+    arquivo: (arquivo) => `      file: ${arquivo}`,
+    comandos: (comandos) => `      command(s): ${comandos}`,
+    semComando: '      no verification command',
+    motivoTipado: (motivo, detalhe) => `      typed reason: ${motivo} (${detalhe})`,
+    comandosDoManifesto: 'Manifest verify commands:',
+    comandoOk: 'ok',
+    comando: (nome, situacao, comando) => `  ${nome.padEnd(10)} ${situacao}  ${comando}`,
+    testesQueCairam: (testes) => `             failing test(s): ${testes}`,
+    estourou: (prazo, rodou) => `TIMED OUT (${prazo}, ran ${rodou})`,
+    relogioSobSteal: (pct, limiar) => `CLOCK UNDER STEAL (${pct}% steal, above ${limiar}%)`,
+    naoExecutou: (code) => `DID NOT RUN (command not found, exit ${code})`,
+    mortoPorSinal: (code) => `KILLED BY SIGNAL (exit ${code})`,
+    falhou: (code) => `FAILED (exit ${code})`,
+    semVeredito: (nomes) => `No verdict for lack of time (not a failure: deadline exceeded or clock under steal): ${nomes}`,
+    classificacao: (regressoes, preExistentes, semBaseline) => `Classification: ${regressoes} regression(s), ${preExistentes} pre-existing, ${semBaseline} failure(s) without a baseline`,
+    regressao: (nome, comando) => `  regression     ${nome}: ${comando}`,
+    preExistente: (nome, comando) => `  pre-existing   ${nome}: ${comando}`,
+    falhaSemBaseline: (nome, comando) => `  no baseline    ${nome}: ${comando}`,
+    verdade: 'Verdict: VERIFIED (no blocking reason).',
+    reprovado: (motivos) => `Verdict: FAILED. Typed reasons: ${motivos}`,
+    claimNegativaSemComando: 'negative or absolute claim without a verification command: there is no way to prove it',
+    claimSemComando: 'no verification command declared',
+    claimNaoExecutada: (comando, resumo) => `command "${comando}" did not run: ${resumo}`,
+    claimEstourou: (comando, segundos) => `command "${comando}" ran past its ${segundos} s deadline`,
+    claimRelogio: (comando, pct, limiar, testes) => `command "${comando}" failed only in clock-bound tests under ${pct}% steal (above ${limiar}%): ${testes}`,
+    claimSaiu: (comando, code) => `command "${comando}" exited with code ${code}`,
+    claimOk: (n) => `${n} command(s) rerun successfully`,
+    filaPesadaOcupante: (operacao, thread, desde) => `${operacao}${thread ? ` of thread ${thread}` : ''} since ${desde}`,
+    filaPesadaEsperando: (operacao, ocupantes) => `Waiting for a turn in the heavy-work queue (\`concurrency.max_parallel_heavy\`) for the ${operacao}: ` +
+        `held by ${ocupantes || 'a request that arrived earlier'}.`,
+};