@orkastery/cli 0.5.6 → 0.6.0

package/dist/locale-projetos.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROJETOS_EN = exports.PROJETOS_PT_BR = void 0;
+/** RM-061 F3d: registro e seleção de projetos, sem importar o núcleo. */
+exports.PROJETOS_PT_BR = {
+    candidatos: 'Candidatos:', semRemoto: 'sem remoto', ausente: 'ausente do disco',
+    ocupado: (trava) => `registro de projetos ocupado (${trava}); tente de novo`,
+    segredoConteudo: 'registro de projetos recusado: o conteudo parece carregar segredo',
+    segredoEntrada: 'registro de projetos recusado: a entrada parece carregar segredo',
+    semManifesto: (caminho) => `nenhum manifesto do ork em ${caminho}`,
+    rodeInit: 'Rode `ork init` na raiz do projeto antes de registrá-lo.',
+    manifestoInvalido: (caminho) => `registro de projetos: manifesto inválido em ${caminho}`,
+    naoRegistrado: (valor) => `"${valor}" não está no registro de projetos desta máquina`,
+    vejaRegistrados: 'Veja os registrados com `ork projetos`.',
+    caminhoNaoExiste: (caminho) => `o caminho ${caminho} não existe`,
+    informeRaiz: 'Informe o caminho da raiz de um projeto com orkastery.yaml, ou o nome de um projeto registrado (`ork projetos`).',
+    yamlAusente: (caminho) => `nenhum orkastery.yaml em ${caminho} nem acima dele`,
+    initOuNome: 'Rode `ork init` na raiz do projeto, ou informe o nome de um projeto registrado (`ork projetos`).',
+    nomeInvalido: (valor) => `"${valor}" não é um nome de projeto válido`,
+    useNome: 'Use o nome ou o abbrev de um projeto de `ork projetos`.',
+    ambiguo: (valor, total) => `"${valor}" casa ${total} projetos registrados nesta máquina`,
+    escolhaRaiz: 'Repita com o caminho da raiz (`--projeto <caminho>`), ou tire a cópia que sobra com `ork projetos esquecer <caminho>`.',
+    semManifestoRegistrado: (valor) => `"${valor}" está registrado, mas o manifesto não está mais na raiz`,
+    registreCopia: 'Veja os registrados com `ork projetos`; registre uma cópia com `ork projetos registrar <caminho>`.',
+    ofertaRede: 'Para ver todos os projetos e as threads de todas as máquinas sem escolher, com a fonte e a hora de cada parte: ' +
+        '`ork network roadmap` (tool ork_network_roadmap).',
+    opcaoSemValor: '--projeto sem valor',
+    usoOpcao: 'Uso: --projeto <nome|caminho>; os nomes registrados estão em `ork projetos`.',
+    hostCaminho: (valor) => `no host o projeto vem pelo nome registrado; o caminho "${valor}" não é aceito`,
+    hostUseNome: 'Use o nome de um projeto de `ork projetos` (ex.: --projeto orkastery).',
+    precisaEscolher: (total) => `${total} projetos conhecidos nesta máquina e nenhum foi pedido; o ork não escolhe pelo diretório do gateway`,
+    repitaEscolha: (oferta) => 'Repita com o projeto pedido: parâmetro `projeto` da tool, ou `--projeto <nome>`. ' + oferta,
+    nenhum: 'nenhum projeto conhecido nesta máquina e nenhum foi pedido',
+    registrePrimeiro: 'Registre o projeto com `ork projetos registrar <caminho>` (ou `ork init` na raiz dele) e repita com o nome. ' +
+        'Sem clone nesta máquina, o roadmap de um projeto vem da forja: `ork network roadmap --projeto github:dono/repo` (tool ork_network_roadmap).',
+    avisoTemporario: (raiz, registro) => `aviso: projeto em pasta temporária (${raiz}) não entra no registro desta máquina ` +
+        `(${registro}); para registrá-lo mesmo assim: ork projetos registrar ${raiz}`,
+    avisoRegistro: (registro, erro) => `aviso: projeto não registrado em ${registro} (${erro})`,
+    cli: {
+        titulo: (arquivo) => `Projetos conhecidos desta maquina (${arquivo})`,
+        nenhum: '  Nenhum ainda. ork init, ork thread new e ork fabrica entrar registram; ou: ork projetos registrar <caminho>',
+        cabecalho: ['NOME', 'ABBREV', 'RAIZ', 'REMOTO', 'NO DISCO', 'ATUALIZADO'],
+        sim: 'sim', ausente: 'ausente', semRemoto: 'sem remoto',
+        selecao: 'Use --projeto <nome> em qualquer comando (ORK_PROJETO vale para o shell inteiro).',
+        usoRegistrar: 'uso: ork projetos registrar [caminho] (um caminho ou --projeto, não os dois)',
+        registrado: (nome, abbrev, raiz, remoto) => `Projeto ${nome} (${abbrev}) registrado: ${raiz} · ${remoto}`,
+        usoEsquecer: 'uso: ork projetos esquecer <nome|caminho>',
+        esquecido: (nome, raiz) => `Projeto ${nome} esquecido: ${raiz} (nada no disco foi apagado)`,
+        desconhecido: (sub) => `subcomando desconhecido: projetos ${sub}`,
+        uso: 'uso: ork projetos [--json] | projetos registrar [caminho] | projetos esquecer <nome|caminho>',
+    },
+};
+exports.PROJETOS_EN = {
+    candidatos: 'Candidates:', semRemoto: 'no remote', ausente: 'missing from disk',
+    ocupado: (lock) => `project registry busy (${lock}); try again`,
+    segredoConteudo: 'project registry refused: its content appears to contain a secret',
+    segredoEntrada: 'project registry refused: the entry appears to contain a secret',
+    semManifesto: (path) => `no ork manifest in ${path}`,
+    rodeInit: 'Run `ork init` at the project root before registering it.',
+    manifestoInvalido: (path) => `project registry: invalid manifest at ${path}`,
+    naoRegistrado: (value) => `"${value}" is not in this machine's project registry`,
+    vejaRegistrados: 'View registered projects with `ork projetos`.',
+    caminhoNaoExiste: (path) => `path ${path} does not exist`,
+    informeRaiz: 'Provide the root path of a project with orkastery.yaml, or the name of a registered project (`ork projetos`).',
+    yamlAusente: (path) => `no orkastery.yaml in ${path} or any parent directory`,
+    initOuNome: 'Run `ork init` at the project root, or provide the name of a registered project (`ork projetos`).',
+    nomeInvalido: (value) => `"${value}" is not a valid project name`,
+    useNome: 'Use the name or abbrev of a project from `ork projetos`.',
+    ambiguo: (value, total) => `"${value}" matches ${total} projects registered on this machine`,
+    escolhaRaiz: 'Repeat with the root path (`--projeto <path>`), or remove the stale copy with `ork projetos esquecer <path>`.',
+    semManifestoRegistrado: (value) => `"${value}" is registered, but its manifest is no longer at the root`,
+    registreCopia: 'View projects with `ork projetos`; register a copy with `ork projetos registrar <path>`.',
+    ofertaRede: 'To view all projects and threads from every machine without choosing one, including each source and timestamp: ' +
+        '`ork network roadmap` (tool ork_network_roadmap).',
+    opcaoSemValor: '--projeto has no value',
+    usoOpcao: 'Usage: --projeto <name|path>; registered names are listed by `ork projetos`.',
+    hostCaminho: (value) => `on a host, select a project by its registered name; path "${value}" is not accepted`,
+    hostUseNome: 'Use a project name from `ork projetos` (for example: --projeto orkastery).',
+    precisaEscolher: (total) => `${total} projects are known on this machine and none was requested; ork does not choose from the gateway directory`,
+    repitaEscolha: (offer) => "Repeat with the requested project: the tool's `projeto` parameter, or `--projeto <name>`. " + offer,
+    nenhum: 'no project is known on this machine and none was requested',
+    registrePrimeiro: 'Register the project with `ork projetos registrar <path>` (or `ork init` at its root), then repeat with its name. ' +
+        'Without a clone on this machine, read a project roadmap from the forge: `ork network roadmap --projeto github:owner/repo` (tool ork_network_roadmap).',
+    avisoTemporario: (root, registry) => `warning: project in a temporary folder (${root}) is not added to this machine's registry ` +
+        `(${registry}); to register it anyway: ork projetos registrar ${root}`,
+    avisoRegistro: (registry, error) => `warning: project was not registered in ${registry} (${error})`,
+    cli: {
+        titulo: (file) => `Projects known on this machine (${file})`,
+        nenhum: '  None yet. ork init, ork thread new, and ork fabrica entrar register projects; or run: ork projetos registrar <path>',
+        cabecalho: ['NAME', 'ABBREV', 'ROOT', 'REMOTE', 'ON DISK', 'UPDATED'],
+        sim: 'yes', ausente: 'missing', semRemoto: 'no remote',
+        selecao: 'Use --projeto <name> with any command (ORK_PROJETO applies to the whole shell).',
+        usoRegistrar: 'usage: ork projetos registrar [path] (use either a path or --projeto, not both)',
+        registrado: (name, abbrev, root, remote) => `Project ${name} (${abbrev}) registered: ${root} · ${remote}`,
+        usoEsquecer: 'usage: ork projetos esquecer <name|path>',
+        esquecido: (name, root) => `Project ${name} forgotten: ${root} (nothing was deleted from disk)`,
+        desconhecido: (sub) => `unknown subcommand: projetos ${sub}`,
+        uso: 'usage: ork projetos [--json] | projetos registrar [path] | projetos esquecer <name|path>',
+    },
+};

package/dist/locale-prompts.js

@@ -0,0 +1,194 @@
+"use strict";
+/** RM-061 F3c: texto dos prompts de fase e da familia `ork prompt`. PT-BR e a fonte tipada. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROMPTS_EN = exports.PROMPTS_PT_BR = void 0;
+const locale_thread_1 = require("./locale-thread");
+exports.PROMPTS_PT_BR = {
+    contratoDasFases: {
+        GOAL: 'GOAL (F1): objetivo verificavel, impact map, criterios de sucesso e claims com comando de verificacao. Nao implementa.',
+        PLAN: 'PLAN (F2): plano com tarefas, touch_paths, decisoes D1..Dn com domicilio unico e verify executavel por tarefa. Nao implementa.',
+        GO: 'GO (F3): implementacao slice por slice, um commit atomico por tarefa, dentro da worktree da thread.',
+        CHECK: 'CHECK (F4): verificacao contra a baseline (regressao versus divida pre-existente), review de codigo, testes, seguranca e performance; ' +
+            'o parecer diz o modo do CHECK da rodada (Agile Check ou Classic Check, da linha `check` do `ork verify`).',
+        SHIP: 'SHIP (F5): merge serializado, push provado por comando, roadmap atualizado e plano de rollback.',
+        MASTER: 'MASTER (F6): MASTER log com postmortem tipado, licoes e o score humano de 0 a 5. Uma entrega sem MASTER log nao aconteceu.',
+    },
+    invariantes: [
+        'Claims, verify e policies rodam identicos em todos os modos.',
+        'Policy `block` pausa qualquer modo, inclusive #Auto.',
+        'Escalacao tipada para humano pausa qualquer modo, inclusive #Auto.',
+        'Toda entrega fecha com indice derivado do ledger; a nota humana, quando vier, sobrescreve.',
+        'Toda decisao autonoma vai ao ledger com quem decidiu, evidencia e razao.',
+    ],
+    variante: (v) => `Variante de ciclo: ${v}`,
+    pausaSobre: (s) => s,
+    pausa: (sobre) => `Ao fim deste bloco HA PAUSA humana sobre: ${sobre}. Pare, apresente a evidencia e espere o veredito.`,
+    semPausa: 'Ao fim deste bloco NAO ha pausa humana: siga com decisao autonoma e registre no ledger quem decidiu, com que evidencia e por que.',
+    raizDoProjeto: '(raiz do projeto)',
+    regrasDeEvidencia: [
+        'Nada de self-report: toda alegacao vem com o comando que a comprova e a saida real.',
+        'Trabalhe apenas no diretorio de trabalho indicado acima.',
+        'Passos irreversiveis (push, merge, delecao) so acontecem quando o modo autoriza.',
+    ],
+    regraDasEsperas: 'Esperas: nunca dispare verify, build ou suite com `&` dentro do comando, porque o processo se perde e a sessao ' +
+        'espera um aviso que nunca vem; rode o `ork verify` em primeiro plano, com `timeout` (ele espera a vez na fila de ' +
+        'recursos pesados), ou use a execucao em segundo plano do host, que avisa quando termina; nunca espere com ' +
+        '`pgrep -f` cujo padrao aparece no proprio comando, porque o laco acha a si mesmo e nao termina: espere pelo ' +
+        'arquivo de saida com prazo, ou pelo PID guardado.',
+    fechoDoGo: (t) => [
+        '## Fecho obrigatório do GO',
+        '',
+        `Antes de encerrar o bloco com GO, rode \`ork verify ${t}\` e o build declarado no manifesto, ambos em primeiro plano.`,
+        `Gere o bundle com \`ork ci prepare ${t}\` e faça o commit atômico final \`ci(${t}): bundle ...\`.`,
+        `Grave \`.orkastery/threads/${t}/pr-body.md\` curto, no idioma do projeto, com o modo do CHECK da rodada (Agile Check ou Classic Check, da linha \`check\` do \`ork verify\`); ` +
+            'se o perfil não puder gravá-lo pelo transporte autorizado, devolva o corpo completo no resumo final.',
+        'O rito é idêntico em Claude Code e Codex. Ele fecha o GO, mas não autoriza SHIP, push, PR ou merge.',
+    ].join('\n'),
+    contextoDoGrafo: (thread) => '\n\n## Contexto do grafo (opcional)\n' +
+        `Consulte ork_grafo_contexto {threadId: "${thread}"} ou ork grafo contexto ${thread} --json para o pacote da thread com evidencias e teto em bytes.\n` +
+        'As tools ork_grafo_vizinhos, ork_grafo_chamadores, ork_grafo_importadores e ork_grafo_caminho permitem aprofundar. ' +
+        'Sem indice do HEAD, rode ork grafo indexar. O grafo e parcial e descreve o HEAD; ' +
+        'aresta com arvore: modificada vem de fonte que mudou depois dele: confira o arquivo antes de usar.\n',
+    memoria: {
+        titulo: (regime) => `## Memoria injetada (regime ${regime})`,
+        explicacao: 'Recuperacao deterministica por tag. Todo item declara de onde veio: nada entra neste prompt sem proveniencia. ' +
+            'O que NAO esta aqui esta nos ponteiros do handoff, recuperavel por `ork recall`.',
+        decisaoFechada: (id, por) => `Decisao ${id} (fechada por ${por})`,
+        decisaoSemantica: (id) => `Decisao ${id} (memoria semantica)`,
+        decisaoSemId: 'Decisao fechada (memoria semantica)',
+        licaoDaThread: (thread) => `Licao da thread ${thread}`,
+        licoesDoProduto: 'Licoes das threads fechadas deste produto (POSTMORTEM e MASTER)',
+        regraMandatoria: (titulo) => `Regra mandatoria: ${titulo}`,
+        grupos: { decision: 'Decisoes fechadas desta thread (entram em TODA fase)', learning: 'Licoes de threads anteriores deste produto',
+            rule: 'Regras mandatorias do ecossistema', handoff: 'Handoffs anteriores', roadmap: 'Roadmap' },
+        mandatory: ' [MANDATORY]',
+        origem: (location) => `origem: ${location}`,
+    },
+    secoesObrigatorias: ['## Ciclo canonico', '## Modo de conducao', '## Contexto da thread', '## Pedido do builder', '## Regras de evidencia'],
+    regraCentral: 'REGRA CENTRAL: o modo afrouxa a pausa, NUNCA a verificacao.',
+    cli: {
+        variavelSemValor: (id, v) => `template ${id}: variavel sem valor na renderizacao: ${v}`,
+        frontmatterAusente: (o) => `template em ${o}: frontmatter ausente (esperado bloco --- ... ---)`,
+        idAusente: 'frontmatter sem `id`', idDiverge: (id, e) => `o id "${id}" nao bate com o nome do arquivo "${e}.md"`,
+        versaoInvalida: (v) => `versao "${v}" invalida: esperado inteiro a partir de 1`, descricaoAusente: 'frontmatter sem `descricao`',
+        faseInvalida: (f, fs) => `"${f}" nao e fase do ciclo canonico (${fs})`,
+        variaveisNaoDeclaradas: (v) => `usadas no corpo e nao declaradas: ${v}`, variaveisNaoUsadas: (v) => `declaradas e nao usadas: ${v}`,
+        secaoAusente: (s) => `secao obrigatoria ausente: ${s}`, regraCentralAusente: (r) => `o template perdeu a linha: ${r}`,
+        pedidoAusente: (v, c) => `o template nao usa {{${v}}}: despacharia uma ${c} sem a demanda do builder`,
+        segredo: (n, l) => `padrao "${n}" casou na linha ${l} do template (trecho omitido de proposito)`,
+        tamanho: (b, l) => `${b} bytes acima do limite de ${l}`,
+        hitlTextoLivre: (l, o) => `linha ${l} pede ${o}; HITL de conducao e selecao de 3 a 5 alternativas com uma Recomendacao (RM-057)`,
+        travessao: 'o template usa travessao longo (U+2014); o padrao do projeto e hifen ou virgula',
+        templateNaoExiste: (id, ids) => `template "${id}" nao existe (conhecidos: ${ids})`,
+        templatePadraoAusente: 'template `fase-padrao` ausente: o `ork` nao tem prompt de fase',
+        semParIngles: (id) => `o dono fala ingles e o template ${id} do projeto nao tem o par ${id}.en: essa fase sai em pt-BR`,
+        gravidades: { erro: 'erro', aviso: 'aviso' }, semProblema: (n) => `  nenhum problema em ${n} template(s)`,
+        resumoLint: (n, e, a) => `templates: ${n} | erros: ${e} | avisos: ${a}`,
+        tituloLista: 'Templates de prompt (o do projeto sobrescreve o embutido de mesmo id)', origem: (o) => `origem: ${o}`,
+        fases: (f) => `fases: ${f}`, todas: 'todas', comoVersionar: 'Para versionar o seu: grave em prompts/<id>.md e rode `ork prompt lint`.',
+        lintTitulo: (r) => `Lint dos templates de prompt${r ? ` (projeto ${r})` : ' (somente embutidos)'}`, somenteEmbutidos: 'somente embutidos',
+        pedidoExemplo: '<pedido do builder>', cabecalhoTemplate: (id, v, o) => `# template ${id} v${v} (origem: ${o})`,
+        cabecalhoExemplo: (m, s) => `# thread de EXEMPLO (nada foi gravado), modo ${m}, sha256 ${s}`,
+        cabecalhoThread: (t, f, s) => `# thread ${t}, fase ${f}, sha256 ${s}`,
+        pedidoGuardado: (s) => `# pedido guardado na criacao da thread (sha256 ${s})`,
+        usoRenderThread: 'uso: ork prompt render <thread-id> <FASE> --pedido "<texto>"',
+        usoRenderExemplo: '     ork prompt render --exemplo --fase GOAL --modo auto --pedido "<texto>"',
+        subcomandoDesconhecido: (s) => `subcomando desconhecido: prompt ${s}`,
+        faseForaDoCiclo: (f, fs) => `fase "${f}" fora do ciclo canonico (${fs})`,
+    },
+};
+exports.PROMPTS_EN = {
+    contratoDasFases: {
+        GOAL: 'GOAL (F1): verifiable objective, impact map, success criteria, and claims with verification commands. Does not implement.',
+        PLAN: 'PLAN (F2): sliced tasks, queryable touch_paths, D1..Dn decisions with one home, and executable verify per task. Does not implement.',
+        GO: 'GO (F3): implement slice by slice, one atomic commit per task, inside the thread worktree.',
+        CHECK: 'CHECK (F4): verify against the baseline (regressions versus pre-existing debt), then review code, tests, security, and performance; ' +
+            'the verdict names the CHECK mode of the round (Agile Check or Classic Check, from the `check` line of `ork verify`).',
+        SHIP: 'SHIP (F5): serialized merge, command-proven push, updated roadmap, and rollback plan.',
+        MASTER: 'MASTER (F6): typed POSTMORTEM, MASTER log, lessons, and a human score from 0 to 5. A delivery without a MASTER log did not happen.',
+    },
+    invariantes: [
+        'Claims, verify, and policies run identically in every mode.',
+        'A `block` policy pauses every mode, including #Auto.',
+        'A typed human escalation pauses every mode, including #Auto.',
+        'Every delivery closes with an index derived from the ledger; a later human score overrides it.',
+        'Every autonomous decision goes to the ledger with who decided, evidence, and rationale.',
+    ],
+    variante: (v) => `Cycle variant: ${v}`,
+    pausaSobre: (s) => locale_thread_1.PAUSA_SOBRE_EN[s] ?? s,
+    pausa: (s) => `At the end of this block, PAUSE for a human verdict about: ${s}. Stop, present the evidence, and wait for the verdict.`,
+    semPausa: 'At the end of this block there is NO human pause: continue autonomously and record who decided, the evidence, and why in the ledger.',
+    raizDoProjeto: '(project root)',
+    regrasDeEvidencia: [
+        'No self-report: every claim includes the command that proves it and its real output.',
+        'Work only in the working directory shown above.',
+        'Irreversible steps (push, merge, deletion) happen only when the mode authorizes them.',
+    ],
+    regraDasEsperas: 'Waiting: never start verify, build, or a test suite with `&` inside the command; the process may be lost while the session ' +
+        'waits for a notice that never comes. Run `ork verify` in the foreground with `timeout` (it waits for the heavy-resource queue), ' +
+        'or use the host background execution that reports completion. Never wait with `pgrep -f` when its pattern appears in the command itself; ' +
+        'the loop finds itself and never ends. Wait for an output file with a deadline, or for a stored PID.',
+    fechoDoGo: (t) => [
+        '## Mandatory GO closing',
+        '',
+        `Before ending a block that includes GO, run \`ork verify ${t}\` and the build declared in the manifest, both in the foreground.`,
+        `Generate the bundle with \`ork ci prepare ${t}\` and make the final atomic commit \`ci(${t}): bundle ...\`.`,
+        `Write a short \`.orkastery/threads/${t}/pr-body.md\` in the project language, naming the CHECK mode of the round (Agile Check or Classic Check, from the \`check\` line of \`ork verify\`); ` +
+            'if the profile cannot write it through the authorized transport, return the full body in the final summary.',
+        'The ritual is identical in Claude Code and Codex. It closes GO, but it does not authorize SHIP, push, PR, or merge.',
+    ].join('\n'),
+    contextoDoGrafo: (thread) => '\n\n## Graph context (optional)\n' +
+        `Use ork_grafo_contexto {threadId: "${thread}"} or ork grafo contexto ${thread} --json for the thread package with evidence and a byte limit.\n` +
+        'The ork_grafo_vizinhos, ork_grafo_chamadores, ork_grafo_importadores, and ork_grafo_caminho tools allow deeper queries. ' +
+        'If HEAD has no index, run ork grafo indexar. The graph is partial and describes HEAD; an edge marked arvore: modificada comes from a source ' +
+        'that changed after HEAD, so inspect the file before using it.\n',
+    memoria: {
+        titulo: (regime) => `## Injected memory (${regime} regime)`,
+        explicacao: 'Deterministic retrieval by tag. Every item declares its source: nothing enters this prompt without provenance. ' +
+            'What is NOT here remains in the handoff pointers and can be retrieved with `ork recall`.',
+        decisaoFechada: (id, por) => `Decision ${id} (closed by ${por})`,
+        decisaoSemantica: (id) => `Decision ${id} (semantic memory)`,
+        decisaoSemId: 'Closed decision (semantic memory)',
+        licaoDaThread: (thread) => `Lesson from thread ${thread}`,
+        licoesDoProduto: 'Lessons from closed threads in this product (POSTMORTEM and MASTER)',
+        regraMandatoria: (titulo) => `Mandatory rule: ${titulo}`,
+        grupos: { decision: 'Closed decisions from this thread (included in EVERY phase)', learning: 'Lessons from previous product threads',
+            rule: 'Mandatory ecosystem rules', handoff: 'Previous handoffs', roadmap: 'Roadmap' },
+        mandatory: ' [MANDATORY]',
+        origem: (location) => `source: ${location}`,
+    },
+    secoesObrigatorias: ['## Canonical cycle', '## Conduction mode', '## Thread context', '## Builder request', '## Evidence rules'],
+    regraCentral: 'CENTRAL RULE: the mode relaxes the pause, NEVER verification.',
+    cli: {
+        variavelSemValor: (id, v) => `template ${id}: missing render value for variable: ${v}`,
+        frontmatterAusente: (o) => `template at ${o}: missing frontmatter (expected a --- ... --- block)`,
+        idAusente: 'frontmatter has no `id`', idDiverge: (id, e) => `id "${id}" does not match file name "${e}.md"`,
+        versaoInvalida: (v) => `invalid version "${v}": expected an integer starting at 1`, descricaoAusente: 'frontmatter has no `descricao`',
+        faseInvalida: (f, fs) => `"${f}" is not a canonical phase (${fs})`,
+        variaveisNaoDeclaradas: (v) => `used in the body but not declared: ${v}`, variaveisNaoUsadas: (v) => `declared but not used: ${v}`,
+        secaoAusente: (s) => `missing required section: ${s}`, regraCentralAusente: (r) => `template lost the line: ${r}`,
+        pedidoAusente: (v, c) => `template does not use {{${v}}}: it would dispatch a ${c} without the builder request`,
+        segredo: (n, l) => `pattern "${n}" matched template line ${l} (excerpt intentionally omitted)`,
+        tamanho: (b, l) => `${b} bytes exceeds the ${l}-byte limit`,
+        hitlTextoLivre: (l, _o) => `line ${l} asks for free-form text; conduction HITL is a selection of 3 to 5 choices with one Recommendation (RM-057)`,
+        travessao: 'template uses an em dash (U+2014); the project standard is a hyphen or comma',
+        templateNaoExiste: (id, ids) => `template "${id}" does not exist (known: ${ids})`,
+        templatePadraoAusente: 'missing `fase-padrao` template: `ork` has no phase prompt',
+        semParIngles: (id) => `the owner speaks English and the project template ${id} has no ${id}.en counterpart: that phase is rendered in pt-BR`,
+        gravidades: { erro: 'error', aviso: 'warning' }, semProblema: (n) => `  no problem in ${n} template(s)`,
+        resumoLint: (n, e, a) => `templates: ${n} | errors: ${e} | warnings: ${a}`,
+        tituloLista: 'Prompt templates (the project template overrides the built-in template with the same id)',
+        origem: (o) => `source: ${o === 'embutido' ? 'built-in' : o}`,
+        fases: (f) => `phases: ${f}`, todas: 'all', comoVersionar: 'To version yours, write prompts/<id>.md and run `ork prompt lint`.',
+        lintTitulo: (r) => `Prompt template lint${r ? ` (project ${r})` : ' (built-ins only)'}`, somenteEmbutidos: 'built-ins only',
+        pedidoExemplo: '<builder request>',
+        cabecalhoTemplate: (id, v, o) => `# template ${id} v${v} (source: ${o === 'embutido' ? 'built-in' : o})`,
+        cabecalhoExemplo: (m, s) => `# EXAMPLE thread (nothing was written), mode ${m}, sha256 ${s}`,
+        cabecalhoThread: (t, f, s) => `# thread ${t}, phase ${f}, sha256 ${s}`,
+        pedidoGuardado: (s) => `# request stored when the thread was created (sha256 ${s})`,
+        usoRenderThread: 'usage: ork prompt render <thread-id> <PHASE> --pedido "<text>"',
+        usoRenderExemplo: '       ork prompt render --exemplo --fase GOAL --modo auto --pedido "<text>"',
+        subcomandoDesconhecido: (s) => `unknown subcommand: prompt ${s}`,
+        faseForaDoCiclo: (f, fs) => `phase "${f}" is outside the canonical cycle (${fs})`,
+    },
+};

package/dist/locale-pulse.js

@@ -16,16 +16,26 @@ exports.PULSE_EN = exports.PULSE_PT_BR = void 0;
 const CLASSES_EN = {
     abandonada: 'abandoned', falha: 'failed', trabalhando: 'working', concluida: 'done', interrompida: 'stopped',
     interativa: 'interactive', desconhecida: 'unknown', fase_orfa: 'orphan phase', score_pendente: 'pending score',
+    // RM-063 (F5): o item de uma acao da varredura.
+    varredura: 'sweep',
 };
 /** As alternativas do pedido curto do impedimento do despacho (`impedimento.ts`), pelo texto que ele grava. */
 const ALTERNATIVAS_DO_IMPEDIMENTO_EN = {
     'Rodei o comando': 'I ran the command', 'Trocar o runtime do bloco': 'Switch the block runtime', 'Deixar parada': 'Leave it stopped',
+    // RM-063 (F4): a alternativa recomendada da escada de recuperacao que acabou.
+    'Conferir o runtime e despachar de novo com o mesmo pedido': 'Check the runtime and dispatch again with the same request',
 };
 exports.PULSE_PT_BR = {
     cabecalho: (contrato, quando) => `Pulse (${contrato}) ${quando}`,
     precisaDeHumano: (n) => `Precisa de humano agora: ${n}`,
     semNota: (n) => `${n} entrega(s) sem nota, aceitas por padrão com registro`,
     diagnostico: (detalhe) => `[diagnostico] ${detalhe}`,
+    // A forja sem leitura de pedidos (parado-no-condutor): o estado dela, dito uma vez por remoto e host.
+    forjaSemLogin: (cli, host, remoto) => `o ${cli} não está autenticado em ${host}, a forja de ${remoto}`,
+    /** Nem o `gh` nem o `glab` tem login no host proprio: a frase do gh de sempre, e o glab junto. */
+    forjaSemLoginNasDuas: (host, remoto) => `o gh não está autenticado em ${host}, a forja de ${remoto}, e o glab também não`,
+    forjaSemPedidos: (tipo, host, remoto) => `a forja de ${remoto} (${host}, ${tipo}) não tem a leitura de pedidos abertos no ork`,
+    forjaNaoResolvida: (remoto, motivo) => `a forja de ${remoto} não se resolveu: ${motivo}`,
     consultaIncompleta: (detalhe) => `[consulta incompleta] ${detalhe}`,
     item: (quem, classe, minutos) => `${quem} [${classe}] ${minutos} min`,
     /** A classe do item (`ItemPulse.classe`), dado do `--json`: o ingles a traduz pelo id na impressao (D4). */
@@ -67,7 +77,9 @@ exports.PULSE_PT_BR = {
     sessao: { blocked: 'sessao parada esperando acao humana (prompt, permissao ou credencial)',
         failed: 'sessao terminou em erro: alguem decide entre retomar, corrigir ou abandonar',
         working: 'sessao em execucao', done: 'sessao concluiu', stopped: 'sessao parada por decisao humana (`claude stop`)',
-        idle: 'sessao interativa ociosa, conduzida por um humano no terminal' },
+        idle: 'sessao interativa ociosa, conduzida por um humano no terminal',
+        // RM-063 (fatia 3, achado a): `busy` e `running` sao a sessao trabalhando num turno, como o observador ja os le.
+        busy: 'sessao ocupada, executando um turno', running: 'sessao em execucao' },
     sessaoSemEstado: 'runtime nao informou estado desta sessao: tratada como possivel parada',
     sessaoEstadoForaDoCatalogo: (estado) => `estado "${estado}" nao esta no catalogo do ork: tratado como possivel parada`,
     // a consulta do runtime (claude-bg.ts e hitl.ts): o detalhe do pulse quando ela falha
@@ -91,6 +103,70 @@ exports.PULSE_PT_BR = {
     // board.ts: a correcao das vagas que o escalonador devolve e o pulse mostra nas acoes automaticas
     vagaStaleCorrecao: (thread, fase) => `redespache com ork phase run ${thread} --fase ${fase}, ou feche com ork master ${thread}`,
     limiteCorrecao: 'espere uma thread liberar, ou suba concurrency.max_parallel_threads no orkastery.yaml',
+    /**
+     * RM-063 (F5): as acoes da varredura que age (`varredura-acoes.ts`) e a autorizacao duravel. O que vai ao `--json` nasce
+     * em pt-BR; a impressao remonta no locale.
+     */
+    varredura: {
+        oQue: {
+            limpar: (sessao) => `soltar a sessão ${sessao}, que não tem mais processo (fantasma) e ainda segura a condução ` +
+                'e a vaga da thread; o runtime não é tocado',
+            registrar: (merge, branch, base) => `registrar a entrega: o merge ${merge} da branch ${branch} já ` +
+                `está em ${base}, e o ledger não tem o ship_done`,
+            master: 'fechar a thread pelo MASTER por omissão: a entrega está registrada, ninguém deu nota e nada anda nela; o índice ' +
+                'do ledger vira a nota, e a sua nota, quando vier, vale',
+            // RM-063 (F7): a batida da conducao (`conducao-batida.ts`).
+            merge: (pr, branch, base) => `mesclar o PR #${pr} (${branch}) em ${base}, com os checks obrigatórios ` +
+                'verdes e o PR limpo',
+            atualizar: (pr, branch, base) => `trazer ${base} para a branch ${branch} do PR #${pr}, que ficou para trás ` +
+                'ou em conflito só no CHANGELOG',
+            despachar: (fase) => `despachar a fase ${fase} com o pedido guardado na criação da thread`,
+            retomar: (fase) => `retomar a fase ${fase} pelo retry, com o mesmo prompt gravado`,
+        },
+        bloqueios: {
+            'conduzida': 'alguém conduz a thread agora',
+            'sessao-viva': 'há sessão viva trabalhando na worktree da thread',
+            'sessoes-sem-leitura': 'sem a leitura das sessões vivas do runtime agora, não dá para provar a worktree parada',
+            'worktree-suja': 'a worktree da thread tem alteração não commitada',
+            'branch-com-commits': 'a branch tem commits depois do head do PR mesclado',
+            'trabalho-novo': 'a thread recebeu trabalho novo depois do PR, e a ação mudaria a fase dela',
+            'git-sem-resposta': 'o git não respondeu sobre a branch',
+            'pr-rascunho': 'o PR está em rascunho',
+            'checks-vermelhos': 'um check obrigatório do PR falhou',
+            'sem-checks-obrigatorios': 'a base não exige check nenhum, e merge sem check obrigatório verde fica com você',
+            'pr-bloqueado': 'o GitHub bloqueia o merge mesmo com os checks obrigatórios verdes (revisão ou regra da base)',
+            'pr-instavel': 'há check não obrigatório vermelho, e o PR não está limpo',
+            'conflito-em-codigo': 'o merge da base na branch conflita em código, e conflito em código nunca é resolvido sozinho',
+            'branch-nao-publicada': 'a branch local tem commits que o PR ainda não tem',
+            'sem-prompt-gravado': 'a thread não tem o pedido guardado na criação (ork thread new --pedido), e sem ele não há prompt',
+            'check-pendente': 'o CHECK da thread não passou (veredito PASSOU) depois do último commit de produto do PR',
+            'pendencia-do-dono': 'a thread espera você (pausada, pausa prevista, pergunta ou escalação aberta)',
+            'espera-longa': 'a batida espera há mais de 2 h (check obrigatório pendente ou o GitHub sem o estado do merge)',
+            'thread-do-arco': 'a thread é trabalho de um arco #Noctum: a entrega e o MASTER dela são do passo da entrega do arco',
+        },
+        comBloqueio: (oQue, bloqueio) => `${oQue}. A varredura não faz isso sozinha agora: ${bloqueio}`,
+        comBloqueioRecomendacao: (thread, comando) => `veja a thread antes (ork thread status ${thread}); quando o trabalho nela parar, o comando é ${comando}`,
+        comRecusa: (oQue, detalhe) => `${oQue}. A varredura tentou e não fez: ${detalhe}`,
+        daVarredura: (por, ate) => `a varredura faz isso na próxima batida, pela autorização durável de ${por} até ${ate}`,
+        doDono: (acao) => `rode o comando; para a varredura fazer isso sozinha, autorize a ação ${acao} na autorização ` +
+            'durável desta máquina (ork.autorizacao-duravel/v1)',
+        autorizacaoValida: (por, ate, pode) => `Varredura: autorização durável de ${por} até ${ate} (pode: ${pode})`,
+        autorizacaoAusente: 'Varredura: sem autorização durável; as ações dela ficam na fila do dono, com o comando pronto',
+        autorizacaoInvalida: (motivo, detalhe) => `Varredura: autorização durável sem valor (${motivo}: ${detalhe}); as ações dela ficam na fila do dono`,
+        feitas: (n) => `A varredura fez sozinha nos últimos 7 dias: ${n}`,
+        feita: (thread, acao, detalhe) => `  ${thread}: ${acao}; ${detalhe}`,
+    },
+    /** RM-063 (F6): a maquina ociosa (`maquina-ociosa.ts`): o passo de cada sugestao e as linhas do pulse. */
+    ociosa: {
+        despachar: (fase) => `despachar a fase ${fase} com o pedido guardado da thread`,
+        retomar: 'retomar a fase pelo retry, com o mesmo prompt',
+        verAThread: (fase) => `ver por que a thread parou na fase ${fase}`,
+        abrir: 'abrir a thread do item, que ainda não tem uma',
+        linha: (maquina, livres, limite, reservados) => `Máquina ociosa: ${maquina} com ${livres} de ` +
+            `${limite} vagas livres e ${reservados} item(ns) do roadmap reservado(s) para ela sem ninguém trabalhando`,
+        sugerida: (item, onde, passo, comando) => `  ${item} (${onde}): ${passo}; ${comando}`,
+        semThread: 'sem thread',
+    },
     /** A descricao de cada motivo tipado: a fonte de `DESCRICAO_DO_MOTIVO` (reserva do detalhe da parada). */
     motivos: {
         'artifact.missing': 'artefato exigido pela fase nao existe no disco',
@@ -126,6 +202,10 @@ exports.PULSE_EN = {
     precisaDeHumano: (n) => `Needs a human now: ${n}`,
     semNota: (n) => `${n} delivery(ies) without a score, accepted by default with a record`,
     diagnostico: (detalhe) => `[diagnostic] ${detalhe}`,
+    forjaSemLogin: (cli, host, remoto) => `${cli} is not logged in to ${host}, the forge of ${remoto}`,
+    forjaSemLoginNasDuas: (host, remoto) => `gh is not logged in to ${host}, the forge of ${remoto}, and neither is glab`,
+    forjaSemPedidos: (tipo, host, remoto) => `the forge of ${remoto} (${host}, ${tipo}) has no open-request reading in ork`,
+    forjaNaoResolvida: (remoto, motivo) => `the forge of ${remoto} did not resolve: ${motivo}`,
     consultaIncompleta: (detalhe) => `[incomplete query] ${detalhe}`,
     item: (quem, classe, minutos) => `${quem} [${classe}] ${minutos} min`,
     classe: (classe) => CLASSES_EN[classe] ?? classe,
@@ -160,7 +240,8 @@ exports.PULSE_EN = {
     sessao: { blocked: 'session stopped waiting for human action (prompt, permission or credential)',
         failed: 'session ended in an error: someone decides whether to resume, fix or drop it',
         working: 'session running', done: 'session finished', stopped: 'session stopped by a human decision (`claude stop`)',
-        idle: 'idle interactive session, driven by a human in the terminal' },
+        idle: 'idle interactive session, driven by a human in the terminal',
+        busy: 'session busy, running a turn', running: 'session running' },
     sessaoSemEstado: 'the runtime did not report a state for this session: treated as possibly stopped',
     sessaoEstadoForaDoCatalogo: (estado) => `state "${estado}" is not in the ork catalog: treated as possibly stopped`,
     adapterIndisponivel: 'runtime adapter unavailable on this machine (`claude` not on PATH)',
@@ -180,6 +261,63 @@ exports.PULSE_EN = {
     alternativaDoImpedimento: (texto) => ALTERNATIVAS_DO_IMPEDIMENTO_EN[texto] ?? texto,
     vagaStaleCorrecao: (thread, fase) => `re-dispatch with \`ork phase run ${thread} --fase ${fase}\`, or close it with \`ork master ${thread}\``,
     limiteCorrecao: 'wait for a thread to free its slot, or raise `concurrency.max_parallel_threads` in `orkastery.yaml`',
+    varredura: {
+        oQue: {
+            limpar: (sessao) => `release session ${sessao}, which has no process anymore (a ghost) and still holds the thread ` +
+                'conduction and slot; the runtime is not touched',
+            registrar: (merge, branch, base) => `record the delivery: merge ${merge} of branch ${branch} is already in ${base}, and the ` +
+                'ledger has no ship_done',
+            master: 'close the thread through MASTER by default: the delivery is recorded, nobody scored it and nothing runs on it; the ' +
+                'ledger index becomes the score, and your score, when it comes, wins',
+            merge: (pr, branch, base) => `merge PR #${pr} (${branch}) into ${base}, with the required checks green and the PR clean`,
+            atualizar: (pr, branch, base) => `bring ${base} into branch ${branch} of PR #${pr}, which fell behind or conflicts only in ` +
+                'the CHANGELOG',
+            despachar: (fase) => `dispatch phase ${fase} with the request stored when the thread was created`,
+            retomar: (fase) => `resume phase ${fase} through the retry, with the same recorded prompt`,
+        },
+        bloqueios: {
+            'conduzida': 'someone conducts the thread now',
+            'sessao-viva': 'a live session works in the thread worktree',
+            'sessoes-sem-leitura': 'without a reading of the runtime live sessions now, the worktree cannot be proven idle',
+            'worktree-suja': 'the thread worktree has uncommitted changes',
+            'branch-com-commits': 'the branch has commits after the head of the merged PR',
+            'trabalho-novo': 'the thread got new work after the PR, and the action would change its phase',
+            'git-sem-resposta': 'git did not answer about the branch',
+            'pr-rascunho': 'the PR is a draft',
+            'checks-vermelhos': 'a required check of the PR failed',
+            'sem-checks-obrigatorios': 'the base requires no check at all, and a merge without a green required check stays with you',
+            'pr-bloqueado': 'GitHub blocks the merge even with the required checks green (review or base rule)',
+            'pr-instavel': 'a non-required check is red, and the PR is not clean',
+            'conflito-em-codigo': 'merging the base into the branch conflicts in code, and a code conflict is never resolved on its own',
+            'branch-nao-publicada': 'the local branch has commits the PR does not have yet',
+            'sem-prompt-gravado': 'the thread has no request stored at creation (ork thread new --pedido), and without it there is no prompt',
+            'check-pendente': 'the thread CHECK did not pass (verdict PASSOU) after the last product commit of the PR',
+            'pendencia-do-dono': 'the thread waits for you (paused, planned pause, open question or escalation)',
+            'espera-longa': 'the beat has been waiting for more than 2 h (a required check pending, or GitHub without the merge state)',
+            'thread-do-arco': 'the thread is work of a #Noctum arc: its delivery and MASTER belong to the arc delivery step',
+        },
+        comBloqueio: (oQue, bloqueio) => `${oQue}. The sweep does not do this on its own now: ${bloqueio}`,
+        comBloqueioRecomendacao: (thread, comando) => `look at the thread first (ork thread status ${thread}); once the work in it stops, the command is ${comando}`,
+        comRecusa: (oQue, detalhe) => `${oQue}. The sweep tried and did not do it: ${detalhe}`,
+        daVarredura: (por, ate) => `the sweep does this at the next beat, under the durable authorization of ${por} until ${ate}`,
+        doDono: (acao) => `run the command; for the sweep to do this on its own, authorize the action ${acao} in this machine's ` +
+            'durable authorization (ork.autorizacao-duravel/v1)',
+        autorizacaoValida: (por, ate, pode) => `Sweep: durable authorization of ${por} until ${ate} (may: ${pode})`,
+        autorizacaoAusente: 'Sweep: no durable authorization; its actions stay in the owner queue, with the command ready',
+        autorizacaoInvalida: (motivo, detalhe) => `Sweep: durable authorization without effect (${motivo}: ${detalhe}); its actions stay in the owner queue`,
+        feitas: (n) => `The sweep did on its own in the last 7 days: ${n}`,
+        feita: (thread, acao, detalhe) => `  ${thread}: ${acao}; ${detalhe}`,
+    },
+    ociosa: {
+        despachar: (fase) => `dispatch phase ${fase} with the thread's stored request`,
+        retomar: 'resume the phase through the retry, with the same prompt',
+        verAThread: (fase) => `see why the thread stopped in phase ${fase}`,
+        abrir: 'open the thread of the item, which has none yet',
+        linha: (maquina, livres, limite, reservados) => `Idle machine: ${maquina} with ${livres} of ${limite} free slots and ` +
+            `${reservados} roadmap item(s) reserved for it with nobody working`,
+        sugerida: (item, onde, passo, comando) => `  ${item} (${onde}): ${passo}; ${comando}`,
+        semThread: 'no thread',
+    },
     motivos: {
         'artifact.missing': 'an artifact the phase requires does not exist on disk',
         'claims.failed': 'a verifiable claim failed when rerun on the real HEAD',

package/dist/locale-reservas.js

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * RM-061, fatia F3b: a familia `reservas` do catalogo de mensagens (`ork roadmap reservas|pegar|soltar|feat`), o painel
+ * das reservas no terminal e as recusas de `roadmap-reservas.ts`. O pt-BR e a fonte; o ingles e tipado por ele. Sem
+ * import do nucleo.
+ *
+ * O item, quem reservou, a maquina, a thread e a nota sao dado e saem iguais. O detalhe da soltura de uma reserva orfa
+ * vai ao ledger e ao `--json` em pt-BR e so a impressao o remonta. O painel em Markdown da branch de reservas e a
+ * mensagem de commit nao mudam com a lingua; o bloco `Projeto consultado:` e `Não lido:` do RM-052 sai igual nas duas.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RESERVAS_EN = exports.RESERVAS_PT_BR = void 0;
+exports.RESERVAS_PT_BR = {
+    // O painel no terminal
+    semRemoto: (projeto, remoto, branch) => `Reservas do roadmap: ${projeto ? `o projeto ${projeto}` : 'o projeto'} não tem o remoto ${remoto}; nada foi lido de ${branch}.`,
+    semCopia: (remoto, branch) => `Reservas do roadmap: o remoto ${remoto} não respondeu e esta máquina não tem cópia de ${branch}; nada foi lido.`,
+    copiaLocal: 'AVISO: sem acesso ao remoto; esta e a ultima copia lida nesta maquina.',
+    nenhuma: 'Nenhum item do roadmap reservado.',
+    numerosDeFeat: (n, ultimos) => `Números de FEAT reservados (${n}), os últimos: ${ultimos}. O próximo sai de: ork roadmap feat`,
+    cabecalho: 'ITEM     COM QUEM            MAQUINA         THREAD             DESDE',
+    orfa: (sucessora) => `  ÓRFÃ: thread fechada${sucessora ? `, passa para ${sucessora}` : ''}`,
+    orfas: (n) => `${n} reserva(s) órfã(s) desta máquina. Para soltar: ork roadmap reservas --soltar-orfas`,
+    // ork roadmap reservas --soltar-orfas
+    nenhumaOrfa: 'Nenhuma reserva órfã desta máquina.',
+    soltura: (item, detalhe, thread) => `${item}: ${detalhe} (thread fechada ${thread})`,
+    mudouDeDono: (item) => `${item} mudou de dono entre a leitura e a gravacao; ficou como estava`,
+    passouPara: (item, sucessora) => `${item} passou para a thread ${sucessora}, aberta no mesmo item`,
+    devolvido: (item) => `${item} devolvido`,
+    semLeituraPendente: (branch, remoto) => `sem leitura de ${branch} em ${remoto}; a reserva fica para depois`,
+    soQuemPegou: (descricao) => `${descricao}; so quem pegou solta, ou --forcar --motivo`,
+    // ork roadmap feat
+    feat: (feat, thread) => `${feat}: reservado para esta maquina${thread ? `, thread ${thread}` : ''}.`,
+    crieAPagina: (feat) => `  crie docs/produto/${feat}-<assunto>.md; o numero nao volta, mesmo que a feature nao saia`,
+    branch: (commit) => `  branch ork/roadmap-reservas em ${commit}`,
+    // ork roadmap pegar e soltar
+    acao: (acao) => ({ pegou: 'reservado para esta maquina', renovou: 'reserva renovada', tomou: 'reserva TOMADA de outra maquina',
+        soltou: 'devolvido', nada: 'ja estava livre' }[acao] ?? acao),
+    itemAcao: (item, acao) => `${item}: ${acao}.`,
+    com: (por, maquina, thread) => `  com ${por} em ${maquina}${thread ? `, thread ${thread}` : ''}`,
+    uso: 'uso: ork roadmap status [--json] | reservas [--soltar-orfas] | pegar <RM-NNN> [--thread T] [--nota N] | ' +
+        'soltar <RM-NNN> [--forcar --motivo M] | feat [--thread T] [--nota N]',
+    // As recusas (roadmap-reservas.ts)
+    descricao: (item, por, maquina, desde, thread) => `${item} esta com ${por} em ${maquina} desde ${desde}${thread ? ` (thread ${thread})` : ''}`,
+    semRemotoParaReservar: (branch, remoto) => `roadmap.sem-remoto: nao consegui ler ${branch} em ${remoto}; reservar exige rede`,
+    semRemotoParaSoltar: (branch, remoto) => `roadmap.sem-remoto: nao consegui ler ${branch} em ${remoto}; soltar exige rede`,
+    semRemotoParaOrfas: (branch) => `roadmap.sem-remoto: nao consegui ler ${branch}; soltar exige rede`,
+    featsAcabaram: 'roadmap.feat: os numeros de FEAT de tres digitos acabaram',
+    concorrencia: (n) => `roadmap.concorrencia: ${n} pushes recusados seguidos; tente de novo em instantes`,
+    forcarSemMotivo: 'roadmap.forcar: --forcar exige --motivo (tomar a reserva de outra maquina e decisao registrada)',
+    reservadoAoPegar: (descricao) => `roadmap.reservado: ${descricao}. Escolha outro item ou combine com quem esta nele`,
+    reservadoAoSoltar: (descricao) => `roadmap.reservado: ${descricao}; so quem pegou solta, ou --forcar --motivo`,
+};
+exports.RESERVAS_EN = {
+    semRemoto: (projeto, remoto, branch) => `Roadmap reservations: ${projeto ? `project ${projeto}` : 'the project'} has no remote ${remoto}; nothing was read from ${branch}.`,
+    semCopia: (remoto, branch) => `Roadmap reservations: remote ${remoto} did not answer and this machine has no copy of ${branch}; nothing was read.`,
+    copiaLocal: 'WARNING: no access to the remote; this is the last copy read on this machine.',
+    nenhuma: 'No roadmap item reserved.',
+    numerosDeFeat: (n, ultimos) => `FEAT numbers reserved (${n}), the latest: ${ultimos}. The next one comes from: ork roadmap feat`,
+    cabecalho: 'ITEM     WITH                MACHINE         THREAD             SINCE',
+    orfa: (sucessora) => `  ORPHAN: closed thread${sucessora ? `, goes to ${sucessora}` : ''}`,
+    orfas: (n) => `${n} orphan reservation(s) on this machine. To release them: ork roadmap reservas --soltar-orfas`,
+    nenhumaOrfa: 'No orphan reservation on this machine.',
+    soltura: (item, detalhe, thread) => `${item}: ${detalhe} (closed thread ${thread})`,
+    mudouDeDono: (item) => `${item} changed owner between the read and the write; it was left as it was`,
+    passouPara: (item, sucessora) => `${item} went to thread ${sucessora}, open on the same item`,
+    devolvido: (item) => `${item} released`,
+    semLeituraPendente: (branch, remoto) => `no read of ${branch} in ${remoto}; the reservation is left for later`,
+    soQuemPegou: (descricao) => `${descricao}; only whoever took it releases it, or \`--forcar --motivo\``,
+    feat: (feat, thread) => `${feat}: reserved for this machine${thread ? `, thread ${thread}` : ''}.`,
+    crieAPagina: (feat) => `  create \`docs/produto/${feat}-<subject>.md\`; the number does not come back, even if the feature never ships`,
+    branch: (commit) => `  branch ork/roadmap-reservas at ${commit}`,
+    acao: (acao) => ({ pegou: 'reserved for this machine', renovou: 'reservation renewed', tomou: 'reservation TAKEN from another machine',
+        soltou: 'released', nada: 'was already free' }[acao] ?? acao),
+    itemAcao: (item, acao) => `${item}: ${acao}.`,
+    com: (por, maquina, thread) => `  with ${por} on ${maquina}${thread ? `, thread ${thread}` : ''}`,
+    uso: 'usage: ork roadmap status [--json] | reservas [--soltar-orfas] | pegar <RM-NNN> [--thread T] [--nota N] | ' +
+        'soltar <RM-NNN> [--forcar --motivo M] | feat [--thread T] [--nota N]',
+    descricao: (item, por, maquina, desde, thread) => `${item} has been with ${por} on ${maquina} since ${desde}${thread ? ` (thread ${thread})` : ''}`,
+    semRemotoParaReservar: (branch, remoto) => `roadmap.sem-remoto: could not read ${branch} in ${remoto}; reserving needs the network`,
+    semRemotoParaSoltar: (branch, remoto) => `roadmap.sem-remoto: could not read ${branch} in ${remoto}; releasing needs the network`,
+    semRemotoParaOrfas: (branch) => `roadmap.sem-remoto: could not read ${branch}; releasing needs the network`,
+    featsAcabaram: 'roadmap.feat: the three-digit FEAT numbers ran out',
+    concorrencia: (n) => `roadmap.concorrencia: ${n} pushes refused in a row; try again in a moment`,
+    forcarSemMotivo: 'roadmap.forcar: `--forcar` needs `--motivo` (taking another machine\'s reservation is a recorded decision)',
+    reservadoAoPegar: (descricao) => `roadmap.reservado: ${descricao}. Pick another item or talk to whoever is on it`,
+    reservadoAoSoltar: (descricao) => `roadmap.reservado: ${descricao}; only whoever took it releases it, or \`--forcar --motivo\``,
+};